Aurailus
/
Zepha
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove ServerPlayer, clean up ServerClient

master
Nicole Collings 2020-02-17 15:55:39 -08:00
parent f27a40abeb
commit 2097d3a954
12 changed files with 103 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/CMakeLists.txt
View File

@ -53,9 +53,7 @@ set(ZEPHA_SRC
server/Server.h
util/net/Packet.cpp
util/net/Packet.h
server/conn/ServerPlayer.cpp
server/conn/ServerPlayer.h
game/scene/net/ClientNetworkInterpreter.cpp
game/scene/net/ClientNetworkInterpreter.cpp
game/scene/net/ClientNetworkInterpreter.h
def/gen/MapGen.cpp
def/gen/MapGen.h

21
src/server/Server.cpp
View File

@ -2,8 +2,9 @@
// Created by aurailus on 09/01/19.
//
#include <thread>
#include "Server.h"
#include "../util/net/Deserializer.h"
Server::Server(const std::string& path, unsigned short port, const std::string& subgame) :
defs(subgame, path),
@ -56,7 +57,7 @@ void Server::update() {
Packet p(event.packet);
ServerClient* client = static_cast<ServerClient*>(event.peer->data);
if (client->hasPlayer()) {
if (client->hasPlayer) {
handlePlayerPacket(*client, p);
}
else {
@ -81,8 +82,6 @@ void Server::update() {
}
void Server::handlePlayerPacket(ServerClient &client, Packet& p) {
ServerPlayer& player = client.getPlayer();
switch (p.type) {
default: {
std::cout << Log::err << "Invalid packet type (" << static_cast<int>(p.type) << ") recieved." << Log::endl;
@ -91,20 +90,20 @@ void Server::handlePlayerPacket(ServerClient &client, Packet& p) {
case PacketType::THIS_PLAYER_INFO: {
Deserializer d(p.data);
player.setPos(d.read<glm::vec3>());
player.setAngle(d.read<float>());
client.setPos(d.read<glm::vec3>());
client.setAngle(d.read<float>());
//Send All ServerClients the new positon
Packet r(PacketType::PLAYER_INFO);
r.data = Serializer()
.append(client.getConnectID())
.append(player.getPos())
.append(player.getAngle())
.append(client.cid)
.append(client.getPos())
.append(client.getAngle())
.data;
for (auto& iter : clientList.clients) {
if (iter->getConnectID() != client.getConnectID()) {
r.sendTo(iter->getPeer(), PacketChannel::ENTITY);
if (iter->cid != client.cid) {
r.sendTo(iter->peer, PacketChannel::ENTITY);
}
}

12
src/server/Server.h
View File

@ -4,20 +4,14 @@
#pragma once
#include <thread>
#include <vector>
#include <iostream>
#include "conn/ServerPlayer.h"
#include "conn/ServerClient.h"
#include "conn/ServerClients.h"
#include "world/ServerWorld.h"
#include "config/ServerConfig.h"
#include "../def/ServerDefs.h"
#include "../util/net/Packet.h"
#include "../util/Timer.h"
#include "../util/net/NetHandler.h"
#include "../util/net/Serializer.h"
class ServerClient;
class Packet;
class Server {
public:

16
src/server/config/ServerConfig.cpp
View File

@ -28,26 +28,26 @@ bool ServerConfig::handlePacket(ServerClient &client, Packet &r) {
Serializer()
.append(blockIdentifierList)
.packet(PacketType::BLOCK_IDENTIFIER_LIST)
.sendTo(client.getPeer(), PacketChannel::CONNECT);
.sendTo(client.peer, PacketChannel::CONNECT);
break;
}
case PacketType::BIOME_IDENTIFIER_LIST: {
Serializer()
.append(biomeIdentifierList)
.packet(PacketType::BIOME_IDENTIFIER_LIST)
.sendTo(client.getPeer(), PacketChannel::CONNECT);
.sendTo(client.peer, PacketChannel::CONNECT);
break;
}
case PacketType::MODS: {
for (LuaMod& mod : defs.luaApi.mods) {
Packet p(PacketType::MODS);
p.data = Serializer().append(mod.serialized).data;
p.sendTo(client.getPeer(), PacketChannel::CONNECT);
p.sendTo(client.peer, PacketChannel::CONNECT);
}
std::vector<std::string> order {};
for (LuaMod& mod : defs.luaApi.mods) order.push_back(mod.config.name);
Serializer().append(order).packet(PacketType::MOD_ORDER).sendTo(client.getPeer(), PacketChannel::CONNECT);
Serializer().append(order).packet(PacketType::MOD_ORDER).sendTo(client.peer, PacketChannel::CONNECT);
break;
}
case PacketType::MEDIA: {
@ -65,7 +65,7 @@ bool ServerConfig::handlePacket(ServerClient &client, Packet &r) {
packetSize = 0;
s = {};
p.sendTo(client.getPeer(), PacketChannel::CONNECT);
p.sendTo(client.peer, PacketChannel::CONNECT);
}
s.append(static_cast<int>(AssetType::TEXTURE))
@ -86,7 +86,7 @@ bool ServerConfig::handlePacket(ServerClient &client, Packet &r) {
packetSize = 0;
s = {};
p.sendTo(client.getPeer(), PacketChannel::CONNECT);
p.sendTo(client.peer, PacketChannel::CONNECT);
}
s.append(static_cast<int>(AssetType::MODEL))
@ -101,10 +101,10 @@ bool ServerConfig::handlePacket(ServerClient &client, Packet &r) {
Packet p(PacketType::MEDIA);
p.data = s.data;
p.sendTo(client.getPeer(), PacketChannel::CONNECT);
p.sendTo(client.peer, PacketChannel::CONNECT);
Packet d(PacketType::MEDIA_DONE);
d.sendTo(client.getPeer(), PacketChannel::CONNECT);
d.sendTo(client.peer, PacketChannel::CONNECT);
}
}
return false;

43
src/server/conn/ServerClient.cpp
View File

@ -8,36 +8,37 @@
ServerClient::ServerClient(ENetPeer *peer, ENetAddress address) :
peer(peer),
address(address),
connectID(peer->connectID) {}
cid(peer->connectID) {}
unsigned int ServerClient::getConnectID() {
return connectID;
void ServerClient::setMapBlockIntegrity(glm::ivec3 pos, unsigned long long integrity) {
mapBlockIntegrity[pos] = integrity;
}
void ServerClient::initPlayer() {
delete player;
player = new ServerPlayer({0, 0, 0}, connectID, "TEMPORARY");
unsigned long long ServerClient::getMapBlockIntegrity(glm::ivec3 pos) {
if (mapBlockIntegrity.count(pos)) return mapBlockIntegrity[pos];
return 0;
}
bool ServerClient::hasPlayer() const {
return player != nullptr;
void ServerClient::setPos(glm::vec3 pos) {
glm::vec3 lastMapBlock = Space::MapBlock::world::fromBlock(this->pos);
glm::vec3 newMapBlock = Space::MapBlock::world::fromBlock(pos);
if (newMapBlock != lastMapBlock && !changedMapBlocks) {
lastMapBlock = newMapBlock;
changedMapBlocks = true;
}
this->pos = pos;
}
ServerPlayer& ServerClient::getPlayer() {
if (!player) throw "getPlayer() called on client without player!";
return *player;
glm::vec3 ServerClient::getPos() {
return pos;
}
const ServerPlayer &ServerClient::cGetPlayer() const {
if (!player) throw "getPlayer() called on client without player!";
return *player;
void ServerClient::setAngle(float angle) {
this->angle = angle;
}
ENetPeer& ServerClient::getPeer() {
return *peer;
float ServerClient::getAngle() {
return angle;
}
ServerClient::~ServerClient() {
delete player;
}

35
src/server/conn/ServerClient.h
View File

@ -5,27 +5,40 @@
#pragma once
#include <enet/enet.h>
#include "ServerPlayer.h"
#include <glm/vec3.hpp>
#include <unordered_map>
#include "../../util/Vec.h"
class ServerClient {
public:
const static int CHUNK_SEND_RANGE = 32;
ServerClient(ENetPeer* peer, ENetAddress address);
void initPlayer();
void setPos(glm::vec3 pos);
glm::vec3 getPos();
bool hasPlayer() const;
const ServerPlayer& cGetPlayer() const;
ServerPlayer& getPlayer();
ENetPeer& getPeer();
void setAngle(float angle);
float getAngle();
unsigned int getConnectID();
void setMapBlockIntegrity(glm::ivec3 pos, unsigned long long integrity);
unsigned long long getMapBlockIntegrity(glm::ivec3 pos);
bool hasPlayer = false;
unsigned int cid;
std::string username;
~ServerClient();
private:
ENetPeer* peer;
ENetAddress address;
ServerPlayer* player = nullptr;
bool changedMapBlocks = true;
glm::vec3 lastPos {-10000000, -10000000, -10000000};
unsigned int connectID;
private:
glm::vec3 pos {};
float angle = 0;
std::unordered_map<glm::ivec3, unsigned long long, Vec::ivec3> mapBlockIntegrity {};
};

14
src/server/conn/ServerClients.cpp
View File

@ -20,14 +20,14 @@ void ServerClients::handleDisconnect(ENetEvent e) {
ENetPeer* peer = e.peer;
ENetAddress& addr = peer->address;
unsigned int connectID = static_cast<ServerClient*>(peer->data)->getConnectID();
unsigned int cid = static_cast<ServerClient*>(peer->data)->cid;
std::cout << Log::info << NetHandler::intToIPString(addr.host) << ":" << addr.port << " disconnected." << Log::endl;
bool found = false;
auto it = clients.begin();
while (it != clients.end()) {
if ((*it)->getConnectID() == connectID) {
if ((*it)->cid == cid) {
found = true;
clients.erase(it);
break;
@ -39,14 +39,14 @@ void ServerClients::handleDisconnect(ENetEvent e) {
}
void ServerClients::createPlayer(ServerClient &c) {
c.initPlayer();
c.hasPlayer = true;
Packet p(PacketType::THIS_PLAYER_INFO);
p.data = Serializer()
.append(c.getConnectID())
.append(c.getPlayer().getPos())
.append(c.getPlayer().getAngle())
.append(c.cid)
.append(c.getPos())
.append(c.getAngle())
.data;
p.sendTo(c.getPeer(), PacketChannel::ENTITY);
p.sendTo(c.peer, PacketChannel::ENTITY);
}

54
src/server/conn/ServerPlayer.cpp
View File

@ -1,54 +0,0 @@
//
// Created by aurailus on 11/01/19.
//
#include <iostream>
#include "ServerPlayer.h"
ServerPlayer::ServerPlayer(glm::vec3 pos, unsigned int connectID, const std::string& username) :
pos(pos),
connectID(connectID),
username(username) {
mapBlock = Space::MapBlock::world::fromBlock(pos);
lastMapBlock = mapBlock - glm::vec3(200); //Force resending of all chunks around getPlayer.
changedMapBlocks = true;
}
void ServerPlayer::setPos(glm::vec3 pos) {
this->pos = pos;
glm::vec3 newMapBlock = Space::MapBlock::world::fromBlock(pos);
if (newMapBlock != mapBlock) {
if (!changedMapBlocks) {
lastMapBlock = mapBlock;
changedMapBlocks = true;
}
mapBlock = newMapBlock;
}
}
void ServerPlayer::setAngle(float angle) {
this->angle = angle;
}
glm::vec3 ServerPlayer::getPos() {
return pos;
}
float ServerPlayer::getAngle() {
return angle;
}
glm::ivec3 ServerPlayer::getChunkPos() const {
return Space::Chunk::world::fromBlock(pos);
}
void ServerPlayer::setMapBlockIntegrity(glm::vec3 pos, unsigned long long integrity) {
mapBlockIntegrity[pos] = integrity;
}
unsigned long long ServerPlayer::getMapBlockIntegrity(glm::vec3 pos) {
if (mapBlockIntegrity.count(pos)) return mapBlockIntegrity[pos];
return 0;
}

40
src/server/conn/ServerPlayer.h
View File

@ -1,40 +0,0 @@
//
// Created by aurailus on 11/01/19.
//
#pragma once
#include <glm/vec3.hpp>
#include <unordered_map>
#include "../../util/Vec.h"
#include "../../util/Space.h"
class ServerPlayer {
public:
const static int CHUNK_SEND_RANGE = 32;
explicit ServerPlayer(glm::vec3 pos, unsigned int connectID, const std::string& username);
void setPos(glm::vec3 pos);
void setAngle(float angle);
glm::vec3 getPos();
glm::ivec3 getChunkPos() const;
float getAngle();
glm::vec3 mapBlock;
glm::vec3 lastMapBlock;
bool changedMapBlocks = true;
void setMapBlockIntegrity(glm::vec3 pos, unsigned long long integrity);
unsigned long long getMapBlockIntegrity(glm::vec3 pos);
private:
std::string username;
unsigned int connectID;
glm::vec3 pos {};
float angle = 0;
std::unordered_map<glm::vec3, unsigned long long, Vec::vec3> mapBlockIntegrity {};
};

39
src/server/world/ServerWorld.cpp
View File

@ -4,6 +4,13 @@
#include <algorithm>
#include <glm/glm.hpp>
#include <unordered_map>
#include "WorldGenStream.h"
#include "../conn/ServerClient.h"
#include "../../world/chunk/BlockChunk.h"
#include "../../util/Vec.h"
#include "ServerWorld.h"
ServerWorld::ServerWorld(unsigned int seed, ServerDefs& defs, ServerClients& clients) :
@ -58,16 +65,16 @@ void ServerWorld::update(double delta) {
unsigned long long mapBlockIntegrity = dimension.getMapBlockIntegrity(mapBlockPos);
for (auto& client : clientList.clients) {
if (client->hasPlayer()) {
auto playerMapBlock = client->getPlayer().mapBlock;
if (client->hasPlayer) {
auto playerMapBlock = Space::MapBlock::world::fromBlock(client->getPos());
std::pair<glm::ivec3, glm::ivec3> bounds = {
{playerMapBlock.x - MB_GEN_H, playerMapBlock.y - MB_GEN_V, playerMapBlock.z - MB_GEN_H},
{playerMapBlock.x + MB_GEN_H, playerMapBlock.y + MB_GEN_V, playerMapBlock.z + MB_GEN_H}};
if (isInBounds(mapBlockPos, bounds) && client->getPlayer().getMapBlockIntegrity(mapBlockPos) < mapBlockIntegrity) {
if (isInBounds(mapBlockPos, bounds) && client->getMapBlockIntegrity(mapBlockPos) < mapBlockIntegrity) {
client->setMapBlockIntegrity(mapBlockPos, mapBlockIntegrity);
sendChunk(chunk->pos, *client);
client->getPlayer().setMapBlockIntegrity(mapBlockPos, mapBlockIntegrity);
}
}
}
@ -79,10 +86,10 @@ void ServerWorld::update(double delta) {
r.data = Serializer().append(generatedChunks).data;
for (auto& client : clientList.clients) {
if (client->hasPlayer()) {
r.sendTo(client->getPeer(), PacketChannel::SERVER);
if (client->hasPlayer) {
r.sendTo(client->peer, PacketChannel::SERVER);
if (client->getPlayer().changedMapBlocks) changedChunks(*client);
if (client->changedMapBlocks) changedChunks(*client);
}
}
@ -92,15 +99,15 @@ void ServerWorld::update(double delta) {
if (entity->entity->checkAndResetDirty()) {
Packet p = entity->entity->createPacket();
for (auto& client : clientList.clients) {
if (client->hasPlayer()) p.sendTo(client->getPeer(), PacketChannel::ENTITY);
if (client->hasPlayer) p.sendTo(client->peer, PacketChannel::ENTITY);
}
}
}
}
void ServerWorld::changedChunks(ServerClient& client) {
auto mapBlock = client.getPlayer().mapBlock;
auto lastMapBlock = client.getPlayer().lastMapBlock;
auto mapBlock = Space::MapBlock::world::fromBlock(client.getPos());
auto lastMapBlock = Space::MapBlock::world::fromBlock(client.lastPos);
std::pair<glm::ivec3, glm::ivec3> oldBounds = {
{lastMapBlock.x - MB_GEN_H, lastMapBlock.y - MB_GEN_V, lastMapBlock.z - MB_GEN_H},
@ -124,7 +131,7 @@ void ServerWorld::changedChunks(ServerClient& client) {
}
std::cout << "Generating " << mapBlocksGenerating << " blocks, sending " << mapBlocksExisting << " existing blocks." << std::endl;
client.getPlayer().changedMapBlocks = false;
client.changedMapBlocks = false;
}
bool ServerWorld::generateMapBlock(glm::ivec3 pos) {
@ -140,7 +147,7 @@ void ServerWorld::sendChunk(const std::shared_ptr<BlockChunk>& chunk, ServerClie
if (chunk == nullptr || !chunk->generated) return;
Packet r = chunk->serialize();
r.sendTo(peer.getPeer(), PacketChannel::CHUNK);
r.sendTo(peer.peer, PacketChannel::CHUNK);
}
void ServerWorld::sendChunk(const glm::ivec3& pos, ServerClient &peer) {
@ -149,7 +156,7 @@ void ServerWorld::sendChunk(const glm::ivec3& pos, ServerClient &peer) {
void ServerWorld::sendMapBlock(const glm::ivec3& pos, ServerClient &peer) {
unsigned long long mapBlockIntegrity = dimension.getMapBlockIntegrity(pos);
if (peer.getPlayer().getMapBlockIntegrity(pos) < mapBlockIntegrity) {
if (peer.getMapBlockIntegrity(pos) < mapBlockIntegrity) {
auto mapBlock = dimension.getMapBlock(pos);
assert(mapBlock != nullptr);
@ -190,15 +197,15 @@ void ServerWorld::setBlock(glm::ivec3 pos, unsigned int block) {
auto chunkPos = Space::Chunk::world::fromBlock(pos);
for (auto &client : clientList.clients) {
if (client->hasPlayer()) {
auto mapBlock = client->getPlayer().mapBlock;
if (client->hasPlayer) {
auto mapBlock = Space::MapBlock::world::fromBlock(client->getPos());
std::pair<glm::ivec3, glm::ivec3> bounds = {
{mapBlock.x - MB_GEN_H, mapBlock.y - MB_GEN_V, mapBlock.z - MB_GEN_H},
{mapBlock.x + MB_GEN_H, mapBlock.y + MB_GEN_V, mapBlock.z + MB_GEN_H}};
if (isInBounds(Space::MapBlock::world::fromChunk(chunkPos), bounds)) {
b.sendTo(client->getPeer(), PacketChannel::BLOCK);
b.sendTo(client->peer, PacketChannel::BLOCK);
}
}
}

11
src/server/world/ServerWorld.h
View File

@ -4,17 +4,12 @@
#pragma once
#include <unordered_map>
#include <unordered_set>
#include "WorldGenStream.h"
#include "../conn/ServerClient.h"
#include "../conn/ServerPlayer.h"
#include "../../world/chunk/BlockChunk.h"
#include "../../util/Vec.h"
#include "../../def/ServerDefs.h"
#include "../conn/ServerClients.h"
#include "../../world/ServerDimension.h"
#include "../../def/ServerDefs.h"
#include "../../game/scene/world/World.h"
#include "../../world/ServerDimension.h"
class ServerWorld : public World {
public:
@ -52,6 +47,6 @@ private:
unsigned int generatedChunks = 0;
//Static vector of chunks to place around players
std::vector<glm::vec3> generateOrder;
std::vector<glm::ivec3> generateOrder;
};

4
src/world/ServerDimension.cpp
View File

@ -15,8 +15,8 @@ void ServerDimension::update(const std::vector<ServerClient*> &clients) {
bool clientNearby = false;
for (const auto& client : clients) {
if (client->hasPlayer()) {
auto clientPos = Space::MapBlock::world::fromChunk(client->cGetPlayer().getChunkPos());
if (client->hasPlayer) {
auto clientPos = Space::MapBlock::world::fromBlock(client->getPos());
if (abs(clientPos.x - mapBlockPos.x) <= ServerWorld::MB_GEN_H + 1
&& abs(clientPos.y - mapBlockPos.y) <= ServerWorld::MB_GEN_V + 1
&& abs(clientPos.z - mapBlockPos.z) <= ServerWorld::MB_GEN_H + 1) {