migrate main

src/td/display/state/DebugWorldState.cpp

@@ -0,0 +1,162 @@
+#include <td/display/state/DebugWorldState.h>
+
+#include <chrono>
+#include <fstream>
+#include <iostream>
+
+#include <td/game/World.h>
+#include <td/protocol/packet/PacketSerialize.h>
+#include <td/protocol/packet/Packets.h>
+#include <td/render/renderer/EntityRenderer.h>
+#include <td/render/renderer/TowerRenderer.h>
+#include <td/render/renderer/WorldRenderer.h>
+#include <td/simulation/ClientSimulation.h>
+
+#include <sp/common/DataBuffer.h>
+#include <sp/extensions/Compress.h>
+#include <sp/io/MessageStream.h>
+#include <sp/io/StdIo.h>
+
+#include <server/Server.h>
+#include <server/socket/FakeSocket.h>
+#include <server/state/GameState.h>
+
+#include <client/Client.h>
+#include <client/socket/FakeSocket.h>
+#include <client/state/GameState.h>
+
+#include <td/display/Display.h>
+#include <td/display/state/DebugWorldState.h>
+
+namespace td {
+
+class ClientHandler : public protocol::PacketHandler {
+  private:
+	sim::ClientSimulation& m_Simulation;
+
+	using protocol::PacketHandler::Handle;
+
+  public:
+	ClientHandler(sim::ClientSimulation& a_Simulation) : m_Simulation(a_Simulation) {}
+
+	void Handle(const protocol::packets::LockStepsPacket& a_LockStep) {
+		m_Simulation.Handle(a_LockStep);
+	}
+
+	void Handle(const protocol::packets::LockStepResponsePacket& a_LockStep) {
+		m_Simulation.Handle(a_LockStep);
+	}
+};
+
+class WorldApply : public protocol::PacketHandler {
+  private:
+	game::World& m_World;
+	using protocol::PacketHandler::Handle;
+
+  public:
+	WorldApply(game::World& a_World) : m_World(a_World) {}
+
+	void Handle(const protocol::packets::WorldHeaderPacket& a_Header) override {
+		m_World.LoadMap(*a_Header);
+	}
+
+	void Handle(const protocol::packets::WorldDataPacket& a_Data) override {
+		m_World.LoadMap(*a_Data);
+	}
+};
+
+void Save(const protocol::PacketBase& header, const protocol::PacketBase& data) {
+	auto comp = std::make_shared<sp::ZlibCompress>();
+
+	std::ofstream fStream("test/tdmap.tdmap3");
+	auto out = std::make_shared<sp::StdOuput>(fStream);
+
+	sp::MessageStream<protocol::PacketFactory> stream(std::move(out), std::move(comp));
+
+	stream.WriteMessage(header, false);
+	stream.WriteMessage(data, false);
+}
+
+game::WorldPtr GetWorld() {
+	auto comp = std::make_shared<sp::ZlibCompress>();
+
+	std::ifstream fStream("test/tdmap.tdmap2");
+	auto out = std::make_shared<sp::StdInput>(fStream);
+
+	sp::MessageStream<protocol::PacketFactory> stream(std::move(out), std::move(comp));
+
+	auto header = stream.ReadMessage(protocol::PacketID::WorldHeader);
+	auto data = stream.ReadMessage(protocol::PacketID::WorldData);
+
+	auto w = std::make_shared<game::World>();
+	auto wa = std::make_shared<WorldApply>(*w);
+
+	protocol::PacketDispatcher d;
+	d.RegisterHandler(wa);
+
+	d.Dispatch(*header);
+	d.Dispatch(*data);
+
+	Save(*header, *data);
+
+	return w;
+}
+
+DebugWorldState::DebugWorldState(Display& a_Display) : DisplayState(a_Display) {
+	game::WorldPtr serverWorld = GetWorld();
+
+	// server
+	auto serverFakeSocket = std::make_shared<server::FakeSocket>();
+	m_Server = std::make_unique<server::Server>(serverFakeSocket);
+
+	// client
+	auto clientFakeSocket = client::FakeSocket::Connect(serverFakeSocket);
+	m_Client = std::make_unique<client::Client>(clientFakeSocket);
+
+	game::WorldPtr clientWorld = GetWorld();
+
+	m_Renderer.AddRenderer<render::WorldRenderer>(m_Camera, *clientWorld);
+	m_Renderer.AddRenderer<render::EntityRenderer>(m_Camera, *clientWorld);
+	m_Renderer.AddRenderer<render::TowerRenderer>(m_Camera, *clientWorld);
+
+	m_Camera.SetCamPos({77, 7, 13});
+	m_Camera.UpdatePerspective(m_StateMachine.GetAspectRatio());
+
+	m_Simulation = std::make_unique<sim::ClientSimulation>(*clientWorld, STEP_TIME);
+
+	m_ClientHandler = std::make_unique<ClientHandler>(*m_Simulation);
+
+	// packets from the server to the client
+	clientFakeSocket->OnReceive.Connect([this](const protocol::PacketBase& a_Packet) { a_Packet.Dispatch(*m_ClientHandler); });
+
+	m_Simulation->OnMissingLockSteps.Connect([clientFakeSocket](const std::vector<td::StepTime>& a_MissingSteps) {
+		clientFakeSocket->Send(protocol::packets::LockStepRequestPacket(a_MissingSteps));
+	});
+
+	m_Server->ChangeState<server::GameState>(serverWorld);
+	m_Client->ChangeState<client::GameState>(clientWorld);
+}
+
+void DebugWorldState::Update(float a_Delta) {
+	m_Server->Update(a_Delta);
+	m_Client->Update(a_Delta);
+	float lerp = m_Simulation->Update(a_Delta);
+	m_Renderer.Render(lerp);
+}
+
+void DebugWorldState::OnAspectRatioChange(float a_Ratio) {
+	m_Camera.UpdatePerspective(a_Ratio);
+}
+
+void DebugWorldState::OnKeyDown(SDL_Keycode a_Key) {
+	// temporary tests
+	if (a_Key == SDLK_A) {
+		m_Client->SendPacket(td::protocol::packets::SpawnTroopPacket(td::EntityType::Zombie, 1));
+	} else if (a_Key == SDLK_Z) {
+		m_Client->SendPacket(td::protocol::packets::PlaceTowerPacket(td::TowerType::Archer, td::TowerCoords(77, 13)));
+	}
+}
+
+DebugWorldState::~DebugWorldState() {}
+
+}  // namespace td