Basic arena working that lets me work on the boss fight system quicker.

tools/arena.cpp

@@ -1,45 +1,77 @@
-#include "arena_fsm.hpp"
+#include "gui/fsm.hpp"
 #include "textures.hpp"
 #include "sound.hpp"
+#include "autowalker.hpp"
 #include "ai.hpp"
 #include "animation.hpp"
 #include <iostream>
+#include "shaders.hpp"
+#include "backend.hpp"
+#include "game_level.hpp"
+#include "boss/system.hpp"
+#include "gui/fsm_events.hpp"
+#include "events.hpp"
+#include "constants.hpp"
+#include "gui/event_router.hpp"
 
-int main(int argc, char* argv[]) {
-  try {
-    dbc::check(argc == 2, "USAGE: arena enemy_name");
-    std::string enemy_name{argv[1]};
+void craft_weapon() {
+  auto world = GameDB::current_world();
+  auto& the_belt = world->get_the<ritual::Belt>();
+  ritual::Action action{1.0, 20, ritual::Kind::MAGICK, ritual::Element::FIRE, {"fake"}};
+  the_belt.equip(the_belt.next(), action);
+}
 
-    textures::init();
-    sound::init();
-    ai::init("ai");
-    animation::init();
+int main(int, char*[]) {
+  components::init();
+  sfml::Backend backend;
+  guecs::init(&backend);
+  ai::init("ai");
+  animation::init();
+  GameDB::init();
 
-    sound::mute(false);
-    sound::play("ambient_1", true);
+  sf::RenderWindow window(sf::VideoMode({SCREEN_WIDTH, SCREEN_HEIGHT}), "Bossfight Testing Arena");
+  gui::routing::Router router;
 
-    arena::FSM main(enemy_name);
+  sound::mute(true);
+  sound::play("ambient_1", true);
 
-    main.event(arena::Event::STARTED);
+  GameDB::create_level();
+  craft_weapon();
 
-    while(main.active()) {
-      main.render();
+  auto main = boss::System::create_bossfight();
+  auto world = GameDB::current_world();
 
-      // ZED: need to sort out how to deal with this in the FSM
-      if(main.in_state(arena::State::IDLE)) {
-        main.event(arena::Event::TICK);
+
+  while(!main->in_state(boss::State::END)) {
+    main->mouse_pos = window.mapPixelToCoords(router.position);
+
+    while(const auto ev = window.pollEvent()) {
+      auto gui_ev = router.process_event(ev);
+
+      if(gui_ev == gui::Event::QUIT || main->event(gui_ev, {})) {
+        return 0;
+      } else {
+        main->event(gui::Event::TICK, {});
       }
-
-      main.keyboard_mouse();
-
-      main.handle_world_events();
     }
 
-    return 0;
-  } catch(const std::system_error& e) {
-    std::cout << "WARNING: On OSX you'll get this error on shutdown.\n";
-    std::cout << "Caught system_error with code "
-                 "[" << e.code() << "] meaning "
-                 "[" << e.what() << "]\n";
+    while(world->has_event<Events::GUI>()) {
+      auto [evt, entity, data] = world->recv<Events::GUI>();
+
+      // FIX YOUR DAMN EVENTS
+      switch(evt) {
+        case Events::GUI::ATTACK:
+          main->event(gui::Event::ATTACK, data);
+          break;
+        default:
+          fmt::println("GUI EVENT: {} entity={}", int(evt), entity);
+      }
+    }
+
+    window.clear();
+    main->render(window);
+    window.display();
   }
+
+  return 0;
 }

tools/arena_fsm.cpp

@@ -1,121 +0,0 @@
-#include "gui_fsm.hpp"
-#include <iostream>
-#include <chrono>
-#include <numeric>
-#include <functional>
-#include "components.hpp"
-#include <numbers>
-#include "systems.hpp"
-#include "events.hpp"
-#include "sound.hpp"
-#include <fmt/xchar.h>
-#include "arena_fsm.hpp"
-
-namespace arena {
-  using namespace components;
-
-  FSM::FSM(std::string enemy_name) :
-    $enemy_name(enemy_name),
-    $window(sf::VideoMode({SCREEN_WIDTH, SCREEN_HEIGHT}), "Arena Battle Tester"),
-    $font{FONT_FILE_NAME}
-    {
-    }
-
-  void FSM::event(Event ev) {
-    switch($state) {
-      FSM_STATE(State, START, ev);
-      FSM_STATE(State, IDLE, ev);
-      FSM_STATE(State, END, ev);
-    }
-  }
-
-  void FSM::START(Event ) {
-    run_systems();
-    dbc::sentinel("THIS IS FUCKED");
-    $level = $level_mgr.current();
-
-    auto entity_id = $level_mgr.spawn_enemy($enemy_name);
-
-    $arena_ui = make_shared<ArenaUI>($level.world, entity_id);
-    $arena_ui->init();
-    state(State::IDLE);
-  }
-
-  void FSM::END(Event ev) {
-    dbc::log(fmt::format("END: received event after done: {}", int(ev)));
-  }
-
-  void FSM::IDLE(Event ev) {
-    using enum Event;
-
-    switch(ev) {
-      case QUIT:
-        $window.close();
-        state(State::END);
-        return; // done
-      case CLOSE:
-        dbc::log("Nothing to close.");
-        break;
-      case TICK:
-        // do nothing
-        break;
-      case ATTACK:
-        dbc::log("ATTACK!");
-        break;
-      default:
-        dbc::sentinel("unhandled event in IDLE");
-    }
-  }
-
-  void FSM::keyboard_mouse() {
-    while(const auto ev = $window.pollEvent()) {
-      if(ev->is<sf::Event::Closed>()) {
-        event(Event::QUIT);
-      }
-
-      if(const auto* mouse = ev->getIf<sf::Event::MouseButtonPressed>()) {
-        if(mouse->button == sf::Mouse::Button::Left) {
-          sf::Vector2f pos = $window.mapPixelToCoords(mouse->position);
-          (void)pos;
-        }
-      }
-
-      if(const auto* key = ev->getIf<sf::Event::KeyPressed>()) {
-        using KEY = sf::Keyboard::Scan;
-
-        switch(key->scancode) {
-          case KEY::Escape:
-            event(Event::CLOSE);
-            break;
-          case KEY::Space:
-            event(Event::ATTACK);
-            break;
-          default:
-            break; // ignored
-        }
-      }
-    }
-  }
-
-  void FSM::draw_gui() {
-    if($arena_ui != nullptr) {
-      $arena_ui->render($window);
-    }
-  }
-
-  void FSM::render() {
-    $window.clear();
-    draw_gui();
-    $window.display();
-  }
-
-  void FSM::run_systems() {
-  }
-
-  bool FSM::active() {
-    return !in_state(State::END);
-  }
-
-  void FSM::handle_world_events() {
-  }
-}

tools/arena_fsm.hpp

@@ -1,49 +0,0 @@
-#pragma once
-#include "constants.hpp"
-#include "stats.hpp"
-#include "fsm.hpp"
-#include "main_ui.hpp"
-#include "combat_ui.hpp"
-#include "status_ui.hpp"
-#include "arena_ui.hpp"
-#include "map_view.hpp"
-#include "mini_map.hpp"
-
-namespace arena {
-  enum class State {
-    START,
-    IDLE,
-    END
-  };
-
-  enum class Event {
-    STARTED=0,
-    TICK=1,
-    CLOSE = 7,
-    ATTACK = 10,
-    QUIT = 14
-  };
-
-  class FSM : public DeadSimpleFSM<State, Event> {
-    public:
-      std::string $enemy_name;
-      sf::RenderWindow $window;
-      sf::Font $font;
-      shared_ptr<arena::ArenaUI> $arena_ui = nullptr;
-
-      FSM(std::string enemy_name);
-
-      void event(Event ev);
-      void START(Event );
-      void IDLE(Event ev);
-      void END(Event ev);
-
-      void try_move(int dir, bool strafe);
-      void keyboard_mouse();
-      void draw_gui();
-      void render();
-      bool active();
-      void run_systems();
-      void handle_world_events();
-  };
-}