Files
neoLegacy/Minecraft.Server/ServerProperties.cpp
T
DrPerkyLegit 2af29e050b implement per socket send locks, remove useless cipher encryption
cipher encryption is useless, we legit have the source code, someone can just add cheats to the game or hook into where the client decodes / encodes the packets, its just useless performance overhead rn
2026-10-30 14:40:00 -04:00

971 lines
25 KiB
C++

#include "stdafx.h"
#include "ServerProperties.h"
#include "ServerLogger.h"
#include "Common//StringUtils.h"
#include "Common//FileUtils.h"
#include "..//Minecraft.World//ChunkSource.h"
#include <cctype>
#include <map>
#include <stdio.h>
#include <stdlib.h>
#include <unordered_map>
namespace ServerRuntime
{
using StringUtils::ToLowerAscii;
using StringUtils::TrimAscii;
using StringUtils::StripUtf8Bom;
using StringUtils::Utf8ToWide;
using StringUtils::WideToUtf8;
struct ServerPropertyDefault
{
const char *key;
const char *value;
};
static const char *kServerPropertiesPath = "server.properties";
static const size_t kMaxSaveIdLength = 31;
static const int kDefaultServerPort = 25565;
static const int kDefaultMaxPlayers = 16;
static const int kMaxDedicatedPlayers = 256;
static const int kDefaultAutosaveIntervalSeconds = 60;
static const char *kLanAdvertisePropertyKey = "lan-advertise";
static const ServerPropertyDefault kServerPropertyDefaults[] =
{
{ "allow-flight", "true" },
{ "allow-nether", "true" },
{ "autosave-interval", "60" },
{ "bedrock-fog", "true" },
{ "bonus-chest", "false" },
{ "difficulty", "1" },
{ "disable-saving", "false" },
{ "do-daylight-cycle", "true" },
{ "do-mob-loot", "true" },
{ "do-mob-spawning", "true" },
{ "do-tile-drops", "true" },
{ "fire-spreads", "true" },
{ "friends-of-friends", "false" },
{ "gamemode", "0" },
{ "gamertags", "true" },
{ "generate-structures", "true" },
{ "hardcore", "false" },
{ "hardcore-ban-ip", "false" },
{ "host-can-be-invisible", "true" },
{ "host-can-change-hunger", "true" },
{ "host-can-fly", "true" },
{ "keep-inventory", "false" },
{ "level-id", "world" },
{ "level-name", "world" },
{ "level-seed", "" },
{ "level-type", "default" },
{ "world-size", "classic" },
{ "spawn-protection", "0" },
{ "log-level", "info" },
{ "max-build-height", "256" },
{ "max-players", "16" },
{ "mob-griefing", "true" },
{ "motd", "A Minecraft Server" },
{ "natural-regeneration", "true" },
{ "pvp", "true" },
{ "server-ip", "0.0.0.0" },
{ "server-name", "DedicatedServer" },
{ "server-port", "25565" },
{ "white-list", "false" },
{ "lan-advertise", "false" },
{ "spawn-animals", "true" },
{ "spawn-monsters", "true" },
{ "spawn-npcs", "true" },
{ "tnt", "true" },
{ "trust-players", "true" },
{ "hide-player-list-prelogin", "true" },
{ "rate-limit-connections-per-window", "5" },
{ "rate-limit-window-seconds", "30" },
{ "max-pending-connections", "10" },
{ "require-challenge-token", "false" },
{ "enable-stream-cipher", "true" },
{ "require-secure-client", "true" },
{ "proxy-protocol", "false" }
};
static std::string BoolToString(bool value)
{
return value ? "true" : "false";
}
static std::string IntToString(int value)
{
char buffer[32] = {};
sprintf_s(buffer, sizeof(buffer), "%d", value);
return std::string(buffer);
}
static std::string Int64ToString(__int64 value)
{
char buffer[64] = {};
_i64toa_s(value, buffer, sizeof(buffer), 10);
return std::string(buffer);
}
static int ClampInt(int value, int minValue, int maxValue)
{
if (value < minValue)
{
return minValue;
}
if (value > maxValue)
{
return maxValue;
}
return value;
}
static bool TryParseBool(const std::string &value, bool *outValue)
{
if (outValue == NULL)
{
return false;
}
std::string lowered = ToLowerAscii(TrimAscii(value));
if (lowered == "true" || lowered == "1" || lowered == "yes" || lowered == "on")
{
*outValue = true;
return true;
}
if (lowered == "false" || lowered == "0" || lowered == "no" || lowered == "off")
{
*outValue = false;
return true;
}
return false;
}
static bool TryParseInt(const std::string &value, int *outValue)
{
if (outValue == NULL)
{
return false;
}
std::string trimmed = TrimAscii(value);
if (trimmed.empty())
{
return false;
}
char *end = NULL;
long parsed = strtol(trimmed.c_str(), &end, 10);
if (end == trimmed.c_str() || *end != 0)
{
return false;
}
*outValue = (int)parsed;
return true;
}
static bool TryParseInt64(const std::string &value, __int64 *outValue)
{
if (outValue == NULL)
{
return false;
}
std::string trimmed = TrimAscii(value);
if (trimmed.empty())
{
return false;
}
char *end = NULL;
__int64 parsed = _strtoi64(trimmed.c_str(), &end, 10);
if (end == trimmed.c_str() || *end != 0)
{
return false;
}
*outValue = parsed;
return true;
}
static std::string LogLevelToPropertyValue(EServerLogLevel level)
{
switch (level)
{
case eServerLogLevel_Debug:
return "debug";
case eServerLogLevel_Warn:
return "warn";
case eServerLogLevel_Error:
return "error";
case eServerLogLevel_Info:
default:
return "info";
}
}
/**
* **Normalize Save ID**
*
* Normalizes an arbitrary string into a safe save destination ID
* Conversion rules:
* - Lowercase alphabetic characters
* - Keep only `[a-z0-9_.-]`
* - Replace spaces and unsupported characters with `_`
* - Fallback to `world` when empty
* - Enforce max length to match storage constraints
* 保存先IDの正規化処理
*/
static std::string NormalizeSaveId(const std::string &source)
{
std::string out;
out.reserve(source.length());
// Normalize into a character set that is safe for storage save IDs
// Replace invalid characters with '_' and fold letter case to reduce collisions
for (size_t i = 0; i < source.length(); ++i)
{
unsigned char ch = (unsigned char)source[i];
if (ch >= 'A' && ch <= 'Z')
{
ch = (unsigned char)(ch - 'A' + 'a');
}
const bool alnum = (ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9');
const bool passthrough = (ch == '_') || (ch == '-') || (ch == '.');
if (alnum || passthrough)
{
out.push_back((char)ch);
}
else if (std::isspace(ch))
{
out.push_back('_');
}
else if (ch < 0x80)
{
out.push_back('_');
}
}
if (out.empty())
{
out = "world";
}
// Add a prefix when needed to avoid awkward leading characters
if (!((out[0] >= 'a' && out[0] <= 'z') || (out[0] >= '0' && out[0] <= '9')))
{
out = std::string("w_") + out;
}
// Clamp length to the 4J-side filename buffer constraint
if (out.length() > kMaxSaveIdLength)
{
out.resize(kMaxSaveIdLength);
}
return out;
}
static void ApplyDefaultServerProperties(std::unordered_map<std::string, std::string> *properties)
{
if (properties == NULL)
{
return;
}
const size_t defaultCount = sizeof(kServerPropertyDefaults) / sizeof(kServerPropertyDefaults[0]);
for (size_t i = 0; i < defaultCount; ++i)
{
(*properties)[kServerPropertyDefaults[i].key] = kServerPropertyDefaults[i].value;
}
}
/**
* **Parse server.properties Text**
*
* Extracts key/value pairs from `server.properties` format text
* - Ignores lines starting with `#` or `!` as comments
* - Accepts `=` or `:` as separators
* - Skips invalid lines and continues
* server.propertiesのパース処理
*/
static bool ReadServerPropertiesFile(const char *filePath, std::unordered_map<std::string, std::string> *properties, int *outParsedCount)
{
if (properties == NULL)
{
return false;
}
std::string text;
if (filePath == NULL || !FileUtils::ReadTextFile(filePath, &text))
{
return false;
}
text = StripUtf8Bom(text);
int parsedCount = 0;
for (size_t start = 0; start <= text.length();)
{
size_t end = text.find_first_of("\r\n", start);
size_t nextStart = text.length() + 1;
if (end != std::string::npos)
{
nextStart = end + 1;
if (text[end] == '\r' && nextStart < text.length() && text[nextStart] == '\n')
{
++nextStart;
}
}
std::string line;
if (end == std::string::npos)
{
line = text.substr(start);
}
else
{
line = text.substr(start, end - start);
}
std::string trimmedLine = TrimAscii(line);
if (trimmedLine.empty())
{
start = nextStart;
continue;
}
if (trimmedLine[0] == '#' || trimmedLine[0] == '!')
{
start = nextStart;
continue;
}
size_t eqPos = trimmedLine.find('=');
size_t colonPos = trimmedLine.find(':');
size_t sepPos = std::string::npos;
if (eqPos == std::string::npos)
{
sepPos = colonPos;
}
else if (colonPos == std::string::npos)
{
sepPos = eqPos;
}
else
{
sepPos = (eqPos < colonPos) ? eqPos : colonPos;
}
if (sepPos == std::string::npos)
{
start = nextStart;
continue;
}
std::string key = TrimAscii(trimmedLine.substr(0, sepPos));
if (key.empty())
{
start = nextStart;
continue;
}
std::string value = TrimAscii(trimmedLine.substr(sepPos + 1));
(*properties)[key] = value;
++parsedCount;
start = nextStart;
}
if (outParsedCount != NULL)
{
*outParsedCount = parsedCount;
}
return true;
}
/**
* **Write server.properties Text**
*
* Writes key/value data back as `server.properties`
* Sorts keys before writing to keep output order stable
* server.propertiesの書き戻し処理
*/
static bool WriteServerPropertiesFile(const char *filePath, const std::unordered_map<std::string, std::string> &properties)
{
if (filePath == NULL)
{
return false;
}
std::string text;
text += "# Minecraft server properties\n";
text += "# Auto-generated and normalized when missing\n";
std::map<std::string, std::string> sortedProperties(properties.begin(), properties.end());
for (std::map<std::string, std::string>::const_iterator it = sortedProperties.begin(); it != sortedProperties.end(); ++it)
{
text += it->first;
text += "=";
text += it->second;
text += "\n";
}
return FileUtils::WriteTextFileAtomic(filePath, text);
}
static bool ReadNormalizedBoolProperty(
std::unordered_map<std::string, std::string> *properties,
const char *key,
bool defaultValue,
bool *shouldWrite)
{
std::string raw = TrimAscii((*properties)[key]);
bool value = defaultValue;
if (!TryParseBool(raw, &value))
{
value = defaultValue;
}
std::string normalized = BoolToString(value);
if (raw != normalized)
{
(*properties)[key] = normalized;
if (shouldWrite != NULL)
{
*shouldWrite = true;
}
}
return value;
}
static int ReadNormalizedIntProperty(
std::unordered_map<std::string, std::string> *properties,
const char *key,
int defaultValue,
int minValue,
int maxValue,
bool *shouldWrite)
{
std::string raw = TrimAscii((*properties)[key]);
int value = defaultValue;
if (!TryParseInt(raw, &value))
{
value = defaultValue;
}
value = ClampInt(value, minValue, maxValue);
std::string normalized = IntToString(value);
if (raw != normalized)
{
(*properties)[key] = normalized;
if (shouldWrite != NULL)
{
*shouldWrite = true;
}
}
return value;
}
static std::string ReadNormalizedStringProperty(
std::unordered_map<std::string, std::string> *properties,
const char *key,
const std::string &defaultValue,
size_t maxLength,
bool *shouldWrite)
{
std::string value = TrimAscii((*properties)[key]);
if (value.empty())
{
value = defaultValue;
}
if (maxLength > 0 && value.length() > maxLength)
{
value.resize(maxLength);
}
if (value != (*properties)[key])
{
(*properties)[key] = value;
if (shouldWrite != NULL)
{
*shouldWrite = true;
}
}
return value;
}
static bool ReadNormalizedOptionalInt64Property(
std::unordered_map<std::string, std::string> *properties,
const char *key,
__int64 *outValue,
bool *shouldWrite)
{
std::string raw = TrimAscii((*properties)[key]);
if (raw.empty())
{
if ((*properties)[key] != "")
{
(*properties)[key] = "";
if (shouldWrite != NULL)
{
*shouldWrite = true;
}
}
return false;
}
__int64 parsed = 0;
if (!TryParseInt64(raw, &parsed))
{
(*properties)[key] = "";
if (shouldWrite != NULL)
{
*shouldWrite = true;
}
return false;
}
std::string normalized = Int64ToString(parsed);
if (raw != normalized)
{
(*properties)[key] = normalized;
if (shouldWrite != NULL)
{
*shouldWrite = true;
}
}
if (outValue != NULL)
{
*outValue = parsed;
}
return true;
}
static EServerLogLevel ReadNormalizedLogLevelProperty(
std::unordered_map<std::string, std::string> *properties,
const char *key,
EServerLogLevel defaultValue,
bool *shouldWrite)
{
std::string raw = TrimAscii((*properties)[key]);
EServerLogLevel value = defaultValue;
if (!TryParseServerLogLevel(raw.c_str(), &value))
{
value = defaultValue;
}
std::string normalized = LogLevelToPropertyValue(value);
if (raw != normalized)
{
(*properties)[key] = normalized;
if (shouldWrite != NULL)
{
*shouldWrite = true;
}
}
return value;
}
static std::string ReadNormalizedLevelTypeProperty(
std::unordered_map<std::string, std::string> *properties,
const char *key,
bool *outIsFlat,
bool *shouldWrite)
{
std::string raw = TrimAscii((*properties)[key]);
std::string lowered = ToLowerAscii(raw);
bool isFlat = false;
std::string normalized = "default";
if (lowered == "flat" || lowered == "superflat" || lowered == "1")
{
isFlat = true;
normalized = "flat";
}
else if (lowered == "default" || lowered == "normal" || lowered == "0")
{
isFlat = false;
normalized = "default";
}
if (raw != normalized)
{
(*properties)[key] = normalized;
if (shouldWrite != NULL)
{
*shouldWrite = true;
}
}
if (outIsFlat != NULL)
{
*outIsFlat = isFlat;
}
return normalized;
}
static std::string WorldSizeToPropertyValue(int worldSize)
{
switch (worldSize)
{
case e_worldSize_Small:
return "small";
case e_worldSize_Medium:
return "medium";
case e_worldSize_Large:
return "large";
case e_worldSize_Classic:
default:
return "classic";
}
}
static int WorldSizeToXzChunks(int worldSize)
{
switch (worldSize)
{
case e_worldSize_Small:
return LEVEL_WIDTH_SMALL;
case e_worldSize_Medium:
return LEVEL_WIDTH_MEDIUM;
case e_worldSize_Large:
return LEVEL_WIDTH_LARGE;
case e_worldSize_Classic:
default:
return LEVEL_WIDTH_CLASSIC;
}
}
static int WorldSizeToHellScale(int worldSize)
{
switch (worldSize)
{
case e_worldSize_Small:
return HELL_LEVEL_SCALE_SMALL;
case e_worldSize_Medium:
return HELL_LEVEL_SCALE_MEDIUM;
case e_worldSize_Large:
return HELL_LEVEL_SCALE_LARGE;
case e_worldSize_Classic:
default:
return HELL_LEVEL_SCALE_CLASSIC;
}
}
static bool TryParseWorldSize(const std::string &lowered, int *outWorldSize)
{
if (outWorldSize == NULL)
{
return false;
}
if (lowered == "classic" || lowered == "54" || lowered == "1")
{
*outWorldSize = e_worldSize_Classic;
return true;
}
if (lowered == "small" || lowered == "64" || lowered == "2")
{
*outWorldSize = e_worldSize_Small;
return true;
}
if (lowered == "medium" || lowered == "192" || lowered == "3")
{
*outWorldSize = e_worldSize_Medium;
return true;
}
if (lowered == "large" || lowered == "320" || lowered == "4")
{
*outWorldSize = e_worldSize_Large;
return true;
}
return false;
}
static int ReadNormalizedWorldSizeProperty(
std::unordered_map<std::string, std::string> *properties,
const char *key,
int defaultWorldSize,
int *outXzChunks,
int *outHellScale,
bool *shouldWrite)
{
std::string raw = TrimAscii((*properties)[key]);
std::string lowered = ToLowerAscii(raw);
int worldSize = defaultWorldSize;
if (!raw.empty())
{
int parsedWorldSize = defaultWorldSize;
if (TryParseWorldSize(lowered, &parsedWorldSize))
{
worldSize = parsedWorldSize;
}
}
std::string normalized = WorldSizeToPropertyValue(worldSize);
if (raw != normalized)
{
(*properties)[key] = normalized;
if (shouldWrite != NULL)
{
*shouldWrite = true;
}
}
if (outXzChunks != NULL)
{
*outXzChunks = WorldSizeToXzChunks(worldSize);
}
if (outHellScale != NULL)
{
*outHellScale = WorldSizeToHellScale(worldSize);
}
return worldSize;
}
/**
* **Load Effective Server Properties Config**
*
* Loads effective world settings, repairs missing or invalid values, and returns normalized config
* - Creates defaults when file is missing
* - Fills required keys when absent
* - Normalizes `level-id` to a safe format
* - Auto-saves when any fix is applied
* 実効設定の読み込みと補正処理
*/
ServerPropertiesConfig LoadServerPropertiesConfig()
{
ServerPropertiesConfig config;
std::unordered_map<std::string, std::string> defaults;
std::unordered_map<std::string, std::string> loaded;
ApplyDefaultServerProperties(&defaults);
int parsedCount = 0;
bool readSuccess = ReadServerPropertiesFile(kServerPropertiesPath, &loaded, &parsedCount);
std::unordered_map<std::string, std::string> merged = defaults;
bool shouldWrite = false;
if (!readSuccess)
{
LogWorldIO("server.properties not found or unreadable; creating defaults");
shouldWrite = true;
}
else
{
if (parsedCount == 0)
{
LogWorldIO("server.properties has no properties; applying defaults");
shouldWrite = true;
}
const size_t defaultCount = sizeof(kServerPropertyDefaults) / sizeof(kServerPropertyDefaults[0]);
for (size_t i = 0; i < defaultCount; ++i)
{
if (loaded.find(kServerPropertyDefaults[i].key) == loaded.end())
{
shouldWrite = true;
break;
}
}
}
for (std::unordered_map<std::string, std::string>::const_iterator it = loaded.begin(); it != loaded.end(); ++it)
{
// Merge loaded values over defaults and keep unknown keys whenever possible
merged[it->first] = it->second;
}
std::string worldName = TrimAscii(merged["level-name"]);
if (worldName.empty())
{
worldName = "world";
shouldWrite = true;
}
std::string worldSaveId = TrimAscii(merged["level-id"]);
if (worldSaveId.empty())
{
// If level-id is missing, derive it from level-name to lock save destination
worldSaveId = NormalizeSaveId(worldName);
shouldWrite = true;
}
else
{
// Normalize existing level-id as well to avoid future inconsistencies
std::string normalized = NormalizeSaveId(worldSaveId);
if (normalized != worldSaveId)
{
worldSaveId = normalized;
shouldWrite = true;
}
}
merged["level-name"] = worldName;
merged["level-id"] = worldSaveId;
config.worldName = Utf8ToWide(worldName.c_str());
config.worldSaveId = worldSaveId;
config.serverPort = ReadNormalizedIntProperty(&merged, "server-port", kDefaultServerPort, 1, 65535, &shouldWrite);
config.serverIp = ReadNormalizedStringProperty(&merged, "server-ip", "0.0.0.0", 255, &shouldWrite);
config.lanAdvertise = ReadNormalizedBoolProperty(&merged, kLanAdvertisePropertyKey, false, &shouldWrite);
config.whiteListEnabled = ReadNormalizedBoolProperty(&merged, "white-list", false, &shouldWrite);
config.serverName = ReadNormalizedStringProperty(&merged, "server-name", "DedicatedServer", 16, &shouldWrite);
config.maxPlayers = ReadNormalizedIntProperty(&merged, "max-players", kDefaultMaxPlayers, 1, kMaxDedicatedPlayers, &shouldWrite);
config.seed = 0;
config.hasSeed = ReadNormalizedOptionalInt64Property(&merged, "level-seed", &config.seed, &shouldWrite);
config.overrideSeed = 0;
config.hasOverrideSeed = false;
{
auto it = merged.find("override-seed");
if (it != merged.end() && !TrimAscii(it->second).empty())
{
__int64 parsed = 0;
if (TryParseInt64(TrimAscii(it->second), &parsed))
{
config.overrideSeed = parsed;
config.hasOverrideSeed = true;
}
}
}
config.logLevel = ReadNormalizedLogLevelProperty(&merged, "log-level", eServerLogLevel_Info, &shouldWrite);
config.autosaveIntervalSeconds = ReadNormalizedIntProperty(&merged, "autosave-interval", kDefaultAutosaveIntervalSeconds, 5, 3600, &shouldWrite);
config.difficulty = ReadNormalizedIntProperty(&merged, "difficulty", 1, 0, 3, &shouldWrite);
config.gameMode = ReadNormalizedIntProperty(&merged, "gamemode", 0, 0, 1, &shouldWrite);
config.worldSize = ReadNormalizedWorldSizeProperty(
&merged,
"world-size",
e_worldSize_Classic,
&config.worldSizeChunks,
&config.worldHellScale,
&shouldWrite);
config.levelType = ReadNormalizedLevelTypeProperty(&merged, "level-type", &config.levelTypeFlat, &shouldWrite);
config.spawnProtectionRadius = ReadNormalizedIntProperty(&merged, "spawn-protection", 0, 0, 256, &shouldWrite);
config.generateStructures = ReadNormalizedBoolProperty(&merged, "generate-structures", true, &shouldWrite);
config.bonusChest = ReadNormalizedBoolProperty(&merged, "bonus-chest", false, &shouldWrite);
config.pvp = ReadNormalizedBoolProperty(&merged, "pvp", true, &shouldWrite);
config.trustPlayers = ReadNormalizedBoolProperty(&merged, "trust-players", true, &shouldWrite);
config.fireSpreads = ReadNormalizedBoolProperty(&merged, "fire-spreads", true, &shouldWrite);
config.tnt = ReadNormalizedBoolProperty(&merged, "tnt", true, &shouldWrite);
config.spawnAnimals = ReadNormalizedBoolProperty(&merged, "spawn-animals", true, &shouldWrite);
config.spawnNpcs = ReadNormalizedBoolProperty(&merged, "spawn-npcs", true, &shouldWrite);
config.spawnMonsters = ReadNormalizedBoolProperty(&merged, "spawn-monsters", true, &shouldWrite);
config.allowFlight = ReadNormalizedBoolProperty(&merged, "allow-flight", true, &shouldWrite);
config.allowNether = ReadNormalizedBoolProperty(&merged, "allow-nether", true, &shouldWrite);
config.friendsOfFriends = ReadNormalizedBoolProperty(&merged, "friends-of-friends", false, &shouldWrite);
config.gamertags = ReadNormalizedBoolProperty(&merged, "gamertags", true, &shouldWrite);
config.bedrockFog = ReadNormalizedBoolProperty(&merged, "bedrock-fog", true, &shouldWrite);
config.hostCanFly = ReadNormalizedBoolProperty(&merged, "host-can-fly", true, &shouldWrite);
config.hostCanChangeHunger = ReadNormalizedBoolProperty(&merged, "host-can-change-hunger", true, &shouldWrite);
config.hostCanBeInvisible = ReadNormalizedBoolProperty(&merged, "host-can-be-invisible", true, &shouldWrite);
config.disableSaving = ReadNormalizedBoolProperty(&merged, "disable-saving", false, &shouldWrite);
config.mobGriefing = ReadNormalizedBoolProperty(&merged, "mob-griefing", true, &shouldWrite);
config.keepInventory = ReadNormalizedBoolProperty(&merged, "keep-inventory", false, &shouldWrite);
config.doMobSpawning = ReadNormalizedBoolProperty(&merged, "do-mob-spawning", true, &shouldWrite);
config.doMobLoot = ReadNormalizedBoolProperty(&merged, "do-mob-loot", true, &shouldWrite);
config.doTileDrops = ReadNormalizedBoolProperty(&merged, "do-tile-drops", true, &shouldWrite);
config.naturalRegeneration = ReadNormalizedBoolProperty(&merged, "natural-regeneration", true, &shouldWrite);
config.doDaylightCycle = ReadNormalizedBoolProperty(&merged, "do-daylight-cycle", true, &shouldWrite);
config.hardcore = ReadNormalizedBoolProperty(&merged, "hardcore", false, &shouldWrite);
config.hardcoreBanIp = ReadNormalizedBoolProperty(&merged, "hardcore-ban-ip", false, &shouldWrite);
config.maxMonsters = ReadNormalizedIntProperty(&merged, "max-monsters", 50, 0, 1000, &shouldWrite);
config.maxAnimals = ReadNormalizedIntProperty(&merged, "max-animals", 50, 0, 1000, &shouldWrite);
config.maxAmbient = ReadNormalizedIntProperty(&merged, "max-ambient", 20, 0, 1000, &shouldWrite);
config.maxWaterAnimals = ReadNormalizedIntProperty(&merged, "max-water-animals", 5, 0, 1000, &shouldWrite);
config.maxWolves = ReadNormalizedIntProperty(&merged, "max-wolves", 8, 0, 1000, &shouldWrite);
config.maxChickens = ReadNormalizedIntProperty(&merged, "max-chickens", 8, 0, 1000, &shouldWrite);
config.maxMushroomCows = ReadNormalizedIntProperty(&merged, "max-mushroom-cows", 2, 0, 1000, &shouldWrite);
config.maxBuildHeight = ReadNormalizedIntProperty(&merged, "max-build-height", 256, 64, 256, &shouldWrite);
config.motd = ReadNormalizedStringProperty(&merged, "motd", "A Minecraft Server", 255, &shouldWrite);
config.hidePlayerListPreLogin = ReadNormalizedBoolProperty(&merged, "hide-player-list-prelogin", true, &shouldWrite);
config.rateLimitConnectionsPerWindow = ReadNormalizedIntProperty(&merged, "rate-limit-connections-per-window", 5, 1, 100, &shouldWrite);
config.rateLimitWindowSeconds = ReadNormalizedIntProperty(&merged, "rate-limit-window-seconds", 30, 5, 300, &shouldWrite);
config.maxPendingConnections = ReadNormalizedIntProperty(&merged, "max-pending-connections", 10, 1, 50, &shouldWrite);
config.proxyProtocol = ReadNormalizedBoolProperty(&merged, "proxy-protocol", false, &shouldWrite);
if (shouldWrite)
{
if (WriteServerPropertiesFile(kServerPropertiesPath, merged))
{
LogWorldIO("wrote server.properties");
}
else
{
LogWorldIO("failed to write server.properties");
}
}
return config;
}
/**
* **Save World Identity While Preserving Other Keys**
*
* Saves world identity fields while preserving as many other settings as possible
* - Reads existing file and merges including unknown keys
* - Updates `level-name`, `level-id`, and `white-list` before writing back
* ワールド識別情報の保存処理
*/
bool SaveServerPropertiesConfig(const ServerPropertiesConfig &config)
{
std::unordered_map<std::string, std::string> merged;
ApplyDefaultServerProperties(&merged);
std::unordered_map<std::string, std::string> loaded;
int parsedCount = 0;
if (ReadServerPropertiesFile(kServerPropertiesPath, &loaded, &parsedCount))
{
for (std::unordered_map<std::string, std::string>::const_iterator it = loaded.begin(); it != loaded.end(); ++it)
{
// Keep existing content so keys untouched by caller are not dropped
merged[it->first] = it->second;
}
}
std::string worldName = TrimAscii(WideToUtf8(config.worldName));
if (worldName.empty())
{
worldName = "world"; // Default world name
}
std::string worldSaveId = TrimAscii(config.worldSaveId);
if (worldSaveId.empty())
{
worldSaveId = NormalizeSaveId(worldName);
}
else
{
worldSaveId = NormalizeSaveId(worldSaveId);
}
merged["level-name"] = worldName;
merged["level-id"] = worldSaveId;
merged["white-list"] = BoolToString(config.whiteListEnabled);
return WriteServerPropertiesFile(kServerPropertiesPath, merged);
}
}