feat: implement basic tower placement

include/game/Towers.h

@@ -18,7 +18,9 @@ enum class TowerType : std::uint8_t{
 
     Leach,
     Turret,
-    Necromancer
+    Necromancer,
+
+    TowerCount
 };
 
 enum class TowerSize : bool{
@@ -64,8 +66,8 @@ public:
 
     // operator to sort maps
     friend bool operator<(const TowerLevel& level, const TowerLevel& other){
-        return level.getLevel() * (std::uint8_t)level.getPath() <
-            other.getLevel() * (std::uint8_t)other.getPath();
+        return level.getLevel() * static_cast<std::uint8_t>(level.getPath()) <
+            other.getLevel() * static_cast<std::uint8_t>(other.getPath());
     }
 };
 

include/game/client/Client.h

@@ -18,10 +18,14 @@ private:
     ClientGame m_Game;
     bool m_Connected;
 public:
-    Client(render::Renderer* renderer) : m_Renderer(renderer), m_Game(m_Connexion.GetDispatcher(), m_Renderer), m_Connected(false){}
+    Client(render::Renderer* renderer) : m_Renderer(renderer), m_Game(this), m_Connected(false){}
 
     const ClientGame& getGame() const{ return m_Game; }
     const ClientConnexion& getConnexion() const{ return m_Connexion; }
+    render::Renderer* getRenderer() const {return m_Renderer;}
+
+    ClientGame& getGame(){ return m_Game; }
+    ClientConnexion& getConnexion(){ return m_Connexion; }
 
     void tick(std::uint64_t delta);
 

include/game/client/ClientGame.h

@@ -12,8 +12,11 @@
 namespace td {
 namespace client {
 
+class Client;
+
 class ClientGame : public protocol::PacketHandler, public game::Game{
 private:
+    Client* m_Client;
     std::uint8_t m_ConnexionID;
     std::uint32_t m_LobbyTime = 0;
     game::Player* m_Player = nullptr;
@@ -21,7 +24,7 @@ private:
     client::WorldClient m_WorldClient;
     render::WorldRenderer m_WorldRenderer;
 public:
-    ClientGame(protocol::PacketDispatcher* dispatcher, render::Renderer* renderer);
+    ClientGame(Client* client);
     virtual ~ClientGame();
 
     virtual void tick(std::uint64_t delta);
@@ -31,6 +34,13 @@ public:
     std::uint32_t getLobbyTime() const{return m_LobbyTime;}
     const game::Player* getPlayer() const{return m_Player;}
 
+    render::Renderer* getRenderer() const {return m_Renderer;}
+
+    void PlaceTower(game::TowerType type, const glm::vec2& position);
+
+    bool CanPlaceLittleTower(const glm::vec2& worldPos);
+    bool CanPlaceBigTower(const glm::vec2& worldPos);
+
     virtual void HandlePacket(protocol::ConnexionInfoPacket* packet);
     virtual void HandlePacket(protocol::PlayerJoinPacket* packet);
     virtual void HandlePacket(protocol::PlayerLeavePacket* packet);

include/game/client/TowersInfo.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "game/Towers.h"
+#include <string>
+
+namespace td {
+namespace game {
+
+class TowerInfo {
+private:
+    std::string m_Name, m_Description;
+    bool m_IsBigTower;
+public:
+    TowerInfo(std::string&& name, std::string&& description, bool big) : m_Name(std::move(name)),
+        m_Description(std::move(description)), m_IsBigTower(big) {}
+
+    const std::string& getName() const { return m_Name; }
+    const std::string& getDescription() const { return m_Description; }
+
+    bool isBigTower() const { return m_IsBigTower; }
+};
+
+const TowerInfo& getTowerInfo(TowerType type);
+
+} // namespace game
+} // namespace td

include/game/client/WorldClient.h

@@ -16,6 +16,7 @@ public:
 
     virtual void HandlePacket(protocol::WorldBeginDataPacket* packet);
     virtual void HandlePacket(protocol::WorldDataPacket* packet);
+    virtual void HandlePacket(protocol::WorldAddTowerPacket* packet);
     virtual void HandlePacket(protocol::SpawnMobPacket* packet);
 };
 

include/game/server/ServerConnexion.h

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

include/protocol/PacketHandler.h

@@ -33,6 +33,8 @@ public:
     virtual void HandlePacket(DisconnectPacket* packet){}
     virtual void HandlePacket(ServerTpsPacket* packet){}
     virtual void HandlePacket(SpawnMobPacket* packet){}
+    virtual void HandlePacket(PlaceTowerPacket* packet){}
+    virtual void HandlePacket(WorldAddTowerPacket* packet){}
 };
 
 } // namespace protocol

include/protocol/Protocol.h

@@ -28,6 +28,8 @@ enum class PacketType : std::uint8_t{
     UpdatePlayerTeam,
     ServerTps,
     SpawnMob,
+    PlaceTower,
+    WorldAddTower
 };
 
 class Packet{
@@ -380,5 +382,49 @@ public:
     virtual PacketType getType() const{ return PacketType::SpawnMob; }
 };
 
+class PlaceTowerPacket : public Packet{
+private:
+    std::int32_t m_TowerX, m_TowerY;
+    game::TowerType m_TowerType;
+public:
+    PlaceTowerPacket(){}
+    PlaceTowerPacket(std::int32_t x, std::int32_t y, game::TowerType type) :
+        m_TowerX(x), m_TowerY(y), m_TowerType(type){}
+    virtual ~PlaceTowerPacket(){}
+
+    virtual DataBuffer Serialize() const;
+    virtual void Deserialize(DataBuffer& data);
+    virtual void Dispatch(PacketHandler* handler);
+
+    std::int32_t getTowerX() const { return m_TowerX; }
+    std::int32_t getTowerY() const { return m_TowerY; }
+    game::TowerType getTowerType() const { return m_TowerType; }
+
+    virtual PacketType getType() const{ return PacketType::PlaceTower; }
+};
+
+class WorldAddTowerPacket : public Packet{
+private:
+    std::int32_t m_TowerX, m_TowerY;
+    game::TowerType m_TowerType;
+    game::PlayerID m_Builder;
+public:
+    WorldAddTowerPacket(){}
+    WorldAddTowerPacket(std::int32_t x, std::int32_t y, game::TowerType type, game::PlayerID player) :
+        m_TowerX(x), m_TowerY(y), m_TowerType(type), m_Builder(player){}
+    virtual ~WorldAddTowerPacket(){}
+
+    virtual DataBuffer Serialize() const;
+    virtual void Deserialize(DataBuffer& data);
+    virtual void Dispatch(PacketHandler* handler);
+
+    std::int32_t getTowerX() const { return m_TowerX; }
+    std::int32_t getTowerY() const { return m_TowerY; }
+    game::TowerType getTowerType() const { return m_TowerType; }
+    game::PlayerID getBuilder() const {return m_Builder;}
+
+    virtual PacketType getType() const{ return PacketType::WorldAddTower; }
+};
+
 }
 }

include/render/WorldRenderer.h

@@ -7,36 +7,51 @@
 #include <glm/glm.hpp>
 
 namespace td {
+
+namespace client{
+
+class ClientGame;
+    
+} // namespace client
+
+
 namespace render {
 
 class WorldRenderer{
 private:
+    client::ClientGame* m_Client;
     Renderer* m_Renderer;
     game::World* m_World;
-    std::unique_ptr<GL::VAO> m_WorldVao, m_MobVao, m_SelectTileVao;
+    std::unique_ptr<GL::VertexArray> m_WorldVao, m_MobVao, m_SelectTileVao;
     glm::vec2 m_CamPos;
     glm::vec2 m_CursorPos;
+    glm::vec2 m_HoldCursorPos;
     float m_Zoom = 1;
     float m_CamSensibility = 1;
+    bool m_TowerPlacePopupOpened = false;
 public:
-    WorldRenderer(game::World* world, Renderer* renderer);
+    WorldRenderer(game::World* world, client::ClientGame* client);
     ~WorldRenderer();
 
     void loadModels();
 
     void update();
-    void render() const;
+    void render();
 
     void setCamPos(float camX, float camY);
 
     void moveCam(float relativeX, float relativeY, float aspectRatio);
     void changeZoom(float zoom);
-    void click(int mouseX, int mouseY);
 private:
+    void click();
     void renderWorld() const;
     void renderTowers() const;
     void renderMobs() const;
     void renderTileSelect() const;
+    void renderPopups() const;
+    void detectClick();
+    glm::vec2 getCursorWorldPos() const;
+    glm::vec2 getClickWorldPos() const;
 
     void updateCursorPos();
 };