demo 1

demo/inc/demo_game.hpp

@@ -12,19 +12,24 @@
 
 #include <engine.hpp>
 #include <game.hpp>
+#include "state/state_manager.hpp"
 
-namespace Tyra {
+using Tyra::Engine;
+using Tyra::Game;
 
-class Demo : public Game {
+namespace Demo {
+
+class DemoGame : public Game {
  public:
-  Demo(Engine* engine);
-  ~Demo();
+  DemoGame(Engine* engine);
+  ~DemoGame();
 
   void init();
   void loop();
 
  private:
   Engine* engine;
+  StateManager<GlobalStateType> stateManager;
 };
 
-}  // namespace Tyra
+}  // namespace Demo

demo/inc/state/global_state_type.hpp

@@ -8,14 +8,10 @@
 # Sandro Sobczyński <sandro.sobczynski@gmail.com>
 */
 
-#include "demo.hpp"
+#pragma once
 
-namespace Tyra {
+namespace Demo {
 
-Demo::Demo(Engine* t_engine) { engine = t_engine; }
-Demo::~Demo() {}
+enum GlobalStateType { STATE_INTRO, STATE_GAME, STATE_EXIT };
 
-void Demo::init() { TYRA_LOG("Init!"); }
-void Demo::loop() {}
-
-}  // namespace Tyra
+}  // namespace Demo

demo/inc/state/state.hpp

@@ -0,0 +1,40 @@
+/*
+# ______       ____   ___
+#   |     \/   ____| |___|
+#   |     |   |   \  |   |
+#-----------------------------------------------------------------------
+# Copyright 2022, tyra - https://github.com/h4570/tyra
+# Licenced under Apache License 2.0
+# Sandro Sobczyński <sandro.sobczynski@gmail.com>
+*/
+
+#pragma once
+
+#include <engine.hpp>
+
+using Tyra::Engine;
+
+namespace Demo {
+
+template <typename StateTypeT>
+class State {
+ public:
+  State(Engine* t_engine) : engine(t_engine) {}
+  virtual ~State() {}
+
+  virtual const StateTypeT& getState() const = 0;
+
+  virtual const bool& wantFinish() const = 0;
+
+  virtual void onStart() = 0;
+
+  virtual void update() = 0;
+
+  /** @return Next game state */
+  virtual StateTypeT onFinish() = 0;
+
+ protected:
+  Engine* engine;
+};
+
+}  // namespace Demo

demo/inc/state/state_manager.hpp

@@ -0,0 +1,63 @@
+/*
+# ______       ____   ___
+#   |     \/   ____| |___|
+#   |     |   |   \  |   |
+#-----------------------------------------------------------------------
+# Copyright 2022, tyra - https://github.com/h4570/tyra
+# Licenced under Apache License 2.0
+# Sandro Sobczyński <sandro.sobczynski@gmail.com>
+*/
+
+#pragma once
+
+#include <vector>
+#include "./state.hpp"
+#include "./global_state_type.hpp"
+
+namespace Demo {
+
+template <typename StateTypeT>
+class StateManager {
+ public:
+  StateManager(const StateTypeT& initialState) {
+    stateInitialized = false;
+    currentState = initialState;
+  }
+
+  ~StateManager() {
+    for (auto& state : states) {
+      delete state;
+    }
+  }
+
+  const StateTypeT& getCurrentState() const { return currentState; }
+
+  void add(State<StateTypeT>* state) { states.push_back(state); }
+
+  void update() {
+    for (auto& state : states) {
+      if (state->getState() == currentState) {
+        if (state->wantFinish()) {
+          currentState = state->onFinish();
+          stateInitialized = false;
+          break;
+        }
+
+        if (!stateInitialized) {
+          state->onStart();
+          stateInitialized = true;
+        }
+
+        state->update();
+        break;
+      }
+    }
+  }
+
+ private:
+  bool stateInitialized;
+  std::vector<State<StateTypeT>*> states;
+  StateTypeT currentState;
+};
+
+}  // namespace Demo

demo/inc/states/intro/intro_state.hpp

@@ -0,0 +1,43 @@
+/*
+# ______       ____   ___
+#   |     \/   ____| |___|
+#   |     |   |   \  |   |
+#-----------------------------------------------------------------------
+# Copyright 2022, tyra - https://github.com/h4570/tyra
+# Licenced under Apache License 2.0
+# Sandro Sobczyński <sandro.sobczynski@gmail.com>
+*/
+
+#pragma once
+
+#include "state/state.hpp"
+#include "state/global_state_type.hpp"
+#include "state/state_manager.hpp"
+#include "./intro_state_type.hpp"
+
+namespace Demo {
+
+class IntroState : public State<GlobalStateType> {
+ public:
+  IntroState(Engine* t_engine);
+  ~IntroState();
+
+  const GlobalStateType& getState() const { return state; }
+
+  const bool& wantFinish() const { return _wantFinish; };
+
+  void onStart();
+
+  void update();
+
+  /** @return Next game state */
+  GlobalStateType onFinish();
+
+ private:
+  GlobalStateType state;
+  bool _wantFinish;
+
+  StateManager<IntroStateType> stateManager;
+};
+
+}  // namespace Demo

demo/inc/states/intro/intro_state_type.hpp

@@ -0,0 +1,23 @@
+/*
+# ______       ____   ___
+#   |     \/   ____| |___|
+#   |     |   |   \  |   |
+#-----------------------------------------------------------------------
+# Copyright 2022, tyra - https://github.com/h4570/tyra
+# Licenced under Apache License 2.0
+# Sandro Sobczyński <sandro.sobczynski@gmail.com>
+*/
+
+#pragma once
+
+namespace Demo {
+
+enum IntroStateType {
+  STATE_PS2DEV,
+  STATE_TYRA,
+  STATE_WAR_INFO,
+  STATE_PRESS_KEY,
+  STATE_INTRO_END
+};
+
+}  // namespace Demo

demo/inc/states/intro/states/intro_ps2dev_state.hpp

@@ -0,0 +1,55 @@
+/*
+# ______       ____   ___
+#   |     \/   ____| |___|
+#   |     |   |   \  |   |
+#-----------------------------------------------------------------------
+# Copyright 2022, tyra - https://github.com/h4570/tyra
+# Licenced under Apache License 2.0
+# Sandro Sobczyński <sandro.sobczynski@gmail.com>
+*/
+
+#pragma once
+
+#include "state/state.hpp"
+#include "../intro_state_type.hpp"
+#include "renderer/core/2d/sprite/sprite.hpp"
+#include "time/timer.hpp"
+
+using Tyra::Sprite;
+using Tyra::Texture;
+using Tyra::Timer;
+
+namespace Demo {
+
+class IntroPs2DevState : public State<IntroStateType> {
+ public:
+  IntroPs2DevState(Engine* t_engine);
+  ~IntroPs2DevState();
+
+  const IntroStateType& getState() const { return state; }
+
+  const bool& wantFinish() const { return _wantFinish; };
+
+  void onStart();
+
+  void update();
+
+  /** @return Next game state */
+  IntroStateType onFinish();
+
+ private:
+  IntroStateType state;
+  bool _wantFinish;
+
+  Texture* texture;
+  Timer initialDelayTimer;
+  bool initialized;
+  bool initialDelayElapsed;
+  bool fadeinActivated;
+  bool fadeoutActivated;
+  u8 frameSkipper;
+
+  Sprite* sprite;
+};
+
+}  // namespace Demo

demo/inc/states/intro/states/intro_tyra_state.hpp

@@ -0,0 +1,64 @@
+/*
+# ______       ____   ___
+#   |     \/   ____| |___|
+#   |     |   |   \  |   |
+#-----------------------------------------------------------------------
+# Copyright 2022, tyra - https://github.com/h4570/tyra
+# Licenced under Apache License 2.0
+# Sandro Sobczyński <sandro.sobczynski@gmail.com>
+*/
+
+#pragma once
+
+#include "state/state.hpp"
+#include "../intro_state_type.hpp"
+#include "renderer/core/2d/sprite/sprite.hpp"
+#include "time/timer.hpp"
+
+using Tyra::Sprite;
+using Tyra::Texture;
+using Tyra::Timer;
+
+namespace Demo {
+
+class IntroTyraState : public State<IntroStateType> {
+ public:
+  IntroTyraState(Engine* t_engine);
+  ~IntroTyraState();
+
+  const IntroStateType& getState() const { return state; }
+
+  const bool& wantFinish() const { return _wantFinish; };
+
+  void onStart();
+
+  void update();
+
+  /** @return Next game state */
+  IntroStateType onFinish();
+
+ private:
+  IntroStateType state;
+  bool _wantFinish;
+
+  Texture* tyraTexture;
+  Texture* bgTexture;
+  Texture* bg2Texture;
+  Texture* fillerTexture;
+
+  Timer initialDelayTimer;
+  bool initialized;
+  bool initialDelayElapsed;
+  bool animActivated;
+  bool fadeoutActivated;
+  u8 frameSkipper;
+
+  Sprite* tyraSprite;
+  Sprite* bgSprite;
+  Sprite* bg2Sprite;
+  Sprite* fillerSprite;
+
+  void renderFillers();
+};
+
+}  // namespace Demo

demo/inc/states/intro/states/intro_war_info_state.hpp

@@ -0,0 +1,46 @@
+/*
+# ______       ____   ___
+#   |     \/   ____| |___|
+#   |     |   |   \  |   |
+#-----------------------------------------------------------------------
+# Copyright 2022, tyra - https://github.com/h4570/tyra
+# Licenced under Apache License 2.0
+# Sandro Sobczyński <sandro.sobczynski@gmail.com>
+*/
+
+#pragma once
+
+#include "state/state.hpp"
+#include "../intro_state_type.hpp"
+#include "renderer/core/2d/sprite/sprite.hpp"
+#include "time/timer.hpp"
+
+using Tyra::Sprite;
+using Tyra::Texture;
+using Tyra::Timer;
+
+namespace Demo {
+
+class IntroWarInfoState : public State<IntroStateType> {
+ public:
+  IntroWarInfoState(Engine* t_engine);
+  ~IntroWarInfoState();
+
+  const IntroStateType& getState() const { return state; }
+
+  const bool& wantFinish() const { return _wantFinish; };
+
+  void onStart();
+
+  void update();
+
+  /** @return Next game state */
+  IntroStateType onFinish();
+
+ private:
+  IntroStateType state;
+  bool _wantFinish;
+  bool initialized;
+};
+
+}  // namespace Demo

demo/res/.gitignore

@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

demo/src/demo_game.cpp

@@ -0,0 +1,23 @@
+/*
+# ______       ____   ___
+#   |     \/   ____| |___|
+#   |     |   |   \  |   |
+#-----------------------------------------------------------------------
+# Copyright 2022, tyra - https://github.com/h4570/tyra
+# Licenced under Apache License 2.0
+# Sandro Sobczyński <sandro.sobczynski@gmail.com>
+*/
+
+#include "demo_game.hpp"
+#include "states/intro/intro_state.hpp"
+
+namespace Demo {
+
+DemoGame::DemoGame(Engine* t_engine)
+    : engine(t_engine), stateManager(STATE_INTRO) {}
+DemoGame::~DemoGame() {}
+
+void DemoGame::init() { stateManager.add(new IntroState(engine)); }
+void DemoGame::loop() { stateManager.update(); }
+
+}  // namespace Demo

demo/src/main.cpp

@@ -9,11 +9,11 @@
 */
 
 #include "engine.hpp"
-#include "demo.hpp"
+#include "demo_game.hpp"
 
 int main() {
   Tyra::Engine engine;
-  Tyra::Demo game(&engine);
+  Demo::DemoGame game(&engine);
   engine.run(&game);
   SleepThread();
   return 0;

demo/src/states/intro/intro_state.cpp

@@ -0,0 +1,46 @@
+/*
+# ______       ____   ___
+#   |     \/   ____| |___|
+#   |     |   |   \  |   |
+#-----------------------------------------------------------------------
+# Copyright 2022, tyra - https://github.com/h4570/tyra
+# Licenced under Apache License 2.0
+# Sandro Sobczyński <sandro.sobczynski@gmail.com>
+*/
+
+#include "states/intro/intro_state.hpp"
+#include "file/file_utils.hpp"
+#include "debug/debug.hpp"
+
+#include "states/intro/states/intro_ps2dev_state.hpp"
+#include "states/intro/states/intro_tyra_state.hpp"
+#include "states/intro/states/intro_war_info_state.hpp"
+
+using Tyra::FileUtils;
+
+namespace Demo {
+
+IntroState::IntroState(Engine* t_engine)
+    : State(t_engine), stateManager(STATE_PS2DEV) {
+  state = STATE_INTRO;
+  _wantFinish = false;
+}
+
+IntroState::~IntroState() {}
+
+void IntroState::onStart() {
+  engine->audio.loadSong(FileUtils::fromCwd("intro/intro.wav"));
+  engine->audio.setSongLoop(false);
+  engine->audio.setSongVolume(80);
+  engine->audio.playSong();
+
+  stateManager.add(new IntroPs2DevState(engine));
+  stateManager.add(new IntroTyraState(engine));
+  stateManager.add(new IntroWarInfoState(engine));
+}
+
+void IntroState::update() { stateManager.update(); }
+
+GlobalStateType IntroState::onFinish() { return STATE_EXIT; }
+
+}  // namespace Demo

demo/src/states/intro/states/intro_ps2dev_state.cpp

@@ -0,0 +1,99 @@
+/*
+# ______       ____   ___
+#   |     \/   ____| |___|
+#   |     |   |   \  |   |
+#-----------------------------------------------------------------------
+# Copyright 2022, tyra - https://github.com/h4570/tyra
+# Licenced under Apache License 2.0
+# Sandro Sobczyński <sandro.sobczynski@gmail.com>
+*/
+
+#include "states/intro/states/intro_ps2dev_state.hpp"
+#include "loaders/texture/png_loader.hpp"
+#include "file/file_utils.hpp"
+#include "debug/debug.hpp"
+#include "thread/threading.hpp"
+
+using Tyra::FileUtils;
+using Tyra::PngLoader;
+using Tyra::Threading;
+
+namespace Demo {
+
+IntroPs2DevState::IntroPs2DevState(Engine* t_engine) : State(t_engine) {
+  state = STATE_PS2DEV;
+  _wantFinish = false;
+  initialized = false;
+  initialDelayElapsed = false;
+  frameSkipper = 0;
+  fadeinActivated = true;
+  fadeoutActivated = false;
+}
+
+IntroPs2DevState::~IntroPs2DevState() {
+  if (!initialized) return;
+
+  delete sprite;
+  engine->renderer.core.texture.repository.free(texture->getId());
+}
+
+void IntroPs2DevState::onStart() {
+  const auto& settings = engine->renderer.core.getSettings();
+
+  TYRA_LOG("Init!");
+
+  initialDelayTimer.prime();
+
+  sprite = new Sprite;
+  sprite->size.set(256.0F, 64.0F);
+  sprite->position.set(settings.getWidth() / 2 - sprite->size.x / 2,
+                       settings.getHeight() / 2 - sprite->size.y / 2);
+  sprite->color.a = 0;
+
+  texture = engine->renderer.core.texture.repository.add(
+      FileUtils::fromCwd("intro/ps2dev.png"));
+  texture->addLink(sprite->getId());
+
+  initialized = true;
+}
+
+void IntroPs2DevState::update() {
+  engine->renderer.beginFrame();
+
+  if (initialDelayTimer.getTimeDelta() >= 60000) initialDelayElapsed = true;
+
+  frameSkipper++;
+  if (frameSkipper > 3) {
+    frameSkipper = 0;
+  }
+
+  if (fadeinActivated && initialDelayElapsed && frameSkipper == 0) {
+    if (sprite->color.a < 128.0F)
+      sprite->color.a += 2.0F;
+    else {
+      fadeoutActivated = true;
+      fadeinActivated = false;
+    }
+    if (sprite->color.a >= 96.0F && sprite->color.a < 128.0F) {
+      sprite->color.g -= 6.0F;
+      sprite->color.b -= 6.0F;
+    }
+  }
+
+  Threading::switchThread();
+
+  if (fadeoutActivated && frameSkipper == 0) {
+    if (sprite->color.a > 0)
+      sprite->color.a -= 4;
+    else
+      _wantFinish = true;
+  }
+
+  engine->renderer.renderer2D.render(sprite);
+
+  engine->renderer.endFrame();
+}
+
+IntroStateType IntroPs2DevState::onFinish() { return STATE_TYRA; }
+
+}  // namespace Demo

demo/src/states/intro/states/intro_tyra_state.cpp

@@ -0,0 +1,173 @@
+/*
+# ______       ____   ___
+#   |     \/   ____| |___|
+#   |     |   |   \  |   |
+#-----------------------------------------------------------------------
+# Copyright 2022, tyra - https://github.com/h4570/tyra
+# Licenced under Apache License 2.0
+# Sandro Sobczyński <sandro.sobczynski@gmail.com>
+*/
+
+#include "states/intro/states/intro_tyra_state.hpp"
+#include "loaders/texture/png_loader.hpp"
+#include "file/file_utils.hpp"
+#include "debug/debug.hpp"
+#include "thread/threading.hpp"
+#include "math/math.hpp"
+
+using Tyra::FileUtils;
+using Tyra::Math;
+using Tyra::PngLoader;
+using Tyra::Threading;
+
+namespace Demo {
+
+IntroTyraState::IntroTyraState(Engine* t_engine) : State(t_engine) {
+  state = STATE_TYRA;
+  _wantFinish = false;
+  initialized = false;
+  initialDelayElapsed = false;
+  animActivated = true;
+  fadeoutActivated = false;
+  frameSkipper = 0;
+}
+
+IntroTyraState::~IntroTyraState() {
+  if (!initialized) return;
+
+  engine->renderer.core.texture.repository.free(tyraTexture->getId());
+  engine->renderer.core.texture.repository.free(bgTexture->getId());
+  engine->renderer.core.texture.repository.free(fillerTexture->getId());
+
+  delete tyraSprite;
+  delete bgSprite;
+  delete fillerSprite;
+}
+
+void IntroTyraState::onStart() {
+  const auto& settings = engine->renderer.core.getSettings();
+
+  initialDelayTimer.prime();
+
+  tyraSprite = new Sprite;
+  tyraSprite->size.set(256.0F, 64.0F);
+  tyraSprite->position.set(settings.getWidth() / 2 - tyraSprite->size.x / 2,
+                           settings.getHeight() / 2 - tyraSprite->size.y / 2);
+
+  bgSprite = new Sprite;
+  bgSprite->size.set(256.0F, 256.0F);
+  bgSprite->position.set(settings.getWidth() / 2 - bgSprite->size.x / 2,
+                         settings.getHeight() / 3 * 2.0F);
+
+  bg2Sprite = new Sprite;
+  bg2Sprite->size.set(256.0F, 256.0F);
+  bg2Sprite->position.set(
+      settings.getWidth() / 2 - bg2Sprite->size.x / 2,
+      (settings.getHeight() / 3 * 2.0F) + bg2Sprite->size.y + 1.0F);
+
+  fillerSprite = new Sprite;
+  fillerSprite->size.set(256.0F, 256.0F);
+  fillerSprite->position.set(0.0F, 0.0F);
+
+  tyraTexture = engine->renderer.core.texture.repository.add(
+      FileUtils::fromCwd("intro/tyra.png"));
+  tyraTexture->addLink(tyraSprite->getId());
+
+  bgTexture = engine->renderer.core.texture.repository.add(
+      FileUtils::fromCwd("intro/tyra_bg.png"));
+  bgTexture->addLink(bgSprite->getId());
+
+  bg2Texture = engine->renderer.core.texture.repository.add(
+      FileUtils::fromCwd("intro/tyra_bg2.png"));
+  bg2Texture->addLink(bg2Sprite->getId());
+
+  fillerTexture = engine->renderer.core.texture.repository.add(
+      FileUtils::fromCwd("intro/filler.png"));
+  fillerTexture->addLink(fillerSprite->getId());
+
+  initialized = true;
+}
+
+void IntroTyraState::update() {
+  engine->renderer.beginFrame();
+
+  if (initialDelayTimer.getTimeDelta() >= 15000) initialDelayElapsed = true;
+
+  frameSkipper++;
+  if (frameSkipper > 3) {
+    frameSkipper = 0;
+  }
+
+  const float slideUpMaxPost = -128.0F;
+
+  if (initialDelayElapsed) {
+    if (bgSprite->position.y <= 32.0F) fadeoutActivated = true;
+
+    float offset = 1.0F;
+    if (bgSprite->position.y > slideUpMaxPost && bgSprite->position.y <= 64.0F)
+      offset /= 1.6F;
+    else if (bgSprite->position.y > 64.0F && bgSprite->position.y <= 128.0F)
+      offset /= 1.2F;
+
+    if (bgSprite->position.y > 32.0F && bgSprite->position.y <= 64.0F &&
+        bgSprite->color.g > 0.0F) {
+      const float colorOffset = 1.5F;
+      bgSprite->color.g -= colorOffset;
+      bgSprite->color.b -= colorOffset;
+      bg2Sprite->color.g -= colorOffset;
+      bg2Sprite->color.b -= colorOffset;
+    }
+
+    if (bgSprite->position.y > slideUpMaxPost) {
+      bgSprite->position.y -= offset;
+      bg2Sprite->position.y -= offset;
+    }
+  }
+
+  if (fadeoutActivated && frameSkipper == 0) {
+    if (bgSprite->color.a > 0) {
+      bgSprite->color.a -= 4.0F;
+      bg2Sprite->color.a -= 4.0F;
+    } else
+      _wantFinish = true;
+  }
+
+  Threading::switchThread();
+
+  engine->renderer.renderer2D.render(bgSprite);
+  engine->renderer.renderer2D.render(bg2Sprite);
+  engine->renderer.renderer2D.render(tyraSprite);
+
+  Threading::switchThread();
+  renderFillers();
+
+  engine->renderer.endFrame();
+}
+
+void IntroTyraState::renderFillers() {
+  // Up
+  fillerSprite->position.set(0.0F, -63.0F);
+  engine->renderer.renderer2D.render(fillerSprite);
+
+  fillerSprite->position.set(256.0F, -63.0F);
+  engine->renderer.renderer2D.render(fillerSprite);
+
+  // Left
+  fillerSprite->position.set(-124.0F, 128.0F);
+  engine->renderer.renderer2D.render(fillerSprite);
+
+  // Down
+  fillerSprite->position.set(0.0F, 256.0F);
+  engine->renderer.renderer2D.render(fillerSprite);
+
+  fillerSprite->position.set(256.0F, 256.0F);
+  engine->renderer.renderer2D.render(fillerSprite);
+
+  // Right
+  fillerSprite->position.set(386.0F, 128.0F);
+  engine->renderer.renderer2D.render(fillerSprite);
+}
+
+IntroStateType IntroTyraState::onFinish() { return STATE_WAR_INFO; }
+
+}  // namespace Demo

demo/src/states/intro/states/intro_war_info_state.cpp

@@ -0,0 +1,43 @@
+/*
+# ______       ____   ___
+#   |     \/   ____| |___|
+#   |     |   |   \  |   |
+#-----------------------------------------------------------------------
+# Copyright 2022, tyra - https://github.com/h4570/tyra
+# Licenced under Apache License 2.0
+# Sandro Sobczyński <sandro.sobczynski@gmail.com>
+*/
+
+#include "states/intro/states/intro_war_info_state.hpp"
+#include "loaders/texture/png_loader.hpp"
+#include "file/file_utils.hpp"
+#include "debug/debug.hpp"
+#include "thread/threading.hpp"
+#include "math/math.hpp"
+
+using Tyra::FileUtils;
+using Tyra::Math;
+using Tyra::PngLoader;
+using Tyra::Threading;
+
+namespace Demo {
+
+IntroWarInfoState::IntroWarInfoState(Engine* t_engine) : State(t_engine) {
+  state = STATE_WAR_INFO;
+  _wantFinish = false;
+}
+
+IntroWarInfoState::~IntroWarInfoState() {
+  if (!initialized) return;
+}
+
+void IntroWarInfoState::onStart() { initialized = true; }
+
+void IntroWarInfoState::update() {
+  engine->renderer.beginFrame();
+
+  engine->renderer.endFrame();
+}
+IntroStateType IntroWarInfoState::onFinish() { return STATE_PRESS_KEY; }
+
+}  // namespace Demo