bool MoveEvent::configureEvent(xmlNodePtr p)
{
std::string str;
int intValue;
if(readXMLString(p, "event", str)){
if(asLowerCaseString(str) == "stepin"){
m_eventType = MOVE_EVENT_STEP_IN;
}
else if(asLowerCaseString(str) == "stepout"){
m_eventType = MOVE_EVENT_STEP_OUT;
}
else if(asLowerCaseString(str) == "equip"){
m_eventType = MOVE_EVENT_EQUIP;
}
else if(asLowerCaseString(str) == "deequip"){
m_eventType = MOVE_EVENT_DEEQUIP;
}
else if(asLowerCaseString(str) == "additem"){
m_eventType = MOVE_EVENT_ADD_ITEM;
}
else if(asLowerCaseString(str) == "removeitem"){
m_eventType = MOVE_EVENT_REMOVE_ITEM;
}
else{
std::cout << "Error: [MoveEvent::configureMoveEvent] No valid event name " << str << std::endl;
return false;
}
if(m_eventType == MOVE_EVENT_EQUIP || m_eventType == MOVE_EVENT_DEEQUIP){
if(readXMLString(p, "slot", str)){
if(asLowerCaseString(str) == "head"){
slot = SLOT_HEAD;
}
else if(asLowerCaseString(str) == "necklace"){
slot = SLOT_NECKLACE;
}
else if(asLowerCaseString(str) == "backpack"){
slot = SLOT_BACKPACK;
}
else if(asLowerCaseString(str) == "armor"){
slot = SLOT_ARMOR;
}
else if(asLowerCaseString(str) == "right-hand"){
slot = SLOT_RIGHT;
}
else if(asLowerCaseString(str) == "left-hand"){
slot = SLOT_LEFT;
}
else if(asLowerCaseString(str) == "legs"){
slot = SLOT_LEGS;
}
else if(asLowerCaseString(str) == "feet"){
slot = SLOT_FEET;
}
else if(asLowerCaseString(str) == "ring"){
slot = SLOT_RING;
}
else if(asLowerCaseString(str) == "ammo"){
slot = SLOT_AMMO;
}
else{
std::cout << "Warning: [MoveEvent::configureMoveEvent] " << "Unknown slot type " << str << std::endl;
}
}
wieldInfo = 0;
if(readXMLInteger(p, "lvl", intValue) || readXMLInteger(p, "level", intValue)){
reqLevel = intValue;
if(reqLevel > 0){
wieldInfo |= WIELDINFO_LEVEL;
}
}
if(readXMLInteger(p, "maglv", intValue) || readXMLInteger(p, "maglevel", intValue)){
reqMagLevel = intValue;
if(reqMagLevel > 0){
wieldInfo |= WIELDINFO_MAGLV;
}
}
if(readXMLInteger(p, "prem", intValue) || readXMLInteger(p, "premium", intValue)){
premium = (intValue != 0);
if(premium){
wieldInfo |= WIELDINFO_PREMIUM;
}
}
//Gather vocation information
typedef std::list<std::string> STRING_LIST;
STRING_LIST vocStringList;
xmlNodePtr vocationNode = p->children;
while(vocationNode){
if(xmlStrcmp(vocationNode->name,(const xmlChar*)"vocation") == 0){
if(readXMLString(vocationNode, "name", str)){
int32_t vocationId = g_vocations.getVocationId(str);
if(vocationId != -1){
vocEquipMap[vocationId] = true;
intValue = 1;
readXMLInteger(vocationNode, "showInDescription", intValue);
if(intValue != 0){
toLowerCaseString(str);
vocStringList.push_back(str);
}
}
}
}
vocationNode = vocationNode->next;
}
if(!vocStringList.empty()){
for(STRING_LIST::iterator it = vocStringList.begin(); it != vocStringList.end(); ++it){
if(*it != vocStringList.front()){
if(*it != vocStringList.back()){
vocationString += ", ";
}
else{
vocationString += " and ";
}
}
vocationString += *it;
vocationString += "s";
}
wieldInfo |= WIELDINFO_VOCREQ;
}
}
}
else{
std::cout << "Error: [MoveEvent::configureMoveEvent] No event found." << std::endl;
return false;
}
return true;
}
bool Weapon::configureEvent(const pugi::xml_node& node)
{
pugi::xml_attribute attr;
if (!(attr = node.attribute("id"))) {
std::cout << "[Error - Weapon::configureEvent] Weapon without id." << std::endl;
return false;
}
id = pugi::cast<uint16_t>(attr.value());
if ((attr = node.attribute("level"))) {
level = pugi::cast<uint32_t>(attr.value());
}
if ((attr = node.attribute("maglv")) || (attr = node.attribute("maglevel"))) {
magLevel = pugi::cast<uint32_t>(attr.value());
}
if ((attr = node.attribute("mana"))) {
mana = pugi::cast<uint32_t>(attr.value());
}
if ((attr = node.attribute("manapercent"))) {
manaPercent = pugi::cast<uint32_t>(attr.value());
}
if ((attr = node.attribute("soul"))) {
soul = pugi::cast<uint32_t>(attr.value());
}
if ((attr = node.attribute("prem"))) {
premium = attr.as_bool();
}
if ((attr = node.attribute("breakchance"))) {
breakChance = std::min<uint8_t>(100, pugi::cast<uint16_t>(attr.value()));
}
if ((attr = node.attribute("action"))) {
action = getWeaponAction(attr.as_string());
if (action == WEAPONACTION_NONE) {
std::cout << "[Warning - Weapon::configureEvent] Unknown action " << attr.as_string() << std::endl;
}
}
if ((attr = node.attribute("enabled"))) {
enabled = attr.as_bool();
}
if ((attr = node.attribute("unproperly"))) {
wieldUnproperly = attr.as_bool();
}
std::list<std::string> vocStringList;
for (pugi::xml_node vocationNode = node.first_child(); vocationNode; vocationNode = vocationNode.next_sibling()) {
if (!(attr = vocationNode.attribute("name"))) {
continue;
}
int32_t vocationId = g_vocations.getVocationId(attr.as_string());
if (vocationId != -1) {
vocWeaponMap[vocationId] = true;
int32_t promotedVocation = g_vocations.getPromotedVocation(vocationId);
if (promotedVocation != 0) {
vocWeaponMap[promotedVocation] = true;
}
if (vocationNode.attribute("showInDescription").as_bool(true)) {
vocStringList.push_back(asLowerCaseString(attr.as_string()));
}
}
}
range = Item::items[id].shootRange;
std::string vocationString;
for (const std::string& str : vocStringList) {
if (!vocationString.empty()) {
if (str != vocStringList.back()) {
vocationString.push_back(',');
vocationString.push_back(' ');
} else {
vocationString += " and ";
}
}
vocationString += str;
vocationString.push_back('s');
}
uint32_t wieldInfo = 0;
if (getReqLevel() > 0) {
wieldInfo |= WIELDINFO_LEVEL;
}
if (getReqMagLv() > 0) {
wieldInfo |= WIELDINFO_MAGLV;
}
if (!vocationString.empty()) {
wieldInfo |= WIELDINFO_VOCREQ;
}
if (isPremium()) {
wieldInfo |= WIELDINFO_PREMIUM;
}
if (wieldInfo != 0) {
ItemType& it = Item::items.getItemType(id);
it.wieldInfo = wieldInfo;
it.vocationString = vocationString;
it.minReqLevel = getReqLevel();
it.minReqMagicLevel = getReqMagLv();
}
configureWeapon(Item::items[id]);
return true;
}
bool Spell::configureSpell(const pugi::xml_node& node)
{
pugi::xml_attribute nameAttribute = node.attribute("name");
if (!nameAttribute) {
std::cout << "[Error - Spell::configureSpell] Spell without name" << std::endl;
return false;
}
name = nameAttribute.as_string();
static const char* reservedList[] = {
"melee",
"physical",
"poison",
"fire",
"energy",
"drown",
"lifedrain",
"manadrain",
"healing",
"speed",
"outfit",
"invisible",
"drunk",
"firefield",
"poisonfield",
"energyfield",
"firecondition",
"poisoncondition",
"energycondition",
"drowncondition",
"freezecondition",
"cursecondition",
"dazzlecondition"
};
//static size_t size = sizeof(reservedList) / sizeof(const char*);
//for (size_t i = 0; i < size; ++i) {
for (const char* reserved : reservedList) {
if (strcasecmp(reserved, name.c_str()) == 0) {
std::cout << "[Error - Spell::configureSpell] Spell is using a reserved name: " << reserved << std::endl;
return false;
}
}
pugi::xml_attribute attr;
if ((attr = node.attribute("spellid"))) {
spellId = pugi::cast<uint16_t>(attr.value());
}
if ((attr = node.attribute("group"))) {
std::string tmpStr = asLowerCaseString(attr.as_string());
if (tmpStr == "none" || tmpStr == "0") {
group = SPELLGROUP_NONE;
} else if (tmpStr == "attack" || tmpStr == "1") {
group = SPELLGROUP_ATTACK;
} else if (tmpStr == "healing" || tmpStr == "2") {
group = SPELLGROUP_HEALING;
} else if (tmpStr == "support" || tmpStr == "3") {
group = SPELLGROUP_SUPPORT;
} else if (tmpStr == "special" || tmpStr == "4") {
group = SPELLGROUP_SPECIAL;
} else {
std::cout << "[Warning - Spell::configureSpell] Unknown group: " << attr.as_string() << std::endl;
}
}
if ((attr = node.attribute("groupcooldown"))) {
groupCooldown = pugi::cast<uint32_t>(attr.value());
}
if ((attr = node.attribute("secondarygroup"))) {
std::string tmpStr = asLowerCaseString(attr.as_string());
if (tmpStr == "none" || tmpStr == "0") {
secondaryGroup = SPELLGROUP_NONE;
} else if (tmpStr == "attack" || tmpStr == "1") {
secondaryGroup = SPELLGROUP_ATTACK;
} else if (tmpStr == "healing" || tmpStr == "2") {
secondaryGroup = SPELLGROUP_HEALING;
} else if (tmpStr == "support" || tmpStr == "3") {
secondaryGroup = SPELLGROUP_SUPPORT;
} else if (tmpStr == "special" || tmpStr == "4") {
secondaryGroup = SPELLGROUP_SPECIAL;
} else {
std::cout << "[Warning - Spell::configureSpell] Unknown secondarygroup: " << attr.as_string() << std::endl;
}
}
if ((attr = node.attribute("secondarygroupcooldown"))) {
secondaryGroupCooldown = pugi::cast<uint32_t>(attr.value());
}
if ((attr = node.attribute("level")) || (attr = node.attribute("lvl"))) {
level = pugi::cast<uint32_t>(attr.value());
}
if ((attr = node.attribute("magiclevel")) || (attr = node.attribute("maglv"))) {
magLevel = pugi::cast<uint32_t>(attr.value());
}
if ((attr = node.attribute("mana"))) {
mana = pugi::cast<uint32_t>(attr.value());
}
if ((attr = node.attribute("manapercent"))) {
manaPercent = pugi::cast<uint32_t>(attr.value());
}
if ((attr = node.attribute("soul"))) {
soul = pugi::cast<uint32_t>(attr.value());
}
if ((attr = node.attribute("range"))) {
range = pugi::cast<int32_t>(attr.value());
}
if ((attr = node.attribute("cooldown")) || (attr = node.attribute("exhaustion"))) {
cooldown = pugi::cast<uint32_t>(attr.value());
}
if ((attr = node.attribute("premium")) || (attr = node.attribute("prem"))) {
premium = attr.as_bool();
}
if ((attr = node.attribute("enabled"))) {
enabled = attr.as_bool();
}
if ((attr = node.attribute("needtarget"))) {
needTarget = attr.as_bool();
}
if ((attr = node.attribute("needweapon"))) {
needWeapon = attr.as_bool();
}
if ((attr = node.attribute("selftarget"))) {
selfTarget = attr.as_bool();
}
if ((attr = node.attribute("needlearn"))) {
learnable = attr.as_bool();
}
if ((attr = node.attribute("blocking"))) {
blockingSolid = attr.as_bool();
blockingCreature = blockingSolid;
}
if ((attr = node.attribute("blocktype"))) {
std::string tmpStrValue = asLowerCaseString(attr.as_string());
if (tmpStrValue == "all") {
blockingSolid = true;
blockingCreature = true;
} else if (tmpStrValue == "solid") {
blockingSolid = true;
} else if (tmpStrValue == "creature") {
blockingCreature = true;
} else {
std::cout << "[Warning - Spell::configureSpell] Blocktype \"" << attr.as_string() << "\" does not exist." << std::endl;
}
}
if ((attr = node.attribute("aggressive"))) {
aggressive = booleanString(attr.as_string());
}
if (group == SPELLGROUP_NONE) {
group = (aggressive ? SPELLGROUP_ATTACK : SPELLGROUP_HEALING);
}
for (auto vocationNode : node.children()) {
if (!(attr = vocationNode.attribute("name"))) {
continue;
}
int32_t vocationId = g_vocations.getVocationId(attr.as_string());
if (vocationId != -1) {
attr = vocationNode.attribute("showInDescription");
vocSpellMap[vocationId] = !attr || attr.as_bool();
} else {
std::cout << "[Warning - Spell::configureSpell] Wrong vocation name: " << attr.as_string() << std::endl;
}
}
return true;
}
void mainLoader(int, char*[], ServiceManager* services)
{
//dispatcher thread
g_game.setGameState(GAME_STATE_STARTUP);
srand(static_cast<unsigned int>(OTSYS_TIME()));
#ifdef _WIN32
SetConsoleTitle(STATUS_SERVER_NAME);
#endif
std::cout << "The " << STATUS_SERVER_NAME << " Version: (" << STATUS_SERVER_VERSION << "." << MINOR_VERSION << " . " << REVISION_VERSION << ") - Codename: ( " << SOFTWARE_CODENAME << " )" << std::endl;
std::cout << "Compiled with: " << BOOST_COMPILER << std::endl;
std::cout << "Compiled on " << __DATE__ << ' ' << __TIME__ << " for platform ";
#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;
#else
std::cout << "unknown" << 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: " << GIT_REPO <<"." << 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
const std::string& defaultPriority = g_config.getString(ConfigManager::DEFAULT_PRIORITY);
if (strcasecmp(defaultPriority.c_str(), "high") == 0) {
SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
} else if (strcasecmp(defaultPriority.c_str(), "above-normal") == 0) {
SetPriorityClass(GetCurrentProcess(), ABOVE_NORMAL_PRIORITY_CLASS);
}
#endif
//set RSA key
const char* p("14299623962416399520070177382898895550795403345466153217470516082934737582776038882967213386204600674145392845853859217990626450972452084065728686565928113");
const char* q("7630979195970404721891201847792002125535401292779123937207447574596692788513647179235335529307251350570728407373705564708871762033017096809910315212884101");
g_RSA.setKey(p, q);
std::cout << ">> Establishing database connection..." << std::flush;
Database* db = Database::getInstance();
if (!db->connect()) {
startupErrorMessage("Failed to connect to database.");
return;
}
std::cout << " MySQL " << Database::getClientVersion() << std::endl;
// run database manager
std::cout << ">> Running database manager" << std::endl;
if (!DatabaseManager::isDatabaseSetup()) {
startupErrorMessage("The database you have specified in config.lua is empty, please import the schema.sql to your database.");
return;
}
g_databaseTasks.start();
DatabaseManager::updateDatabase();
if (g_config.getBoolean(ConfigManager::OPTIMIZE_DATABASE) && !DatabaseManager::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 item data
std::cout << ">> Loading items" << std::endl;
if (Item::items.loadFromOtb("data/items/items.otb") != ERROR_NONE) {
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 outfits" << std::endl;
Outfits* outfits = Outfits::getInstance();
if (!outfits->loadFromXml()) {
startupErrorMessage("Unable to load outfits!");
return;
}
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.loadMainMap(g_config.getString(ConfigManager::MAP_NAME))) {
startupErrorMessage("Failed to load map");
return;
}
std::cout << ">> Initializing gamestate" << std::endl;
g_game.setGameState(GAME_STATE_INIT);
// Game client 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));
// Legacy login protocol
services->add<ProtocolOld>(g_config.getNumber(ConfigManager::LOGIN_PORT));
RentPeriod_t rentPeriod;
std::string strRentPeriod = asLowerCaseString(g_config.getString(ConfigManager::HOUSE_RENT_PERIOD));
if (strRentPeriod == "yearly") {
rentPeriod = RENTPERIOD_YEARLY;
} else if (strRentPeriod == "weekly") {
rentPeriod = RENTPERIOD_WEEKLY;
} else if (strRentPeriod == "monthly") {
rentPeriod = RENTPERIOD_MONTHLY;
} else if (strRentPeriod == "daily") {
rentPeriod = RENTPERIOD_DAILY;
} else {
rentPeriod = RENTPERIOD_NEVER;
}
g_game.map.houses.payHouses(rentPeriod);
IOMarket::checkExpiredOffers();
IOMarket::getInstance()->updateStatistics();
std::cout << ">> Loaded all modules, server starting up..." << std::endl;
#ifndef _WIN32
if (getuid() == 0 || geteuid() == 0) {
std::cout << "> Warning: " << STATUS_SERVER_NAME << " has been executed as root user, please consider running it as a normal user." << std::endl;
}
#endif
g_game.start(services);
g_game.setGameState(GAME_STATE_NORMAL);
g_loaderSignal.notify_all();
}
bool Weapon::configureEvent(xmlNodePtr p)
{
int32_t intValue;
std::string strValue;
if (readXMLInteger(p, "id", intValue)) {
id = intValue;
} else {
std::cout << "Error: [Weapon::configureEvent] Weapon without id." << std::endl;
return false;
}
if (readXMLInteger(p, "lvl", intValue) || readXMLInteger(p, "level", intValue)) {
level = intValue;
}
if (readXMLInteger(p, "maglv", intValue) || readXMLInteger(p, "maglevel", intValue)) {
magLevel = intValue;
}
if (readXMLInteger(p, "mana", intValue)) {
mana = intValue;
}
if (readXMLInteger(p, "manapercent", intValue)) {
manaPercent = intValue;
}
if (readXMLInteger(p, "soul", intValue)) {
soul = intValue;
}
if (readXMLInteger(p, "exhaustion", intValue)) {
exhaustion = intValue;
}
if (readXMLInteger(p, "prem", intValue)) {
premium = (intValue == 1);
}
if (readXMLInteger(p, "enabled", intValue)) {
enabled = (intValue == 1);
}
if (readXMLInteger(p, "unproperly", intValue)) {
wieldUnproperly = (intValue == 1);
}
if (readXMLString(p, "ammo", strValue)) {
std::cout << "Warning: ammo is not longer used in weapons.xml." << std::endl;
}
typedef std::list<std::string> STRING_LIST;
STRING_LIST vocStringList;
xmlNodePtr vocationNode = p->children;
while (vocationNode) {
if (xmlStrcmp(vocationNode->name, (const xmlChar*)"vocation") == 0) {
if (readXMLString(vocationNode, "name", strValue)) {
int32_t vocationId = g_vocations.getVocationId(strValue);
if (vocationId != -1) {
vocWeaponMap[vocationId] = true;
int32_t promotedVocation = g_vocations.getPromotedVocation(vocationId);
if (promotedVocation != 0) {
vocWeaponMap[promotedVocation] = true;
}
readXMLInteger(vocationNode, "showInDescription", intValue);
if (intValue != 0) {
toLowerCaseString(strValue);
vocStringList.push_back(strValue);
}
}
}
}
vocationNode = vocationNode->next;
}
range = Item::items[id].shootRange;
std::string vocationString;
if (!vocStringList.empty()) {
for (STRING_LIST::iterator it = vocStringList.begin(); it != vocStringList.end(); ++it) {
if (*it != vocStringList.front()) {
if (*it != vocStringList.back()) {
vocationString += ", ";
} else {
vocationString += " and ";
}
}
vocationString += *it;
vocationString += "s";
}
}
uint32_t wieldInfo = 0;
if (getReqLevel() > 0) {
wieldInfo |= WIELDINFO_LEVEL;
}
if (getReqMagLv() > 0) {
wieldInfo |= WIELDINFO_MAGLV;
}
if (!vocationString.empty()) {
wieldInfo |= WIELDINFO_VOCREQ;
}
if (isPremium()) {
wieldInfo |= WIELDINFO_PREMIUM;
}
if (wieldInfo != 0) {
ItemType& it = Item::items.getItemType(id);
it.wieldInfo = wieldInfo;
it.vocationString = vocationString;
it.minReqLevel = getReqLevel();
it.minReqMagicLevel = getReqMagLv();
}
if (configureWeapon(Item::items[getID()])) {
return true;
}
return false;
}
bool MoveEvent::configureEvent(const pugi::xml_node& node)
{
pugi::xml_attribute eventAttr = node.attribute("event");
if (!eventAttr) {
std::cout << "[Error - MoveEvent::configureMoveEvent] Missing event" << std::endl;
return false;
}
std::string tmpStr = asLowerCaseString(eventAttr.as_string());
if (tmpStr == "stepin") {
m_eventType = MOVE_EVENT_STEP_IN;
} else if (tmpStr == "stepout") {
m_eventType = MOVE_EVENT_STEP_OUT;
} else if (tmpStr == "equip") {
m_eventType = MOVE_EVENT_EQUIP;
} else if (tmpStr == "deequip") {
m_eventType = MOVE_EVENT_DEEQUIP;
} else if (tmpStr == "additem") {
m_eventType = MOVE_EVENT_ADD_ITEM;
} else if (tmpStr == "removeitem") {
m_eventType = MOVE_EVENT_REMOVE_ITEM;
} else {
std::cout << "Error: [MoveEvent::configureMoveEvent] No valid event name " << eventAttr.as_string() << std::endl;
return false;
}
if (m_eventType == MOVE_EVENT_EQUIP || m_eventType == MOVE_EVENT_DEEQUIP) {
pugi::xml_attribute slotAttribute = node.attribute("slot");
if (slotAttribute) {
tmpStr = asLowerCaseString(slotAttribute.as_string());
if (tmpStr == "head") {
slot = SLOTP_HEAD;
} else if (tmpStr == "necklace") {
slot = SLOTP_NECKLACE;
} else if (tmpStr == "backpack") {
slot = SLOTP_BACKPACK;
} else if (tmpStr == "armor") {
slot = SLOTP_ARMOR;
} else if (tmpStr == "right-hand") {
slot = SLOTP_RIGHT;
} else if (tmpStr == "left-hand") {
slot = SLOTP_LEFT;
} else if (tmpStr == "hand" || tmpStr == "shield") {
slot = SLOTP_RIGHT | SLOTP_LEFT;
} else if (tmpStr == "legs") {
slot = SLOTP_LEGS;
} else if (tmpStr == "feet") {
slot = SLOTP_FEET;
} else if (tmpStr == "ring") {
slot = SLOTP_RING;
} else if (tmpStr == "ammo") {
slot = SLOTP_AMMO;
} else {
std::cout << "[Warning - MoveEvent::configureMoveEvent] Unknown slot type: " << slotAttribute.as_string() << std::endl;
}
}
wieldInfo = 0;
pugi::xml_attribute levelAttribute = node.attribute("level");
if (levelAttribute) {
reqLevel = pugi::cast<uint32_t>(levelAttribute.value());
if (reqLevel > 0) {
wieldInfo |= WIELDINFO_LEVEL;
}
}
pugi::xml_attribute magLevelAttribute = node.attribute("maglevel");
if (magLevelAttribute) {
reqMagLevel = pugi::cast<uint32_t>(magLevelAttribute.value());
if (reqMagLevel > 0) {
wieldInfo |= WIELDINFO_MAGLV;
}
}
pugi::xml_attribute premiumAttribute = node.attribute("premium");
if (premiumAttribute) {
premium = premiumAttribute.as_bool();
if (premium) {
wieldInfo |= WIELDINFO_PREMIUM;
}
}
//Gather vocation information
std::list<std::string> vocStringList;
for (auto vocationNode : node.children()) {
pugi::xml_attribute vocationNameAttribute = vocationNode.attribute("name");
if (!vocationNameAttribute) {
continue;
}
int32_t vocationId = g_vocations.getVocationId(vocationNameAttribute.as_string());
if (vocationId != -1) {
vocEquipMap[vocationId] = true;
if (vocationNode.attribute("showInDescription").as_bool(true)) {
vocStringList.push_back(asLowerCaseString(vocationNameAttribute.as_string()));
}
}
}
if (!vocEquipMap.empty()) {
wieldInfo |= WIELDINFO_VOCREQ;
}
for (const std::string& str : vocStringList) {
if (!vocationString.empty()) {
if (str != vocStringList.back()) {
vocationString.push_back(',');
vocationString.push_back(' ');
} else {
vocationString += " and ";
}
}
vocationString += str;
vocationString.push_back('s');
}
}
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
//set RSA key
const char* p("14299623962416399520070177382898895550795403345466153217470516082934737582776038882967213386204600674145392845853859217990626450972452084065728686565928113");
const char* q("7630979195970404721891201847792002125535401292779123937207447574596692788513647179235335529307251350570728407373705564708871762033017096809910315212884101");
g_RSA.setKey(p, q);
std::cout << ">> Establishing database connection..." << std::flush;
Database* db = Database::getInstance();
if (!db->connect()) {
startupErrorMessage("Failed to connect to database.");
return;
}
std::cout << " MySQL " << Database::getClientVersion() << std::endl;
// run database manager
std::cout << ">> Running database manager" << std::endl;
if (!DatabaseManager::isDatabaseSetup()) {
startupErrorMessage("The database you have specified in config.lua is empty, please import the schema.sql to your database.");
return;
}
DatabaseManager::updateDatabase();
DatabaseManager::checkEncryption();
if (g_config.getBoolean(ConfigManager::OPTIMIZE_DATABASE) && !DatabaseManager::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.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 outfits" << std::endl;
Outfits* outfits = Outfits::getInstance();
if (!outfits->loadFromXml()) {
startupErrorMessage("Unable to load outfits!");
return;
}
g_adminConfig = new AdminProtocolConfig();
std::cout << ">> Loading admin protocol config" << std::endl;
if (!g_adminConfig->loadXMLConfig()) {
startupErrorMessage("Unable to load admin protocol config!");
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.loadMainMap(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<ProtocolAdmin>(g_config.getNumber(ConfigManager::ADMIN_PORT));
services->add<ProtocolStatus>(g_config.getNumber(ConfigManager::STATUS_PORT));
// Legacy protocols
services->add<ProtocolOldLogin>(g_config.getNumber(ConfigManager::LOGIN_PORT));
services->add<ProtocolOldGame>(g_config.getNumber(ConfigManager::LOGIN_PORT));
int32_t autoSaveEachMinutes = g_config.getNumber(ConfigManager::AUTO_SAVE_EACH_MINUTES);
if (autoSaveEachMinutes > 0) {
g_scheduler->addEvent(createSchedulerTask(autoSaveEachMinutes * 1000 * 60, std::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, std::bind(&Game::prepareServerSave, &g_game)));
}
}
Houses::getInstance().payHouses();
IOLoginData::updateHouseOwners();
g_game.checkExpiredMarketOffers();
IOMarket::getInstance()->updateStatistics();
std::cout << ">> Loaded all modules, server starting up..." << std::endl;
#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();
}
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;
#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.loadFile("config.lua")) {
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(NULL, 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
//set RSA key
const char* p("14299623962416399520070177382898895550795403345466153217470516082934737582776038882967213386204600674145392845853859217990626450972452084065728686565928113");
const char* q("7630979195970404721891201847792002125535401292779123937207447574596692788513647179235335529307251350570728407373705564708871762033017096809910315212884101");
const char* d("46730330223584118622160180015036832148732986808519344675210555262940258739805766860224610646919605860206328024326703361630109888417839241959507572247284807035235569619173792292786907845791904955103601652822519121908367187885509270025388641700821735345222087940578381210879116823013776808975766851829020659073");
g_RSA.setKey(p, q, d);
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;
}
for (uint32_t version = dbManager->updateDatabase(); version != 0; version = dbManager->updateDatabase()) {
std::cout << "> Database has been updated to version " << version << "." << std::endl;
}
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 (!commands.loadFromXml()) {
startupErrorMessage("Unable to load commands!");
return;
}
// load item data
std::cout << ">> Loading items" << std::endl;
if (Item::items.loadFromOtb("data/items/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 outfits" << std::endl;
Outfits* outfits = Outfits::getInstance();
if (!outfits->loadFromXml()) {
startupErrorMessage("Unable to load outfits!");
return;
}
g_adminConfig = new AdminProtocolConfig();
std::cout << ">> Loading admin protocol config" << std::endl;
if (!g_adminConfig->loadXMLConfig()) {
startupErrorMessage("Unable to load admin protocol config!");
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 == "md5") {
g_config.setNumber(ConfigManager::PASSWORD_TYPE, PASSWORD_TYPE_MD5);
std::cout << ">> Using MD5 passwords" << std::endl;
} else 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<ProtocolAdmin>(g_config.getNumber(ConfigManager::ADMIN_PORT));
services->add<ProtocolStatus>(g_config.getNumber(ConfigManager::STATUS_PORT));
// Legacy protocols
services->add<ProtocolOldLogin>(g_config.getNumber(ConfigManager::LOGIN_PORT));
services->add<ProtocolOldGame>(g_config.getNumber(ConfigManager::LOGIN_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(NULL);
tm* timeinfo = localtime(&timeNow);
if (serverSaveHour == 0) {
serverSaveHour = 23;
} else {
serverSaveHour--;
}
timeinfo->tm_hour = serverSaveHour;
timeinfo->tm_min = 55;
timeinfo->tm_sec = 0;
time_t difference = (time_t)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();
if (g_config.getBoolean(ConfigManager::MARKET_ENABLED)) {
g_game.checkExpiredMarketOffers();
IOMarket::getInstance()->updateStatistics();
}
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] != NULL) {
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();
}
void mainLoader(int, char*[], ServiceManager* services)
{
//dispatcher thread
g_game.setGameState(GAME_STATE_STARTUP);
srand(static_cast<unsigned int>(OTSYS_TIME()));
#ifdef _WIN32
SetConsoleTitle(STATUS_SERVER_NAME);
#endif
std::cout << STATUS_SERVER_NAME << " - Versao " << STATUS_SERVER_VERSION << std::endl;
std::cout << "Compilado com " << BOOST_COMPILER << std::endl;
std::cout << "Compilado em " << __DATE__ << ' ' << __TIME__ << " para plataforma ";
#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;
#else
std::cout << "desconhecida" << std::endl;
#endif
std::cout << std::endl;
std::cout << "Este servidor foi desenvolvido por " << STATUS_SERVER_DEVELOPERS << std::endl;
std::cout << "Visite nosso forum para updates, suporte e pedidos: http://xtibia.com/." << std::endl;
std::cout << "Um oferecimento OTPanel, OTserv Cloud em 60s." << std::endl;
std::cout << std::endl;
// read global config
std::cout << ">> Carregando configuracoes" << std::endl;
if (!g_config.load()) {
startupErrorMessage("Falha ao carregar o config.lua!");
return;
}
#ifdef _WIN32
const std::string& defaultPriority = g_config.getString(ConfigManager::DEFAULT_PRIORITY);
if (strcasecmp(defaultPriority.c_str(), "high") == 0) {
SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
} else if (strcasecmp(defaultPriority.c_str(), "above-normal") == 0) {
SetPriorityClass(GetCurrentProcess(), ABOVE_NORMAL_PRIORITY_CLASS);
}
#endif
//set RSA key
const char* p("14299623962416399520070177382898895550795403345466153217470516082934737582776038882967213386204600674145392845853859217990626450972452084065728686565928113");
const char* q("7630979195970404721891201847792002125535401292779123937207447574596692788513647179235335529307251350570728407373705564708871762033017096809910315212884101");
g_RSA.setKey(p, q);
std::cout << ">> Estabilizando conexao com o banco de dados..." << std::flush;
Database* db = Database::getInstance();
if (!db->connect()) {
startupErrorMessage("Falha ao conectar-se com o banco de dados.");
return;
}
std::cout << " MySQL " << Database::getClientVersion() << std::endl;
// run database manager
std::cout << ">> Carregando banco de dados" << std::endl;
if (!DatabaseManager::isDatabaseSetup()) {
startupErrorMessage("O banco de dados que especificou no config.lua esta vazio, por favor importar o schema.sql para seu banco de dados.");
return;
}
g_databaseTasks.start();
DatabaseManager::updateDatabase();
if (g_config.getBoolean(ConfigManager::OPTIMIZE_DATABASE) && !DatabaseManager::optimizeTables()) {
std::cout << "> Nenhuma tabela foi otimizada." << std::endl;
}
//load vocations
std::cout << ">> Carregando vocacoes" << std::endl;
if (!g_vocations.loadFromXml()) {
startupErrorMessage("Impossivel carregar vocacoes!");
return;
}
// load item data
std::cout << ">> Carregando items" << std::endl;
if (Item::items.loadFromOtb("data/items/items.otb") != ERROR_NONE) {
startupErrorMessage("Impossivel carregar items (OTB)!");
return;
}
if (!Item::items.loadFromXml()) {
startupErrorMessage("Impossivel carregar (XML)!");
return;
}
std::cout << ">> Carregando sistemas de scripts" << std::endl;
if (!ScriptingManager::getInstance()->loadScriptSystems()) {
startupErrorMessage("Impossivel carregar sistemas de scripts");
return;
}
std::cout << ">> Carregando criaturas" << std::endl;
if (!g_monsters.loadFromXml()) {
startupErrorMessage("Impossivel carregar criaturas!");
return;
}
std::cout << ">> Carregando outfits" << std::endl;
Outfits* outfits = Outfits::getInstance();
if (!outfits->loadFromXml()) {
startupErrorMessage("Impossivel carregar outfits!");
return;
}
std::cout << ">> Checando tipo do servidor... " << 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 << "> ERRO: Tipo do servidor desconhecido: " << g_config.getString(ConfigManager::WORLD_TYPE) << ", os tipos validos sao: pvp, no-pvp and pvp-enforced.";
startupErrorMessage(ss.str());
return;
}
std::cout << asUpperCaseString(worldType) << std::endl;
std::cout << ">> Carregando mapa" << std::endl;
if (!g_game.loadMainMap(g_config.getString(ConfigManager::MAP_NAME))) {
startupErrorMessage("Impossivel carregar o mapa");
return;
}
std::cout << ">> Inicializando o servidor" << std::endl;
g_game.setGameState(GAME_STATE_INIT);
// Game client 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));
// Legacy login protocol
services->add<ProtocolOld>(g_config.getNumber(ConfigManager::LOGIN_PORT));
RentPeriod_t rentPeriod;
std::string strRentPeriod = asLowerCaseString(g_config.getString(ConfigManager::HOUSE_RENT_PERIOD));
if (strRentPeriod == "yearly") {
rentPeriod = RENTPERIOD_YEARLY;
} else if (strRentPeriod == "weekly") {
rentPeriod = RENTPERIOD_WEEKLY;
} else if (strRentPeriod == "monthly") {
rentPeriod = RENTPERIOD_MONTHLY;
} else if (strRentPeriod == "daily") {
rentPeriod = RENTPERIOD_DAILY;
} else {
rentPeriod = RENTPERIOD_NEVER;
}
g_game.map.houses.payHouses(rentPeriod);
IOMarket::checkExpiredOffers();
IOMarket::getInstance()->updateStatistics();
std::cout << ">> Todos os modulos carregados, servidor iniciando..." << std::endl;
#ifndef _WIN32
if (getuid() == 0 || geteuid() == 0) {
std::cout << "> Aviso: O servidor foi executado com usuario root, por favor considere executa-lo como um usuario normal." << std::endl;
}
#endif
g_game.start(services);
g_game.setGameState(GAME_STATE_NORMAL);
g_loaderSignal.notify_all();
}
