148 lines
3.7 KiB
C++
148 lines
3.7 KiB
C++
#pragma once
|
|
|
|
#include <memory>
|
|
#include <string>
|
|
|
|
#include <td/misc/Shapes.h>
|
|
|
|
#include <td/Types.h>
|
|
|
|
#include <sp/common/GenericHandler.h>
|
|
#include <sp/protocol/ConcreteMessage.h>
|
|
#include <sp/protocol/MessageFactory.h>
|
|
|
|
namespace td {
|
|
namespace game {
|
|
|
|
class World;
|
|
class Mob;
|
|
|
|
typedef std::shared_ptr<Mob> MobPtr;
|
|
|
|
enum class TowerSize : std::uint8_t {
|
|
Little = 3, // 3x3
|
|
Big = 5, // 5x5
|
|
};
|
|
|
|
enum class TowerPath : std::uint8_t {
|
|
Top = 0,
|
|
Base, // Base Path
|
|
Bottom
|
|
};
|
|
|
|
class TowerStats {
|
|
private:
|
|
float m_Rate;
|
|
float m_Damage;
|
|
std::uint8_t m_Range;
|
|
|
|
public:
|
|
TowerStats(float rate, float damage, std::uint8_t range) : m_Rate(rate), m_Damage(damage), m_Range(range) {}
|
|
|
|
float GetDamageRate() const {
|
|
return m_Rate;
|
|
}
|
|
float GetDamage() const {
|
|
return m_Damage;
|
|
}
|
|
std::uint8_t GetRange() const {
|
|
return m_Range;
|
|
}
|
|
};
|
|
|
|
class TowerLevel {
|
|
private:
|
|
// 1, 2, 3, 4
|
|
std::uint8_t m_Level : 3;
|
|
// 0 : base path 1 : top path (if there is bottom path) 2 : bottom path (if there is top path)
|
|
TowerPath m_Path : 2;
|
|
|
|
public:
|
|
TowerLevel() : m_Level(1), m_Path(TowerPath::Base) {}
|
|
TowerLevel(std::uint8_t level, TowerPath path) : m_Level(level), m_Path(path) {}
|
|
|
|
std::uint8_t GetLevel() const {
|
|
return m_Level;
|
|
}
|
|
TowerPath GetPath() const {
|
|
return m_Path;
|
|
}
|
|
|
|
void SetLevel(std::uint8_t level) {
|
|
m_Level = level;
|
|
}
|
|
void SetPath(TowerPath path) {
|
|
m_Path = path;
|
|
}
|
|
|
|
// operator to sort maps
|
|
friend bool operator<(const TowerLevel& level, const TowerLevel& other) {
|
|
return level.GetLevel() + static_cast<std::uint8_t>(level.GetPath()) * 4 <
|
|
other.GetLevel() + static_cast<std::uint8_t>(other.GetPath()) * 4;
|
|
}
|
|
};
|
|
|
|
using TowerID = std::uint16_t;
|
|
|
|
class TowerHandler;
|
|
|
|
class Tower : public utils::shape::Circle, public sp::MessageBase<TowerType, TowerHandler> {
|
|
public:
|
|
TowerID m_ID;
|
|
TowerLevel m_Level{};
|
|
PlayerID m_Builder;
|
|
|
|
public:
|
|
Tower() : m_ID(0), m_Level({}), m_Builder(0) {}
|
|
|
|
virtual TowerType GetType() const = 0;
|
|
virtual TowerSize GetSize() const = 0;
|
|
virtual void Tick(std::uint64_t delta, World* world) = 0;
|
|
};
|
|
|
|
struct TowerData {};
|
|
|
|
template <TowerType Type, TowerSize Size>
|
|
class ConcreteTower : public sp::ConcreteMessage<TowerData, Tower, Type, false> {
|
|
public:
|
|
using HandlerType = typename sp::ConcreteMessage<TowerData, Tower, Type, false>::HandlerType;
|
|
|
|
virtual TowerSize GetSize() const override {
|
|
return Size;
|
|
}
|
|
|
|
virtual TowerType GetType() const override {
|
|
return Type;
|
|
}
|
|
|
|
virtual void Tick(std::uint64_t delta, World* world) override {}
|
|
|
|
virtual void Dispatch(HandlerType& handler) const override {
|
|
handler.Handle(*this);
|
|
}
|
|
};
|
|
|
|
using TowerPtr = std::shared_ptr<Tower>;
|
|
|
|
using ArcherTower = ConcreteTower<TowerType::Archer, TowerSize::Little>;
|
|
using ArtilleryTower = ConcreteTower<TowerType::Artillery, TowerSize::Little>;
|
|
using IceTower = ConcreteTower<TowerType::Ice, TowerSize::Little>;
|
|
using LeachTower = ConcreteTower<TowerType::Leach, TowerSize::Big>;
|
|
using MageTower = ConcreteTower<TowerType::Mage, TowerSize::Little>;
|
|
using NecromancerTower = ConcreteTower<TowerType::Necromancer, TowerSize::Big>;
|
|
using PoisonTower = ConcreteTower<TowerType::Poison, TowerSize::Little>;
|
|
using QuakeTower = ConcreteTower<TowerType::Quake, TowerSize::Little>;
|
|
using SorcererTower = ConcreteTower<TowerType::Sorcerer, TowerSize::Little>;
|
|
using TurretTower = ConcreteTower<TowerType::Turret, TowerSize::Big>;
|
|
using ZeusTower = ConcreteTower<TowerType::Zeus, TowerSize::Little>;
|
|
|
|
using AllTowers = std::tuple<ArcherTower, ArtilleryTower, IceTower, LeachTower, MageTower, NecromancerTower, PoisonTower, QuakeTower,
|
|
SorcererTower, TurretTower, ZeusTower>;
|
|
|
|
using TowerFactory = sp::MessageFactory<Tower, AllTowers>;
|
|
|
|
class TowerHandler : public sp::GenericHandler<AllTowers> {};
|
|
|
|
} // namespace game
|
|
} // namespace td
|