Sources para [DBO]

gustavoadp · Junho 3, 2022

@bringsz, olá. Meu server de dbo tá com bugs nas mortes. Depois de morrer na arena, se morrer normalmente pra qualquer bixo ou player, fica bugando. Life zero e o char não morre.

Então acho que o erro é na source. Mas já tentei compilar várias sources e dá erro na compilação. Mais especificamente quando ele começa a compilar o arquivo tools.cpp.

Vi que seu tópico é o que mais se aproxima de uma resolução para o meu caso. Tentei compilar e, mais uma vez, erro no tools.pp. Você sabe dizer o que é isso?

Outra pergunta: quando vou compilar, o que interessa na hora da compilação? Apenas as sources? Pois tem lugar que vc baixa source e vem mais coisas dentro da pasta, como "data", "mods"...

Editado Junho 3, 2022 por gustavoadp (veja o histórico de edições)

Apache · Junho 3, 2022

Em 03/06/2022 em 17:37, gustavoadp disse:

@bringsz, olá. Meu server de dbo tá com bugs nas mortes. Depois de morrer na arena, se morrer normalmente pra qualquer bixo ou player, fica bugando. Life zero e o char não morre.

Então acho que o erro é na source. Mas já tentei compilar várias sources e dá erro na compilação. Mais especificamente quando ele começa a compilar o arquivo tools.cpp.

Vi que seu tópico é o que mais se aproxima de uma resolução para o meu caso. Tentei compilar e, mais uma vez, erro no tools.pp. Você sabe dizer o que é isso?

Outra pergunta: quando vou compilar, o que interessa na hora da compilação? Apenas as sources? Pois tem lugar que vc baixa source e vem mais coisas dentro da pasta, como "data", "mods"...

Mostrar mais

cara mais provável que seja algum creaturescripts, e não recomendo investir nessa src desse dbo, pega uma mais atual e modifica que é melhor.

gustavoadp · Junho 4, 2022

Em 03/06/2022 em 20:12, Apache disse:

cara mais provável que seja algum creaturescripts, e não recomendo investir nessa src desse dbo, pega uma mais atual e modifica que é melhor.

Mostrar mais

Entendi. Vou procurar mais src então! Só que toda src que eu tento compilar dá vários erros em tools. Estou fazendo errado? Tem algo a ver com o "data", "mods"? Já tentei compilar 3 src diferentes, até de Tibia mesmo e sempre erro nesse tools.cpp. Um exemplo é da src deste tópico daqui. Aparece isso:

Mostrar conteúdo oculto

#include <openssl/sha.h>
#include <openssl/md5.h>

#include "vocation.h"
#include "configmanager.h"

extern ConfigManager g_config;

std::string transformToMD5(std::string plainText, bool upperCase)
{
   MD5_CTX c;
   MD5_Init(&c);
   MD5_Update(&c, plainText.c_str(), plainText.length());

uint8_t md[MD5_DIGEST_LENGTH];
MD5_Final(md, &c);

   char output[MD5_DIGEST_LENGTH * 2 + 1] = "";
   for(int32_t i = 0; i < static_cast<int32_t>(sizeof(md)); i++)
       sprintf(output, "%s%.2X", output, md[i]);

if(upperCase)
return std::string(output);

return asLowerCaseString(std::string(output));
}

std::string transformToSHA1(std::string plainText, bool upperCase)
{
   SHA_CTX c;
   SHA1_Init(&c);
   SHA1_Update(&c, plainText.c_str(), plainText.length());

uint8_t md[SHA_DIGEST_LENGTH];
SHA1_Final(md, &c);

   char output[SHA_DIGEST_LENGTH * 2 + 1] = "";
   for(int32_t i = 0; i < static_cast<int32_t>(sizeof(md)); i++)
       sprintf(output, "%s%.2X", output, md[i]);

if(upperCase)
return std::string(output);

return asLowerCaseString(std::string(output));
}

std::string transformToSHA256(std::string plainText, bool upperCase)
{
   SHA256_CTX c;
   SHA256_Init(&c);
   SHA256_Update(&c, plainText.c_str(), plainText.length());

uint8_t md[SHA256_DIGEST_LENGTH];
SHA256_Final(md, &c);

   char output[SHA256_DIGEST_LENGTH * 2 + 1] = "";
   for(int32_t i = 0; i < static_cast<int32_t>(sizeof(md)); i++)
       sprintf(output, "%s%.2X", output, md[i]);

if(upperCase)
return std::string(output);

return asLowerCaseString(std::string(output));
}

std::string transformToSHA512(std::string plainText, bool upperCase)
{
   SHA512_CTX c;
   SHA512_Init(&c);
   SHA512_Update(&c, plainText.c_str(), plainText.length());

uint8_t md[SHA512_DIGEST_LENGTH];
SHA512_Final(md, &c);

   char output[SHA512_DIGEST_LENGTH * 2 + 1] = "";
   for(int32_t i = 0; i < static_cast<int32_t>(sizeof(md)); i++)
       sprintf(output, "%s%.2X", output, md[i]);

if(upperCase)
return std::string(output);

return asLowerCaseString(std::string(output));
}

void _encrypt(std::string& str, bool upperCase)
{
   switch(g_config.getNumber(ConfigManager::ENCRYPTION))
   {
       case ENCRYPTION_MD5:
           str = transformToMD5(str, upperCase);
           break;
       case ENCRYPTION_SHA1:
           str = transformToSHA1(str, upperCase);
           break;
       case ENCRYPTION_SHA256:
           str = transformToSHA256(str, upperCase);
           break;
       case ENCRYPTION_SHA512:
           str = transformToSHA512(str, upperCase);
           break;
       default:
       {
           if(upperCase)
               std::transform(str.begin(), str.end(), str.begin(), upchar);

           break;
       }
   }
}

bool encryptTest(std::string plain, std::string& hash)
{
   std::transform(hash.begin(), hash.end(), hash.begin(), upchar);
   _encrypt(plain, true);
   return plain == hash;
}

bool replaceString(std::string& text, const std::string& key, const std::string& value)
{
if(text.find(key) == std::string::npos)
return false;

   std::string::size_type start = 0, pos = 0;
   while((start = text.find(key, pos)) != std::string::npos)
   {
       text.replace(start, key.size(), value);
       //text = text.substr(0, start) + value + text.substr(start + key.size());
       pos = start + value.size();
   }

return true;
}

void trim_right(std::string& source, const std::string& t)
{
source.erase(source.find_last_not_of(t) + 1);
}

void trim_left(std::string& source, const std::string& t)
{
source.erase(0, source.find_first_not_of(t));
}

void toLowerCaseString(std::string& source)
{
std::transform(source.begin(), source.end(), source.begin(), tolower);
}

void toUpperCaseString(std::string& source)
{
std::transform(source.begin(), source.end(), source.begin(), upchar);
}

std::string asLowerCaseString(const std::string& source)
{
   std::string s = source;
   toLowerCaseString(s);
   return s;
}

std::string asUpperCaseString(const std::string& source)
{
   std::string s = source;
   toUpperCaseString(s);
   return s;
}

bool booleanString(std::string source)
{
toLowerCaseString(source);
return (source == "yes" || source == "true" || atoi(source.c_str()) > 0);
}

bool readXMLInteger(xmlNodePtr node, const char* tag, int32_t& value)
{
   char* nodeValue = (char*)xmlGetProp(node, (xmlChar*)tag);
   if(!nodeValue)
       return false;

   value = atoi(nodeValue);
   xmlFree(nodeValue);
   return true;
}

bool readXMLInteger64(xmlNodePtr node, const char* tag, int64_t& value)
{
   char* nodeValue = (char*)xmlGetProp(node, (xmlChar*)tag);
   if(!nodeValue)
       return false;

   value = atoll(nodeValue);
   xmlFree(nodeValue);
   return true;
}

bool readXMLFloat(xmlNodePtr node, const char* tag, float& value)
{
   char* nodeValue = (char*)xmlGetProp(node, (xmlChar*)tag);
   if(!nodeValue)
       return false;

   value = atof(nodeValue);
   xmlFree(nodeValue);
   return true;
}

bool readXMLString(xmlNodePtr node, const char* tag, std::string& value)
{
   char* nodeValue = (char*)xmlGetProp(node, (xmlChar*)tag);
   if(!nodeValue)
       return false;

if(!utf8ToLatin1(nodeValue, value))
value = nodeValue;

xmlFree(nodeValue);
return true;
}

bool readXMLContentString(xmlNodePtr node, std::string& value)
{
   char* nodeValue = (char*)xmlNodeGetContent(node);
   if(!nodeValue)
       return false;

if(!utf8ToLatin1(nodeValue, value))
value = nodeValue;

xmlFree(nodeValue);
return true;
}

bool parseXMLContentString(xmlNodePtr node, std::string& value)
{
   bool result = false;
   std::string compareValue;
   while(node)
   {
       if(xmlStrcmp(node->name, (const xmlChar*)"text") && node->type != XML_CDATA_SECTION_NODE)
       {
           node = node->next;
           continue;
       }

       if(!readXMLContentString(node, compareValue))
       {
           node = node->next;
           continue;
       }

       trim_left(compareValue, "\r");
       trim_left(compareValue, "\n");
       trim_left(compareValue, " ");
       if(compareValue.length() > value.length())
       {
           value = compareValue;
           if(!result)
               result = true;
       }

node = node->next;
}

return result;
}

std::string getLastXMLError()
{
   std::stringstream ss;
   xmlErrorPtr lastError = xmlGetLastError();
   if(lastError->line)
       ss << "Line: " << lastError->line << ", ";

ss << "Info: " << lastError->message << std::endl;
return ss.str();
}

bool utf8ToLatin1(char* intext, std::string& outtext)
{
   outtext = "";
   if(!intext)
       return false;

   int32_t inlen = strlen(intext);
   if(!inlen)
       return false;

int32_t outlen = inlen * 2;
uint8_t* outbuf = new uint8_t[outlen];

   int32_t res = UTF8Toisolat1(outbuf, &outlen, (uint8_t*)intext, &inlen);
   if(res < 0)
   {
       delete[] outbuf;
       return false;
   }

outbuf[outlen] = '\0';
outtext = (char*)outbuf;

delete[] outbuf;
return true;
}

StringVec explodeString(const std::string& string, const std::string& separator)
{
   StringVec returnVector;
   size_t start = 0, end = 0;
   while((end = string.find(separator, start)) != std::string::npos)
   {
       returnVector.push_back(string.substr(start, end - start));
       start = end + separator.size();
   }

returnVector.push_back(string.substr(start));
return returnVector;
}

IntegerVec vectorAtoi(StringVec stringVector)
{
   IntegerVec returnVector;
   for(StringVec::iterator it = stringVector.begin(); it != stringVector.end(); ++it)
       returnVector.push_back(atoi((*it).c_str()));

return returnVector;
}

bool hasBitSet(uint32_t flag, uint32_t flags)
{
return ((flags & flag) == flag);
}

int32_t round(float v)
{
   int32_t t = (int32_t)std::floor(v);
   if((v - t) > 0.5)
       return t + 1;

return t;
}

uint32_t rand24b()
{
return ((rand() << 12) ^ (rand())) & (0xFFFFFF);
}

float box_muller(float m, float s)
{
   // normal random variate generator
   // mean m, standard deviation s
   float x1, x2, w, y1;
   static float y2;

   static bool useLast = false;
   if(useLast) // use value from previous call
   {
       y1 = y2;
       useLast = false;
       return (m + y1 * s);
   }

   do
   {
       double r1 = (((float)(rand()) / RAND_MAX));
       double r2 = (((float)(rand()) / RAND_MAX));

       x1 = 2.0 * r1 - 1.0;
       x2 = 2.0 * r2 - 1.0;
       w = x1 * x1 + x2 * x2;
   }
   while(w >= 1.0);
   w = sqrt((-2.0 * log(w)) / w);

y1 = x1 * w;
y2 = x2 * w;

useLast = true;
return (m + y1 * s);
}

int32_t random_range(int32_t lowestNumber, int32_t highestNumber, DistributionType_t type /*= DISTRO_UNIFORM*/)
{
if(highestNumber == lowestNumber)
return lowestNumber;

if(lowestNumber > highestNumber)
std::swap(lowestNumber, highestNumber);

   switch(type)
   {
       case DISTRO_UNIFORM:
           return (lowestNumber + ((int32_t)rand24b() % (highestNumber - lowestNumber + 1)));
       case DISTRO_NORMAL:
           return (lowestNumber + int32_t(float(highestNumber - lowestNumber) * (float)std::min((float)1, std::max((float)0, box_muller(0.5, 0.25)))));
       default:
           break;
   }

const float randMax = 16777216;
return (lowestNumber + int32_t(float(highestNumber - lowestNumber) * float(1.f - sqrt((1.f * rand24b()) / randMax))));
}

char upchar(char character)
{
if((character >= 97 && character <= 122) || (character <= -1 && character >= -32))
character -= 32;

return character;
}

bool isNumber(char character)
{
return (character >= 48 && character <= 57);
}

bool isLowercaseLetter(char character)
{
return (character >= 97 && character <= 122);
}

bool isUppercaseLetter(char character)
{
return (character >= 65 && character <= 90);
}

bool isPasswordCharacter(char character)
{
return ((character >= 33 && character <= 47) || (character >= 58 && character <= 64) || (character >= 91 && character <= 96) || (character >= 123 && character <= 126));
}

bool isValidAccountName(std::string text)
{
toLowerCaseString(text);

   uint32_t textLength = text.length();
   for(uint32_t size = 0; size < textLength; size++)
   {
       if(!isLowercaseLetter(text[size]) && !isNumber(text[size]))
           return false;
   }

return true;
}

bool isValidPassword(std::string text)
{
toLowerCaseString(text);

   uint32_t textLength = text.length();
   for(uint32_t size = 0; size < textLength; size++)
   {
       if(!isLowercaseLetter(text[size]) && !isNumber(text[size]) && !isPasswordCharacter(text[size]))
           return false;
   }

return true;
}

bool isValidName(std::string text, bool forceUppercaseOnFirstLetter/* = true*/)
{
   uint32_t textLength = text.length(), lenBeforeSpace = 1, lenBeforeQuote = 1, lenBeforeDash = 1, repeatedCharacter = 0;
   char lastChar = 32;
   if(forceUppercaseOnFirstLetter)
   {
       if(!isUppercaseLetter(text[0]))
           return false;
   }
   else if(!isLowercaseLetter(text[0]) && !isUppercaseLetter(text[0]))
       return false;

   for(uint32_t size = 1; size < textLength; size++)
   {
       if(text[size] != 32)
       {
           lenBeforeSpace++;
           if(text[size] != 39)
               lenBeforeQuote++;
           else
           {
               if(lenBeforeQuote <= 1 || size == textLength - 1 || text[size + 1] == 32)
                   return false;

lenBeforeQuote = 0;
}

           if(text[size] != 45)
               lenBeforeDash++;
           else
           {
               if(lenBeforeDash <= 1 || size == textLength - 1 || text[size + 1] == 32)
                   return false;

lenBeforeDash = 0;
}

           if(text[size] == lastChar)
           {
               repeatedCharacter++;
               if(repeatedCharacter > 2)
                   return false;
           }
           else
               repeatedCharacter = 0;

           lastChar = text[size];
       }
       else
       {
           if(lenBeforeSpace <= 1 || size == textLength - 1 || text[size + 1] == 32)
               return false;

lenBeforeSpace = lenBeforeQuote = lenBeforeDash = 0;
}

       if(!(isLowercaseLetter(text[size]) || text[size] == 32 || text[size] == 39 || text[size] == 45
           || (isUppercaseLetter(text[size]) && text[size - 1] == 32)))
           return false;
   }

return true;
}

bool isNumbers(std::string text)
{
   uint32_t textLength = text.length();
   for(uint32_t size = 0; size < textLength; size++)
   {
       if(!isNumber(text[size]))
           return false;
   }

return true;
}

bool checkText(std::string text, std::string str)
{
trimString(text);
return asLowerCaseString(text) == str;
}

std::string generateRecoveryKey(int32_t fieldCount, int32_t fieldLenght, bool mixCase/* = false*/)
{
std::stringstream key;
int32_t i = 0, j = 0, lastNumber = 99, number = 0;

   char character = 0, lastCharacter = 0;
   bool madeNumber = false, madeCharacter = false;
   do
   {
       do
       {
           madeNumber = madeCharacter = false;
           if((mixCase && !random_range(0, 2)) || (!mixCase && (bool)random_range(0, 1)))
           {
               number = random_range(2, 9);
               if(number != lastNumber)
               {
                   key << number;
                   lastNumber = number;
                   madeNumber = true;
               }
           }
           else
           {
               if(mixCase && (bool)random_range(0,1) )
                   character = (char)random_range(97, 122);
               else
                   character = (char)random_range(65, 90);

               if(character != lastCharacter)
               {
                   key << character;
                   lastCharacter = character;
                   madeCharacter = true;
               }
           }
       }
       while((!madeCharacter && !madeNumber) ? true : (++j && j < fieldLenght));
       lastCharacter = character = number = j = 0;

       lastNumber = 99;
       if(i < fieldCount - 1)
           key << "-";
   }
   while(++i && i < fieldCount);
   return key.str();
}

std::string trimString(std::string& str)
{
str.erase(str.find_last_not_of(" ") + 1);
return str.erase(0, str.find_first_not_of(" "));
}

std::string parseParams(tokenizer::iterator &it, tokenizer::iterator end)
{
if(it == end)
return "";

   std::string tmp = (*it);
   ++it;
   if(tmp[0] == '"')
   {
       tmp.erase(0, 1);
       while(it != end && tmp[tmp.length() - 1] != '"')
       {
           tmp += " " + (*it);
           ++it;
       }

       if(tmp.length() > 0 && tmp[tmp.length() - 1] == '"')
           tmp.erase(tmp.length() - 1);
   }

return tmp;
}

std::string formatDate(time_t _time/* = 0*/)
{
if(!_time)
_time = time(NULL);

   const tm* tms = localtime(&_time);
   std::stringstream s;
   if(tms)
       s << tms->tm_mday << "/" << (tms->tm_mon + 1) << "/" << (tms->tm_year + 1900) << " " << tms->tm_hour << ":" << tms->tm_min << ":" << tms->tm_sec;
   else
       s << "UNIX Time: " << (int32_t)_time;

return s.str();
}

std::string formatDateEx(time_t _time/* = 0*/, std::string format/* = "%d %b %Y, %H:%M:%S"*/)
{
if(!_time)
_time = time(NULL);

   const tm* tms = localtime(&_time);
   char buffer[100];
   if(tms)
       strftime(buffer, 25, format.c_str(), tms);
   else
       sprintf(buffer, "UNIX Time: %d", (int32_t)_time);

return buffer;
}

std::string formatTime(time_t _time/* = 0*/, bool ms/* = false*/)
{
   if(!_time)
       _time = time(NULL);
   else if(ms)
       ms = false;

   const tm* tms = localtime(&_time);
   std::stringstream s;
   if(tms)
   {
       s << tms->tm_hour << ":" << tms->tm_min << ":";
       if(tms->tm_sec < 10)
           s << "0";

       s << tms->tm_sec;
       if(ms)
       {
           timeb t;
           ftime(&t);

           s << "."; // make it format zzz
           if(t.millitm < 10)
               s << "0";

if(t.millitm < 100)
s << "0";

           s << t.millitm;
       }
   }
   else
       s << "UNIX Time: " << (int32_t)_time;

return s.str();
}

std::string convertIPAddress(uint32_t ip)
{
   char buffer[17];
   sprintf(buffer, "%d.%d.%d.%d", ip & 0xFF, (ip >> ? & 0xFF, (ip >> 16) & 0xFF, (ip >> 24));
   return buffer;
}

Skulls_t getSkulls(std::string strValue)
{
   std::string tmpStrValue = asLowerCaseString(strValue);
   if(tmpStrValue == "black" || tmpStrValue == "5")
       return SKULL_BLACK;

if(tmpStrValue == "red" || tmpStrValue == "4")
return SKULL_RED;

if(tmpStrValue == "white" || tmpStrValue == "3")
return SKULL_WHITE;

if(tmpStrValue == "green" || tmpStrValue == "2")
return SKULL_GREEN;

if(tmpStrValue == "yellow" || tmpStrValue == "1")
return SKULL_YELLOW;

return SKULL_NONE;
}

PartyShields_t getShields(std::string strValue)
{
   std::string tmpStrValue = asLowerCaseString(strValue);
   if(tmpStrValue == "whitenoshareoff" || tmpStrValue == "10")
       return SHIELD_YELLOW_NOSHAREDEXP;

if(tmpStrValue == "blueshareoff" || tmpStrValue == "9")
return SHIELD_BLUE_NOSHAREDEXP;

if(tmpStrValue == "yellowshareblink" || tmpStrValue == "8")
return SHIELD_YELLOW_NOSHAREDEXP_BLINK;

if(tmpStrValue == "blueshareblink" || tmpStrValue == "7")
return SHIELD_BLUE_NOSHAREDEXP_BLINK;

if(tmpStrValue == "yellowshareon" || tmpStrValue == "6")
return SHIELD_YELLOW_SHAREDEXP;

if(tmpStrValue == "blueshareon" || tmpStrValue == "5")
return SHIELD_BLUE_SHAREDEXP;

if(tmpStrValue == "yellow" || tmpStrValue == "4")
return SHIELD_YELLOW;

if(tmpStrValue == "blue" || tmpStrValue == "3")
return SHIELD_BLUE;

if(tmpStrValue == "whiteyellow" || tmpStrValue == "2")
return SHIELD_WHITEYELLOW;

if(tmpStrValue == "whiteblue" || tmpStrValue == "1")
return SHIELD_WHITEBLUE;

return SHIELD_NONE;
}

GuildEmblems_t getEmblems(std::string strValue)
{
   std::string tmpStrValue = asLowerCaseString(strValue);
   if(tmpStrValue == "blue" || tmpStrValue == "3")
       return EMBLEM_BLUE;

if(tmpStrValue == "red" || tmpStrValue == "2")
return EMBLEM_RED;

if(tmpStrValue == "green" || tmpStrValue == "1")
return EMBLEM_GREEN;

return EMBLEM_NONE;
}

Direction getDirection(std::string string)
{
if(string == "north" || string == "n" || string == "0")
return NORTH;

if(string == "east" || string == "e" || string == "1")
return EAST;

if(string == "south" || string == "s" || string == "2")
return SOUTH;

if(string == "west" || string == "w" || string == "3")
return WEST;

if(string == "southwest" || string == "south west" || string == "south-west" || string == "sw" || string == "4")
return SOUTHWEST;

if(string == "southeast" || string == "south east" || string == "south-east" || string == "se" || string == "5")
return SOUTHEAST;

if(string == "northwest" || string == "north west" || string == "north-west" || string == "nw" || string == "6")
return NORTHWEST;

if(string == "northeast" || string == "north east" || string == "north-east" || string == "ne" || string == "7")
return NORTHEAST;

return SOUTH;
}

Direction getDirectionTo(Position pos1, Position pos2, bool extended/* = true*/)
{
   Direction direction = NORTH;
   if(pos1.x > pos2.x)
   {
       direction = WEST;
       if(extended)
       {
           if(pos1.y > pos2.y)
               direction = NORTHWEST;
           else if(pos1.y < pos2.y)
               direction = SOUTHWEST;
       }
   }
   else if(pos1.x < pos2.x)
   {
       direction = EAST;
       if(extended)
       {
           if(pos1.y > pos2.y)
               direction = NORTHEAST;
           else if(pos1.y < pos2.y)
               direction = SOUTHEAST;
       }
   }
   else
   {
       if(pos1.y > pos2.y)
           direction = NORTH;
       else if(pos1.y < pos2.y)
           direction = SOUTH;
   }

return direction;
}

Direction getReverseDirection(Direction dir)
{
   switch(dir)
   {
       case NORTH:
           return SOUTH;
       case SOUTH:
           return NORTH;
       case WEST:
           return EAST;
       case EAST:
           return WEST;
       case SOUTHWEST:
           return NORTHEAST;
       case NORTHWEST:
           return SOUTHEAST;
       case NORTHEAST:
           return SOUTHWEST;
       case SOUTHEAST:
           return NORTHWEST;
   }

return SOUTH;
}

Position getNextPosition(Direction direction, Position pos)
{
   switch(direction)
   {
       case NORTH:
           pos.y--;
           break;
       case SOUTH:
           pos.y++;
           break;
       case WEST:
           pos.x--;
           break;
       case EAST:
           pos.x++;
           break;
       case SOUTHWEST:
           pos.x--;
           pos.y++;
           break;
       case NORTHWEST:
           pos.x--;
           pos.y--;
           break;
       case SOUTHEAST:
           pos.x++;
           pos.y++;
           break;
       case NORTHEAST:
           pos.x++;
           pos.y--;
           break;
   }

return pos;
}

struct AmmoTypeNames
{
const char* name;
Ammo_t ammoType;
};

struct MagicEffectNames
{
const char* name;
MagicEffect_t magicEffect;
};

struct ShootTypeNames
{
const char* name;
ShootEffect_t shootType;
};

struct CombatTypeNames
{
const char* name;
CombatType_t combatType;
};

struct AmmoActionNames
{
const char* name;
AmmoAction_t ammoAction;
};

struct FluidTypeNames
{
const char* name;
FluidTypes_t fluidType;
};

struct SkillIdNames
{
const char* name;
skills_t skillId;
};

MagicEffectNames magicEffectNames[] =
{
   {"redspark",       MAGIC_EFFECT_DRAW_BLOOD},
   {"bluebubble",       MAGIC_EFFECT_LOSE_ENERGY},
   {"poff",       MAGIC_EFFECT_POFF},
   {"yellowspark",       MAGIC_EFFECT_BLOCKHIT},
   {"explosionarea",   MAGIC_EFFECT_EXPLOSION_AREA},
   {"explosion",       MAGIC_EFFECT_EXPLOSION_DAMAGE},
   {"firearea",       MAGIC_EFFECT_FIRE_AREA},
   {"yellowbubble",   MAGIC_EFFECT_YELLOW_RINGS},
   {"greenbubble",       MAGIC_EFFECT_POISON_RINGS},
   {"blackspark",       MAGIC_EFFECT_HIT_AREA},
   {"teleport",       MAGIC_EFFECT_TELEPORT},
   {"energy",       MAGIC_EFFECT_ENERGY_DAMAGE},
   {"blueshimmer",       MAGIC_EFFECT_WRAPS_BLUE},
   {"redshimmer",       MAGIC_EFFECT_WRAPS_RED},
   {"greenshimmer",   MAGIC_EFFECT_WRAPS_GREEN},
   {"fire",       MAGIC_EFFECT_HITBY_FIRE},
   {"greenspark",       MAGIC_EFFECT_POISON},
   {"mortarea",       MAGIC_EFFECT_MORT_AREA},
   {"greennote",       MAGIC_EFFECT_SOUND_GREEN},
   {"rednote",       MAGIC_EFFECT_SOUND_RED},
   {"poison",       MAGIC_EFFECT_POISON_AREA},
   {"yellownote",       MAGIC_EFFECT_SOUND_YELLOW},
   {"purplenote",       MAGIC_EFFECT_SOUND_PURPLE},
   {"bluenote",       MAGIC_EFFECT_SOUND_BLUE},
   {"whitenote",       MAGIC_EFFECT_SOUND_WHITE},
   {"bubbles",       MAGIC_EFFECT_BUBBLES},
   {"dice",       MAGIC_EFFECT_CRAPS},
   {"giftwraps",       MAGIC_EFFECT_GIFT_WRAPS},
   {"yellowfirework",   MAGIC_EFFECT_FIREWORK_YELLOW},
   {"redfirework",       MAGIC_EFFECT_FIREWORK_RED},
   {"bluefirework",   MAGIC_EFFECT_FIREWORK_BLUE},
   {"stun",       MAGIC_EFFECT_STUN},
   {"sleep",       MAGIC_EFFECT_SLEEP},
   {"watercreature",   MAGIC_EFFECT_WATERCREATURE},
   {"groundshaker",   MAGIC_EFFECT_GROUNDSHAKER},
   {"hearts",       MAGIC_EFFECT_HEARTS},
   {"fireattack",       MAGIC_EFFECT_FIREATTACK},
   {"energyarea",       MAGIC_EFFECT_ENERGY_AREA},
   {"smallclouds",       MAGIC_EFFECT_SMALLCLOUDS},
   {"holydamage",       MAGIC_EFFECT_HOLYDAMAGE},
   {"bigclouds",       MAGIC_EFFECT_BIGCLOUDS},
   {"icearea",       MAGIC_EFFECT_ICEAREA},
   {"icetornado",       MAGIC_EFFECT_ICETORNADO},
   {"iceattack",       MAGIC_EFFECT_ICEATTACK},
   {"stones",       MAGIC_EFFECT_STONES},
   {"smallplants",       MAGIC_EFFECT_SMALLPLANTS},
   {"carniphila",       MAGIC_EFFECT_CARNIPHILA},
   {"purpleenergy",   MAGIC_EFFECT_PURPLEENERGY},
   {"yellowenergy",   MAGIC_EFFECT_YELLOWENERGY},
   {"holyarea",       MAGIC_EFFECT_HOLYAREA},
   {"bigplants",       MAGIC_EFFECT_BIGPLANTS},
   {"cake",       MAGIC_EFFECT_CAKE},
   {"giantice",       MAGIC_EFFECT_GIANTICE},
   {"watersplash",       MAGIC_EFFECT_WATERSPLASH},
   {"plantattack",       MAGIC_EFFECT_PLANTATTACK},
   {"tutorialarrow",   MAGIC_EFFECT_TUTORIALARROW},
   {"tutorialsquare",   MAGIC_EFFECT_TUTORIALSQUARE},
   {"mirrorhorizontal",   MAGIC_EFFECT_MIRRORHORIZONTAL},
   {"mirrorvertical",   MAGIC_EFFECT_MIRRORVERTICAL},
   {"skullhorizontal",   MAGIC_EFFECT_SKULLHORIZONTAL},
   {"skullvertical",   MAGIC_EFFECT_SKULLVERTICAL},
   {"assassin",       MAGIC_EFFECT_ASSASSIN},
   {"stepshorizontal",   MAGIC_EFFECT_STEPSHORIZONTAL},
   {"bloodysteps",       MAGIC_EFFECT_BLOODYSTEPS},
   {"stepsvertical",   MAGIC_EFFECT_STEPSVERTICAL},
   {"yalaharighost",   MAGIC_EFFECT_YALAHARIGHOST},
   {"bats",       MAGIC_EFFECT_BATS},
   {"smoke",       MAGIC_EFFECT_SMOKE},
   {"insects",       MAGIC_EFFECT_INSECTS},
   {"dragonhead",   MAGIC_EFFECT_DRAGONHEAD}
};

ShootTypeNames shootTypeNames[] =
{
   {"spear",       SHOOT_EFFECT_SPEAR},
   {"bolt",       SHOOT_EFFECT_BOLT},
   {"arrow",       SHOOT_EFFECT_ARROW},
   {"fire",       SHOOT_EFFECT_FIRE},
   {"energy",       SHOOT_EFFECT_ENERGY},
   {"poisonarrow",       SHOOT_EFFECT_POISONARROW},
   {"burstarrow",       SHOOT_EFFECT_BURSTARROW},
   {"throwingstar",   SHOOT_EFFECT_THROWINGSTAR},
   {"throwingknife",   SHOOT_EFFECT_THROWINGKNIFE},
   {"smallstone",       SHOOT_EFFECT_SMALLSTONE},
   {"death",       SHOOT_EFFECT_DEATH},
   {"largerock",       SHOOT_EFFECT_LARGEROCK},
   {"snowball",       SHOOT_EFFECT_SNOWBALL},
   {"powerbolt",       SHOOT_EFFECT_POWERBOLT},
   {"poison",       SHOOT_EFFECT_POISONFIELD},
   {"infernalbolt",   SHOOT_EFFECT_INFERNALBOLT},
   {"huntingspear",   SHOOT_EFFECT_HUNTINGSPEAR},
   {"enchantedspear",   SHOOT_EFFECT_ENCHANTEDSPEAR},
   {"redstar",       SHOOT_EFFECT_REDSTAR},
   {"greenstar",       SHOOT_EFFECT_GREENSTAR},
   {"royalspear",       SHOOT_EFFECT_ROYALSPEAR},
   {"sniperarrow",       SHOOT_EFFECT_SNIPERARROW},
   {"onyxarrow",       SHOOT_EFFECT_ONYXARROW},
   {"piercingbolt",   SHOOT_EFFECT_PIERCINGBOLT},
   {"whirlwindsword",   SHOOT_EFFECT_WHIRLWINDSWORD},
   {"whirlwindaxe",   SHOOT_EFFECT_WHIRLWINDAXE},
   {"whirlwindclub",   SHOOT_EFFECT_WHIRLWINDCLUB},
   {"etherealspear",   SHOOT_EFFECT_ETHEREALSPEAR},
   {"ice",           SHOOT_EFFECT_ICE},
   {"earth",       SHOOT_EFFECT_EARTH},
   {"holy",       SHOOT_EFFECT_HOLY},
   {"suddendeath",       SHOOT_EFFECT_SUDDENDEATH},
   {"flasharrow",       SHOOT_EFFECT_FLASHARROW},
   {"flammingarrow",   SHOOT_EFFECT_FLAMMINGARROW},
   {"flamingarrow",   SHOOT_EFFECT_FLAMMINGARROW},
   {"shiverarrow",       SHOOT_EFFECT_SHIVERARROW},
   {"energyball",       SHOOT_EFFECT_ENERGYBALL},
   {"smallice",       SHOOT_EFFECT_SMALLICE},
   {"smallholy",       SHOOT_EFFECT_SMALLHOLY},
   {"smallearth",       SHOOT_EFFECT_SMALLEARTH},
   {"eartharrow",       SHOOT_EFFECT_EARTHARROW},
   {"explosion",       SHOOT_EFFECT_EXPLOSION},
   {"cake",       SHOOT_EFFECT_CAKE}
};

CombatTypeNames combatTypeNames[] =
{
   {"physical",       COMBAT_PHYSICALDAMAGE},
   {"energy",       COMBAT_ENERGYDAMAGE},
   {"earth",       COMBAT_EARTHDAMAGE},
   {"fire",       COMBAT_FIREDAMAGE},
   {"undefined",       COMBAT_UNDEFINEDDAMAGE},
   {"lifedrain",       COMBAT_LIFEDRAIN},
   {"life drain",       COMBAT_LIFEDRAIN},
   {"manadrain",       COMBAT_MANADRAIN},
   {"mana drain",       COMBAT_MANADRAIN},
   {"healing",       COMBAT_HEALING},
   {"drown",       COMBAT_DROWNDAMAGE},
   {"ice",           COMBAT_ICEDAMAGE},
   {"holy",       COMBAT_HOLYDAMAGE},
   {"death",       COMBAT_DEATHDAMAGE}
};

AmmoTypeNames ammoTypeNames[] =
{
   {"spear",       AMMO_SPEAR},
   {"arrow",       AMMO_ARROW},
   {"poisonarrow",       AMMO_ARROW},
   {"burstarrow",       AMMO_ARROW},
   {"bolt",       AMMO_BOLT},
   {"powerbolt",       AMMO_BOLT},
   {"smallstone",       AMMO_STONE},
   {"largerock",       AMMO_STONE},
   {"throwingstar",   AMMO_THROWINGSTAR},
   {"throwingknife",   AMMO_THROWINGKNIFE},
   {"snowball",       AMMO_SNOWBALL},
   {"huntingspear",   AMMO_SPEAR},
   {"royalspear",       AMMO_SPEAR},
   {"enchantedspear",   AMMO_SPEAR},
   {"sniperarrow",       AMMO_ARROW},
   {"onyxarrow",       AMMO_ARROW},
   {"piercingbolt",   AMMO_BOLT},
   {"infernalbolt",   AMMO_BOLT},
   {"flasharrow",       AMMO_ARROW},
   {"flammingarrow",   AMMO_ARROW},
   {"flamingarrow",   AMMO_ARROW},
   {"shiverarrow",       AMMO_ARROW},
   {"eartharrow",       AMMO_ARROW},
   {"etherealspear",   AMMO_SPEAR}
};

AmmoActionNames ammoActionNames[] =
{
   {"move",       AMMOACTION_MOVE},
   {"moveback",       AMMOACTION_MOVEBACK},
   {"move back",       AMMOACTION_MOVEBACK},
   {"removecharge",   AMMOACTION_REMOVECHARGE},
   {"remove charge",   AMMOACTION_REMOVECHARGE},
   {"removecount",       AMMOACTION_REMOVECOUNT},
   {"remove count",   AMMOACTION_REMOVECOUNT}
};

FluidTypeNames fluidTypeNames[] =
{
   {"none",       FLUID_NONE},
   {"water",       FLUID_WATER},
   {"blood",       FLUID_BLOOD},
   {"beer",       FLUID_BEER},
   {"slime",       FLUID_SLIME},
   {"lemonade",       FLUID_LEMONADE},
   {"milk",       FLUID_MILK},
   {"mana",       FLUID_MANA},
   {"life",       FLUID_LIFE},
   {"oil",           FLUID_OIL},
   {"urine",       FLUID_URINE},
   {"coconutmilk",       FLUID_COCONUTMILK},
   {"coconut milk",   FLUID_COCONUTMILK},
   {"wine",       FLUID_WINE},
   {"mud",           FLUID_MUD},
   {"fruitjuice",       FLUID_FRUITJUICE},
   {"fruit juice",       FLUID_FRUITJUICE},
   {"lava",       FLUID_LAVA},
   {"rum",           FLUID_RUM},
   {"swamp",       FLUID_SWAMP},
   {"tea",           FLUID_TEA},
   {"mead",       FLUID_MEAD}
};

SkillIdNames skillIdNames[] =
{
   {"fist",       SKILL_FIST},
   {"club",       SKILL_CLUB},
   {"sword",       SKILL_SWORD},
   {"axe",           SKILL_AXE},
   {"distance",       SKILL_DIST},
   {"dist",       SKILL_DIST},
   {"shielding",       SKILL_SHIELD},
   {"shield",       SKILL_SHIELD},
   {"fishing",       SKILL_FISH},
   {"fish",       SKILL_FISH},
   {"level",       SKILL__LEVEL},
   {"magiclevel",       SKILL__MAGLEVEL},
   {"magic level",       SKILL__MAGLEVEL}
};

MagicEffect_t getMagicEffect(const std::string& strValue)
{
   for(uint32_t i = 0; i < sizeof(magicEffectNames) / sizeof(MagicEffectNames); ++i)
   {
       if(!strcasecmp(strValue.c_str(), magicEffectNames[i].name))
           return magicEffectNames[i].magicEffect;
   }

return MAGIC_EFFECT_UNKNOWN;
}

ShootEffect_t getShootType(const std::string& strValue)
{
   for(uint32_t i = 0; i < sizeof(shootTypeNames) / sizeof(ShootTypeNames); ++i)
   {
       if(!strcasecmp(strValue.c_str(), shootTypeNames[i].name))
           return shootTypeNames[i].shootType;
   }

return SHOOT_EFFECT_UNKNOWN;
}

CombatType_t getCombatType(const std::string& strValue)
{
   for(uint32_t i = 0; i < sizeof(combatTypeNames) / sizeof(CombatTypeNames); ++i)
   {
       if(!strcasecmp(strValue.c_str(), combatTypeNames[i].name))
           return combatTypeNames[i].combatType;
   }

return COMBAT_NONE;
}

Ammo_t getAmmoType(const std::string& strValue)
{
   for(uint32_t i = 0; i < sizeof(ammoTypeNames) / sizeof(AmmoTypeNames); ++i)
   {
       if(!strcasecmp(strValue.c_str(), ammoTypeNames[i].name))
           return ammoTypeNames[i].ammoType;
   }

return AMMO_NONE;
}

AmmoAction_t getAmmoAction(const std::string& strValue)
{
   for(uint32_t i = 0; i < sizeof(ammoActionNames) / sizeof(AmmoActionNames); ++i)
   {
       if(!strcasecmp(strValue.c_str(), ammoActionNames[i].name))
           return ammoActionNames[i].ammoAction;
   }

return AMMOACTION_NONE;
}

FluidTypes_t getFluidType(const std::string& strValue)
{
   for(uint32_t i = 0; i < sizeof(fluidTypeNames) / sizeof(FluidTypeNames); ++i)
   {
       if(!strcasecmp(strValue.c_str(), fluidTypeNames[i].name))
           return fluidTypeNames[i].fluidType;
   }

return FLUID_NONE;
}

skills_t getSkillId(const std::string& strValue)
{
   for(uint32_t i = 0; i < sizeof(skillIdNames) / sizeof(SkillIdNames); ++i)
   {
       if(!strcasecmp(strValue.c_str(), skillIdNames[i].name))
           return skillIdNames[i].skillId;
   }

return SKILL_FIST;
}

std::string getCombatName(CombatType_t combatType)
{
   switch(combatType)
   {
       case COMBAT_PHYSICALDAMAGE:
           return "physical";
       case COMBAT_ENERGYDAMAGE:
           return "energy";
       case COMBAT_EARTHDAMAGE:
           return "earth";
       case COMBAT_FIREDAMAGE:
           return "fire";
       case COMBAT_UNDEFINEDDAMAGE:
           return "undefined";
       case COMBAT_LIFEDRAIN:
           return "life drain";
       case COMBAT_MANADRAIN:
           return "mana drain";
       case COMBAT_HEALING:
           return "healing";
       case COMBAT_DROWNDAMAGE:
           return "drown";
       case COMBAT_ICEDAMAGE:
           return "ice";
       case COMBAT_HOLYDAMAGE:
           return "holy";
       case COMBAT_DEATHDAMAGE:
           return "death";
       default:
           break;
   }

return "unknown";
}

std::string getSkillName(uint16_t skillId, bool suffix/* = true*/)
{
   switch(skillId)
   {
       case SKILL_FIST:
       {
           std::string tmp = "fist";
           if(suffix)
               tmp += " fighting";

           return tmp;
       }
       case SKILL_CLUB:
       {
           std::string tmp = "club";
           if(suffix)
               tmp += " fighting";

           return tmp;
       }
       case SKILL_SWORD:
       {
           std::string tmp = "sword";
           if(suffix)
               tmp += " fighting";

           return tmp;
       }
       case SKILL_AXE:
       {
           std::string tmp = "axe";
           if(suffix)
               tmp += " fighting";

           return tmp;
       }
       case SKILL_DIST:
       {
           std::string tmp = "distance";
           if(suffix)
               tmp += " fighting";

           return tmp;
       }
       case SKILL_SHIELD:
           return "shielding";
       case SKILL_FISH:
           return "fishing";
       case SKILL__MAGLEVEL:
           return "magic level";
       case SKILL__LEVEL:
           return "level";
       default:
           break;
   }

return "unknown";
}

std::string getReason(int32_t reasonId)
{
   switch(reasonId)
   {
       case 0:
           return "Offensive Name";
       case 1:
           return "Invalid Name Format";
       case 2:
           return "Unsuitable Name";
       case 3:
           return "Name Inciting Rule Violation";
       case 4:
           return "Offensive Statement";
       case 5:
           return "Spamming";
       case 6:
           return "Illegal Advertising";
       case 7:
           return "Off-Topic Public Statement";
       case 8:
           return "Non-English Public Statement";
       case 9:
           return "Inciting Rule Violation";
       case 10:
           return "Bug Abuse";
       case 11:
           return "Game Weakness Abuse";
       case 12:
           return "Using Unofficial Software to Play";
       case 13:
           return "Hacking";
       case 14:
           return "Multi-Clienting";
       case 15:
           return "Account Trading or Sharing";
       case 16:
           return "Threatening Gamemaster";
       case 17:
           return "Pretending to Have Influence on Rule Enforcement";
       case 18:
           return "False Report to Gamemaster";
       case 19:
           return "Destructive Behaviour";
       case 20:
           return "Excessive Unjustified Player Killing";
       default:
           break;
   }

return "Unknown Reason";
}

std::string getAction(ViolationAction_t actionId, bool ipBanishment)
{
   std::string action = "Unknown";
   switch(actionId)
   {
       case ACTION_NOTATION:
           action = "Notation";
           break;
       case ACTION_NAMEREPORT:
           action = "Name Report";
           break;
       case ACTION_BANISHMENT:
           action = "Banishment";
           break;
       case ACTION_BANREPORT:
           action = "Name Report + Banishment";
           break;
       case ACTION_BANFINAL:
           action = "Banishment + Final Warning";
           break;
       case ACTION_BANREPORTFINAL:
           action = "Name Report + Banishment + Final Warning";
           break;
       case ACTION_STATEMENT:
           action = "Statement Report";
           break;
       //internal use
       case ACTION_DELETION:
           action = "Deletion";
           break;
       case ACTION_NAMELOCK:
           action = "Name Lock";
           break;
       case ACTION_BANLOCK:
           action = "Name Lock + Banishment";
           break;
       case ACTION_BANLOCKFINAL:
           action = "Name Lock + Banishment + Final Warning";
           break;
       default:
           break;
   }

if(ipBanishment)
action += " + IP Banishment";

return action;
}

std::string parseVocationString(StringVec vocStringVec)
{
   std::string str = "";
   if(!vocStringVec.empty())
   {
       for(StringVec::iterator it = vocStringVec.begin(); it != vocStringVec.end(); ++it)
       {
           if((*it) != vocStringVec.front())
           {
               if((*it) != vocStringVec.back())
                   str += ", ";
               else
                   str += " and ";
           }

           str += (*it);
           str += "s";
       }
   }

return str;
}

bool parseVocationNode(xmlNodePtr vocationNode, VocationMap& vocationMap, StringVec& vocStringVec, std::string& errorStr)
{
if(xmlStrcmp(vocationNode->name,(const xmlChar*)"vocation"))
return true;

   int32_t vocationId = -1;
   std::string strValue, tmpStrValue;
   if(readXMLString(vocationNode, "name", strValue))
   {
       vocationId = Vocations::getInstance()->getVocationId(strValue);
       if(vocationId != -1)
       {
           vocationMap[vocationId] = true;
           int32_t promotedVocation = Vocations::getInstance()->getPromotedVocation(vocationId);
           if(promotedVocation != -1)
               vocationMap[promotedVocation] = true;
       }
       else
       {
           errorStr = "Wrong vocation name: " + strValue;
           return false;
       }
   }
   else if(readXMLString(vocationNode, "id", strValue))
   {
       IntegerVec intVector;
       if(!parseIntegerVec(strValue, intVector))
       {
           errorStr = "Invalid vocation id - '" + strValue + "'";
           return false;
       }

       size_t size = intVector.size();
       for(size_t i = 0; i < size; ++i)
       {
           Vocation* vocation = Vocations::getInstance()->getVocation(intVector[i]);
           if(vocation && vocation->getName() != "")
           {
               vocationId = vocation->getId();
               strValue = vocation->getName();

               vocationMap[vocationId] = true;
               int32_t promotedVocation = Vocations::getInstance()->getPromotedVocation(vocationId);
               if(promotedVocation != -1)
                   vocationMap[promotedVocation] = true;
           }
           else
           {
               std::stringstream ss;
               ss << "Wrong vocation id: " << intVector[i];

               errorStr = ss.str();
               return false;
           }
       }
   }

if(vocationId != -1 && (!readXMLString(vocationNode, "showInDescription", tmpStrValue) || booleanString(tmpStrValue)))
vocStringVec.push_back(asLowerCaseString(strValue));

return true;
}

bool parseIntegerVec(std::string str, IntegerVec& intVector)
{
   StringVec strVector = explodeString(str, ";");
   IntegerVec tmpIntVector;
   for(StringVec::iterator it = strVector.begin(); it != strVector.end(); ++it)
   {
       tmpIntVector = vectorAtoi(explodeString((*it), "-"));
       if(!tmpIntVector[0] && it->substr(0, 1) != "0")
           continue;

       intVector.push_back(tmpIntVector[0]);
       if(tmpIntVector.size() > 1)
       {
           while(tmpIntVector[0] < tmpIntVector[1])
               intVector.push_back(++tmpIntVector[0]);
       }
   }

return true;
}

bool fileExists(const char* filename)
{
   FILE* f = fopen(filename, "rb");
   if(!f)
       return false;

fclose(f);
return true;
}

uint32_t adlerChecksum(uint8_t* data, size_t length)
{
if(length > NETWORK_MAX_SIZE || !length)
return 0;

   const uint16_t adler = 65521;
   uint32_t a = 1, b = 0;
   while(length > 0)
   {
       size_t tmp = length > 5552 ? 5552 : length;
       length -= tmp;
       do
       {
           a += *data++;
           b += a;
       }
       while(--tmp);
       a %= adler;
       b %= adler;
   }

   return (b << 16) | a;
}

std::string getFilePath(FileType_t type, std::string name/* = ""*/)
{
   #ifdef __FILESYSTEM_HIERARCHY_STANDARD__
   std::string path = "/var/lib/tfs/";
   #endif
   std::string path = g_config.getString(ConfigManager::DATA_DIRECTORY);
   switch(type)
   {
       case FILE_TYPE_OTHER:
           path += name;
           break;
       case FILE_TYPE_XML:
           path += "XML/" + name;
           break;
       case FILE_TYPE_LOG:
           #ifndef __FILESYSTEM_HIERARCHY_STANDARD__
           path = g_config.getString(ConfigManager::LOGS_DIRECTORY) + name;
           #else
           path = "/var/log/tfs/" + name;
           #endif
           break;
       case FILE_TYPE_MOD:
       {
           #ifndef __FILESYSTEM_HIERARCHY_STANDARD__
           path = "mods/" + name;
           #else
           path = "/usr/share/tfs/" + name;
           #endif
           break;
       }
       case FILE_TYPE_CONFIG:
       {
           #if defined(__HOMEDIR_CONF__)
           if(fileExists("~/.tfs/" + name))
               path = "~/.tfs/" + name;
           else
           #endif
           #if defined(__FILESYSTEM_HIERARCHY_STANDARD__)
               path = "/etc/tfs/" + name;
           #else
               path = name;
           #endif
           break;
       }
       default:
           std::clog << "> ERROR: Wrong file type!" << std::endl;
           break;
   }
   return path;
}

Meu dbo base é o rox. Se eu for pegar src de outros dbo não dá erro de incompatibilidade? São muitas perguntas porque sou inexperiente.

Apache · Junho 4, 2022

Em 04/06/2022 em 01:27, gustavoadp disse:

Entendi. Vou procurar mais src então! Só que toda src que eu tento compilar dá vários erros em tools. Estou fazendo errado? Tem algo a ver com o "data", "mods"? Já tentei compilar 3 src diferentes, até de Tibia mesmo e sempre erro nesse tools.cpp. Um exemplo é da src deste tópico daqui. Aparece isso:

Mostrar conteúdo oculto

#include <openssl/sha.h>
#include <openssl/md5.h>

#include "vocation.h"
#include "configmanager.h"

extern ConfigManager g_config;

std::string transformToMD5(std::string plainText, bool upperCase)
{
   MD5_CTX c;
   MD5_Init(&c);
   MD5_Update(&c, plainText.c_str(), plainText.length());

   uint8_t md[MD5_DIGEST_LENGTH];
   MD5_Final(md, &c);

   char output[MD5_DIGEST_LENGTH * 2 + 1] = "";
   for(int32_t i = 0; i < static_cast<int32_t>(sizeof(md)); i++)
       sprintf(output, "%s%.2X", output, md[i]);

   if(upperCase)
       return std::string(output);

   return asLowerCaseString(std::string(output));
}

std::string transformToSHA1(std::string plainText, bool upperCase)
{
   SHA_CTX c;
   SHA1_Init(&c);
   SHA1_Update(&c, plainText.c_str(), plainText.length());

   uint8_t md[SHA_DIGEST_LENGTH];
   SHA1_Final(md, &c);

   char output[SHA_DIGEST_LENGTH * 2 + 1] = "";
   for(int32_t i = 0; i < static_cast<int32_t>(sizeof(md)); i++)
       sprintf(output, "%s%.2X", output, md[i]);

   if(upperCase)
       return std::string(output);

   return asLowerCaseString(std::string(output));
}

std::string transformToSHA256(std::string plainText, bool upperCase)
{
   SHA256_CTX c;
   SHA256_Init(&c);
   SHA256_Update(&c, plainText.c_str(), plainText.length());

   uint8_t md[SHA256_DIGEST_LENGTH];
   SHA256_Final(md, &c);

   char output[SHA256_DIGEST_LENGTH * 2 + 1] = "";
   for(int32_t i = 0; i < static_cast<int32_t>(sizeof(md)); i++)
       sprintf(output, "%s%.2X", output, md[i]);

   if(upperCase)
       return std::string(output);

   return asLowerCaseString(std::string(output));
}

std::string transformToSHA512(std::string plainText, bool upperCase)
{
   SHA512_CTX c;
   SHA512_Init(&c);
   SHA512_Update(&c, plainText.c_str(), plainText.length());

   uint8_t md[SHA512_DIGEST_LENGTH];
   SHA512_Final(md, &c);

   char output[SHA512_DIGEST_LENGTH * 2 + 1] = "";
   for(int32_t i = 0; i < static_cast<int32_t>(sizeof(md)); i++)
       sprintf(output, "%s%.2X", output, md[i]);

   if(upperCase)
       return std::string(output);

   return asLowerCaseString(std::string(output));
}

void _encrypt(std::string& str, bool upperCase)
{
   switch(g_config.getNumber(ConfigManager::ENCRYPTION))
   {
       case ENCRYPTION_MD5:
           str = transformToMD5(str, upperCase);
           break;
       case ENCRYPTION_SHA1:
           str = transformToSHA1(str, upperCase);
           break;
       case ENCRYPTION_SHA256:
           str = transformToSHA256(str, upperCase);
           break;
       case ENCRYPTION_SHA512:
           str = transformToSHA512(str, upperCase);
           break;
       default:
       {
           if(upperCase)
               std::transform(str.begin(), str.end(), str.begin(), upchar);

           break;
       }
   }
}

bool encryptTest(std::string plain, std::string& hash)
{
   std::transform(hash.begin(), hash.end(), hash.begin(), upchar);
   _encrypt(plain, true);
   return plain == hash;
}

bool replaceString(std::string& text, const std::string& key, const std::string& value)
{
   if(text.find(key) == std::string::npos)
       return false;

   std::string::size_type start = 0, pos = 0;
   while((start = text.find(key, pos)) != std::string::npos)
   {
       text.replace(start, key.size(), value);
       //text = text.substr(0, start) + value + text.substr(start + key.size());
       pos = start + value.size();
   }

   return true;
}

void trim_right(std::string& source, const std::string& t)
{
   source.erase(source.find_last_not_of(t) + 1);
}

void trim_left(std::string& source, const std::string& t)
{
   source.erase(0, source.find_first_not_of(t));
}

void toLowerCaseString(std::string& source)
{
   std::transform(source.begin(), source.end(), source.begin(), tolower);
}

void toUpperCaseString(std::string& source)
{
   std::transform(source.begin(), source.end(), source.begin(), upchar);
}

std::string asLowerCaseString(const std::string& source)
{
   std::string s = source;
   toLowerCaseString(s);
   return s;
}

std::string asUpperCaseString(const std::string& source)
{
   std::string s = source;
   toUpperCaseString(s);
   return s;
}

bool booleanString(std::string source)
{
   toLowerCaseString(source);
   return (source == "yes" || source == "true" || atoi(source.c_str()) > 0);
}

bool readXMLInteger(xmlNodePtr node, const char* tag, int32_t& value)
{
   char* nodeValue = (char*)xmlGetProp(node, (xmlChar*)tag);
   if(!nodeValue)
       return false;

   value = atoi(nodeValue);
   xmlFree(nodeValue);
   return true;
}

bool readXMLInteger64(xmlNodePtr node, const char* tag, int64_t& value)
{
   char* nodeValue = (char*)xmlGetProp(node, (xmlChar*)tag);
   if(!nodeValue)
       return false;

   value = atoll(nodeValue);
   xmlFree(nodeValue);
   return true;
}

bool readXMLFloat(xmlNodePtr node, const char* tag, float& value)
{
   char* nodeValue = (char*)xmlGetProp(node, (xmlChar*)tag);
   if(!nodeValue)
       return false;

   value = atof(nodeValue);
   xmlFree(nodeValue);
   return true;
}

bool readXMLString(xmlNodePtr node, const char* tag, std::string& value)
{
   char* nodeValue = (char*)xmlGetProp(node, (xmlChar*)tag);
   if(!nodeValue)
       return false;

   if(!utf8ToLatin1(nodeValue, value))
       value = nodeValue;

   xmlFree(nodeValue);
   return true;
}

bool readXMLContentString(xmlNodePtr node, std::string& value)
{
   char* nodeValue = (char*)xmlNodeGetContent(node);
   if(!nodeValue)
       return false;

   if(!utf8ToLatin1(nodeValue, value))
       value = nodeValue;

   xmlFree(nodeValue);
   return true;
}

bool parseXMLContentString(xmlNodePtr node, std::string& value)
{
   bool result = false;
   std::string compareValue;
   while(node)
   {
       if(xmlStrcmp(node->name, (const xmlChar*)"text") && node->type != XML_CDATA_SECTION_NODE)
       {
           node = node->next;
           continue;
       }

       if(!readXMLContentString(node, compareValue))
       {
           node = node->next;
           continue;
       }

       trim_left(compareValue, "\r");
       trim_left(compareValue, "\n");
       trim_left(compareValue, " ");
       if(compareValue.length() > value.length())
       {
           value = compareValue;
           if(!result)
               result = true;
       }

       node = node->next;
   }

   return result;
}

std::string getLastXMLError()
{
   std::stringstream ss;
   xmlErrorPtr lastError = xmlGetLastError();
   if(lastError->line)
       ss << "Line: " << lastError->line << ", ";

   ss << "Info: " << lastError->message << std::endl;
   return ss.str();
}

bool utf8ToLatin1(char* intext, std::string& outtext)
{
   outtext = "";
   if(!intext)
       return false;

   int32_t inlen = strlen(intext);
   if(!inlen)
       return false;

   int32_t outlen = inlen * 2;
   uint8_t* outbuf = new uint8_t[outlen];

   int32_t res = UTF8Toisolat1(outbuf, &outlen, (uint8_t*)intext, &inlen);
   if(res < 0)
   {
       delete[] outbuf;
       return false;
   }

   outbuf[outlen] = '\0';
   outtext = (char*)outbuf;

   delete[] outbuf;
   return true;
}

StringVec explodeString(const std::string& string, const std::string& separator)
{
   StringVec returnVector;
   size_t start = 0, end = 0;
   while((end = string.find(separator, start)) != std::string::npos)
   {
       returnVector.push_back(string.substr(start, end - start));
       start = end + separator.size();
   }

   returnVector.push_back(string.substr(start));
   return returnVector;
}

IntegerVec vectorAtoi(StringVec stringVector)
{
   IntegerVec returnVector;
   for(StringVec::iterator it = stringVector.begin(); it != stringVector.end(); ++it)
       returnVector.push_back(atoi((*it).c_str()));

   return returnVector;
}

bool hasBitSet(uint32_t flag, uint32_t flags)
{
   return ((flags & flag) == flag);
}

int32_t round(float v)
{
   int32_t t = (int32_t)std::floor(v);
   if((v - t) > 0.5)
       return t + 1;

   return t;
}

uint32_t rand24b()
{
   return ((rand() << 12) ^ (rand())) & (0xFFFFFF);
}

float box_muller(float m, float s)
{
   // normal random variate generator
   // mean m, standard deviation s
   float x1, x2, w, y1;
   static float y2;

   static bool useLast = false;
   if(useLast) // use value from previous call
   {
       y1 = y2;
       useLast = false;
       return (m + y1 * s);
   }

   do
   {
       double r1 = (((float)(rand()) / RAND_MAX));
       double r2 = (((float)(rand()) / RAND_MAX));

       x1 = 2.0 * r1 - 1.0;
       x2 = 2.0 * r2 - 1.0;
       w = x1 * x1 + x2 * x2;
   }
   while(w >= 1.0);
   w = sqrt((-2.0 * log(w)) / w);

   y1 = x1 * w;
   y2 = x2 * w;

   useLast = true;
   return (m + y1 * s);
}

int32_t random_range(int32_t lowestNumber, int32_t highestNumber, DistributionType_t type /*= DISTRO_UNIFORM*/)
{
   if(highestNumber == lowestNumber)
       return lowestNumber;

   if(lowestNumber > highestNumber)
       std::swap(lowestNumber, highestNumber);

   switch(type)
   {
       case DISTRO_UNIFORM:
           return (lowestNumber + ((int32_t)rand24b() % (highestNumber - lowestNumber + 1)));
       case DISTRO_NORMAL:
           return (lowestNumber + int32_t(float(highestNumber - lowestNumber) * (float)std::min((float)1, std::max((float)0, box_muller(0.5, 0.25)))));
       default:
           break;
   }

   const float randMax = 16777216;
   return (lowestNumber + int32_t(float(highestNumber - lowestNumber) * float(1.f - sqrt((1.f * rand24b()) / randMax))));
}

char upchar(char character)
{
   if((character >= 97 && character <= 122) || (character <= -1 && character >= -32))
       character -= 32;

   return character;
}

bool isNumber(char character)
{
   return (character >= 48 && character <= 57);
}

bool isLowercaseLetter(char character)
{
   return (character >= 97 && character <= 122);
}

bool isUppercaseLetter(char character)
{
   return (character >= 65 && character <= 90);
}

bool isPasswordCharacter(char character)
{
   return ((character >= 33 && character <= 47) || (character >= 58 && character <= 64) || (character >= 91 && character <= 96) || (character >= 123 && character <= 126));
}

bool isValidAccountName(std::string text)
{
   toLowerCaseString(text);

   uint32_t textLength = text.length();
   for(uint32_t size = 0; size < textLength; size++)
   {
       if(!isLowercaseLetter(text[size]) && !isNumber(text[size]))
           return false;
   }

   return true;
}

bool isValidPassword(std::string text)
{
   toLowerCaseString(text);

   uint32_t textLength = text.length();
   for(uint32_t size = 0; size < textLength; size++)
   {
       if(!isLowercaseLetter(text[size]) && !isNumber(text[size]) && !isPasswordCharacter(text[size]))
           return false;
   }

   return true;
}

bool isValidName(std::string text, bool forceUppercaseOnFirstLetter/* = true*/)
{
   uint32_t textLength = text.length(), lenBeforeSpace = 1, lenBeforeQuote = 1, lenBeforeDash = 1, repeatedCharacter = 0;
   char lastChar = 32;
   if(forceUppercaseOnFirstLetter)
   {
       if(!isUppercaseLetter(text[0]))
           return false;
   }
   else if(!isLowercaseLetter(text[0]) && !isUppercaseLetter(text[0]))
       return false;

   for(uint32_t size = 1; size < textLength; size++)
   {
       if(text[size] != 32)
       {
           lenBeforeSpace++;
           if(text[size] != 39)
               lenBeforeQuote++;
           else
           {
               if(lenBeforeQuote <= 1 || size == textLength - 1 || text[size + 1] == 32)
                   return false;

               lenBeforeQuote = 0;
           }

           if(text[size] != 45)
               lenBeforeDash++;
           else
           {
               if(lenBeforeDash <= 1 || size == textLength - 1 || text[size + 1] == 32)
                   return false;

               lenBeforeDash = 0;
           }

           if(text[size] == lastChar)
           {
               repeatedCharacter++;
               if(repeatedCharacter > 2)
                   return false;
           }
           else
               repeatedCharacter = 0;

           lastChar = text[size];
       }
       else
       {
           if(lenBeforeSpace <= 1 || size == textLength - 1 || text[size + 1] == 32)
               return false;

           lenBeforeSpace = lenBeforeQuote = lenBeforeDash = 0;
       }

       if(!(isLowercaseLetter(text[size]) || text[size] == 32 || text[size] == 39 || text[size] == 45
           || (isUppercaseLetter(text[size]) && text[size - 1] == 32)))
           return false;
   }

   return true;
}

bool isNumbers(std::string text)
{
   uint32_t textLength = text.length();
   for(uint32_t size = 0; size < textLength; size++)
   {
       if(!isNumber(text[size]))
           return false;
   }

   return true;
}

bool checkText(std::string text, std::string str)
{
   trimString(text);
   return asLowerCaseString(text) == str;
}

std::string generateRecoveryKey(int32_t fieldCount, int32_t fieldLenght, bool mixCase/* = false*/)
{
   std::stringstream key;
   int32_t i = 0, j = 0, lastNumber = 99, number = 0;

   char character = 0, lastCharacter = 0;
   bool madeNumber = false, madeCharacter = false;
   do
   {
       do
       {
           madeNumber = madeCharacter = false;
           if((mixCase && !random_range(0, 2)) || (!mixCase && (bool)random_range(0, 1)))
           {
               number = random_range(2, 9);
               if(number != lastNumber)
               {
                   key << number;
                   lastNumber = number;
                   madeNumber = true;
               }
           }
           else
           {
               if(mixCase && (bool)random_range(0,1) )
                   character = (char)random_range(97, 122);
               else
                   character = (char)random_range(65, 90);

               if(character != lastCharacter)
               {
                   key << character;
                   lastCharacter = character;
                   madeCharacter = true;
               }
           }
       }
       while((!madeCharacter && !madeNumber) ? true : (++j && j < fieldLenght));
       lastCharacter = character = number = j = 0;

       lastNumber = 99;
       if(i < fieldCount - 1)
           key << "-";
   }
   while(++i && i < fieldCount);
   return key.str();
}

std::string trimString(std::string& str)
{
   str.erase(str.find_last_not_of(" ") + 1);
   return str.erase(0, str.find_first_not_of(" "));
}

std::string parseParams(tokenizer::iterator &it, tokenizer::iterator end)
{
   if(it == end)
       return "";

   std::string tmp = (*it);
   ++it;
   if(tmp[0] == '"')
   {
       tmp.erase(0, 1);
       while(it != end && tmp[tmp.length() - 1] != '"')
       {
           tmp += " " + (*it);
           ++it;
       }

       if(tmp.length() > 0 && tmp[tmp.length() - 1] == '"')
           tmp.erase(tmp.length() - 1);
   }

   return tmp;
}

std::string formatDate(time_t _time/* = 0*/)
{
   if(!_time)
       _time = time(NULL);

   const tm* tms = localtime(&_time);
   std::stringstream s;
   if(tms)
       s << tms->tm_mday << "/" << (tms->tm_mon + 1) << "/" << (tms->tm_year + 1900) << " " << tms->tm_hour << ":" << tms->tm_min << ":" << tms->tm_sec;
   else
       s << "UNIX Time: " << (int32_t)_time;

   return s.str();
}

std::string formatDateEx(time_t _time/* = 0*/, std::string format/* = "%d %b %Y, %H:%M:%S"*/)
{
   if(!_time)
       _time = time(NULL);

   const tm* tms = localtime(&_time);
   char buffer[100];
   if(tms)
       strftime(buffer, 25, format.c_str(), tms);
   else
       sprintf(buffer, "UNIX Time: %d", (int32_t)_time);

   return buffer;
}

std::string formatTime(time_t _time/* = 0*/, bool ms/* = false*/)
{
   if(!_time)
       _time = time(NULL);
   else if(ms)
       ms = false;

   const tm* tms = localtime(&_time);
   std::stringstream s;
   if(tms)
   {
       s << tms->tm_hour << ":" << tms->tm_min << ":";
       if(tms->tm_sec < 10)
           s << "0";

       s << tms->tm_sec;
       if(ms)
       {
           timeb t;
           ftime(&t);

           s << "."; // make it format zzz
           if(t.millitm < 10)
               s << "0";

           if(t.millitm < 100)
               s << "0";

           s << t.millitm;
       }
   }
   else
       s << "UNIX Time: " << (int32_t)_time;

   return s.str();
}

std::string convertIPAddress(uint32_t ip)
{
   char buffer[17];
   sprintf(buffer, "%d.%d.%d.%d", ip & 0xFF, (ip >> ? & 0xFF, (ip >> 16) & 0xFF, (ip >> 24));
   return buffer;
}

Skulls_t getSkulls(std::string strValue)
{
   std::string tmpStrValue = asLowerCaseString(strValue);
   if(tmpStrValue == "black" || tmpStrValue == "5")
       return SKULL_BLACK;

   if(tmpStrValue == "red" || tmpStrValue == "4")
       return SKULL_RED;

   if(tmpStrValue == "white" || tmpStrValue == "3")
       return SKULL_WHITE;

   if(tmpStrValue == "green" || tmpStrValue == "2")
       return SKULL_GREEN;

   if(tmpStrValue == "yellow" || tmpStrValue == "1")
       return SKULL_YELLOW;

   return SKULL_NONE;
}

PartyShields_t getShields(std::string strValue)
{
   std::string tmpStrValue = asLowerCaseString(strValue);
   if(tmpStrValue == "whitenoshareoff" || tmpStrValue == "10")
       return SHIELD_YELLOW_NOSHAREDEXP;

   if(tmpStrValue == "blueshareoff" || tmpStrValue == "9")
       return SHIELD_BLUE_NOSHAREDEXP;

   if(tmpStrValue == "yellowshareblink" || tmpStrValue == "8")
       return SHIELD_YELLOW_NOSHAREDEXP_BLINK;

   if(tmpStrValue == "blueshareblink" || tmpStrValue == "7")
       return SHIELD_BLUE_NOSHAREDEXP_BLINK;

   if(tmpStrValue == "yellowshareon" || tmpStrValue == "6")
       return SHIELD_YELLOW_SHAREDEXP;

   if(tmpStrValue == "blueshareon" || tmpStrValue == "5")
       return SHIELD_BLUE_SHAREDEXP;

   if(tmpStrValue == "yellow" || tmpStrValue == "4")
       return SHIELD_YELLOW;

   if(tmpStrValue == "blue" || tmpStrValue == "3")
       return SHIELD_BLUE;

   if(tmpStrValue == "whiteyellow" || tmpStrValue == "2")
       return SHIELD_WHITEYELLOW;

   if(tmpStrValue == "whiteblue" || tmpStrValue == "1")
       return SHIELD_WHITEBLUE;

   return SHIELD_NONE;
}

GuildEmblems_t getEmblems(std::string strValue)
{
   std::string tmpStrValue = asLowerCaseString(strValue);
   if(tmpStrValue == "blue" || tmpStrValue == "3")
       return EMBLEM_BLUE;

   if(tmpStrValue == "red" || tmpStrValue == "2")
       return EMBLEM_RED;

   if(tmpStrValue == "green" || tmpStrValue == "1")
       return EMBLEM_GREEN;

   return EMBLEM_NONE;
}

Direction getDirection(std::string string)
{
   if(string == "north" || string == "n" || string == "0")
       return NORTH;

   if(string == "east" || string == "e" || string == "1")
       return EAST;

   if(string == "south" || string == "s" || string == "2")
       return SOUTH;

   if(string == "west" || string == "w" || string == "3")
       return WEST;

   if(string == "southwest" || string == "south west" || string == "south-west" || string == "sw" || string == "4")
       return SOUTHWEST;

   if(string == "southeast" || string == "south east" || string == "south-east" || string == "se" || string == "5")
       return SOUTHEAST;

   if(string == "northwest" || string == "north west" || string == "north-west" || string == "nw" || string == "6")
       return NORTHWEST;

   if(string == "northeast" || string == "north east" || string == "north-east" || string == "ne" || string == "7")
       return NORTHEAST;

   return SOUTH;
}

Direction getDirectionTo(Position pos1, Position pos2, bool extended/* = true*/)
{
   Direction direction = NORTH;
   if(pos1.x > pos2.x)
   {
       direction = WEST;
       if(extended)
       {
           if(pos1.y > pos2.y)
               direction = NORTHWEST;
           else if(pos1.y < pos2.y)
               direction = SOUTHWEST;
       }
   }
   else if(pos1.x < pos2.x)
   {
       direction = EAST;
       if(extended)
       {
           if(pos1.y > pos2.y)
               direction = NORTHEAST;
           else if(pos1.y < pos2.y)
               direction = SOUTHEAST;
       }
   }
   else
   {
       if(pos1.y > pos2.y)
           direction = NORTH;
       else if(pos1.y < pos2.y)
           direction = SOUTH;
   }

   return direction;
}

Direction getReverseDirection(Direction dir)
{
   switch(dir)
   {
       case NORTH:
           return SOUTH;
       case SOUTH:
           return NORTH;
       case WEST:
           return EAST;
       case EAST:
           return WEST;
       case SOUTHWEST:
           return NORTHEAST;
       case NORTHWEST:
           return SOUTHEAST;
       case NORTHEAST:
           return SOUTHWEST;
       case SOUTHEAST:
           return NORTHWEST;
   }

   return SOUTH;
}

Position getNextPosition(Direction direction, Position pos)
{
   switch(direction)
   {
       case NORTH:
           pos.y--;
           break;
       case SOUTH:
           pos.y++;
           break;
       case WEST:
           pos.x--;
           break;
       case EAST:
           pos.x++;
           break;
       case SOUTHWEST:
           pos.x--;
           pos.y++;
           break;
       case NORTHWEST:
           pos.x--;
           pos.y--;
           break;
       case SOUTHEAST:
           pos.x++;
           pos.y++;
           break;
       case NORTHEAST:
           pos.x++;
           pos.y--;
           break;
   }

   return pos;
}

struct AmmoTypeNames
{
   const char* name;
   Ammo_t ammoType;
};

struct MagicEffectNames
{
   const char* name;
   MagicEffect_t magicEffect;
};

struct ShootTypeNames
{
   const char* name;
   ShootEffect_t shootType;
};

struct CombatTypeNames
{
   const char* name;
   CombatType_t combatType;
};

struct AmmoActionNames
{
   const char* name;
   AmmoAction_t ammoAction;
};

struct FluidTypeNames
{
   const char* name;
   FluidTypes_t fluidType;
};

struct SkillIdNames
{
   const char* name;
   skills_t skillId;
};

MagicEffectNames magicEffectNames[] =
{
   {"redspark",       MAGIC_EFFECT_DRAW_BLOOD},
   {"bluebubble",       MAGIC_EFFECT_LOSE_ENERGY},
   {"poff",       MAGIC_EFFECT_POFF},
   {"yellowspark",       MAGIC_EFFECT_BLOCKHIT},
   {"explosionarea",   MAGIC_EFFECT_EXPLOSION_AREA},
   {"explosion",       MAGIC_EFFECT_EXPLOSION_DAMAGE},
   {"firearea",       MAGIC_EFFECT_FIRE_AREA},
   {"yellowbubble",   MAGIC_EFFECT_YELLOW_RINGS},
   {"greenbubble",       MAGIC_EFFECT_POISON_RINGS},
   {"blackspark",       MAGIC_EFFECT_HIT_AREA},
   {"teleport",       MAGIC_EFFECT_TELEPORT},
   {"energy",       MAGIC_EFFECT_ENERGY_DAMAGE},
   {"blueshimmer",       MAGIC_EFFECT_WRAPS_BLUE},
   {"redshimmer",       MAGIC_EFFECT_WRAPS_RED},
   {"greenshimmer",   MAGIC_EFFECT_WRAPS_GREEN},
   {"fire",       MAGIC_EFFECT_HITBY_FIRE},
   {"greenspark",       MAGIC_EFFECT_POISON},
   {"mortarea",       MAGIC_EFFECT_MORT_AREA},
   {"greennote",       MAGIC_EFFECT_SOUND_GREEN},
   {"rednote",       MAGIC_EFFECT_SOUND_RED},
   {"poison",       MAGIC_EFFECT_POISON_AREA},
   {"yellownote",       MAGIC_EFFECT_SOUND_YELLOW},
   {"purplenote",       MAGIC_EFFECT_SOUND_PURPLE},
   {"bluenote",       MAGIC_EFFECT_SOUND_BLUE},
   {"whitenote",       MAGIC_EFFECT_SOUND_WHITE},
   {"bubbles",       MAGIC_EFFECT_BUBBLES},
   {"dice",       MAGIC_EFFECT_CRAPS},
   {"giftwraps",       MAGIC_EFFECT_GIFT_WRAPS},
   {"yellowfirework",   MAGIC_EFFECT_FIREWORK_YELLOW},
   {"redfirework",       MAGIC_EFFECT_FIREWORK_RED},
   {"bluefirework",   MAGIC_EFFECT_FIREWORK_BLUE},
   {"stun",       MAGIC_EFFECT_STUN},
   {"sleep",       MAGIC_EFFECT_SLEEP},
   {"watercreature",   MAGIC_EFFECT_WATERCREATURE},
   {"groundshaker",   MAGIC_EFFECT_GROUNDSHAKER},
   {"hearts",       MAGIC_EFFECT_HEARTS},
   {"fireattack",       MAGIC_EFFECT_FIREATTACK},
   {"energyarea",       MAGIC_EFFECT_ENERGY_AREA},
   {"smallclouds",       MAGIC_EFFECT_SMALLCLOUDS},
   {"holydamage",       MAGIC_EFFECT_HOLYDAMAGE},
   {"bigclouds",       MAGIC_EFFECT_BIGCLOUDS},
   {"icearea",       MAGIC_EFFECT_ICEAREA},
   {"icetornado",       MAGIC_EFFECT_ICETORNADO},
   {"iceattack",       MAGIC_EFFECT_ICEATTACK},
   {"stones",       MAGIC_EFFECT_STONES},
   {"smallplants",       MAGIC_EFFECT_SMALLPLANTS},
   {"carniphila",       MAGIC_EFFECT_CARNIPHILA},
   {"purpleenergy",   MAGIC_EFFECT_PURPLEENERGY},
   {"yellowenergy",   MAGIC_EFFECT_YELLOWENERGY},
   {"holyarea",       MAGIC_EFFECT_HOLYAREA},
   {"bigplants",       MAGIC_EFFECT_BIGPLANTS},
   {"cake",       MAGIC_EFFECT_CAKE},
   {"giantice",       MAGIC_EFFECT_GIANTICE},
   {"watersplash",       MAGIC_EFFECT_WATERSPLASH},
   {"plantattack",       MAGIC_EFFECT_PLANTATTACK},
   {"tutorialarrow",   MAGIC_EFFECT_TUTORIALARROW},
   {"tutorialsquare",   MAGIC_EFFECT_TUTORIALSQUARE},
   {"mirrorhorizontal",   MAGIC_EFFECT_MIRRORHORIZONTAL},
   {"mirrorvertical",   MAGIC_EFFECT_MIRRORVERTICAL},
   {"skullhorizontal",   MAGIC_EFFECT_SKULLHORIZONTAL},
   {"skullvertical",   MAGIC_EFFECT_SKULLVERTICAL},
   {"assassin",       MAGIC_EFFECT_ASSASSIN},
   {"stepshorizontal",   MAGIC_EFFECT_STEPSHORIZONTAL},
   {"bloodysteps",       MAGIC_EFFECT_BLOODYSTEPS},
   {"stepsvertical",   MAGIC_EFFECT_STEPSVERTICAL},
   {"yalaharighost",   MAGIC_EFFECT_YALAHARIGHOST},
   {"bats",       MAGIC_EFFECT_BATS},
   {"smoke",       MAGIC_EFFECT_SMOKE},
   {"insects",       MAGIC_EFFECT_INSECTS},
   {"dragonhead",   MAGIC_EFFECT_DRAGONHEAD}
};

ShootTypeNames shootTypeNames[] =
{
   {"spear",       SHOOT_EFFECT_SPEAR},
   {"bolt",       SHOOT_EFFECT_BOLT},
   {"arrow",       SHOOT_EFFECT_ARROW},
   {"fire",       SHOOT_EFFECT_FIRE},
   {"energy",       SHOOT_EFFECT_ENERGY},
   {"poisonarrow",       SHOOT_EFFECT_POISONARROW},
   {"burstarrow",       SHOOT_EFFECT_BURSTARROW},
   {"throwingstar",   SHOOT_EFFECT_THROWINGSTAR},
   {"throwingknife",   SHOOT_EFFECT_THROWINGKNIFE},
   {"smallstone",       SHOOT_EFFECT_SMALLSTONE},
   {"death",       SHOOT_EFFECT_DEATH},
   {"largerock",       SHOOT_EFFECT_LARGEROCK},
   {"snowball",       SHOOT_EFFECT_SNOWBALL},
   {"powerbolt",       SHOOT_EFFECT_POWERBOLT},
   {"poison",       SHOOT_EFFECT_POISONFIELD},
   {"infernalbolt",   SHOOT_EFFECT_INFERNALBOLT},
   {"huntingspear",   SHOOT_EFFECT_HUNTINGSPEAR},
   {"enchantedspear",   SHOOT_EFFECT_ENCHANTEDSPEAR},
   {"redstar",       SHOOT_EFFECT_REDSTAR},
   {"greenstar",       SHOOT_EFFECT_GREENSTAR},
   {"royalspear",       SHOOT_EFFECT_ROYALSPEAR},
   {"sniperarrow",       SHOOT_EFFECT_SNIPERARROW},
   {"onyxarrow",       SHOOT_EFFECT_ONYXARROW},
   {"piercingbolt",   SHOOT_EFFECT_PIERCINGBOLT},
   {"whirlwindsword",   SHOOT_EFFECT_WHIRLWINDSWORD},
   {"whirlwindaxe",   SHOOT_EFFECT_WHIRLWINDAXE},
   {"whirlwindclub",   SHOOT_EFFECT_WHIRLWINDCLUB},
   {"etherealspear",   SHOOT_EFFECT_ETHEREALSPEAR},
   {"ice",           SHOOT_EFFECT_ICE},
   {"earth",       SHOOT_EFFECT_EARTH},
   {"holy",       SHOOT_EFFECT_HOLY},
   {"suddendeath",       SHOOT_EFFECT_SUDDENDEATH},
   {"flasharrow",       SHOOT_EFFECT_FLASHARROW},
   {"flammingarrow",   SHOOT_EFFECT_FLAMMINGARROW},
   {"flamingarrow",   SHOOT_EFFECT_FLAMMINGARROW},
   {"shiverarrow",       SHOOT_EFFECT_SHIVERARROW},
   {"energyball",       SHOOT_EFFECT_ENERGYBALL},
   {"smallice",       SHOOT_EFFECT_SMALLICE},
   {"smallholy",       SHOOT_EFFECT_SMALLHOLY},
   {"smallearth",       SHOOT_EFFECT_SMALLEARTH},
   {"eartharrow",       SHOOT_EFFECT_EARTHARROW},
   {"explosion",       SHOOT_EFFECT_EXPLOSION},
   {"cake",       SHOOT_EFFECT_CAKE}
};

CombatTypeNames combatTypeNames[] =
{
   {"physical",       COMBAT_PHYSICALDAMAGE},
   {"energy",       COMBAT_ENERGYDAMAGE},
   {"earth",       COMBAT_EARTHDAMAGE},
   {"fire",       COMBAT_FIREDAMAGE},
   {"undefined",       COMBAT_UNDEFINEDDAMAGE},
   {"lifedrain",       COMBAT_LIFEDRAIN},
   {"life drain",       COMBAT_LIFEDRAIN},
   {"manadrain",       COMBAT_MANADRAIN},
   {"mana drain",       COMBAT_MANADRAIN},
   {"healing",       COMBAT_HEALING},
   {"drown",       COMBAT_DROWNDAMAGE},
   {"ice",           COMBAT_ICEDAMAGE},
   {"holy",       COMBAT_HOLYDAMAGE},
   {"death",       COMBAT_DEATHDAMAGE}
};

AmmoTypeNames ammoTypeNames[] =
{
   {"spear",       AMMO_SPEAR},
   {"arrow",       AMMO_ARROW},
   {"poisonarrow",       AMMO_ARROW},
   {"burstarrow",       AMMO_ARROW},
   {"bolt",       AMMO_BOLT},
   {"powerbolt",       AMMO_BOLT},
   {"smallstone",       AMMO_STONE},
   {"largerock",       AMMO_STONE},
   {"throwingstar",   AMMO_THROWINGSTAR},
   {"throwingknife",   AMMO_THROWINGKNIFE},
   {"snowball",       AMMO_SNOWBALL},
   {"huntingspear",   AMMO_SPEAR},
   {"royalspear",       AMMO_SPEAR},
   {"enchantedspear",   AMMO_SPEAR},
   {"sniperarrow",       AMMO_ARROW},
   {"onyxarrow",       AMMO_ARROW},
   {"piercingbolt",   AMMO_BOLT},
   {"infernalbolt",   AMMO_BOLT},
   {"flasharrow",       AMMO_ARROW},
   {"flammingarrow",   AMMO_ARROW},
   {"flamingarrow",   AMMO_ARROW},
   {"shiverarrow",       AMMO_ARROW},
   {"eartharrow",       AMMO_ARROW},
   {"etherealspear",   AMMO_SPEAR}
};

AmmoActionNames ammoActionNames[] =
{
   {"move",       AMMOACTION_MOVE},
   {"moveback",       AMMOACTION_MOVEBACK},
   {"move back",       AMMOACTION_MOVEBACK},
   {"removecharge",   AMMOACTION_REMOVECHARGE},
   {"remove charge",   AMMOACTION_REMOVECHARGE},
   {"removecount",       AMMOACTION_REMOVECOUNT},
   {"remove count",   AMMOACTION_REMOVECOUNT}
};

FluidTypeNames fluidTypeNames[] =
{
   {"none",       FLUID_NONE},
   {"water",       FLUID_WATER},
   {"blood",       FLUID_BLOOD},
   {"beer",       FLUID_BEER},
   {"slime",       FLUID_SLIME},
   {"lemonade",       FLUID_LEMONADE},
   {"milk",       FLUID_MILK},
   {"mana",       FLUID_MANA},
   {"life",       FLUID_LIFE},
   {"oil",           FLUID_OIL},
   {"urine",       FLUID_URINE},
   {"coconutmilk",       FLUID_COCONUTMILK},
   {"coconut milk",   FLUID_COCONUTMILK},
   {"wine",       FLUID_WINE},
   {"mud",           FLUID_MUD},
   {"fruitjuice",       FLUID_FRUITJUICE},
   {"fruit juice",       FLUID_FRUITJUICE},
   {"lava",       FLUID_LAVA},
   {"rum",           FLUID_RUM},
   {"swamp",       FLUID_SWAMP},
   {"tea",           FLUID_TEA},
   {"mead",       FLUID_MEAD}
};

SkillIdNames skillIdNames[] =
{
   {"fist",       SKILL_FIST},
   {"club",       SKILL_CLUB},
   {"sword",       SKILL_SWORD},
   {"axe",           SKILL_AXE},
   {"distance",       SKILL_DIST},
   {"dist",       SKILL_DIST},
   {"shielding",       SKILL_SHIELD},
   {"shield",       SKILL_SHIELD},
   {"fishing",       SKILL_FISH},
   {"fish",       SKILL_FISH},
   {"level",       SKILL__LEVEL},
   {"magiclevel",       SKILL__MAGLEVEL},
   {"magic level",       SKILL__MAGLEVEL}
};

MagicEffect_t getMagicEffect(const std::string& strValue)
{
   for(uint32_t i = 0; i < sizeof(magicEffectNames) / sizeof(MagicEffectNames); ++i)
   {
       if(!strcasecmp(strValue.c_str(), magicEffectNames[i].name))
           return magicEffectNames[i].magicEffect;
   }

   return MAGIC_EFFECT_UNKNOWN;
}

ShootEffect_t getShootType(const std::string& strValue)
{
   for(uint32_t i = 0; i < sizeof(shootTypeNames) / sizeof(ShootTypeNames); ++i)
   {
       if(!strcasecmp(strValue.c_str(), shootTypeNames[i].name))
           return shootTypeNames[i].shootType;
   }

   return SHOOT_EFFECT_UNKNOWN;
}

CombatType_t getCombatType(const std::string& strValue)
{
   for(uint32_t i = 0; i < sizeof(combatTypeNames) / sizeof(CombatTypeNames); ++i)
   {
       if(!strcasecmp(strValue.c_str(), combatTypeNames[i].name))
           return combatTypeNames[i].combatType;
   }

   return COMBAT_NONE;
}

Ammo_t getAmmoType(const std::string& strValue)
{
   for(uint32_t i = 0; i < sizeof(ammoTypeNames) / sizeof(AmmoTypeNames); ++i)
   {
       if(!strcasecmp(strValue.c_str(), ammoTypeNames[i].name))
           return ammoTypeNames[i].ammoType;
   }

   return AMMO_NONE;
}

AmmoAction_t getAmmoAction(const std::string& strValue)
{
   for(uint32_t i = 0; i < sizeof(ammoActionNames) / sizeof(AmmoActionNames); ++i)
   {
       if(!strcasecmp(strValue.c_str(), ammoActionNames[i].name))
           return ammoActionNames[i].ammoAction;
   }

   return AMMOACTION_NONE;
}

FluidTypes_t getFluidType(const std::string& strValue)
{
   for(uint32_t i = 0; i < sizeof(fluidTypeNames) / sizeof(FluidTypeNames); ++i)
   {
       if(!strcasecmp(strValue.c_str(), fluidTypeNames[i].name))
           return fluidTypeNames[i].fluidType;
   }

   return FLUID_NONE;
}

skills_t getSkillId(const std::string& strValue)
{
   for(uint32_t i = 0; i < sizeof(skillIdNames) / sizeof(SkillIdNames); ++i)
   {
       if(!strcasecmp(strValue.c_str(), skillIdNames[i].name))
           return skillIdNames[i].skillId;
   }

   return SKILL_FIST;
}

std::string getCombatName(CombatType_t combatType)
{
   switch(combatType)
   {
       case COMBAT_PHYSICALDAMAGE:
           return "physical";
       case COMBAT_ENERGYDAMAGE:
           return "energy";
       case COMBAT_EARTHDAMAGE:
           return "earth";
       case COMBAT_FIREDAMAGE:
           return "fire";
       case COMBAT_UNDEFINEDDAMAGE:
           return "undefined";
       case COMBAT_LIFEDRAIN:
           return "life drain";
       case COMBAT_MANADRAIN:
           return "mana drain";
       case COMBAT_HEALING:
           return "healing";
       case COMBAT_DROWNDAMAGE:
           return "drown";
       case COMBAT_ICEDAMAGE:
           return "ice";
       case COMBAT_HOLYDAMAGE:
           return "holy";
       case COMBAT_DEATHDAMAGE:
           return "death";
       default:
           break;
   }

   return "unknown";
}

std::string getSkillName(uint16_t skillId, bool suffix/* = true*/)
{
   switch(skillId)
   {
       case SKILL_FIST:
       {
           std::string tmp = "fist";
           if(suffix)
               tmp += " fighting";

           return tmp;
       }
       case SKILL_CLUB:
       {
           std::string tmp = "club";
           if(suffix)
               tmp += " fighting";

           return tmp;
       }
       case SKILL_SWORD:
       {
           std::string tmp = "sword";
           if(suffix)
               tmp += " fighting";

           return tmp;
       }
       case SKILL_AXE:
       {
           std::string tmp = "axe";
           if(suffix)
               tmp += " fighting";

           return tmp;
       }
       case SKILL_DIST:
       {
           std::string tmp = "distance";
           if(suffix)
               tmp += " fighting";

           return tmp;
       }
       case SKILL_SHIELD:
           return "shielding";
       case SKILL_FISH:
           return "fishing";
       case SKILL__MAGLEVEL:
           return "magic level";
       case SKILL__LEVEL:
           return "level";
       default:
           break;
   }

   return "unknown";
}

std::string getReason(int32_t reasonId)
{
   switch(reasonId)
   {
       case 0:
           return "Offensive Name";
       case 1:
           return "Invalid Name Format";
       case 2:
           return "Unsuitable Name";
       case 3:
           return "Name Inciting Rule Violation";
       case 4:
           return "Offensive Statement";
       case 5:
           return "Spamming";
       case 6:
           return "Illegal Advertising";
       case 7:
           return "Off-Topic Public Statement";
       case 8:
           return "Non-English Public Statement";
       case 9:
           return "Inciting Rule Violation";
       case 10:
           return "Bug Abuse";
       case 11:
           return "Game Weakness Abuse";
       case 12:
           return "Using Unofficial Software to Play";
       case 13:
           return "Hacking";
       case 14:
           return "Multi-Clienting";
       case 15:
           return "Account Trading or Sharing";
       case 16:
           return "Threatening Gamemaster";
       case 17:
           return "Pretending to Have Influence on Rule Enforcement";
       case 18:
           return "False Report to Gamemaster";
       case 19:
           return "Destructive Behaviour";
       case 20:
           return "Excessive Unjustified Player Killing";
       default:
           break;
   }

   return "Unknown Reason";
}

std::string getAction(ViolationAction_t actionId, bool ipBanishment)
{
   std::string action = "Unknown";
   switch(actionId)
   {
       case ACTION_NOTATION:
           action = "Notation";
           break;
       case ACTION_NAMEREPORT:
           action = "Name Report";
           break;
       case ACTION_BANISHMENT:
           action = "Banishment";
           break;
       case ACTION_BANREPORT:
           action = "Name Report + Banishment";
           break;
       case ACTION_BANFINAL:
           action = "Banishment + Final Warning";
           break;
       case ACTION_BANREPORTFINAL:
           action = "Name Report + Banishment + Final Warning";
           break;
       case ACTION_STATEMENT:
           action = "Statement Report";
           break;
       //internal use
       case ACTION_DELETION:
           action = "Deletion";
           break;
       case ACTION_NAMELOCK:
           action = "Name Lock";
           break;
       case ACTION_BANLOCK:
           action = "Name Lock + Banishment";
           break;
       case ACTION_BANLOCKFINAL:
           action = "Name Lock + Banishment + Final Warning";
           break;
       default:
           break;
   }

   if(ipBanishment)
       action += " + IP Banishment";

   return action;
}

std::string parseVocationString(StringVec vocStringVec)
{
   std::string str = "";
   if(!vocStringVec.empty())
   {
       for(StringVec::iterator it = vocStringVec.begin(); it != vocStringVec.end(); ++it)
       {
           if((*it) != vocStringVec.front())
           {
               if((*it) != vocStringVec.back())
                   str += ", ";
               else
                   str += " and ";
           }

           str += (*it);
           str += "s";
       }
   }

   return str;
}

bool parseVocationNode(xmlNodePtr vocationNode, VocationMap& vocationMap, StringVec& vocStringVec, std::string& errorStr)
{
   if(xmlStrcmp(vocationNode->name,(const xmlChar*)"vocation"))
       return true;

   int32_t vocationId = -1;
   std::string strValue, tmpStrValue;
   if(readXMLString(vocationNode, "name", strValue))
   {
       vocationId = Vocations::getInstance()->getVocationId(strValue);
       if(vocationId != -1)
       {
           vocationMap[vocationId] = true;
           int32_t promotedVocation = Vocations::getInstance()->getPromotedVocation(vocationId);
           if(promotedVocation != -1)
               vocationMap[promotedVocation] = true;
       }
       else
       {
           errorStr = "Wrong vocation name: " + strValue;
           return false;
       }
   }
   else if(readXMLString(vocationNode, "id", strValue))
   {
       IntegerVec intVector;
       if(!parseIntegerVec(strValue, intVector))
       {
           errorStr = "Invalid vocation id - '" + strValue + "'";
           return false;
       }

       size_t size = intVector.size();
       for(size_t i = 0; i < size; ++i)
       {
           Vocation* vocation = Vocations::getInstance()->getVocation(intVector[i]);
           if(vocation && vocation->getName() != "")
           {
               vocationId = vocation->getId();
               strValue = vocation->getName();

               vocationMap[vocationId] = true;
               int32_t promotedVocation = Vocations::getInstance()->getPromotedVocation(vocationId);
               if(promotedVocation != -1)
                   vocationMap[promotedVocation] = true;
           }
           else
           {
               std::stringstream ss;
               ss << "Wrong vocation id: " << intVector[i];

               errorStr = ss.str();
               return false;
           }
       }
   }

   if(vocationId != -1 && (!readXMLString(vocationNode, "showInDescription", tmpStrValue) || booleanString(tmpStrValue)))
       vocStringVec.push_back(asLowerCaseString(strValue));

   return true;
}

bool parseIntegerVec(std::string str, IntegerVec& intVector)
{
   StringVec strVector = explodeString(str, ";");
   IntegerVec tmpIntVector;
   for(StringVec::iterator it = strVector.begin(); it != strVector.end(); ++it)
   {
       tmpIntVector = vectorAtoi(explodeString((*it), "-"));
       if(!tmpIntVector[0] && it->substr(0, 1) != "0")
           continue;

       intVector.push_back(tmpIntVector[0]);
       if(tmpIntVector.size() > 1)
       {
           while(tmpIntVector[0] < tmpIntVector[1])
               intVector.push_back(++tmpIntVector[0]);
       }
   }

   return true;
}

bool fileExists(const char* filename)
{
   FILE* f = fopen(filename, "rb");
   if(!f)
       return false;

   fclose(f);
   return true;
}

uint32_t adlerChecksum(uint8_t* data, size_t length)
{
   if(length > NETWORK_MAX_SIZE || !length)
       return 0;

   const uint16_t adler = 65521;
   uint32_t a = 1, b = 0;
   while(length > 0)
   {
       size_t tmp = length > 5552 ? 5552 : length;
       length -= tmp;
       do
       {
           a += *data++;
           b += a;
       }
       while(--tmp);
       a %= adler;
       b %= adler;
   }

   return (b << 16) | a;
}

std::string getFilePath(FileType_t type, std::string name/* = ""*/)
{
   #ifdef __FILESYSTEM_HIERARCHY_STANDARD__
   std::string path = "/var/lib/tfs/";
   #endif
   std::string path = g_config.getString(ConfigManager::DATA_DIRECTORY);
   switch(type)
   {
       case FILE_TYPE_OTHER:
           path += name;
           break;
       case FILE_TYPE_XML:
           path += "XML/" + name;
           break;
       case FILE_TYPE_LOG:
           #ifndef __FILESYSTEM_HIERARCHY_STANDARD__
           path = g_config.getString(ConfigManager::LOGS_DIRECTORY) + name;
           #else
           path = "/var/log/tfs/" + name;
           #endif
           break;
       case FILE_TYPE_MOD:
       {
           #ifndef __FILESYSTEM_HIERARCHY_STANDARD__
           path = "mods/" + name;
           #else
           path = "/usr/share/tfs/" + name;
           #endif
           break;
       }
       case FILE_TYPE_CONFIG:
       {
           #if defined(__HOMEDIR_CONF__)
           if(fileExists("~/.tfs/" + name))
               path = "~/.tfs/" + name;
           else
           #endif
           #if defined(__FILESYSTEM_HIERARCHY_STANDARD__)
               path = "/etc/tfs/" + name;
           #else
               path = name;
           #endif
           break;
       }
       default:
           std::clog << "> ERROR: Wrong file type!" << std::endl;
           break;
   }
   return path;
}

Meu dbo base é o rox. Se eu for pegar src de outros dbo não dá erro de incompatibilidade? São muitas perguntas porque sou inexperiente.

Mostrar mais

cara só se o servidor tiver sistemas que tenham funções na source, esse dbo rox ai acredito que não tenha, obviu que você vai ter que passar a src pra uint_16 ou 32 n lembro o numero faz tempo que não mexo com derivado

gustavoadp · Junho 4, 2022

Em 04/06/2022 em 03:48, Apache disse:

cara só se o servidor tiver sistemas que tenham funções na source, esse dbo rox ai acredito que não tenha, obviu que você vai ter que passar a src pra uint_16 ou 32 n lembro o numero faz tempo que não mexo com derivado

Expand Mostrar mais

Ontem procurei muito sources e distros e não achei NADA. As mais próximas que eu tinha eram a do dbo rox, já que veio junto com o server, e a deste tópico daqui, que vejo muita gente falando da do @Fir3element e o @bringsz passou ela pra dbo. Quanto à compilação, vi que o erro era algo que eu tava fazendo, já que compilando sources diferentes dava o erro parecido. Então vi que eu não tinha instalado o pack do Open SSL kkkkk...

Aí fiz o seguinte: compilei a src deste tópico, mas não tinha arquivos dll, só o executável. Como sou muito leigo e não encontrei respostas, eu só substituí o executável.

Aí liguei o ot, não deu nenhum erro. Fui testar meu problema principal, que é o das mortes depois do pvp e está tudo ok. Até agora não estou tendo nenhum erro. Será que essa misturada que eu dei pode aparecer algo grave?

Obrigado pela atenção,

Entrar

Sources para [DBO]

Posts Recomendados

gustavoadp 0

Link para o post

Compartilhar em outros sites

Top Posters In This Topic

Popular Days

Top Posters In This Topic

Popular Days

Popular Posts

bringsz

netoxdd

Apache

Apache 149

Link para o post

Compartilhar em outros sites

gustavoadp 0

Link para o post

Compartilhar em outros sites

Apache 149

Link para o post

Compartilhar em outros sites

gustavoadp 0

Link para o post

Compartilhar em outros sites

Participe da conversa

Quem Está Navegando 0 membros estão online

Estatísticas dos Fóruns

TibiaKing

Open Tibia Server

Redes Sociais

Anuncie no TibiaKing

Fóruns

Cursos TibiaKing

Informação Importante