From 8173937797f93811b8ef482de8b34ec777fa9b4b Mon Sep 17 00:00:00 2001
From: Tiberiu Chibici <chibicitiberiu@gmail.com>
Date: Sun, 27 Nov 2016 13:53:18 +0200
Subject: [PATCH] Rendering player and tiles now works.

---
 .cproject                                     |   9 +-
 .directory                                    |   6 +
 assets/levels/.directory                      |   6 +
 assets/levels/Farm.level                      |   2 +-
 assets/player/default.png                     | Bin 0 -> 3415 bytes
 assets/ui/cursor.png                          | Bin 0 -> 249 bytes
 assets_original/cursor.xcf                    | Bin 0 -> 917 bytes
 build/prepareAssets.py                        |   3 +
 src/FarmlandsGame.cpp                         | 144 -----------------
 src/FarmlandsGame.h                           |  49 ------
 src/GameState.h                               |  68 ++++++++
 src/Main.cpp                                  |   5 +-
 src/controller/FarmlandsGame.cpp              | 126 +++++++++++++++
 src/controller/FarmlandsGame.h                |  49 ++++++
 src/controller/GuiController.cpp              |  39 +++++
 src/controller/GuiController.h                |  43 ++++++
 src/controller/PlayerController.cpp           |  88 +++++++++++
 src/controller/PlayerController.h             |  52 +++++++
 src/graphics/GameRenderer.cpp                 | 146 ++++++++++++++++++
 src/graphics/GameRenderer.h                   |  60 +++++++
 src/graphics/GuiRenderer.cpp                  |  72 +++++++++
 src/graphics/GuiRenderer.h                    |  48 ++++++
 src/graphics/SdlRenderer.cpp                  | 105 +++++++++++++
 src/graphics/SdlRenderer.h                    |  68 ++++++++
 src/math/GameMath.cpp                         |  10 ++
 src/math/GameMath.h                           |  25 +++
 src/model/GameConfig.h                        |  18 +++
 src/model/Level.cpp                           |  16 +-
 src/model/Level.h                             |   4 +
 src/model/Player.h                            |   5 +-
 src/resources/ResourceManager.h               |  32 ++--
 .../ResourceManager/ResourceManager.cpp       |  41 ++++-
 .../ResourceManager_Levels.cpp                |  18 ++-
 .../ResourceManager_Textures.cpp              |  11 +-
 src/resources/Resources.g.h                   |  22 ++-
 35 files changed, 1160 insertions(+), 230 deletions(-)
 create mode 100644 .directory
 create mode 100644 assets/levels/.directory
 create mode 100644 assets/player/default.png
 create mode 100644 assets/ui/cursor.png
 create mode 100644 assets_original/cursor.xcf
 delete mode 100644 src/FarmlandsGame.cpp
 delete mode 100644 src/FarmlandsGame.h
 create mode 100644 src/GameState.h
 create mode 100644 src/controller/FarmlandsGame.cpp
 create mode 100644 src/controller/FarmlandsGame.h
 create mode 100644 src/controller/GuiController.cpp
 create mode 100644 src/controller/GuiController.h
 create mode 100644 src/controller/PlayerController.cpp
 create mode 100644 src/controller/PlayerController.h
 create mode 100644 src/graphics/GameRenderer.cpp
 create mode 100644 src/graphics/GameRenderer.h
 create mode 100644 src/graphics/GuiRenderer.cpp
 create mode 100644 src/graphics/GuiRenderer.h
 create mode 100644 src/graphics/SdlRenderer.cpp
 create mode 100644 src/graphics/SdlRenderer.h
 create mode 100644 src/math/GameMath.cpp
 create mode 100644 src/math/GameMath.h
 create mode 100644 src/model/GameConfig.h

diff --git a/.cproject b/.cproject
index 0543afb..7f24998 100644
--- a/.cproject
+++ b/.cproject
@@ -7,9 +7,7 @@
 				<extensions>
 					<extension id="org.eclipse.cdt.core.GNU_ELF" point="org.eclipse.cdt.core.BinaryParser"/>
 					<extension id="org.eclipse.cdt.core.GASErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
-					<extension id="org.eclipse.cdt.core.GmakeErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
 					<extension id="org.eclipse.cdt.core.GLDErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
-					<extension id="org.eclipse.cdt.core.CWDLocator" point="org.eclipse.cdt.core.ErrorParser"/>
 					<extension id="org.eclipse.cdt.core.GCCErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
 				</extensions>
 			</storageModule>
@@ -18,7 +16,7 @@
 					<folderInfo id="cdt.managedbuild.config.gnu.exe.debug.1767279125." name="/" resourcePath="">
 						<toolChain id="cdt.managedbuild.toolchain.gnu.exe.debug.263074825" name="Linux GCC" superClass="cdt.managedbuild.toolchain.gnu.exe.debug">
 							<targetPlatform id="cdt.managedbuild.target.gnu.platform.exe.debug.361182110" name="Debug Platform" superClass="cdt.managedbuild.target.gnu.platform.exe.debug"/>
-							<builder buildPath="${workspace_loc:/Farmlands}/Debug" id="cdt.managedbuild.target.gnu.builder.exe.debug.756240966" keepEnvironmentInBuildfile="false" managedBuildOn="true" name="Gnu Make Builder" superClass="cdt.managedbuild.target.gnu.builder.exe.debug"/>
+							<builder buildPath="${workspace_loc:/Farmlands}/Debug" id="org.eclipse.cdt.build.core.internal.builder.1184678368" superClass="org.eclipse.cdt.build.core.internal.builder"/>
 							<tool id="cdt.managedbuild.tool.gnu.archiver.base.1607221000" name="GCC Archiver" superClass="cdt.managedbuild.tool.gnu.archiver.base"/>
 							<tool command="g++" commandLinePattern="${COMMAND} ${FLAGS} ${OUTPUT_FLAG} ${OUTPUT_PREFIX}${OUTPUT} ${INPUTS}" id="cdt.managedbuild.tool.gnu.cpp.compiler.exe.debug.1808198807" name="GCC C++ Compiler" superClass="cdt.managedbuild.tool.gnu.cpp.compiler.exe.debug">
 								<option id="gnu.cpp.compiler.exe.debug.option.optimization.level.593370343" name="Optimization Level" superClass="gnu.cpp.compiler.exe.debug.option.optimization.level" useByScannerDiscovery="false" value="gnu.cpp.compiler.optimization.level.none" valueType="enumerated"/>
@@ -66,6 +64,11 @@
 				</configuration>
 			</storageModule>
 			<storageModule moduleId="org.eclipse.cdt.core.externalSettings"/>
+			<storageModule moduleId="de.marw.cdt.cmake.core.settings">
+				<options/>
+				<defs/>
+				<undefs/>
+			</storageModule>
 		</cconfiguration>
 		<cconfiguration id="cdt.managedbuild.config.gnu.exe.release.1609929883">
 			<storageModule buildSystemId="org.eclipse.cdt.managedbuilder.core.configurationDataProvider" id="cdt.managedbuild.config.gnu.exe.release.1609929883" moduleId="org.eclipse.cdt.core.settings" name="Release">
diff --git a/.directory b/.directory
new file mode 100644
index 0000000..9591c9e
--- /dev/null
+++ b/.directory
@@ -0,0 +1,6 @@
+[Dolphin]
+Timestamp=2016,11,11,20,21,5
+Version=3
+
+[Settings]
+HiddenFilesShown=true
diff --git a/assets/levels/.directory b/assets/levels/.directory
new file mode 100644
index 0000000..605c359
--- /dev/null
+++ b/assets/levels/.directory
@@ -0,0 +1,6 @@
+[Dolphin]
+Timestamp=2016,11,26,16,53,1
+Version=3
+
+[Settings]
+HiddenFilesShown=true
diff --git a/assets/levels/Farm.level b/assets/levels/Farm.level
index 4b5b3a3..2c16e27 100644
--- a/assets/levels/Farm.level
+++ b/assets/levels/Farm.level
@@ -2,7 +2,7 @@
 	"cellWidth": 16,
 	"cellHeight": 16,
 	
-	"layerCount" : 10,
+	"layerCount" : 1,
 	"width" : 380,
 	"height" : 213,
 	
diff --git a/assets/player/default.png b/assets/player/default.png
new file mode 100644
index 0000000000000000000000000000000000000000..04fa9e40c50f1749fa8a71fa6d83979678e82f3b
GIT binary patch
literal 3415
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

literal 0
HcmV?d00001

diff --git a/assets/ui/cursor.png b/assets/ui/cursor.png
new file mode 100644
index 0000000000000000000000000000000000000000..60e8b22a0e0499c7eeab42208afca76ef65fd524
GIT binary patch
literal 249
zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`Y)RhkE<hRxemd{22U45`9+AZi
z4BWyX%*Zfnjs#GUy~NYkmHh#?l&}$}gvK!wppayVYeb22er|4RUI~M9QEFmIYKlU6
zW=V#EyQgnJcq5-UP*I|%i(`nz>7|zfxfm2VSOU^t{0pD=*Rw-a+qA>uW9X!rGuIee
zgl}c=Og)kx;I<=Ai{pQz&Y@U?W&^K1N;azT0{8rOC@Om~oG>p8Zb_Zj7|G)v<oo5(
jsc^SD){)}ZPYc`q;n3kaIQb?Y&@u*3S3j3^P6<r_>JUl;

literal 0
HcmV?d00001

diff --git a/assets_original/cursor.xcf b/assets_original/cursor.xcf
new file mode 100644
index 0000000000000000000000000000000000000000..98496f14270894fbfc14b3b32c1d8339a68e0544
GIT binary patch
literal 917
zcmd5)OHRW;4E3a+q@O_fZ&=K-T?DmPfJKD_5?4smNjg$KRT4yd1D2eG6QUYBouD9!
z*kb98pY7+FaVC*Y)^ZbsGSsmGvXKGv6M_)5oDrPcHvk6NIiXGH5H1a8-396A<lTt2
z^@1!(R9aFDTs*zYm0zl*e9`4f&hH<exH77wI`JdrMY&#bj?@CiMY)ZYEV5WHC;f34
z1zDWsa$Gqtj~2e1-b^byKxU>iq1MHL*19f#C)~Oz)_$PVNY3iBD7ih9G&%1%)uq&F
zuu=v0XJJ^V^6P@!{WG=Cd~fCNU`)K%jC}n*{6)JD{#NB&w0I%w68K?|;26%zp5f%+
zy21MmK4|b^gS!oWOq}<v%_hR<vDH6CYajAzRnJMJzBOsBjj5ZQ^~$k?9fAu2U9fNn
zEgV1_`_RE2bkPAD?J5@d0f;mXsYRt0ctrl{A8hdF01kGchn)&Ml!ZG$izX8&Xkwmv
HNZf``#{;xs

literal 0
HcmV?d00001

diff --git a/build/prepareAssets.py b/build/prepareAssets.py
index fdfa159..cd0dc09 100755
--- a/build/prepareAssets.py
+++ b/build/prepareAssets.py
@@ -113,6 +113,9 @@ if __name__ == '__main__':
                 RdirPrefix += "_"
             
             for f in files:
+                if (f[0] == '.'):
+                    continue
+                
                 # Append to R
                 fResName = RdirPrefix + capitalize(os.path.splitext(f)[0])
                 r += "            {0} = {1},\n".format(fResName, assetId)
diff --git a/src/FarmlandsGame.cpp b/src/FarmlandsGame.cpp
deleted file mode 100644
index 19b6671..0000000
--- a/src/FarmlandsGame.cpp
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * FarmlandsGame.cpp
- *
- *  Created on: Nov 7, 2016
- *      Author: tibi
- */
-
-#include "FarmlandsGame.h"
-#include <resources/Resources.h>
-
-#include <SDL2/SDL.h>
-#include <SDL2/SDL_image.h>
-#include <SDL2/SDL_ttf.h>
-#include <unistd.h>
-#include <iostream>
-
-namespace farmlands
-{
-
-FarmlandsGame::FarmlandsGame() :
-	m_running(true),
-	m_sdlWindow(nullptr),
-	m_sdlRenderer(nullptr)
-{
-}
-
-bool FarmlandsGame::initialize()
-{
-	if (SDL_Init(SDL_INIT_VIDEO) != 0) {
-		std::cerr << "Failed to initialize SDL!\n";
-		return false;
-	}
-
-	int imgFlags = IMG_INIT_PNG;
-	if (IMG_Init(IMG_INIT_PNG) != imgFlags) {
-		std::cerr << "Failed to initialize SDL_image!\n";
-		return false;
-	}
-
-	if (TTF_Init() != 0) {
-		std::cerr << "Failed to initialize SDL_ttf!\n";
-		return false;
-	}
-
-	m_sdlWindow = SDL_CreateWindow("Farmlands", 0, 0, 1024, 768, SDL_WINDOW_SHOWN);
-	if (!m_sdlWindow) {
-		std::cerr << "Failed to create main window!\n";
-		return false;
-	}
-
-	m_sdlRenderer = SDL_CreateRenderer(m_sdlWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
-	if (!m_sdlRenderer) {
-		std::cerr << "Failed to create renderer!\n";
-		return false;
-	}
-
-	// Load resources
-	m_resourceManager.initialize(m_sdlRenderer);
-	m_resourceManager.loadLevel(resources::R::Levels::Farm);
-
-	return true;
-}
-
-void FarmlandsGame::onLogicUpdate()
-{
-
-}
-
-void FarmlandsGame::onRender()
-{
-	SDL_RenderClear(m_sdlRenderer);
-
-	SDL_Rect dest = { 0, 0, 0, 0};
-	SDL_QueryTexture(m_resourceManager.texture(resources::R::Tilesets::Ground), NULL, NULL, &dest.w, &dest.h);
-	dest.w *= 4;
-	dest.h *= 4;
-
-	SDL_RenderCopy(m_sdlRenderer, m_resourceManager.texture(resources::R::Tilesets::Ground), nullptr, &dest);
-	// Render loading screen
-
-	SDL_Delay(10);
-
-	SDL_RenderPresent(m_sdlRenderer);
-}
-
-void FarmlandsGame::onEvent(SDL_Event& event)
-{
-	switch(event.type)
-	{
-	case SDL_QUIT:
-		stop();
-		break;
-
-	case SDL_KEYDOWN:
-		if (event.key.keysym.scancode == SDL_Scancode::SDL_SCANCODE_ESCAPE)
-			stop();
-		break;
-	case SDL_WINDOWEVENT_RESIZED:
-		break;
-	}
-}
-
-void FarmlandsGame::stop()
-{
-	m_running = false;
-}
-
-void FarmlandsGame::dispose()
-{
-	if (m_sdlRenderer)
-		SDL_DestroyRenderer(m_sdlRenderer);
-
-	if (m_sdlWindow)
-		SDL_DestroyWindow(m_sdlWindow);
-
-	SDL_Quit();
-}
-
-int FarmlandsGame::run()
-{
-	// Initialize game
-	if (!initialize())
-	{
-		dispose();
-		return 1;
-	}
-
-	// Main loop
-	while(m_running)
-	{
-		SDL_Event event;
-		while (SDL_PollEvent(&event))
-			onEvent(event);
-
-		onLogicUpdate();
-		onRender();
-	}
-
-	// Cleanup
-	dispose();
-	return 0;
-}
-
-}
diff --git a/src/FarmlandsGame.h b/src/FarmlandsGame.h
deleted file mode 100644
index fe8f774..0000000
--- a/src/FarmlandsGame.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * FarmlandsGame.h
- *
- *  Created on: Nov 7, 2016
- *      Author: tibi
- */
-
-#ifndef FARMLANDSGAME_H_
-#define FARMLANDSGAME_H_
-
-#include "resources/ResourceManager.h"
-
-#include <SDL2/SDL.h>
-
-namespace farmlands
-{
-	enum GameState
-	{
-		Splash,
-		MainMenu,
-		Playing
-	};
-
-	class FarmlandsGame {
-
-	public:
-		int run();
-		FarmlandsGame();
-
-	protected:
-		bool initialize();
-
-		void onLogicUpdate();
-		void onRender();
-		void onEvent(SDL_Event& event);
-
-		void stop();
-		void dispose();
-
-	private:
-		bool m_running;
-		SDL_Window* m_sdlWindow;
-		SDL_Renderer* m_sdlRenderer;
-		//enum GameState m_state;
-
-		resources::ResourceManager m_resourceManager;
-	};
-}
-#endif /* FARMLANDSGAME_H_ */
diff --git a/src/GameState.h b/src/GameState.h
new file mode 100644
index 0000000..af1e1a1
--- /dev/null
+++ b/src/GameState.h
@@ -0,0 +1,68 @@
+/*
+ * GameState.h
+ *
+ *  Created on: Nov 13, 2016
+ *      Author: tibi
+ */
+
+#ifndef MODEL_GAMESTATE_H_
+#define MODEL_GAMESTATE_H_
+
+#include <model/Level.h>
+#include <model/Player.h>
+#include <model/GameConfig.h>
+#include <graphics/SdlRenderer.h>
+#include <graphics/GameRenderer.h>
+#include <graphics/GuiRenderer.h>
+#include <resources/ResourceManager.h>
+
+#include <memory>
+
+namespace farmlands {
+
+	struct ViewportState
+	{
+		bool initialized;
+		int width, height;
+	};
+
+	struct Camera
+	{
+		float posX, posY;
+		float scale;
+	};
+
+	struct GuiState
+	{
+
+	};
+
+	struct GameState
+	{
+		// Resource layer
+		resources::ResourceManager resManager;
+
+		// Graphics layer
+		graphics::SdlRenderer sdlRenderer;
+		graphics::GuiRenderer guiRenderer;
+		graphics::GameRenderer gameRenderer;
+
+		// Gui
+		GuiState gui;
+
+		// Settings
+		model::GameConfig gameConfig;
+
+		// Current game
+		ViewportState viewport;
+		Camera camera;
+		model::Player player;
+		model::Level* currentLevel;
+
+		float elapsedTime;
+
+	};
+
+}
+
+#endif /* MODEL_GAMESTATE_H_ */
diff --git a/src/Main.cpp b/src/Main.cpp
index 17aefe8..71a0f0d 100644
--- a/src/Main.cpp
+++ b/src/Main.cpp
@@ -1,7 +1,8 @@
-#include "FarmlandsGame.h"
+#include <controller/FarmlandsGame.h>
+
 using namespace farmlands;
 
 int main()
 {
-	return FarmlandsGame().run();
+	return controller::FarmlandsGame().run();
 }
diff --git a/src/controller/FarmlandsGame.cpp b/src/controller/FarmlandsGame.cpp
new file mode 100644
index 0000000..6c9f4b1
--- /dev/null
+++ b/src/controller/FarmlandsGame.cpp
@@ -0,0 +1,126 @@
+/*
+ * FarmlandsGame.cpp
+ *
+ *  Created on: Nov 7, 2016
+ *      Author: tibi
+ */
+
+#include "FarmlandsGame.h"
+#include <resources/Resources.h>
+
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_image.h>
+#include <SDL2/SDL_ttf.h>
+#include <unistd.h>
+#include <iostream>
+
+namespace farmlands {
+namespace controller {
+
+FarmlandsGame::FarmlandsGame() :
+	m_running(true),
+	m_gameState(),
+	m_time(0),
+	m_guiController(),
+	m_playerController()
+{
+}
+
+bool FarmlandsGame::initialize()
+{
+	// Initialize game state
+	m_gameState.viewport.initialized = false;
+	m_gameState.camera.scale = 4;
+
+	// Initialize render system
+	if (!m_gameState.sdlRenderer.initialize(&m_gameState))
+		return false;
+
+	m_gameState.gameRenderer.initialize(&m_gameState);
+	m_gameState.guiRenderer.initialize(&m_gameState);
+
+	// Initialize controllers
+	m_guiController.initialize(&m_gameState);
+	m_playerController.initialize(&m_gameState);
+
+	// Initialize & load resources
+	m_gameState.resManager.initialize(&m_gameState);
+	m_gameState.resManager.loadGameAssets();
+	m_gameState.resManager.loadLevel(resources::R::Levels::Farm);
+	m_gameState.currentLevel = m_gameState.resManager.level(resources::R::Levels::Farm);
+
+	return true;
+}
+
+void FarmlandsGame::onUpdateLogic()
+{
+	m_playerController.updateLogic();
+}
+
+void FarmlandsGame::onRender()
+{
+	m_gameState.sdlRenderer.renderBegin();
+	m_gameState.gameRenderer.render();
+	m_gameState.guiRenderer.render();
+	m_gameState.sdlRenderer.renderEnd();
+}
+
+void FarmlandsGame::onEvent(SDL_Event& event)
+{
+	// Let controllers handle event
+	if (m_guiController.processEvent(event))
+		return;
+
+	if (m_playerController.processEvent(event))
+		return;
+
+	// Nobody? Handle global events
+	switch(event.type)
+	{
+	case SDL_QUIT:
+		stop();
+		break;
+
+	case SDL_KEYDOWN:
+		if (event.key.keysym.scancode == SDL_Scancode::SDL_SCANCODE_ESCAPE)
+			stop();
+		break;
+
+	case SDL_WINDOWEVENT_RESIZED:
+		break;
+	}
+}
+
+void FarmlandsGame::stop()
+{
+	m_running = false;
+}
+
+int FarmlandsGame::run()
+{
+	// Initialize game
+	if (!initialize())
+		return 1;
+
+	// Main loop
+	while(m_running)
+	{
+		// Update elapsed time
+		Uint32 now = SDL_GetTicks();
+		m_gameState.elapsedTime = (now - m_time) * 0.001f;
+		m_time = now;
+
+		SDL_Event event;
+		while (SDL_PollEvent(&event))
+			onEvent(event);
+
+		onUpdateLogic();
+		onRender();
+	}
+
+	// Cleanup
+	return 0;
+}
+
+}
+}
diff --git a/src/controller/FarmlandsGame.h b/src/controller/FarmlandsGame.h
new file mode 100644
index 0000000..33b665f
--- /dev/null
+++ b/src/controller/FarmlandsGame.h
@@ -0,0 +1,49 @@
+/*
+ * FarmlandsGame.h
+ *
+ *  Created on: Nov 7, 2016
+ *      Author: tibi
+ */
+
+#ifndef FARMLANDSGAME_H_
+#define FARMLANDSGAME_H_
+
+#include <GameState.h>
+#include <controller/GuiController.h>
+#include <controller/PlayerController.h>
+#include <graphics/GameRenderer.h>
+#include <graphics/SdlRenderer.h>
+#include <resources/ResourceManager.h>
+
+#include <SDL2/SDL.h>
+
+namespace farmlands {
+namespace controller {
+
+	class FarmlandsGame {
+
+	public:
+		int run();
+		FarmlandsGame();
+
+	protected:
+		bool initialize();
+
+		void onUpdateLogic();
+		void onRender();
+		void onEvent(SDL_Event& event);
+
+		void stop();
+
+	private:
+		bool m_running;
+		GameState m_gameState;
+		Uint32 m_time;
+
+		GuiController m_guiController;
+		PlayerController m_playerController;
+	};
+
+}
+}
+#endif /* FARMLANDSGAME_H_ */
diff --git a/src/controller/GuiController.cpp b/src/controller/GuiController.cpp
new file mode 100644
index 0000000..bf77358
--- /dev/null
+++ b/src/controller/GuiController.cpp
@@ -0,0 +1,39 @@
+/*
+ * GuiController.cpp
+ *
+ *  Created on: Nov 26, 2016
+ *      Author: tibi
+ */
+
+#include <controller/GuiController.h>
+
+#include <cassert>
+
+namespace farmlands
+{
+namespace controller
+{
+
+GuiController::GuiController()
+	: m_gameState(nullptr)
+{
+}
+
+GuiController::~GuiController()
+{
+}
+
+void GuiController::initialize(GameState* gameState)
+{
+	assert(gameState != nullptr);
+
+	m_gameState = gameState;
+}
+
+bool GuiController::processEvent(SDL_Event& event)
+{
+	return false;
+}
+
+} /* namespace controller */
+} /* namespace farmlands */
diff --git a/src/controller/GuiController.h b/src/controller/GuiController.h
new file mode 100644
index 0000000..db87f17
--- /dev/null
+++ b/src/controller/GuiController.h
@@ -0,0 +1,43 @@
+/*
+ * GuiController.h
+ *
+ *  Created on: Nov 26, 2016
+ *      Author: tibi
+ */
+
+#ifndef CONTROLLER_GUICONTROLLER_H_
+#define CONTROLLER_GUICONTROLLER_H_
+
+#include <SDL2/SDL.h>
+
+namespace farmlands {
+
+// Forward declarations
+struct GameState;
+
+namespace controller {
+
+	class GuiController
+	{
+	public:
+		GuiController();
+		virtual ~GuiController();
+
+		/**
+		 * Initializes game renderer
+		 */
+		void initialize(GameState* gameState);
+
+		/**
+		 * Processes an UI event
+		 */
+		bool processEvent(SDL_Event& event);
+
+	private:
+		GameState* m_gameState;
+	};
+
+} /* namespace controller */
+} /* namespace farmlands */
+
+#endif /* CONTROLLER_GUICONTROLLER_H_ */
diff --git a/src/controller/PlayerController.cpp b/src/controller/PlayerController.cpp
new file mode 100644
index 0000000..b83a12c
--- /dev/null
+++ b/src/controller/PlayerController.cpp
@@ -0,0 +1,88 @@
+/*
+ * PlayerController.cpp
+ *
+ *  Created on: Nov 27, 2016
+ *      Author: tibi
+ */
+
+#include <GameState.h>
+#include <controller/PlayerController.h>
+
+#include <cassert>
+
+namespace farmlands
+{
+namespace controller
+{
+
+PlayerController::PlayerController()
+	: m_gameState(nullptr)
+{
+}
+
+PlayerController::~PlayerController()
+{
+}
+
+void PlayerController::initialize(GameState* gameState)
+{
+	assert(gameState != nullptr);
+	m_gameState = gameState;
+}
+
+bool PlayerController::processEvent(SDL_Event& event)
+{
+	return false;
+}
+
+void PlayerController::updateLogic()
+{
+	// Get keyboard status
+	const Uint8* keys = SDL_GetKeyboardState(NULL);
+	const SDL_Keymod mods = SDL_GetModState();
+
+	float deltaX = 0;
+	float deltaY = 0;
+
+	// Compute movement delta multiplier
+	float deltaMultiplier = 5.0f * m_gameState->elapsedTime; // Equivalent to units per second
+	if ((mods & KMOD_LSHIFT) || (mods & KMOD_RSHIFT))
+		deltaMultiplier *= 5;
+
+	// Handle scale changes (debugging only)
+	if (keys[SDL_SCANCODE_KP_MINUS])
+		m_gameState->camera.scale *= 1.0f - 0.05f * deltaMultiplier;
+	if (keys[SDL_SCANCODE_KP_PLUS])
+		m_gameState->camera.scale *= 1.0f + 0.05f * deltaMultiplier;
+
+	// Handle movement
+	if (keys[SDL_SCANCODE_UP])
+		deltaY -= 1;
+	if (keys[SDL_SCANCODE_DOWN])
+		deltaY += 1;
+	if (keys[SDL_SCANCODE_LEFT])
+		deltaX -= 1;
+	if (keys[SDL_SCANCODE_RIGHT])
+		deltaX += 1;
+
+	float newX = m_gameState->player.posX + deltaX * deltaMultiplier;
+	float newY = m_gameState->player.posY + deltaY * deltaMultiplier;
+
+	if (canMove(newX, newY))
+	{
+		m_gameState->player.posX = newX;
+		m_gameState->player.posY = newY;
+
+		m_gameState->camera.posX = m_gameState->player.posX;
+		m_gameState->camera.posY = m_gameState->player.posY - 1;
+	}
+}
+
+bool PlayerController::canMove(float x, float y)
+{
+	// TODO: check collisions & stuff. For now, nothing
+	return true;
+}
+
+} /* namespace controller */
+} /* namespace farmlands */
diff --git a/src/controller/PlayerController.h b/src/controller/PlayerController.h
new file mode 100644
index 0000000..d81712d
--- /dev/null
+++ b/src/controller/PlayerController.h
@@ -0,0 +1,52 @@
+/*
+ * PlayerController.h
+ *
+ *  Created on: Nov 27, 2016
+ *      Author: tibi
+ */
+
+#ifndef CONTROLLER_PLAYERCONTROLLER_H_
+#define CONTROLLER_PLAYERCONTROLLER_H_
+
+#include <SDL2/SDL.h>
+
+namespace farmlands {
+
+// Forward declarations
+struct GameState;
+
+namespace controller {
+
+	class PlayerController
+	{
+	public:
+		PlayerController();
+		virtual ~PlayerController();
+
+		/**
+		 * Initializes game renderer
+		 */
+		void initialize(GameState* gameState);
+
+		/**
+		 * Processes an event.
+		 *
+		 * @returns true if the event was handled, or false otherwise.
+		 */
+		bool processEvent(SDL_Event& event);
+
+		/**
+		 * Called at the update logic step for every frame
+		 */
+		void updateLogic();
+
+	private:
+		bool canMove(float x, float y);
+
+		GameState* m_gameState;
+	};
+
+} /* namespace controller */
+} /* namespace farmlands */
+
+#endif /* CONTROLLER_PLAYERCONTROLLER_H_ */
diff --git a/src/graphics/GameRenderer.cpp b/src/graphics/GameRenderer.cpp
new file mode 100644
index 0000000..e769c3f
--- /dev/null
+++ b/src/graphics/GameRenderer.cpp
@@ -0,0 +1,146 @@
+/*
+ * GameRenderer.cpp
+ *
+ *  Created on: Nov 13, 2016
+ *      Author: tibi
+ */
+#include <GameState.h>
+#include <graphics/GameRenderer.h>
+#include <math/GameMath.h>
+#include <resources/Resources.h>
+
+namespace farmlands {
+namespace graphics {
+
+GameRenderer::GameRenderer()
+	: m_gameState(nullptr)
+{
+}
+
+GameRenderer::~GameRenderer()
+{
+}
+
+void GameRenderer::initialize(GameState* gameState)
+{
+	m_gameState = gameState;
+}
+
+void GameRenderer::render()
+{
+	prepareRender();
+	renderTileLayers();
+	renderPlayer();
+}
+
+void GameRenderer::prepareRender()
+{
+	m_cellW = m_gameState->currentLevel->m_cellWidth * m_gameState->camera.scale;
+	m_cellH = m_gameState->currentLevel->m_cellHeight * m_gameState->camera.scale;
+}
+
+void GameRenderer::renderTileLayers()
+{
+	// Compute how many cells fit on the screen
+	float cellsOnScreenX = m_gameState->viewport.width / m_cellW;
+	float cellsOnScreenY = m_gameState->viewport.height / m_cellH;
+
+	int minCellX = floorf(m_gameState->camera.posX - cellsOnScreenX / 2);
+	int minCellY = floorf(m_gameState->camera.posY - cellsOnScreenY / 2);
+	int maxCellX = ceilf(m_gameState->camera.posX + cellsOnScreenX / 2);
+	int maxCellY = ceilf(m_gameState->camera.posY + cellsOnScreenY / 2);
+
+	// Clamp cell positions
+	minCellX = clamp(minCellX, 0, (int)m_gameState->currentLevel->columnCount() - 1);
+	minCellY = clamp(minCellY, 0, (int)m_gameState->currentLevel->rowCount() - 1);
+	maxCellX = clamp(maxCellX, 0, (int)m_gameState->currentLevel->columnCount() - 1);
+	maxCellY = clamp(maxCellY, 0, (int)m_gameState->currentLevel->rowCount() - 1);
+
+	// Draw each layer
+	for (size_t i = 0; i < m_gameState->currentLevel->layerCount(); i++)
+	{
+		int textureId = m_gameState->currentLevel->texture(i);
+
+		// Render only visible tiles
+		for (int y = minCellY; y <= maxCellY; y++)
+			for (int x = minCellX; x <= maxCellX; x++)
+			{
+				int cellId = m_gameState->currentLevel->cell(i, y, x);
+
+				// Obtain texture
+				int texWidth, texHeight;
+				SDL_Texture* texture = m_gameState->resManager.texture(textureId);
+				SDL_QueryTexture(texture, NULL, NULL, &texWidth, &texHeight);
+
+				// Compute texture coordinates
+				int cellCol = (cellId * m_gameState->currentLevel->m_cellWidth) % texWidth;
+				int cellRow = ((cellId * m_gameState->currentLevel->m_cellWidth) / texWidth) * m_gameState->currentLevel->m_cellHeight;
+
+				// Calculate source position
+				SDL_Rect src =
+				{
+					cellCol,
+					cellRow,
+					(int) m_gameState->currentLevel->m_cellWidth,
+					(int) m_gameState->currentLevel->m_cellHeight
+				};
+
+				// Calculate destination position
+				SDL_Rect dest =
+				{
+					(int) xToScreen(x),
+					(int) yToScreen(y),
+					(int) ceilf(m_cellW),
+					(int) ceilf(m_cellH)
+				};
+
+				// Blit
+				SDL_RenderCopy(m_gameState->sdlRenderer.internalRenderer(), texture, &src, &dest);
+			}
+	}
+}
+
+void GameRenderer::renderPlayer()
+{
+	float posX = xToScreen(m_gameState->player.posX);
+	float posY = yToScreen(m_gameState->player.posY);
+
+	// Obtain texture
+	int texWidth, texHeight;
+	SDL_Texture* playerTexture = m_gameState->resManager.texture(resources::R::Player::Default);
+	SDL_QueryTexture(playerTexture, NULL, NULL, &texWidth, &texHeight);
+
+	// Draw using bottom center of texture as anchor point
+	SDL_Rect dest =
+	{
+		(int) (posX - texWidth * m_gameState->camera.scale / 2),
+		(int) (posY - texHeight * m_gameState->camera.scale),
+		(int) (texWidth * m_gameState->camera.scale),
+		(int) (texHeight * m_gameState->camera.scale),
+	};
+
+	SDL_RenderCopy(m_gameState->sdlRenderer.internalRenderer(), playerTexture, NULL, &dest);
+}
+
+float GameRenderer::xToWorld(float x)
+{
+	return (x - m_gameState->viewport.width / 2) / m_cellW + m_gameState->camera.posX;
+}
+
+float GameRenderer::yToWorld(float y)
+{
+	return (y - m_gameState->viewport.height / 2) / m_cellH + m_gameState->camera.posY;
+}
+
+float GameRenderer::xToScreen(float x)
+{
+	return (x - m_gameState->camera.posX) * m_cellW + m_gameState->viewport.width / 2;
+}
+
+float GameRenderer::yToScreen(float y)
+{
+	return (y - m_gameState->camera.posY) * m_cellH + m_gameState->viewport.height / 2;
+}
+
+} /* namespace graphics */
+} /* namespace farmlands */
diff --git a/src/graphics/GameRenderer.h b/src/graphics/GameRenderer.h
new file mode 100644
index 0000000..8af3623
--- /dev/null
+++ b/src/graphics/GameRenderer.h
@@ -0,0 +1,60 @@
+/*
+ * GameRenderer.h
+ *
+ *  Created on: Nov 13, 2016
+ *      Author: tibi
+ */
+
+#ifndef GRAPHICS_GAMERENDERER_H_
+#define GRAPHICS_GAMERENDERER_H_
+
+#include <graphics/SdlRenderer.h>
+#include <resources/ResourceManager.h>
+
+#include <memory>
+
+#include <SDL2/SDL.h>
+
+namespace farmlands {
+
+// Forward declarations
+struct GameState;
+
+namespace graphics {
+
+	class GameRenderer
+	{
+	public:
+		GameRenderer();
+		virtual ~GameRenderer();
+
+		/**
+		 * Initializes game renderer
+		 */
+		void initialize(GameState* gameState);
+
+		/**
+		 * Renders everything
+		 */
+		void render();
+
+	private:
+		void prepareRender();
+		void renderTileLayers();
+		void renderPlayer();
+
+		float xToWorld(float x);
+		float yToWorld(float y);
+		float xToScreen(float x);
+		float yToScreen(float y);
+
+		GameState* m_gameState;
+
+		// Size of a cell (scaled)
+		float m_cellW, m_cellH;
+	};
+
+} /* namespace graphics */
+} /* namespace farmlands */
+
+#endif /* GRAPHICS_GAMERENDERER_H_ */
diff --git a/src/graphics/GuiRenderer.cpp b/src/graphics/GuiRenderer.cpp
new file mode 100644
index 0000000..0aeaa75
--- /dev/null
+++ b/src/graphics/GuiRenderer.cpp
@@ -0,0 +1,72 @@
+/*
+ * GuiRenderer.cpp
+ *
+ *  Created on: Nov 13, 2016
+ *      Author: tibi
+ */
+
+#include <GameState.h>
+#include <graphics/GuiRenderer.h>
+#include <resources/Resources.h>
+
+#include <sstream>
+
+#include <SDL2/SDL.h>
+
+namespace farmlands
+{
+namespace graphics
+{
+
+GuiRenderer::GuiRenderer()
+	: m_gameState(nullptr),
+	  m_fps(0),
+	  m_fpsIndex(0)
+{
+}
+
+GuiRenderer::~GuiRenderer()
+{
+}
+
+void GuiRenderer::initialize(GameState* gameState)
+{
+	m_gameState = gameState;
+}
+
+void GuiRenderer::render()
+{
+	computeFps();
+
+	// Prepare stuff
+	TTF_Font* font = m_gameState->resManager.font(resources::R::Fonts::DejaVuSans, 10);
+	SDL_Color white = { 255, 255, 255, 255 };
+	SDL_Rect dest = { 10, 10, 0, 0 };
+
+	// Figure out what text to print
+	std::stringstream textStream;
+	textStream << "FPS: " << m_fps;
+
+	// Render text
+	SDL_Texture* fpsText = m_gameState->sdlRenderer.renderText(textStream.str(), font, white);
+	SDL_QueryTexture(fpsText, NULL, NULL, &dest.w, &dest.h);
+	SDL_RenderCopy(m_gameState->sdlRenderer.internalRenderer(), fpsText, NULL, &dest);
+}
+
+void GuiRenderer::computeFps()
+{
+	// Compute FPS
+	m_fpsVals[m_fpsIndex++] = 1.0f / m_gameState->elapsedTime;
+	if (m_fpsIndex >= GUIRENDERER_FPS_VALS)
+	{
+		m_fpsIndex = 0;
+
+		m_fps = 0;
+		for (int i = 0; i < GUIRENDERER_FPS_VALS; i++)
+			m_fps += m_fpsVals[i];
+		m_fps /= GUIRENDERER_FPS_VALS;
+	}
+}
+
+} /* namespace graphics */
+} /* namespace farmlands */
diff --git a/src/graphics/GuiRenderer.h b/src/graphics/GuiRenderer.h
new file mode 100644
index 0000000..b27558b
--- /dev/null
+++ b/src/graphics/GuiRenderer.h
@@ -0,0 +1,48 @@
+/*
+ * GuiRenderer.h
+ *
+ *  Created on: Nov 13, 2016
+ *      Author: tibi
+ */
+
+#ifndef GRAPHICS_GUIRENDERER_H_
+#define GRAPHICS_GUIRENDERER_H_
+
+#define GUIRENDERER_FPS_VALS 30
+
+namespace farmlands {
+
+// Forward declarations
+struct GameState;
+
+namespace graphics {
+
+	class GuiRenderer
+	{
+	public:
+		GuiRenderer();
+		virtual ~GuiRenderer();
+
+		/**
+		 * Initializes game renderer
+		 */
+		void initialize(GameState* gameState);
+
+		/**
+		 * Renders the GUI
+		 */
+		void render();
+
+	private:
+		void computeFps();
+
+		GameState* m_gameState;
+		float m_fpsVals[GUIRENDERER_FPS_VALS];
+		float m_fps;
+		int m_fpsIndex;
+	};
+
+} /* namespace graphics */
+} /* namespace farmlands */
+
+#endif /* GRAPHICS_GUIRENDERER_H_ */
diff --git a/src/graphics/SdlRenderer.cpp b/src/graphics/SdlRenderer.cpp
new file mode 100644
index 0000000..4c93888
--- /dev/null
+++ b/src/graphics/SdlRenderer.cpp
@@ -0,0 +1,105 @@
+/*
+ * SdlRenderer.cpp
+ *
+ *  Created on: Nov 13, 2016
+ *      Author: tibi
+ */
+
+#include <GameState.h>
+#include <graphics/SdlRenderer.h>
+
+#include <iostream>
+#include <cassert>
+
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_image.h>
+#include <SDL2/SDL_ttf.h>
+
+namespace farmlands
+{
+namespace graphics
+{
+
+SdlRenderer::SdlRenderer()
+	: m_sdlWindow(nullptr),
+	  m_sdlRenderer(nullptr),
+	  m_gameState(nullptr)
+{
+}
+
+SdlRenderer::~SdlRenderer()
+{
+	if (m_sdlRenderer)
+		SDL_DestroyRenderer(m_sdlRenderer);
+
+	if (m_sdlWindow)
+		SDL_DestroyWindow(m_sdlWindow);
+
+	SDL_Quit();
+}
+
+bool SdlRenderer::initialize(GameState* gameState)
+{
+	m_gameState = gameState;
+
+	if (SDL_Init(SDL_INIT_VIDEO) != 0) {
+		std::cerr << "Failed to initialize SDL!\n";
+		return false;
+	}
+
+	int imgFlags = IMG_INIT_PNG;
+	if (IMG_Init(IMG_INIT_PNG) != imgFlags) {
+		std::cerr << "Failed to initialize SDL_image!\n";
+		return false;
+	}
+
+	if (TTF_Init() != 0) {
+		std::cerr << "Failed to initialize SDL_ttf!\n";
+		return false;
+	}
+
+	m_gameState->viewport.width = 1024;
+	m_gameState->viewport.height = 768;
+	m_sdlWindow = SDL_CreateWindow("Farmlands", 0, 0, m_gameState->viewport.width, m_gameState->viewport.height, SDL_WINDOW_SHOWN);
+	if (!m_sdlWindow) {
+		std::cerr << "Failed to create main window!\n";
+		return false;
+	}
+
+	m_sdlRenderer = SDL_CreateRenderer(m_sdlWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
+	if (!m_sdlRenderer) {
+		std::cerr << "Failed to create renderer!\n";
+		return false;
+	}
+
+	return true;
+}
+
+void SdlRenderer::renderBegin()
+{
+	SDL_RenderClear(m_sdlRenderer);
+}
+
+void SdlRenderer::renderEnd()
+{
+	SDL_RenderPresent(m_sdlRenderer);
+}
+
+SDL_Texture* SdlRenderer::renderText(const std::string& text, TTF_Font* font, SDL_Color color)
+{
+	assert(font != nullptr);
+
+	SDL_Surface* surface = TTF_RenderText_Blended(font, text.c_str(), color);
+	if (surface == nullptr)
+		return nullptr;
+
+	SDL_Texture* texture = SDL_CreateTextureFromSurface(m_sdlRenderer, surface);
+
+	SDL_FreeSurface(surface);
+	return texture;
+}
+
+} /* namespace graphics */
+} /* namespace farmlands */
+
+
diff --git a/src/graphics/SdlRenderer.h b/src/graphics/SdlRenderer.h
new file mode 100644
index 0000000..b73e27a
--- /dev/null
+++ b/src/graphics/SdlRenderer.h
@@ -0,0 +1,68 @@
+/*
+ * SdlRenderer.h
+ *
+ *  Created on: Nov 13, 2016
+ *      Author: tibi
+ */
+
+#ifndef GRAPHICS_SDLRENDERER_H_
+#define GRAPHICS_SDLRENDERER_H_
+
+#include <string>
+
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_ttf.h>
+
+namespace farmlands {
+
+// Forward declarations
+struct GameState;
+
+namespace graphics {
+
+	class SdlRenderer
+	{
+	public:
+		SdlRenderer();
+		virtual ~SdlRenderer();
+
+		/**
+		 * Initializes the game renderer.
+		 *
+		 * @returns true if successful, false otherwise.
+		 */
+		bool initialize(GameState* gameState);
+
+		/**
+		 * Performs steps for beginning to render.
+		 */
+		void renderBegin();
+
+		/**
+		 * Performs steps for ending a render.
+		 */
+		void renderEnd();
+
+		/**
+		 * Renders given text to a texture
+		 */
+		SDL_Texture* renderText(const std::string& text, TTF_Font* font, SDL_Color color);
+
+		// Getters
+		/**
+		 * Gets the internal SDL renderer object;
+		 */
+		SDL_Renderer* internalRenderer() { return m_sdlRenderer; }
+
+	private:
+
+		SDL_Window* m_sdlWindow;
+		SDL_Renderer* m_sdlRenderer;
+
+		GameState* m_gameState;
+	};
+
+} /* namespace graphics */
+} /* namespace farmlands */
+
+#endif /* GRAPHICS_SDLRENDERER_H_ */
diff --git a/src/math/GameMath.cpp b/src/math/GameMath.cpp
new file mode 100644
index 0000000..730c49c
--- /dev/null
+++ b/src/math/GameMath.cpp
@@ -0,0 +1,10 @@
+/*
+ * Math.cpp
+ *
+ *  Created on: Nov 26, 2016
+ *      Author: tibi
+ */
+
+#include <math/GameMath.h>
+
+
diff --git a/src/math/GameMath.h b/src/math/GameMath.h
new file mode 100644
index 0000000..53f67a0
--- /dev/null
+++ b/src/math/GameMath.h
@@ -0,0 +1,25 @@
+/*
+ * Math.h
+ *
+ *  Created on: Nov 26, 2016
+ *      Author: tibi
+ */
+
+#ifndef MATH_GAMEMATH_H_
+#define MATH_GAMEMATH_H_
+
+template<typename TVal, typename TMin, typename TMax>
+TVal clamp (TVal value, TMin min, TMax max)
+{
+	if (value < min)
+		return min;
+
+	if (value > max)
+		return max;
+
+	return value;
+}
+
+
+
+#endif /* MATH_GAMEMATH_H_ */
diff --git a/src/model/GameConfig.h b/src/model/GameConfig.h
new file mode 100644
index 0000000..10fcea3
--- /dev/null
+++ b/src/model/GameConfig.h
@@ -0,0 +1,18 @@
+/*
+ * Settings.h
+ *
+ *  Created on: Nov 13, 2016
+ *      Author: tibi
+ */
+namespace farmlands {
+namespace model {
+
+	struct GameConfig
+	{
+		float graphics_Scale;
+		float graphics_UiScale;
+	};
+
+}
+}
+
diff --git a/src/model/Level.cpp b/src/model/Level.cpp
index b6ec10f..03d54cf 100644
--- a/src/model/Level.cpp
+++ b/src/model/Level.cpp
@@ -12,7 +12,10 @@ namespace farmlands {
 namespace model {
 
 Level::Level(size_t layerCount, size_t rowCount, size_t columnCount)
-	: m_cells(new Cell[layerCount * rowCount * columnCount]),
+	: m_cellWidth(0),
+	  m_cellHeight(0),
+      m_cells(new Cell[layerCount * rowCount * columnCount]),
+	  m_textures(new int[layerCount]),
 	  m_layers(layerCount),
 	  m_rows(rowCount),
 	  m_columns(columnCount)
@@ -22,6 +25,7 @@ Level::Level(size_t layerCount, size_t rowCount, size_t columnCount)
 Level::~Level()
 {
 	delete[] m_cells;
+	delete[] m_textures;
 }
 
 
@@ -43,6 +47,16 @@ void Level::setCell(size_t layer, size_t row, size_t col, Cell value)
 	m_cells[layer * m_rows * m_columns + row * m_columns + col] = value;
 }
 
+int Level::texture(size_t layer) const
+{
+	return m_textures[layer];
+}
+
+void Level::setTexture(size_t layer, int textureId) const
+{
+	m_textures[layer] = textureId;
+}
 
 } /* namespace model */
 } /* namespace farmlands */
+
diff --git a/src/model/Level.h b/src/model/Level.h
index 872afd4..14b7fdb 100644
--- a/src/model/Level.h
+++ b/src/model/Level.h
@@ -32,10 +32,14 @@ namespace model {
 		Cell cell(size_t layer, size_t row, size_t col) const;
 		void setCell(size_t layer, size_t row, size_t col, Cell value);
 
+		int texture(size_t layer) const;
+		void setTexture(size_t layer, int textureId) const;
+
 		size_t m_cellWidth, m_cellHeight;
 
 	private:
 		Cell* m_cells;
+		int* m_textures;
 		size_t m_layers;
 		size_t m_rows;
 		size_t m_columns;
diff --git a/src/model/Player.h b/src/model/Player.h
index 9584fe5..74d534c 100644
--- a/src/model/Player.h
+++ b/src/model/Player.h
@@ -1,7 +1,7 @@
 /*
  * Player.h
  *
- *  Created on: Nov 12, 2016
+ *  Created on: Nov 26, 2016
  *      Author: tibi
  */
 
@@ -11,9 +11,12 @@
 namespace farmlands {
 namespace model {
 
+#define PLAYER_INVENTORY_SIZE 3*12
+
 	struct Player
 	{
 		float posX, posY;
+		int inventory[PLAYER_INVENTORY_SIZE];
 	};
 
 }
diff --git a/src/resources/ResourceManager.h b/src/resources/ResourceManager.h
index 240b354..5fac075 100644
--- a/src/resources/ResourceManager.h
+++ b/src/resources/ResourceManager.h
@@ -20,15 +20,26 @@
 #include <SDL2/SDL_ttf.h>
 
 namespace farmlands {
+
+// Forward declaration
+struct GameState;
+
 namespace resources {
 
-	union LoadedResource
+	struct LoadedResource
 	{
-		struct
+		bool loaded;
+
+		union
 		{
-			SDL_Surface* m_surface;
-			SDL_Texture* m_texture;
-		} texture;
+			struct
+			{
+				SDL_Surface* surface;
+				SDL_Texture* texture;
+			} texture;
+
+			model::Level* level;
+		};
 	};
 
 	class ResourceManager
@@ -36,14 +47,16 @@ namespace resources {
 	public:
 		ResourceManager();
 		virtual ~ResourceManager();
-		void initialize(SDL_Renderer* renderer);
+		void initialize(GameState* gameState);
 
 		// Loading routines
 		void loadMainMenu();
+		void loadGameAssets();
 		void loadLevel(int levelId);
 
 		TTF_Font* font(int id, int pointSize);
 		SDL_Texture* texture(int id);
+		model::Level* level(int id);
 
 	private:
 		/**
@@ -60,7 +73,7 @@ namespace resources {
 		/**
 		 * Loads the cell data for a level tile layer.
 		 */
-		void loadLevelLayer(std::shared_ptr<model::Level> level, size_t layerNumber, int resourceId);
+		void loadLevelLayer(model::Level* level, size_t layerNumber, int resourceId);
 
 		/**
 		 * Loads a texture into memory.
@@ -68,11 +81,10 @@ namespace resources {
 		void loadTexture(int textureId);
 		void loadFont(int fontId, int pointSize);
 
-		// SDL Renderer
-		SDL_Renderer* m_renderer;
+		// State
+		GameState* m_gameState;
 
 		// Loaded resources
-		std::shared_ptr<model::Level> m_loadedLevel;
 		LoadedResource* m_loadedResources;
 
 		typedef int FontId;
diff --git a/src/resources/ResourceManager/ResourceManager.cpp b/src/resources/ResourceManager/ResourceManager.cpp
index f6c9ace..6215fa5 100644
--- a/src/resources/ResourceManager/ResourceManager.cpp
+++ b/src/resources/ResourceManager/ResourceManager.cpp
@@ -18,26 +18,55 @@ namespace farmlands {
 namespace resources {
 
 ResourceManager::ResourceManager()
-	: m_renderer(nullptr),
-	  m_loadedLevel(nullptr),
+	: m_gameState(nullptr),
 	  m_loadedResources(new LoadedResource[sizeof(RInfo) / sizeof(RInfo[0])])
 {
+	for(size_t i = 0; i < sizeof(RInfo) / sizeof(RInfo[0]); i++)
+		m_loadedResources[i].loaded = false;
 }
 
 ResourceManager::~ResourceManager()
 {
+	// Unload resources
+	for(size_t i = 0; i < sizeof(RInfo) / sizeof(RInfo[0]); i++)
+	{
+		if (m_loadedResources[i].loaded)
+		{
+			switch(RInfo[i].type)
+			{
+			case ResourceType::Level:
+				delete m_loadedResources[i].level;
+				break;
+
+			case ResourceType::Texture:
+				SDL_DestroyTexture(m_loadedResources[i].texture.texture);
+				SDL_FreeSurface(m_loadedResources[i].texture.surface);
+				break;
+
+			default:
+				assert(false);
+				break;
+			}
+		}
+	}
+
 	delete[] m_loadedResources;
 }
 
-void ResourceManager::initialize(SDL_Renderer* renderer)
+void ResourceManager::initialize(GameState* gameState)
 {
-	m_renderer = renderer;
+	m_gameState = gameState;
 }
 
 void ResourceManager::loadMainMenu()
 {
 }
 
+void ResourceManager::loadGameAssets()
+{
+	loadTexture(R::Player::Default);
+}
+
 TTF_Font* ResourceManager::font(int id, int pointSize)
 {
 	// Open from cache
@@ -46,7 +75,7 @@ TTF_Font* ResourceManager::font(int id, int pointSize)
 		return it->second;
 
 	// Open font
-	TTF_Font* font = TTF_OpenFont(RInfo[id].path, pointSize);
+	TTF_Font* font = TTF_OpenFont(getPath(id).c_str(), pointSize);
 	m_fontCache.emplace(FONTID(id, pointSize), font);
 
 	return font;
@@ -76,3 +105,5 @@ int ResourceManager::getId(std::string resPathStr)
 
 } /* namespace storage */
 } /* namespace farmlands */
+
+
diff --git a/src/resources/ResourceManager/ResourceManager_Levels.cpp b/src/resources/ResourceManager/ResourceManager_Levels.cpp
index ad0b305..1b8d112 100644
--- a/src/resources/ResourceManager/ResourceManager_Levels.cpp
+++ b/src/resources/ResourceManager/ResourceManager_Levels.cpp
@@ -18,7 +18,7 @@ using namespace nlohmann;
 namespace farmlands {
 namespace resources {
 
-void ResourceManager::loadLevelLayer(std::shared_ptr<model::Level> level, size_t layer, int resourceId)
+void ResourceManager::loadLevelLayer(model::Level* level, size_t layer, int resourceId)
 {
 	assert(RInfo[resourceId].type == ResourceType::LevelLayer);
 
@@ -71,7 +71,7 @@ void ResourceManager::loadLevel(int levelId)
 	size_t colCount = levelJs.value("width", 0u);
 
 	assert(layerCount > 0 && rowCount > 0 && colCount > 0);
-	std::shared_ptr<model::Level> level(new model::Level(layerCount, rowCount, colCount));
+	model::Level* level = new model::Level(layerCount, rowCount, colCount);
 
 	level->m_cellWidth = levelJs.value("cellWidth", 0u);
 	level->m_cellHeight = levelJs.value("cellHeight", 0u);
@@ -86,10 +86,20 @@ void ResourceManager::loadLevel(int levelId)
 		loadLevelLayer(level, layer, getId(cellsFileName));
 
 		std::string textureFileName = it->value("textureFile", std::string());
-		loadTexture(getId(textureFileName));
+		int textureId = getId(textureFileName);
+		level->setTexture(layer, textureId);
+		loadTexture(textureId);
 	}
 
-	m_loadedLevel = level;
+	m_loadedResources[levelId].loaded = true;
+	m_loadedResources[levelId].level = level;
+}
+
+model::Level* ResourceManager::level(int id)
+{
+	assert(RInfo[id].type == ResourceType::Level);
+
+	return m_loadedResources[id].level;
 }
 
 }
diff --git a/src/resources/ResourceManager/ResourceManager_Textures.cpp b/src/resources/ResourceManager/ResourceManager_Textures.cpp
index 259fdef..985ba62 100644
--- a/src/resources/ResourceManager/ResourceManager_Textures.cpp
+++ b/src/resources/ResourceManager/ResourceManager_Textures.cpp
@@ -4,7 +4,7 @@
  *  Created on: Nov 12, 2016
  *      Author: tibi
  */
-
+#include <GameState.h>
 #include <resources/ResourceManager.h>
 #include <resources/Resources.h>
 
@@ -22,18 +22,19 @@ void ResourceManager::loadTexture(int resourceId)
 	if (surface == NULL)
 		throw 0; // TODO: error handling
 
-	SDL_Texture* texture = SDL_CreateTextureFromSurface(m_renderer, surface);
+	SDL_Texture* texture = SDL_CreateTextureFromSurface(m_gameState->sdlRenderer.internalRenderer(), surface);
 	if (texture == NULL)
 		throw 0; // TODO: error handling
 
-	m_loadedResources[resourceId].texture.m_surface = surface;
-	m_loadedResources[resourceId].texture.m_texture = texture;
+	m_loadedResources[resourceId].loaded = true;
+	m_loadedResources[resourceId].texture.surface = surface;
+	m_loadedResources[resourceId].texture.texture = texture;
 }
 
 SDL_Texture* ResourceManager::texture(int id)
 {
 	assert(RInfo[id].type == ResourceType::Texture);
-	return m_loadedResources[id].texture.m_texture;
+	return m_loadedResources[id].texture.texture;
 }
 
 }
diff --git a/src/resources/Resources.g.h b/src/resources/Resources.g.h
index cb69271..dd2ea3b 100644
--- a/src/resources/Resources.g.h
+++ b/src/resources/Resources.g.h
@@ -16,27 +16,39 @@ namespace resources {
         {
             DejaVuSans = 0,
         };
+        enum Player
+        {
+            Default = 1,
+        };
         enum Tilesets
         {
-            Ground = 1,
+            Ground = 2,
+        };
+        enum Ui
+        {
+            Cursor = 3,
         };
         enum Levels
         {
-            Farm_Background = 2,
-            Farm = 3,
+            Farm_Background = 4,
+            Farm = 5,
         };
     }
 
     const int RInfo_Fonts_Begin = 0;
-    const int RInfo_Tilesets_Begin = 1;
-    const int RInfo_Levels_Begin = 2;
+    const int RInfo_Player_Begin = 1;
+    const int RInfo_Tilesets_Begin = 2;
+    const int RInfo_Ui_Begin = 3;
+    const int RInfo_Levels_Begin = 4;
 
     /**
      * This array contains the names of all the files, and the corresponding file type.
      */
     const ResourceInfo RInfo[] = {
         { "fonts/DejaVuSans.ttf", ResourceType::Font },
+        { "player/default.png", ResourceType::Texture },
         { "tilesets/Ground.png", ResourceType::Texture },
+        { "ui/cursor.png", ResourceType::Texture },
         { "levels/Farm_Background.csv", ResourceType::LevelLayer },
         { "levels/Farm.level", ResourceType::Level },
     };