feat: add summon menu

include/game/Mobs.h

@@ -27,7 +27,9 @@ enum class MobType : std::uint8_t {
     Blaze,
     Witch,
     Slime,
-    Giant
+    Giant,
+
+    MOB_COUNT
 };
 
 typedef std::uint32_t MobID;
@@ -132,6 +134,62 @@ public:
     virtual MobType getType() const { return MobType::Spider; }
 };
 
+class Skeleton : public Mob {
+public:
+    Skeleton(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { initHealth(); }
+
+    virtual MobType getType() const { return MobType::Skeleton; }
+};
+
+class PigMan : public Mob {
+public:
+    PigMan(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { initHealth(); }
+
+    virtual MobType getType() const { return MobType::Pigman; }
+};
+
+class Creeper : public Mob {
+public:
+    Creeper(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { initHealth(); }
+
+    virtual MobType getType() const { return MobType::Creeper; }
+};
+
+class Silverfish : public Mob {
+public:
+    Silverfish(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { initHealth(); }
+
+    virtual MobType getType() const { return MobType::Silverfish; }
+};
+
+class Blaze : public Mob {
+public:
+    Blaze(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { initHealth(); }
+
+    virtual MobType getType() const { return MobType::Blaze; }
+};
+
+class Witch : public Mob {
+public:
+    Witch(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { initHealth(); }
+
+    virtual MobType getType() const { return MobType::Witch; }
+};
+
+class Slime : public Mob {
+public:
+    Slime(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { initHealth(); }
+
+    virtual MobType getType() const { return MobType::Slime; }
+};
+
+class Giant : public Mob {
+public:
+    Giant(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { initHealth(); }
+
+    virtual MobType getType() const { return MobType::Giant; }
+};
+
 namespace MobFactory {
 MobPtr createMob(MobID id, MobType type, std::uint8_t level, PlayerID sender);
 }

include/game/client/Client.h

@@ -6,6 +6,8 @@
 #include "game/Team.h"
 #include "game/Player.h"
 
+#include "protocol/Protocol.h"
+
 #include "render/Renderer.h"
 
 #include "network/Network.h"
@@ -39,6 +41,7 @@ public:
     bool isConnected() const { return m_Connexion.getSocketStatus() == network::Socket::Connected; }
 
     void selectTeam(game::TeamColor team);
+    void sendMobs(const std::vector<protocol::MobSend>& mobSends);
 };
 
 } // namespace client

include/game/server/ServerConnexion.h

@@ -38,6 +38,7 @@ public:
     virtual void HandlePacket(protocol::SelectTeamPacket* packet);
     virtual void HandlePacket(protocol::DisconnectPacket* packet);
     virtual void HandlePacket(protocol::PlaceTowerPacket* packet);
+    virtual void HandlePacket(protocol::SendMobsPacket* packet);
 
     std::uint8_t getID() const { return m_ID; }
     const game::Player* getPlayer() const { return m_Player; }

include/protocol/PacketHandler.h

@@ -36,6 +36,7 @@ public:
     virtual void HandlePacket(PlaceTowerPacket* packet) {}
     virtual void HandlePacket(WorldAddTowerPacket* packet) {}
     virtual void HandlePacket(WorldRemoveTowerPacket* packet) {}
+    virtual void HandlePacket(SendMobsPacket* packet) {}
 };
 
 } // namespace protocol

include/protocol/Protocol.h

@@ -28,6 +28,7 @@ enum class PacketType : std::uint8_t {
     UpdatePlayerTeam,
     ServerTps,
     SpawnMob,
+    SendMobs,
     PlaceTower,
     WorldAddTower,
     WorldRemoveTower,
@@ -369,6 +370,29 @@ public:
     virtual PacketType getType() const { return PacketType::ServerTps; }
 };
 
+struct MobSend { // represents a mob send
+    game::MobType mobType;
+    game::MobLevel mobLevel;
+    std::uint8_t mobCount; // the max is 12
+};
+
+class SendMobsPacket : public Packet {
+private:
+    std::vector<MobSend> m_MobSends;
+public:
+    SendMobsPacket() {}
+    SendMobsPacket(const std::vector<MobSend>& mobSends) : m_MobSends(mobSends) {}
+    virtual ~SendMobsPacket() {}
+
+    virtual DataBuffer Serialize() const;
+    virtual void Deserialize(DataBuffer& data);
+    virtual void Dispatch(PacketHandler* handler);
+
+    const std::vector<MobSend>& getMobSends() const { return m_MobSends; }
+
+    virtual PacketType getType() const { return PacketType::SendMobs; }
+};
+
 class SpawnMobPacket : public Packet {
 private:
     game::MobID m_MobID;

include/render/gui/GuiManager.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "GuiWidget.h"
+
+#include <vector>
+#include <memory>
+
+namespace td {
+namespace gui {
+
+class GuiManager {
+private:
+    std::vector<std::shared_ptr<GuiWidget>> m_Widgets;
+public:
+    void renderWidgets(){
+        for(auto widget : m_Widgets){
+            widget->render();
+        }
+    }
+
+    void addWidgets(const std::shared_ptr<GuiWidget>& widget){
+        m_Widgets.push_back(std::move(widget));
+    }
+};
+
+} // namespace gui
+} // namespace td

include/render/gui/GuiWidget.h

@@ -0,0 +1,25 @@
+#pragma once
+
+namespace td {
+
+namespace client {
+class Client;
+} // namespace client
+
+namespace gui {
+
+class GuiWidget {
+protected:
+    client::Client* m_Client;
+public:
+    GuiWidget(client::Client* client) {
+        m_Client = client;
+    }
+
+    client::Client* getClient() { return m_Client; }
+
+    virtual void render() = 0;
+};
+
+} // namespace gui
+} // namespace td

include/render/gui/SummonMenu.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "GuiWidget.h"
+
+#include <array>
+#include "game/Mobs.h"
+
+namespace td {
+namespace gui {
+
+class SummonMenu : public GuiWidget{
+private:
+    bool m_MenuOpened;
+    int m_ImageWidth = 100;
+    static constexpr int m_MobTypeCount = static_cast<std::size_t>(td::game::MobType::MOB_COUNT);
+    std::array<int, static_cast<std::size_t>(m_MobTypeCount)> m_Values;
+public:
+    SummonMenu(client::Client* client);
+
+    virtual void render();
+private:
+    void setSummonMax(int valueIndex);
+};
+
+} // namespace gui  
+} // namespace td