and again

src/main.cpp

@@ -20,11 +20,11 @@ class WorldApply : public td::protocol::PacketHandler {
   public:
 	WorldApply(td::game::World& a_World) : m_World(a_World) {}
 
-	void Handle(const td::protocol::pdata::WorldHeader& a_Header) override {
-		m_World.LoadMap(a_Header);
+	void Handle(const td::protocol::packets::WorldHeaderPacket& a_Header) override {
+		m_World.LoadMap(*a_Header);
 	}
-	void Handle(const td::protocol::pdata::WorldData& a_Data) override {
-		m_World.LoadMap(a_Data);
+	void Handle(const td::protocol::packets::WorldDataPacket& a_Data) override {
+		m_World.LoadMap(*a_Data);
 	}
 };
 
@@ -93,15 +93,15 @@ int main(int argc, char** argv) {
 	renderer.AddRenderer<td::render::WorldRenderer>(cam, w);
 	renderer.AddRenderer<td::render::EntityRenderer>(cam, w);
 
-	cam.SetCamPos({77, 25, 13});
+	cam.SetCamPos({77, 5, 13});
 	cam.UpdatePerspective(display.GetAspectRatio());
 
-	td::sim::RealTimeSimulation simulation(w, std::move(gh), 1000);
+	td::sim::RealTimeSimulation simulation(w, std::move(gh), 2000);
 
 	while (!display.IsCloseRequested()) {
 		display.PollEvents();
-		simulation.Update();
-		renderer.Render();
+		float lerp = simulation.Update();
+		renderer.Render(lerp);
 		display.Update();
 	}
 

src/td/game/World.cpp

@@ -5,9 +5,7 @@
 namespace td {
 namespace game {
 
-World::World() : m_CurrentState{.m_Teams{Team{TeamColor::Red}, Team{TeamColor::Blue}}} {
-	
-}
+World::World() : m_CurrentState{.m_Teams{Team{TeamColor::Red}, Team{TeamColor::Blue}}}, m_NextState{.m_Teams{Team{TeamColor::Red}, Team{TeamColor::Blue}}} {}
 
 const Color* World::GetTileColor(TilePtr tile) const {
 	switch (tile->GetType()) {
@@ -58,7 +56,8 @@ bool World::LoadMap(const protocol::pdata::WorldData& a_WorldData) {
 }
 
 void World::Tick(const protocol::LockStep& a_LockStep, FpFloat a_Delta) {
-	m_CurrentState = m_Ticker.NextStep(*this, m_CurrentState, a_LockStep, a_Delta);
+	m_CurrentState = m_NextState;
+	m_NextState = m_Ticker.NextStep(*this, m_NextState, a_LockStep, a_Delta);
 }
 
 }  // namespace game

src/td/render/renderer/EntityRenderer.cpp

@@ -13,16 +13,19 @@ EntityRenderer::EntityRenderer(Camera& a_Camera, const game::World& a_World) : R
 
 EntityRenderer::~EntityRenderer() {}
 
-void EntityRenderer::Render() {
+
+
+void EntityRenderer::Render(float a_Lerp) {
 	m_Shader->Start();
 	for (const auto& mob : m_World.GetMobList()) {
-		const auto mobCoords = mob->GetPosition();
-		float x = static_cast<float>(mobCoords.x);
-		float z = static_cast<float>(mobCoords.y);
+
+		float x = Lerp<game::Mob>(*mob, a_Lerp, [](const game::Mob& a_Mob) { return static_cast<float>(a_Mob.m_Position.x); });
+		float z = Lerp<game::Mob>(*mob, a_Lerp, [](const game::Mob& a_Mob) { return static_cast<float>(a_Mob.m_Position.y); });
+
 		m_Shader->SetModelPos({x, 1, z});
 		Renderer::Render(*m_EntityVao);
 	}
 }
 
-}	 // namespace render
+}  // namespace render
 }  // namespace td

src/td/render/renderer/WorldRenderer.cpp

@@ -7,13 +7,13 @@
 namespace td {
 namespace render {
 
-WorldRenderer::WorldRenderer(Camera& a_Camera, const game::World& a_World) : Renderer(a_Camera), m_World(a_World) {
-	m_WorldVao = std::make_unique<GL::VertexArray>(std::move(WorldLoader::LoadWorldModel(&a_World)));
+WorldRenderer::WorldRenderer(Camera& a_Camera, const game::World& a_World) : Renderer(a_Camera) {
+	m_WorldVao = std::make_unique<GL::VertexArray>(WorldLoader::LoadWorldModel(&a_World));
 }
 
 WorldRenderer::~WorldRenderer() {}
 
-void WorldRenderer::Render() {
+void WorldRenderer::Render(float a_Lerp) {
 	m_Shader->Start();
 	Renderer::Render(*m_WorldVao);
 	ImGui::ShowDemoWindow();

src/td/simulation/CommandApply.cpp

@@ -5,9 +5,9 @@ namespace sim {
 
 CommandApply::CommandApply(const game::World& a_World, WorldSnapshot& a_Snapshot) : m_World(a_World), m_Snapshot(a_Snapshot) {}
 
-void CommandApply::Handle(const protocol::cdata::SpawnTroop& a_SpawnTroop) {
-	auto zombie = std::make_shared<game::Zombie>(0, *a_SpawnTroop.m_Level, a_SpawnTroop.m_Sender);
-	zombie->GetPosition() = a_SpawnTroop.m_Position;
+void CommandApply::Handle(const protocol::commands::SpawnTroopCommand& a_SpawnTroop) {
+	auto zombie = std::make_shared<game::Zombie>();
+	zombie->m_Position = a_SpawnTroop->m_Position;
 	m_Snapshot.m_Mobs.push_back(zombie);
 }
 

src/td/simulation/RealTimeSimulation.cpp

@@ -16,16 +16,24 @@ RealTimeSimulation::RealTimeSimulation(game::World& a_World, GameHistory&& a_His
 	m_History(std::move(a_History)),
 	m_CurrentTime(0),
 	m_LastTime(GetTime()),
-	m_CurrentStep(0) {}
+	m_CurrentStep(0) {
+	Step();
+}
 
-void RealTimeSimulation::Update() {
+float RealTimeSimulation::Update() {
+	// TODO: handle freezes (m_CurrentTime > 2 * m_StepTime)
 	m_CurrentTime += GetTime() - m_LastTime;
 	m_LastTime = GetTime();
 	if (m_CurrentTime > m_StepTime) {
-		m_World.Tick(m_History[m_CurrentStep], FpFloat(m_StepTime) / FpFloat(1000));
-		m_CurrentStep++;
+		Step();
 		m_CurrentTime -= m_StepTime;
 	}
+	return (float) m_CurrentTime / (float) m_StepTime;
+}
+
+void RealTimeSimulation::Step() {
+	m_World.Tick(m_History[m_CurrentStep], FpFloat(m_StepTime) / FpFloat(1000));
+	m_CurrentStep++;
 }
 
 }  // namespace sim

src/td/simulation/WorldTicker.cpp

@@ -13,9 +13,9 @@ WorldTicker::WorldTicker() {
 }
 
 WorldSnapshot WorldTicker::NextStep(
-	const game::World& a_World, const WorldSnapshot& a_PreviousState, const protocol::LockStep& a_LockStep, FpFloat a_Delta) {
+	const game::World& a_World, WorldSnapshot& a_PreviousState, const protocol::LockStep& a_LockStep, FpFloat a_Delta) {
 	WorldSnapshot next = CreateNext(a_PreviousState);
-	ApplySteps(a_World, next, a_LockStep);
+	ApplySteps(a_World, next, a_LockStep); // maybe swap with tick ?
 	Tick(a_World, next, a_Delta);
 	return next;
 }
@@ -33,8 +33,21 @@ void WorldTicker::Tick(const game::World& a_World, WorldSnapshot& a_State, FpFlo
 	}
 }
 
-WorldSnapshot WorldTicker::CreateNext(const WorldSnapshot& a_PreviousState) {
-	return a_PreviousState;
+WorldSnapshot WorldTicker::CreateNext(WorldSnapshot& a_PreviousState) {
+	static game::MobFactory mobFactory;
+
+	WorldSnapshot next {
+		.m_Towers = a_PreviousState.m_Towers,
+		.m_Teams = a_PreviousState.m_Teams
+	};
+	next.m_Mobs.reserve(a_PreviousState.m_Mobs.size());
+	for (auto& mob : a_PreviousState.m_Mobs) {
+		game::MobPtr newMob = std::shared_ptr<game::Mob>(mobFactory.CreateMessage(mob->GetId()).release());
+		*newMob = *mob;
+		mob->m_Next = newMob;
+		next.m_Mobs.push_back(newMob);
+	}
+	return next;
 }
 
 }  // namespace sim

src/td/simulation/system/EntityMove.cpp

@@ -5,7 +5,7 @@ namespace sim {
 
 void EntityMove::Tick(const game::World& a_World, WorldSnapshot& a_State, FpFloat a_Delta) {
 	for (auto& mob : a_State.m_Mobs) {
-		mob->GetPosition().x += a_Delta;
+		mob->m_Position.x += a_Delta;
 	}
 }