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

Revise Server Client Handling 

Fix Transparency in Mushroom Textures
master
aurailus 2019-07-03 13:24:19 -07:00
parent bb436e23c4
commit 76173d06d1
26 changed files with 392 additions and 384 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.idea/inspectionProfiles/Project_Default.xml
View File

@ -2,7 +2,7 @@
<profile version="1.0">
<option name="myName" value="Project Default" />
<inspection_tool class="ClangTidyInspection" enabled="true" level="WARNING" enabled_by_default="true">
<option name="clangTidyChecks" value="*,-android-*,-bugprone-bool-pointer-implicit-conversion,-cert-env33-c,-cert-dcl50-cpp,-cert-dcl59-cpp,-cppcoreguidelines-no-malloc,-cppcoreguidelines-owning-memory,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-constant-array-index,-cppcoreguidelines-pro-bounds-pointer-arithmetic,-cppcoreguidelines-pro-type-const-cast,-cppcoreguidelines-pro-type-cstyle-cast,-cppcoreguidelines-pro-type-reinterpret-cast,-cppcoreguidelines-pro-type-union-access,-cppcoreguidelines-pro-type-vararg,-cppcoreguidelines-special-member-functions,-fuchsia-*,-google-*,google-default-arguments,google-explicit-constructor,google-runtime-member-string-references,google-runtime-operator,-hicpp-braces-around-statements,-hicpp-named-parameter,-hicpp-no-array-decay,-hicpp-no-assembler,-hicpp-no-malloc,-hicpp-function-size,-hicpp-special-member-functions,-hicpp-vararg,-llvm-*,-objc-*,-readability-else-after-return,-readability-implicit-bool-conversion,-readability-named-parameter,-readability-simplify-boolean-expr,-readability-braces-around-statements,-readability-identifier-naming,-readability-function-size,-readability-redundant-member-init,-misc-bool-pointer-implicit-conversion,-misc-definitions-in-headers,-misc-unused-alias-decls,-misc-unused-parameters,-misc-unused-using-decls,-modernize-use-using,-modernize-use-default-member-init,-clang-diagnostic-*,-clang-analyzer-*,-cert-msc30-c,-cert-msc50-cpp,-bugprone-integer-division" />
<option name="clangTidyChecks" value="*,-android-*,-bugprone-bool-pointer-implicit-conversion,-cert-env33-c,-cert-dcl50-cpp,-cert-dcl59-cpp,-cppcoreguidelines-no-malloc,-cppcoreguidelines-owning-memory,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-constant-array-index,-cppcoreguidelines-pro-bounds-pointer-arithmetic,-cppcoreguidelines-pro-type-const-cast,-cppcoreguidelines-pro-type-cstyle-cast,-cppcoreguidelines-pro-type-reinterpret-cast,-cppcoreguidelines-pro-type-union-access,-cppcoreguidelines-pro-type-vararg,-cppcoreguidelines-special-member-functions,-fuchsia-*,-google-*,google-default-arguments,google-explicit-constructor,google-runtime-member-string-references,google-runtime-operator,-hicpp-braces-around-statements,-hicpp-named-parameter,-hicpp-no-array-decay,-hicpp-no-assembler,-hicpp-no-malloc,-hicpp-function-size,-hicpp-special-member-functions,-hicpp-vararg,-llvm-*,-objc-*,-readability-else-after-return,-readability-implicit-bool-conversion,-readability-named-parameter,-readability-simplify-boolean-expr,-readability-braces-around-statements,-readability-identifier-naming,-readability-function-size,-readability-redundant-member-init,-misc-bool-pointer-implicit-conversion,-misc-definitions-in-headers,-misc-unused-alias-decls,-misc-unused-parameters,-misc-unused-using-decls,-modernize-use-using,-modernize-use-default-member-init,-clang-diagnostic-*,-clang-analyzer-*,-cert-msc30-c,-cert-msc50-cpp,-bugprone-integer-division,-modernize-use-auto" />
</inspection_tool>
<inspection_tool class="OCDFAInspection" enabled="false" level="WARNING" enabled_by_default="false" />
<inspection_tool class="SpellCheckingInspection" enabled="false" level="TYPO" enabled_by_default="false">

2
res/shader/world/deferredLighting.fs
View File

@ -19,7 +19,7 @@ void main() {
vec3 color = texture(gColorSpec, texCoords).rgb;
//Discard fragments without normals
if (normal.x == 0 && normal.y == 0 && normal.z == 0) discard;
if (normal == vec3(0)) discard;
//Shade based on Normals
float shading = (0.8 + abs(normal.x) * 0.15) + (normal.y * 0.15) + 0.2;

BIN
res/tex/game/default_bush_stem.png Executable file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 812 B

BIN
res/tex/game/flowers_mushroom_brown.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 284 B

After

Width:  |  Height:  |  Size: 279 B

BIN
res/tex/game/flowers_mushroom_red.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 324 B

After

Width:  |  Height:  |  Size: 324 B

12
src/CMakeLists.txt
View File

@ -57,8 +57,8 @@ set(ZEUS_SRC_FILES
server/Server.h
util/net/Packet.cpp
util/net/Packet.h
server/player/ServerPlayer.cpp
server/player/ServerPlayer.h
server/conn/ServerPlayer.cpp
server/conn/ServerPlayer.h
game/scene/net/ServerConnection.cpp
game/scene/net/ServerConnection.h
def/gen/MapGen.cpp
@ -69,9 +69,9 @@ set(ZEUS_SRC_FILES
game/entity/hud/GameGui.h
util/net/Serializer.cpp
util/net/Serializer.h
server/conn/ConnectionList.cpp
server/conn/ConnectionList.h
server/conn/ServerPeer.h
server/conn/ServerClients.cpp
server/conn/ServerClients.h
server/conn/ServerClient.h
util/net/PacketChannel.h
game/entity/world/PlayerEntity.cpp
game/entity/world/PlayerEntity.h
@ -166,6 +166,6 @@ set(ZEUS_SRC_FILES
api/client/LocalRegisterBlocks.h
api/server/ServerRegisterBlocks.cpp
api/server/ServerRegisterBlocks.h
)
server/conn/ServerClient.cpp)
add_library (zeusCore ${ZEUS_SRC_FILES})

2
src/game/scene/net/ServerConnection.cpp
View File

@ -61,6 +61,8 @@ void ServerConnection::update(Player &player) {
auto playerPos = Serializer::decodeFloatVec3(&p.data[4]);
auto playerAngle = Serializer::decodeFloat(&p.data[16]);
std::cout << peer_id << std::endl;
bool found = false;
for (auto ent : entities->getChildren()) {
auto playerEntity = (PlayerEntity*)ent;

138
src/server/Server.cpp
View File

@ -6,115 +6,119 @@
Server::Server(unsigned short port) :
defs(),
world(55, defs),
connections(&world),
clientList(),
world(55, defs, clientList),
port(port),
handler(port, 32) {
defs.init(world);
world.init();
//Some signal to turn off alive is needed to shut down the server gracefully
while (alive) update();
}
void Server::update() {
const static long interval_ns = (long)((1000 / 20.f) * 1000000L);
Timer loop("");
world.update();
defs.update(deltaTime);
ENetEvent event;
while (handler.update(&event) && loop.elapsedNs() < 30L*1000000L) {
while (handler.update(&event) && loop.elapsedNs() < interval_ns) {
switch (event.type) {
case ENET_EVENT_TYPE_NONE:
default: break;
default:
case ENET_EVENT_TYPE_NONE: break;
case ENET_EVENT_TYPE_CONNECT: {
auto peer = connections.addPeer(event.peer);
//TODO: Get an actual username / uuid
connections.createPlayer(peer, "1234567890", "Aurailus");
clientList.handleConnect(event);
break;
}
case ENET_EVENT_TYPE_DISCONNECT: {
connections.removePeer(event.peer);
clientList.handleDisconnect(event);
break;
}
case ENET_EVENT_TYPE_RECEIVE: {
Packet p(event.packet);
ServerClient *client = (ServerClient *) event.peer->data;
auto from = (ServerPeer*)event.peer->data;
auto player = from->player;
if (player != nullptr) {
switch (p.type) {
default: break;
case Packet::PLAYER_INFO: {
//Update Player Object
auto newPos = Serializer::decodeFloatVec3(&p.data[0]);
auto angle = Serializer::decodeFloat(&p.data[12]);
player->setPos(newPos);
player->setAngle(angle);
//Send All Clients the new positon
Packet r(Packet::ENTITY_INFO);
Serializer::encodeInt(r.data, player->peer->index);
Serializer::encodeFloatVec3(r.data, newPos);
Serializer::encodeFloat(r.data, angle);
for (auto peer : connections.peers) {
if (peer->index != player->peer->index)
r.sendTo(peer->peer, PacketChannel::ENTITY_INFO);
}
break;
}
case Packet::BLOCK_SET: {
auto pos = Serializer::decodeIntVec3(&p.data[0]);
auto block = Serializer::decodeInt(&p.data[12]);
world.setBlock(pos, block);
if (block == 0) {
auto def = defs.blocks().fromIndex(world.getBlock(pos));
if (def.callbacks.count(Callback::BREAK)) {
def.callbacks[Callback::BREAK](defs.lua().vecToTable(pos));
}
}
else {
auto def = defs.blocks().fromIndex(block);
if (def.callbacks.count(Callback::PLACE)) {
def.callbacks[Callback::PLACE](defs.lua().vecToTable(pos));
}
}
break;
}
}
if (client->hasPlayer()) {
handlePlayerPacket(*client, p);
}
else {
// handleConnectPacket(*client, p);
}
enet_packet_destroy(event.packet);
break;
}
}
enet_packet_destroy(event.packet);
}
const static long interval_ns = (long)((1000 / 20.f) * 1000000L);
long sleep_for = interval_ns - loop.elapsedNs();
if (sleep_for > 0) {
std::this_thread::sleep_for(std::chrono::nanoseconds(sleep_for));
}
if (sleep_for > 0) std::this_thread::sleep_for(std::chrono::nanoseconds(sleep_for));
deltaTime = loop.elapsedNs() / 1000000.0;
elapsedSeconds += deltaTime;
}
void Server::handlePlayerPacket(ServerClient &client, Packet& p) {
//Client *does* have a getPlayer, this is ensured in update().
ServerPlayer& player = client.getPlayer();
switch (p.type) {
default: {
std::cout << Log::err << "Invalid packet type (" << p.type << ") recieved." << Log::endl;
break;
}
case Packet::PLAYER_INFO: {
player.setPos(Serializer::decodeFloatVec3(&p.data[0]));
player.setAngle(Serializer::decodeFloat(&p.data[12]));
//Send All ServerClients the new positon
Packet r(Packet::ENTITY_INFO);
Serializer::encodeInt(r.data, client.getConnectID());
Serializer::encodeFloatVec3(r.data, player.getPos());
Serializer::encodeFloat(r.data, player.getAngle());
for (auto& iter : clientList.clients) {
if (iter.getConnectID() != client.getConnectID()) {
r.sendTo(iter.getPeer(), PacketChannel::ENTITY_INFO);
}
}
break;
}
case Packet::BLOCK_SET: {
auto pos = Serializer::decodeIntVec3(&p.data[0]);
auto block = Serializer::decodeInt(&p.data[12]);
world.setBlock(pos, block);
if (block == 0) {
auto def = defs.blocks().fromIndex(world.getBlock(pos));
if (def.callbacks.count(Callback::BREAK)) {
def.callbacks[Callback::BREAK](defs.lua().vecToTable(pos));
}
} else {
auto def = defs.blocks().fromIndex(block);
if (def.callbacks.count(Callback::PLACE)) {
def.callbacks[Callback::PLACE](defs.lua().vecToTable(pos));
}
}
break;
}
}
}
void Server::cleanup() {
alive = false;
}

12
src/server/Server.h
View File

@ -9,18 +9,22 @@
#include <vector>
#include <iostream>
#include "player/ServerPlayer.h"
#include "conn/ServerPlayer.h"
#include "conn/ServerClient.h"
#include "conn/ServerClients.h"
#include "world/ServerWorld.h"
#include "../util/net/Packet.h"
#include "../util/Timer.h"
#include "../util/net/NetHandler.h"
#include "conn/ConnectionList.h"
#include "conn/ServerPeer.h"
#include "../def/ServerDefs.h"
class Server {
public:
explicit Server(unsigned short port);
void update();
void handlePlayerPacket(ServerClient& client, Packet& p);
void cleanup();
~Server();
@ -30,7 +34,7 @@ private:
ServerDefs defs;
ServerWorld world;
NetHandler handler;
ConnectionList connections;
ServerClients clientList;
double elapsedSeconds;
double deltaTime;

52
src/server/conn/ConnectionList.cpp
View File

@ -1,52 +0,0 @@
//
// Created by aurailus on 07/02/19.
//
#include "ConnectionList.h"
#include "../../util/net/PacketChannel.h"
ConnectionList::ConnectionList(ServerWorld* world) {
this->world = world;
}
ServerPeer* ConnectionList::addPeer(ENetPeer *eNetPeer) {
std::cout << Log::info << eNetPeer->address.host << ":" << eNetPeer->address.port << " connected." << Log::endl;
auto peer = new ServerPeer {.peer = eNetPeer, .player = nullptr, .index = (int)peers.size()};
eNetPeer->data = (void*)peer;
peers.push_back(peer);
return peer;
}
void ConnectionList::removePeer(ENetPeer *eNetPeer) {
std::cout << Log::info << eNetPeer->address.host << ":" << eNetPeer->address.port << " disconnected." << Log::endl;
auto peer = (ServerPeer*)eNetPeer->data;
eNetPeer->data = nullptr;
for (auto it = peers.begin(); it != peers.end(); it++) {
if (peer == *it) {
peers.erase(it);
(*it)->cleanup();
delete *it;
break;
}
}
}
ServerPlayer* ConnectionList::createPlayer(ServerPeer *peer, std::string uuid, std::string username) {
std::cout << Log::info << "Creating player " << uuid << " for "
<< peer->peer->address.host << ":" << peer->peer->address.port << "." << Log::endl;
auto player = new ServerPlayer(peer, uuid, std::move(username));
player->setPos(glm::vec3(0, 16, 0));
//Send Initialization Data
auto packet = player->getInitPacket();
packet.sendTo(peer->peer, PacketChannel::PLAYER_INFO);
world->addPlayer(player);
return player;
}

28
src/server/conn/ConnectionList.h
View File

@ -1,28 +0,0 @@
//
// Created by aurailus on 07/02/19.
//
#ifndef ZEUS_SERVERPLAYERLIST_H
#define ZEUS_SERVERPLAYERLIST_H
#include <vector>
#include <string>
#include "../player/ServerPlayer.h"
#include "ServerPeer.h"
#include "../world/ServerWorld.h"
class ConnectionList {
public:
explicit ConnectionList(ServerWorld* world);
ServerPeer* addPeer(ENetPeer* peer);
void removePeer(ENetPeer* peer);
ServerPlayer* createPlayer(ServerPeer *peer, std::string uuid, std::string username);
public:
std::vector<ServerPeer*> peers;
ServerWorld* world;
};
#endif //ZEUS_SERVERPLAYERLIST_H

38
src/server/conn/ServerClient.cpp Normal file
View File

@ -0,0 +1,38 @@
//
// Created by aurailus on 29/06/19.
//
#include <iostream>
#include "ServerClient.h"
ServerClient::ServerClient(ENetPeer *peer, ENetAddress address) :
peer(peer),
address(address),
connectID(peer->connectID) {
}
unsigned int ServerClient::getConnectID() {
return connectID;
}
void ServerClient::initPlayer() {
//TODO: IMPLEMENT USERNAME
player = new ServerPlayer({0, 16, 0}, connectID, "TEMPORARY");
}
bool ServerClient::hasPlayer() {
return player != nullptr;
}
ServerPlayer& ServerClient::getPlayer() {
if (!player) throw "getPlayer() called on client without player!";
return *player;
}
ENetPeer& ServerClient::getPeer() {
return *peer;
}
ServerClient::~ServerClient() {
delete player;
}

33
src/server/conn/ServerClient.h Normal file
View File

@ -0,0 +1,33 @@
//
// Created by aurailus on 07/02/19.
//
#ifndef ZEUS_SERVERPEER_H
#define ZEUS_SERVERPEER_H
#include <enet/enet.h>
#include "ServerPlayer.h"
class ServerClient {
public:
ServerClient(ENetPeer* peer, ENetAddress address);
void initPlayer();
bool hasPlayer();
ServerPlayer& getPlayer();
ENetPeer& getPeer();
unsigned int getConnectID();
~ServerClient();
private:
ENetPeer* peer;
ENetAddress address;
ServerPlayer* player = nullptr;
unsigned int connectID;
};
#endif //ZEUS_SERVERPEER_H

47
src/server/conn/ServerClients.cpp Normal file
View File

@ -0,0 +1,47 @@
//
// Created by aurailus on 07/02/19.
//
#include "ServerClients.h"
void ServerClients::handleConnect(ENetEvent e) {
ENetPeer* peer = e.peer;
ENetAddress& addr = peer->address;
std::cout << Log::info << addr.host << ":" << addr.port << " connected." << Log::endl;
clients.emplace_back(peer, addr);
ServerClient& client = clients.back();
client.initPlayer();
peer->data = &client;
Packet p(Packet::PLAYER_INFO);
Serializer::encodeInt(p.data, client.getConnectID());
Serializer::encodeFloatVec3(p.data, client.getPlayer().getPos());
p.sendTo(peer, PacketChannel::PLAYER_INFO);
}
void ServerClients::handleDisconnect(ENetEvent e) {
ENetPeer* peer = e.peer;
ENetAddress& addr = peer->address;
unsigned int connectID = ((ServerClient*) peer->data)->getConnectID();
std::cout << Log::info << addr.host << ":" << addr.port << " disconnected." << Log::endl;
bool found = false;
auto it = clients.begin();
while (it != clients.end()) {
if ((*it).getConnectID() == connectID) {
found = true;
std::cout << Log::info << "Disconnected a Client." << Log::endl;
clients.erase(it);
break;
}
it ++;
}
if (!found) std::cout << Log::err << "Tried to disconnect nonexistent client!" << Log::endl;
}

23
src/server/conn/ServerClients.h Normal file
View File

@ -0,0 +1,23 @@
//
// Created by aurailus on 07/02/19.
//
#ifndef ZEUS_SERVERPLAYERLIST_H
#define ZEUS_SERVERPLAYERLIST_H
#include <vector>
#include <string>
#include "ServerClient.h"
#include "../../util/net/Packet.h"
#include "../../util/net/PacketChannel.h"
#include "../../util/Log.h"
class ServerClients {
public:
void handleConnect(ENetEvent e);
void handleDisconnect(ENetEvent e);
std::vector<ServerClient> clients;
};
#endif //ZEUS_SERVERPLAYERLIST_H

20
src/server/conn/ServerPeer.h
View File

@ -1,20 +0,0 @@
//
// Created by aurailus on 07/02/19.
//
#ifndef ZEUS_SERVERPEER_H
#define ZEUS_SERVERPEER_H
#include <enet/enet.h>
class ServerPlayer;
struct ServerPeer {
ENetPeer* peer;
ServerPlayer* player;
int index;
void cleanup() {};
};
#endif //ZEUS_SERVERPEER_H

62
src/server/conn/ServerPlayer.cpp Normal file
View File

@ -0,0 +1,62 @@
//
// Created by aurailus on 11/01/19.
//
#include "ServerPlayer.h"
ServerPlayer::ServerPlayer(glm::vec3 pos, unsigned int connectID, std::string username) :
pos(pos),
connectID(connectID),
username(std::move(username)) {
chunkPos = TransPos::chunkFromVec(pos);
lastChunkPos = chunkPos - glm::vec3(200); //Force resending of all chunks around getPlayer.
changedChunks = true;
}
void ServerPlayer::setPos(glm::vec3 pos) {
this->pos = pos;
glm::vec3 newChunkPos = TransPos::chunkFromVec(pos);
if (newChunkPos != chunkPos) {
if (!changedChunks) {
lastChunkPos = chunkPos;
changedChunks = true;
}
chunkPos = newChunkPos;
}
}
void ServerPlayer::setAngle(float angle) {
this->angle = angle;
}
glm::vec3 ServerPlayer::getPos() {
return pos;
}
float ServerPlayer::getAngle() {
return angle;
}
glm::vec3 ServerPlayer::getChunkPos() {
return chunkPos;
}
glm::vec3 ServerPlayer::getLastChunkPos() {
return lastChunkPos;
}
std::pair<glm::vec3, glm::vec3> ServerPlayer::getChunkBounds() {
glm::vec3 minBounds(chunkPos.x - ACTIVE_RANGE_H, chunkPos.y - ACTIVE_RANGE_V, chunkPos.z - ACTIVE_RANGE_H);
glm::vec3 maxBounds(chunkPos.x + ACTIVE_RANGE_H, chunkPos.y + ACTIVE_RANGE_V, chunkPos.z + ACTIVE_RANGE_H);
return {minBounds, maxBounds};
}
std::pair<glm::vec3, glm::vec3> ServerPlayer::getLastChunkBounds() {
glm::vec3 minBounds(lastChunkPos.x - ACTIVE_RANGE_H, lastChunkPos.y - ACTIVE_RANGE_V, lastChunkPos.z - ACTIVE_RANGE_H);
glm::vec3 maxBounds(lastChunkPos.x + ACTIVE_RANGE_H, lastChunkPos.y + ACTIVE_RANGE_V, lastChunkPos.z + ACTIVE_RANGE_H);
return {minBounds, maxBounds};
}

44
src/server/conn/ServerPlayer.h Normal file
View File

@ -0,0 +1,44 @@
//
// Created by aurailus on 11/01/19.
//
#ifndef ZEUS_SERVERPLAYER_H
#define ZEUS_SERVERPLAYER_H
#include <vec3.hpp>
#include "../../util/TransPos.h"
class ServerPlayer {
public:
const static int ACTIVE_RANGE_H = 6;
const static int ACTIVE_RANGE_V = 6;
explicit ServerPlayer(glm::vec3 pos, unsigned int connectID, std::string username);
void setPos(glm::vec3 pos);
void setAngle(float angle);
glm::vec3 getPos();
float getAngle();
glm::vec3 getChunkPos();
glm::vec3 getLastChunkPos();
std::pair<glm::vec3, glm::vec3> getChunkBounds();
std::pair<glm::vec3, glm::vec3> getLastChunkBounds();
bool changedChunks = true;
private:
std::string username;
unsigned int connectID;
glm::vec3 chunkPos {};
glm::vec3 lastChunkPos {};
glm::vec3 pos {};
float angle;
};
#endif //ZEUS_SERVERPLAYER_H

79
src/server/player/ServerPlayer.cpp
View File

@ -1,79 +0,0 @@
//
// Created by aurailus on 11/01/19.
//
#include <cmath>
#include "ServerPlayer.h"
#include "../../util/TransPos.h"
ServerPlayer::ServerPlayer(ServerPeer *peer, std::string uuid, std::string username) :
peer(peer),
uuid(std::move(uuid)),
username(std::move(username)) {
peer->player = this;
}
Packet ServerPlayer::getInitPacket() {
Packet p(Packet::PLAYER_INFO);
Serializer::encodeInt(p.data, peer->index);
Serializer::encodeFloatVec3(p.data, pos);
return p;
}
glm::vec3 ServerPlayer::getPos() {
return pos;
}
glm::vec3 ServerPlayer::getChunkPos() {
return chunkPos;
}
glm::vec3 ServerPlayer::getOldPos() {
return lastChunkPos;
}
void ServerPlayer::setPos(glm::vec3 pos) {
this->pos = pos;
glm::vec3 newChunkPos = TransPos::chunkFromVec(pos);
if (newChunkPos != chunkPos) {
if (!changedChunks) {
lastChunkPos = chunkPos;
changedChunks = true;
}
chunkPos = newChunkPos;
}
}
std::pair<glm::vec3, glm::vec3> ServerPlayer::getBounds() {
glm::vec3 minBounds(chunkPos.x - ACTIVE_RANGE_H, chunkPos.y - ACTIVE_RANGE_H, chunkPos.z - ACTIVE_RANGE_H);
glm::vec3 maxBounds(chunkPos.x + ACTIVE_RANGE_H, chunkPos.y + ACTIVE_RANGE_H, chunkPos.z + ACTIVE_RANGE_H);
return {minBounds, maxBounds};
}
std::pair<glm::vec3, glm::vec3> ServerPlayer::getOldBounds() {
glm::vec3 minBounds(lastChunkPos.x - ACTIVE_RANGE_H, lastChunkPos.y - ACTIVE_RANGE_H, lastChunkPos.z - ACTIVE_RANGE_H);
glm::vec3 maxBounds(lastChunkPos.x + ACTIVE_RANGE_H, lastChunkPos.y + ACTIVE_RANGE_H, lastChunkPos.z + ACTIVE_RANGE_H);
return {minBounds, maxBounds};
}
bool ServerPlayer::isInBounds(glm::vec3 cPos, std::pair<glm::vec3, glm::vec3> &bounds) {
return (cPos.x >= bounds.first.x && cPos.x <= bounds.second.x
&& cPos.y >= bounds.first.y && cPos.y <= bounds.second.y
&& cPos.z >= bounds.first.z && cPos.z <= bounds.second.z);
}
std::string ServerPlayer::getUsername() {
return username;
}
void ServerPlayer::setAngle(float angle) {
this->angle = angle;
}
ServerPlayer::~ServerPlayer() = default;

52
src/server/player/ServerPlayer.h
View File

@ -1,52 +0,0 @@
//
// Created by aurailus on 11/01/19.
//
#ifndef ZEUS_SERVERPLAYER_H
#define ZEUS_SERVERPLAYER_H
#include <vec3.hpp>
#include "../conn/ServerPeer.h"
#include "../../util/net/Packet.h"
#include "../../util/TransPos.h"
class ServerPlayer {
public:
const static int ACTIVE_RANGE_H = 6;
const static int ACTIVE_RANGE_V = 6;
explicit ServerPlayer(ServerPeer* peer, std::string uuid, std::string username);
Packet getInitPacket();
glm::vec3 getPos();
void setPos(glm::vec3 pos);
void setAngle(float angle);
glm::vec3 getChunkPos();
glm::vec3 getOldPos();
std::pair<glm::vec3, glm::vec3> getBounds();
std::pair<glm::vec3, glm::vec3> getOldBounds();
bool isInBounds(glm::vec3 pos, std::pair<glm::vec3, glm::vec3>& bounds);
std::string getUsername();
~ServerPlayer();
bool changedChunks = false;
ServerPeer* peer;
private:
std::string username, uuid;
glm::vec3 chunkPos {0, 2, 0};
glm::vec3 lastChunkPos {0, 2, 0};
glm::vec3 pos {0, 32, 0};
float angle;
};
#endif //ZEUS_SERVERPLAYER_H

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

@ -9,13 +9,13 @@
#include "../../util/Timer.h"
#include "../../util/Util.h"
ServerWorld::ServerWorld(unsigned int seed, ServerDefs& defs) :
ServerWorld::ServerWorld(unsigned int seed, ServerDefs& defs, ServerClients& clients) :
seed(seed),
defs(defs) {
defs(defs),
clientList(clients) {
//Pregenerate chunk generation order
generateOrder.reserve((unsigned long)pow(ServerPlayer::ACTIVE_RANGE_H * 2, 3));
generateOrder.reserve((unsigned long)pow(ServerPlayer::ACTIVE_RANGE_H * 2, 2) * ServerPlayer::ACTIVE_RANGE_V * 2);
for (int i = 0; i <= ServerPlayer::ACTIVE_RANGE_H; i++) {
for (int j = 0; j <= i; j++) {
@ -36,43 +36,19 @@ void ServerWorld::init() {
genStream = new WorldGenStream(seed, defs.blocks());
}
void ServerWorld::changedChunks(ServerClient& client) {
auto pos = client.getPlayer().getChunkPos();
void ServerWorld::addPlayer(ServerPlayer *player) {
// Timer t("New Chunk Allocation");
this->players.push_back(player);
auto bounds = player->getBounds();
auto pos = player->getChunkPos();
for (const auto &c : generateOrder) {
glm::vec3 chunkPos = {c.x + pos.x, c.y + pos.y, c.z + pos.z};
if (dimension.getChunk(chunkPos) != nullptr) {
sendChunk(chunkPos, *player->peer);
}
else {
generate(chunkPos);
}
}
// t.printElapsedMs();
}
void ServerWorld::playerChangedChunks(ServerPlayer *player) {
// Timer t("Movement Allocation");
auto pos = player->getChunkPos();
auto bounds = player->getBounds();
auto oldBounds = player->getOldBounds();
auto bounds = client.getPlayer().getChunkBounds();
auto oldBounds = client.getPlayer().getLastChunkBounds();
int generated = 0;
for (const auto &c : generateOrder) {
glm::vec3 chunkPos = {c.x + pos.x, c.y + pos.y, c.z + pos.z};
if (!player->isInBounds(chunkPos, oldBounds)) {
if (!isInBounds(chunkPos, oldBounds)) {
if (dimension.getChunk(chunkPos) != nullptr) {
sendChunk(chunkPos, *player->peer);
sendChunk(chunkPos, client);
}
else {
generate(chunkPos);
@ -81,18 +57,7 @@ void ServerWorld::playerChangedChunks(ServerPlayer *player) {
}
}
// printf("%s %s moved to %d, %d, %d, generating %d chunks. %s",
// Log::info,
// player->getUsername().c_str(),
// static_cast<int>(pos.x),
// static_cast<int>(pos.y),
// static_cast<int>(pos.z),
// generated,
// Log::endl);
// t.printElapsedMs();
player->changedChunks = false;
client.getPlayer().changedChunks = false;
}
void ServerWorld::generate(glm::vec3 pos) {
@ -117,14 +82,16 @@ void ServerWorld::update() {
auto finished = genStream->update();
generatedChunks = (int)finished.size();
for (const auto &chunk : finished) {
for (const auto& chunk : finished) {
dimension.addBlockChunk(chunk);
for (auto player : players) {
auto bounds = player->getBounds();
for (auto& client : clientList.clients) {
if (client.hasPlayer()) {
auto bounds = client.getPlayer().getChunkBounds();
if (player->isInBounds(chunk->pos, bounds)) {
sendChunk(chunk->pos, *player->peer);
if (isInBounds(chunk->pos, bounds)) {
sendChunk(chunk->pos, client);
}
}
}
}
@ -132,17 +99,16 @@ void ServerWorld::update() {
Packet r(Packet::SERVER_INFO);
Serializer::encodeInt(r.data, generatedChunks);
for (auto player : players) {
r.sendTo(player->peer->peer, PacketChannel::SERVER_INFO);
for (auto& client : clientList.clients) {
if (client.hasPlayer()) {
r.sendTo(client.getPeer(), PacketChannel::SERVER_INFO);
//Run update method for players
if (player->changedChunks) {
playerChangedChunks(player);
if (client.getPlayer().changedChunks) changedChunks(client);
}
}
}
void ServerWorld::sendChunk(glm::vec3 pos, ServerPeer &peer) {
void ServerWorld::sendChunk(glm::vec3 pos, ServerClient &peer) {
auto chunk = dimension.getChunk(pos);
auto serialized = chunk->serialize();
@ -151,7 +117,7 @@ void ServerWorld::sendChunk(glm::vec3 pos, ServerPeer &peer) {
Serializer::encodeIntVec3(r.data, pos);
Serializer::encodeString(r.data, serialized);
r.sendTo(peer.peer, PacketChannel::CHUNKS);
r.sendTo(peer.getPeer(), PacketChannel::CHUNKS);
}
void ServerWorld::setBlock(glm::vec3 pos, int block) {
@ -178,11 +144,13 @@ void ServerWorld::setBlock(glm::vec3 pos, int block) {
auto chunkPos = TransPos::chunkFromVec(TransPos::roundPos(pos));
for (auto player : players) {
auto bounds = player->getBounds();
for (auto &client : clientList.clients) {
if (client.hasPlayer()) {
auto bounds = client.getPlayer().getChunkBounds();
if (player->isInBounds(chunkPos, bounds)) {
b.sendTo(player->peer->peer, PacketChannel::BLOCK_UPDATES);
if (isInBounds(chunkPos, bounds)) {
b.sendTo(client.getPeer(), PacketChannel::BLOCK_UPDATES);
}
}
}
@ -200,6 +168,12 @@ void ServerWorld::setBlock(glm::vec3 pos, int block) {
}
}
bool ServerWorld::isInBounds(glm::vec3 cPos, std::pair<glm::vec3, glm::vec3> &bounds) {
return (cPos.x >= bounds.first.x && cPos.x <= bounds.second.x
&& cPos.y >= bounds.first.y && cPos.y <= bounds.second.y
&& cPos.z >= bounds.first.z && cPos.z <= bounds.second.z);
}
int ServerWorld::getBlock(glm::vec3 pos) {
return dimension.getBlock(pos);
}

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

@ -8,32 +8,32 @@
#include <unordered_map>
#include <unordered_set>
#include "../../world/chunk/BlockChunk.h"
#include "../player/ServerPlayer.h"
#include "WorldGenStream.h"
#include "../conn/ServerClient.h"
#include "../conn/ServerPlayer.h"
#include "../../world/chunk/BlockChunk.h"
#include "../../util/Vec.h"
#include "../../world/Dimension.h"
#include "../../def/ServerDefs.h"
#include "../conn/ServerClients.h"
class ServerWorld {
public:
explicit ServerWorld(unsigned int seed, ServerDefs& defs);
explicit ServerWorld(unsigned int seed, ServerDefs& defs, ServerClients& clients);
void init();
void update();
void addPlayer(ServerPlayer* player);
void setBlock(glm::vec3 pos, int block);
int getBlock(glm::vec3 pos);
~ServerWorld();
private:
void playerChangedChunks(ServerPlayer* player);
void changedChunks(ServerClient& client);
void generate(glm::vec3 pos);
void sendChunk(glm::vec3 pos, ServerPeer& peer);
void sendChunk(glm::vec3 pos, ServerClient& client);
std::vector<ServerPlayer*> players;
bool isInBounds(glm::vec3 pos, std::pair<glm::vec3, glm::vec3>& bounds);
WorldGenStream* genStream;
Dimension dimension;
@ -41,9 +41,11 @@ private:
std::unordered_set<glm::vec3, VecUtils::compareFunc> generateQueueMap;
std::vector<glm::vec3> generateQueueList;
int generatedChunks = 0;
unsigned int seed;
ServerDefs& defs;
ServerClients& clientList;
int generatedChunks = 0;
//Static vector of chunks to place around players
std::vector<glm::vec3> generateOrder;

2
src/util/net/NetHandler.cpp
View File

@ -45,7 +45,7 @@ void NetHandler::initServer(unsigned short port, short max_clients) {
return;
}
std::cout << Log::info << "Server Started. Listening for clients." << Log::endl;
std::cout << Log::info << "Server Started. Listening for clientList." << Log::endl;
}
void NetHandler::initClient(std::string host_address, unsigned short host_port, int attempts, int timeout) {

5
src/util/net/Packet.cpp
View File

@ -28,3 +28,8 @@ void Packet::sendTo(ENetPeer *peer, int channel) {
ENetPacket* enet = toENetPacket();
enet_peer_send(peer, (enet_uint8)channel, enet);
}
void Packet::sendTo(const ENetPeer &peer, int channel) {
ENetPacket* enet = toENetPacket();
enet_peer_send(const_cast<ENetPeer*>(&peer), (enet_uint8)channel, enet);
}

1
src/util/net/Packet.h
View File

@ -32,6 +32,7 @@ struct Packet {
ENetPacket* toENetPacket();
void sendTo(ENetPeer* peer, int channel);
void sendTo(const ENetPeer &peer, int channel);
int type = UNDEFINED;
std::string data;

4
src/world/chunk/BlockChunk.cpp
View File

@ -40,8 +40,8 @@ int BlockChunk::getBlock(int ind) const {
}
bool BlockChunk::setBlock(const glm::vec3& pos, int block) {
auto ind = VecUtils::vecToInd(pos);
if (ind < 0 || ind >= (int)pow(TransPos::CHUNK_SIZE, 3)) return false;
unsigned int ind = VecUtils::vecToInd(pos);
if (ind >= (int)pow(TransPos::CHUNK_SIZE, 3)) return false;
if (blocks[ind] != block) {
if (block == 0) {