void Commands::reloadInfo(Player* player, const std::string& cmd, const std::string& param)
{
std::string tmpParam = asLowerCaseString(param);
if (tmpParam == "action" || tmpParam == "actions") {
g_actions->reload();
player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded actions.");
} else if (tmpParam == "config" || tmpParam == "configuration") {
g_config.reload();
player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded config.");
} else if (tmpParam == "command" || tmpParam == "commands") {
reload();
player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded commands.");
} else if (tmpParam == "creaturescript" || tmpParam == "creaturescripts") {
g_creatureEvents->reload();
player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded creature scripts.");
} else if (tmpParam == "monster" || tmpParam == "monsters") {
g_monsters.reload();
player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded monsters.");
} else if (tmpParam == "move" || tmpParam == "movement" || tmpParam == "movements"
|| tmpParam == "moveevents" || tmpParam == "moveevent") {
g_moveEvents->reload();
player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded movements.");
} else if (tmpParam == "npc" || tmpParam == "npcs") {
g_npcs.reload();
player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded npcs.");
} else if (tmpParam == "raid" || tmpParam == "raids") {
Raids::getInstance()->reload();
Raids::getInstance()->startup();
player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded raids.");
} else if (tmpParam == "spell" || tmpParam == "spells") {
g_spells->reload();
g_monsters.reload();
player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded spells.");
} else if (tmpParam == "talk" || tmpParam == "talkaction" || tmpParam == "talkactions") {
g_talkActions->reload();
player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded talk actions.");
} else if (tmpParam == "items") {
Item::items.reload();
player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded items.");
} else if (tmpParam == "weapon" || tmpParam == "weapons") {
g_weapons->reload();
g_weapons->loadDefaults();
player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded weapons.");
} else if (tmpParam == "quest" || tmpParam == "quests") {
Quests::getInstance()->reload();
player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded quests.");
} else if (tmpParam == "mount" || tmpParam == "mounts") {
Mounts::getInstance()->reload();
player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded mounts.");
} else if (tmpParam == "globalevents" || tmpParam == "globalevent") {
g_globalEvents->reload();
player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded globalevents.");
} else {
player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reload type not found.");
}
}
bool ScriptManager::loadFromXml(const std::string& file, bool& enabled)
{
enabled = false;
xmlDocPtr doc = xmlParseFile(getFilePath(FILE_TYPE_MOD, file).c_str());
if(!doc)
{
std::clog << "[Error - ScriptManager::loadFromXml] Cannot load mod " << file << std::endl;
std::clog << getLastXMLError() << std::endl;
return false;
}
int32_t intValue;
std::string strValue;
xmlNodePtr p, root = xmlDocGetRootElement(doc);
if(xmlStrcmp(root->name,(const xmlChar*)"mod"))
{
std::clog << "[Error - ScriptManager::loadFromXml] Malformed mod " << file << std::endl;
std::clog << getLastXMLError() << std::endl;
xmlFreeDoc(doc);
return false;
}
if(!readXMLString(root, "name", strValue))
strValue = file;
ModBlock mod;
mod.enabled = true;
mod.name = strValue;
if(readXMLString(root, "enabled", strValue) && !booleanString(strValue))
mod.enabled = false;
mod.file = file;
if(readXMLString(root, "author", strValue))
mod.author = strValue;
if(readXMLString(root, "version", strValue))
mod.version = strValue;
if(readXMLString(root, "contact", strValue))
mod.contact = strValue;
bool supported = true;
for(p = root->children; p; p = p->next)
{
if(xmlStrcmp(p->name, (const xmlChar*)"server"))
continue;
supported = false;
for(xmlNodePtr versionNode = p->children; versionNode; versionNode = versionNode->next)
{
std::string id = SOFTWARE_VERSION;
if(readXMLString(versionNode, "id", strValue))
id = asLowerCaseString(strValue);
IntegerVec protocol;
protocol.push_back(CLIENT_VERSION_MIN);
if(readXMLString(versionNode, "protocol", strValue))
protocol = vectorAtoi(explodeString(strValue, "-"));
int16_t database = VERSION_DATABASE;
if(readXMLInteger(versionNode, "database", intValue))
database = intValue;
if(id == asLowerCaseString(SOFTWARE_VERSION) && database >= VERSION_DATABASE
&& protocol[0] >= CLIENT_VERSION_MIN && (protocol.size() < 2 || protocol[1] <= CLIENT_VERSION_MAX))
{
supported = true;
break;
}
}
}
if(!supported)
{
std::clog << "[Warning - ScriptManager::loadFromXml] Your server is not supported by mod " << file << std::endl;
xmlFreeDoc(doc);
return false;
}
if(mod.enabled)
{
std::string scriptsPath = getFilePath(FILE_TYPE_MOD, "scripts/");
for(p = root->children; p; p = p->next)
{
if(!xmlStrcmp(p->name, (const xmlChar*)"quest"))
Quests::getInstance()->parseQuestNode(p, modsLoaded);
else if(!xmlStrcmp(p->name, (const xmlChar*)"outfit"))
Outfits::getInstance()->parseOutfitNode(p);
else if(!xmlStrcmp(p->name, (const xmlChar*)"vocation"))
Vocations::getInstance()->parseVocationNode(p); //duplicates checking is dangerous, shouldn't be performed until we find some good solution
else if(!xmlStrcmp(p->name, (const xmlChar*)"group"))
Groups::getInstance()->parseGroupNode(p); //duplicates checking is dangerous, shouldn't be performed until we find some good solution
else if(!xmlStrcmp(p->name, (const xmlChar*)"raid"))
Raids::getInstance()->parseRaidNode(p, modsLoaded, FILE_TYPE_MOD); //TODO: support mods path
else if(!xmlStrcmp(p->name, (const xmlChar*)"spawn"))
Spawns::getInstance()->parseSpawnNode(p, modsLoaded);
else if(!xmlStrcmp(p->name, (const xmlChar*)"channel"))
g_chat.parseChannelNode(p); //TODO: duplicates- channel destructor needs to send closeChannel to users!
else if(!xmlStrcmp(p->name, (const xmlChar*)"npc"))
g_npcs.parseNpcNode(p, FILE_TYPE_MOD);
else if(!xmlStrcmp(p->name, (const xmlChar*)"monster"))
{
std::string path, name;
if((readXMLString(p, "file", path) || readXMLString(p, "path", path)) && readXMLString(p, "name", name))
g_monsters.loadMonster(getFilePath(FILE_TYPE_MOD, "monster/" + path), name, true);
}
else if(!xmlStrcmp(p->name, (const xmlChar*)"item"))
{
if(readXMLInteger(p, "id", intValue))
Item::items.parseItemNode(p, intValue);
}
if(!xmlStrcmp(p->name, (const xmlChar*)"description") || !xmlStrcmp(p->name, (const xmlChar*)"info"))
{
if(parseXMLContentString(p->children, strValue))
{
replaceString(strValue, "\t", "");
mod.description = strValue;
}
}
else if(!xmlStrcmp(p->name, (const xmlChar*)"lib") || !xmlStrcmp(p->name, (const xmlChar*)"config"))
{
if(!readXMLString(p, "name", strValue))
{
if(!xmlStrcmp(p->name, (const xmlChar*)"lib"))
strValue = mod.name + "-lib";
else if(!xmlStrcmp(p->name, (const xmlChar*)"config"))
strValue = mod.name + "-config";
}
else
toLowerCaseString(strValue);
std::string strLib;
if(parseXMLContentString(p->children, strLib))
{
LibMap::iterator it = libMap.find(strValue);
if(it == libMap.end())
{
LibBlock lb;
lb.first = file;
lb.second = strLib;
libMap[strValue] = lb;
}
else
std::clog << "[Warning - ScriptManager::loadFromXml] Duplicated lib in mod "
<< strValue << ", previously declared in " << it->second.first << std::endl;
}
}
else if(!g_actions->parseEventNode(p, scriptsPath, modsLoaded))
{
if(!g_talkActions->parseEventNode(p, scriptsPath, modsLoaded))
{
if(!g_moveEvents->parseEventNode(p, scriptsPath, modsLoaded))
{
if(!g_creatureEvents->parseEventNode(p, scriptsPath, modsLoaded))
{
if(!g_globalEvents->parseEventNode(p, scriptsPath, modsLoaded))
{
if(!g_spells->parseEventNode(p, scriptsPath, modsLoaded))
g_weapons->parseEventNode(p, scriptsPath, modsLoaded);
}
}
}
}
}
}
}
enabled = mod.enabled;
modMap[mod.name] = mod;
xmlFreeDoc(doc);
return true;
}
bool Commands::reloadInfo(Creature* creature, const std::string& cmd, const std::string& param)
{
Player* player = creature->getPlayer();
if(param == "actions" || param == "action"){
g_actions->reload();
if(player) player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded actions.");
}
else if(param == "commands" || param == "command"){
this->reload();
if(player) player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded commands.");
}
else if(param == "monsters" || param == "monster"){
g_monsters.reload();
if(player) player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded monsters.");
}
else if(param == "npc"){
g_npcs.reload();
if(player) player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded npcs.");
}
else if(param == "config"){
g_config.reload();
if(player) player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded config.");
}
else if(param == "talk" || param == "talkactions" || param == "talk actions" || param == "ta"){
g_talkactions->reload();
if(player) player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded talk actions.");
}
else if(param == "move" || param == "movement" || param == "movement actions"){
g_moveEvents->reload();
if(player) player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded movement actions.");
}
else if(param == "spells" || param == "spell"){
g_spells->reload();
g_monsters.reload();
if(player) player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded spells and monsters.");
}
else if(param == "raids" || param == "raid"){
Raids::getInstance()->reload();
Raids::getInstance()->startup();
if(player) player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded raids.");
}
/*
else if(param == "weapons"){
g_weapons->reload();
}
else if(param == "items"){
Item::items.reload();
}
*/
else if(param == "creaturescripts" || param == "creature scripts" || param == "cs"){
g_creatureEvents->reload();
if(player) player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded creature scripts.");
}
else if(param == "globalevent" || param == "global event" || param == "ge"){
g_globalEvents->reload();
if(player) player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Reloaded global events.");
}
else{
if(player) player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Option not found.");
}
return true;
}
void mainLoader(int argc, char* argv[], ServiceManager* services)
{
//dispatcher thread
g_game.setGameState(GAME_STATE_STARTUP);
srand((unsigned int)OTSYS_TIME());
#ifdef _WIN32
SetConsoleTitle(STATUS_SERVER_NAME);
#endif
std::cout << STATUS_SERVER_NAME << " - Version " << STATUS_SERVER_VERSION << std::endl;
std::cout << "Compilied on " << __DATE__ << ' ' << __TIME__ << " for arch ";
#if defined(__amd64__) || defined(_M_X64)
std::cout << "x64" << std::endl;
#elif defined(__i386__) || defined(_M_IX86) || defined(_X86_)
std::cout << "x86" << std::endl;
#elif defined(__arm__)
std::cout << "ARM" << std::endl;
#elif defined(__mips__)
std::cout << "MIPS" << std::endl;
#else
std::cout << "unk" << std::endl;
#endif
std::cout << std::endl;
std::cout << "A server developed by " << STATUS_SERVER_DEVELOPERS << std::endl;
std::cout << "Visit our forum for updates, support, and resources: http://otland.net/." << std::endl;
std::cout << std::endl;
// read global config
std::cout << ">> Loading config" << std::endl;
if (!g_config.load()) {
startupErrorMessage("Unable to load config.lua!");
return;
}
#ifdef _WIN32
std::string defaultPriority = asLowerCaseString(g_config.getString(ConfigManager::DEFAULT_PRIORITY));
if (defaultPriority == "realtime") {
SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
} else if (defaultPriority == "high") {
SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
} else if (defaultPriority == "higher") {
SetPriorityClass(GetCurrentProcess(), ABOVE_NORMAL_PRIORITY_CLASS);
}
std::ostringstream mutexName;
mutexName << "forgottenserver_" << g_config.getNumber(ConfigManager::LOGIN_PORT);
CreateMutex(nullptr, FALSE, mutexName.str().c_str());
if (GetLastError() == ERROR_ALREADY_EXISTS) {
startupErrorMessage("Another instance of The Forgotten Server is already running with the same login port, please shut it down first or change ports for this one.");
return;
}
#endif
#ifdef __PROTOCOL_77__
//set RSA key
const char* p("14299623962416399520070177382898895550795403345466153217470516082934737582776038882967213386204600674145392845853859217990626450972452084065728686565928113");
const char* q("7630979195970404721891201847792002125535401292779123937207447574596692788513647179235335529307251350570728407373705564708871762033017096809910315212884101");
g_RSA.setKey(p, q);
#endif
std::cout << ">> Establishing database connection..." << std::flush;
Database* db = Database::getInstance();
if (!db->connect()) {
startupErrorMessage("Failed to connect to database.");
return;
}
std::cout << " MySQL " << db->getClientVersion() << std::endl;
// run database manager
std::cout << ">> Running database manager" << std::endl;
DatabaseManager* dbManager = DatabaseManager::getInstance();
if (!dbManager->isDatabaseSetup()) {
startupErrorMessage("The database you have specified in config.lua is empty, please import the schema to the database.");
return;
}
dbManager->updateDatabase();
dbManager->checkTriggers();
dbManager->checkEncryption();
if (g_config.getBoolean(ConfigManager::OPTIMIZE_DATABASE) && !dbManager->optimizeTables()) {
std::cout << "> No tables were optimized." << std::endl;
}
//load vocations
std::cout << ">> Loading vocations" << std::endl;
if (!g_vocations.loadFromXml()) {
startupErrorMessage("Unable to load vocations!");
return;
}
//load commands
std::cout << ">> Loading commands" << std::endl;
if (!g_commands.loadFromXml()) {
startupErrorMessage("Unable to load commands!");
return;
}
// load item data
std::cout << ">> Loading items" << std::endl;
if (Item::items.loadFromOtb("data/items/" + ITEMS_PATH + "/items.otb")) {
startupErrorMessage("Unable to load items (OTB)!");
return;
}
if (!Item::items.loadFromXml()) {
startupErrorMessage("Unable to load items (XML)!");
return;
}
std::cout << ">> Loading script systems" << std::endl;
if (!ScriptingManager::getInstance()->loadScriptSystems()) {
startupErrorMessage("Failed to load script systems");
return;
}
std::cout << ">> Loading monsters" << std::endl;
if (!g_monsters.loadFromXml()) {
startupErrorMessage("Unable to load monsters!");
return;
}
std::cout << ">> Loading experience stages" << std::endl;
if (!g_game.loadExperienceStages()) {
startupErrorMessage("Unable to load experience stages!");
return;
}
std::string passwordType = asLowerCaseString(g_config.getString(ConfigManager::PASSWORDTYPE));
if (passwordType == "sha1") {
g_config.setNumber(ConfigManager::PASSWORD_TYPE, PASSWORD_TYPE_SHA1);
std::cout << ">> Using SHA1 passwords" << std::endl;
} else {
g_config.setNumber(ConfigManager::PASSWORD_TYPE, PASSWORD_TYPE_PLAIN);
std::cout << ">> Using plaintext passwords" << std::endl;
}
std::cout << ">> Checking world type... " << std::flush;
std::string worldType = asLowerCaseString(g_config.getString(ConfigManager::WORLD_TYPE));
if (worldType == "pvp") {
g_game.setWorldType(WORLD_TYPE_PVP);
} else if (worldType == "no-pvp") {
g_game.setWorldType(WORLD_TYPE_NO_PVP);
} else if (worldType == "pvp-enforced") {
g_game.setWorldType(WORLD_TYPE_PVP_ENFORCED);
} else {
std::cout << std::endl;
std::ostringstream ss;
ss << "> ERROR: Unknown world type: " << g_config.getString(ConfigManager::WORLD_TYPE) << ", valid world types are: pvp, no-pvp and pvp-enforced.";
startupErrorMessage(ss.str());
return;
}
std::cout << asUpperCaseString(worldType) << std::endl;
std::cout << ">> Loading map" << std::endl;
if (!g_game.loadMap(g_config.getString(ConfigManager::MAP_NAME))) {
startupErrorMessage("Failed to load map");
return;
}
std::cout << ">> Initializing gamestate" << std::endl;
g_game.setGameState(GAME_STATE_INIT);
// Tibia protocols
services->add<ProtocolGame>(g_config.getNumber(ConfigManager::GAME_PORT));
services->add<ProtocolLogin>(g_config.getNumber(ConfigManager::LOGIN_PORT));
// OT protocols
services->add<ProtocolStatus>(g_config.getNumber(ConfigManager::STATUS_PORT));
int32_t autoSaveEachMinutes = g_config.getNumber(ConfigManager::AUTO_SAVE_EACH_MINUTES);
if (autoSaveEachMinutes > 0) {
g_scheduler.addEvent(createSchedulerTask(autoSaveEachMinutes * 1000 * 60, boost::bind(&Game::autoSave, &g_game)));
}
if (g_config.getBoolean(ConfigManager::SERVERSAVE_ENABLED)) {
int32_t serverSaveHour = g_config.getNumber(ConfigManager::SERVERSAVE_H);
if (serverSaveHour >= 0 && serverSaveHour <= 24) {
time_t timeNow = time(nullptr);
tm* timeinfo = localtime(&timeNow);
if (serverSaveHour == 0) {
serverSaveHour = 23;
} else {
serverSaveHour--;
}
timeinfo->tm_hour = serverSaveHour;
timeinfo->tm_min = 55;
timeinfo->tm_sec = 0;
double difference = difftime(mktime(timeinfo), timeNow);
if (difference < 0) {
difference += 86400;
}
g_scheduler.addEvent(createSchedulerTask(difference * 1000, boost::bind(&Game::prepareServerSave, &g_game)));
}
}
Houses::getInstance().payHouses();
IOLoginData::getInstance()->updateHouseOwners();
g_npcs.reload();
std::cout << ">> Loaded all modules, server starting up..." << std::endl;
std::pair<uint32_t, uint32_t> IpNetMask;
IpNetMask.first = inet_addr("127.0.0.1");
IpNetMask.second = 0xFFFFFFFF;
serverIPs.push_back(IpNetMask);
char szHostName[128];
if (gethostname(szHostName, 128) == 0) {
hostent* he = gethostbyname(szHostName);
if (he) {
unsigned char** addr = (unsigned char**)he->h_addr_list;
while (addr[0] != nullptr) {
IpNetMask.first = *(uint32_t*)(*addr);
IpNetMask.second = 0xFFFFFFFF;
serverIPs.push_back(IpNetMask);
addr++;
}
}
}
std::string ip = g_config.getString(ConfigManager::IP);
uint32_t resolvedIp = inet_addr(ip.c_str());
if (resolvedIp == INADDR_NONE) {
struct hostent* he = gethostbyname(ip.c_str());
if (!he) {
std::ostringstream ss;
ss << "ERROR: Cannot resolve " << ip << "!" << std::endl;
startupErrorMessage(ss.str());
return;
}
resolvedIp = *(uint32_t*)he->h_addr;
}
IpNetMask.first = resolvedIp;
IpNetMask.second = 0;
serverIPs.push_back(IpNetMask);
#if !defined(WIN32) && !defined(__ROOT_PERMISSION__)
if (getuid() == 0 || geteuid() == 0) {
std::cout << "> WARNING: " << STATUS_SERVER_NAME << " has been executed as root user, it is recommended to execute is as a normal user." << std::endl;
}
#endif
g_game.start(services);
g_game.setGameState(GAME_STATE_NORMAL);
g_loaderSignal.notify_all();
}