Persson-dev/Tower-Defense2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

send world to client

Browse Source
This commit is contained in:
Simon Pribylski
2025-08-22 11:41:58 +02:00
parent 20acbc0499
commit 7d58b881b2
22 changed files with 217 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
src/td/display/state/DebugWorldState.cpp
View File

@@ -1,101 +1,69 @@
#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 <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 <server/state/LobbyState.h>
#include <client/Client.h>
#include <client/socket/FakeSocket.h>
#include <client/state/GameState.h>
#include <client/state/LoggingState.h>
#include <td/display/Display.h>
#include <td/display/state/DebugWorldState.h>
namespace td {
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.ReadConcreteMessage<protocol::packets::WorldHeaderPacket>();
auto data = stream.ReadConcreteMessage<protocol::packets::WorldDataPacket>();
auto w = std::make_shared<game::World>();
w->LoadMap(**header);
w->LoadMap(**data);
// Save(*header, *data);
return w;
}
DebugWorldState::DebugWorldState(Display& a_Display) : DisplayState(a_Display) {
// server
game::WorldPtr serverWorld = GetWorld();
auto serverFakeSocket = std::make_shared<server::FakeSocket>();
m_Server = std::make_unique<server::Server>(serverFakeSocket);
// client
game::WorldPtr clientWorld = GetWorld();
auto clientFakeSocket = client::FakeSocket::Connect(serverFakeSocket);
m_Client = std::make_unique<client::Client>(clientFakeSocket, "Player0");
// client2
auto clientFakeSocket2 = client::FakeSocket::Connect(serverFakeSocket);
m_Client2 = std::make_unique<client::Client>(clientFakeSocket2, "Player1");
// TODO: make it better
m_Client->OnStateChange.Connect([this](client::Client::State& a_State) {
if (auto gameState = dynamic_cast<client::GameState*>(&a_State)) {
// render
auto clientWorld = gameState->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);
// update state
m_ClientState = gameState;
}
});
// render
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_Client->ChangeState<client::LoggingState>("Player0");
std::cout << "Switched to login!\n";
// // client2
// auto clientFakeSocket2 = client::FakeSocket::Connect(serverFakeSocket);
// m_Client2 = std::make_unique<client::Client>(clientFakeSocket2, "Player1");
// m_Client2->ChangeState<client::LoggingState>("Player1");
// camera
m_Camera.SetCamPos({77, 7, 13});
m_Camera.UpdatePerspective(m_StateMachine.GetAspectRatio());
// states
m_ClientState = m_Client->ChangeState<client::GameState>(clientWorld, STEP_TIME);
m_Server->ChangeState<server::GameState>(serverWorld);
}
void DebugWorldState::Update(float a_Delta) {
m_Server->Update(a_Delta);
m_Client->Update(a_Delta);
// TODO: m_ClientState might be invalid !
m_Renderer.Render(m_ClientState->GetCurrentLerp());
if (m_ClientState)
m_Renderer.Render(m_ClientState->GetCurrentLerp());
}
void DebugWorldState::OnAspectRatioChange(float a_Ratio) {

13
src/td/game/World.cpp
View File

@@ -1,6 +1,7 @@
#include <td/game/World.h>
#include <td/simulation/WorldTicker.h>
#include <td/protocol/packet/PacketSerialize.h>
namespace td {
namespace game {
@@ -14,7 +15,7 @@ class ColorTileVisitor : public TileHandler {
ColorTileVisitor(const World& a_World) : m_World(a_World), m_Result(nullptr) {}
virtual void Handle(const EmptyTile& a_Tile) override {}
virtual void Handle(const TowerTile& a_Tile) override {
m_Result = &m_World.GetTowerTileColorPalette()[a_Tile->m_ColorPaletteRef];
}
@@ -62,6 +63,16 @@ bool World::LoadMap(const protocol::pdata::WorldHeader& a_WorldHeader) {
return true;
}
protocol::packets::WorldHeaderPacket World::GetPacketHeader() const {
return protocol::packets::WorldHeaderPacket(m_TowerPlacePalette, m_WalkablePalette, m_DecorationPalette, m_Background,
m_SpawnColorPalette, m_TilePalette, GetRedTeam().GetSpawn(), GetBlueTeam().GetSpawn(), GetRedTeam().GetCastle(),
GetBlueTeam().GetCastle());
}
protocol::packets::WorldDataPacket World::GetPacketData() const {
return protocol::packets::WorldDataPacket(m_Chunks);
}
bool World::LoadMap(const protocol::pdata::WorldData& a_WorldData) {
m_Chunks = a_WorldData.m_Chunks;
return true;