nice

include/td/game/Game.h

@@ -1,14 +1,46 @@
 #pragma once
 
-#include <td/game/GameHistory.h>
+#include <td/game/World.h>
 
 namespace td {
 namespace game {
 
-class Game {
-  private:
-	GameHistory m_History;
+enum class GameState : std::uint8_t {
+	Lobby,
+	Game,
+	EndGame,
+	Disconnected,
+	Closed
 };
 
-}  // namespace game
-}  // namespace td
+typedef std::map<std::uint8_t, Player> PlayerList;
+
+
+class Game {
+protected:
+	World* m_World;
+	
+	GameState m_GameState = GameState::Lobby;
+	PlayerList m_Players;
+public:
+	Game(World* world);
+	virtual ~Game();
+
+	virtual void Tick(std::uint64_t delta);
+
+	GameState GetGameState() const { return m_GameState; }
+	void SetGameState(GameState gameState) { m_GameState = gameState; };
+
+	const World* GetWorld() const { return m_World; }
+	World* GetWorld() { return m_World; }
+
+	const PlayerList& GetPlayers() const { return m_Players; }
+	PlayerList& GetPlayers() { return m_Players; }
+
+	const Player* GetPlayerById(PlayerID id) const;
+	Player* GetPlayerById(PlayerID id);
+
+};
+
+} // namespace game 
+} // namespace td

include/td/game/Mobs.h

@@ -0,0 +1,260 @@
+#pragma once
+
+#include <td/game/Towers.h>
+
+#include <td/Maths.h>
+#include <td/Types.h>
+#include <td/game/Team.h>
+
+#include <vector>
+#include <memory>
+
+namespace td {
+namespace game {
+
+struct WalkableTile;
+
+enum class EffectType : std::uint8_t {
+	Slowness = 0,
+	Stun,
+	Fire,
+	Poison,
+	Heal,
+};
+
+enum class MobType : std::uint8_t {
+	Zombie = 0,
+	Spider,
+	Skeleton,
+	Pigman,
+	Creeper,
+	Silverfish,
+	Blaze,
+	Witch,
+	Slime,
+	Giant,
+
+	MOB_COUNT
+};
+
+typedef std::uint32_t MobID;
+typedef std::uint8_t MobLevel;
+typedef std::vector<TowerType> TowerImmunities;
+typedef std::vector<EffectType> EffectImmunities;
+
+class MobStats {
+private:
+	float m_Damage;
+	float m_Speed;
+	Vec2f m_Size;
+	std::uint16_t m_MoneyCost;
+	std::uint16_t m_ExpCost;
+	std::uint16_t m_MaxLife;
+	std::uint16_t m_ExpReward;
+public:
+	MobStats(float damage, float speed, Vec2f size, std::uint16_t moneyCost,
+		std::uint16_t expCost, std::uint16_t expReward,
+		std::uint16_t maxLife) : m_Damage(damage), m_Speed(speed),
+		m_Size(size), m_MoneyCost(moneyCost), m_ExpCost(expCost),
+		m_MaxLife(maxLife), m_ExpReward(expReward) {
+	}
+
+	float GetDamage() const { return m_Damage; }
+	float GetMovementSpeed() const { return m_Speed; }
+	const Vec2f& GetSize() const { return m_Size; }
+	std::uint16_t GetMoneyCost() const { return m_MoneyCost; }
+	std::uint16_t GetExpCost() const { return m_ExpCost; }
+	std::uint16_t GetExpReward() const { return m_ExpReward; }
+	std::uint16_t GetMaxLife() const { return m_MaxLife; }
+};
+
+struct EffectDuration {
+	EffectType type;
+	float duration; // in seconds
+	Tower* tower; // the tower that gived the effect
+};
+
+const MobStats* GetMobStats(MobType type, std::uint8_t level);
+const TowerImmunities& GetMobTowerImmunities(MobType type, std::uint8_t level);
+const EffectImmunities& GetMobEffectImmunities(MobType type, std::uint8_t level);
+
+class Mob : public utils::shape::Rectangle {
+protected:
+	float m_Health;
+private:
+	MobID m_ID;
+	PlayerID m_Sender;
+	MobLevel m_Level;
+	Direction m_Direction;
+	std::vector<EffectDuration> m_Effects;
+	const Tower* m_LastDamage;   // the last tower that damaged the mob
+	float m_HitCooldown;
+
+	// utils::Timer m_EffectFireTimer;
+	// utils::Timer m_EffectPoisonTimer;
+	// utils::Timer m_EffectHealTimer;
+
+	TeamCastle* m_CastleTarget;
+	// utils::CooldownTimer m_AttackTimer;
+
+public:
+	Mob(MobID id, MobLevel level, PlayerID sender) : m_Sender(sender), m_Level(level),
+		m_HitCooldown(0), m_CastleTarget(nullptr) {
+
+	}
+
+	virtual MobType GetType() const = 0;
+
+	virtual void Tick(std::uint64_t delta, World* world);
+
+	virtual bool OnDeath(World* world) { return true; }
+
+	MobID GetMobID() const { return m_ID; }
+	const TowerImmunities& GetTowerImmunities() const { return GetMobTowerImmunities(GetType(), m_Level); }
+	const EffectImmunities& GetEffectImmunities() const { return GetMobEffectImmunities(GetType(), m_Level); }
+	PlayerID GetSender() const { return m_Sender; }
+	MobLevel GetLevel() const { return m_Level; }
+	const MobStats* GetStats() const { return GetMobStats(GetType(), m_Level); }
+	void SetHealth(float newHealth) { m_Health = newHealth; }
+	float GetHealth() const { return m_Health; }
+	bool IsDead() const { return m_Health <= 0; }
+	bool IsAlive() const { return m_Health > 0; }
+	const Tower* GetLastDamageTower() { return m_LastDamage; }
+	bool HasReachedEnemyCastle() { return m_CastleTarget != nullptr; }
+
+	void Damage(float dmg, const Tower* damager) {
+		m_Health = std::max(0.0f, m_Health - dmg);
+		m_LastDamage = damager;
+		m_HitCooldown = 0.1;
+	}
+
+	void Heal(float heal) {
+		m_Health = std::min(static_cast<float>(GetStats()->GetMaxLife()), m_Health + heal);
+	}
+
+	void SetMobReachedCastle(TeamCastle* castle) { m_CastleTarget = castle; } // used when mob is in front of the castle
+
+	bool IsImmuneTo(TowerType type);
+
+	bool IsImmuneTo(EffectType type);
+	void AddEffect(EffectType type, float durationSec, Tower* tower);
+	bool HasEffect(EffectType type);
+
+	bool HasTakenDamage() { return m_HitCooldown > 0; }
+
+	float GetTileX() { return GetCenterX() - static_cast<float>(static_cast<std::int32_t>(GetCenterX())); } // returns a float between 0 and 1 excluded
+	float GetTileY() { return GetCenterY() - static_cast<float>(static_cast<std::int32_t>(GetCenterY())); } // returns a float between 0 and 1 excluded
+
+	Direction GetDirection() const { return m_Direction; }
+	void SetDirection(Direction dir) { m_Direction = dir; }
+protected:
+	void InitMob() {
+		m_Health = static_cast<float>(GetStats()->GetMaxLife());
+		SetSize(GetStats()->GetSize().x, GetStats()->GetSize().y);
+	}
+private:
+	void UpdateEffects(std::uint64_t delta, World* world);
+	void AttackCastle(std::uint64_t delta, World* world);
+	void Move(std::uint64_t delta, World* world);
+	void Walk(std::uint64_t delta, World* world);
+	void MoveBack(const TeamCastle& castle, World* world);
+	void ChangeDirection(const WalkableTile& tile, World* world);
+	bool IsTouchingCastle(const TeamCastle& castle) const;
+	EffectDuration& GetEffect(EffectType type);
+};
+
+typedef std::shared_ptr<Mob> MobPtr;
+
+class Zombie : public Mob {
+public:
+	Zombie(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { InitMob(); }
+
+	virtual MobType GetType() const { return MobType::Zombie; }
+};
+
+class Spider : public Mob {
+public:
+	Spider(MobID id, std::uint8_t level, PlayerID sender) : Mob(id, level, sender) { InitMob(); }
+
+	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) { InitMob(); }
+
+	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) { InitMob(); }
+
+	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) { InitMob(); }
+
+	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) { InitMob(); }
+
+	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) { InitMob(); }
+
+	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) { InitMob(); }
+
+	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) { InitMob(); }
+
+	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) { InitMob(); }
+
+	virtual MobType GetType() const { return MobType::Giant; }
+};
+
+namespace MobFactory {
+
+MobPtr CreateMob(MobID id, MobType type, std::uint8_t level, PlayerID sender);
+std::string GetMobName(MobType type);
+
+}
+
+class MobListener {
+public:
+	virtual void OnMobSpawn(Mob* mob) {}
+	virtual void OnMobDie(Mob* mob) {}
+
+	virtual void OnMobDamage(Mob* target, float damage, Tower* damager) {}
+
+	virtual void OnMobTouchCastle(Mob* damager, TeamCastle* enemyCastle) {}
+	virtual void OnMobCastleDamage(Mob* damager, TeamCastle* enemyCastle, float damage) {}
+};
+
+// typedef utils::ObjectNotifier<MobListener> MobNotifier;
+
+} // namespace game
+} // namespace td
+

include/td/game/Team.h

@@ -0,0 +1,86 @@
+#pragma once
+
+#include <td/Types.h>
+
+#include <td/misc/Shapes.h>
+
+#include <vector>
+#include <memory>
+#include <cmath>
+
+namespace td {
+namespace game {
+
+class Player;
+
+class Spawn : public utils::shape::Rectangle {
+private:
+	Direction m_Direction;
+public:
+	Spawn() {
+		SetWidth(5);
+		SetHeight(5);
+	}
+
+	Direction GetDirection() const { return m_Direction; }
+
+	void SetDirection(Direction direction) { m_Direction = direction; }
+};
+
+class Team;
+
+class TeamCastle : public utils::shape::Rectangle {
+private:
+	const Team* m_Team;
+	float m_Life;
+public:
+	static constexpr int CastleMaxLife = 1000;
+
+	TeamCastle(const Team* team) : m_Team(team), m_Life(CastleMaxLife) {
+		SetWidth(5);
+		SetHeight(5);
+	}
+
+	TeamCastle() : TeamCastle(nullptr) {}
+
+	float GetLife() const { return m_Life; }
+
+	const Team* GetTeam() const { return m_Team; }
+	void SetTeam(const Team* team) { m_Team = team; }
+
+	void SetLife(float life) { m_Life = life; }
+	void Damage(float damage) { m_Life = std::max(0.0f, m_Life - damage); }
+
+	void SetShape(utils::shape::Rectangle rect) {
+		SetCenter(rect.GetCenter());
+		SetSize(rect.GetSize());
+	}
+};
+
+class Team {
+private:
+	std::vector<Player*> m_Players;
+	TeamColor m_Color;
+	Spawn m_Spawn;
+	TeamCastle m_TeamCastle;
+public:
+	Team(TeamColor color) : m_Color(color) {}
+
+	void AddPlayer(Player* newPlayer);
+	void RemovePlayer(const Player* player);
+
+	TeamColor GetColor() const;
+
+	const Spawn& GetSpawn() const { return m_Spawn; }
+	Spawn& GetSpawn() { return m_Spawn; }
+
+	const TeamCastle& GetCastle() const { return m_TeamCastle; }
+	TeamCastle& GetCastle() { return m_TeamCastle; }
+
+	std::uint8_t GetPlayerCount() const;
+};
+
+typedef std::array<Team, 2> TeamList;
+
+} // namespace game
+} // namespace td

include/td/game/Towers.h

@@ -0,0 +1,266 @@
+#pragma once
+
+#include <string>
+#include <memory>
+
+#include <td/misc/Shapes.h>
+
+#include <td/Types.h>
+
+namespace td {
+namespace game {
+
+class World;
+class Mob;
+
+typedef std::shared_ptr<Mob> MobPtr;
+
+enum class TowerType : std::uint8_t {
+	Archer = 0,
+	Ice,
+	Sorcerer,
+	Zeus,
+	Mage,
+	Artillery,
+	Quake,
+	Poison,
+
+	Leach,
+	Turret,
+	Necromancer,
+
+	TowerCount
+};
+
+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;
+	}
+};
+
+const TowerStats* GetTowerStats(TowerType type, TowerLevel level);
+
+typedef std::uint16_t TowerID;
+
+class Tower : public utils::shape::Circle {
+private:
+	TowerID m_ID;
+	TowerType m_Type;
+	TowerLevel m_Level{};
+	PlayerID m_Builder;
+protected:
+	// utils::CooldownTimer m_Timer;
+public:
+	Tower(TowerID id, TowerType type, std::int32_t x, std::int32_t y, PlayerID builder) : utils::shape::Circle(x + 0.5f, y + 0.5f, 0), m_ID(id), m_Type(type), m_Builder(builder)
+		// m_Timer(GetStats()->GetDamageRate() * 1000) 
+		{ // converting seconds to millis
+		SetRadius(GetStats()->GetRange());
+	}
+
+	virtual TowerType GetType() const = 0;
+	virtual TowerSize GetSize() const = 0;
+	virtual void Tick(std::uint64_t delta, World* world) = 0;
+
+	void Upgrade(std::uint8_t level, TowerPath path) {
+		m_Level.SetLevel(level);
+		m_Level.SetPath(path);
+		// m_Timer.SetCooldown(GetStats()->GetDamageRate() * 1000); // converting seconds to millis
+		// m_Timer.Reset();
+		SetRadius(GetStats()->GetRange());
+	}
+
+	std::uint16_t GetID() const { return m_ID; }
+	const TowerLevel& GetLevel() const { return m_Level; }
+	const TowerStats* GetStats() const { return GetTowerStats(m_Type, m_Level); }
+	PlayerID GetBuilder() const { return m_Builder; }
+
+	bool IsMobInRange(MobPtr mob);
+};
+
+typedef std::shared_ptr<Tower> TowerPtr;
+
+namespace TowerFactory {
+
+TowerPtr CreateTower(TowerType type, TowerID id, std::int32_t x, std::int32_t y, PlayerID builder);
+std::string GetTowerName(TowerType type);
+
+} // namespace TowerFactory
+
+
+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);
+
+// ---------- Little Towers ----------
+
+class LittleTower : public Tower {
+public:
+	LittleTower(TowerID id, TowerType type, std::uint16_t x, std::uint16_t y, PlayerID builder) : Tower(id, type, x, y, builder) {}
+
+	virtual TowerSize GetSize() const { return TowerSize::Little; }
+
+	virtual TowerType GetType() const = 0;
+	virtual void Tick(std::uint64_t delta, World* world) = 0;
+};
+
+class ArcherTower : public LittleTower {
+public:
+	ArcherTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, GetType(), x, y, builder) {}
+
+	constexpr static float ExplosionRadius = 1.5f;
+	constexpr static float FireDurationSec = 10.0f;
+
+	virtual TowerType GetType() const { return TowerType::Archer; }
+	virtual void Tick(std::uint64_t delta, World* world);
+};
+
+class IceTower : public LittleTower {
+public:
+	IceTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, GetType(), x, y, builder) {}
+
+	virtual TowerType GetType() const { return TowerType::Ice; }
+	virtual void Tick(std::uint64_t delta, World* world);
+};
+
+class MageTower : public LittleTower {
+public:
+	MageTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, GetType(), x, y, builder) {}
+
+	virtual TowerType GetType() const { return TowerType::Mage; }
+	virtual void Tick(std::uint64_t delta, World* world);
+};
+
+class PoisonTower : public LittleTower {
+public:
+	PoisonTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, GetType(), x, y, builder) {}
+
+	virtual TowerType GetType() const { return TowerType::Poison; }
+	virtual void Tick(std::uint64_t delta, World* world);
+};
+
+class QuakeTower : public LittleTower {
+public:
+	QuakeTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, GetType(), x, y, builder) {}
+
+	virtual TowerType GetType() const { return TowerType::Quake; }
+	virtual void Tick(std::uint64_t delta, World* world);
+};
+
+class ArtilleryTower : public LittleTower {
+public:
+	ArtilleryTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, GetType(), x, y, builder) {}
+
+	virtual TowerType GetType() const { return TowerType::Artillery; }
+	virtual void Tick(std::uint64_t delta, World* world);
+};
+
+class SorcererTower : public LittleTower {
+public:
+	SorcererTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, GetType(), x, y, builder) {}
+
+	virtual TowerType GetType() const { return TowerType::Sorcerer; }
+	virtual void Tick(std::uint64_t delta, World* world);
+};
+
+class ZeusTower : public LittleTower {
+public:
+	ZeusTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : LittleTower(id, GetType(), x, y, builder) {}
+
+	virtual TowerType GetType() const { return TowerType::Zeus; }
+	virtual void Tick(std::uint64_t delta, World* world);
+};
+
+// ---------- Big Towers ----------
+
+class BigTower : public Tower {
+public:
+	BigTower(TowerID id, TowerType type, std::uint16_t x, std::uint16_t y, PlayerID builder) : Tower(id, type, x, y, builder) {}
+
+	virtual TowerSize GetSize() const { return TowerSize::Big; }
+
+	virtual TowerType GetType() const = 0;
+	virtual void Tick(std::uint64_t delta, World* world) = 0;
+};
+
+class TurretTower : public BigTower {
+public:
+	TurretTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : BigTower(id, GetType(), x, y, builder) {}
+
+	virtual TowerType GetType() const { return TowerType::Turret; }
+	virtual void Tick(std::uint64_t delta, World* world);
+};
+
+class NecromancerTower : public BigTower {
+public:
+	NecromancerTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : BigTower(id, GetType(), x, y, builder) {}
+
+	virtual TowerType GetType() const { return TowerType::Necromancer; }
+	virtual void Tick(std::uint64_t delta, World* world);
+};
+
+class LeachTower : public BigTower {
+public:
+	LeachTower(TowerID id, std::uint16_t x, std::uint16_t y, PlayerID builder) : BigTower(id, GetType(), x, y, builder) {}
+
+	virtual TowerType GetType() const { return TowerType::Leach; }
+	virtual void Tick(std::uint64_t delta, World* world);
+};
+
+} // namespace game
+} // namespace td

include/td/game/World.h

@@ -0,0 +1,137 @@
+#pragma once
+
+#include <td/game/WorldTypes.h>
+#include <td/protocol/packet/Packets.h>
+
+namespace td {
+namespace game {
+
+class World {
+  protected:
+	TowerTileColorPalette m_TowerPlacePalette;
+	Color m_WalkablePalette;
+	std::vector<Color> m_DecorationPalette;
+	Color m_Background;
+
+	std::unordered_map<ChunkCoord, ChunkPtr> m_Chunks;
+
+	SpawnColorPalette m_SpawnColorPalette;
+
+	TilePalette m_TilePalette;
+
+	MobList m_Mobs;
+
+	TowerList m_Towers;
+
+	TeamList m_Teams;
+
+  public:
+	World();
+
+	bool LoadMap(const protocol::pdata::WorldHeader& worldHeader);
+	bool LoadMap(const protocol::pdata::WorldData& worldData);
+
+	bool LoadMapFromFile(const std::string& fileName);
+	bool SaveMap(const std::string& fileName) const;
+
+	void Tick(std::uint64_t delta);
+
+	void SpawnMobAt(MobID id, MobType type, std::uint8_t level, PlayerID sender, float x, float y, Direction dir);
+
+	TowerPtr PlaceTowerAt(TowerID id, TowerType type, std::int32_t x, std::int32_t y, PlayerID builder);
+	TowerPtr RemoveTower(TowerID id);
+
+	TilePtr GetTile(std::int32_t x, std::int32_t y) const;
+
+	const TowerTileColorPalette& GetTowerTileColorPalette() const {
+		return m_TowerPlacePalette;
+	}
+	const Color& GetWalkableTileColor() const {
+		return m_WalkablePalette;
+	}
+	const std::vector<Color>& GetDecorationPalette() const {
+		return m_DecorationPalette;
+	}
+	const Color& GetBackgroundColor() const {
+		return m_Background;
+	}
+
+	const TilePalette& GetTilePalette() const {
+		return m_TilePalette;
+	}
+
+	TilePtr GetTilePtr(TileIndex index) const {
+		if (index == 0)
+			return nullptr;
+		return m_TilePalette.at(index - 1);
+	}
+
+	bool CanPlaceLittleTower(const Vec2f& worldPos, PlayerID player) const;
+	bool CanPlaceBigTower(const Vec2f& worldPos, PlayerID player) const;
+
+	TowerPtr GetTower(const Vec2f& position) const;	 // returns null if no tower is here
+
+	const std::unordered_map<ChunkCoord, ChunkPtr>& GetChunks() const {
+		return m_Chunks;
+	}
+
+	const Color& GetSpawnColor(TeamColor color) const {
+		return m_SpawnColorPalette[static_cast<std::size_t>(color)];
+	}
+	const SpawnColorPalette& GetSpawnColors() const {
+		return m_SpawnColorPalette;
+	}
+
+	const MobList& GetMobList() const {
+		return m_Mobs;
+	}
+	MobList& GetMobList() {
+		return m_Mobs;
+	}
+
+	const Color* GetTileColor(TilePtr tile) const;
+
+	Team& GetRedTeam() {
+		return m_Teams[static_cast<std::uint8_t>(TeamColor::Red)];
+	}
+	const Team& GetRedTeam() const {
+		return m_Teams[static_cast<std::uint8_t>(TeamColor::Red)];
+	}
+
+	Team& GetBlueTeam() {
+		return m_Teams[static_cast<std::uint8_t>(TeamColor::Blue)];
+	}
+	const Team& GetBlueTeam() const {
+		return m_Teams[static_cast<std::uint8_t>(TeamColor::Red)];
+	}
+
+	Team& GetTeam(TeamColor team) {
+		return m_Teams[static_cast<std::uint8_t>(team)];
+	}
+	const Team& GetTeam(TeamColor team) const {
+		return m_Teams[static_cast<std::uint8_t>(team)];
+	}
+
+	const TeamList& GetTeams() const {
+		return m_Teams;
+	}
+
+	const TowerList& GetTowers() const {
+		return m_Towers;
+	}
+
+	TowerPtr GetTowerById(TowerID tower);
+
+	const Player* GetPlayerById(PlayerID id) const;
+
+  private:
+	void TickMobs(std::uint64_t delta);
+	void CleanDeadMobs();
+};
+
+
+
+
+
+}  // namespace game
+}  // namespace td

include/td/game/WorldTypes.h

@@ -0,0 +1,119 @@
+#pragma once
+
+#include <td/Maths.h>
+#include <td/game/Mobs.h>
+#include <td/game/Team.h>
+#include <td/game/Towers.h>
+
+namespace td {
+namespace game {
+struct ChunkCoord {
+	std::int16_t x, y;
+
+	friend bool operator==(const td::game::ChunkCoord& first, const td::game::ChunkCoord& other) {
+		return first.x == other.x && first.y == other.y;
+	}
+};
+
+
+class Game;
+
+enum class TileType : std::uint8_t {
+	None = 0,
+	Tower,
+	Walk,
+	Decoration,
+	/*Heal,
+	Lava,
+	Bedrock,
+	Freeze,
+	Ice,*/
+};
+
+static constexpr Color BLACK{0, 0, 0};
+static constexpr Color WHITE{255, 255, 255};
+
+static constexpr Color RED{255, 0, 0};
+static constexpr Color GREEN{0, 255, 0};
+static constexpr Color BLUE{0, 0, 255};
+
+struct Tile {
+	virtual TileType GetType() const = 0;
+};
+
+struct TowerTile : Tile {
+	std::uint8_t color_palette_ref;
+	TeamColor team_owner;
+
+	virtual TileType GetType() const {
+		return TileType::Tower;
+	}
+};
+
+struct WalkableTile : Tile {
+	Direction direction;
+
+	virtual TileType GetType() const {
+		return TileType::Walk;
+	}
+};
+
+struct DecorationTile : Tile {
+	std::uint16_t color_palette_ref;
+
+	virtual TileType GetType() const {
+		return TileType::Decoration;
+	}
+};
+
+typedef std::shared_ptr<Tile> TilePtr;
+typedef std::vector<std::uint16_t> ChunkPalette;
+
+typedef std::shared_ptr<WalkableTile> WalkableTilePtr;
+
+typedef std::uint32_t TileIndex;
+
+// 32 x 32 area
+struct Chunk {
+	enum { ChunkWidth = 32, ChunkHeight = 32, ChunkSize = ChunkWidth * ChunkHeight };
+	typedef std::array<std::uint16_t, ChunkSize> ChunkData;
+
+	// stores index of tile palette
+	ChunkData tiles{0};
+	ChunkPalette palette;
+
+	TileIndex GetTileIndex(std::uint16_t tileNumber) const {
+		TileIndex chunkPaletteIndex = tiles.at(tileNumber);
+		if (chunkPaletteIndex == 0)	 // index 0 means empty tile     index 1 = first tile
+			return 0;
+		return palette.at(chunkPaletteIndex);
+	}
+};
+
+typedef std::shared_ptr<Chunk> ChunkPtr;
+
+typedef std::array<Color, 2> TowerTileColorPalette;
+
+typedef std::vector<TilePtr> TilePalette;
+
+typedef std::vector<MobPtr> MobList;
+
+typedef std::array<Color, 2> SpawnColorPalette;
+
+typedef std::vector<TowerPtr> TowerList;
+
+
+}  // namespace game
+
+}  // namespace td
+
+
+
+namespace std {
+template <>
+struct hash<td::game::ChunkCoord> {
+	std::size_t operator()(const td::game::ChunkCoord& key) const noexcept {
+		return std::hash<std::int16_t>()(key.x << 16 | key.y);
+	}
+};
+}  // namespace std