[WorldController] Added. It's basically a container for 'ServerWorld' instances.

Author: Unarelith

common/source/core/Registry.hpp

@@ -98,6 +98,7 @@ class Registry : public ISerializable {
 		const std::vector<Item> &items() const { return m_items; }
 		const std::vector<Tree> &trees() const { return m_trees; }
 		const std::vector<Biome> &biomes() const { return m_biomes; }
+		const std::vector<Dimension> &dimensions() const { return m_dimensions; }
 
 		static Registry &getInstance() { return *s_instance; }
 		static void setInstance(Registry &instance) { s_instance = &instance; }

server/source/core/ServerApplication.cpp

@@ -47,8 +47,6 @@ void ServerApplication::init() {
 	m_registry.registerItem({}, "_:air", "Air").setIsBlock(true);
 
 	m_scriptEngine.init();
-	// m_luaCore.setPlayer(m_player); // FIXME
-	m_luaCore.setWorld(m_world);
 
 	try {
 		m_scriptEngine.lua()["openminer"] = &m_luaCore;
@@ -64,7 +62,8 @@ void ServerApplication::init() {
 
 	m_serverCommandHandler.setupCallbacks();
 
-	m_world.setServer(&m_serverCommandHandler);
+	m_worldController.setServer(m_serverCommandHandler);
+	m_worldController.init();
 
 	std::cout << "Server is running on localhost:" << m_port << std::endl;
 }
@@ -89,7 +88,7 @@ int ServerApplication::run(bool isProtected) {
 }
 
 void ServerApplication::update() {
-	m_world.update(m_players);
+	m_worldController.update(m_players);
 
 	if (gk::GameClock::getTicks() % 100 < 10) {
 		for (auto &it : m_players) {

server/source/core/ServerApplication.hpp

@@ -36,7 +36,7 @@
 #include "Server.hpp"
 #include "ServerCommandHandler.hpp"
 #include "ServerPlayer.hpp"
-#include "ServerWorld.hpp"
+#include "WorldController.hpp"
 
 class ServerApplication {
 	public:
@@ -56,18 +56,18 @@ class ServerApplication {
 		gk::ArgumentParser m_argumentParser;
 		gk::GameClock m_clock;
 
-		Server m_server;
-		ServerWorld m_world;
-		std::unordered_map<u16, ServerPlayer> m_players;
+		Registry m_registry;
 
 		ScriptEngine m_scriptEngine;
-		LuaCore m_luaCore;
-
-		Registry m_registry;
+		LuaCore m_luaCore{m_registry};
 
 		u16 m_port = 4242;
 
-		ServerCommandHandler m_serverCommandHandler{m_scriptEngine, m_server, m_world, m_players, m_registry};
+		WorldController m_worldController{m_registry};
+		std::unordered_map<u16, ServerPlayer> m_players;
+
+		Server m_server;
+		ServerCommandHandler m_serverCommandHandler{m_scriptEngine, m_server, m_worldController, m_players, m_registry};
 };
 
 #endif // SERVERAPPLICATION_HPP_

server/source/lua/LuaCore.cpp

@@ -29,12 +29,11 @@
 #include "ServerWorld.hpp"
 
 Registry *LuaCore::registry() {
-	return &Registry::getInstance();
+	return &m_registry;
 }
 
 void LuaCore::initUsertype(sol::state &lua) {
 	lua.new_usertype<LuaCore>("LuaCore",
-		"world",    &LuaCore::world,
 		"registry", &LuaCore::registry
 	);
 }

server/source/lua/LuaCore.hpp

@@ -32,19 +32,17 @@
 #include <sol.hpp>
 
 class Registry;
-class ServerWorld;
 
 class LuaCore {
 	public:
-		ServerWorld *world() { return m_world; }
-		void setWorld(ServerWorld &world) { m_world = &world; }
+		LuaCore(Registry &registry) : m_registry(registry) {}
 
 		Registry *registry();
 
 		static void initUsertype(sol::state &lua);
 
 	private:
-		ServerWorld *m_world = nullptr;
+		Registry &m_registry;
 };
 
 #endif // LUACORE_HPP_

server/source/network/ServerCommandHandler.cpp

@@ -30,8 +30,8 @@
 #include "Server.hpp"
 #include "ServerBlock.hpp"
 #include "ServerPlayer.hpp"
-#include "ServerWorld.hpp"
 #include "ServerCommandHandler.hpp"
+#include "WorldController.hpp"
 
 void ServerCommandHandler::sendBlockDataUpdate(s32 x, s32 y, s32 z, const BlockData *blockData, const ClientInfo *client) const {
 	sf::Packet packet;
@@ -125,7 +125,7 @@ void ServerCommandHandler::setupCallbacks() {
 		s32 cx, cy, cz;
 		packet >> cx >> cy >> cz;
 
-		m_world.sendRequestedData(client, cx, cy, cz);
+		getWorldForClient(client.id).sendRequestedData(client, cx, cy, cz);
 	});
 
 	m_server.setCommandCallback(Network::Command::PlayerInvUpdate, [this](ClientInfo &client, sf::Packet &packet) {
@@ -146,22 +146,24 @@ void ServerCommandHandler::setupCallbacks() {
 			m_players.at(client.id).setPosition(x, y, z);
 	});
 
-	m_server.setCommandCallback(Network::Command::PlayerPlaceBlock, [this](ClientInfo &, sf::Packet &packet) {
+	m_server.setCommandCallback(Network::Command::PlayerPlaceBlock, [this](ClientInfo &client, sf::Packet &packet) {
 		s32 x, y, z;
 		u32 block;
 		packet >> x >> y >> z >> block;
-		m_world.setBlock(x, y, z, block & 0xffff);
-		m_world.setData(x, y, z, block >> 16);
+
+		ServerWorld &world = getWorldForClient(client.id);
+		world.setBlock(x, y, z, block & 0xffff);
+		world.setData(x, y, z, block >> 16);
 
 		sf::Packet answer;
 		answer << Network::Command::BlockUpdate << x << y << z << block;
 		m_server.sendToAllClients(answer);
 	});
 
-	m_server.setCommandCallback(Network::Command::PlayerDigBlock, [this](ClientInfo &, sf::Packet &packet) {
+	m_server.setCommandCallback(Network::Command::PlayerDigBlock, [this](ClientInfo &client, sf::Packet &packet) {
 		s32 x, y, z;
 		packet >> x >> y >> z;
-		m_world.setBlock(x, y, z, 0);
+		getWorldForClient(client.id).setBlock(x, y, z, 0);
 
 		sf::Packet answer;
 		answer << Network::Command::BlockUpdate << x << y << z << u32(0);
@@ -204,26 +206,28 @@ void ServerCommandHandler::setupCallbacks() {
 		u8 guiScale;
 		packet >> x >> y >> z >> screenWidth >> screenHeight >> guiScale;
 
-		u16 id = m_world.getBlock(x, y, z);
-		((ServerBlock &)(m_registry.getBlock(id))).onBlockActivated({x, y, z}, m_players.at(client.id), m_world, client, screenWidth, screenHeight, guiScale);
+		ServerWorld &world = getWorldForClient(client.id);
+
+		u16 id = world.getBlock(x, y, z);
+		((ServerBlock &)(m_registry.getBlock(id))).onBlockActivated({x, y, z}, m_players.at(client.id), world, client, screenWidth, screenHeight, guiScale);
 	});
 
-	m_server.setCommandCallback(Network::Command::BlockInvUpdate, [this](ClientInfo &, sf::Packet &packet) {
+	m_server.setCommandCallback(Network::Command::BlockInvUpdate, [this](ClientInfo &client, sf::Packet &packet) {
 		gk::Vector3<s32> pos;
 		packet >> pos.x >> pos.y >> pos.z;
 
-		BlockData *data = m_world.getBlockData(pos.x, pos.y, pos.z);
+		BlockData *data = getWorldForClient(client.id).getBlockData(pos.x, pos.y, pos.z);
 		if (data)
 			packet >> data->inventory;
 		else
 			DEBUG("BlockInvUpdate: No block data found at", pos.x, pos.y, pos.z);
 	});
 
-	m_server.setCommandCallback(Network::Command::BlockDataUpdate, [this](ClientInfo &, sf::Packet &packet) {
+	m_server.setCommandCallback(Network::Command::BlockDataUpdate, [this](ClientInfo &client, sf::Packet &packet) {
 		gk::Vector3<s32> pos;
 		packet >> pos.x >> pos.y >> pos.z;
 
-		BlockData *data = m_world.getBlockData(pos.x, pos.y, pos.z);
+		BlockData *data = getWorldForClient(client.id).getBlockData(pos.x, pos.y, pos.z);
 		if (data) {
 			packet >> data->meta >> data->useAltTiles;
 		}
@@ -278,3 +282,11 @@ void ServerCommandHandler::setupCallbacks() {
 	});
 }
 
+inline ServerWorld &ServerCommandHandler::getWorldForClient(u16 clientID) {
+	auto it = m_players.find(clientID);
+	if (it == m_players.end())
+		throw EXCEPTION("Player instance not found for client", clientID);
+
+	return m_worldController.getWorld(it->second.dimension());
+}
+

server/source/network/ServerCommandHandler.hpp

@@ -40,11 +40,12 @@ class ScriptEngine;
 class Server;
 class ServerPlayer;
 class ServerWorld;
+class WorldController;
 
 class ServerCommandHandler {
 	public:
-		ServerCommandHandler(ScriptEngine &scriptEngine, Server &server, ServerWorld &world, std::unordered_map<u16, ServerPlayer> &players, Registry &registry)
-			: m_scriptEngine(scriptEngine), m_server(server), m_world(world), m_players(players), m_registry(registry) {}
+		ServerCommandHandler(ScriptEngine &scriptEngine, Server &server, WorldController &worldController, std::unordered_map<u16, ServerPlayer> &players, Registry &registry)
+			: m_scriptEngine(scriptEngine), m_server(server), m_worldController(worldController), m_players(players), m_registry(registry) {}
 
 		void sendBlockDataUpdate(s32 x, s32 y, s32 z, const BlockData *blockData, const ClientInfo *client = nullptr) const;
 		void sendBlockInvUpdate(s32 x, s32 y, s32 z, const Inventory &inventory, const ClientInfo *client = nullptr) const;
@@ -56,10 +57,12 @@ class ServerCommandHandler {
 		const Server &server() const { return m_server; }
 
 	private:
+		ServerWorld &getWorldForClient(u16 clientID);
+
 		ScriptEngine &m_scriptEngine;
 
 		Server &m_server;
-		ServerWorld &m_world;
+		WorldController &m_worldController;
 		std::unordered_map<u16, ServerPlayer> &m_players;
 
 		Registry &m_registry;

server/source/world/ServerWorld.hpp

@@ -34,14 +34,15 @@
 #include "World.hpp"
 
 class ClientInfo;
+class Dimension;
 class ServerCommandHandler;
 class ServerPlayer;
 
 class ServerWorld : public World {
 	using ChunkMap = std::unordered_map<gk::Vector3i, std::unique_ptr<ServerChunk>>;
 
 	public:
-		ServerWorld() = default;
+		ServerWorld(const Dimension &dimension) : m_dimension(dimension) {}
 
 		void update(std::unordered_map<u16, ServerPlayer> &players);
 
@@ -51,11 +52,15 @@ class ServerWorld : public World {
 
 		Chunk *getChunk(int cx, int cy, int cz) const override;
 
+		const Dimension &dimension() const { return m_dimension; }
+
 		TerrainGenerator &terrainGenerator() { return m_terrainGenerator; }
 
 		void setServer(ServerCommandHandler *server) { m_server = server; }
 
 	private:
+		const Dimension &m_dimension;
+
 		ChunkMap m_chunks;
 
 		u32 m_lastTick = 0;

server/source/world/WorldController.cpp

@@ -0,0 +1,41 @@
+/*
+ * =====================================================================================
+ *
+ *  OpenMiner
+ *
+ *  Copyright (C) 2018-2020 Unarelith, Quentin Bazin <[email protected]>
+ *  Copyright (C) 2019-2020 the OpenMiner contributors (see CONTRIBUTORS.md)
+ *
+ *  This file is part of OpenMiner.
+ *
+ *  OpenMiner is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  OpenMiner is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with OpenMiner; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * =====================================================================================
+ */
+#include "Registry.hpp"
+#include "WorldController.hpp"
+
+void WorldController::init() {
+	for (const Dimension &dimension : m_registry.dimensions()) {
+		m_worldList.emplace_back(dimension);
+		m_worldList.back().setServer(m_server);
+	}
+}
+
+void WorldController::update(std::unordered_map<u16, ServerPlayer> &players) {
+	for (auto &it : m_worldList)
+		it.update(players);
+}
+

server/source/world/WorldController.hpp

@@ -0,0 +1,57 @@
+/*
+ * =====================================================================================
+ *
+ *  OpenMiner
+ *
+ *  Copyright (C) 2018-2020 Unarelith, Quentin Bazin <[email protected]>
+ *  Copyright (C) 2019-2020 the OpenMiner contributors (see CONTRIBUTORS.md)
+ *
+ *  This file is part of OpenMiner.
+ *
+ *  OpenMiner is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  OpenMiner is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with OpenMiner; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * =====================================================================================
+ */
+#ifndef WORLDCONTROLLER_HPP_
+#define WORLDCONTROLLER_HPP_
+
+#include <deque>
+
+#include "ServerWorld.hpp"
+
+class Registry;
+
+class WorldController {
+	public:
+		WorldController(Registry &registry)
+			: m_registry(registry) {}
+
+		void init();
+
+		void update(std::unordered_map<u16, ServerPlayer> &players);
+
+		ServerWorld &getWorld(u16 dimension) { return m_worldList.at(dimension); }
+
+		void setServer(ServerCommandHandler &server) { m_server = &server; }
+
+	private:
+		std::vector<ServerWorld> m_worldList;
+
+		Registry &m_registry;
+
+		ServerCommandHandler *m_server = nullptr;
+};
+
+#endif // WORLDCONTROLLER_HPP_