cheatable player client / server sync

client/Game.cpp

@@ -3,7 +3,7 @@
 #include "client/gui/StartGUI.h"
 #include "client/rendering/Engine.h"
 #include "common/network/Packets.h"
-#include "common/network/toserver/ControllerPacket.h"
+#include "common/network/toserver/PlayerUpdatePacket.h"
 #include "rendering/renderer/WorldRenderer.h"
 #include "utils/Logger.h"
 #include "utils/Utils.h"
@@ -35,23 +35,17 @@ static void tickConnectedState() {
     Vector3 right = back.cross(up);
 
     constexpr float rotationSpeed = 4.0f;
-    ControllerPacket cp;
-
     Vector3 force;
     if(Game::controller.down.isDown()) {
-        cp.set(ControllerPacket::Type::DOWN);
         force += back;
     }
     if(Game::controller.up.isDown()) {
-        cp.set(ControllerPacket::Type::UP);
         force -= back;
     }
     if(Game::controller.left.isDown()) {
-        cp.set(ControllerPacket::Type::LEFT);
         force -= right;
     }
     if(Game::controller.right.isDown()) {
-        cp.set(ControllerPacket::Type::RIGHT);
         force += right;
     }
     if(force.squareLength() > 0.0f) {
@@ -60,30 +54,24 @@ static void tickConnectedState() {
     Game::player.addForce(force * 0.1f);
 
     if(Game::controller.jump.isDown() && Game::player.isOnGround()) {
-        cp.set(ControllerPacket::Type::JUMP);
         Game::player.addForce(up * (0.42f / 0.98f + 0.08f));
     }
-    if(Game::controller.sneak.isDown()) {
-        cp.set(ControllerPacket::Type::SNEAK);
-    }
     if(Game::controller.camLeft.isDown()) {
-        cp.set(ControllerPacket::Type::CAM_LEFT);
         Game::player.addLengthAngle(-rotationSpeed);
     }
     if(Game::controller.camRight.isDown()) {
-        cp.set(ControllerPacket::Type::CAM_RIGHT);
         Game::player.addLengthAngle(rotationSpeed);
     }
     if(Game::controller.camUp.isDown()) {
-        cp.set(ControllerPacket::Type::CAM_UP);
         Game::player.addWidthAngle(-rotationSpeed * 0.5f);
     }
     if(Game::controller.camDown.isDown()) {
-        cp.set(ControllerPacket::Type::CAM_DOWN);
         Game::player.addWidthAngle(rotationSpeed * 0.5f);
     }
-    OutPacket out = OutPacket::reliable(ControllerPacket::getSize());
-    cp.write(out);
+
+    PlayerUpdatePacket p(Game::player);
+    OutPacket out = OutPacket::sequenced(PlayerUpdatePacket::getSize());
+    p.write(out);
     GameClient::send(out);
 }
 
@@ -148,13 +136,6 @@ void Game::renderOverlay() {
 }
 
 void Game::onEntityUpdate(EntityUpdatePacket& p) {
-    float distance = (p.position - player.position).squareLength();
-    LOG_DEBUG(StringBuffer<50>(distance));
-    if(distance > 25.0f) {
-        LOG_DEBUG("set");
-        player.setPosition(p.position);
-    }
-    // player.position = p.position;
-    // player.lengthAngle = p.lengthAngle;
-    // player.widthAngle = p.widthAngle;
+    LOG_DEBUG("set");
+    player.setPosition(p.position);
 }

common/network/Packets.h

@@ -8,7 +8,7 @@ namespace Packets {
     // packets from the server to clients
     enum ServerPacket { S_CHAT, S_WORLD_SEGMENT, S_ENTITY_UPDATE };
     // packets from clients to the server
-    enum ClientPacket { C_CHAT, C_CONTROLLER };
+    enum ClientPacket { C_CHAT, C_PLAYER_UPDATE };
 
     template<int N>
     void writeVector(OutPacket& out, const Vector<N>& v) {

common/network/toserver/ControllerPacket.cpp

@@ -1,26 +0,0 @@
-#include "common/network/toserver/ControllerPacket.h"
-#include "common/network/Packets.h"
-
-ControllerPacket::ControllerPacket() : flags(0) {
-}
-
-void ControllerPacket::set(Type type) {
-    flags |= (1 << type);
-}
-
-bool ControllerPacket::has(Type type) const {
-    return flags & (1 << type);
-}
-
-void ControllerPacket::write(OutPacket& out) const {
-    out.writeU16(Packets::C_CONTROLLER);
-    out.writeU32(flags);
-}
-
-bool ControllerPacket::read(InPacket& in) {
-    return in.readU32(flags);
-}
-
-int ControllerPacket::getSize() {
-    return sizeof(ControllerPacket) + 2;
-}

common/network/toserver/ControllerPacket.h

@@ -1,32 +0,0 @@
-#ifndef CONTROLLER_PACKET_H
-#define CONTROLLER_PACKET_H
-
-#include "network/Packet.h"
-
-class ControllerPacket {
-    uint32 flags;
-
-public:
-    enum Type {
-        LEFT,
-        RIGHT,
-        UP,
-        DOWN,
-        JUMP,
-        SNEAK,
-        CAM_LEFT,
-        CAM_RIGHT,
-        CAM_UP,
-        CAM_DOWN
-    };
-    ControllerPacket();
-
-    void set(Type type);
-    bool has(Type type) const;
-    void write(OutPacket& out) const;
-    bool read(InPacket& in);
-
-    static int getSize();
-};
-
-#endif

common/network/toserver/PlayerUpdatePacket.cpp

@@ -0,0 +1,21 @@
+#include "common/network/toserver/PlayerUpdatePacket.h"
+#include "common/network/Packets.h"
+
+PlayerUpdatePacket::PlayerUpdatePacket(Entity& e) : position(e.position) {
+}
+
+PlayerUpdatePacket::PlayerUpdatePacket() {
+}
+
+void PlayerUpdatePacket::write(OutPacket& out) const {
+    out.writeU16(Packets::C_PLAYER_UPDATE);
+    Packets::writeVector(out, position);
+}
+
+bool PlayerUpdatePacket::read(InPacket& in) {
+    return Packets::readVector(in, position);
+}
+
+int PlayerUpdatePacket::getSize() {
+    return sizeof(PlayerUpdatePacket) + 2;
+}

common/network/toserver/PlayerUpdatePacket.h

@@ -0,0 +1,19 @@
+#ifndef PLAYER_UPDATE_PACKET_H
+#define PLAYER_UPDATE_PACKET_H
+
+#include "common/entities/Entity.h"
+#include "network/Packet.h"
+
+struct PlayerUpdatePacket {
+    Vector3 position;
+
+    PlayerUpdatePacket(Entity& e);
+    PlayerUpdatePacket();
+
+    void write(OutPacket& out) const;
+    bool read(InPacket& in);
+
+    static int getSize();
+};
+
+#endif

common/world/World.cpp

@@ -62,82 +62,80 @@ List<CollisionBox> World::getBoxes(const CollisionBox& box) const {
 void World::tick() {
     for(Entity* e : entities) {
         e->tick();
-        if(e->skip) {
-            LOG_DEBUG("skip");
-            continue;
-        }
+        Vector3 move = limitMove(*e, e->getVelocity());
+        e->move(move);
+    }
+}
 
-        Vector3 move = e->getVelocity();
-        CollisionBox box = e->getCollisionBox();
-        List<CollisionBox> boxes = getBoxes(box.expand(move));
-        if(boxes.getLength() == 0) {
-            e->move(move);
-            continue;
-        }
-        Vector3 realMove;
+Vector3 World::limitMove(const Entity& e, Vector3 move) const {
+    CollisionBox box = e.getCollisionBox();
+    List<CollisionBox> boxes = getBoxes(box.expand(move));
+    if(boxes.getLength() == 0) {
+        return move;
+    }
+    Vector3 realMove;
 
-        constexpr float step = 0.05f;
-        while(move[0] != 0.0f || move[1] != 0.0f || move[2] != 0.0f) {
-            Vector3 old = realMove;
-            if(move[0] > step) {
-                realMove[0] += step;
-                move[0] -= step;
-            } else if(move[0] < -step) {
-                realMove[0] -= step;
-                move[0] += step;
-            } else if(move[0] != 0.0f) {
-                realMove[0] += move[0];
+    constexpr float step = 0.05f;
+    while(move[0] != 0.0f || move[1] != 0.0f || move[2] != 0.0f) {
+        Vector3 old = realMove;
+        if(move[0] > step) {
+            realMove[0] += step;
+            move[0] -= step;
+        } else if(move[0] < -step) {
+            realMove[0] -= step;
+            move[0] += step;
+        } else if(move[0] != 0.0f) {
+            realMove[0] += move[0];
+            move[0] = 0.0f;
+        }
+        CollisionBox moved = box.offset(realMove);
+        for(const CollisionBox& box : boxes) {
+            if(box.collidesWith(moved)) {
                 move[0] = 0.0f;
+                realMove = old;
+                break;
             }
-            CollisionBox moved = box.offset(realMove);
-            for(const CollisionBox& box : boxes) {
-                if(box.collidesWith(moved)) {
-                    move[0] = 0.0f;
-                    realMove = old;
-                    break;
-                }
-            }
+        }
 
-            old = realMove;
-            if(move[1] > step) {
-                realMove[1] += step;
-                move[1] -= step;
-            } else if(move[1] < -step) {
-                realMove[1] -= step;
-                move[1] += step;
-            } else if(move[1] != 0.0f) {
-                realMove[1] += move[1];
+        old = realMove;
+        if(move[1] > step) {
+            realMove[1] += step;
+            move[1] -= step;
+        } else if(move[1] < -step) {
+            realMove[1] -= step;
+            move[1] += step;
+        } else if(move[1] != 0.0f) {
+            realMove[1] += move[1];
+            move[1] = 0.0f;
+        }
+        moved = box.offset(realMove);
+        for(const CollisionBox& box : boxes) {
+            if(box.collidesWith(moved)) {
                 move[1] = 0.0f;
+                realMove = old;
+                break;
             }
-            moved = box.offset(realMove);
-            for(const CollisionBox& box : boxes) {
-                if(box.collidesWith(moved)) {
-                    move[1] = 0.0f;
-                    realMove = old;
-                    break;
-                }
-            }
+        }
 
-            old = realMove;
-            if(move[2] > step) {
-                realMove[2] += step;
-                move[2] -= step;
-            } else if(move[2] < -step) {
-                realMove[2] -= step;
-                move[2] += step;
-            } else if(move[2] != 0.0f) {
-                realMove[2] += move[2];
+        old = realMove;
+        if(move[2] > step) {
+            realMove[2] += step;
+            move[2] -= step;
+        } else if(move[2] < -step) {
+            realMove[2] -= step;
+            move[2] += step;
+        } else if(move[2] != 0.0f) {
+            realMove[2] += move[2];
+            move[2] = 0.0f;
+        }
+        moved = box.offset(realMove);
+        for(const CollisionBox& box : boxes) {
+            if(box.collidesWith(moved)) {
                 move[2] = 0.0f;
-            }
-            moved = box.offset(realMove);
-            for(const CollisionBox& box : boxes) {
-                if(box.collidesWith(moved)) {
-                    move[2] = 0.0f;
-                    realMove = old;
-                    break;
-                }
+                realMove = old;
+                break;
             }
         }
-        e->move(realMove);
     }
+    return realMove;
 }

common/world/World.h

@@ -27,6 +27,8 @@ public:
 
     void tick();
 
+    Vector3 limitMove(const Entity& e, Vector3 move) const;
+
 private:
     List<CollisionBox> getBoxes(const CollisionBox& box) const;
 };

meson.build

@@ -9,7 +9,7 @@ src_common = [
     'common/world/HighMap.cpp',
     'common/utils/CollisionBox.cpp',
     'common/entities/Entity.cpp',
-    'common/network/toserver/ControllerPacket.cpp',
+    'common/network/toserver/PlayerUpdatePacket.cpp',
     'common/network/toclient/EntityUpdatePacket.cpp',
 ]
 

server/Game.cpp

@@ -15,7 +15,6 @@ static RawReader<256, 10> reader{0, "> "};
 Clock Game::ticksPerSecond;
 BlockRegistry Game::blocks;
 World Game::world{blocks};
-static Entity* test = nullptr;
 
 void Game::stop() {
     running = false;
@@ -44,12 +43,6 @@ static void handleCommands() {
 void Game::tick() {
     ticksPerSecond.update();
     world.tick();
-    if(test != nullptr) {
-        EntityUpdatePacket e(*test);
-        OutPacket out = OutPacket::sequenced(EntityUpdatePacket::getSize());
-        e.write(out);
-        GameServer::sendToAll(out);
-    }
     handleCommands();
 }
 
@@ -61,12 +54,10 @@ void Game::addPlayer(ServerPlayer& p) {
         }
     }
     p.setPosition(Vector3(0.0f, 1.0f, 0.0f));
-    test = &p;
     world.addEntity(&p);
 }
 
 void Game::removePlayer(ServerPlayer& p) {
     LOG_INFO("player remove");
-    test = nullptr;
     world.removeEntity(&p);
 }

server/GameServer.cpp

@@ -8,9 +8,9 @@ static Server server;
 static HashMap<int, UniquePointer<ServerPlayer>> players;
 
 static void handleControllerPacket(ServerPlayer& p, InPacket& in) {
-    ControllerPacket cp;
-    cp.read(in);
-    p.onControllerPacket(cp);
+    PlayerUpdatePacket pup;
+    pup.read(in);
+    p.onUpdatePacket(pup);
 }
 
 struct Receiver {
@@ -52,7 +52,9 @@ struct Receiver {
         }
         switch(id) {
             case Packets::C_CHAT: (*p)->onChat(in); break;
-            case Packets::C_CONTROLLER: handleControllerPacket(**p, in); break;
+            case Packets::C_PLAYER_UPDATE:
+                handleControllerPacket(**p, in);
+                break;
             default: LOG_WARNING("invalid packet from client");
         }
     }

server/Main.cpp

@@ -11,8 +11,8 @@ void loop() {
         lag += clock.update();
         while(lag >= NANOS_PER_TICK) {
             lag -= NANOS_PER_TICK;
-            Game::tick();
             GameServer::tick();
+            Game::tick();
         }
         Clock::Nanos waitNanos = NANOS_PER_TICK - lag;
         if(waitNanos > 300000) {

server/entities/ServerPlayer.cpp

@@ -1,4 +1,7 @@
 #include "server/entities/ServerPlayer.h"
+#include "common/network/toclient/EntityUpdatePacket.h"
+#include "server/Game.h"
+#include "server/GameServer.h"
 #include "utils/Logger.h"
 
 ServerPlayer::ServerPlayer(Server::Client& client) : client(client) {
@@ -6,55 +9,23 @@ ServerPlayer::ServerPlayer(Server::Client& client) : client(client) {
 
 void ServerPlayer::tick() {
     if(!history.canRead()) {
-        skip = true;
         return;
     }
-    skip = false;
     Entity::tick();
 
-    ControllerPacket cp = history.read();
+    PlayerUpdatePacket p = history.read();
 
-    Quaternion q = getRotation();
-    Vector3 up(0.0f, 1.0f, 0.0f);
-    Vector3 back = q * Vector3(0.0f, 0.0f, -1.0f);
-    back[1] = 0.0f;
-    back.normalize();
-    Vector3 right = back.cross(up);
+    Vector3 move = p.position - position;
+    Vector3 actualMove = Game::world.limitMove(*this, move);
 
-    Vector3 force;
-    if(cp.has(ControllerPacket::Type::DOWN)) {
-        force += back;
-    }
-    if(cp.has(ControllerPacket::Type::UP)) {
-        force -= back;
-    }
-    if(cp.has(ControllerPacket::Type::LEFT)) {
-        force -= right;
-    }
-    if(cp.has(ControllerPacket::Type::RIGHT)) {
-        force += right;
-    }
-    if(force.squareLength() > 0.0f) {
-        force.normalize();
-    }
-    addForce(force * 0.1f);
-
-    if(cp.has(ControllerPacket::Type::JUMP) && isOnGround()) {
-        addForce(up * (0.42f / 0.98f + 0.08f));
-    }
-
-    constexpr float rotationSpeed = 4.0f;
-    if(cp.has(ControllerPacket::Type::CAM_LEFT)) {
-        addLengthAngle(-rotationSpeed);
-    }
-    if(cp.has(ControllerPacket::Type::CAM_RIGHT)) {
-        addLengthAngle(rotationSpeed);
-    }
-    if(cp.has(ControllerPacket::Type::CAM_UP)) {
-        addWidthAngle(-rotationSpeed * 0.5f);
-    }
-    if(cp.has(ControllerPacket::Type::CAM_DOWN)) {
-        addWidthAngle(rotationSpeed * 0.5f);
+    float diff = (move - actualMove).squareLength();
+    if(diff > 0.1f) {
+        EntityUpdatePacket e(*this);
+        OutPacket out = OutPacket::sequenced(EntityUpdatePacket::getSize());
+        e.write(out);
+        GameServer::sendToAll(out);
+    } else {
+        this->move(actualMove);
     }
 }
 
@@ -66,6 +37,6 @@ void ServerPlayer::send(OutPacket& out) {
     client.send(out);
 }
 
-void ServerPlayer::onControllerPacket(const ControllerPacket& cp) {
-    history.write(cp);
+void ServerPlayer::onUpdatePacket(const PlayerUpdatePacket& p) {
+    history.write(p);
 }

server/entities/ServerPlayer.h

@@ -2,13 +2,13 @@
 #define SERVER_PLAYER_H
 
 #include "common/entities/Entity.h"
-#include "common/network/toserver/ControllerPacket.h"
+#include "common/network/toserver/PlayerUpdatePacket.h"
 #include "network/Server.h"
 #include "utils/RingBuffer.h"
 
 class ServerPlayer : public Entity {
     Server::Client& client;
-    RingBuffer<ControllerPacket, 30> history;
+    RingBuffer<PlayerUpdatePacket, 5> history;
 
 public:
     ServerPlayer(Server::Client& client);
@@ -17,7 +17,7 @@ public:
     void onChat(InPacket& in);
     void sendChunk();
     void send(OutPacket& out);
-    void onControllerPacket(const ControllerPacket& cp);
+    void onUpdatePacket(const PlayerUpdatePacket& p);
 };
 
 #endif