////////////////////////////////////////////////////////////////////////

// OpenTibia - an opensource roleplaying game

////////////////////////////////////////////////////////////////////////

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with this program. If not, see <http://www.gnu.org/licenses/>.

////////////////////////////////////////////////////////////////////////

 

#ifndef __CONST__

#define __CONST__

#include "definitions.h"

 

enum MagicEffect_t

{

MAGIC_EFFECT_DRAW_BLOOD = 0x00,

MAGIC_EFFECT_LOSE_ENERGY = 0x01,

MAGIC_EFFECT_POFF = 0x02,

MAGIC_EFFECT_BLOCKHIT = 0x03,

MAGIC_EFFECT_EXPLOSION_AREA = 0x04,

MAGIC_EFFECT_EXPLOSION_DAMAGE = 0x05,

MAGIC_EFFECT_FIRE_AREA = 0x06,

MAGIC_EFFECT_YELLOW_RINGS = 0x07,

MAGIC_EFFECT_POISON_RINGS = 0x08,

MAGIC_EFFECT_HIT_AREA = 0x09,

MAGIC_EFFECT_TELEPORT = 0x0A, //10

MAGIC_EFFECT_ENERGY_DAMAGE = 0x0B, //11

MAGIC_EFFECT_WRAPS_BLUE = 0x0C, //12

MAGIC_EFFECT_WRAPS_RED = 0x0D, //13

MAGIC_EFFECT_WRAPS_GREEN = 0x0E, //14

MAGIC_EFFECT_HITBY_FIRE = 0x0F, //15

MAGIC_EFFECT_POISON = 0x10, //16

MAGIC_EFFECT_MORT_AREA = 0x11, //17

MAGIC_EFFECT_SOUND_GREEN = 0x12, //18

MAGIC_EFFECT_SOUND_RED = 0x13, //19

MAGIC_EFFECT_POISON_AREA = 0x14, //20

MAGIC_EFFECT_SOUND_YELLOW = 0x15, //21

MAGIC_EFFECT_SOUND_PURPLE = 0x16, //22

MAGIC_EFFECT_SOUND_BLUE = 0x17, //23

MAGIC_EFFECT_SOUND_WHITE = 0x18, //24

MAGIC_EFFECT_BUBBLES = 0x19, //25

MAGIC_EFFECT_CRAPS = 0x1A, //26

MAGIC_EFFECT_GIFT_WRAPS = 0x1B, //27

MAGIC_EFFECT_FIREWORK_YELLOW = 0x1C, //28

MAGIC_EFFECT_FIREWORK_RED = 0x1D, //29

MAGIC_EFFECT_FIREWORK_BLUE = 0x1E, //30

MAGIC_EFFECT_STUN = 0x1F, //31

MAGIC_EFFECT_SLEEP = 0x20, //32

MAGIC_EFFECT_WATERCREATURE = 0x21, //33

MAGIC_EFFECT_GROUNDSHAKER = 0x22, //34

MAGIC_EFFECT_HEARTS = 0x23, //35

MAGIC_EFFECT_FIREATTACK = 0x24, //36

MAGIC_EFFECT_ENERGY_AREA = 0x25, //37

MAGIC_EFFECT_SMALLCLOUDS = 0x26, //38

MAGIC_EFFECT_HOLYDAMAGE = 0x27, //39

MAGIC_EFFECT_BIGCLOUDS = 0x28, //40

MAGIC_EFFECT_ICEAREA = 0x29, //41

MAGIC_EFFECT_ICETORNADO = 0x2A, //42

MAGIC_EFFECT_ICEATTACK = 0x2B, //43

MAGIC_EFFECT_STONES = 0x2C, //44

MAGIC_EFFECT_SMALLPLANTS = 0x2D, //45

MAGIC_EFFECT_CARNIPHILA = 0x2E, //46

MAGIC_EFFECT_PURPLEENERGY = 0x2F, //47

MAGIC_EFFECT_YELLOWENERGY = 0x30, //48

MAGIC_EFFECT_HOLYAREA = 0x31, //49

MAGIC_EFFECT_BIGPLANTS = 0x32, //50

MAGIC_EFFECT_CAKE = 0x33, //51

MAGIC_EFFECT_GIANTICE = 0x34, //52

MAGIC_EFFECT_WATERSPLASH = 0x35, //53

MAGIC_EFFECT_PLANTATTACK = 0x36, //54

MAGIC_EFFECT_TUTORIALARROW = 0x37, //55

MAGIC_EFFECT_TUTORIALSQUARE = 0x38, //56

MAGIC_EFFECT_MIRRORHORIZONTAL = 0x39, //57

MAGIC_EFFECT_MIRRORVERTICAL = 0x3A, //58

MAGIC_EFFECT_SKULLHORIZONTAL = 0x3B, //59

MAGIC_EFFECT_SKULLVERTICAL = 0x3C, //60

MAGIC_EFFECT_ASSASSIN = 0x3D, //61

MAGIC_EFFECT_STEPSHORIZONTAL = 0x3E, //62

MAGIC_EFFECT_BLOODYSTEPS = 0x3F, //63

MAGIC_EFFECT_STEPSVERTICAL = 0x40, //64

MAGIC_EFFECT_YALAHARIGHOST = 0x41, //65

MAGIC_EFFECT_BATS = 0x42, //66

MAGIC_EFFECT_SMOKE = 0x43, //67

MAGIC_EFFECT_INSECTS = 0x44, //68

MAGIC_EFFECT_PINK = 0x45, //69

MAGIC_EFFECT_RED = 0x46, //70

MAGIC_EFFECT_BLUEK = 0x47, //71

MAGIC_EFFECT_BLUEKI = 0x48, //72

MAGIC_EFFECT_BLUEB = 0x49, //73

MAGIC_EFFECT_KAMEBLUE = 0x4A, //74

MAGIC_EFFECT_GENERIK = 0x4B, //75

MAGIC_EFFECT_GENERIKB = 0x4C, //76

MAGIC_EFFECT_GENERIKA = 0x4D, //77

MAGIC_EFFECT_GENERIKGREEN = 0x4E, //78

MAGIC_EFFECT_GREENONE = 0x4F, //79

MAGIC_EFFECT_GREENTWO = 0x50, //80

MAGIC_EFFECT_GREENTHREE = 0x51, //81

MAGIC_EFFECT_GREENFOUR = 0x52, //82

MAGIC_EFFECT_GREENFIVE = 0x53, //83

MAGIC_EFFECT_ORANGE = 0x54, //84

MAGIC_EFFECT_ORANGEONE = 0x55, //85

MAGIC_EFFECT_ORANGETWO = 0x56, //86

MAGIC_EFFECT_ORANGETHREE = 0x57, //87

MAGIC_EFFECT_ORANGEFOUR = 0x58, //88

MAGIC_EFFECT_ORANGEFIVE = 0x59, //89

MAGIC_EFFECT_PINKB = 0x5A, //90

MAGIC_EFFECT_PINKONE = 0x5B, //91

MAGIC_EFFECT_PINKTWO = 0x5C, //92

MAGIC_EFFECT_PINKTHREE = 0x5D, //93

MAGIC_EFFECT_PINKFOUR = 0x5E, //94

MAGIC_EFFECT_YELLOWB = 0x5F, //95

MAGIC_EFFECT_YELLOWONE = 0x60, //96

MAGIC_EFFECT_YELLOWTWO = 0x61, //97

MAGIC_EFFECT_YELLOWTHREE = 0x62, //98

MAGIC_EFFECT_YELLOWFOUR = 0x63, //99

MAGIC_EFFECT_YELLOWFIVE = 0x64, //100

MAGIC_EFFECT_YELLOWSIX = 0x65, //101

MAGIC_EFFECT_YELLOWSEVEN = 0x66, //102

MAGIC_EFFECT_YELLOWEIGHT = 0x67, //103

MAGIC_EFFECT_YELLOWNINE = 0x68, //104

MAGIC_EFFECT_YELLOWTEN = 0x69, //105

MAGIC_EFFECT_YELLOWELEVEN = 0x6A, //106

MAGIC_EFFECT_PINKA = 0x6B, //107

MAGIC_EFFECT_PINKC = 0x6C, //108

MAGIC_EFFECT_PINKD = 0x6D, //109

MAGIC_EFFECT_PINKE = 0x6E, //110

MAGIC_EFFECT_PINKF = 0x6F, //111

MAGIC_EFFECT_PINKG = 0x70, //112

MAGIC_EFFECT_PINKH = 0x71, //113

MAGIC_EFFECT_PINKI = 0x72, //114

MAGIC_EFFECT_PINKJ = 0x73, //115

MAGIC_EFFECT_PINKL = 0x74, //116

MAGIC_EFFECT_PINKM = 0x75, //117

MAGIC_EFFECT_PINKN = 0x76, //118

MAGIC_EFFECT_PINKO = 0x77, //119

MAGIC_EFFECT_PINKP = 0x78, //120

MAGIC_EFFECT_PINKQ = 0x79, //121

MAGIC_EFFECT_PINKR = 0x7A, //122

MAGIC_EFFECT_PINKS = 0x7B, //123

MAGIC_EFFECT_PINKT = 0x7C, //124

MAGIC_EFFECT_PINKU = 0x7D, //125

MAGIC_EFFECT_PINKV = 0x7E, //126

MAGIC_EFFECT_PINKX = 0x7F, //127

MAGIC_EFFECT_PINKZ = 0x80, //128

MAGIC_EFFECT_GRAYA = 0x81, //129

MAGIC_EFFECT_GRAYB = 0x82, //130

MAGIC_EFFECT_GRAYC = 0x83, //131

MAGIC_EFFECT_GRAYD = 0x84, //132

MAGIC_EFFECT_GRAYE = 0x85, //133

MAGIC_EFFECT_GRAYF = 0x86, //134

MAGIC_EFFECT_GRAYG = 0x87, //135

MAGIC_EFFECT_GRAYH = 0x88, //136

MAGIC_EFFECT_GRAYI = 0x89, //137

MAGIC_EFFECT_GRAYJ = 0x8A, //138

MAGIC_EFFECT_GRAYL = 0x8B, //139

MAGIC_EFFECT_GRAYM = 0x8C, //140

MAGIC_EFFECT_GRAYN = 0x8D, //141

MAGIC_EFFECT_GRAYO = 0x8E, //142

MAGIC_EFFECT_GRAYP = 0x8F, //143

MAGIC_EFFECT_GRAYQ = 0x90, //144

MAGIC_EFFECT_GRAYR = 0x91, //145

MAGIC_EFFECT_GRAYS = 0x92, //146

MAGIC_EFFECT_GRAYT = 0x93, //147

MAGIC_EFFECT_GRAYU = 0x94, //148

MAGIC_EFFECT_GRAYV = 0x95, //149

MAGIC_EFFECT_GRAYX = 0x96, //150

MAGIC_EFFECT_GRAYZ = 0x97, //151

MAGIC_EFFECT_BLACKA = 0x98, //152

MAGIC_EFFECT_BLACKB = 0x99, //153

MAGIC_EFFECT_BLACKC = 0x9A, //154

MAGIC_EFFECT_BLACKD = 0x9B, //155

MAGIC_EFFECT_BLACKE = 0x9C, //156

MAGIC_EFFECT_BLACKF = 0x9D, //157

MAGIC_EFFECT_BLACKG = 0x9E, //158

MAGIC_EFFECT_BLACKH = 0x9F, //159

MAGIC_EFFECT_BLACKJ = 0xA0, //160

MAGIC_EFFECT_BLACKL = 0xA1, //161

MAGIC_EFFECT_BLACKM = 0xA2, //162

MAGIC_EFFECT_BLACKN = 0xA3, //163

MAGIC_EFFECT_BLACKO = 0xA4, //164

MAGIC_EFFECT_BLACKP = 0xA5, //165

MAGIC_EFFECT_BLACKQ = 0xA6, //166

MAGIC_EFFECT_BLACKR = 0xA7, //167

MAGIC_EFFECT_BLACKS = 0xA8, //168

MAGIC_EFFECT_BLACKT = 0xA9, //169

MAGIC_EFFECT_BLACKU = 0xAA, //170

MAGIC_EFFECT_BLACKV = 0xAB, //171

MAGIC_EFFECT_BLACKX = 0xAC, //172

MAGIC_EFFECT_BLACKZ = 0xAD, //173

MAGIC_EFFECT_SKYA = 0xAE, //174

MAGIC_EFFECT_SKYB = 0xAF, //175

MAGIC_EFFECT_SKYC = 0xB0, //176

MAGIC_EFFECT_SKYD = 0xB1, //177

MAGIC_EFFECT_SKYE = 0xB2, //178

MAGIC_EFFECT_SKYF = 0xB3, //179

MAGIC_EFFECT_SKYG = 0xB4, //180

MAGIC_EFFECT_SKYH = 0xB5, //181

MAGIC_EFFECT_SKYI = 0xB6, //182

MAGIC_EFFECT_SKYJ = 0xB7, //183

MAGIC_EFFECT_SKYL = 0xB8, //184

MAGIC_EFFECT_SKYM = 0xB9, //185

MAGIC_EFFECT_SKYN = 0xBA, //186

MAGIC_EFFECT_SKYO = 0xBB, //187

MAGIC_EFFECT_SKYP = 0xBC, //188

MAGIC_EFFECT_SKYQ = 0xBD, //189

MAGIC_EFFECT_SKYR = 0xBE, //190

MAGIC_EFFECT_SKYS = 0xBF, //191

MAGIC_EFFECT_SKYT = 0xC0, //192

MAGIC_EFFECT_SKYU = 0xC1, //193

MAGIC_EFFECT_SKYV = 0xC2, //194

MAGIC_EFFECT_SKYX = 0xC3, //195

MAGIC_EFFECT_SKYZ = 0xC4, //196

MAGIC_EFFECT_FIGHTA = 0xC5, //197

MAGIC_EFFECT_FIGHTB = 0xC6, //198

MAGIC_EFFECT_FIGHTC = 0xC7, //199

MAGIC_EFFECT_FIGHTD = 0xC8, //200

MAGIC_EFFECT_FIGHTE = 0xC9, //201

MAGIC_EFFECT_FIGHTF = 0xCA, //202

MAGIC_EFFECT_FIGHTG = 0xCB, //203

MAGIC_EFFECT_FIGHTH = 0xCC, //204

MAGIC_EFFECT_FIGHTI = 0xCD, //205

MAGIC_EFFECT_REDSTORM = 0xCE, //206

MAGIC_EFFECT_BURNINGR = 0xCF, //207

MAGIC_EFFECT_BLUESTORMZ = 0xD0, //208

MAGIC_EFFECT_BLACKSTORMZ = 0xD1, //209

MAGIC_EFFECT_GOLDENSTORMZ = 0xD2, //210

MAGIC_EFFECT_DARKSTORMZ = 0xD3, //211

MAGIC_EFFECT_CELLTRANSFORMZ = 0xD4, //212

MAGIC_EFFECT_BROLLYTRANSFORMZ = 0xD5, //213

MAGIC_EFFECT_FABIOUM = 0xD6, //214

MAGIC_EFFECT_FABIODOIS = 0xD7, //215

MAGIC_EFFECT_FABIOTRES = 0xD8, //216

MAGIC_EFFECT_FABIOQUATRO = 0xD9, //217

MAGIC_EFFECT_FABIOCINCO = 0xDA, //218

MAGIC_EFFECT_FABIOSEIS = 0xDB, //219

MAGIC_EFFECT_FABIOSETE = 0xDC, //220

MAGIC_EFFECT_FABIOOITO = 0xDD, //221

MAGIC_EFFECT_FABIONOVE = 0xDE, //222

MAGIC_EFFECT_FABIODEZ = 0xDF, //223

MAGIC_EFFECT_FABIOONZE = 0xE0, //224

MAGIC_EFFECT_FABIODOZE = 0xE1, //225

MAGIC_EFFECT_FABIOTREZE = 0xE2, //226

MAGIC_EFFECT_FABIOQUATORZE = 0xE3, //227

MAGIC_EFFECT_FABIOQUINZE = 0xE4, //228

MAGIC_EFFECT_FABIODEZESEIS = 0xE5, //229

MAGIC_EFFECT_FABIODEZESETE = 0xE6, //230

MAGIC_EFFECT_FABIODEZOITO = 0xE7, //231

MAGIC_EFFECT_FABIOSKY = 0xE8, //232

MAGIC_EFFECT_FABIODEZENOVE = 0xE9, //233

MAGIC_EFFECT_FABIOVINTE = 0xEA, //234

MAGIC_EFFECT_FABIONUYS= 0xEB, //235

MAGIC_EFFECT_FABIOSEXYNUYS= 0xEC, //236

MAGIC_EFFECT_FABIOTRINTA= 0xED, //237

MAGIC_EFFECT_FABIOTRINTADOIS= 0xEE, //238

MAGIC_EFFECT_FABIOTRINTATRES= 0xEF, //239

MAGIC_EFFECT_FABIOTRINTAQUATRO= 0xF0, //240

MAGIC_EFFECT_FABIOTRINTACINCO= 0xF1, //241

MAGIC_EFFECT_FABIOTRINTASEIS= 0xF2, //242

MAGIC_EFFECT_FABIOTRINTASETE= 0xF3, //243

MAGIC_EFFECT_FABIOTRINTAOITO= 0xF4, //244

MAGIC_EFFECT_FABIOTRINTANOVE= 0xF5, //245

MAGIC_EFFECT_FABIOQUARENTA= 0xF6, //246

MAGIC_EFFECT_FABIOQUARENTAUM= 0xF7, //247

MAGIC_EFFECT_FABIOQUARENTADOIS= 0xF8, //248

MAGIC_EFFECT_FABIOQUARENTATRES= 0xF9, //249

MAGIC_EFFECT_FABIOQUARENTAQUATRO= 0xFA, //250

MAGIC_EFFECT_FABIOQUARENTACINCO= 0xFB, //251

MAGIC_EFFECT_FABIOQUARENTASEIS= 0xFC, //252

MAGIC_EFFECT_FABIOQUARENTASETE= 0xFD, //253

MAGIC_EFFECT_FABIOQUARENTAOITO= 0xFE, //254

MAGIC_EFFECT_LAST = MAGIC_EFFECT_FABIOQUARENTAOITO,

 

//for internal use, dont send to client

MAGIC_EFFECT_NONE = 0xFF,

MAGIC_EFFECT_UNKNOWN = 0xFFFF

};

 

enum ShootEffect_t

{

SHOOT_EFFECT_SPEAR = 0x00,

SHOOT_EFFECT_BOLT = 0x01,

SHOOT_EFFECT_ARROW = 0x02,

SHOOT_EFFECT_FIRE = 0x03,

SHOOT_EFFECT_ENERGY = 0x04,

SHOOT_EFFECT_POISONARROW = 0x05,

SHOOT_EFFECT_BURSTARROW = 0x06,

SHOOT_EFFECT_THROWINGSTAR = 0x07,

SHOOT_EFFECT_THROWINGKNIFE = 0x08,

SHOOT_EFFECT_SMALLSTONE = 0x09,

SHOOT_EFFECT_DEATH = 0x0A, //10

SHOOT_EFFECT_LARGEROCK = 0x0B, //11

SHOOT_EFFECT_SNOWBALL = 0x0C, //12

SHOOT_EFFECT_POWERBOLT = 0x0D, //13

SHOOT_EFFECT_POISONFIELD = 0x0E, //14

SHOOT_EFFECT_INFERNALBOLT = 0x0F, //15

SHOOT_EFFECT_HUNTINGSPEAR = 0x10, //16

SHOOT_EFFECT_ENCHANTEDSPEAR = 0x11, //17

SHOOT_EFFECT_REDSTAR = 0x12, //18

SHOOT_EFFECT_GREENSTAR = 0x13, //19

SHOOT_EFFECT_ROYALSPEAR = 0x14, //20

SHOOT_EFFECT_SNIPERARROW = 0x15, //21

SHOOT_EFFECT_ONYXARROW = 0x16, //22

SHOOT_EFFECT_PIERCINGBOLT = 0x17, //23

SHOOT_EFFECT_WHIRLWINDSWORD = 0x18, //24

SHOOT_EFFECT_WHIRLWINDAXE = 0x19, //25

SHOOT_EFFECT_WHIRLWINDCLUB = 0x1A, //26

SHOOT_EFFECT_ETHEREALSPEAR = 0x1B, //27

SHOOT_EFFECT_ICE = 0x1C, //28

SHOOT_EFFECT_EARTH = 0x1D, //29

SHOOT_EFFECT_HOLY = 0x1E, //30

SHOOT_EFFECT_SUDDENDEATH = 0x1F, //31

SHOOT_EFFECT_FLASHARROW = 0x20, //32

SHOOT_EFFECT_FLAMMINGARROW = 0x21, //33

SHOOT_EFFECT_SHIVERARROW = 0x22, //34

SHOOT_EFFECT_ENERGYBALL = 0x23, //35

SHOOT_EFFECT_SMALLICE = 0x24, //36

SHOOT_EFFECT_SMALLHOLY = 0x25, //37

SHOOT_EFFECT_SMALLEARTH = 0x26, //38

SHOOT_EFFECT_EARTHARROW = 0x27, //39

SHOOT_EFFECT_EXPLOSION = 0x28, //40

SHOOT_EFFECT_CAKE = 0x29, //41

SHOOT_EFFECT_LAST = SHOOT_EFFECT_CAKE,

 

//for internal use, dont send to client

SHOOT_EFFECT_WEAPONTYPE = 0xFE, //254

SHOOT_EFFECT_NONE = 0xFF,

SHOOT_EFFECT_UNKNOWN = 0xFFFF

};

 

enum SpeakClasses

{

SPEAK_CLASS_NONE = 0x00,

SPEAK_CLASS_FIRST = 0x01,

SPEAK_SAY = SPEAK_CLASS_FIRST,

SPEAK_WHISPER = 0x02,

SPEAK_YELL = 0x03,

SPEAK_PRIVATE_PN = 0x04,

SPEAK_PRIVATE_NP = 0x05,

SPEAK_PRIVATE = 0x06,

SPEAK_CHANNEL_Y = 0x07,

SPEAK_CHANNEL_W = 0x08,

SPEAK_RVR_CHANNEL = 0x09,

SPEAK_RVR_ANSWER = 0x0A,

SPEAK_RVR_CONTINUE = 0x0B,

SPEAK_BROADCAST = 0x0C,

SPEAK_CHANNEL_RN = 0x0D, //red - #c text

SPEAK_PRIVATE_RED = 0x0E, //@name@text

SPEAK_CHANNEL_O = 0x0F,

//SPEAK_UNKNOWN_1 = 0x10,

SPEAK_CHANNEL_RA = 0x11, //red anonymous - #d text

//SPEAK_UNKNOWN_2 = 0x12,

SPEAK_MONSTER_SAY = 0x13,

SPEAK_MONSTER_YELL = 0x14,

SPEAK_CLASS_LAST = SPEAK_MONSTER_YELL

};

 

enum MessageClasses

{

MSG_CLASS_FIRST = 0x12,

MSG_STATUS_CONSOLE_RED = MSG_CLASS_FIRST, /*Red message in the console*/

MSG_EVENT_ORANGE = 0x13, /*Orange message in the console*/

MSG_STATUS_CONSOLE_ORANGE = 0x14, /*Orange message in the console*/

MSG_STATUS_WARNING = 0x15, /*Red message in game window and in the console*/

MSG_EVENT_ADVANCE = 0x16, /*White message in game window and in the console*/

MSG_EVENT_DEFAULT = 0x17, /*White message at the bottom of the game window and in the console*/

MSG_STATUS_DEFAULT = 0x18, /*White message at the bottom of the game window and in the console*/

MSG_INFO_DESCR = 0x19, /*Green message in game window and in the console*/

MSG_STATUS_SMALL = 0x1A, /*White message at the bottom of the game window"*/

MSG_STATUS_CONSOLE_BLUE = 0x1B, /*Blue message in the console*/

MSG_CLASS_LAST = MSG_STATUS_CONSOLE_BLUE

};

 

enum MapMarks_t

{

MAPMARK_TICK = 0x00,

MAPMARK_QUESTION = 0x01,

MAPMARK_EXCLAMATION = 0x02,

MAPMARK_STAR = 0x03,

MAPMARK_CROSS = 0x04,

MAPMARK_TEMPLE = 0x05,

MAPMARK_KISS = 0x06,

MAPMARK_SHOVEL = 0x07,

MAPMARK_SWORD = 0x08,

MAPMARK_FLAG = 0x09,

MAPMARK_LOCK = 0x0A,

MAPMARK_BAG = 0x0B,

MAPMARK_SKULL = 0x0C,

MAPMARK_DOLLAR = 0x0D,

MAPMARK_REDNORTH = 0x0E,

MAPMARK_REDSOUTH = 0x0F,

MAPMARK_REDEAST = 0x10,

MAPMARK_REDWEST = 0x11,

MAPMARK_GREENNORTH = 0x12,

MAPMARK_GREENSOUTH = 0x13

};

 

enum FluidColors_t

{

FLUID_EMPTY = 0x00,

FLUID_BLUE = 0x01,

FLUID_RED = 0x02,

FLUID_BROWN = 0x03,

FLUID_GREEN = 0x04,

FLUID_YELLOW = 0x05,

FLUID_WHITE = 0x06,

FLUID_PURPLE = 0x07

};

 

enum FluidTypes_t

{

FLUID_NONE = FLUID_EMPTY,

FLUID_WATER = FLUID_BLUE,

FLUID_BLOOD = FLUID_RED,

FLUID_BEER = FLUID_BROWN,

FLUID_SLIME = FLUID_GREEN,

FLUID_LEMONADE = FLUID_YELLOW,

FLUID_MILK = FLUID_WHITE,

FLUID_MANA = FLUID_PURPLE,

 

FLUID_LIFE = FLUID_RED + 8,

FLUID_OIL = FLUID_BROWN + 8,

FLUID_URINE = FLUID_YELLOW + 8,

FLUID_COCONUTMILK = FLUID_WHITE + 8,

FLUID_WINE = FLUID_PURPLE + 8,

 

FLUID_MUD = FLUID_BROWN + 16,

FLUID_FRUITJUICE = FLUID_YELLOW + 16,

 

FLUID_LAVA = FLUID_RED + 24,

FLUID_RUM = FLUID_BROWN + 24,

FLUID_SWAMP = FLUID_GREEN + 24,

};

 

const uint8_t reverseFluidMap[] =

{

FLUID_EMPTY,

FLUID_WATER,

FLUID_MANA,

FLUID_BEER,

FLUID_EMPTY,

FLUID_BLOOD,

FLUID_SLIME,

FLUID_EMPTY,

FLUID_LEMONADE,

FLUID_MILK

};

 

enum ClientFluidTypes_t

{

CLIENTFLUID_EMPTY = 0x00,

CLIENTFLUID_BLUE = 0x01,

CLIENTFLUID_PURPLE = 0x02,

CLIENTFLUID_BROWN_1 = 0x03,

CLIENTFLUID_BROWN_2 = 0x04,

CLIENTFLUID_RED = 0x05,

CLIENTFLUID_GREEN = 0x06,

CLIENTFLUID_BROWN = 0x07,

CLIENTFLUID_YELLOW = 0x08,

CLIENTFLUID_WHITE = 0x09

};

 

const uint8_t fluidMap[] =

{

CLIENTFLUID_EMPTY,

CLIENTFLUID_BLUE,

CLIENTFLUID_RED,

CLIENTFLUID_BROWN_1,

CLIENTFLUID_GREEN,

CLIENTFLUID_YELLOW,

CLIENTFLUID_WHITE,

CLIENTFLUID_PURPLE

};

 

enum SquareColor_t

{

SQ_COLOR_NONE = 256,

SQ_COLOR_BLACK = 0,

};

 

enum TextColor_t

{

TEXTCOLOR_BLUE = 5,

TEXTCOLOR_GREEN = 18,

TEXTCOLOR_TEAL = 35,

TEXTCOLOR_LIGHTGREEN = 66,

TEXTCOLOR_DARKBROWN = 78,

TEXTCOLOR_LIGHTBLUE = 89,

TEXTCOLOR_DARKPURPLE = 112,

TEXTCOLOR_BROWN = 120,

TEXTCOLOR_GREY = 129,

TEXTCOLOR_DARKRED = 144,

TEXTCOLOR_DARKPINK = 152,

TEXTCOLOR_PURPLE = 154,

TEXTCOLOR_DARKORANGE = 156,

TEXTCOLOR_RED = 180,

TEXTCOLOR_PINK = 190,

TEXTCOLOR_ORANGE = 192,

TEXTCOLOR_DARKYELLOW = 205,

TEXTCOLOR_YELLOW = 210,

TEXTCOLOR_WHITE = 215,

 

TEXTCOLOR_NONE = 255,

TEXTCOLOR_UNKNOWN = 256

};

 

enum Icons_t

{

ICON_NONE = 0,

ICON_POISON = 1 << 0,

ICON_BURN = 1 << 1,

ICON_ENERGY = 1 << 2,

ICON_DRUNK = 1 << 3,

ICON_MANASHIELD = 1 << 4,

ICON_PARALYZE = 1 << 5,

ICON_HASTE = 1 << 6,

ICON_SWORDS = 1 << 7,

ICON_DROWNING = 1 << 8,

ICON_FREEZING = 1 << 9,

ICON_DAZZLED = 1 << 10,

ICON_CURSED = 1 << 11,

ICON_BUFF = 1 << 12,

ICON_PZ = 1 << 13,

ICON_PROTECTIONZONE = 1 << 14

};

 

enum WeaponType_t

{

WEAPON_NONE = 0,

WEAPON_SWORD = 1,

WEAPON_CLUB = 2,

WEAPON_AXE = 3,

WEAPON_SHIELD = 4,

WEAPON_DIST = 5,

WEAPON_WAND = 6,

WEAPON_AMMO = 7,

WEAPON_FIST = 8

};

 

enum Ammo_t

{

AMMO_NONE = 0,

AMMO_BOLT = 1,

AMMO_ARROW = 2,

AMMO_SPEAR = 3,

AMMO_THROWINGSTAR = 4,

AMMO_THROWINGKNIFE = 5,

AMMO_STONE = 6,

AMMO_SNOWBALL = 7

};

 

enum AmmoAction_t

{

AMMOACTION_NONE,

AMMOACTION_REMOVECOUNT,

AMMOACTION_REMOVECHARGE,

AMMOACTION_MOVE,

AMMOACTION_MOVEBACK

};

 

enum WieldInfo_t

{

WIELDINFO_LEVEL = 1,

WIELDINFO_MAGLV = 2,

WIELDINFO_VOCREQ = 4,

WIELDINFO_PREMIUM = 8

};

 

enum Skulls_t

{

SKULL_NONE = 0,

SKULL_YELLOW = 1,

SKULL_GREEN = 2,

SKULL_WHITE = 3,

SKULL_RED = 4,

SKULL_BLACK = 5,

SKULL_LAST = SKULL_BLACK

};

 

enum PartyShields_t

{

SHIELD_NONE = 0,

SHIELD_WHITEYELLOW = 1,

SHIELD_WHITEBLUE = 2,

SHIELD_BLUE = 3,

SHIELD_YELLOW = 4,

SHIELD_BLUE_SHAREDEXP = 5,

SHIELD_YELLOW_SHAREDEXP = 6,

SHIELD_BLUE_NOSHAREDEXP_BLINK = 7,

SHIELD_YELLOW_NOSHAREDEXP_BLINK = 8,

SHIELD_BLUE_NOSHAREDEXP = 9,

SHIELD_YELLOW_NOSHAREDEXP = 10,

SHIELD_LAST = SHIELD_YELLOW_NOSHAREDEXP

};

 

enum item_t

{

ITEM_FIREFIELD = 1492,

ITEM_FIREFIELD_SAFE = 1500,

 

ITEM_POISONFIELD = 1496,

ITEM_POISONFIELD_SAFE = 1503,

 

ITEM_ENERGYFIELD = 1495,

ITEM_ENERGYFIELD_SAFE = 1504,

 

ITEM_MAGICWALL = 1497,

ITEM_MAGICWALL_SAFE = 11095,

 

ITEM_WILDGROWTH = 1499,

ITEM_WILDGROWTH_SAFE = 11096,

 

ITEM_DEPOT = 2594,

ITEM_LOCKER = 2589,

ITEM_GLOWING_SWITCH = 11060,

 

ITEM_MALE_CORPSE = 6080,

ITEM_FEMALE_CORPSE = 6081,

 

ITEM_MEAT = 2666,

ITEM_HAM = 2671,

ITEM_GRAPE = 2681,

ITEM_APPLE = 2674,

ITEM_BREAD = 2689,

ITEM_ROLL = 2690,

ITEM_CHEESE = 2696,

 

ITEM_FULLSPLASH = 2016,

ITEM_SMALLSPLASH = 2019,

 

ITEM_PARCEL = 2595,

ITEM_PARCEL_STAMPED = 2596,

ITEM_LETTER = 2597,

ITEM_LETTER_STAMPED = 2598,

ITEM_LABEL = 2599,

 

ITEM_WATERBALL_SPLASH = 7711,

ITEM_WATERBALL = 7956,

 

ITEM_HOUSE_TRANSFER = 1968 //read-only

};

 

enum PlayerFlags

{

PlayerFlag_CannotUseCombat = 0, //2^0 = 1

PlayerFlag_CannotAttackPlayer, //2^1 = 2

PlayerFlag_CannotAttackMonster, //2^2 = 4

PlayerFlag_CannotBeAttacked, //2^3 = 8

PlayerFlag_CanConvinceAll, //2^4 = 16

PlayerFlag_CanSummonAll, //2^5 = 32

PlayerFlag_CanIllusionAll, //2^6 = 64

PlayerFlag_CanSenseInvisibility, //2^7 = 128

PlayerFlag_IgnoredByMonsters, //2^8 = 256

PlayerFlag_NotGainInFight, //2^9 = 512

PlayerFlag_HasInfiniteMana, //2^10 = 1024

PlayerFlag_HasInfiniteSoul, //2^11 = 2048

PlayerFlag_HasNoExhaustion, //2^12 = 4096

PlayerFlag_CannotUseSpells, //2^13 = 8192

PlayerFlag_CannotPickupItem, //2^14 = 16384

PlayerFlag_CanAlwaysLogin, //2^15 = 32768

PlayerFlag_CanBroadcast, //2^16 = 65536

PlayerFlag_CanEditHouses, //2^17 = 131072

PlayerFlag_CannotBeBanned, //2^18 = 262144

PlayerFlag_CannotBePushed, //2^19 = 524288

PlayerFlag_HasInfiniteCapacity, //2^20 = 1048576

PlayerFlag_CanPushAllCreatures, //2^21 = 2097152

PlayerFlag_CanTalkRedPrivate, //2^22 = 4194304

PlayerFlag_CanTalkRedChannel, //2^23 = 8388608

PlayerFlag_TalkOrangeHelpChannel, //2^24 = 16777216

PlayerFlag_NotGainExperience, //2^25 = 33554432

PlayerFlag_NotGainMana, //2^26 = 67108864

PlayerFlag_NotGainHealth, //2^27 = 134217728

PlayerFlag_NotGainSkill, //2^28 = 268435456

PlayerFlag_SetMaxSpeed, //2^29 = 536870912

PlayerFlag_SpecialVIP, //2^30 = 1073741824

PlayerFlag_NotGenerateLoot, //2^31 = 2147483648

PlayerFlag_CanTalkRedChannelAnonymous, //2^32 = 4294967296

PlayerFlag_IgnoreProtectionZone, //2^33 = 8589934592

PlayerFlag_IgnoreSpellCheck, //2^34 = 17179869184

PlayerFlag_IgnoreEquipCheck, //2^35 = 34359738368

PlayerFlag_CannotBeMuted, //2^36 = 68719476736

PlayerFlag_IsAlwaysPremium, //2^37 = 137438953472

PlayerFlag_CanAnswerRuleViolations, //2^38 = 274877906944

PlayerFlag_39, //ignore //2^39 = 549755813888 //not used by us

PlayerFlag_ShowGroupNameInsteadOfVocation, //2^40 = 1099511627776

PlayerFlag_HasInfiniteStamina, //2^41 = 2199023255552

PlayerFlag_CannotMoveItems, //2^42 = 4398046511104

PlayerFlag_CannotMoveCreatures, //2^43 = 8796093022208

PlayerFlag_CanReportBugs, //2^44 = 17592186044416

PlayerFlag_45, //ignore //2^45 = 35184372088832 //not used by us

PlayerFlag_CannotBeSeen, //2^46 = 70368744177664

 

PlayerFlag_LastFlag

};

 

enum PlayerCustomFlags

{

PlayerCustomFlag_AllowIdle = 0, //2^0 = 1

PlayerCustomFlag_CanSeePosition, //2^1 = 2

PlayerCustomFlag_CanSeeItemDetails, //2^2 = 4

PlayerCustomFlag_CanSeeCreatureDetails, //2^3 = 8

PlayerCustomFlag_NotSearchable, //2^4 = 16

PlayerCustomFlag_GamemasterPrivileges, //2^5 = 32

PlayerCustomFlag_CanThrowAnywhere, //2^6 = 64

PlayerCustomFlag_CanPushAllItems, //2^7 = 128

PlayerCustomFlag_CanMoveAnywhere, //2^8 = 256

PlayerCustomFlag_CanMoveFromFar, //2^9 = 512

PlayerCustomFlag_CanLoginMultipleCharacters, //2^10 = 1024 (account flag)

PlayerCustomFlag_HasFullLight, //2^11 = 2048

PlayerCustomFlag_CanLogoutAnytime, //2^12 = 4096 (account flag)

PlayerCustomFlag_HideLevel, //2^13 = 8192

PlayerCustomFlag_IsProtected, //2^14 = 16384

PlayerCustomFlag_IsImmune, //2^15 = 32768

PlayerCustomFlag_NotGainSkull, //2^16 = 65536

PlayerCustomFlag_NotGainUnjustified, //2^17 = 131072

PlayerCustomFlag_IgnorePacification, //2^18 = 262144

PlayerCustomFlag_IgnoreLoginDelay, //2^19 = 524288

PlayerCustomFlag_CanStairhop, //2^20 = 1048576

PlayerCustomFlag_CanTurnhop, //2^21 = 2097152

PlayerCustomFlag_IgnoreHouseRent, //2^22 = 4194304

PlayerCustomFlag_CanWearAllAddons, //2^23 = 8388608

 

PlayerCustomFlag_LastFlag

};

 

//Reserved player storage key ranges

//[10000000 - 20000000]

#define PSTRG_RESERVED_RANGE_START 10000000

#define PSTRG_RESERVED_RANGE_SIZE 10000000

 

//[1000 - 1500]

#define PSTRG_OUTFITS_RANGE_START (PSTRG_RESERVED_RANGE_START + 1000)

#define PSTRG_OUTFITS_RANGE_SIZE 500

 

//[1500 - 2000]

#define PSTRG_OUTFITSID_RANGE_START (PSTRG_RESERVED_RANGE_START + 1500)

#define PSTRG_OUTFITSID_RANGE_SIZE 500

 

#define NETWORKMESSAGE_MAXSIZE 15360

#define IPBAN_FLAG 128

#define LOCALHOST 2130706433

 

#define IS_IN_KEYRANGE(key, range) (key >= PSTRG_##range##_START && ((key - PSTRG_##range##_START) < PSTRG_##range##_SIZE))

#endif

 

////////////////////////////////////////////////////////////////////////

// OpenTibia - an opensource roleplaying game

////////////////////////////////////////////////////////////////////////

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any alater version.

//

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with this program. If not, see <http://www.gnu.org/licenses/>.

////////////////////////////////////////////////////////////////////////

#include "otpch.h"

#include <iostream>

#include <iomanip>

 

#include "tools.h"

#include "md5.h"

#include "sha1.h"

 

#include "vocation.h"

#include "configmanager.h"

extern ConfigManager g_config;

 

std::string transformToSHA1(std::string plainText, bool upperCase)

{

SHA1 sha1;

unsigned sha1Hash[5];

std::stringstream hexStream;

 

sha1.Input((const uint8_t*)plainText.c_str(), plainText.length());

sha1.Result(sha1Hash);

 

hexStream.flags(std::ios::hex | std::ios::uppercase);

for(uint32_t i = 0; i < 5; ++i)

hexStream << std::setw(8) << std::setfill('0') << (uint32_t)sha1Hash;

 

std::string hexStr = hexStream.str();

if(!upperCase)

toLowerCaseString(hexStr);

 

return hexStr;

}

 

std::string transformToMD5(std::string plainText, bool upperCase)

{

MD5_CTX m_md5;

std::stringstream hexStream;

 

MD5Init(&m_md5, 0);

MD5Update(&m_md5, (const uint8_t*)plainText.c_str(), plainText.length());

MD5Final(&m_md5);

 

hexStream.flags(std::ios::hex | std::ios::uppercase);

for(uint32_t i = 0; i < 16; ++i)

hexStream << std::setw(2) << std::setfill('0') << (uint32_t)m_md5.digest;

 

std::string hexStr = hexStream.str();

if(!upperCase)

toLowerCaseString(hexStr);

 

return hexStr;

}

 

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;

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;

}

 

void replaceString(std::string& text, const std::string key, const std::string value)

{

if(value.find(key) != std::string::npos) //don't allow infinite loops

return;

 

for(std::string::size_type keyStart = text.find(key); keyStart

!= std::string::npos; keyStart = text.find(key))

text.replace(keyStart, key.size(), value);

}

 

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, int& value)

{

char* nodeValue = (char*)xmlGetProp(node, (xmlChar*)tag);

if(!nodeValue)

return false;

 

value = atoi(nodeValue);

xmlFree(nodeValue);

return true;

}

 

#if defined WINDOWS && !defined __GNUC__

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;

}

#endif

 

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) && !isNumber(text))

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) && !isNumber(text) && !isPasswordCharacter(text))

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 != 32)

{

lenBeforeSpace++;

 

if(text != 39)

lenBeforeQuote++;

else

{

if(lenBeforeQuote <= 1 || size == textLength - 1 || text == 32)

return false;

 

lenBeforeQuote = 0;

}

 

if(text != 45)

lenBeforeDash++;

else

{

if(lenBeforeDash <= 1 || size == textLength - 1 || text == 32)

return false;

 

lenBeforeDash = 0;

}

 

if(text == lastChar)

{

repeatedCharacter++;

if(repeatedCharacter > 2)

return false;

}

else

repeatedCharacter = 0;

 

lastChar = text;

}

else

{

if(lenBeforeSpace <= 1 || size == textLength - 1 || text == 32)

return false;

 

lenBeforeSpace = lenBeforeQuote = lenBeforeDash = 0;

}

 

if(!(isLowercaseLetter(text) || text == 32 || text == 39 || text == 45

|| (isUppercaseLetter(text) && text == 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))

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)

{

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((bool)random_range(0, 1))

{

number = random_range(2, 9);

if(number != lastNumber)

{

key << number;

lastNumber = number;

madeNumber = true;

}

}

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*/)

{

char buffer[21];

if(!_time)

_time = time(NULL);

 

const tm* tms = localtime(&_time);

if(tms)

sprintf(buffer, "%02d/%02d/%04d %02d:%02d:%02d", tms->tm_mday, tms->tm_mon + 1, tms->tm_year + 1900, tms->tm_hour, tms->tm_min, tms->tm_sec);

else

sprintf(buffer, "UNIX Time: %d", (int32_t)_time);

 

return buffer;

}

 

std::string formatDateShort(time_t _time, bool detailed/* = false*/)

{

char buffer[21];

if(!_time)

_time = time(NULL);

 

const tm* tms = localtime(&_time);

if(tms)

{

std::string format = "%d %b %Y";

if(detailed)

format += " %H:%M:%S";

 

strftime(buffer, 25, format.c_str(), tms);

}

else

sprintf(buffer, "UNIX Time: %d", (int32_t)_time);

 

return buffer;

}

 

std::string formatTime(int32_t hours, int32_t minutes)

{

std::stringstream time;

if(hours)

time << hours << " " << (hours > 1 ? "hours" : "hour") << (minutes ? " and " : "");

 

if(minutes)

time << minutes << " " << (minutes > 1 ? "minutes" : "minute");

 

return time.str();

}

 

std::string convertIPAddress(uint32_t ip)

{

char buffer[17];

sprintf(buffer, "%d.%d.%d.%d", ip & 0xFF, (ip >> 8) & 0xFF, (ip >> 16) & 0xFF, (ip >> 24));

return buffer;

}

 

Skulls_t getSkull(std::string strValue)

{

std::string tmpStrValue = asLowerCaseString(strValue);

if(tmpStrValue == "black" || tmpStrValue == "5")

return SKULL_BLACK;

else if(tmpStrValue == "red" || tmpStrValue == "4")

return SKULL_RED;

else if(tmpStrValue == "white" || tmpStrValue == "3")

return SKULL_WHITE;

else if(tmpStrValue == "green" || tmpStrValue == "2")

return SKULL_GREEN;

else if(tmpStrValue == "yellow" || tmpStrValue == "1")

return SKULL_YELLOW;

 

return SKULL_NONE;

}

 

PartyShields_t getPartyShield(std::string strValue)

{

std::string tmpStrValue = asLowerCaseString(strValue);

if(tmpStrValue == "whitenoshareoff" || tmpStrValue == "10")

return SHIELD_YELLOW_NOSHAREDEXP;

else if(tmpStrValue == "blueshareoff" || tmpStrValue == "9")

return SHIELD_BLUE_NOSHAREDEXP;

else if(tmpStrValue == "yellowshareblink" || tmpStrValue == "8")

return SHIELD_YELLOW_NOSHAREDEXP_BLINK;

else if(tmpStrValue == "blueshareblink" || tmpStrValue == "7")

return SHIELD_BLUE_NOSHAREDEXP_BLINK;

else if(tmpStrValue == "yellowshareon" || tmpStrValue == "6")

return SHIELD_YELLOW_SHAREDEXP;

else if(tmpStrValue == "blueshareon" || tmpStrValue == "5")

return SHIELD_BLUE_SHAREDEXP;

else if(tmpStrValue == "yellow" || tmpStrValue == "4")

return SHIELD_YELLOW;

else if(tmpStrValue == "blue" || tmpStrValue == "3")

return SHIELD_BLUE;

else if(tmpStrValue == "whiteyellow" || tmpStrValue == "2")

return SHIELD_WHITEYELLOW;

else if(tmpStrValue == "whiteblue" || tmpStrValue == "1")

return SHIELD_WHITEBLUE;

 

return SHIELD_NONE;

}

 

Direction getDirection(std::string string)

{

if(string == "north" || string == "n" || string == "0")

return NORTH;

else if(string == "east" || string == "e" || string == "1")

return EAST;

else if(string == "south" || string == "s" || string == "2")

return SOUTH;

else if(string == "west" || string == "w" || string == "3")

return WEST;

else if(string == "southwest" || string == "south west" || string == "south-west" || string == "sw" || string == "4")

return SOUTHWEST;

else if(string == "southeast" || string == "south east" || string == "south-east" || string == "se" || string == "5")

return SOUTHEAST;

else if(string == "northwest" || string == "north west" || string == "north-west" || string == "nw" || string == "6")

return NORTHWEST;

else 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},

{"pink", MAGIC_EFFECT_PINK},

{"red", MAGIC_EFFECT_RED},

{"bluek", MAGIC_EFFECT_BLUEK},

{"blueki", MAGIC_EFFECT_BLUEKI},

{"blueb", MAGIC_EFFECT_BLUEB},

{"kameblue", MAGIC_EFFECT_KAMEBLUE},

{"generiki", MAGIC_EFFECT_GENERIK},

{"generikib", MAGIC_EFFECT_GENERIKB},

{"generikia", MAGIC_EFFECT_GENERIKA},

{"generikigreen", MAGIC_EFFECT_GENERIKGREEN},

{"greenone", MAGIC_EFFECT_GREENONE},

{"greentwo", MAGIC_EFFECT_GREENTWO},

{"greenthree", MAGIC_EFFECT_GREENTHREE},

{"greenfour", MAGIC_EFFECT_GREENFOUR},

{"greenfive", MAGIC_EFFECT_GREENFIVE},

{"orange", MAGIC_EFFECT_ORANGE},

{"orangeone", MAGIC_EFFECT_ORANGEONE},

{"orangetwo", MAGIC_EFFECT_ORANGETWO},

{"orangethree", MAGIC_EFFECT_ORANGETHREE},

{"orangefour", MAGIC_EFFECT_ORANGEFOUR},

{"orangefive", MAGIC_EFFECT_ORANGEFIVE},

{"pinkb", MAGIC_EFFECT_PINKB},

{"pinkone", MAGIC_EFFECT_PINKONE},

{"pinktwo", MAGIC_EFFECT_PINKTWO},

{"pinkthree", MAGIC_EFFECT_PINKTHREE},

{"pinkfour", MAGIC_EFFECT_PINKFOUR},

{"yellowb", MAGIC_EFFECT_YELLOWB},

{"yellowone", MAGIC_EFFECT_YELLOWONE},

{"yellowtwo", MAGIC_EFFECT_YELLOWTWO},

{"yellowthree", MAGIC_EFFECT_YELLOWTHREE},

{"yellowfour", MAGIC_EFFECT_YELLOWFOUR},

{"yellowfive", MAGIC_EFFECT_YELLOWFIVE},

{"yellowsix", MAGIC_EFFECT_YELLOWSIX},

{"yellowseven", MAGIC_EFFECT_YELLOWSEVEN},

{"yelloweight", MAGIC_EFFECT_YELLOWEIGHT},

{"yellownine", MAGIC_EFFECT_YELLOWNINE},

{"yellowten", MAGIC_EFFECT_YELLOWTEN},

{"yelloweleven", MAGIC_EFFECT_YELLOWELEVEN},

{"pinka", MAGIC_EFFECT_PINKA},

{"pinkc", MAGIC_EFFECT_PINKC},

{"pinkd", MAGIC_EFFECT_PINKD},

{"pinke", MAGIC_EFFECT_PINKE},

{"pinkf", MAGIC_EFFECT_PINKF},

{"pinkg", MAGIC_EFFECT_PINKG},

{"pinkh", MAGIC_EFFECT_PINKH},

{"pinki", MAGIC_EFFECT_PINKI},

{"pinkj", MAGIC_EFFECT_PINKJ},

{"pinkl", MAGIC_EFFECT_PINKL},

{"pinkl", MAGIC_EFFECT_PINKL},

{"pinkm", MAGIC_EFFECT_PINKM},

{"pinkn", MAGIC_EFFECT_PINKN},

{"pinko", MAGIC_EFFECT_PINKO},

{"pinkp", MAGIC_EFFECT_PINKP},

{"pinkq", MAGIC_EFFECT_PINKQ},

{"pinkr", MAGIC_EFFECT_PINKR},

{"pinks", MAGIC_EFFECT_PINKS},

{"pinkt", MAGIC_EFFECT_PINKT},

{"pinku", MAGIC_EFFECT_PINKU},

{"pinkv", MAGIC_EFFECT_PINKV},

{"pinkx", MAGIC_EFFECT_PINKX},

{"pinkz", MAGIC_EFFECT_PINKZ},

{"graya", MAGIC_EFFECT_GRAYA},

{"grayb", MAGIC_EFFECT_GRAYB},

{"grayc", MAGIC_EFFECT_GRAYC},

{"grayd", MAGIC_EFFECT_GRAYD},

{"graye", MAGIC_EFFECT_GRAYE},

{"grayf", MAGIC_EFFECT_GRAYF},

{"grayg", MAGIC_EFFECT_GRAYG},

{"grayh", MAGIC_EFFECT_GRAYH},

{"grayi", MAGIC_EFFECT_GRAYI},

{"grayj", MAGIC_EFFECT_GRAYJ},

{"grayl", MAGIC_EFFECT_GRAYL},

{"graym", MAGIC_EFFECT_GRAYM},

{"grayn", MAGIC_EFFECT_GRAYN},

{"grayo", MAGIC_EFFECT_GRAYO},

{"grayp", MAGIC_EFFECT_GRAYP},

{"grayq", MAGIC_EFFECT_GRAYQ},

{"grayr", MAGIC_EFFECT_GRAYR},

{"grays", MAGIC_EFFECT_GRAYS},

{"grayt", MAGIC_EFFECT_GRAYT},

{"grayu", MAGIC_EFFECT_GRAYU},

{"grayv", MAGIC_EFFECT_GRAYV},

{"grayx", MAGIC_EFFECT_GRAYX},

{"grayz", MAGIC_EFFECT_GRAYZ},

{"blacka", MAGIC_EFFECT_BLACKA},

{"blackb", MAGIC_EFFECT_BLACKB},

{"blackc", MAGIC_EFFECT_BLACKC},

{"blackd", MAGIC_EFFECT_BLACKD},

{"blacke", MAGIC_EFFECT_BLACKE},

{"blackf", MAGIC_EFFECT_BLACKF},

{"blackg", MAGIC_EFFECT_BLACKG},

{"blackh", MAGIC_EFFECT_BLACKH},

{"blackj", MAGIC_EFFECT_BLACKJ},

{"blackl", MAGIC_EFFECT_BLACKL},

{"blackm", MAGIC_EFFECT_BLACKM},

{"blackn", MAGIC_EFFECT_BLACKN},

{"blacko", MAGIC_EFFECT_BLACKO},

{"blackp", MAGIC_EFFECT_BLACKP},

{"blackr", MAGIC_EFFECT_BLACKR},

{"blacks", MAGIC_EFFECT_BLACKS},

{"blackt", MAGIC_EFFECT_BLACKT},

{"blacku", MAGIC_EFFECT_BLACKU},

{"blacku", MAGIC_EFFECT_BLACKV},

{"blackx", MAGIC_EFFECT_BLACKX},

{"blackz", MAGIC_EFFECT_BLACKZ},

{"skya", MAGIC_EFFECT_SKYA},

{"skyb", MAGIC_EFFECT_SKYB},

{"skyc", MAGIC_EFFECT_SKYC},

{"skyd", MAGIC_EFFECT_SKYD},

{"skyd", MAGIC_EFFECT_SKYE},

{"skyf", MAGIC_EFFECT_SKYF},

{"skyg", MAGIC_EFFECT_SKYG},

{"skyh", MAGIC_EFFECT_SKYH},

{"skyi", MAGIC_EFFECT_SKYI},

{"skyj", MAGIC_EFFECT_SKYJ},

{"skyl", MAGIC_EFFECT_SKYL},

{"skym", MAGIC_EFFECT_SKYM},

{"skyn", MAGIC_EFFECT_SKYN},

{"skyo", MAGIC_EFFECT_SKYO},

{"skyp", MAGIC_EFFECT_SKYP},

{"skyr", MAGIC_EFFECT_SKYR},

{"skys", MAGIC_EFFECT_SKYS},

{"skyt", MAGIC_EFFECT_SKYT},

{"skyu", MAGIC_EFFECT_SKYU},

{"skyv", MAGIC_EFFECT_SKYV},

{"skyx", MAGIC_EFFECT_SKYX},

{"skyz", MAGIC_EFFECT_SKYZ},

{"fighta", MAGIC_EFFECT_FIGHTA},

{"fightb", MAGIC_EFFECT_FIGHTB},

{"fightc", MAGIC_EFFECT_FIGHTC},

{"fightd", MAGIC_EFFECT_FIGHTD},

{"fighte", MAGIC_EFFECT_FIGHTE},

{"fightf", MAGIC_EFFECT_FIGHTF},

{"fightg", MAGIC_EFFECT_FIGHTG},

{"fighth", MAGIC_EFFECT_FIGHTH},

{"fighti", MAGIC_EFFECT_FIGHTI},

{"redstorm", MAGIC_EFFECT_REDSTORM},

{"burningr", MAGIC_EFFECT_BURNINGR},

{"bluestormz", MAGIC_EFFECT_BLUESTORMZ},

{"blackstormz", MAGIC_EFFECT_BLACKSTORMZ},

{"goldenstormz", MAGIC_EFFECT_GOLDENSTORMZ},

{"darkstormz", MAGIC_EFFECT_DARKSTORMZ},

{"celltransformz", MAGIC_EFFECT_CELLTRANSFORMZ},

{"brollytransformz", MAGIC_EFFECT_BROLLYTRANSFORMZ},

{"fabioum", MAGIC_EFFECT_FABIOUM},

{"fabiodois", MAGIC_EFFECT_FABIODOIS},

{"fabiotres", MAGIC_EFFECT_FABIOTRES},

{"fabioquatro", MAGIC_EFFECT_FABIOQUATRO},

{"fabiocinco", MAGIC_EFFECT_FABIOCINCO},

{"fabioseis", MAGIC_EFFECT_FABIOSEIS},

{"fabiosete", MAGIC_EFFECT_FABIOSETE},

{"fabiooito", MAGIC_EFFECT_FABIOOITO},

{"fabionove", MAGIC_EFFECT_FABIONOVE},

{"fabiodez", MAGIC_EFFECT_FABIODEZ},

{"fabioonze", MAGIC_EFFECT_FABIOONZE},

{"fabiodoze", MAGIC_EFFECT_FABIODOZE},

{"fabiotreze", MAGIC_EFFECT_FABIOTREZE},

{"fabioquatorze", MAGIC_EFFECT_FABIOQUATORZE},

{"fabioquinze", MAGIC_EFFECT_FABIOQUINZE},

{"fabiodezeseis", MAGIC_EFFECT_FABIODEZESEIS},

{"fabiodezesete", MAGIC_EFFECT_FABIODEZESETE},

{"fabiodezoito", MAGIC_EFFECT_FABIODEZOITO},

{"fabiosky", MAGIC_EFFECT_FABIOSKY},

{"fabiodezenove", MAGIC_EFFECT_FABIODEZENOVE},

{"fabiovinte", MAGIC_EFFECT_FABIOVINTE},

{"fabionuys", MAGIC_EFFECT_FABIONUYS},

{"fabiosexynuys", MAGIC_EFFECT_FABIOSEXYNUYS},

{"fabiotrinta", MAGIC_EFFECT_FABIOTRINTA},

{"fabiotrintadois", MAGIC_EFFECT_FABIOTRINTADOIS},

{"fabiotrintatres", MAGIC_EFFECT_FABIOTRINTATRES},

{"fabiotrintaquatro", MAGIC_EFFECT_FABIOTRINTAQUATRO},

{"fabiotrintacinco", MAGIC_EFFECT_FABIOTRINTACINCO},

{"fabiotrintasete", MAGIC_EFFECT_FABIOTRINTASEIS},

{"fabiotrintasete", MAGIC_EFFECT_FABIOTRINTASETE},

{"fabiotrintaoito", MAGIC_EFFECT_FABIOTRINTAOITO},

{"fabiotrintanove", MAGIC_EFFECT_FABIOTRINTANOVE},

{"fabioquarenta", MAGIC_EFFECT_FABIOQUARENTA},

{"fabioquarentadois", MAGIC_EFFECT_FABIOQUARENTADOIS},

{"fabioquarentatres", MAGIC_EFFECT_FABIOQUARENTATRES},

{"fabioquarentaquatro", MAGIC_EFFECT_FABIOQUARENTAQUATRO},

{"fabioquarentacinco", MAGIC_EFFECT_FABIOQUARENTACINCO},

{"fabioquarentaseis", MAGIC_EFFECT_FABIOQUARENTASEIS},

{"fabioquarentasete", MAGIC_EFFECT_FABIOQUARENTASETE},

{"fabioquarentaoito", MAGIC_EFFECT_FABIOQUARENTAOITO}

};

 

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}

};

 

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.name))

return magicEffectNames.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.name))

return shootTypeNames.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.name))

return combatTypeNames.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.name))

return ammoTypeNames.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.name))

return ammoActionNames.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.name))

return fluidTypeNames.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.name))

return skillIdNames.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);

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;

 

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 > NETWORKMESSAGE_MAXSIZE || length < 0)

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 filetype, std::string filename)

{

#ifdef __FILESYSTEM_HIERARCHY_STANDARD__

std::string path = "/usr/share/tfs/";

#endif

std::string path = g_config.getString(ConfigManager::DATA_DIRECTORY);

switch(filetype)

{

case FILE_TYPE_OTHER:

path += filename;

break;

case FILE_TYPE_XML:

path += "XML/" + filename;

break;

case FILE_TYPE_LOG:

#ifndef __FILESYSTEM_HIERARCHY_STANDARD__

path += "logs/" + filename;

#else

path = "/var/log/tfs/" + filename;

#endif

break;

case FILE_TYPE_MOD:

{

#ifndef __FILESYSTEM_HIERARCHY_STANDARD__

path = "mods/" + filename;

#else

path = "/etc/tfs/mods/" + filename;

#endif

break;

}

case FILE_TYPE_CONFIG:

{

#if defined(__FILESYSTEM_HIERARCHY_STANDARD__) && defined(__HOMEDIR_CONF__)

if(fileExists("~/.tfs/" + filename))

path = "~/.tfs/" + filename;

else

path = "/etc/tfs/" + filename;

 

#elif defined(__FILESYSTEM_HIERARCHY_STANDARD__)

path = "/etc/tfs/" + filename;

#else

path = filename;

#endif

break;

}

default:

std::cout << "ERROR: Wrong file type!" << std::endl;

break;

}

return path;

}