Added some structuring.

The game runs but only a black window is shown.

CMakeLists.txt

@@ -8,8 +8,13 @@ set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -std=c++11 -Wall -Wextra
 include(FindPkgConfig)
 PKG_SEARCH_MODULE(SDL2 REQUIRED sdl2)
 
+find_package(PNG REQUIRED)
+
+add_definitions(${PNG_DEFINITIONS})
+
 include_directories(SYSTEM
 	${SDL2_INCLUDE_DIR}
+	${PNG_INCLUDE_DIRS}
 )
 include_directories(
 	src
@@ -30,14 +35,19 @@ add_executable(${PROJECT_NAME}
 	src/texture.cpp
 	src/sdlerror.cpp
 	src/sdlmain.cpp
-	src/game.cpp
 	src/gamebase.cpp
 	src/character.cpp
 	src/placeable.cpp
 	src/physicsfswrapper.cpp
+	src/gameplayscene.cpp
+	src/mover.cpp
+	src/moveroneshot.cpp
+	src/moversine.cpp
+	src/gameplaysceneclassic.cpp
 )
 
 target_link_libraries(${PROJECT_NAME}
 	${SDL2_LIBRARIES}
 	physfs
+	${PNG_LIBRARIES}
 )

src/game.cpp

@@ -1,47 +0,0 @@
-#include "game.hpp"
-#include "character.hpp"
-
-namespace cloonel {
-	namespace {
-		const char g_characterTexture[] = "/resources/graphics/duck.bmp";
-	} //unnamed namespace
-
-	///------------------------------------------------------------------------
-	///------------------------------------------------------------------------
-	Game::Game (SDLMain* parSdlMain) :
-		GameBase(parSdlMain),
-		m_character(new Character(g_characterTexture, parSdlMain))
-	{
-	}
-
-	///------------------------------------------------------------------------
-	///------------------------------------------------------------------------
-	Game::~Game() noexcept {
-	}
-
-	///------------------------------------------------------------------------
-	///------------------------------------------------------------------------
-	void Game::Prepare() {
-		m_character->Prepare();
-	}
-
-	///------------------------------------------------------------------------
-	///------------------------------------------------------------------------
-	void Game::Destroy() noexcept {
-		m_character->Destroy();
-	}
-
-	///------------------------------------------------------------------------
-	///------------------------------------------------------------------------
-	void Game::OnRender() {
-		const int2 newPos(m_character->GetPos() + 0.5f);
-		//m_character->Render(newPos);
-	}
-
-	///------------------------------------------------------------------------
-	///------------------------------------------------------------------------
-	void Game::OnUpdate (float parDelta) {
-		//const float2 increase(parDelta * 15.0f, parDelta * 22.8f);
-		//m_pos += increase;
-	}
-} //namespace cloonel

src/game.hpp

@@ -1,27 +0,0 @@
-#ifndef id0E85DAFBFF5D497E8B3699AED806840A
-#define id0E85DAFBFF5D497E8B3699AED806840A
-
-#include "gamebase.hpp"
-#include "vector.hpp"
-#include <memory>
-
-namespace cloonel {
-	class Character;
-
-	class Game : public GameBase {
-	public:
-		explicit Game ( SDLMain* parSdlMain );
-		virtual ~Game ( void ) noexcept;
-
-		virtual void Prepare ( void );
-		virtual void Destroy ( void ) noexcept;
-
-	private:
-		virtual void OnRender ( void );
-		virtual void OnUpdate ( float parDelta );
-
-		const std::unique_ptr<Character> m_character;
-	};
-} //namespace cloonel
-
-#endif

src/gameplayscene.cpp

@@ -0,0 +1,24 @@
+#include "gameplayscene.hpp"
+#include "mover.hpp"
+
+namespace cloonel {
+	///--------------------------------------------------------------------------
+	///--------------------------------------------------------------------------
+	GameplayScene::GameplayScene (SDLMain* parSdlMain) :
+		GameBase(parSdlMain)
+	{
+	}
+
+	///--------------------------------------------------------------------------
+	///--------------------------------------------------------------------------
+	void GameplayScene::OnUpdate (float parDelta) {
+		for (auto itMover : m_movers) {
+			itMover->ApplyMotion(parDelta);
+		}
+	}
+
+	///--------------------------------------------------------------------------
+	///--------------------------------------------------------------------------
+	void GameplayScene::OnRender() {
+	}
+} //namespace cloonel

src/gameplayscene.hpp

@@ -0,0 +1,25 @@
+#ifndef id1DF84BC48C0547D69F79499E3A25BFC5
+#define id1DF84BC48C0547D69F79499E3A25BFC5
+
+#include <vector>
+#include "gamebase.hpp"
+
+namespace cloonel {
+	class Mover;
+
+	class GameplayScene : public GameBase {
+	public:
+		explicit GameplayScene ( SDLMain* parSdlMain );
+		virtual ~GameplayScene ( void ) noexcept = default;
+
+		void AddMover ( Mover* parMover ) { m_movers.push_back(parMover); }
+
+	private:
+		virtual void OnRender ( void );
+		virtual void OnUpdate ( float parDelta );
+
+		std::vector<Mover*> m_movers;
+	};
+} //namespace cloonel
+
+#endif

src/gameplaysceneclassic.cpp

@@ -0,0 +1,26 @@
+#include "gameplaysceneclassic.hpp"
+
+namespace cloonel {
+	///--------------------------------------------------------------------------
+	///--------------------------------------------------------------------------
+	GameplaySceneClassic::GameplaySceneClassic (SDLMain* parSdlMain) :
+		GameplayScene(parSdlMain)
+	{
+	}
+
+	///--------------------------------------------------------------------------
+	///--------------------------------------------------------------------------
+	GameplaySceneClassic::~GameplaySceneClassic() noexcept {
+		Destroy();
+	}
+
+	///--------------------------------------------------------------------------
+	///--------------------------------------------------------------------------
+	void GameplaySceneClassic::Prepare() {
+	}
+
+	///--------------------------------------------------------------------------
+	///--------------------------------------------------------------------------
+	void GameplaySceneClassic::Destroy() noexcept {
+	}
+} //namespace cloonel

src/gameplaysceneclassic.hpp

@@ -0,0 +1,21 @@
+#ifndef idF6FF1F57C36842DC9B20E2F55C507C2E
+#define idF6FF1F57C36842DC9B20E2F55C507C2E
+
+#include "gameplayscene.hpp"
+
+namespace cloonel {
+	class SDLMain;
+
+	class GameplaySceneClassic : public GameplayScene {
+	public:
+		explicit GameplaySceneClassic ( SDLMain* parSdlMain );
+		~GameplaySceneClassic ( void ) noexcept;
+
+		virtual void Prepare ( void );
+		virtual void Destroy ( void ) noexcept;
+
+	private:
+	};
+} //namespace cloonel
+
+#endif

src/main.cpp

@@ -1,7 +1,7 @@
 #include "CloonelJumpConfig.h"
 #include "sdlmain.hpp"
-#include "game.hpp"
 #include "physicsfswrapper.hpp"
+#include "gameplaysceneclassic.hpp"
 #include <iostream>
 #include <stdexcept>
 #include <ciso646>
@@ -9,11 +9,9 @@
 namespace {
 	///-------------------------------------------------------------------------
 	///-------------------------------------------------------------------------
-	void RunMainLoop (cloonel::Game& parGame) {
-		float totalElapsed = 0.0f;
+	void RunMainLoop (cloonel::GameplaySceneClassic& parGame) {
 		do {
-			const float delta = parGame.Exec();
-			totalElapsed += delta;
+			parGame.Exec();
 		} while (not parGame.WantsToQuit());
 	}
 } //unnamed namespace
@@ -21,7 +19,7 @@ namespace {
 ///----------------------------------------------------------------------------
 ///following http://twinklebeardev.blogspot.co.uk/2012/07/lesson-1-hello-world.html
 ///----------------------------------------------------------------------------
-int main (int, char* parArgv[]) {
+int main (int, char* []) {
 	std::cout << GameName << " v" << GameVersionMajor << "." << GameVersionMinor << std::endl;
 
 	int retVal = 0;
@@ -36,8 +34,7 @@ int main (int, char* parArgv[]) {
 
 		sdlmain.Init();
 
-		cloonel::Game game(&sdlmain);
-		game.Prepare();
+		cloonel::GameplaySceneClassic game(&sdlmain);
 		RunMainLoop(game);
 	}
 	catch (const std::runtime_error& e) {

src/mover.cpp

@@ -0,0 +1,12 @@
+#include "mover.hpp"
+#include "placeable.hpp"
+#include <cassert>
+
+namespace cloonel {
+	///--------------------------------------------------------------------------
+	///--------------------------------------------------------------------------
+	void Mover::ApplyOffsetToPlaceable (std::size_t parIndex, const float2& parOffset) {
+		assert(m_placeables[parIndex]);
+		m_placeables[parIndex]->AddOffset(parOffset);
+	}
+} //namespace cloonel

src/mover.hpp

@@ -0,0 +1,28 @@
+#ifndef id20409B43E62B4247A278B413D1114896
+#define id20409B43E62B4247A278B413D1114896
+
+#include "vector.hpp"
+#include <vector>
+
+namespace cloonel {
+	class Placeable;
+
+	class Mover {
+	public:
+		Mover ( void ) = default;
+		virtual ~Mover ( void ) noexcept = default;
+
+		virtual void ApplyMotion ( float parDelta ) = 0;
+		void AddPlaceable ( Placeable* parPlaceable ) { m_placeables.push_back(parPlaceable); }
+
+	protected:
+		virtual void Update ( float parDelta ) = 0;
+		std::size_t PlaceableCount ( void ) const { return m_placeables.size(); }
+		void ApplyOffsetToPlaceable ( std::size_t parIndex, const float2& parOffset );
+
+	private:
+		std::vector<Placeable*> m_placeables;
+	};
+} //namespace cloonel
+
+#endif

src/moveroneshot.cpp

@@ -0,0 +1,14 @@
+#include "moveroneshot.hpp"
+
+namespace cloonel {
+	///--------------------------------------------------------------------------
+	///--------------------------------------------------------------------------
+	void MoverOneShot::ApplyMotion (float parDelta) {
+		Update(parDelta);
+		const float2 offs(GetOffset());
+		const std::size_t placeableCount = PlaceableCount();
+		for (std::size_t z = 0; z < placeableCount; ++z) {
+			ApplyOffsetToPlaceable(z, offs);
+		}
+	}
+} //namespace cloonel

src/moveroneshot.hpp

@@ -0,0 +1,20 @@
+#ifndef id9CDCF10D483641A2845353C0835F93EC
+#define id9CDCF10D483641A2845353C0835F93EC
+
+#include "vector.hpp"
+#include "mover.hpp"
+
+namespace cloonel {
+	class MoverOneShot : public Mover {
+	public:
+		MoverOneShot ( void ) = default;
+		virtual ~MoverOneShot ( void ) noexcept = default;
+
+		virtual void ApplyMotion ( float parDelta );
+
+	private:
+		virtual float2 GetOffset ( void ) const = 0;
+	};
+} //namespace cloonel
+
+#endif

src/moversine.cpp

@@ -0,0 +1,25 @@
+#include "moversine.hpp"
+#include <cmath>
+
+namespace cloonel {
+	///--------------------------------------------------------------------------
+	///--------------------------------------------------------------------------
+	MoverSine::MoverSine() :
+		MoverOneShot(),
+		m_alpha(0.0f),
+		m_power(1.0f)
+	{
+	}
+
+	///--------------------------------------------------------------------------
+	///--------------------------------------------------------------------------
+	float2 MoverSine::GetOffset() const {
+		return float2(std::sin(m_alpha) * m_power);
+	}
+
+	///--------------------------------------------------------------------------
+	///--------------------------------------------------------------------------
+	void MoverSine::Update (float parDelta) {
+		m_alpha += parDelta;
+	}
+} //namespace cloonel

src/moversine.hpp

@@ -0,0 +1,23 @@
+#ifndef id16A9347A373E4144A9C2B98E7D7A1351
+#define id16A9347A373E4144A9C2B98E7D7A1351
+
+#include "moveroneshot.hpp"
+
+namespace cloonel {
+	class MoverSine : public MoverOneShot {
+	public:
+		MoverSine ( void );
+		~MoverSine ( void ) noexcept = default;
+
+	protected:
+		virtual void Update ( float parDelta );
+
+	private:
+		virtual float2 GetOffset() const;
+
+		float m_alpha;
+		float m_power;
+	};
+} //namespace cloonel
+
+#endif

src/placeable.hpp

@@ -7,6 +7,7 @@ namespace cloonel {
 	class Placeable {
 	public:
 		const float2& GetPos ( void ) const noexcept { return m_pos; }
+		void AddOffset ( const float2& parOffset ) noexcept { m_pos += parOffset; }
 
 	protected:
 		Placeable ( float parX, float parY );

src/texture.cpp

@@ -6,13 +6,59 @@
 #include <stdexcept>
 #include <cassert>
 #include <ciso646>
+#include <png.h>
 
 namespace cloonel {
 	namespace {
-		///---------------------------------------------------------------------
-		///---------------------------------------------------------------------
-		SDL_Surface* LoadNewSurface (const std::string& parPath) {
-			assert(false);
+		enum GraphicFormat {
+			GraphicFormat_Unknown,
+			GraphicFormat_Png
+		};
+		struct GraphicFormatItem {
+			const char* extension;
+			size_t length;
+			GraphicFormat enumvalue;
+		};
+
+		const GraphicFormatItem g_graphicFormatItems[] = {
+			{".png", 4, GraphicFormat_Png}
+		};
+
+		GraphicFormat GuessGraphicFormatFromName (const std::string& parPath) __attribute__((pure));
+
+		///--------------------------------------------------------------------
+		///--------------------------------------------------------------------
+		GraphicFormat GuessGraphicFormatFromName (const std::string& parPath) {
+			const size_t dotPos = parPath.find_last_of('.');
+			if (parPath.npos == dotPos) {
+				return GraphicFormat_Unknown;
+			}
+
+			const size_t extLen = parPath.size() - dotPos;
+			for (size_t z = 0; z < sizeof(g_graphicFormatItems) / sizeof(g_graphicFormatItems[0]); ++z) {
+				const GraphicFormatItem& currItem = g_graphicFormatItems[z];
+				if (currItem.length == extLen and parPath.compare(dotPos, currItem.length, currItem.extension) == 0) {
+					return currItem.enumvalue;
+				}
+			}
+			return GraphicFormat_Unknown;
+		}
+
+		///--------------------------------------------------------------------
+		///--------------------------------------------------------------------
+		SDL_Surface* LoadNewPngSurface (const std::string& parPath) {
+			PhysicsFSFile rawfile(parPath.c_str(), PhysicsFSFile::OpenMode_Read, "graphics");
+			unsigned char header[8];
+			assert(rawfile.IsOpen());
+
+			rawfile.Read(header, 8, 1);
+			if (png_sig_cmp(header, 0, 8))
+				return nullptr;
+
+      png_structp pngptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
+      if (not pngptr)
+        return nullptr;
+
 			return nullptr;
 		}
 	} //unnamed namespace
@@ -46,8 +92,18 @@ namespace cloonel {
 	///------------------------------------------------------------------------
 	///------------------------------------------------------------------------
 	void Texture::Reload() {
+		const GraphicFormat fmt = GuessGraphicFormatFromName(m_path);
 		Destroy();
-		SDL_Surface* surf = SDL_LoadBMP(m_path.c_str());
+
+		SDL_Surface* surf = nullptr;
+		switch (fmt) {
+		case GraphicFormat_Png:
+			surf = LoadNewPngSurface(m_path.c_str());
+
+		default:
+			throw std::runtime_error(std::string("Unsupported file format for \"") + m_path + "\"");
+		}
+
 		if (nullptr == surf)
 			throw std::runtime_error(GetFullErrorMessage(__PRETTY_FUNCTION__, m_path));