feat: place towers

include/game/Towers.h

@@ -5,6 +5,7 @@
 #include <memory>
 
 #include "misc/Time.h"
+#include "game/Types.h"
 
 namespace td {
 namespace game {
@@ -78,12 +79,17 @@ const TowerStats* getTowerStats(TowerType type, TowerLevel level);
 
 class Tower {
 private:
+    TowerType m_Type;
     std::uint16_t m_X, m_Y;
     TowerLevel m_Level{};
+    PlayerID m_Builder;
 protected:
     utils::Timer m_Timer;
 public:                                                                 // converting seconds to millis
-    Tower(std::uint16_t x, std::uint16_t y) : m_X(x), m_Y(y), m_Timer(getStats()->getDamageRate() * 1000) {}
+    Tower(TowerType type, std::uint16_t x, std::uint16_t y, PlayerID builder) : m_Type(type), m_X(x), m_Y(y), m_Builder(builder), 
+    m_Timer(getStats()->getDamageRate()) {
+        
+    }
 
     virtual TowerType getType() const = 0;
     virtual TowerSize getSize() const = 0;
@@ -97,12 +103,19 @@ public:                                                                 // conve
     std::uint16_t getX() const { return m_X; }
     std::uint16_t getY() const { return m_Y; }
     const TowerLevel& getLevel() const { return m_Level; }
-    const TowerStats* getStats() const { return getTowerStats(getType(), m_Level); }
+    const TowerStats* getStats() const { return getTowerStats(m_Type, m_Level); }
 
 };
 
 typedef std::shared_ptr<Tower> TowerPtr;
 
+namespace TowerFactory{
+
+TowerPtr createTower(TowerType type, std::int32_t x, std::int32_t y, PlayerID builder);
+    
+} // namespace TowerFactory
+
+
 class TowerInfo {
 private:
     std::string m_Name, m_Description;
@@ -123,7 +136,7 @@ const TowerInfo& getTowerInfo(TowerType type);
 
 class LittleTower : public Tower {
 public:
-    LittleTower(std::uint16_t x, std::uint16_t y) : Tower(x, y) {}
+    LittleTower(TowerType type, std::uint16_t x, std::uint16_t y, PlayerID builder) : Tower(type, x, y, builder) {}
 
     virtual TowerSize getSize() const { return TowerSize::Little; }
 
@@ -133,7 +146,7 @@ public:
 
 class ArcherTower : public LittleTower {
 public:
-    ArcherTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {}
+    ArcherTower(std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(getType(), x, y, builder) {}
 
     virtual TowerType getType() const { return TowerType::Archer; }
     virtual void tick(std::uint64_t delta);
@@ -141,7 +154,7 @@ public:
 
 class IceTower : public LittleTower {
 public:
-    IceTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {}
+    IceTower(std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(getType(), x, y, builder) {}
 
     virtual TowerType getType() const { return TowerType::Ice; }
     virtual void tick(std::uint64_t delta);
@@ -149,7 +162,7 @@ public:
 
 class MageTower : public LittleTower {
 public:
-    MageTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {}
+    MageTower(std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(getType(), x, y, builder) {}
 
     virtual TowerType getType() const { return TowerType::Mage; }
     virtual void tick(std::uint64_t delta);
@@ -157,7 +170,7 @@ public:
 
 class PoisonTower : public LittleTower {
 public:
-    PoisonTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {}
+    PoisonTower(std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(getType(), x, y, builder) {}
 
     virtual TowerType getType() const { return TowerType::Poison; }
     virtual void tick(std::uint64_t delta);
@@ -165,7 +178,7 @@ public:
 
 class QuakeTower : public LittleTower {
 public:
-    QuakeTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {}
+    QuakeTower(std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(getType(), x, y, builder) {}
 
     virtual TowerType getType() const { return TowerType::Quake; }
     virtual void tick(std::uint64_t delta);
@@ -173,7 +186,7 @@ public:
 
 class ArtilleryTower : public LittleTower {
 public:
-    ArtilleryTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {}
+    ArtilleryTower(std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(getType(), x, y, builder) {}
 
     virtual TowerType getType() const { return TowerType::Artillery; }
     virtual void tick(std::uint64_t delta);
@@ -181,7 +194,7 @@ public:
 
 class SorcererTower : public LittleTower {
 public:
-    SorcererTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {}
+    SorcererTower(std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(getType(), x, y, builder) {}
 
     virtual TowerType getType() const { return TowerType::Sorcerer; }
     virtual void tick(std::uint64_t delta);
@@ -189,7 +202,7 @@ public:
 
 class ZeusTower : public LittleTower {
 public:
-    ZeusTower(std::uint16_t x, std::uint16_t y) : LittleTower(x, y) {}
+    ZeusTower(std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(getType(), x, y, builder) {}
 
     virtual TowerType getType() const { return TowerType::Zeus; }
     virtual void tick(std::uint64_t delta);
@@ -199,7 +212,7 @@ public:
 
 class BigTower : public Tower {
 public:
-    BigTower(std::uint16_t x, std::uint16_t y) : Tower(x, y) {}
+    BigTower(TowerType type, std::uint16_t x, std::uint16_t y, PlayerID builder) : Tower(type, x, y, builder) {}
 
     virtual TowerSize getSize() const { return TowerSize::Big; }
 
@@ -209,7 +222,7 @@ public:
 
 class TurretTower : public BigTower {
 public:
-    TurretTower(std::uint16_t x, std::uint16_t y) : BigTower(x, y) {}
+    TurretTower(std::uint16_t x, std::uint16_t y, PlayerID builder) : BigTower(getType(), x, y, builder) {}
 
     virtual TowerType getType() const { return TowerType::Turret; }
     virtual void tick(std::uint64_t delta);
@@ -217,7 +230,7 @@ public:
 
 class NecromancerTower : public BigTower {
 public:
-    NecromancerTower(std::uint16_t x, std::uint16_t y) : BigTower(x, y) {}
+    NecromancerTower(std::uint16_t x, std::uint16_t y, PlayerID builder) : BigTower(getType(), x, y, builder) {}
 
     virtual TowerType getType() const { return TowerType::Necromancer; }
     virtual void tick(std::uint64_t delta);
@@ -225,7 +238,7 @@ public:
 
 class LeachTower : public BigTower {
 public:
-    LeachTower(std::uint16_t x, std::uint16_t y) : BigTower(x, y) {}
+    LeachTower(std::uint16_t x, std::uint16_t y, PlayerID builder) : BigTower(getType(), x, y, builder) {}
 
     virtual TowerType getType() const { return TowerType::Leach; }
     virtual void tick(std::uint64_t delta);

include/game/World.h

@@ -141,6 +141,8 @@ public:
 
     void spawnMobAt(MobID id, MobType type, std::uint8_t level, PlayerID sender, float x, float y, Direction dir);
 
+    void placeTowerAt(TowerType type, std::int32_t x, std::int32_t y, PlayerID builder);
+
     TilePtr getTile(std::int32_t x, std::int32_t y) const;
 
     const TowerTileColorPalette& getTowerTileColorPalette() const { return m_TowerPlacePalette; }

src/game/Towers.cpp

@@ -133,6 +133,34 @@ const TowerInfo& getTowerInfo(TowerType type) {
 
 
 
+namespace TowerFactory {
+
+using TowerCreator = std::function<std::shared_ptr<Tower>(std::int32_t, std::int32_t, PlayerID)>;
+
+static const std::map<TowerType, TowerCreator> towerFactory = {
+    {TowerType::Archer,         [](std::int32_t x, std::int32_t y, PlayerID builder) -> TowerPtr {return std::make_shared<ArcherTower>(x, y, builder);} },
+    {TowerType::Artillery,      [](std::int32_t x, std::int32_t y, PlayerID builder) -> TowerPtr {return std::make_shared<ArtilleryTower>(x, y, builder);} },
+    {TowerType::Ice,            [](std::int32_t x, std::int32_t y, PlayerID builder) -> TowerPtr {return std::make_shared<IceTower>(x, y, builder);} },
+    {TowerType::Mage,           [](std::int32_t x, std::int32_t y, PlayerID builder) -> TowerPtr {return std::make_shared<MageTower>(x, y, builder);} },
+    {TowerType::Poison,         [](std::int32_t x, std::int32_t y, PlayerID builder) -> TowerPtr {return std::make_shared<PoisonTower>(x, y, builder);} },
+    {TowerType::Quake,          [](std::int32_t x, std::int32_t y, PlayerID builder) -> TowerPtr {return std::make_shared<QuakeTower>(x, y, builder);} },
+    {TowerType::Sorcerer,       [](std::int32_t x, std::int32_t y, PlayerID builder) -> TowerPtr {return std::make_shared<SorcererTower>(x, y, builder);} },
+    {TowerType::Zeus,           [](std::int32_t x, std::int32_t y, PlayerID builder) -> TowerPtr {return std::make_shared<ZeusTower>(x, y, builder);} },
+    {TowerType::Leach,          [](std::int32_t x, std::int32_t y, PlayerID builder) -> TowerPtr {return std::make_shared<LeachTower>(x, y, builder);} },
+    {TowerType::Necromancer,    [](std::int32_t x, std::int32_t y, PlayerID builder) -> TowerPtr {return std::make_shared<NecromancerTower>(x, y, builder);} },
+    {TowerType::Turret,         [](std::int32_t x, std::int32_t y, PlayerID builder) -> TowerPtr {return std::make_shared<TurretTower>(x, y, builder);} },
+};
+
+TowerPtr createTower(TowerType type, std::int32_t x, std::int32_t y, PlayerID builder) {
+    return towerFactory.at(type)(x, y, builder);
+}
+
+} // namespace TowerFactory
+
+
+
+
+
 void ArcherTower::tick(std::uint64_t delta) {
 
 }

src/game/World.cpp

@@ -299,7 +299,7 @@ bool World::loadMapFromFile(const std::string& fileName) {
     m_Chunks.insert({ {3, 0}, std::make_shared<Chunk>(chunk11) });
     m_Chunks.insert({ {3, 1}, std::make_shared<Chunk>(chunk21) });
 
-    return saveMap("tdmap_linux.tdmap");
+    return saveMap("tdmap_debug.tdmap");
 #endif
 
 }
@@ -334,6 +334,11 @@ void World::spawnMobAt(MobID id, MobType type, std::uint8_t level, PlayerID send
     m_Mobs.push_back(mob);
 }
 
+void World::placeTowerAt(TowerType type, std::int32_t x, std::int32_t y, PlayerID builder) {
+    TowerPtr tower = TowerFactory::createTower(type, x, y, builder);
+    m_Towers.push_back(tower);
+}
+
 void World::moveMobs(std::uint64_t delta) {
     for (MobPtr mob : m_Mobs) {
         TilePtr tile = getTile(mob->getX(), mob->getY());

src/game/client/WorldClient.cpp

@@ -22,7 +22,7 @@ void WorldClient::HandlePacket(protocol::WorldDataPacket* packet) {
 }
 
 void WorldClient::HandlePacket(protocol::WorldAddTowerPacket* packet) {
-
+    placeTowerAt(packet->getTowerType(), packet->getTowerX(), packet->getTowerY(), packet->getBuilder());
 }
 
 void WorldClient::HandlePacket(protocol::SpawnMobPacket* packet) {

src/game/server/ServerConnexion.cpp

@@ -146,7 +146,7 @@ void ServerConnexion::initConnection() {
 void ServerConnexion::HandlePacket(protocol::PlaceTowerPacket* packet) {
     game::TowerType towerType = packet->getTowerType();
     const game::TowerInfo& towerInfo = game::getTowerInfo(towerType);
-    const game::World* world = m_Server->getGame().getWorld();
+    game::World* world = m_Server->getGame().getWorld();
     if (towerInfo.isBigTower()) {
         if (!world->CanPlaceBigTower({ packet->getTowerX(), packet->getTowerY() }))
             return;
@@ -154,6 +154,9 @@ void ServerConnexion::HandlePacket(protocol::PlaceTowerPacket* packet) {
         if (!world->CanPlaceLittleTower({ packet->getTowerX(), packet->getTowerY() }))
             return;
     }
+    
+    world->placeTowerAt(towerType, packet->getTowerX(), packet->getTowerY(), m_ID);
+
     protocol::WorldAddTowerPacket addTowerPacket(packet->getTowerX(), packet->getTowerY(), packet->getTowerType(), m_ID);
     m_Server->broadcastPacket(&addTowerPacket);
 }