Dedicated Server Software - Minecraft.Server.exe (#498)

* add: Dedicated Server implementation

- Introduced `ServerMain.cpp` for the dedicated server logic, handling command-line arguments, server initialization, and network management.
- Created `postbuild_server.ps1` script for post-build tasks, including copying necessary resources and DLLs for the dedicated server.
- Added `CopyServerAssets.cmake` to manage the copying of server assets during the build process, ensuring required files are available for the dedicated server.
- Defined project filters in `Minecraft.Server.vcxproj.filters` for better organization of server-related files.

* add: refactor world loader & add server properties

- Introduced ServerLogger for logging startup steps and world I/O operations.
- Implemented ServerProperties for loading and saving server configuration from `server.properties`.
- Added WorldManager to handle world loading and creation based on server properties.
- Updated ServerMain to integrate server properties loading and world management.
- Enhanced project files to include new source and header files for the server components.

* update: implement enhanced logging functionality with configurable log levels

* update: update keyboard and mouse input initialization 1dc8a005ed111463c22c17b487e5ec8a3e2d30f3

* fix: change virtual screen resolution to 1920x1080(HD)

Since 31881af56936aeef38ff322b975fd0 , `skinHud.swf` for 720 is not included in `MediaWindows64.arc`,
the app crashes unless the virtual screen is set to HD.

* fix: dedicated server build settings for miniaudio migration and missing sources

- remove stale Windows64 Miles (mss64) link/copy references from server build
- add Common/Filesystem/Filesystem.cpp to Minecraft.Server.vcxproj
- add Windows64/PostProcesser.cpp to Minecraft.Server.vcxproj
- fix unresolved externals (PostProcesser::*, FileExists) in dedicated server build

* update: changed the virtual screen to 720p

Since the crash caused by the 720p `skinHud.swf` not being included in `MediaWindows64.arc` has been resolved, switching back to 720p to reduce resource usage.

* add: add Docker support for Dedicated Server

add with entrypoint and build scripts

* fix: add initial save for newly created worlds in dedicated server

on the server side, I fixed the behavior introduced after commit aadb511, where newly created worlds are intentionally not saved to disk immediately.

* update: add basically all configuration options that are implemented in the classes to `server.properties`

* update: add LAN advertising configuration for server.properties

LAN-Discovery, which isn’t needed in server mode and could potentially be a security risk, has also been disabled(only server mode).

* add: add implementing interactive command line using linenoise

- Integrated linenoise library for line editing and completion in the server console.
- Updated ServerLogger to handle external writes safely during logging.
- Modified ServerMain to initialize and manage the ServerCli for command input.
- The implementation is separate from everything else, so it doesn't affect anything else.
- The command input section and execution section are separated into threads.

* update: enhance command line completion with predictive hints

Like most command line tools, it highlights predictions in gray.

* add: implement `StringUtils` for string manipulation and refactor usages

Unified the scattered utility functions.

* fix: send DisconnectPacket on shutdown and fix Win64 recv-thread teardown race

Before this change, server/host shutdown closed sockets directly in
ServerConnection::stop(), which bypassed the normal disconnect flow.
As a result, clients could be dropped without receiving a proper
DisconnectPacket during stop/kill/world-close paths.

Also, WinsockNetLayer::Shutdown() could destroy synchronization objects
while host-side recv threads were still exiting, causing a crash in
RecvThreadProc (access violation on world close in host mode).

* fix: return client to menus when Win64 host connection drops

- Add client-side host disconnect handling in CPlatformNetworkManagerStub::DoWork() for _WINDOWS64.
- When in QNET_STATE_GAME_PLAY as a non-host and WinsockNetLayer::IsConnected() becomes false, trigger g_NetworkManager.HandleDisconnect(false) to enter the normal disconnect/UI flow.
- Use m_bLeaveGameOnTick as a one-shot guard to prevent repeated disconnect handling while the link remains down.
- Reset m_bLeaveGameOnTick on LeaveGame(), HostGame(), and JoinGame() to avoid stale state across sessions.

* update: converted Japanese comments to English

* add: create `Minecraft.Server` developer guide in English and Japanese

* update: add note about issue

* add: add `nlohmann/json` json lib

* add: add FileUtils

Moved file operations to `utils`.

* add: Dedicated Server BAN access manager with persistent player and IP bans

- add Access frontend that publishes thread-safe ban manager snapshots for dedicated server use
- add BanManager storage for banned-players.json and banned-ips.json with load/save/update flows
- add persistent player and IP ban checks during dedicated server connection handling
- add UTF-8 BOM-safe JSON parsing and shared file helpers backed by nlohmann/json
- add Unicode-safe ban file read/write and safer atomic replacement behavior on Windows
- add active-ban snapshot APIs and expiry-aware filtering for expires metadata
- add RAII-based dedicated access shutdown handling during server startup and teardown

* update: changed file read/write operations to use `FileUtils`.

- As a side effect, saving has become faster!

* fix: Re-added the source that had somehow disappeared.

* add: significantly improved the dedicated server logging system

- add ServerLogManager to Minecraft.Server as the single entry point for dedicated-server log output
- forward CMinecraftApp logger output to the server logger when running with g_Win64DedicatedServer
- add named network logs for incoming, accepted, rejected, and disconnected connections
- cache connection metadata by smallId so player name and remote IP remain available for disconnect logs
- keep Minecraft.Client changes minimal by using lightweight hook points and handling log orchestration on the server side

* fix: added the updated library source

* add: add `ban` and `pardon` commands for Player and IP

* fix: fix stop command shutdown process

add dedicated server shutdown request handling

* fix: fixed the save logic during server shutdown

Removed redundant repeated saves and eliminated the risks of async writes.

* update: added new sever files to Docker entrypoint

* fix: replace shutdown flag with atomic variable for thread safety

* update: update Dedicated Server developer guide

English is machine translated.
Please forgive me.

* update: check for the existence of `GameHDD` and create

* add: add Whitelist to Dedicated Server

* refactor: clean up and refactor the code

- unify duplicated implementations that were copied repeatedly
- update outdated patterns to more modern ones

* fix: include UI header (new update fix)

* fix: fix the detection range for excessive logging

`getHighestNonEmptyY()` returning `-1` occurs normally when the chunk is entirely air.
The caller (`Minecraft.World/LevelChunk.cpp:2400`) normalizes `-1` to `0`.

* update: add world size config to dedicated server properties

* update: update README add explanation of  `server.properties` & launch arguments

* update: add nightly release workflow for dedicated server and client builds to Actions

* fix: update name for workflow

* add random seed generation

* add: add Docker nightly workflow for Dedicated Server publish to GitHub Container Registry

* fix: ghost player when clients disconnect out of order

#4

* fix: fix 7zip option

* fix: fix Docker workflow for Dedicated Server artifact handling

* add: add no build Dedicated Server startup scripts and Docker Compose

* update: add README for Docker Dedicated Server setup with no local build

* refactor: refactor command path structure

As the number of commands has increased and become harder to navigate, each command has been organized into separate folders.

* update: support stream(file stdin) input mode for server CLI

Support for the stream (file stdin) required when attaching a tty to a Docker container on Linux.

* add: add new CLI Console Commands for Dedicated Server

Most of these commands are executed using the command dispatcher implemented on the `Minecraft.World` side. When registering them with the dispatcher, the sender uses a permission-enabled configuration that treats the CLI as a player.

- default game.
- enchant
- experience.
- give
- kill(currently, getting a permission error for some reason)
- time
- weather.
- update tp & gamemode command

* fix: change player map icon to random select

* update: increase the player limit

* add: restore the basic anti-cheat implementation and add spawn protection

Added the following anti-cheat measures and add spawn protection to `server.properties`.
- instant break
- speed
- reach

* fix: fix Docker image tag

---------

Co-authored-by: sylvessa <225480449+sylvessa@users.noreply.github.com>

2 files changed, 302 insertions, 0 deletions

diff --git a/Minecraft.Server/Console/commands/whitelist/CliCommandWhitelist.cpp b/Minecraft.Server/Console/commands/whitelist/CliCommandWhitelist.cpp
new file mode 100644
index 00000000..03724278
--- /dev/null
+++ b/Minecraft.Server/Console/commands/whitelist/CliCommandWhitelist.cpp
@@ -0,0 +1,285 @@
+#include "stdafx.h"
+
+#include "CliCommandWhitelist.h"
+
+#include "..\..\ServerCliEngine.h"
+#include "..\..\ServerCliParser.h"
+#include "..\..\..\Access\Access.h"
+#include "..\..\..\Common\StringUtils.h"
+#include "..\..\..\ServerProperties.h"
+
+#include <algorithm>
+#include <array>
+
+namespace ServerRuntime
+{
+	namespace
+	{
+		static const char *kWhitelistUsage = "whitelist <on|off|list|add|remove|reload> [...]";
+
+		static bool CompareWhitelistEntries(const ServerRuntime::Access::WhitelistedPlayerEntry &left, const ServerRuntime::Access::WhitelistedPlayerEntry &right)
+		{
+			const auto leftName = StringUtils::ToLowerAscii(left.name);
+			const auto rightName = StringUtils::ToLowerAscii(right.name);
+			if (leftName != rightName)
+			{
+				return leftName < rightName;
+			}
+
+			return StringUtils::ToLowerAscii(left.xuid) < StringUtils::ToLowerAscii(right.xuid);
+		}
+
+		static bool PersistWhitelistToggle(bool enabled)
+		{
+			auto config = LoadServerPropertiesConfig();
+			config.whiteListEnabled = enabled;
+			return SaveServerPropertiesConfig(config);
+		}
+
+		static std::string BuildWhitelistEntryRow(const ServerRuntime::Access::WhitelistedPlayerEntry &entry)
+		{
+			std::string row = "  ";
+			row += entry.xuid;
+			if (!entry.name.empty())
+			{
+				row += " - ";
+				row += entry.name;
+			}
+			return row;
+		}
+
+		static void LogWhitelistMode(ServerCliEngine *engine)
+		{
+			engine->LogInfo(std::string("Whitelist is ") + (ServerRuntime::Access::IsWhitelistEnabled() ? "enabled." : "disabled."));
+		}
+
+		static bool LogWhitelistEntries(ServerCliEngine *engine)
+		{
+			std::vector<ServerRuntime::Access::WhitelistedPlayerEntry> entries;
+			if (!ServerRuntime::Access::SnapshotWhitelistedPlayers(&entries))
+			{
+				engine->LogError("Failed to read whitelist entries.");
+				return false;
+			}
+
+			std::sort(entries.begin(), entries.end(), CompareWhitelistEntries);
+			LogWhitelistMode(engine);
+			engine->LogInfo("There are " + std::to_string(entries.size()) + " whitelisted player(s).");
+			for (const auto &entry : entries)
+			{
+				engine->LogInfo(BuildWhitelistEntryRow(entry));
+			}
+			return true;
+		}
+
+		static bool TryParseWhitelistXuid(const std::string &text, ServerCliEngine *engine, PlayerUID *outXuid)
+		{
+			if (ServerRuntime::Access::TryParseXuid(text, outXuid))
+			{
+				return true;
+			}
+
+			engine->LogWarn("Invalid XUID: " + text);
+			return false;
+		}
+
+		static void SuggestLiteral(const std::string &candidate, const ServerCliCompletionContext &context, std::vector<std::string> *out)
+		{
+			if (out == nullptr)
+			{
+				return;
+			}
+
+			if (StringUtils::StartsWithIgnoreCase(candidate, context.prefix))
+			{
+				out->push_back(context.linePrefix + candidate);
+			}
+		}
+	}
+
+	const char *CliCommandWhitelist::Name() const
+	{
+		return "whitelist";
+	}
+
+	const char *CliCommandWhitelist::Usage() const
+	{
+		return kWhitelistUsage;
+	}
+
+	const char *CliCommandWhitelist::Description() const
+	{
+		return "Manage the dedicated-server XUID whitelist.";
+	}
+
+	bool CliCommandWhitelist::Execute(const ServerCliParsedLine &line, ServerCliEngine *engine)
+	{
+		if (line.tokens.size() < 2)
+		{
+			engine->LogWarn(std::string("Usage: ") + kWhitelistUsage);
+			return false;
+		}
+		if (!ServerRuntime::Access::IsInitialized())
+		{
+			engine->LogWarn("Access manager is not initialized.");
+			return false;
+		}
+
+		const auto subcommand = StringUtils::ToLowerAscii(line.tokens[1]);
+		if (subcommand == "on" || subcommand == "off")
+		{
+			if (line.tokens.size() != 2)
+			{
+				engine->LogWarn("Usage: whitelist <on|off>");
+				return false;
+			}
+
+			const bool enabled = (subcommand == "on");
+			if (!PersistWhitelistToggle(enabled))
+			{
+				engine->LogError("Failed to persist whitelist mode to server.properties.");
+				return false;
+			}
+
+			ServerRuntime::Access::SetWhitelistEnabled(enabled);
+			engine->LogInfo(std::string("Whitelist ") + (enabled ? "enabled." : "disabled."));
+			return true;
+		}
+
+		if (subcommand == "list")
+		{
+			if (line.tokens.size() != 2)
+			{
+				engine->LogWarn("Usage: whitelist list");
+				return false;
+			}
+
+			return LogWhitelistEntries(engine);
+		}
+
+		if (subcommand == "reload")
+		{
+			if (line.tokens.size() != 2)
+			{
+				engine->LogWarn("Usage: whitelist reload");
+				return false;
+			}
+			if (!ServerRuntime::Access::ReloadWhitelist())
+			{
+				engine->LogError("Failed to reload whitelist.");
+				return false;
+			}
+
+			const auto config = LoadServerPropertiesConfig();
+			ServerRuntime::Access::SetWhitelistEnabled(config.whiteListEnabled);
+			engine->LogInfo("Reloaded whitelist from disk.");
+			LogWhitelistMode(engine);
+			return true;
+		}
+
+		if (subcommand == "add")
+		{
+			if (line.tokens.size() < 3)
+			{
+				engine->LogWarn("Usage: whitelist add <xuid> [name ...]");
+				return false;
+			}
+
+			PlayerUID xuid = INVALID_XUID;
+			if (!TryParseWhitelistXuid(line.tokens[2], engine, &xuid))
+			{
+				return false;
+			}
+
+			if (ServerRuntime::Access::IsPlayerWhitelisted(xuid))
+			{
+				engine->LogWarn("That XUID is already whitelisted.");
+				return false;
+			}
+
+			const auto metadata = ServerRuntime::Access::WhitelistManager::BuildDefaultMetadata("Console");
+			const auto name = StringUtils::JoinTokens(line.tokens, 3);
+			if (!ServerRuntime::Access::AddWhitelistedPlayer(xuid, name, metadata))
+			{
+				engine->LogError("Failed to write whitelist entry.");
+				return false;
+			}
+
+			std::string message = "Whitelisted XUID " + ServerRuntime::Access::FormatXuid(xuid) + ".";
+			if (!name.empty())
+			{
+				message += " Name: " + name;
+			}
+			engine->LogInfo(message);
+			return true;
+		}
+
+		if (subcommand == "remove")
+		{
+			if (line.tokens.size() != 3)
+			{
+				engine->LogWarn("Usage: whitelist remove <xuid>");
+				return false;
+			}
+
+			PlayerUID xuid = INVALID_XUID;
+			if (!TryParseWhitelistXuid(line.tokens[2], engine, &xuid))
+			{
+				return false;
+			}
+
+			if (!ServerRuntime::Access::IsPlayerWhitelisted(xuid))
+			{
+				engine->LogWarn("That XUID is not whitelisted.");
+				return false;
+			}
+
+			if (!ServerRuntime::Access::RemoveWhitelistedPlayer(xuid))
+			{
+				engine->LogError("Failed to remove whitelist entry.");
+				return false;
+			}
+
+			engine->LogInfo("Removed XUID " + ServerRuntime::Access::FormatXuid(xuid) + " from the whitelist.");
+			return true;
+		}
+
+		engine->LogWarn(std::string("Usage: ") + kWhitelistUsage);
+		return false;
+	}
+
+	void CliCommandWhitelist::Complete(const ServerCliCompletionContext &context, const ServerCliEngine *engine, std::vector<std::string> *out) const
+	{
+		(void)engine;
+		if (out == nullptr)
+		{
+			return;
+		}
+
+		if (context.currentTokenIndex == 1)
+		{
+			SuggestLiteral("on", context, out);
+			SuggestLiteral("off", context, out);
+			SuggestLiteral("list", context, out);
+			SuggestLiteral("add", context, out);
+			SuggestLiteral("remove", context, out);
+			SuggestLiteral("reload", context, out);
+			return;
+		}
+
+		if (context.currentTokenIndex == 2 && context.parsed.tokens.size() >= 2 && StringUtils::ToLowerAscii(context.parsed.tokens[1]) == "remove")
+		{
+			std::vector<ServerRuntime::Access::WhitelistedPlayerEntry> entries;
+			if (!ServerRuntime::Access::SnapshotWhitelistedPlayers(&entries))
+			{
+				return;
+			}
+
+			for (const auto &entry : entries)
+			{
+				SuggestLiteral(entry.xuid, context, out);
+			}
+		}
+	}
+}
+
diff --git a/Minecraft.Server/Console/commands/whitelist/CliCommandWhitelist.h b/Minecraft.Server/Console/commands/whitelist/CliCommandWhitelist.h
new file mode 100644
index 00000000..45e21a5e
--- /dev/null
+++ b/Minecraft.Server/Console/commands/whitelist/CliCommandWhitelist.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include "..\IServerCliCommand.h"
+
+namespace ServerRuntime
+{
+	class CliCommandWhitelist : public IServerCliCommand
+	{
+	public:
+		const char *Name() const override;
+		const char *Usage() const override;
+		const char *Description() const override;
+		bool Execute(const ServerCliParsedLine &line, ServerCliEngine *engine) override;
+		void Complete(const ServerCliCompletionContext &context, const ServerCliEngine *engine, std::vector<std::string> *out) const override;
+	};
+}
+