Multiplayer

// Server side
class MinecraftServer {
    ServerConnection* connection;       // Network listener
    PlayerList* players;                // Connected players
    ServerLevelArray levels;            // Authoritative worlds
};

// Client side
class MultiPlayerLevel : public Level {
    vector<ClientConnection*> connections;  // Server connections
    MultiPlayerChunkCache* chunkCache;      // Received chunks
};

┌─────────────┐      Packets      ┌─────────────┐
│   Client    │ ─────────────────> │   Server    │
│             │                    │             │
│ LocalPlayer │ <───────────────── │ServerPlayer │
└─────────────┘   Updates/Sync    └─────────────┘
      │                                  │
      ▼                                  ▼
 MultiPlayerLevel               ServerLevel (x3)

class Minecraft {
    shared_ptr<MultiplayerLocalPlayer> localplayers[XUSER_MAX_COUNT];
    GameMode* localgameModes[XUSER_MAX_COUNT];
    ItemInHandRenderer* localitemInHandRenderers[XUSER_MAX_COUNT];
    int localPlayerIdx;  // Currently active player
};

bool Minecraft::addLocalPlayer(int idx) {
    // Create temporary player for connecting screen
    localplayers[idx] = make_shared<MultiplayerLocalPlayer>(
        this, level, user, NULL
    );
    localgameModes[idx] = NULL;
    
    // Add to network session
    g_NetworkManager.AddLocalPlayerByUserIndex(idx);
    
    updatePlayerViewportAssignments();
    
    return true;
}

VIEWPORT_TYPE_FULLSCREEN

if (splitScreenVertical) {
    VIEWPORT_TYPE_SPLIT_LEFT
    VIEWPORT_TYPE_SPLIT_RIGHT
} else {
    VIEWPORT_TYPE_SPLIT_TOP
    VIEWPORT_TYPE_SPLIT_BOTTOM
}

VIEWPORT_TYPE_QUADRANT_TOP_LEFT
VIEWPORT_TYPE_QUADRANT_TOP_RIGHT
VIEWPORT_TYPE_QUADRANT_BOTTOM_LEFT
VIEWPORT_TYPE_QUADRANT_BOTTOM_RIGHT

class ServerConnection {
public:
    void listen();  // Accept incoming connections
    void tick();    // Process network packets
};

class ClientConnection {
public:
    void connect(string host, int port);
    void sendPacket(shared_ptr<Packet> packet);
    void tick();  // Handle received packets
};

ClientConnection* connection = new ClientConnection();
connection->connect(serverIp, port);

// Client sends login packet
LoginPacket* login = new LoginPacket();
login->username = playerName;
login->protocolVersion = VERSION;
connection->send(login);

// Server sends level data
LevelDataPacket* levelData = new LevelDataPacket();
levelData->seed = level->getSeed();
levelData->gameType = level->getGameType();
connection->send(levelData);

// Server sends spawn chunks
for (ChunkPos pos : spawnChunks) {
    connection->send(new ChunkDataPacket(pos));
}

// Server spawns player
ServerPlayer* player = new ServerPlayer(server, level, username);
player->moveTo(spawnX, spawnY, spawnZ);
level->addEntity(player);

// Broadcast to other players
players->broadcastAll(
    new AddPlayerPacket(player)
);

void ClientConnection::disconnect(DisconnectReason reason) {
    sendAndDisconnect(
        new DisconnectPacket(reason)
    );
}

class ServerPlayer : public Player {
    ClientConnection* connection;
    ChunkPos lastChunk;
    
public:
    void tick() override;
    void sendInventory();
    void broadcastMove();
};

class MultiplayerLocalPlayer : public LocalPlayer {
    ClientConnection* connection;
    
public:
    void tick() override;
    void sendInput();
    void applyServerUpdate();
};

class ChunkDataPacket : public Packet {
public:
    int x, z;                    // Chunk coordinates
    bool groundUp;               // Full chunk
    int availableSections;       // Section bitmask
    byte* data;                  // Compressed chunk data
    int dataLength;
};

void MultiPlayerLevel::setChunkVisible(int x, int z, bool visible) {
    if (visible) {
        chunkCache->create(x, z);
    } else {
        chunkCache->drop(x, z);
        setTilesDirty(x*16, 0, z*16, 
                      x*16+15, maxBuildHeight, z*16+15);
    }
}

class TileUpdatePacket : public Packet {
public:
    int x, y, z;
    int tile;
    int data;
};

class ChunkTilesUpdatePacket : public Packet {
public:
    int xChunk, zChunk;
    vector<short> offsets;   // Relative positions
    vector<byte> tiles;      // Block IDs
    vector<byte> data;       // Block data
};

struct ResetInfo {
    int x, y, z;
    int ticks;      // Time until reset
    int tile;       // Original block
    int data;
};

vector<ResetInfo> updatesToReset;

if (--r.ticks == 0) {
    Level::setTileAndDataNoUpdate(r.x, r.y, r.z, r.tile, r.data);
}

class AddEntityPacket : public Packet {
public:
    int entityId;
    eINSTANCEOF type;
    int x, y, z;           // Position (* 32 for fixed point)
    byte yRot, xRot;       // Rotation
};

class MoveEntityPacket : public Packet {
public:
    int entityId;
    byte dx, dy, dz;       // Delta * 32
};

class TeleportEntityPacket : public Packet {
public:
    int entityId;
    int x, y, z;           // Absolute * 32
    byte yRot, xRot;
};

class SetEntityDataPacket : public Packet {
public:
    int entityId;
    map<int, DataItem*> data;  // Changed values only
};

class RemoveEntityPacket : public Packet {
public:
    int entityId;
};

class ClientConnection {
    SavedDataStorage* savedDataStorage;  // Shared with server
    bool connected;
    int timeoutCounter;
    
public:
    void tick();
    void send(shared_ptr<Packet> packet);
    void handlePacket(shared_ptr<Packet> packet);
};

if (++timeoutCounter > 20*30) {  // 30 seconds
    disconnect(DisconnectPacket::eDisconnect_Timeout);
}

class ServerConnection {
    MinecraftServer* server;
    vector<ClientConnection*> connections;
    
public:
    void tick();  // Tick all connections
    void broadcast(shared_ptr<Packet> packet);
};

ClientConnection* m_pendingLocalConnections[XUSER_MAX_COUNT];
bool m_connectionFailed[XUSER_MAX_COUNT];

void Minecraft::addPendingLocalConnection(int idx, 
                                          ClientConnection* conn) {
    m_pendingLocalConnections[idx] = conn;
}

void ServerConnection::tick() {
    for (ClientConnection* conn : connections) {
        while (Packet* packet = conn->receive()) {
            switch(packet->getType()) {
                case PLAYER_INPUT:
                    handlePlayerInput(conn, packet);
                    break;
                case PLAYER_ACTION:
                    handlePlayerAction(conn, packet);
                    break;
                case USE_ITEM:
                    handleUseItem(conn, packet);
                    break;
            }
        }
    }
}

void ClientConnection::tick() {
    while (Packet* packet = receive()) {
        switch(packet->getType()) {
            case CHUNK_DATA:
                handleChunkData(packet);
                break;
            case ADD_ENTITY:
                handleAddEntity(packet);
                break;
            case MOVE_ENTITY:
                handleMoveEntity(packet);
                break;
            case TILE_UPDATE:
                handleTileUpdate(packet);
                break;
        }
    }
}

enum DisconnectReason {
    eDisconnect_None,
    eDisconnect_Quitting,
    eDisconnect_Timeout,
    eDisconnect_Kicked,
    eDisconnect_SignOut,
    eDisconnect_NetworkError
};

void MultiPlayerLevel::disconnect(bool sendDisconnect) {
    if (sendDisconnect) {
        for (ClientConnection* conn : connections) {
            conn->sendAndDisconnect(
                new DisconnectPacket(eDisconnect_Quitting)
            );
        }
    } else {
        for (ClientConnection* conn : connections) {
            conn->close();
        }
    }
}

void Minecraft::removeLocalPlayerIdx(int idx) {
    if (localgameModes[idx] != NULL) {
        MultiPlayerLevel* mpLevel = 
            (MultiPlayerLevel*)getLevel(localplayers[idx]->dimension);
        
        mpLevel->removeClientConnection(
            localplayers[idx]->connection, true
        );
        
        g_NetworkManager.RemoveLocalPlayerByUserIndex(idx);
        getLevel(localplayers[idx]->dimension)->removeEntity(
            localplayers[idx]
        );
        
        delete localgameModes[idx];
        localgameModes[idx] = NULL;
    }
    
    localplayers[idx] = nullptr;
    updatePlayerViewportAssignments();
}

static int s_slowQueuePlayerIndex = 0;
static int s_slowQueueLastTime = 0;
static bool s_slowQueuePacketSent = false;

void MinecraftServer::cycleSlowQueueIndex() {
    s_slowQueuePlayerIndex = 
        (s_slowQueuePlayerIndex + 1) % players->count();
}

ChunkTilesUpdatePacket* packet = new ChunkTilesUpdatePacket();
for (TileUpdate update : pendingUpdates) {
    packet->add(update.x, update.y, update.z, 
                update.tile, update.data);
}
broadcast(packet);