Just breaking stuff

archive/dawnpokergame/CMakeLists.txt

@@ -0,0 +1,34 @@
+# Copyright (c) 2022 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Add Common Engine Parts
+set(DAWN_VISUAL_NOVEL true CACHE INTERNAL ${DAWN_CACHE_TARGET})
+
+# Build Project
+add_executable(${DAWN_TARGET_NAME})
+
+# Includes
+target_include_directories(${DAWN_TARGET_NAME}
+  PUBLIC
+    ${CMAKE_CURRENT_LIST_DIR}
+)
+
+# Subdirs
+add_subdirectory(game)
+add_subdirectory(ui)
+add_subdirectory(visualnovel)
+add_subdirectory(prefabs)
+add_subdirectory(save)
+add_subdirectory(scenes)
+
+# Assets
+set(DIR_GAME_ASSETS games/pokergame)
+tool_texture(texture_test texture_test.png)
+tool_language(locale_poker ${DIR_GAME_ASSETS}/locale/locale.xml)
+tool_tileset(tileset_death texture_death ${DIR_GAME_ASSETS}/characters/death/sheet.png 1 3)
+tool_tileset(tileset_penny texture_penny ${DIR_GAME_ASSETS}/characters/penny/sheet.png 1 3)
+tool_truetype(truetype_bizudp ${DIR_GAME_ASSETS}/font/BIZUDPGothic-Regular.ttf truetype_bizudp 2048 2048 120)
+tool_audio(audio_test borrowed/sample_short.wav)
+tool_vnscene(Scene_1 ${DIR_GAME_ASSETS}/vn/Scene_1.xml)

archive/dawnpokergame/game/CMakeLists.txt

@@ -0,0 +1,10 @@
+# Copyright (c) 2022 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    DawnGame.cpp
+)

archive/dawnpokergame/game/DawnGame.cpp

@@ -0,0 +1,59 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "DawnGame.hpp"
+#include "scenes/Scene_1.hpp"
+
+using namespace Dawn;
+
+DawnGame::DawnGame(DawnHost *host) :
+  host(host),
+  renderManager(this),
+  inputManager(this),
+  localeManager(this),
+  saveManager(this),
+  audioManager(this)
+{
+}
+
+int32_t DawnGame::init() {
+  this->assetManager.init();
+  this->localeManager.init();
+  this->renderManager.init();
+  this->audioManager.init();
+
+  this->scene = new Scene_1(this);
+  
+  return DAWN_GAME_INIT_RESULT_SUCCESS;
+}
+
+int32_t DawnGame::update(float_t delta) {
+  if(this->sceneToCutTo != nullptr) {
+    if(this->sceneToCutTo == this->scene) {
+      delete this->scene;
+      this->scene = nullptr;
+    } else {
+      delete this->scene;
+      this->scene = this->sceneToCutTo;
+    }
+    this->sceneToCutTo = nullptr;
+  }
+
+  this->assetManager.update();
+  this->inputManager.update();
+  this->timeManager.update(delta);
+
+  if(this->scene != nullptr) this->scene->update();
+  
+  this->renderManager.update();
+
+  return DAWN_GAME_UPDATE_RESULT_SUCCESS;
+}
+
+
+void DawnGame::sceneCutover(Scene *scene) {
+  if(scene == nullptr) scene = this->scene;
+  this->sceneToCutTo = scene;
+}

archive/dawnpokergame/game/DawnGame.hpp

@@ -0,0 +1,31 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "game/_DawnGame.hpp"
+#include "scene/components/Components.hpp"
+#include "save/PokerSaveManager.hpp"
+
+namespace Dawn {
+  class DawnGame : public IDawnGame {
+    private:
+      Scene *sceneToCutTo = nullptr;
+
+    public:
+      DawnHost *host;
+      RenderManager renderManager;
+      AssetManager assetManager;
+      InputManager inputManager;
+      TimeManager timeManager;
+      LocaleManager localeManager;
+      PokerSaveManager saveManager;
+      AudioManager audioManager;
+      
+      DawnGame(DawnHost *host);
+      int32_t init() override;
+      int32_t update(float_t delta) override;
+      void sceneCutover(Scene *scene) override;
+  };
+}

archive/dawnpokergame/input/InputBinds.hpp

@@ -0,0 +1,15 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "input/InputManager.hpp"
+
+#define dbind(n) ((inputbind_t)n)
+
+#define INPUT_BIND_ACCEPT dbind(1)
+#define INPUT_BIND_NEGATIVE_X dbind(2)
+#define INPUT_BIND_POSITIVE_X dbind(3)
+#define INPUT_BIND_NEGATIVE_Y dbind(4)
+#define INPUT_BIND_POSITIVE_Y dbind(5)

archive/dawnpokergame/prefabs/CMakeLists.txt

@@ -0,0 +1,6 @@
+# Copyright (c) 2022 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+add_subdirectory(characters)

archive/dawnpokergame/prefabs/characters/CMakeLists.txt

@@ -0,0 +1,11 @@
+# Copyright (c) 2023 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    CharacterPrefab.cpp
+    DeathPrefab.cpp
+)

archive/dawnpokergame/prefabs/characters/CharacterPrefab.cpp

@@ -0,0 +1,8 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "CharacterPrefab.hpp"
+
+using namespace Dawn;

archive/dawnpokergame/prefabs/characters/CharacterPrefab.hpp

@@ -0,0 +1,82 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "prefab/SceneItemPrefab.hpp"
+#include "scene/Scene.hpp"
+#include "scene/components/display/MeshRenderer.hpp"
+#include "scene/components/display/AnimationController.hpp"
+#include "scene/components/display/MeshHost.hpp"
+#include "scene/components/display/material/SimpleTexturedMaterial.hpp"
+#include "scene/components/audio/AudioSource.hpp"
+#include "visualnovel/components/VisualNovelCharacter.hpp"
+
+namespace Dawn {
+  template<class O>
+  class CharacterPrefab : public SceneItemPrefab<O> {
+    protected:
+      /**
+       * Character Prefab will request you to initialize your characters' 
+       * emotions here, including loading assets, 
+       * 
+       * @return struct VisualNovelCharacterEmotion 
+       */
+      virtual struct VisualNovelCharacterEmotion defineAndGetInitialEmotion(
+        AssetManager *assMan
+      ) = 0;
+      
+
+    public:
+      static std::vector<Asset*> prefabAssets(AssetManager *assMan) {
+        return std::vector<Asset*>{
+          assMan->get<TextureAsset>(O::getCharacterTexture()),
+          assMan->get<TilesetAsset>(O::getCharacterTileset())
+        };
+      }
+
+      // Instance
+      VisualNovelCharacter *vnCharacter;
+      AnimationController *animation;
+      TextureAsset *characterTexture;
+      TilesetAsset *characterTileset;
+      MeshRenderer *meshRenderer;
+      MeshHost *meshHost;
+      SimpleTexturedMaterial *material;
+      TiledSprite *tiledSprite;
+      AudioSource *audioSource;
+
+      CharacterPrefab(Scene *s, sceneitemid_t i) : SceneItemPrefab<O>(s, i) {}
+      
+      void prefabInit(AssetManager *man) override {
+        characterTexture = man->get<TextureAsset>(O::getCharacterTexture());
+        characterTileset = man->get<TilesetAsset>(O::getCharacterTileset());
+
+        // Emotions
+        auto emotion = this->defineAndGetInitialEmotion(man);
+
+        // Components
+        meshRenderer = this->template addComponent<MeshRenderer>();
+        meshHost = this->template addComponent<MeshHost>();
+
+        material = this->template addComponent<SimpleTexturedMaterial>();
+        material->texture = &characterTexture->texture;
+
+        vnCharacter = this->template addComponent<VisualNovelCharacter>();
+        vnCharacter->nameKey = O::getLanguagePrefix() + ".name";
+
+        animation = this->template addComponent<AnimationController>();
+        
+        tiledSprite = this->template addComponent<TiledSprite>();
+        tiledSprite->setTileset(&characterTileset->tileset);
+        float_t ratio = characterTileset->tileset.getTileWidth() / characterTileset->tileset.getTileHeight();
+        tiledSprite->setSize(glm::vec2(ratio, 1.0f));
+        tiledSprite->setTile(emotion.tile);
+
+        audioSource = this->template addComponent<AudioSource>();
+        
+        this->transform.setLocalPosition(glm::vec3(0, 0, 0)); 
+      }
+  };
+}

archive/dawnpokergame/prefabs/characters/DeathPrefab.cpp

@@ -0,0 +1,32 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "DeathPrefab.hpp"
+
+using namespace Dawn;
+
+std::string DeathPrefab::getCharacterTexture() {
+  return "texture_death";
+}
+
+std::string DeathPrefab::getCharacterTileset() {
+  return "tileset_death";
+}
+
+std::string DeathPrefab::getLanguagePrefix() {
+  return "character.death";
+}
+
+struct VisualNovelCharacterEmotion DeathPrefab::defineAndGetInitialEmotion(
+  AssetManager *man
+) {
+  this->emotionHappy.tile = 0;
+
+  this->emotionConcerned.tile = 1;
+  
+  this->emotionSurprised.tile = 2;
+
+  return this->emotionHappy;
+}

archive/dawnpokergame/prefabs/characters/DeathPrefab.hpp

@@ -0,0 +1,29 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "prefabs/characters/CharacterPrefab.hpp"
+
+namespace Dawn {
+  class DeathPrefab : public CharacterPrefab<DeathPrefab> {
+    protected:
+
+      struct VisualNovelCharacterEmotion defineAndGetInitialEmotion(
+        AssetManager *man
+      ) override;
+
+    public:
+      static std::string getCharacterTexture();
+      static std::string getCharacterTileset();
+      static std::string getLanguagePrefix();
+      
+      struct VisualNovelCharacterEmotion emotionHappy;
+      struct VisualNovelCharacterEmotion emotionConcerned;
+      struct VisualNovelCharacterEmotion emotionSurprised;
+      struct VisualNovelCharacterEmotion emotionUnset;
+
+      DeathPrefab(Scene *s, sceneitemid_t i) : CharacterPrefab(s,i) {}
+  };
+}

archive/dawnpokergame/prefabs/characters/PennyPrefab.hpp

@@ -0,0 +1,68 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "prefab/SceneItemPrefab.hpp"
+#include "asset/AssetManager.hpp"
+#include "poker/PokerPlayer.hpp"
+#include "scene/components/Components.hpp"
+#include "visualnovel/components/VisualNovelCharacter.hpp"
+#include "display/animation/TiledSpriteAnimation.hpp"
+#include "scene/components/display/material/SimpleTexturedMaterial.hpp"
+
+namespace Dawn {
+  class PennyPrefab : public SceneItemPrefab<PennyPrefab> {
+    public:
+      VisualNovelCharacter *vnCharacter;
+      PokerPlayer *pokerPlayer;
+      SimpleTexturedMaterial *material;
+
+      struct VisualNovelCharacterEmotion emotionHappy;
+      struct VisualNovelCharacterEmotion emotionSurprised;
+      struct VisualNovelCharacterEmotion emotionConcerned;
+
+      static std::vector<Asset*> prefabAssets(AssetManager *assMan) {
+        return std::vector<Asset*>{
+          assMan->get<TextureAsset>("texture_penny"),
+          assMan->get<TilesetAsset>("tileset_penny")
+        };
+      }
+
+      PennyPrefab(Scene *scene, sceneitemid_t id) : SceneItemPrefab(scene, id){}
+
+      void prefabInit(AssetManager *man) override {
+        // Assets
+        auto textureAsset = man->get<TextureAsset>("texture_penny");
+        auto tilesetAsset = man->get<TilesetAsset>("tileset_penny");
+
+        // Emotions
+        this->emotionHappy.tile = 0;
+        
+        this->emotionSurprised.tile = 1;
+
+        this->emotionConcerned.tile = 2;
+
+        // Components
+        auto meshRenderer = this->addComponent<MeshRenderer>();
+        auto meshHost = this->addComponent<MeshHost>();
+
+        material = this->addComponent<SimpleTexturedMaterial>();
+        material->texture = &textureAsset->texture;
+
+        auto animation = this->addComponent<AnimationController>();
+
+        pokerPlayer = this->addComponent<PokerPlayer>();
+
+        vnCharacter = this->addComponent<VisualNovelCharacter>();
+        vnCharacter->nameKey = "character.penny.name";
+        
+        auto tiledSprite = this->addComponent<TiledSprite>();
+        tiledSprite->setTilesetAndSize(&tilesetAsset->tileset);
+        tiledSprite->setTile(0);
+
+        this->transform.setLocalPosition(glm::vec3(0, 0, 0));
+      }
+  };
+}

archive/dawnpokergame/prefabs/ui/UIBorderPrefab.hpp

@@ -0,0 +1,25 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "prefab/UIPrefab.hpp"
+#include "ui/UIBorder.hpp"
+
+namespace Dawn {
+  class UIBorderPrefab : public UIPrefab<UIBorder, UIBorderPrefab> {
+    public:
+      static std::vector<Asset*> prefabAssets(AssetManager *man) {
+        std::vector<Asset*> assets;
+        assets.push_back(man->get<TextureAsset>("texture_test"));
+        return assets;
+      }
+
+      static void prefabApply(AssetManager *man, UIBorder *border) {
+        auto text = man->get<TextureAsset>("texture_test");
+        border->texture = &text->texture;
+        border->setBorderSize(glm::vec2(4, 4));
+      }
+  };
+}

archive/dawnpokergame/prefabs/ui/VisualNovelTextboxPrefab.hpp

@@ -0,0 +1,43 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "prefabs/ui/UIBorderPrefab.hpp"
+#include "visualnovel/ui/VisualNovelTextbox.hpp"
+
+namespace Dawn {
+  class VisualNovelTextboxPrefab :
+    public UIPrefab<VisualNovelTextbox, VisualNovelTextboxPrefab>
+  {
+    public:
+      static std::vector<Asset*> prefabAssets(AssetManager *man) {
+        std::vector<Asset*> assets;
+        assets.push_back(man->get<TrueTypeAsset>("truetype_bizudp"));
+        vectorAppend(&assets, UIBorderPrefab::getRequiredAssets(man));
+        return assets;
+      }
+  
+      static void prefabApply(AssetManager *man, VisualNovelTextbox *textbox) {
+        auto assetFont = man->get<TrueTypeAsset>("truetype_bizudp");
+        UIBorderPrefab::apply(&textbox->border);
+        textbox->setFont(&assetFont->font);
+        textbox->setFontSize(36.0f);
+        textbox->setLabelPadding(glm::vec2(2, 2));
+        textbox->label.textColor = COLOR_WHITE;
+
+        textbox->setTransform(
+          UI_COMPONENT_ALIGN_STRETCH, UI_COMPONENT_ALIGN_END,
+          glm::vec4(
+            0, 
+            (assetFont->font.getLineHeight(textbox->getFontSize()) * 4) +
+            (textbox->border.getBorderSize().y * 2.0f) +
+            (textbox->getLabelPadding().y * 2.0f),
+            0, 0
+          ),
+          0.0f
+        );
+      }
+  };
+}

archive/dawnpokergame/save/CMakeLists.txt

@@ -0,0 +1,10 @@
+# Copyright (c) 2022 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    PokerSaveManager.cpp
+)

archive/dawnpokergame/save/PokerSaveManager.cpp

@@ -0,0 +1,28 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "PokerSaveManager.hpp"
+
+using namespace Dawn;
+
+PokerSaveManager::PokerSaveManager(DawnGame *game) : SaveManager(game) {
+}
+
+bool_t PokerSaveManager::validateSave(struct SaveFile raw) {
+  if(!raw.has(POKER_SAVE_KEY_EXAMPLE)) return true;
+  this->currentSave.copy(raw, POKER_SAVE_KEY_EXAMPLE);
+
+  return false;
+}
+
+void PokerSaveManager::setExample(int32_t val) {
+  savedata_t value;
+  value.i32 = val;
+  this->currentSave.set(POKER_SAVE_KEY_EXAMPLE, value);
+}
+
+int32_t PokerSaveManager::getExample() {
+  return this->currentSave.get(POKER_SAVE_KEY_EXAMPLE).i32;
+}

archive/dawnpokergame/save/PokerSaveManager.hpp

@@ -0,0 +1,22 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "save/SaveManager.hpp"
+
+#define POKER_SAVE_KEY_EXAMPLE "poker.example"
+
+namespace Dawn {
+  class PokerSaveManager : public SaveManager {
+    protected:
+      virtual bool_t validateSave(struct SaveFile raw) override;
+
+    public:
+      PokerSaveManager(DawnGame *game);
+
+      void setExample(int32_t value);
+      int32_t getExample();
+  };
+}

archive/dawnpokergame/scenes/CMakeLists.txt

@@ -0,0 +1,10 @@
+# Copyright (c) 2022 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    PokerVNScene.cpp
+)

archive/dawnpokergame/scenes/PokerVNScene.cpp

@@ -0,0 +1,39 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "PokerVNScene.hpp"
+
+using namespace Dawn;
+
+PokerVNScene::PokerVNScene(DawnGame *game) : SimpleVNScene(game) {
+
+}
+
+std::vector<Asset*> PokerVNScene::getRequiredAssets() {
+  auto assMan = &this->game->assetManager;
+  std::vector<Asset*> assets;
+  vectorAppend(&assets, SimpleVNScene::getRequiredAssets());
+  vectorAppend(&assets, PokerPlayerDisplay::getAssets(assMan));
+  return assets;
+}
+
+void PokerVNScene::vnStage() {
+  
+  auto pokerGameItem = this->createSceneItem();
+  this->pokerGame = pokerGameItem->addComponent<PokerGame>();
+
+  this->pokerPlayers = this->getPokerPlayers();
+
+  auto it = this->pokerPlayers.begin();
+  int32_t i = 0;
+  while(it != this->pokerPlayers.end()) {
+    auto player = *it;
+    // auto uiPlayer = canvas->addElement<PokerPlayerDisplay>();
+    // uiPlayer->setTransform(UI_COMPONENT_ALIGN_START, UI_COMPONENT_ALIGN_START, glm::vec4(i * 220, 0, 220, 200), 0);
+    // uiPlayer->setPlayer(player);
+    ++it;
+    ++i;
+  }
+}

archive/dawnpokergame/scenes/PokerVNScene.hpp

@@ -0,0 +1,39 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "visualnovel/scene/SimpleVNScene.hpp"
+#include "poker/PokerGame.hpp"
+#include "visualnovel/events/PokerBetLoopEvent.hpp"
+#include "visualnovel/events/PokerInitialEvent.hpp"
+#include "ui/PokerPlayerDisplay.hpp"
+
+namespace Dawn {
+  class PokerVNScene : public SimpleVNScene {
+    protected:
+      void vnStage() override;
+      std::vector<Asset*> getRequiredAssets() override;
+
+      /**
+       * Returns the Poker Players that are in this poker scene.
+       * 
+       * @return List of Poker Players.
+       */
+      virtual std::vector<PokerPlayer*> getPokerPlayers() = 0;
+
+    public:
+      PokerGame *pokerGame;
+      std::vector<PokerPlayer*> pokerPlayers;
+      std::map<PokerPlayer*, PokerPlayerDisplay*> pokerPlayerDisplays;
+
+      /**
+       * Create a simple Poker Visual Novel Scene. Simplifies some of the less
+       * interesting parts of a poker VN game.
+       * 
+       * @param game Game that this poker scene belongs to.
+       */
+      PokerVNScene(DawnGame *game);
+  };
+}

archive/dawnpokergame/scenes/Scene_10.hpp

@@ -0,0 +1,45 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "visualnovel/scene/SimpleVNScene.hpp"
+#include "scenes/Scene_11.hpp"
+
+namespace Dawn {
+  class Scene_10 : public SimpleVNScene {
+    protected:
+      void vnStage() override {
+        
+      }
+
+      void onSceneEnded() {
+        auto scene = new Scene_11(this->game);
+        game->assetManager.queueSwap(
+          scene->getRequiredAssets(), this->getRequiredAssets()
+        );
+        game->assetManager.syncLoad();
+        scene->stage();
+        this->game->sceneCutover(scene);
+      }
+
+    public:
+      Scene_10(DawnGame *game) : SimpleVNScene(game) {
+      }
+
+      std::vector<Asset*> getRequiredAssets() override {
+        std::vector<Asset*> assets = SimpleVNScene::getRequiredAssets();
+        return assets;
+      }
+
+      IVisualNovelEvent * getVNEvent() override {
+        auto start = new VisualNovelPauseEvent(vnManager, 0.1f);
+        start
+          ->then(new VisualNovelTextboxEvent(vnManager, "scene.10.1"))
+          ->then(new VisualNovelCallbackEvent<Scene_10>(vnManager, this, &Scene_10::onSceneEnded))
+        ;
+        return start;
+      }
+  };
+}

archive/dawnpokergame/scenes/Scene_11.hpp

@@ -0,0 +1,45 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "visualnovel/scene/SimpleVNScene.hpp"
+#include "scenes/Scene_12.hpp"
+
+namespace Dawn {
+  class Scene_11 : public SimpleVNScene {
+    protected:
+      void vnStage() override {
+        
+      }
+
+      void onSceneEnded() {
+        auto scene = new Scene_12(this->game);
+        game->assetManager.queueSwap(
+          scene->getRequiredAssets(), this->getRequiredAssets()
+        );
+        game->assetManager.syncLoad();
+        scene->stage();
+        this->game->sceneCutover(scene);
+      }
+
+    public:
+      Scene_11(DawnGame *game) : SimpleVNScene(game) {
+      }
+
+      std::vector<Asset*> getRequiredAssets() override {
+        std::vector<Asset*> assets = SimpleVNScene::getRequiredAssets();
+        return assets;
+      }
+
+      IVisualNovelEvent * getVNEvent() override {
+        auto start = new VisualNovelPauseEvent(vnManager, 0.1f);
+        start
+          ->then(new VisualNovelTextboxEvent(vnManager, "scene.11.1"))
+          ->then(new VisualNovelCallbackEvent<Scene_11>(vnManager, this, &Scene_11::onSceneEnded))
+        ;
+        return start;
+      }
+  };
+}

archive/dawnpokergame/scenes/Scene_12.hpp

@@ -0,0 +1,66 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "PokerVNScene.hpp"
+#include "prefabs/characters/PennyPrefab.hpp"
+#include "scenes/Scene_13.hpp"
+
+namespace Dawn {
+  class Scene_12 : public PokerVNScene {
+    protected:
+      PennyPrefab *penny;
+      PennyPrefab *julie;
+      PennyPrefab *sammy;
+      PennyPrefab *lucy;
+
+      void vnStage() override {
+        penny = PennyPrefab::create(this);
+        julie = PennyPrefab::create(this);
+        sammy = PennyPrefab::create(this);
+        lucy = PennyPrefab::create(this);
+
+        PokerVNScene::vnStage();
+      }
+
+      void onSceneEnded() {
+        auto scene = new Scene_13(this->game);
+        game->assetManager.queueSwap(
+          scene->getRequiredAssets(), this->getRequiredAssets()
+        );
+        game->assetManager.syncLoad();
+        scene->stage();
+        this->game->sceneCutover(scene);
+      }
+
+      std::vector<PokerPlayer *> getPokerPlayers() override {
+        return std::vector<PokerPlayer*>{
+          this->penny->getComponent<PokerPlayer>(),
+          this->julie->getComponent<PokerPlayer>(),
+          this->sammy->getComponent<PokerPlayer>(),
+          this->lucy->getComponent<PokerPlayer>()
+        };
+      }
+
+    public:
+      Scene_12(DawnGame *game) : PokerVNScene(game) {}
+
+      std::vector<Asset*> getRequiredAssets() override {
+        auto assMan = &this->game->assetManager;
+        std::vector<Asset*> assets;
+        vectorAppend(&assets, PokerVNScene::getRequiredAssets());
+        vectorAppend(&assets, PennyPrefab::getRequiredAssets(assMan));
+        return assets;
+      }
+
+      IVisualNovelEvent * getVNEvent() override {
+        auto start = new VisualNovelTextboxEvent(vnManager, "scene.12.1");
+        start
+          ->then(new VisualNovelCallbackEvent<Scene_12>(vnManager, this, &Scene_12::onSceneEnded))
+        ;
+        return start;
+      }
+  };
+}

archive/dawnpokergame/scenes/Scene_13.hpp

@@ -0,0 +1,45 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "visualnovel/scene/SimpleVNScene.hpp"
+#include "scenes/Scene_14.hpp"
+
+namespace Dawn {
+  class Scene_13 : public SimpleVNScene {
+    protected:
+      void vnStage() override {
+        
+      }
+
+      void onSceneEnded() {
+        auto scene = new Scene_14(this->game);
+        game->assetManager.queueSwap(
+          scene->getRequiredAssets(), this->getRequiredAssets()
+        );
+        game->assetManager.syncLoad();
+        scene->stage();
+        this->game->sceneCutover(scene);
+      }
+
+    public:
+      Scene_13(DawnGame *game) : SimpleVNScene(game) {
+      }
+
+      std::vector<Asset*> getRequiredAssets() override {
+        std::vector<Asset*> assets = SimpleVNScene::getRequiredAssets();
+        return assets;
+      }
+
+      IVisualNovelEvent * getVNEvent() override {
+        auto start = new VisualNovelPauseEvent(vnManager, 0.1f);
+        start
+          ->then(new VisualNovelTextboxEvent(vnManager, "scene.13.1"))
+          ->then(new VisualNovelCallbackEvent<Scene_13>(vnManager, this, &Scene_13::onSceneEnded))
+        ;
+        return start;
+      }
+  };
+}

archive/dawnpokergame/scenes/Scene_14.hpp

@@ -0,0 +1,45 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "visualnovel/scene/SimpleVNScene.hpp"
+#include "scenes/Scene_15.hpp"
+
+namespace Dawn {
+  class Scene_14 : public SimpleVNScene {
+    protected:
+      void vnStage() override {
+        
+      }
+
+      void onSceneEnded() {
+        auto scene = new Scene_15(this->game);
+        game->assetManager.queueSwap(
+          scene->getRequiredAssets(), this->getRequiredAssets()
+        );
+        game->assetManager.syncLoad();
+        scene->stage();
+        this->game->sceneCutover(scene);
+      }
+
+    public:
+      Scene_14(DawnGame *game) : SimpleVNScene(game) {
+      }
+
+      std::vector<Asset*> getRequiredAssets() override {
+        std::vector<Asset*> assets = SimpleVNScene::getRequiredAssets();
+        return assets;
+      }
+
+      IVisualNovelEvent * getVNEvent() override {
+        auto start = new VisualNovelPauseEvent(vnManager, 0.1f);
+        start
+          ->then(new VisualNovelTextboxEvent(vnManager, "scene.14.1"))
+          ->then(new VisualNovelCallbackEvent<Scene_14>(vnManager, this, &Scene_14::onSceneEnded))
+        ;
+        return start;
+      }
+  };
+}

archive/dawnpokergame/scenes/Scene_15.hpp

@@ -0,0 +1,45 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "visualnovel/scene/SimpleVNScene.hpp"
+#include "scenes/Scene_16.hpp"
+
+namespace Dawn {
+  class Scene_15 : public SimpleVNScene {
+    protected:
+      void vnStage() override {
+        
+      }
+
+      void onSceneEnded() {
+        auto scene = new Scene_16(this->game);
+        game->assetManager.queueSwap(
+          scene->getRequiredAssets(), this->getRequiredAssets()
+        );
+        game->assetManager.syncLoad();
+        scene->stage();
+        this->game->sceneCutover(scene);
+      }
+
+    public:
+      Scene_15(DawnGame *game) : SimpleVNScene(game) {
+      }
+
+      std::vector<Asset*> getRequiredAssets() override {
+        std::vector<Asset*> assets = SimpleVNScene::getRequiredAssets();
+        return assets;
+      }
+
+      IVisualNovelEvent * getVNEvent() override {
+        auto start = new VisualNovelPauseEvent(vnManager, 0.1f);
+        start
+          ->then(new VisualNovelTextboxEvent(vnManager, "scene.15.1"))
+          ->then(new VisualNovelCallbackEvent<Scene_15>(vnManager, this, &Scene_15::onSceneEnded))
+        ;
+        return start;
+      }
+  };
+}

archive/dawnpokergame/scenes/Scene_16.hpp

@@ -0,0 +1,45 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "visualnovel/scene/SimpleVNScene.hpp"
+#include "scenes/Scene_17.hpp"
+
+namespace Dawn {
+  class Scene_16 : public SimpleVNScene {
+    protected:
+      void vnStage() override {
+        
+      }
+
+      void onSceneEnded() {
+        auto scene = new Scene_17(this->game);
+        game->assetManager.queueSwap(
+          scene->getRequiredAssets(), this->getRequiredAssets()
+        );
+        game->assetManager.syncLoad();
+        scene->stage();
+        this->game->sceneCutover(scene);
+      }
+    public:
+      Scene_16(DawnGame *game) : SimpleVNScene(game) {
+      }
+
+      std::vector<Asset*> getRequiredAssets() override {
+        std::vector<Asset*> assets = SimpleVNScene::getRequiredAssets();
+        return assets;
+      }
+
+      IVisualNovelEvent * getVNEvent() override {
+        auto start = new VisualNovelPauseEvent(vnManager, 0.1f);
+        start
+          ->then(new VisualNovelTextboxEvent(vnManager, "scene.16.1"))
+          ->then(new VisualNovelCallbackEvent<Scene_16>(vnManager, this, &Scene_16::onSceneEnded))
+        ;
+        return start;
+      }
+
+  };
+}

archive/dawnpokergame/scenes/Scene_17.hpp

@@ -0,0 +1,66 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "PokerVNScene.hpp"
+#include "prefabs/characters/PennyPrefab.hpp"
+#include "scenes/Scene_18.hpp"
+
+namespace Dawn {
+  class Scene_17 : public PokerVNScene {
+    protected:
+      PennyPrefab *penny;
+      PennyPrefab *julie;
+      PennyPrefab *sammy;
+      PennyPrefab *lucy;
+
+      void vnStage() override {
+        penny = PennyPrefab::create(this);
+        julie = PennyPrefab::create(this);
+        sammy = PennyPrefab::create(this);
+        lucy = PennyPrefab::create(this);
+
+        PokerVNScene::vnStage();
+      }
+
+      void onSceneEnded() {
+        auto scene = new Scene_18(this->game);
+        game->assetManager.queueSwap(
+          scene->getRequiredAssets(), this->getRequiredAssets()
+        );
+        game->assetManager.syncLoad();
+        scene->stage();
+        this->game->sceneCutover(scene);
+      }
+
+      std::vector<PokerPlayer *> getPokerPlayers() override {
+        return std::vector<PokerPlayer*>{
+          this->penny->getComponent<PokerPlayer>(),
+          this->julie->getComponent<PokerPlayer>(),
+          this->sammy->getComponent<PokerPlayer>(),
+          this->lucy->getComponent<PokerPlayer>()
+        };
+      }
+
+    public:
+      Scene_17(DawnGame *game) : PokerVNScene(game) {}
+
+      std::vector<Asset*> getRequiredAssets() override {
+        auto assMan = &this->game->assetManager;
+        std::vector<Asset*> assets;
+        vectorAppend(&assets, PokerVNScene::getRequiredAssets());
+        vectorAppend(&assets, PennyPrefab::getRequiredAssets(assMan));
+        return assets;
+      }
+
+      IVisualNovelEvent * getVNEvent() override {
+        auto start = new VisualNovelTextboxEvent(vnManager, "scene.17.1");
+        start
+          ->then(new VisualNovelCallbackEvent<Scene_17>(vnManager, this, &Scene_17::onSceneEnded))
+        ;
+        return start;
+      }
+  };
+}

archive/dawnpokergame/scenes/Scene_18.hpp

@@ -0,0 +1,37 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "visualnovel/scene/SimpleVNScene.hpp"
+
+namespace Dawn {
+  class Scene_18 : public SimpleVNScene {
+    protected:
+      void vnStage() override {
+        
+      }
+
+      void onSceneEnded() {
+      }
+
+    public:
+      Scene_18(DawnGame *game) : SimpleVNScene(game) {
+      }
+
+      std::vector<Asset*> getRequiredAssets() override {
+        std::vector<Asset*> assets = SimpleVNScene::getRequiredAssets();
+        return assets;
+      }
+
+      IVisualNovelEvent * getVNEvent() override {
+        auto start = new VisualNovelPauseEvent(vnManager, 0.1f);
+        start
+          ->then(new VisualNovelTextboxEvent(vnManager, "scene.18.1"))
+          ->then(new VisualNovelCallbackEvent<Scene_18>(vnManager, this, &Scene_18::onSceneEnded))
+        ;
+        return start;
+      }
+  };
+}

archive/dawnpokergame/scenes/Scene_2.hpp

@@ -0,0 +1,46 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "visualnovel/scene/SimpleVNScene.hpp"
+#include "scenes/Scene_3.hpp"
+
+namespace Dawn {
+  class Scene_2 : public SimpleVNScene {
+    protected:
+      void vnStage() override {
+        
+      }
+
+      void onSceneEnded() {
+        auto scene = new Scene_3(this->game);
+        game->assetManager.queueSwap(
+          scene->getRequiredAssets(), this->getRequiredAssets()
+        );
+        game->assetManager.syncLoad();
+        scene->stage();
+        this->game->sceneCutover(scene);
+      }
+
+    public:
+      Scene_2(DawnGame *game) : SimpleVNScene(game) {
+        
+      }
+
+      std::vector<Asset*> getRequiredAssets() override {
+        std::vector<Asset*> assets = SimpleVNScene::getRequiredAssets();
+        return assets;
+      }
+
+      IVisualNovelEvent * getVNEvent() override {
+        auto start = new VisualNovelPauseEvent(vnManager, 0.1f);
+        start
+          ->then(new VisualNovelTextboxEvent(vnManager, "scene.2.1"))
+          ->then(new VisualNovelCallbackEvent<Scene_2>(vnManager, this, &Scene_2::onSceneEnded))
+        ;
+        return start;
+      }
+  };
+}

archive/dawnpokergame/scenes/Scene_3.hpp

@@ -0,0 +1,46 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "visualnovel/scene/SimpleVNScene.hpp"
+#include "scenes/Scene_4.hpp"
+
+namespace Dawn {
+  class Scene_3 : public SimpleVNScene {
+    protected:
+      void vnStage() override {
+        
+      }
+
+      void onSceneEnded() {
+        auto scene = new Scene_4(this->game);
+        game->assetManager.queueSwap(
+          scene->getRequiredAssets(), this->getRequiredAssets()
+        );
+        game->assetManager.syncLoad();
+        scene->stage();
+        this->game->sceneCutover(scene);
+      }
+
+    public:
+      Scene_3(DawnGame *game) : SimpleVNScene(game) {
+        
+      }
+
+      std::vector<Asset*> getRequiredAssets() override {
+        std::vector<Asset*> assets = SimpleVNScene::getRequiredAssets();
+        return assets;
+      }
+
+      IVisualNovelEvent * getVNEvent() override {
+        auto start = new VisualNovelPauseEvent(vnManager, 0.1f);
+        start
+          ->then(new VisualNovelTextboxEvent(vnManager, "scene.3.1"))
+          ->then(new VisualNovelCallbackEvent<Scene_3>(vnManager, this, &Scene_3::onSceneEnded))
+        ;
+        return start;
+      }
+  };
+}

archive/dawnpokergame/scenes/Scene_4.hpp

@@ -0,0 +1,66 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "PokerVNScene.hpp"
+#include "prefabs/characters/PennyPrefab.hpp"
+#include "scenes/Scene_5.hpp"
+
+namespace Dawn {
+  class Scene_4 : public PokerVNScene {
+    protected:
+      PennyPrefab *penny;
+      PennyPrefab *julie;
+      PennyPrefab *sammy;
+      PennyPrefab *lucy;
+
+      void vnStage() override {
+        penny = PennyPrefab::create(this);
+        julie = PennyPrefab::create(this);
+        sammy = PennyPrefab::create(this);
+        lucy = PennyPrefab::create(this);
+
+        PokerVNScene::vnStage();
+      }
+
+      void onSceneEnded() {
+        auto scene = new Scene_5(this->game);
+        game->assetManager.queueSwap(
+          scene->getRequiredAssets(), this->getRequiredAssets()
+        );
+        game->assetManager.syncLoad();
+        scene->stage();
+        this->game->sceneCutover(scene);
+      }
+
+      std::vector<PokerPlayer *> getPokerPlayers() override {
+        return std::vector<PokerPlayer*>{
+          this->penny->getComponent<PokerPlayer>(),
+          this->julie->getComponent<PokerPlayer>(),
+          this->sammy->getComponent<PokerPlayer>(),
+          this->lucy->getComponent<PokerPlayer>()
+        };
+      }
+
+    public:
+      Scene_4(DawnGame *game) : PokerVNScene(game) {}
+
+      std::vector<Asset*> getRequiredAssets() override {
+        auto assMan = &this->game->assetManager;
+        std::vector<Asset*> assets;
+        vectorAppend(&assets, PokerVNScene::getRequiredAssets());
+        vectorAppend(&assets, PennyPrefab::getRequiredAssets(assMan));
+        return assets;
+      }
+
+      IVisualNovelEvent * getVNEvent() override {
+        auto start = new VisualNovelTextboxEvent(vnManager, "scene.4.1");
+        start
+          ->then(new VisualNovelCallbackEvent<Scene_4>(vnManager, this, &Scene_4::onSceneEnded))
+        ;
+        return start;
+      }
+  };
+}

archive/dawnpokergame/scenes/Scene_5.hpp

@@ -0,0 +1,46 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "visualnovel/scene/SimpleVNScene.hpp"
+#include "scenes/Scene_6.hpp"
+
+namespace Dawn {
+  class Scene_5 : public SimpleVNScene {
+    protected:
+      void vnStage() override {
+        
+      }
+
+      void onSceneEnded() {
+        auto scene = new Scene_6(this->game);
+        game->assetManager.queueSwap(
+          scene->getRequiredAssets(), this->getRequiredAssets()
+        );
+        game->assetManager.syncLoad();
+        scene->stage();
+        this->game->sceneCutover(scene);
+      }
+
+    public:
+      Scene_5(DawnGame *game) : SimpleVNScene(game) {
+        
+      }
+
+      std::vector<Asset*> getRequiredAssets() override {
+        std::vector<Asset*> assets = SimpleVNScene::getRequiredAssets();
+        return assets;
+      }
+
+      IVisualNovelEvent * getVNEvent() override {
+        auto start = new VisualNovelPauseEvent(vnManager, 0.1f);
+        start
+          ->then(new VisualNovelTextboxEvent(vnManager, "scene.5.1"))
+          ->then(new VisualNovelCallbackEvent<Scene_5>(vnManager, this, &Scene_5::onSceneEnded))
+        ;
+        return start;
+      }
+  };
+}

archive/dawnpokergame/scenes/Scene_6.hpp

@@ -0,0 +1,46 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "visualnovel/scene/SimpleVNScene.hpp"
+#include "scenes/Scene_7.hpp"
+
+namespace Dawn {
+  class Scene_6 : public SimpleVNScene {
+    protected:
+      void vnStage() override {
+        
+      }
+
+      void onSceneEnded() {
+        auto scene = new Scene_7(this->game);
+        game->assetManager.queueSwap(
+          scene->getRequiredAssets(), this->getRequiredAssets()
+        );
+        game->assetManager.syncLoad();
+        scene->stage();
+        this->game->sceneCutover(scene);
+      }
+
+    public:
+      Scene_6(DawnGame *game) : SimpleVNScene(game) {
+        
+      }
+
+      std::vector<Asset*> getRequiredAssets() override {
+        std::vector<Asset*> assets = SimpleVNScene::getRequiredAssets();
+        return assets;
+      }
+
+      IVisualNovelEvent * getVNEvent() override {
+        auto start = new VisualNovelPauseEvent(vnManager, 0.1f);
+        start
+          ->then(new VisualNovelTextboxEvent(vnManager, "scene.6.1"))
+          ->then(new VisualNovelCallbackEvent<Scene_6>(vnManager, this, &Scene_6::onSceneEnded))
+        ;
+        return start;
+      }
+  };
+}

archive/dawnpokergame/scenes/Scene_7.hpp

@@ -0,0 +1,45 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "visualnovel/scene/SimpleVNScene.hpp"
+#include "scenes/Scene_8.hpp"
+
+namespace Dawn {
+  class Scene_7 : public SimpleVNScene {
+    protected:
+      void vnStage() override {
+        
+      }
+
+      void onSceneEnded() {
+        auto scene = new Scene_8(this->game);
+        game->assetManager.queueSwap(
+          scene->getRequiredAssets(), this->getRequiredAssets()
+        );
+        game->assetManager.syncLoad();
+        scene->stage();
+        this->game->sceneCutover(scene);
+      }
+
+    public:
+      Scene_7(DawnGame *game) : SimpleVNScene(game) {
+      }
+
+      std::vector<Asset*> getRequiredAssets() override {
+        std::vector<Asset*> assets = SimpleVNScene::getRequiredAssets();
+        return assets;
+      }
+
+      IVisualNovelEvent * getVNEvent() override {
+        auto start = new VisualNovelPauseEvent(vnManager, 0.1f);
+        start
+          ->then(new VisualNovelTextboxEvent(vnManager, "scene.7.1"))
+          ->then(new VisualNovelCallbackEvent<Scene_7>(vnManager, this, &Scene_7::onSceneEnded))
+        ;
+        return start;
+      }
+  };
+}

archive/dawnpokergame/scenes/Scene_8.hpp

@@ -0,0 +1,66 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "PokerVNScene.hpp"
+#include "prefabs/characters/PennyPrefab.hpp"
+#include "scenes/Scene_9.hpp"
+
+namespace Dawn {
+  class Scene_8 : public PokerVNScene {
+    protected:
+      PennyPrefab *penny;
+      PennyPrefab *julie;
+      PennyPrefab *sammy;
+      PennyPrefab *lucy;
+
+      void vnStage() override {
+        penny = PennyPrefab::create(this);
+        julie = PennyPrefab::create(this);
+        sammy = PennyPrefab::create(this);
+        lucy = PennyPrefab::create(this);
+
+        PokerVNScene::vnStage();
+      }
+
+      void onSceneEnded() {
+        auto scene = new Scene_9(this->game);
+        game->assetManager.queueSwap(
+          scene->getRequiredAssets(), this->getRequiredAssets()
+        );
+        game->assetManager.syncLoad();
+        scene->stage();
+        this->game->sceneCutover(scene);
+      }
+
+      std::vector<PokerPlayer *> getPokerPlayers() override {
+        return std::vector<PokerPlayer*>{
+          this->penny->getComponent<PokerPlayer>(),
+          this->julie->getComponent<PokerPlayer>(),
+          this->sammy->getComponent<PokerPlayer>(),
+          this->lucy->getComponent<PokerPlayer>()
+        };
+      }
+
+    public:
+      Scene_8(DawnGame *game) : PokerVNScene(game) {}
+
+      std::vector<Asset*> getRequiredAssets() override {
+        auto assMan = &this->game->assetManager;
+        std::vector<Asset*> assets;
+        vectorAppend(&assets, PokerVNScene::getRequiredAssets());
+        vectorAppend(&assets, PennyPrefab::getRequiredAssets(assMan));
+        return assets;
+      }
+
+      IVisualNovelEvent * getVNEvent() override {
+        auto start = new VisualNovelTextboxEvent(vnManager, "scene.8.1");
+        start
+          ->then(new VisualNovelCallbackEvent<Scene_8>(vnManager, this, &Scene_8::onSceneEnded))
+        ;
+        return start;
+      }
+  };
+}

archive/dawnpokergame/scenes/Scene_9.hpp

@@ -0,0 +1,45 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "visualnovel/scene/SimpleVNScene.hpp"
+#include "scenes/Scene_10.hpp"
+
+namespace Dawn {
+  class Scene_9 : public SimpleVNScene {
+    protected:
+      void vnStage() override {
+        
+      }
+
+      void onSceneEnded() {
+        auto scene = new Scene_10(this->game);
+        game->assetManager.queueSwap(
+          scene->getRequiredAssets(), this->getRequiredAssets()
+        );
+        game->assetManager.syncLoad();
+        scene->stage();
+        this->game->sceneCutover(scene);
+      }
+
+    public:
+      Scene_9(DawnGame *game) : SimpleVNScene(game) {
+      }
+
+      std::vector<Asset*> getRequiredAssets() override {
+        std::vector<Asset*> assets = SimpleVNScene::getRequiredAssets();
+        return assets;
+      }
+
+      IVisualNovelEvent * getVNEvent() override {
+        auto start = new VisualNovelPauseEvent(vnManager, 0.1f);
+        start
+          ->then(new VisualNovelTextboxEvent(vnManager, "scene.9.1"))
+          ->then(new VisualNovelCallbackEvent<Scene_9>(vnManager, this, &Scene_9::onSceneEnded))
+        ;
+        return start;
+      }
+  };
+}

archive/dawnpokergame/scenes/TestScene.hpp

@@ -0,0 +1,57 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "PokerVNScene.hpp"
+#include "prefabs/characters/PennyPrefab.hpp"
+
+namespace Dawn {
+  class TestScene : public PokerVNScene {
+    protected:
+      PennyPrefab *penny;
+      PennyPrefab *julie;
+      PennyPrefab *sammy;
+      PennyPrefab *lucy;
+
+      void vnStage() override {
+        penny = PennyPrefab::create(this);
+        julie = PennyPrefab::create(this);
+        sammy = PennyPrefab::create(this);
+        lucy = PennyPrefab::create(this);
+
+        PokerVNScene::vnStage();
+      }
+
+      std::vector<PokerPlayer *> getPokerPlayers() override {
+        return std::vector<PokerPlayer*>{
+          this->penny->getComponent<PokerPlayer>(),
+          this->julie->getComponent<PokerPlayer>(),
+          this->sammy->getComponent<PokerPlayer>(),
+          this->lucy->getComponent<PokerPlayer>()
+        };
+      }
+
+    public:
+      TestScene(DawnGame *game) : PokerVNScene(game) {}
+
+      std::vector<Asset*> getRequiredAssets() override {
+        auto assMan = &this->game->assetManager;
+        std::vector<Asset*> assets;
+        vectorAppend(&assets, PokerVNScene::getRequiredAssets());
+        vectorAppend(&assets, PennyPrefab::getRequiredAssets(assMan));
+        assets.push_back(assMan->get<TextureAsset>("texture_tavern_night"));
+        return assets;
+      }
+
+      IVisualNovelEvent * getVNEvent() override {
+        auto texture = this->game->assetManager.get<TextureAsset>("texture_tavern_night");
+        auto start = new VisualNovelChangeSimpleBackgroundEvent(
+          vnManager, &texture->texture
+        );
+        start->then(new VisualNovelTextboxEvent(vnManager, penny->getComponent<VisualNovelCharacter>(), "1234"));
+        return start;
+      }
+  };
+}

archive/dawnpokergame/ui/CMakeLists.txt

@@ -0,0 +1,10 @@
+# Copyright (c) 2022 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    PokerPlayerDisplay.cpp
+)

archive/dawnpokergame/ui/PokerGameBorder.hpp

@@ -0,0 +1,32 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "ui/UIBorder.hpp"
+#include "asset/assets/TextureAsset.hpp"
+#include "game/DawnGame.hpp"
+
+namespace Dawn {
+  class PokerGameBorder {
+    public:
+      static std::vector<Asset*> getAssets(AssetManager *man) {
+        return std::vector<Asset*>{
+          man->get<TextureAsset>("texture_test")
+        };
+      }
+
+      static void apply(UIBorder *border) {
+        auto text = border->getGame()->assetManager.get<TextureAsset>("texture_test");
+        border->texture = &text->texture;
+        border->setBorderSize(glm::vec2(16, 16));
+      }
+
+      static UIBorder * create(UICanvas *canvas) {
+        auto border = canvas->addElement<UIBorder>();
+        PokerGameBorder::apply(border);
+        return border;
+      }
+  };
+}

archive/dawnpokergame/ui/PokerGameTextbox.hpp

@@ -0,0 +1,46 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "ui/PokerGameBorder.hpp"
+#include "visualnovel/ui/VisualNovelTextbox.hpp"
+#include "asset/assets/TrueTypeAsset.hpp"
+
+namespace Dawn {
+  class PokerGameTextbox {
+    public:
+      static std::vector<Asset*> getAssets(AssetManager *man) {
+        assertNotNull(man);
+
+        std::vector<Asset*> assets;
+        vectorAppend(&assets, &PokerGameBorder::getAssets(man));
+        assets.push_back(man->get<TrueTypeAsset>("truetype_ark"));
+        return assets;
+      }
+
+      static void apply(VisualNovelTextbox *textbox) {
+        assertNotNull(textbox);
+
+        auto assetFont = textbox->getGame()->assetManager.get<TrueTypeAsset>("truetype_ark");
+        PokerGameBorder::apply(&textbox->border);
+        textbox->setFont(&assetFont->font);
+        textbox->setFontSize(40);
+        textbox->setLabelPadding(glm::vec2(10, 8));
+      }
+
+      static VisualNovelTextbox * create(UICanvas *canvas) {
+        assertNotNull(canvas);
+        
+        auto textbox = canvas->addElement<VisualNovelTextbox>();
+        PokerGameTextbox::apply(textbox);
+        textbox->setTransform(
+          UI_COMPONENT_ALIGN_STRETCH, UI_COMPONENT_ALIGN_END,
+          glm::vec4(0, 238, 0, 0),
+          0.0f
+        );
+        return textbox;
+      }
+  };
+}

archive/dawnpokergame/ui/PokerPlayerDisplay.cpp

@@ -0,0 +1,101 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "PokerPlayerDisplay.hpp"
+#include "game/DawnGame.hpp"
+
+using namespace Dawn;
+
+PokerPlayerDisplay::PokerPlayerDisplay(UICanvas *canvas) :
+  UIEmpty(canvas),
+  labelName(canvas),
+  labelChips(canvas),
+  borderInner(canvas),
+  border(canvas),
+  animChips(&animChipsValue)
+{
+  this->font = getGame()->assetManager.get<TrueTypeAsset>("truetype_ark");
+
+  // Border
+  this->addChild(&this->border);
+  PokerGameBorder::apply(&this->border);
+  this->border.setTransform(
+    UI_COMPONENT_ALIGN_STRETCH, UI_COMPONENT_ALIGN_STRETCH,
+    glm::vec4(0, 0, 0, 0),
+    0.0f
+  );
+
+  // Border Inner
+  this->addChild(&this->borderInner);
+  this->borderInner.setTransform(
+    UI_COMPONENT_ALIGN_STRETCH, UI_COMPONENT_ALIGN_STRETCH,
+    glm::vec4(this->border.getBorderSize(), this->border.getBorderSize()),
+    0.0f
+  );
+
+  // Player Name
+  this->borderInner.addChild(&this->labelName); 
+  this->labelName.setText("undefined");
+  this->labelName.setFont(&this->font->font);
+  this->labelName.setFontSize(40);
+  this->labelName.setTransform(
+    UI_COMPONENT_ALIGN_START, UI_COMPONENT_ALIGN_START, 
+    glm::vec4(0, 0, 0, 0),
+    0.0f
+  );
+
+  // Chips label
+  this->borderInner.addChild(&this->labelChips);
+  this->labelChips.setFont(&this->font->font);
+  this->labelChips.setFontSize(40);
+  this->labelChips.setTransform(
+    UI_COMPONENT_ALIGN_START, UI_COMPONENT_ALIGN_START, 
+    glm::vec4(0, this->labelName.getContentHeight(), 0, 0),
+    0.0f
+  );
+
+  // Anim
+  this->animChips.easing = &easeOutQuart;
+
+  // Events
+  getScene()->eventSceneUnpausedUpdate.addListener(this, &PokerPlayerDisplay::onSceneUpdate);
+}
+
+void PokerPlayerDisplay::setPlayer(PokerPlayer *player) {
+  assertNull(this->player);
+  this->player = player;
+
+  player->eventChipsChanged.addListener(this, &PokerPlayerDisplay::onPlayerChipsChanged);
+
+  this->labelName.setText("undefined");
+  this->animChips.clear();
+  this->animChips.restart();
+  this->animChipsValue = player->chips;
+
+  this->updatePositions();
+}
+
+void PokerPlayerDisplay::onSceneUpdate() {
+  this->animChips.tick(getGame()->timeManager.delta);
+
+  // std::stringstream stream;
+  // stream.precision(0);
+  // stream << "$";
+  // stream << this->animChipsValue;
+  this->labelChips.setText("undefined");
+}
+
+void PokerPlayerDisplay::onPlayerChipsChanged() {
+  std::cout << "Chips" << player->chips << std::endl;
+
+  this->animChips.clear();
+  this->animChips.addKeyframe(0.0f, this->animChipsValue);
+  this->animChips.addKeyframe(1.0f, this->player->chips);
+  this->animChips.restart();
+}
+
+PokerPlayerDisplay::~PokerPlayerDisplay() {
+  this->canvas->getScene()->eventSceneUnpausedUpdate.removeListener(this, &PokerPlayerDisplay::onSceneUpdate);
+}

archive/dawnpokergame/ui/PokerPlayerDisplay.hpp

@@ -0,0 +1,48 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "ui/UILabel.hpp"
+#include "ui/UIEmpty.hpp"
+#include "ui/UIBorder.hpp"
+#include "poker/PokerPlayer.hpp"
+#include "asset/AssetManager.hpp"
+#include "asset/assets/TrueTypeAsset.hpp"
+#include "display/animation/SimpleAnimation.hpp"
+#include "ui/PokerGameBorder.hpp"
+
+namespace Dawn {
+  class PokerPlayerDisplay : public UIEmpty {
+    private:
+      SimpleAnimation<int32_t> animChips;
+      int32_t animChipsValue;
+
+    protected:
+      PokerPlayer *player = nullptr;
+      UILabel labelName;
+      UILabel labelChips;
+      UIEmpty borderInner;
+      UIBorder border;
+
+      TrueTypeAsset *font;
+
+      void onPlayerChipsChanged();
+      void onSceneUpdate();
+
+    public:
+      static std::vector<Asset*> getAssets(AssetManager *assMan) {
+        std::vector<Asset*> assets;
+        assets = PokerGameBorder::getAssets(assMan);
+        assets.push_back(assMan->get<TrueTypeAsset>("truetype_alice"));
+        return assets;
+      }
+
+      PokerPlayerDisplay(UICanvas *canvas);
+
+      void setPlayer(PokerPlayer *player);
+
+      ~PokerPlayerDisplay();
+  };
+}

archive/dawnpokergame/visualnovel/CMakeLists.txt

@@ -0,0 +1,13 @@
+# Copyright (c) 2022 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    VNPlayer.cpp
+)
+
+# Subdirs
+add_subdirectory(events)

archive/dawnpokergame/visualnovel/VNPlayer.cpp

@@ -0,0 +1,12 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "VNPlayer.hpp"
+
+using namespace Dawn;
+
+VNPlayer::VNPlayer(SceneItem *item) : SceneItemComponent(item) {
+  
+}

archive/dawnpokergame/visualnovel/VNPlayer.hpp

@@ -0,0 +1,18 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnlibs.hpp"
+#include "scene/SceneItemComponent.hpp"
+
+namespace Dawn {
+  class VNPlayer : public SceneItemComponent {
+    protected:
+      
+
+    public:
+      VNPlayer(SceneItem *item);
+  };
+}

archive/dawnpokergame/visualnovel/events/CMakeLists.txt

@@ -0,0 +1,10 @@
+# Copyright (c) 2022 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    PokerBetLoopEvent.cpp
+)

archive/dawnpokergame/visualnovel/events/PokerBetLoopEvent.cpp

@@ -0,0 +1,64 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "PokerBetLoopEvent.hpp"
+#include "PokerInitialEvent.hpp"
+
+using namespace Dawn;
+
+void PokerBetLoopEvent::onStart(IVisualNovelEvent *prev) {
+  PokerGameEvent::onStart(prev);
+  std::cout << "Bet Loop, bet" << std::endl;
+
+  auto evt2 = new PokerDetermineBetterEvent(this->manager);
+
+  auto betting = this->then(evt2);
+  betting
+    // ->whenEveryoneFolded(new VisualNovelTextboxEvent(this->manager, "Everyone Folded"))
+    ->then(new PokerWinnerEvent(this->manager))
+    ->then(new PokerInitialEvent(this->manager))
+  ;
+  betting
+    // ->whenBettingFinished(new VisualNovelTextboxEvent(this->manager, "Betting Finished"))
+    ->then(new PokerWinnerEvent(this->manager))
+    ->then(new PokerInitialEvent(this->manager))
+  ;
+  betting
+    ->whenTurn(new PokerTurnEvent(this->manager))
+    // ->then(new VisualNovelTextboxEvent(this->manager, "Turn Time"))
+    ->then(new PokerNewBettingRoundEvent(this->manager))
+    ->then(new PokerBetLoopEvent(this->manager))
+  ;
+  betting
+    // ->whenHumanBet(new VisualNovelTextboxEvent(this->manager, "Human Bet"))
+    ->then(new PokerBetLoopEvent(this->manager))
+  ;
+
+  // AI Betting
+  auto aiBet = betting
+    // ->whenAiBet(new VisualNovelTextboxEvent(this->manager, "AI Bet"))
+    ->then(new PokerAIBetEvent(this->manager))
+  ;
+  aiBet
+    // ->whenFolded(new VisualNovelTextboxEvent(this->manager, "Folded"))
+    ->then(new PokerBetLoopEvent(this->manager))
+  ;
+  aiBet
+    // ->whenAllIn(new VisualNovelTextboxEvent(this->manager, "All In"))
+    ->then(new PokerBetLoopEvent(this->manager))
+  ;
+  aiBet
+    // ->whenBetting(new VisualNovelTextboxEvent(this->manager, "Betting"))
+    ->then(new PokerBetLoopEvent(this->manager))
+  ;
+  aiBet
+    // ->whenCalling(new VisualNovelTextboxEvent(this->manager, "Calling"))
+    ->then(new PokerBetLoopEvent(this->manager))
+  ;
+  aiBet
+    // ->whenChecking(new VisualNovelTextboxEvent(this->manager, "Checking"))
+    ->then(new PokerBetLoopEvent(this->manager))
+  ;
+}

archive/dawnpokergame/visualnovel/events/PokerBetLoopEvent.hpp

@@ -0,0 +1,36 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "poker/visualnovel/PokerNewGameEvent.hpp"
+#include "poker/visualnovel/PokerNewRoundEvent.hpp"
+#include "poker/visualnovel/PokerTakeBlindsEvent.hpp"
+#include "poker/visualnovel/PokerDealEvent.hpp"
+#include "poker/visualnovel/PokerTurnEvent.hpp"
+#include "poker/visualnovel/PokerDetermineBetterEvent.hpp"
+#include "poker/visualnovel/PokerAIBetEvent.hpp"
+#include "poker/visualnovel/PokerNewBettingRoundEvent.hpp"
+#include "poker/visualnovel/PokerWinnerEvent.hpp"
+
+#define POKER_DEAL_EVENT_CARD_COUNT 2
+
+namespace Dawn {
+  class PokerBetLoopEvent : public PokerGameEvent {
+    protected:
+      void onStart(IVisualNovelEvent *previous) override;
+
+      bool_t onUpdate() override {
+        return false;
+      }
+
+      void onEnd() override {
+        std::cout << "Bet lop fin" << std::endl;
+      }
+
+    public:
+      PokerBetLoopEvent(VisualNovelManager *manager) : PokerGameEvent(manager) {
+      }
+  };
+}

archive/dawnpokergame/visualnovel/events/PokerInitialEvent.hpp

@@ -0,0 +1,43 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "poker/visualnovel/PokerNewRoundEvent.hpp"
+#include "poker/visualnovel/PokerDealEvent.hpp"
+#include "poker/visualnovel/PokerTakeBlindsEvent.hpp"
+#include "PokerBetLoopEvent.hpp"
+#include "visualnovel/events/VisualNovelTextboxEvent.hpp"
+
+#define POKER_DEAL_EVENT_CARD_COUNT 2
+
+namespace Dawn {
+  class PokerInitialEvent : public PokerGameEvent {
+    protected:
+      void onStart(IVisualNovelEvent *previous) override {
+        PokerGameEvent::onStart(previous);
+        
+        this
+          ->then(new PokerNewRoundEvent(this->manager))
+          // ->then(new VisualNovelTextboxEvent(this->manager, "Round Started"))
+          ->then(new PokerTakeBlindsEvent(this->manager))
+          // ->then(new VisualNovelTextboxEvent(this->manager, "Blinds Taken"))
+          ->then(new PokerDealEvent(this->manager))
+          // ->then(new VisualNovelTextboxEvent(this->manager, "Cards Dealt"))
+          ->then(new PokerBetLoopEvent(this->manager))
+        ;
+      }
+
+      bool_t onUpdate() override {
+        return false;
+      }
+
+      void onEnd() override {
+      }
+
+    public:
+      PokerInitialEvent(VisualNovelManager *manager) : PokerGameEvent(manager) {
+      }
+  };
+}