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

feat: allow map edition with exteral tools

Browse Source
This commit is contained in:
Simon Pribylski
2021-10-10 11:03:07 +02:00
parent 81dbfed69a
commit d2551c8864
2 changed files with 133 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files

111
src/protocol/Protocol.cpp
View File

@@ -77,12 +77,12 @@ void PlayerLoginPacket::Deserialize(DataBuffer& data) {
data >> m_PlayerName;
}
DataBuffer WorldBeginDataPacket::Serialize() const {
DataBuffer WorldBeginDataPacket::SerializeCustom() const {
DataBuffer data;
const game::TowerTileColorPalette towerTilePalette = m_World->getTowerTileColorPalette();
const std::vector<game::Color>& decoTilePalette = m_World->getDecorationPalette();
const game::TowerTileColorPalette towerTilePalette = m_Header.m_TowerPlacePalette;
const std::vector<game::Color>& decoTilePalette = m_Header.m_DecorationPalette;
data << getID() << towerTilePalette << m_World->getWalkableTileColor()
data << getID() << towerTilePalette << m_Header.m_WalkablePalette
<< (std::uint16_t)decoTilePalette.size();
// deco color palette
@@ -91,57 +91,132 @@ DataBuffer WorldBeginDataPacket::Serialize() const {
memcpy((std::uint8_t*)data.data() + bufferSize, decoTilePalette.data(), decoTilePalette.size() * sizeof(game::Color));
const game::Spawn& redSpawn = m_World->getRedTeam().getSpawn(), blueSpawn = m_World->getBlueTeam().getSpawn();
const game::TeamCastle& redCastle = m_World->getRedTeam().getCastle(), blueCastle = m_World->getBlueTeam().getCastle();
const game::Spawn& redSpawn = m_Header.m_RedSpawn, blueSpawn = m_Header.m_BlueSpawn;
const game::TeamCastle& redCastle = m_Header.m_RedCastle, blueCastle = m_Header.m_BlueCastle;
data << redSpawn << redCastle;
data << blueSpawn << blueCastle;
// tile palette
data << m_World->getTilePalette().size();
data << m_Header.m_TilePalette.size();
for (game::TilePtr tile : m_World->getTilePalette()) {
for (game::TilePtr tile : m_Header.m_TilePalette) {
data << tile;
}
data << m_World->getSpawnColors();
data << m_Header.m_SpawnColorPalette;
return data;
}
DataBuffer WorldBeginDataPacket::Serialize() const {
DataBuffer data;
const game::TowerTileColorPalette towerTilePalette = m_Header.m_World->getTowerTileColorPalette();
const std::vector<game::Color>& decoTilePalette = m_Header.m_World->getDecorationPalette();
data << getID() << towerTilePalette << m_Header.m_World->getWalkableTileColor()
<< (std::uint16_t)decoTilePalette.size();
// deco color palette
std::size_t bufferSize = data.GetSize();
data.Resize(bufferSize + decoTilePalette.size() * sizeof(game::Color));
memcpy((std::uint8_t*)data.data() + bufferSize, decoTilePalette.data(), decoTilePalette.size() * sizeof(game::Color));
const game::Spawn& redSpawn = m_Header.m_World->getRedTeam().getSpawn(), blueSpawn = m_Header.m_World->getBlueTeam().getSpawn();
const game::TeamCastle& redCastle = m_Header.m_World->getRedTeam().getCastle(), blueCastle = m_Header.m_World->getBlueTeam().getCastle();
data << redSpawn << redCastle;
data << blueSpawn << blueCastle;
// tile palette
data << m_Header.m_World->getTilePalette().size();
for (game::TilePtr tile : m_Header.m_World->getTilePalette()) {
data << tile;
}
data << m_Header.m_World->getSpawnColors();
return data;
}
void WorldBeginDataPacket::Deserialize(DataBuffer& data) {
data >> m_TowerPlacePalette >> m_WalkablePalette;
data >> m_Header.m_TowerPlacePalette >> m_Header.m_WalkablePalette;
std::uint16_t decoPaletteSize;
data >> decoPaletteSize;
std::size_t decoPalletteSizeByte = decoPaletteSize * sizeof(game::Color);
m_DecorationPalette.reserve(decoPaletteSize);
m_Header.m_DecorationPalette.reserve(decoPaletteSize);
memcpy((void*)m_DecorationPalette.data(), data.data() + data.GetReadOffset(), decoPalletteSizeByte);
memcpy((void*)m_Header.m_DecorationPalette.data(), data.data() + data.GetReadOffset(), decoPalletteSizeByte);
data.SetReadOffset(data.GetReadOffset() + decoPalletteSizeByte);
data >> m_RedSpawn >> m_RedTower;
data >> m_BlueSpawn >> m_BlueTower;
data >> m_Header.m_RedSpawn >> m_Header.m_RedCastle;
data >> m_Header.m_BlueSpawn >> m_Header.m_BlueCastle;
std::uint64_t tilePaletteSize;
data >> tilePaletteSize;
m_TilePalette.reserve(tilePaletteSize);
m_Header.m_TilePalette.reserve(tilePaletteSize);
for (std::uint64_t tileNumber = 0; tileNumber < tilePaletteSize; tileNumber++) {
game::TilePtr tile;
data >> tile;
m_TilePalette.push_back(tile);
m_Header.m_TilePalette.push_back(tile);
}
data >> m_SpawnColorPalette;
data >> m_Header.m_SpawnColorPalette;
}
typedef std::vector<uint64_t> ChunkPackedData;
DataBuffer WorldDataPacket::SerializeCustom() const {
DataBuffer data;
data << getID() << m_WorldData.m_Chunks.size();
for (const auto& pair : m_WorldData.m_Chunks) {
game::ChunkCoord coords = pair.first;
game::ChunkPtr chunk = pair.second;
data << coords.first << coords.second << (std::uint64_t)chunk->palette.size();
std::size_t bufferSize = data.GetSize();
data.Resize(data.GetSize() + chunk->palette.size() * sizeof(game::ChunkPalette::value_type));
memcpy((std::uint8_t*)data.data() + bufferSize, chunk->palette.data(), chunk->palette.size() * sizeof(game::ChunkPalette::value_type));
std::uint8_t bitsPerTile = countBits(chunk->palette.size());
game::ChunkData::value_type individualValueMask = ((1 << bitsPerTile) - 1);
ChunkPackedData chunkData(game::Chunk::ChunkSize / (BITS_IN_BYTE * sizeof(ChunkPackedData::value_type) / bitsPerTile), 0);
for (int tileNumber = 0; tileNumber < game::Chunk::ChunkSize; tileNumber++) {
int startLong = (tileNumber * bitsPerTile) / BITS_IN_LONG;
int startOffset = (tileNumber * bitsPerTile) % BITS_IN_LONG;
int endLong = ((tileNumber + 1) * bitsPerTile - 1) / BITS_IN_LONG;
std::uint64_t value = chunk->tiles[tileNumber];
value &= individualValueMask;
chunkData[startLong] |= (value << startOffset);
if (startLong != endLong) {
chunkData[endLong] = (value >> (BITS_IN_LONG - startOffset));
}
}
bufferSize = data.GetSize();
data.Resize(data.GetSize() + chunkData.size() * sizeof(ChunkPackedData::value_type));
memcpy((std::uint8_t*)data.data() + bufferSize, chunkData.data(), chunkData.size() * sizeof(ChunkPackedData::value_type));
}
return data;
}
DataBuffer WorldDataPacket::Serialize() const {
DataBuffer data;
data << getID() << m_World->getChunks().size();
@@ -233,7 +308,7 @@ void WorldDataPacket::Deserialize(DataBuffer& data) {
}
m_Chunks.insert({ {chunkX, chunkY}, chunk });
m_WorldData.m_Chunks.insert({ {chunkX, chunkY}, chunk });
}
}