mirror of
https://github.com/UOX3DevTeam/UOX3
synced 2026-08-13 12:27:04 -04:00
7952 lines
330 KiB
C++
7952 lines
330 KiB
C++
#include "uox3.h"
|
|
#include "scriptc.h"
|
|
#include "ssection.h"
|
|
#include "Dictionary.h"
|
|
#include <filesystem>
|
|
#include <cstdint>
|
|
#include <limits>
|
|
#include <optional>
|
|
#include "IP4Address.hpp"
|
|
#if PLATFORM != WINDOWS
|
|
#include <netdb.h>
|
|
|
|
#include <arpa/inet.h>
|
|
#endif
|
|
|
|
#include "StringUtility.hpp"
|
|
#include "osunique.hpp"
|
|
|
|
using namespace std::string_literals;
|
|
//==================================================================================================
|
|
// constant data
|
|
//==================================================================================================
|
|
//==================================================================================================
|
|
const std::map<std::string, SI32> CServerData::uox3IniCaseValue
|
|
{
|
|
// these numbers dont have to be in order, and can skip aound
|
|
// they just CANT be repeated (now we could add some protection
|
|
// but they dont change that much, and there are a lot, so if you delete one
|
|
// dont worry about reusing it. Just keep adding up from the last one would
|
|
// be easiest.
|
|
// They key is that number HAS to match the case statement number
|
|
// in
|
|
//bool CServerData::HandleLine( const std::string& tag, const std::string& value )
|
|
// in cServerData.cpp (this file).
|
|
{"SERVERNAME"s, 1},
|
|
{"CONSOLELOG"s, 2},
|
|
{"COMMANDPREFIX"s, 3},
|
|
{"ANNOUNCEWORLDSAVES"s, 4},
|
|
{"BACKUPSENABLED"s, 5},
|
|
{"SAVESTIMER"s, 6},
|
|
{"SKILLCAP"s, 7},
|
|
{"SKILLDELAY"s, 8},
|
|
{"STATCAP"s, 9},
|
|
{"MAXSTEALTHMOVEMENTS"s, 10},
|
|
{"MAXSTAMINAMOVEMENTS"s, 11},
|
|
{"ARMORAFFECTMANAREGEN"s, 12},
|
|
{"CORPSEDECAYTIMER"s, 13},
|
|
{"WEATHERTIMER"s, 14},
|
|
{"SHOPSPAWNTIMER"s, 15},
|
|
{"DECAYTIMER"s, 16},
|
|
{"INVISIBILITYTIMER"s, 17},
|
|
{"OBJECTUSETIMER"s, 18},
|
|
{"GATETIMER"s, 19},
|
|
{"POISONTIMER"s, 20},
|
|
{"LOGINTIMEOUT"s, 21},
|
|
{"HITPOINTREGENTIMER"s, 22},
|
|
{"STAMINAREGENTIMER"s, 23},
|
|
{"BASEFISHINGTIMER"s, 24},
|
|
{"SCRIPTSDIRECTORY"s, 25},
|
|
{"JOINPARTMSGS"s, 26},
|
|
{"MAXPETOWNERS"s, 34},
|
|
{"MAXFOLLOWERS"s, 35},
|
|
{"MAXCONTROLSLOTS"s, 36},
|
|
{"MANAREGENTIMER"s, 37},
|
|
{"RANDOMFISHINGTIMER"s, 38},
|
|
{"SPIRITSPEAKTIMER"s, 39},
|
|
{"DIRECTORY"s, 40},
|
|
{"DATADIRECTORY"s, 41},
|
|
{"DEFSDIRECTORY"s, 42},
|
|
{"ACTSDIRECTORY"s, 43},
|
|
{"BACKUPDIRECTORY"s, 44},
|
|
{"MSGBOARDDIRECTORY"s, 45},
|
|
{"SHAREDDIRECTORY"s, 46},
|
|
{"LOOTDECAYSWITHPLAYERCORPSE"s, 47},
|
|
{"GUARDSACTIVE"s, 49},
|
|
{"DEATHANIMATION"s, 27},
|
|
{"AMBIENTSOUNDS"s, 50},
|
|
{"AMBIENTFOOTSTEPS"s, 51},
|
|
{"INTERNALACCOUNTCREATION"s, 52},
|
|
{"SHOWOFFLINEPCS"s, 53},
|
|
{"ROGUESENABLED"s, 54},
|
|
{"PLAYERPERSECUTION"s, 55},
|
|
{"ACCOUNTFLUSH"s, 56},
|
|
{"HTMLSTATUSENABLED"s, 57},
|
|
{"SELLBYNAME"s, 58},
|
|
{"SELLMAXITEMS"s, 59},
|
|
{"TRADESYSTEM"s, 60},
|
|
{"RANKSYSTEM"s, 61},
|
|
{"CUTSCROLLREQUIREMENTS"s, 62},
|
|
{"CHECKITEMS"s, 63},
|
|
{"CHECKBOATS"s, 64},
|
|
{"CHECKNPCAI"s, 65},
|
|
{"CHECKSPAWNREGIONS"s, 66},
|
|
{"POSTINGLEVEL"s, 67},
|
|
{"REMOVALLEVEL"s, 68},
|
|
{"ESCORTENABLED"s, 69},
|
|
{"ESCORTINITEXPIRE"s, 70},
|
|
{"ESCORTACTIVEEXPIRE"s, 71},
|
|
{"MOON1"s, 72},
|
|
{"MOON2"s, 73},
|
|
{"DUNGEONLEVEL"s, 74},
|
|
{"CURRENTLEVEL"s, 75},
|
|
{"BRIGHTLEVEL"s, 76},
|
|
{"BASERANGE"s, 77},
|
|
{"BASETIMER"s, 78},
|
|
{"MAXTARGETS"s, 79},
|
|
{"MSGREDISPLAYTIME"s, 80},
|
|
{"MURDERDECAYTIMER"s, 81},
|
|
{"MAXKILLS"s, 82},
|
|
{"CRIMINALTIMER"s, 83},
|
|
{"MINECHECK"s, 84},
|
|
{"OREPERAREA"s, 85},
|
|
{"ORERESPAWNTIMER"s, 86},
|
|
{"RESOURCEAREASIZE"s, 87},
|
|
{"LOGSPERAREA"s, 88},
|
|
{"LOGSRESPAWNTIMER"s, 89},
|
|
{"STATSAFFECTSKILLCHECKS"s, 90 },
|
|
{"HUNGERRATE"s, 91},
|
|
{"HUNGERDMGVAL"s, 92},
|
|
{"MAXRANGE"s, 93},
|
|
{"SPELLMAXRANGE"s, 94},
|
|
{"DISPLAYHITMSG"s, 95},
|
|
{"MONSTERSVSANIMALS"s, 96},
|
|
{"ANIMALATTACKCHANCE"s, 97},
|
|
{"ANIMALSGUARDED"s, 98},
|
|
{"NPCDAMAGERATE"s, 99},
|
|
{"NPCBASEFLEEAT"s, 100},
|
|
{"NPCBASEREATTACKAT"s, 101},
|
|
{"ATTACKSTAMINA"s, 102},
|
|
{"LOCATION"s, 103},
|
|
{"STARTGOLD"s, 104},
|
|
{"STARTPRIVS"s, 105},
|
|
{"ESCORTDONEEXPIRE"s, 106},
|
|
{"DARKLEVEL"s, 107},
|
|
{"TITLECOLOUR"s, 108},
|
|
{"LEFTTEXTCOLOUR"s, 109},
|
|
{"RIGHTTEXTCOLOUR"s, 110},
|
|
{"BUTTONCANCEL"s, 111},
|
|
{"BUTTONLEFT"s, 112},
|
|
{"BUTTONRIGHT"s, 113},
|
|
{"BACKGROUNDPIC"s, 114},
|
|
{"POLLTIME"s, 115},
|
|
{"MAYORTIME"s, 116},
|
|
{"TAXPERIOD"s, 117},
|
|
{"GUARDSPAID"s, 118},
|
|
{"DAY"s, 119},
|
|
{"HOURS"s, 120},
|
|
{"MINUTES"s, 121},
|
|
{"SECONDS"s, 122},
|
|
{"AMPM"s, 123},
|
|
{"SKILLLEVEL"s, 124},
|
|
{"SNOOPISCRIME"s, 125},
|
|
{"BOOKSDIRECTORY"s, 126},
|
|
{"SKILLCAPSINGLE"s, 127},
|
|
{"PORT"s, 128},
|
|
{"ACCESSDIRECTORY"s, 129},
|
|
{"LOGSDIRECTORY"s, 130},
|
|
// 131 free
|
|
{"HTMLDIRECTORY"s, 132},
|
|
{"SHOOTONANIMALBACK"s, 133},
|
|
{"NPCTRAININGENABLED"s, 134},
|
|
{"DICTIONARYDIRECTORY"s, 135},
|
|
{"BACKUPSAVERATIO"s, 136},
|
|
{"HIDEWHILEMOUNTED"s, 137},
|
|
{"SECONDSPERUOMINUTE"s, 138},
|
|
{"WEIGHTPERSTR"s, 139},
|
|
{"POLYDURATION"s, 140},
|
|
{"UOGENABLED"s, 141},
|
|
{"NETRCVTIMEOUT"s, 142},
|
|
{"NETSNDTIMEOUT"s, 143},
|
|
{"NETRETRYCOUNT"s, 144},
|
|
{"CLIENTFEATURES"s, 145},
|
|
{"OVERLOADPACKETS"s, 146},
|
|
{"NPCMOVEMENTSPEED"s, 147},
|
|
{"PETHUNGEROFFLINE"s, 148},
|
|
{"PETOFFLINETIMEOUT"s, 149},
|
|
{"PETOFFLINECHECKTIMER"s, 150},
|
|
{"ARCHERRANGE"s, 151},
|
|
{"ADVANCEDPATHFINDING"s, 152},
|
|
{"SERVERFEATURES"s, 153},
|
|
{"LOOTINGISCRIME"s, 154},
|
|
{"NPCRUNNINGSPEED"s, 155},
|
|
{"NPCFLEEINGSPEED"s, 156},
|
|
{"BASICTOOLTIPSONLY"s, 157},
|
|
{"GLOBALITEMDECAY"s, 158},
|
|
{"SCRIPTITEMSDECAYABLE"s, 159},
|
|
{"BASEITEMSDECAYABLE"s, 160},
|
|
{"ITEMDECAYINHOUSES"s, 161},
|
|
{"SPAWNREGIONSFACETS"s, 162},
|
|
{"PAPERDOLLGUILDBUTTON"s, 163},
|
|
{"ATTACKSPEEDFROMSTAMINA"s, 164},
|
|
{"DISPLAYDAMAGENUMBERS"s, 169},
|
|
{"CLIENTSUPPORT4000"s, 170},
|
|
{"CLIENTSUPPORT5000"s, 171},
|
|
{"CLIENTSUPPORT6000"s, 172},
|
|
{"CLIENTSUPPORT6050"s, 173},
|
|
{"CLIENTSUPPORT7000"s, 174},
|
|
{"CLIENTSUPPORT7090"s, 175},
|
|
{"CLIENTSUPPORT70160"s, 176},
|
|
{"CLIENTSUPPORT70240"s, 177},
|
|
{"CLIENTSUPPORT70300"s, 178},
|
|
{"CLIENTSUPPORT70331"s, 179},
|
|
{"CLIENTSUPPORT704565"s, 180},
|
|
{"CLIENTSUPPORT70610"s, 181},
|
|
{"EXTENDEDSTARTINGSTATS"s, 182},
|
|
{"EXTENDEDSTARTINGSKILLS"s, 183},
|
|
{"WEAPONDAMAGECHANCE"s, 184},
|
|
{"ARMORDAMAGECHANCE"s, 185},
|
|
{"WEAPONDAMAGEMIN"s, 186},
|
|
{"WEAPONDAMAGEMAX"s, 187},
|
|
{"ARMORDAMAGEMIN"s, 188},
|
|
{"ARMORDAMAGEMAX"s, 189},
|
|
{"GLOBALATTACKSPEED"s, 190},
|
|
{"NPCSPELLCASTSPEED"s, 191},
|
|
{"FISHINGSTAMINALOSS"s, 192},
|
|
{"RANDOMSTARTINGLOCATION"s, 193},
|
|
{"ASSISTANTNEGOTIATION"s, 194},
|
|
{"KICKONASSISTANTSILENCE"s, 195},
|
|
{"AF_FILTERWEATHER"s, 196},
|
|
{"AF_FILTERLIGHT"s, 197},
|
|
{"AF_SMARTTARGET"s, 198},
|
|
{"AF_RANGEDTARGET"s, 199},
|
|
{"AF_AUTOOPENDOORS"s, 200},
|
|
{"AF_DEQUIPONCAST"s, 201},
|
|
{"AF_AUTOPOTIONEQUIP"s, 202},
|
|
{"AF_POISONEDCHECKS"s, 203},
|
|
{"AF_LOOPEDMACROS"s, 204},
|
|
{"AF_USEONCEAGENT"s, 205},
|
|
{"AF_RESTOCKAGENT"s, 206},
|
|
{"AF_SELLAGENT"s, 207},
|
|
{"AF_BUYAGENT"s, 208},
|
|
{"AF_POTIONHOTKEYS"s, 209},
|
|
{"AF_RANDOMTARGETS"s, 210},
|
|
{"AF_CLOSESTTARGETS"s, 211},
|
|
{"AF_OVERHEADHEALTH"s, 212},
|
|
{"AF_AUTOLOOTAGENT"s, 213},
|
|
{"AF_BONECUTTERAGENT"s, 214},
|
|
{"AF_JSCRIPTMACROS"s, 215},
|
|
{"AF_AUTOREMOUNT"s, 216},
|
|
// 217 free
|
|
{"CLASSICUOMAPTRACKER"s, 218},
|
|
{"DECAYTIMERINHOUSE"s, 219},
|
|
{"PROTECTPRIVATEHOUSES"s, 220},
|
|
{"TRACKHOUSESPERACCOUNT"s, 221},
|
|
{"MAXHOUSESOWNABLE"s, 222},
|
|
{"MAXHOUSESCOOWNABLE"s, 223},
|
|
{"CANOWNANDCOOWNHOUSES"s, 224},
|
|
{"COOWNHOUSESONSAMEACCOUNT"s, 225},
|
|
{"ITEMSDETECTSPEECH"s, 226},
|
|
{"MAXPLAYERPACKITEMS"s, 227},
|
|
{"MAXPLAYERBANKITEMS"s, 228},
|
|
{"FORCENEWANIMATIONPACKET"s, 229},
|
|
{"MAPDIFFSENABLED"s, 230},
|
|
{"CORESHARDERA"s, 231},
|
|
{"ARMORCALCULATION"s, 232},
|
|
{"STRENGTHDAMAGEBONUS"s, 233},
|
|
{"TACTICSDAMAGEBONUS"s, 234},
|
|
{"ANATOMYDAMAGEBONUS"s, 235},
|
|
{"LUMBERJACKDAMAGEBONUS"s, 236},
|
|
{"RACIALDAMAGEBONUS"s, 237},
|
|
{"DAMAGEBONUSCAP"s, 238},
|
|
{"SHIELDPARRY"s, 239},
|
|
{"PARRYDAMAGECHANCE"s, 240},
|
|
{"PARRYDAMAGEMIN"s, 241},
|
|
{"PARRYDAMAGEMAX"s, 242},
|
|
{"ARMORCLASSDAMAGEBONUS"s, 243},
|
|
{"FREESHARDSERVERPOLL"s, 244},
|
|
{"ALCHEMYBONUSENABLED"s, 245},
|
|
{"ALCHEMYBONUSMODIFIER"s, 246},
|
|
{"NPCFLAGUPDATETIMER"s, 247},
|
|
{"JSENGINESIZE"s, 248},
|
|
{"USEUNICODEMESSAGES"s, 249},
|
|
{"SCRIPTDATADIRECTORY"s, 250},
|
|
{"THIRSTRATE"s, 251},
|
|
{"THIRSTDRAINVAL"s, 252},
|
|
{"PETTHIRSTOFFLINE"s, 253},
|
|
{"EXTERNALIP"s, 254},
|
|
{"BLOODDECAYTIMER"s, 255},
|
|
{"BLOODDECAYCORPSETIMER"s, 256},
|
|
{"BLOODEFFECTCHANCE"s, 257},
|
|
{"NPCCORPSEDECAYTIMER"s, 258},
|
|
{"HUNGERENABLED"s, 259},
|
|
{"THIRSTENABLED"s, 260},
|
|
{"TRAVELSPELLSFROMBOATKEYS"s, 261},
|
|
{"TRAVELSPELLSWHILEOVERWEIGHT"s, 262},
|
|
{"MARKRUNESINMULTIS"s, 263},
|
|
{"TRAVELSPELLSBETWEENWORLDS"s, 264},
|
|
{"TRAVELSPELLSWHILEAGGRESSOR"s, 265},
|
|
{"BANKBUYTHRESHOLD"s, 266},
|
|
{"NETWORKLOG"s, 267},
|
|
{"SPEECHLOG"s, 268},
|
|
{"NPCMOUNTEDWALKINGSPEED"s, 269},
|
|
{"NPCMOUNTEDRUNNINGSPEED"s, 270},
|
|
{"NPCMOUNTEDFLEEINGSPEED"s, 271},
|
|
{"CONTEXTMENUS"s, 272},
|
|
{"SERVERLANGUAGE"s, 273},
|
|
{"CHECKPETCONTROLDIFFICULTY"s, 274},
|
|
{"PETLOYALTYGAINONSUCCESS"s, 275},
|
|
{"PETLOYALTYLOSSONFAILURE"s, 276},
|
|
{"PETLOYALTYRATE"s, 277},
|
|
{"SHOWNPCTITLESINTOOLTIPS"s, 278},
|
|
{"FISHPERAREA"s, 279},
|
|
{"FISHRESPAWNTIMER"s, 280},
|
|
{"ARCHERYHITBONUS"s, 281},
|
|
{"ITEMSINTERRUPTCASTING"s, 282},
|
|
{"SYSMESSAGECOLOUR"s, 283},
|
|
{"AF_AUTOBANDAGE"s, 284},
|
|
{"AF_ENEMYTARGETSHARE"s, 285},
|
|
{"AF_FILTERSEASON"s, 286},
|
|
{"AF_SPELLTARGETSHARE"s, 287},
|
|
{"AF_HUMANOIDHEALTHCHECKS"s, 288},
|
|
{"AF_SPEECHJOURNALCHECKS"s, 289},
|
|
{"ARCHERYSHOOTDELAY"s, 290},
|
|
{"MAXCLIENTBYTESIN"s, 291},
|
|
{"MAXCLIENTBYTESOUT"s, 292},
|
|
{"NETTRAFFICTIMEBAN"s, 293},
|
|
{"TOOLUSELIMIT"s, 294},
|
|
{"TOOLUSEBREAK"s, 295},
|
|
{"ITEMREPAIRDURABILITYLOSS"s, 296},
|
|
{"HIDESTATSFORUNKNOWNMAGICITEMS"s, 297},
|
|
{"CRAFTCOLOUREDWEAPONS"s, 298},
|
|
{"MAXSAFETELEPORTSPERDAY"s, 299},
|
|
{"TELEPORTTONEARESTSAFELOCATION"s, 300},
|
|
{"ALLOWAWAKENPCS"s, 301},
|
|
{"DISPLAYMAKERSMARK"s, 302},
|
|
{"SHOWNPCTITLESOVERHEAD"s, 303},
|
|
{"SHOWINVULNERABLETAGOVERHEAD"s, 304},
|
|
{"PETCOMBATTRAINING"s, 305},
|
|
{"HIRELINGCOMBATTRAINING"s, 306},
|
|
{"NPCCOMBATTRAINING"s, 307},
|
|
{"GLOBALRESTOCKMULTIPLIER"s, 308},
|
|
{"SHOWITEMRESISTSTATS"s, 309},
|
|
{"SHOWWEAPONDAMAGETYPES"s, 310},
|
|
{"SHOWRACEWITHNAME"s, 311},
|
|
{"SHOWRACEINPAPERDOLL"s, 312},
|
|
{"WEAPONPARRY"s, 313},
|
|
{"WRESTLINGPARRY"s, 314},
|
|
{"COMBATHITCHANCE"s, 315},
|
|
{"CASTSPELLSWHILEMOVING"s, 316},
|
|
{"SHOWREPUTATIONTITLEINTOOLTIP"s, 317},
|
|
{"SHOWGUILDINFOINTOOLTIP"s, 318},
|
|
{"MAXPLAYERPACKWEIGHT"s, 319},
|
|
{"MAXPLAYERBANKWEIGHT"s, 320},
|
|
{"SAFECOOWNERLOGOUT"s, 321},
|
|
{"SAFEFRIENDLOGOUT"s, 322},
|
|
{"SAFEGUESTLOGOUT"s, 323},
|
|
{"KEYLESSOWNERACCESS"s, 324},
|
|
{"KEYLESSCOOWNERACCESS"s, 325},
|
|
{"KEYLESSFRIENDACCESS"s, 326},
|
|
{"KEYLESSGUESTACCESS"s, 327},
|
|
{"WEAPONDAMAGEBONUSTYPE"s, 328},
|
|
{"OFFERBODSFROMITEMSALES"s, 329},
|
|
{"OFFERBODSFROMCONTEXTMENU"s, 330},
|
|
{"BODSFROMCRAFTEDITEMSONLY"s, 331},
|
|
{"BODGOLDREWARDMULTIPLIER"s, 332},
|
|
{"BODFAMEREWARDMULTIPLIER"s, 333},
|
|
{"ENABLENPCGUILDDISCOUNTS"s, 334},
|
|
{"ENABLENPCGUILDPREMIUMS"s, 335},
|
|
{"AGGRESSORFLAGTIMER"s, 336},
|
|
{"PERMAGREYFLAGTIMER"s, 337},
|
|
{"STEALINGFLAGTIMER"s, 338},
|
|
{"SNOOPAWARENESS"s, 339},
|
|
{"APSPERFTHRESHOLD"s, 340},
|
|
{"APSINTERVAL"s, 341},
|
|
{"APSDELAYSTEP"s, 342},
|
|
{"APSDELAYMAXCAP"s, 343},
|
|
{"YOUNGPLAYERSYSTEM"s, 344},
|
|
{"YOUNGLOCATION"s, 345},
|
|
{"SECRETSHARDKEY"s, 346},
|
|
{"MOONGATEFACETS"s, 347},
|
|
{"AUTOUNEQUIPPEDCASTING"s, 348},
|
|
{"LOOTDECAYSWITHNPCCORPSE"s, 349},
|
|
{"HEALTHREGENCAP"s, 350},
|
|
{"STAMINAREGENCAP"s, 351},
|
|
{"MANAREGENCAP"s, 352},
|
|
{"SWINGSPEEDINCREASECAP"s, 353},
|
|
{"KARMALOCKING"s, 354},
|
|
{"PHYSICALRESISTCAP"s, 355},
|
|
{"FIRERESISTCAP"s, 356},
|
|
{"COLDRESISTCAP"s, 357},
|
|
{"POISONRESISTCAP"s, 358},
|
|
{"ENERGYRESISTCAP"s, 359},
|
|
{"DEFENSECHANCEINCREASECAP"s, 360},
|
|
{"DAMAGEINCREASECAP"s, 361},
|
|
{"HEALINGAFFECTHEALTHREGEN"s, 362},
|
|
{"HPREGENMODE"s, 363},
|
|
{"STAMINAREGENMODE"s, 364},
|
|
{"MANAREGENMODE"s, 365},
|
|
{"HUNGERAFFECTHEALTHREGEN"s, 366},
|
|
{"THIRSTAFFECTSTAMINAREGEN"s, 367},
|
|
{"HUMANHEALTHREGENBONUS"s, 368},
|
|
{"HUMANSTAMINAREGENBONUS"s, 369},
|
|
{"HUMANMANAREGENBONUS"s, 370},
|
|
{"ELFHEALTHREGENBONUS"s, 371},
|
|
{"ELFSTAMINAREGENBONUS"s, 372},
|
|
{"ELFMANAREGENBONUS"s, 373},
|
|
{"GARGOYLEHEALTHREGENBONUS"s, 374},
|
|
{"GARGOYLESTAMINAREGENBONUS"s, 375},
|
|
{"GARGOYLEMANAREGENBONUS"s, 376},
|
|
{"HUMANMAXWEIGHTBONUS"s, 377},
|
|
{"ELFMAXWEIGHTBONUS"s, 378},
|
|
{"GARGOYLEMAXWEIGHTBONUS"s, 379},
|
|
{"MAXNPCAGGRORANGE"s, 380},
|
|
{"POISONCORROSIONSYSTEM"s, 381},
|
|
{"PETBONDINGENABLED"s, 382}
|
|
};
|
|
constexpr auto MAX_TRACKINGTARGETS = 128;
|
|
constexpr auto SKILLTOTALCAP = 7000;
|
|
constexpr auto SKILLCAP = 1000;
|
|
constexpr auto STATCAP = 225;
|
|
|
|
constexpr auto BIT_ANNOUNCESAVES = UI32( 0);
|
|
constexpr auto BIT_ANNOUNCEJOINPART = UI32( 1 );
|
|
constexpr auto BIT_SERVERBACKUP = UI32( 2 );
|
|
constexpr auto BIT_SHOOTONANIMALBACK = UI32( 3 );
|
|
constexpr auto BIT_NPCTRAINING = UI32( 4 );
|
|
constexpr auto BIT_LOOTDECAYSONPLAYERCORPSE = UI32( 5 );
|
|
constexpr auto BIT_GUARDSENABLED = UI32( 6 );
|
|
constexpr auto BIT_PLAYDEATHANIMATION = UI32( 7 );
|
|
constexpr auto BIT_AMBIENTFOOTSTEPS = UI32( 8 );
|
|
constexpr auto BIT_INTERNALACCOUNTS = UI32( 9 );
|
|
constexpr auto BIT_SHOWOFFLINEPCS = UI32( 10 );
|
|
constexpr auto BIT_ROGUESTATUS = UI32( 11 );
|
|
constexpr auto BIT_SNOOPISCRIME = UI32( 12 );
|
|
constexpr auto BIT_PERSECUTIONSTATUS = UI32( 13 );
|
|
constexpr auto BIT_SELLBYNAME = UI32( 14 );
|
|
constexpr auto BIT_TRADESYSSTATUS = UI32( 15 );
|
|
constexpr auto BIT_RANKSYSSTATUS = UI32( 16 );
|
|
constexpr auto BIT_CUTSCROLLREQ = UI32( 17 );
|
|
constexpr auto BIT_SHOWHITMESSAGE = UI32( 18 );
|
|
constexpr auto BIT_ESCORTSTATUS = UI32( 19 );
|
|
constexpr auto BIT_MONSTERSVSANIMALS = UI32( 20 );
|
|
constexpr auto BIT_PETHUNGEROFFLINE = UI32( 21 );
|
|
constexpr auto BIT_HIDEWHILEMOUNTED = UI32( 22 );
|
|
constexpr auto BIT_OVERLOADPACKETS = UI32( 23 );
|
|
constexpr auto BIT_ARMORAFFECTMANAREGEN = UI32( 24 );
|
|
constexpr auto BIT_ANIMALSGUARDED = UI32( 25 );
|
|
constexpr auto BIT_ADVANCEDPATHFIND = UI32( 26 );
|
|
constexpr auto BIT_LOOTINGISCRIME = UI32( 27 );
|
|
constexpr auto BIT_BASICTOOLTIPSONLY = UI32( 28 );
|
|
constexpr auto BIT_GLOBALITEMDECAY = UI32( 29 );
|
|
constexpr auto BIT_SCRIPTITEMSDECAYABLE = UI32( 30 );
|
|
constexpr auto BIT_BASEITEMSDECAYABLE = UI32( 31 );
|
|
constexpr auto BIT_ITEMDECAYINHOUSES = UI32( 32 );
|
|
constexpr auto BIT_PAPERDOLLGUILDBUTTON = UI32( 33 );
|
|
constexpr auto BIT_ATTSPEEDFROMSTAMINA = UI32( 34 );
|
|
constexpr auto BIT_SHOWDAMAGENUMBERS = UI32( 35 );
|
|
constexpr auto BIT_PETBONDINGENABLED = UI32( 37 );
|
|
constexpr auto BIT_EXTENDEDSTARTINGSTATS = UI32( 38 );
|
|
constexpr auto BIT_EXTENDEDSTARTINGSKILLS = UI32( 39 );
|
|
constexpr auto BIT_ASSISTANTNEGOTIATION = UI32( 40 );
|
|
constexpr auto BIT_KICKONASSISTANTSILENCE = UI32( 41 );
|
|
constexpr auto BIT_CLASSICUOMAPTRACKER = UI32( 42 );
|
|
constexpr auto BIT_PROTECTPRIVATEHOUSES = UI32( 43 );
|
|
constexpr auto BIT_TRACKHOUSESPERACCOUNT = UI32( 44 );
|
|
constexpr auto BIT_CANOWNANDCOOWNHOUSES = UI32( 45 );
|
|
constexpr auto BIT_COOWNHOUSESONSAMEACCOUNT = UI32( 46 );
|
|
constexpr auto BIT_ITEMSDETECTSPEECH = UI32( 47 );
|
|
constexpr auto BIT_FORCENEWANIMATIONPACKET = UI32( 48 );
|
|
constexpr auto BIT_MAPDIFFSENABLED = UI32( 49 );
|
|
constexpr auto BIT_ARMORCLASSDAMAGEBONUS = UI32( 50 );
|
|
constexpr auto BIT_FREESHARDSERVERPOLL = UI32( 51 );
|
|
constexpr auto BIT_ALCHEMYDAMAGEBONUSENABLED = UI32( 52 );
|
|
constexpr auto BIT_PETTHIRSTOFFLINE = UI32( 53 );
|
|
constexpr auto BIT_USEUNICODEMESSAGES = UI32( 54 );
|
|
constexpr auto BIT_HUNGERSYSTEMENABLED = UI32( 55 );
|
|
constexpr auto BIT_THIRSTSYSTEMENABLED = UI32( 56 );
|
|
constexpr auto BIT_TRAVELSPELLSFROMBOATKEYS = UI32( 57 );
|
|
constexpr auto BIT_TRAVELSPELLSWHILEOVERWEIGHT = UI32( 58 );
|
|
constexpr auto BIT_MARKRUNESINMULTIS = UI32( 59 );
|
|
constexpr auto BIT_TRAVELSPELLSBETWEENWORLDS = UI32( 60 );
|
|
constexpr auto BIT_TRAVELSPELLSWHILEAGGRESSOR = UI32( 61 );
|
|
[[maybe_unused]] constexpr auto BIT_CONSOLELOG = UI32( 62 );
|
|
constexpr auto BIT_NETWORKLOG = UI32( 63 );
|
|
constexpr auto BIT_SPEECHLOG = UI32( 64 );
|
|
constexpr auto BIT_CONTEXTMENUS = UI32( 65 );
|
|
constexpr auto BIT_CHECKPETCONTROLDIFFICULTY = UI32( 66 );
|
|
constexpr auto BIT_SHOWNPCTITLESINTOOLTIPS = UI32( 67 );
|
|
constexpr auto BIT_ITEMSINTERRUPTCASTING = UI32( 68 );
|
|
constexpr auto BIT_STATSAFFECTSKILLCHECKS = UI32( 69 );
|
|
constexpr auto BIT_TOOLUSELIMIT = UI32( 70 );
|
|
constexpr auto BIT_TOOLUSEBREAK = UI32( 71 );
|
|
constexpr auto BIT_ITEMREPAIRDURABILITYLOSS = UI32( 72 );
|
|
constexpr auto BIT_HIDESTATSFORUNKNOWNMAGICITEMS = UI32( 73 );
|
|
constexpr auto BIT_CRAFTCOLOUREDWEAPONS = UI32( 74 );
|
|
constexpr auto BIT_TELEPORTTONEARESTSAFELOC = UI32( 75 );
|
|
constexpr auto BIT_ALLOWAWAKENPCS = UI32( 76 );
|
|
constexpr auto BIT_DISPLAYMAKERSMARK = UI32( 77 );
|
|
constexpr auto BIT_SHOWNPCTITLESOVERHEAD = UI32( 78 );
|
|
constexpr auto BIT_SHOWINVULNERABLETAGOVERHEAD = UI32( 79 );
|
|
constexpr auto BIT_PETCOMBATTRAINING = UI32( 80 );
|
|
constexpr auto BIT_HIRELINGCOMBATTRAINING = UI32( 81 );
|
|
constexpr auto BIT_NPCCOMBATTRAINING = UI32( 82 );
|
|
constexpr auto BIT_SHOWITEMRESISTSTATS = UI32( 83 );
|
|
constexpr auto BIT_SHOWWEAPONDAMAGETYPES = UI32( 84 );
|
|
constexpr auto BIT_SHOWRACEWITHNAME = UI32( 85 );
|
|
constexpr auto BIT_SHOWRACEINPAPERDOLL = UI32( 86 );
|
|
constexpr auto BIT_CASTSPELLSWHILEMOVING = UI32( 87 );
|
|
constexpr auto BIT_SHOWREPTITLEINTOOLTIP = UI32( 88 );
|
|
constexpr auto BIT_SHOWGUILDINFOINTOOLTIP = UI32( 89 );
|
|
constexpr auto BIT_SAFECOOWNERLOGOUT = UI32( 90 );
|
|
constexpr auto BIT_SAFEFRIENDLOGOUT = UI32( 91 );
|
|
constexpr auto BIT_SAFEGUESTLOGOUT = UI32( 92 );
|
|
constexpr auto BIT_KEYLESSOWNERACCESS = UI32( 93 );
|
|
constexpr auto BIT_KEYLESSCOOWNERACCESS = UI32( 94 );
|
|
constexpr auto BIT_KEYLESSFRIENDACCESS = UI32( 95 );
|
|
constexpr auto BIT_KEYLESSGUESTACCESS = UI32( 96 );
|
|
constexpr auto BIT_OFFERBODSFROMITEMSALES = UI32( 97 );
|
|
constexpr auto BIT_OFFERBODSFROMCONTEXTMENU = UI32( 98 );
|
|
constexpr auto BIT_BODSFROMCRAFTEDITEMSONLY = UI32( 99 );
|
|
constexpr auto BIT_ENABLENPCGUILDDISCOUNTS = UI32( 100 );
|
|
constexpr auto BIT_ENABLENPCGUILDPREMIUMS = UI32( 101 );
|
|
constexpr auto BIT_SNOOPAWARENESS = UI32( 102 );
|
|
constexpr auto BIT_YOUNGPLAYERSYSTEM = UI32( 103 );
|
|
constexpr auto BIT_AUTOUNEQUIPPEDCASTING = UI32( 104 );
|
|
constexpr auto BIT_LOOTDECAYSONNPCCORPSE = UI32( 105 );
|
|
constexpr auto BIT_KARMALOCKING = UI32( 106 );
|
|
constexpr auto BIT_HEALINGAFFECTHEALTHREGEN = UI32( 107 );
|
|
constexpr auto BIT_HUNGERAFFECTHEALTHREGEN = UI32( 108 );
|
|
constexpr auto BIT_THIRSTAFFECTSTAMINAREGEN = UI32( 109 );
|
|
constexpr auto BIT_POISONCORROSIONSYSTEM = UI32( 110 );
|
|
|
|
|
|
// New uox3.ini format lookup
|
|
// January 13, 2001 - Modified: January 30, 2001 Converted to uppercase
|
|
// February 26 2002 - Modified: to support the AccountIsolation, and left out dir3ectory tags
|
|
// September 22 2002 - Added the "HIDEWHILEMOUNTED" tag to support hide fix
|
|
// September 06 2003 - Removed unused tags (heartbeat, wilderness, uoxbot, lagfix)
|
|
// October 16, 2003 - Removed unused tag (SAVEMODE) and added "WEIGHTPERSTR".
|
|
// April 3, 2004 - Added new tags, for UOG support, as well as new facet tags etc.
|
|
// June 15, 2004 - Added the new tags for the xFTPd, and xFTPc support.
|
|
// April 2, 2005 - Removed superfluous tags (BEGGINGTIMER, HUNGERDAMAGERATE, HUNGERTHRESHOLD, BEGGINGRANGE)
|
|
// September 13, 2005 - Added MAPCOUNT to the uox.ini to specify the number of maps UOX3 uses.
|
|
// November 20, 2005 - Removed USEFACETSAVES, MAP0, MAP1, MAP2, MAP3, USERMAP, FTPDENABLED,
|
|
// FTPDUSER, FTPDUSERLIMIT, FTPDBIND, FTPDROOT, FTPCENABLED, FTPCHOST,
|
|
// FTPCPORT, FTPCUSER, FTPCULFLAGS, and MAPCOUNT as they were unused.
|
|
// Added OVERLOADPACKETS option to uox.ini to toggle JS packet handling.
|
|
// December 13, 2005 - Changed uox.ini entry SHOWHIDDENNPCS to SHOWOFFLINEPCS to better reflect its function.
|
|
// Removed CACHEMULS from the uox.ini as it is no longer used.
|
|
// February 12, 2006 - Added NPCMOVEMENTSPEED to the UOX.ini to allow customization of NPC movement speeds.
|
|
// July 7, 2006 - PLAYERPERSECUTION in uox.ini (allows ghosts to drain mana from other players) set to 0 by default
|
|
// July 18, 2006 - Added uox.ini flag to disable/enable the A* Pathfinding routine: ADVANCEDPATHFINDING=0/1
|
|
// July 24, 2006 - Simplified many entries in uox.ini, making them easier to read.
|
|
// January 28, 2007 - Moved dynamic parts of [worldlight] section from uox.ini to their own output file in the /shared/ directory
|
|
// March 3, 2007 - Removed CLIENTSUPPORT from the uox.ini
|
|
// Allowed customization of supported client features via uox.ini
|
|
// CLIENTFEATURES
|
|
// SERVERFEATURES
|
|
// April 9, 2007 - Added a new setting to the uox.ini, LOOTINGISCRIME. If you set it to 0 looting corpses of innocent chars is not taken as a crime.
|
|
// June 10, 2007 - Added two new settings to the uox.ini, NPCRUNNINGSPEED and NPCFLEEINGSPEED, they work the same way as NPCMOVEMENTSPEED.
|
|
// July 28, 2007 - Added a new setting to the uox.ini: BASICTOOLTIPSONLY. If this is set to 1 the tooltips will only contain basic information, like the name and the weight of an item.
|
|
// February 7, 2010 - Added new UOX.INI settings:
|
|
// GLOBALITEMDECAY - Toggles on / off item decay on a global scale.Note that it does not remove the decay - status from items, it just resets the decay - timer when it reaches 0
|
|
// SCRIPTITEMSDECAYABLE - Toggles whether DFN - items will decay by default or not.Can be overriden by DECAY tag in item - DFNs
|
|
// BASEITEMSDECAYABLE - Toggles whether base - items will decay by default or not.Can be overriden by DECAY tag in harditems.dfn
|
|
// ITEMDECAYINHOUSES - Toggles default decay of non - locked down items inside multis( houses and boats )
|
|
// December 14, 20011 - Exposed CombatExplodeDelay to UOX.INI, and changed the default delay between targeting and damage for the Explosion spell from 0 to 2 seconds
|
|
// March 19, 2012 - Added support for packet 0xD7, SubCommand 0x28 - Guild button on paperdoll, which gives access to guild-functions if character belongs to a guild.
|
|
// Can be enabled / disabled through UOX.INI setting PAPERDOLLGUILDBUTTON = 0 / 1. Defaults to 0.
|
|
// Added new UOX.INI option to determine whether attack - speed bonuses are gained from Stamina( default ) or Dexterity: ATTACKSPEEDFROMSTAMINA = 1 / 0
|
|
// Added new UOX.INI option to control the displaying of damage - numbers in combat( previously used DISPLAYHITMSG for numbers too ) : DISPLAYDAMAGENUMBERS = 1 / 0
|
|
// Added a new section to UOX.INI - [clientsupport] - along with the following settings to determine approved client - versions for the server :
|
|
// CLIENTSUPPORT4000 = 0 / 1
|
|
// CLIENTSUPPORT5000 = 0 / 1
|
|
// CLIENTSUPPORT6000 = 0 / 1
|
|
// CLIENTSUPPORT6050 = 0 / 1
|
|
// CLIENTSUPPORT7000 = 0 / 1
|
|
// CLIENTSUPPORT7090 = 0 / 1
|
|
// CLIENTSUPPORT70160 = 0 / 1
|
|
// CLIENTSUPPORT70240 = 0 / 1
|
|
// NOTE: Each of these settings represent a range of clients, not just the individual versions mentioned.This means that CLIENTSUPPORT4000, for instance,
|
|
// will allow or disallow connections from clients 4.0.0 to 4.0.11f.Also note that while it is possible to enable support for all clients at the same time,
|
|
// it highly recommended to restrict support for client versions that match up to what the server is running.
|
|
// Added new UOX.INI option : EXTENDEDSTARTINGSTATS = 0 / 1
|
|
// If enabled, makes new characters start with 90 statpoints( selectable in clients 7.0.16.0 + only, lower versions only get 90 if using templates ) instead of 80.
|
|
// Added new UOX.INI option : EXTENDEDSTARTINGSKILLS = 0 / 1
|
|
// If enabled, allows for four starting skills( selectable in clients 7.0.16.0 + only, lower versions only get 4th skill if using templates ) instead of three
|
|
// November 14, 2012 - Fixed issue where DISPLAYDAMAGENUMBERS and ATTACKSPEEDFROMSTAMINA settings in UOX.INI were overwriting the DISPLAYHITMSG setting instead of their own respective settings
|
|
// November 10, 2013 - Added new UOX.INI settings for adjusting combat-speed on a global scale:
|
|
// GLOBALATTACKSPEED = 1 // for adjusting speed of melee and ranged attacks globally for all chars
|
|
// NPCSPELLCASTSPEED = 1 // for adjusting the overall speed of spellcasts for NPCs (base spellcast speed determined by SPADELAY tag in NPC dfns)
|
|
// Added new UOX.INI settings to make hardcoded damage to armor and weapons in combat more customizable :
|
|
// WEAPONDAMAGECHANCE = 17 // Chance of weapons taking damage when attacking
|
|
// WEAPONDAMAGEMIN = 0 // Minimum amount of damage a weapon takes if damaged in combat
|
|
// WEAPONDAMAGEMAX = 1 // Maximum amount of damage a weapon takes if damaged in combat
|
|
// ARMORDAMAGECHANCE = 25 // Chance of armor taking damage when defending
|
|
// ARMORDAMAGEMIN = 0 // Minimum amount of damage armor can take if damaged in combat
|
|
// ARMORDAMAGEMAX = 1 // Maximum amount of damage armor can take if damaged in combat
|
|
// September 12, 2015 - Added new UOX.INI setting for defining the amount of stamina lost when using the fishing skill
|
|
// FISHINGSTAMINALOSS = 2 // The amount of stamina lost when using the fishing skill
|
|
// November 24, 2019 - Added new uox.ini flag for choosing a random starting location for new players (from list in uox.ini)
|
|
// RANDOMSTARTINGLOCATION = 0 // 0 to disable (default), 1 to enable
|
|
|
|
// NOTE: Very important the first lookups required duplication or the search fails on them
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++
|
|
auto CServerData::LookupINIValue( const std::string& tag ) -> SI32
|
|
{
|
|
auto iter = uox3IniCaseValue.find( tag );
|
|
if( iter != uox3IniCaseValue.end() )
|
|
{
|
|
return iter->second;
|
|
}
|
|
return std::numeric_limits<SI32>::max();
|
|
}
|
|
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ResetDefaults()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Reset server settings to default
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ResetDefaults() -> void
|
|
{
|
|
resettingDefaults = true;
|
|
serverList.resize( 1 ); // Set the initial count to hold one server.
|
|
|
|
ServerIP( "127.0.0.1" );
|
|
ServerPort( 2593 );
|
|
ExternalIP( "127.0.0.1" );
|
|
serverList[0].SetPort( 2593 );
|
|
ServerName( "My UOX3 Shard" );
|
|
SecretShardKey( "None" );
|
|
|
|
// Set default gcMaxBytes limit in MB per JS runtime
|
|
// If set too low, UOX3 might crash when reloading (full) JS engine
|
|
// JS API references describe it as "Maximum nominal heap before last ditch GC"
|
|
SetJSEngineSize( 256 );
|
|
|
|
// Send server-originating messages in Unicode format, if possible
|
|
UseUnicodeMessages( true );
|
|
|
|
ServerLanguage( DL_DEFAULT );
|
|
SystemTimer( tSERVER_POTION, 10 );
|
|
ServerMoon( 0, 0 );
|
|
ServerMoon( 1, 0 );
|
|
DungeonLightLevel( 15 );
|
|
WorldLightCurrentLevel( 0 );
|
|
WorldLightBrightLevel( 0 );
|
|
WorldLightDarkLevel( 12 );
|
|
|
|
ServerNetRcvTimeout( 3 );
|
|
ServerNetSndTimeout( 3 );
|
|
ServerNetRetryCount( 3 );
|
|
MaxClientBytesIn( 50000 );
|
|
MaxClientBytesOut( 200000 );
|
|
NetTrafficTimeban( 30 );
|
|
|
|
// Adaptive Performance System
|
|
APSPerfThreshold( 50 ); // Default to 50 simulation cycles as performance threshold
|
|
APSInterval( 100 ); // Default to APS checking performance at 250 ms intervals
|
|
APSDelayStep( 50 ); // Default to 25 ms as the value at which APS gradually increments the delay to NPC AI/movement checking
|
|
APSDelayMaxCap( 2000 ); // Default to 1500 ms as max cap on delay APS can introduce to NPC AI/movement checking
|
|
|
|
ServerSecondsPerUOMinute( 5 );
|
|
ServerTimeDay( 0 );
|
|
ServerTimeHours( 0 );
|
|
ServerTimeMinutes( 0 );
|
|
ServerTimeSeconds( 0 );
|
|
ServerTimeAMPM( 0 );
|
|
|
|
InternalAccountStatus( true );
|
|
YoungPlayerSystem( true );
|
|
KarmaLocking( true );
|
|
CombatMaxRange( 10 );
|
|
CombatMaxSpellRange( 10 );
|
|
CombatMaxNpcAggroRange( 10 );
|
|
|
|
// load defaults values
|
|
SystemTimer( tSERVER_SHOPSPAWN, 300 );
|
|
SystemTimer( tSERVER_POISON, 180 );
|
|
SystemTimer( tSERVER_DECAY, 300 );
|
|
SystemTimer( tSERVER_DECAYINHOUSE, 3600 );
|
|
ServerSkillTotalCap( 7000 );
|
|
ServerSkillCap( 1000 );
|
|
ServerStatCap( 225 );
|
|
StatsAffectSkillChecks( false );
|
|
PlayerCorpseLootDecay( true );
|
|
NpcCorpseLootDecay( true );
|
|
ServerSavesTimer( 600 );
|
|
|
|
// Enable login-support only for latest available client by default
|
|
ClientSupport4000( false );
|
|
ClientSupport5000( false );
|
|
ClientSupport6000( false );
|
|
ClientSupport6050( false );
|
|
ClientSupport7000( false );
|
|
ClientSupport7090( false );
|
|
ClientSupport70160( false );
|
|
ClientSupport70240( false );
|
|
ClientSupport70300( false );
|
|
ClientSupport70331( false );
|
|
ClientSupport704565( false );
|
|
ClientSupport70610( true );
|
|
|
|
SystemTimer( tSERVER_INVISIBILITY, 60 );
|
|
SystemTimer( tSERVER_HUNGERRATE, 6000 );
|
|
HungerDamage( 2 );
|
|
HungerSystemEnabled( true );
|
|
HungerAffectHealthRegen( true );
|
|
|
|
SystemTimer( tSERVER_THIRSTRATE, 6000 );
|
|
ThirstDrain( 2 );
|
|
ThirstSystemEnabled( false );
|
|
ThirstAffectStaminaRegen( false );
|
|
|
|
ServerSkillDelay( 5 );
|
|
SystemTimer( tSERVER_OBJECTUSAGE, 1 );
|
|
SystemTimer( tSERVER_HITPOINTREGEN, 8 );
|
|
SystemTimer( tSERVER_STAMINAREGEN, 3 );
|
|
SystemTimer( tSERVER_MANAREGEN, 5 );
|
|
ArmorAffectManaRegen( true );
|
|
HealingAffectHealthRegen( true );
|
|
SnoopIsCrime( false );
|
|
SnoopAwareness( false );
|
|
SystemTimer( tSERVER_GATE, 30 );
|
|
MineCheck( 1 );
|
|
DeathAnimationStatus( true );
|
|
ShowOfflinePCs( true );
|
|
CombatDisplayHitMessage( true );
|
|
CombatDisplayDamageNumbers( true );
|
|
CombatAttackSpeedFromStamina( true );
|
|
CombatAttackStamina( -2 );
|
|
NPCTrainingStatus( true );
|
|
CharHideWhileMounted( true );
|
|
WeightPerStr( 3.5 );
|
|
SystemTimer( tSERVER_POLYMORPH, 90 );
|
|
ServerOverloadPackets( true );
|
|
AdvancedPathfinding( true );
|
|
LootingIsCrime( true );
|
|
ServerUOGEnabled( true );
|
|
FreeshardServerPoll( true );
|
|
ServerContextMenus( true );
|
|
SysMsgColour( 0x0048 );
|
|
|
|
CombatMonstersVsAnimals( true );
|
|
CombatAnimalsAttackChance( 2 );
|
|
CombatAnimalsGuarded( false );
|
|
CombatNPCBaseFleeAt( 20 );
|
|
CombatNPCBaseReattackAt( 40 );
|
|
ShootOnAnimalBack( false );
|
|
SellByNameStatus( false );
|
|
SkillLevel( 5 );
|
|
SellMaxItemsStatus( 250 );
|
|
CombatNpcDamageRate( 1 );
|
|
RankSystemStatus( true );
|
|
DisplayMakersMark( true );
|
|
CombatArcheryHitBonus( 10 );
|
|
CombatArcheryShootDelay( 1.0 );
|
|
CombatWeaponDamageChance( 17 );
|
|
CombatWeaponDamageMin( 0 );
|
|
CombatWeaponDamageMax( 1 );
|
|
CombatArmorDamageChance( 33 );
|
|
CombatArmorDamageMin( 0 );
|
|
CombatArmorDamageMax( 1 );
|
|
CombatParryDamageChance( 20 );
|
|
CombatParryDamageMin( 0 );
|
|
CombatParryDamageMax( 1 );
|
|
CombatBloodEffectChance( 75 );
|
|
PoisonCorrosionSystem( true );
|
|
GlobalAttackSpeed( 1.0 );
|
|
NPCSpellCastSpeed( 1.0 );
|
|
FishingStaminaLoss( 2 );
|
|
HealthRegenMode( HREG_LBR );
|
|
StaminaRegenMode( SREG_LBR );
|
|
ManaRegenMode( MREG_LBR );
|
|
HealthRegenCap( 18 );
|
|
StaminaRegenCap( 24 );
|
|
ManaRegenCap( 18 );
|
|
CombatArmorClassDamageBonus( false );
|
|
AlchemyDamageBonusEnabled( false );
|
|
AlchemyDamageBonusModifier( 5 );
|
|
PetCombatTraining( true );
|
|
HirelingCombatTraining( true );
|
|
NpcCombatTraining( false );
|
|
SwingSpeedIncreaseCap( 60 );
|
|
PhysicalResistCap( 70 );
|
|
FireResistCap( 70 );
|
|
ColdResistCap( 70 );
|
|
PoisonResistCap( 70 );
|
|
EnergyResistCap( 70 );
|
|
DefenseChanceIncreaseCap( 45 );
|
|
DamageIncreaseCap( 100 );
|
|
WeaponDamageBonusType( 2 );
|
|
|
|
CheckPetControlDifficulty( true );
|
|
SetPetLoyaltyGainOnSuccess( 1 );
|
|
SetPetLoyaltyLossOnFailure( 3 );
|
|
SystemTimer( tSERVER_LOYALTYRATE, 900 );
|
|
ItemsInterruptCasting( true );
|
|
|
|
auto curWorkingDir = std::filesystem::current_path().string();
|
|
|
|
auto wDir = oldstrutil::fixDirectory( curWorkingDir );
|
|
std::string tDir;
|
|
Directory( CSDDP_ROOT, wDir );
|
|
tDir = wDir + std::string( "muldata/" );
|
|
Directory( CSDDP_DATA, tDir );
|
|
tDir = wDir + std::string( "dfndata/" );
|
|
Directory( CSDDP_DEFS, tDir );
|
|
tDir = wDir + std::string( "accounts/" );
|
|
Directory( CSDDP_ACCOUNTS, tDir );
|
|
Directory( CSDDP_ACCESS, tDir );
|
|
tDir = wDir + std::string( "js/" );
|
|
Directory( CSDDP_SCRIPTS, tDir );
|
|
tDir = wDir + std::string( "js/jsdata" );
|
|
Directory( CSDDP_SCRIPTDATA, tDir );
|
|
tDir = wDir + std::string( "archives/" );
|
|
Directory( CSDDP_BACKUP, tDir );
|
|
tDir = wDir + std::string( "msgboards/" );
|
|
Directory( CSDDP_MSGBOARD, tDir );
|
|
tDir = wDir + std::string( "shared/" );
|
|
Directory( CSDDP_SHARED, tDir );
|
|
tDir = wDir + std::string( "html/" );
|
|
Directory( CSDDP_HTML, tDir );
|
|
tDir = wDir + std::string( "books/" );
|
|
Directory( CSDDP_BOOKS, tDir );
|
|
tDir = wDir + std::string( "dictionaries/" );
|
|
Directory( CSDDP_DICTIONARIES, tDir );
|
|
tDir = wDir + std::string( "logs/" );
|
|
Directory( CSDDP_LOGS, tDir );
|
|
|
|
// Expansion settings
|
|
ExpansionCoreShardEra( ER_LBR ); // Default to LBR expansion
|
|
ExpansionArmorCalculation( ER_CORE );
|
|
ExpansionStrengthDamageBonus( ER_CORE );
|
|
ExpansionTacticsDamageBonus( ER_CORE );
|
|
ExpansionAnatomyDamageBonus( ER_CORE );
|
|
ExpansionLumberjackDamageBonus( ER_CORE );
|
|
ExpansionRacialDamageBonus( ER_CORE );
|
|
ExpansionDamageBonusCap( ER_CORE );
|
|
ExpansionShieldParry( ER_CORE );
|
|
ExpansionWeaponParry( ER_CORE );
|
|
ExpansionWrestlingParry( ER_CORE );
|
|
ExpansionCombatHitChance( ER_CORE );
|
|
|
|
// Default Race Bonuses
|
|
HumanHealthRegenBonus( 0 ); // 2 from ML and onwards
|
|
HumanStaminaRegenBonus( 0 );
|
|
HumanManaRegenBonus( 0 );
|
|
HumanMaxWeightBonus( 0 );
|
|
ElfHealthRegenBonus( 0 );
|
|
ElfStaminaRegenBonus( 0 );
|
|
ElfManaRegenBonus( 0 );
|
|
ElfMaxWeightBonus( 0 );
|
|
GargoyleHealthRegenBonus( 0 );
|
|
GargoyleStaminaRegenBonus( 0 );
|
|
GargoyleManaRegenBonus( 2 ); // 2 from SA and onwards
|
|
GargoyleMaxWeightBonus( 0 );
|
|
|
|
BuyThreshold( 2000 );
|
|
GuardStatus( true );
|
|
ServerAnnounceSaves( true );
|
|
WorldAmbientSounds( 5 );
|
|
ServerJoinPartAnnouncements( true );
|
|
ServerConsoleLog( true );
|
|
ServerNetworkLog( false );
|
|
ServerSpeechLog( false );
|
|
RogueStatus( true );
|
|
SystemTimer( tSERVER_WEATHER, 60 );
|
|
SystemTimer( tSERVER_LOGINTIMEOUT, 300 );
|
|
BackupRatio( 5 );
|
|
MaxStealthMovement( 10 );
|
|
MaxStaminaMovement( 15 );
|
|
SystemTimer( tSERVER_NPCFLAGUPDATETIMER, 10 );
|
|
PetOfflineTimeout( 5 );
|
|
PetHungerOffline( true );
|
|
SystemTimer( tSERVER_PETOFFLINECHECK, 600 );
|
|
ItemsDetectSpeech( false );
|
|
MaxPlayerPackItems( 125 );
|
|
MaxPlayerBankItems( 125 );
|
|
MaxPlayerPackWeight( 40000 ); // 400.00 stones
|
|
MaxPlayerBankWeight( 160000 ); // 1600.00 stones
|
|
ForceNewAnimationPacket( true );
|
|
MapDiffsEnabled( false );
|
|
TravelSpellsFromBoatKeys( true );
|
|
TravelSpellsWhileOverweight( false );
|
|
MarkRunesInMultis( true );
|
|
TravelSpellsBetweenWorlds( false );
|
|
TravelSpellsWhileAggressor( false );
|
|
CastSpellsWhileMoving( false );
|
|
AutoUnequippedCasting( false );
|
|
MaxControlSlots( 0 ); // Default to 0, which is equal to off
|
|
MaxFollowers( 5 );
|
|
MaxPetOwners( 10 );
|
|
PetBondingEnabled( false );
|
|
ToolUseLimit( true );
|
|
ToolUseBreak( true );
|
|
ItemRepairDurabilityLoss( true );
|
|
HideStatsForUnknownMagicItems( true );
|
|
CraftColouredWeapons( false );
|
|
MaxSafeTeleportsPerDay( 1 );
|
|
TeleportToNearestSafeLocation( false );
|
|
AllowAwakeNPCs( true );
|
|
GlobalRestockMultiplier( 1.0 );
|
|
ShowItemResistStats( false );
|
|
ShowWeaponDamageTypes( true );
|
|
ShowReputationTitleInTooltip( true );
|
|
ShowGuildInfoInTooltip( true );
|
|
EnableNPCGuildDiscounts( true );
|
|
EnableNPCGuildPremiums( true );
|
|
|
|
CheckBoatSpeed( 0.65 );
|
|
CheckNpcAISpeed( 1 );
|
|
CutScrollRequirementStatus( true );
|
|
PlayerPersecutionStatus( false );
|
|
HtmlStatsStatus( -1 );
|
|
|
|
MsgBoardPostingLevel( 0 );
|
|
MsgBoardPostRemovalLevel( 0 );
|
|
// No replacement I can see
|
|
EscortsEnabled( true );
|
|
BasicTooltipsOnly( false );
|
|
ShowNpcTitlesInTooltips( true );
|
|
ShowNpcTitlesOverhead( true );
|
|
ShowInvulnerableTagOverhead( false );
|
|
ShowRaceWithName( true );
|
|
ShowRaceInPaperdoll( true );
|
|
GlobalItemDecay( true );
|
|
ScriptItemsDecayable( true );
|
|
BaseItemsDecayable( false );
|
|
SystemTimer( tSERVER_ESCORTWAIT, 900 );
|
|
SystemTimer( tSERVER_ESCORTACTIVE, 600 );
|
|
SystemTimer( tSERVER_ESCORTDONE, 600 );
|
|
AmbientFootsteps( false );
|
|
ServerCommandPrefix( '\'' );
|
|
|
|
CheckSpawnRegionSpeed( 30 );
|
|
CheckItemsSpeed( 1.5 );
|
|
NPCWalkingSpeed( 0.6 );
|
|
NPCRunningSpeed( 0.3 );
|
|
NPCFleeingSpeed( 0.4 );
|
|
NPCMountedWalkingSpeed( 0.3 );
|
|
NPCMountedRunningSpeed( 0.12 );
|
|
NPCMountedFleeingSpeed( 0.2 );
|
|
AccountFlushTimer( 5.0 );
|
|
|
|
// RESOURCES
|
|
ResourceAreaSize( 8 );
|
|
ResLogs( 3 );
|
|
ResLogTime( 600 );
|
|
ResOre( 10 );
|
|
ResOreTime( 600 );
|
|
ResFish( 10 );
|
|
ResFishTime( 600 );
|
|
|
|
//REPSYS
|
|
SystemTimer( tSERVER_CRIMINAL, 120 );
|
|
RepMaxKills( 4 );
|
|
SystemTimer( tSERVER_MURDERDECAY, 28800 );
|
|
SystemTimer( tSERVER_AGGRESSORFLAG, 120 );
|
|
SystemTimer( tSERVER_PERMAGREYFLAG, 0 ); // No duration by default
|
|
SystemTimer( tSERVER_STEALINGFLAG, 120 );
|
|
SystemTimer( tSERVER_COMBATIGNORE, 20 ); // Not in ini
|
|
|
|
//RepSys ---^
|
|
TrackingBaseRange( 10 );
|
|
TrackingMaxTargets( 20 );
|
|
TrackingBaseTimer( 30 );
|
|
TrackingRedisplayTime( 30 );
|
|
|
|
SystemTimer( tSERVER_FISHINGBASE, 10 );
|
|
SystemTimer( tSERVER_FISHINGRANDOM, 5 );
|
|
SystemTimer( tSERVER_SPIRITSPEAK, 30 );
|
|
|
|
TitleColour( 0 );
|
|
LeftTextColour( 0 );
|
|
RightTextColour( 0 );
|
|
ButtonCancel( 4017 );
|
|
ButtonLeft( 4014 );
|
|
ButtonRight( 4005 );
|
|
BackgroundPic( 5054 );
|
|
|
|
// Houses
|
|
ItemDecayInHouses( true );
|
|
ProtectPrivateHouses( true );
|
|
TrackHousesPerAccount( true );
|
|
CanOwnAndCoOwnHouses( true );
|
|
CoOwnHousesOnSameAccount( true );
|
|
MaxHousesOwnable( 1 );
|
|
MaxHousesCoOwnable( 10 );
|
|
SafeCoOwnerLogout( true );
|
|
SafeFriendLogout( true );
|
|
SafeGuestLogout( true );
|
|
KeylessOwnerAccess( true );
|
|
KeylessCoOwnerAccess( true );
|
|
KeylessFriendAccess( true );
|
|
KeylessGuestAccess( false );
|
|
|
|
// Bulk Order Deeds
|
|
OfferBODsFromItemSales( true );
|
|
OfferBODsFromContextMenu( false );
|
|
BODsFromCraftedItemsOnly( false );
|
|
BODGoldRewardMultiplier( 1.0 );
|
|
BODFameRewardMultiplier( 1.0 );
|
|
|
|
// Towns
|
|
TownNumSecsPollOpen( 3600 ); // one hour
|
|
TownNumSecsAsMayor( 36000 ); // 10 hours as mayor
|
|
TownTaxPeriod( 1800 ); // taxed every 30 minutes
|
|
TownGuardPayment( 3600 ); // guards paid every hour
|
|
|
|
SetClientFeature( CF_BIT_CHAT, true );
|
|
SetClientFeature( CF_BIT_UOR, true );
|
|
SetClientFeature( CF_BIT_TD, true );
|
|
SetClientFeature( CF_BIT_LBR, true );
|
|
SetClientFeature( CF_BIT_AOS, true );
|
|
SetClientFeature( CF_BIT_SIXCHARS, true );
|
|
SetClientFeature( CF_BIT_SE, true );
|
|
SetClientFeature( CF_BIT_ML, true );
|
|
SetClientFeature( CF_BIT_EXPANSION, true );
|
|
|
|
SetServerFeature( SF_BIT_CONTEXTMENUS, true );
|
|
SetServerFeature( SF_BIT_AOS, true );
|
|
SetServerFeature( SF_BIT_SIXCHARS, true );
|
|
SetServerFeature( SF_BIT_SE, true );
|
|
SetServerFeature( SF_BIT_ML, true );
|
|
|
|
// Disable spawn regions for all facets by default
|
|
SetSpawnRegionsFacetStatus( 0 );
|
|
|
|
// Enable Felucca by default
|
|
SetMoongateFacetStatus( 0, true );
|
|
|
|
// Enable Trammel by default
|
|
SetMoongateFacetStatus( 1, true );
|
|
|
|
// Enable Ilshenar by default
|
|
SetMoongateFacetStatus( 2, true );
|
|
|
|
// Set no assistant features as disabled by default
|
|
SetDisabledAssistantFeature( AF_ALL, false );
|
|
|
|
ExtendedStartingStats( true );
|
|
ExtendedStartingSkills( true );
|
|
|
|
ServerRandomStartingLocation( false );
|
|
ServerStartGold( 1000 );
|
|
ServerStartPrivs( 0 );
|
|
SystemTimer( tSERVER_CORPSEDECAY, 420 );
|
|
SystemTimer( tSERVER_NPCCORPSEDECAY, 420 );
|
|
SystemTimer( tSERVER_BLOODDECAYCORPSE, 210 ); // Default to half the decay timer of a npc corpse
|
|
SystemTimer( tSERVER_BLOODDECAY, 3 ); // Keep it short and sweet
|
|
startlocations.clear();
|
|
youngStartlocations.clear();
|
|
resettingDefaults = false;
|
|
}
|
|
//==================================================================================================
|
|
CServerData::CServerData()
|
|
{
|
|
Startup();
|
|
availableIPs = ip4list_t::available();
|
|
}
|
|
//==================================================================================================
|
|
auto CServerData::Startup() -> void
|
|
{
|
|
ResetDefaults();
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerName()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets server name. Sets to specified value, or to default name if no value specified
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerName() const -> const std::string&
|
|
{
|
|
return serverList[0].GetName();
|
|
}
|
|
auto CServerData::ServerName( const std::string &setname ) -> void
|
|
{
|
|
if( serverList.empty() )
|
|
{
|
|
serverList.resize( 1 );
|
|
}
|
|
serverList[0].SetName( setname );
|
|
if( setname.empty() )
|
|
{
|
|
serverList[0].SetName( "My UOX3 Shard" );
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::SecretShardKey()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets secret shard key used to only allows connections from specific
|
|
//| custom clients that provide a matching secret key
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::SecretShardKey() const -> const std::string&
|
|
{
|
|
return secretShardKey;
|
|
}
|
|
auto CServerData::SecretShardKey( const std::string &newName ) -> void
|
|
{
|
|
if( !newName.empty() )
|
|
{
|
|
secretShardKey = newName;
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerDomain()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets server domain. Sets to specified value, or to no domain if no value specified
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerDomain() const -> const std::string&
|
|
{
|
|
return serverList[0].GetDomain();
|
|
}
|
|
auto CServerData::ServerDomain( const std::string &setdomain ) -> void
|
|
{
|
|
if( serverList.empty() )
|
|
{
|
|
serverList.resize( 1 );
|
|
}
|
|
if( setdomain.empty() )
|
|
{
|
|
serverList[0].SetDomain( "" );
|
|
}
|
|
else
|
|
{
|
|
serverList[0].SetDomain( setdomain );
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerIP()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets server IP. Sets to specified value, or to loopback IP if no value specified
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerIP() const -> const std::string &
|
|
{
|
|
return serverList[0].GetIP();
|
|
}
|
|
auto CServerData::ServerIP( const std::string &setip ) -> void
|
|
{
|
|
if( serverList.empty() )
|
|
{
|
|
serverList.resize( 1 );
|
|
}
|
|
if( setip.empty() )
|
|
{
|
|
serverList[0].SetIP("127.0.0.1" );
|
|
}
|
|
else
|
|
{
|
|
serverList[0].SetIP( setip );
|
|
}
|
|
}
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ExternalIP()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets external (WAN) IP for server
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ExternalIP() const -> const std::string&
|
|
{
|
|
return externalIP;
|
|
}
|
|
auto CServerData::ExternalIP( const std::string &ip ) -> void
|
|
{
|
|
externalIP = ip;
|
|
//IP4Address::setExternal( externalIP );
|
|
}
|
|
auto CServerData::matchIP( const Ip4Addr_st &ip ) const -> Ip4Addr_st
|
|
{
|
|
auto [candidate, match] = availableIPs.bestmatch( ip );
|
|
if( match == 0 )
|
|
{
|
|
if( !externalIP.empty() )
|
|
{
|
|
candidate = Ip4Addr_st( externalIP );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// We got some kind of match, see if on same network type?
|
|
if( candidate.type() != ip.type() )
|
|
{
|
|
if( ip.type() == Ip4Addr_st::ip4type_t::wan )
|
|
{
|
|
if( !externalIP.empty() )
|
|
{
|
|
candidate = Ip4Addr_st( externalIP );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return candidate;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerPort()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Set server port to specified value, or to default port if no value specified
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerPort() const -> UI16
|
|
{
|
|
return port;
|
|
}
|
|
auto CServerData::ServerPort( UI16 setport ) -> void
|
|
{
|
|
if( setport == 0 )
|
|
{
|
|
port = 2593;
|
|
}
|
|
else
|
|
{
|
|
port = setport;
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerConsoleLog()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Set logging of console messages, warnings and errors
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerConsoleLog() const -> bool
|
|
{
|
|
return consoleLogEnabled;
|
|
}
|
|
auto CServerData::ServerConsoleLog( bool setting ) -> void
|
|
{
|
|
consoleLogEnabled = setting;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerNetworkLog()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets logging of network traffic to logs folder
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerNetworkLog() const -> bool
|
|
{
|
|
return boolVals.test( BIT_NETWORKLOG );
|
|
}
|
|
auto CServerData::ServerNetworkLog( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_NETWORKLOG, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerSpeechLog()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets logging of player/staff speech to logs folder
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerSpeechLog() const -> bool
|
|
{
|
|
return boolVals.test( BIT_SPEECHLOG );
|
|
}
|
|
auto CServerData::ServerSpeechLog( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_SPEECHLOG, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerCommandPrefix()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Set command prefix
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerCommandPrefix() const -> char
|
|
{
|
|
return commandprefix.empty() ? 0 : commandprefix[0];
|
|
}
|
|
auto CServerData::ServerCommandPrefix( char cmdvalue ) -> void
|
|
{
|
|
commandprefix = std::string( 1, cmdvalue );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerAnnounceSavesStatus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Set status of server accouncements for worldsaves
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerAnnounceSavesStatus() const -> bool
|
|
{
|
|
return boolVals.test( BIT_ANNOUNCESAVES );
|
|
}
|
|
auto CServerData::ServerAnnounceSaves( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_ANNOUNCESAVES, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerJoinPartAnnouncementsStatus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets status of server accouncements for players connecting/disconnecting
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerJoinPartAnnouncementsStatus() const -> bool
|
|
{
|
|
return boolVals.test( BIT_ANNOUNCEJOINPART );
|
|
}
|
|
auto CServerData::ServerJoinPartAnnouncements( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_ANNOUNCEJOINPART, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerBackupStatus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets enabled status of server worldsave backups
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerBackupStatus() const -> bool
|
|
{
|
|
return boolVals.test( BIT_SERVERBACKUP );
|
|
}
|
|
auto CServerData::ServerBackups( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_SERVERBACKUP, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerContextMenus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets enabled status of context menus
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerContextMenus() const -> bool
|
|
{
|
|
return boolVals.test( BIT_CONTEXTMENUS );
|
|
}
|
|
auto CServerData::ServerContextMenus( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_CONTEXTMENUS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::SysMsgColour()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default text colour for system messages displayed in bottom left
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::SysMsgColour() const -> UI16
|
|
{
|
|
return sysMsgColour;
|
|
}
|
|
auto CServerData::SysMsgColour( UI16 value ) -> void
|
|
{
|
|
sysMsgColour = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerSavesTimerStatus()
|
|
//| CServerData::ServerSavesTimer()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets server world save timer
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerSavesTimerStatus() const -> UI32
|
|
{
|
|
return serverSavesTimer;
|
|
}
|
|
auto CServerData::ServerSavesTimer( UI32 timer ) -> void
|
|
{
|
|
serverSavesTimer = timer;
|
|
if( timer < 180 ) // 3 minutes is the lowest value you can set saves for
|
|
{
|
|
serverSavesTimer = 300; // 10 minutes default
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerSkillCapStatus()
|
|
//| CServerData::ServerSkillCap()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets cap for individual skills
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerSkillCapStatus() const -> UI16
|
|
{
|
|
return skillCap;
|
|
}
|
|
auto CServerData::ServerSkillCap( UI16 cap ) -> void
|
|
{
|
|
skillCap = cap;
|
|
if( cap < 1 ) // Default is on second loop sleeping
|
|
{
|
|
skillCap = SKILLCAP;
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerSkillTotalCapStatus()
|
|
//| CServerData::ServerSkillTotalCap()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets total cap for all skills
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerSkillTotalCapStatus() const -> UI16
|
|
{
|
|
return skillTotalCap;
|
|
}
|
|
auto CServerData::ServerSkillTotalCap( UI16 cap ) -> void
|
|
{
|
|
skillTotalCap = cap;
|
|
if( cap < 1 ) // Default is on second loop sleeping
|
|
{
|
|
skillTotalCap = SKILLTOTALCAP;
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerSkillDelayStatus()
|
|
//| CServerData::ServerSkillDelay()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the global delay for skill usage
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerSkillDelayStatus() const -> UI08
|
|
{
|
|
return skillDelay;
|
|
}
|
|
auto CServerData::ServerSkillDelay( UI08 skdelay ) -> void
|
|
{
|
|
skillDelay = skdelay;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerStatCapStatus()
|
|
//| CServerData::ServerStatCap()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the total stat cap
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerStatCapStatus() const -> UI16
|
|
{
|
|
return statCap;
|
|
}
|
|
auto CServerData::ServerStatCap( UI16 cap ) -> void
|
|
{
|
|
statCap = cap;
|
|
if( cap < 1 ) // Default is on second loop sleeping
|
|
{
|
|
statCap = STATCAP;
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::MaxStealthMovement()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the max number of steps allowed to take while stealthed
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::MaxStealthMovement() const -> SI16
|
|
{
|
|
return maxStealthMovement;
|
|
}
|
|
auto CServerData::MaxStealthMovement( SI16 value ) -> void
|
|
{
|
|
maxStealthMovement = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::MaxStaminaMovement()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the max number of steps allowed while running before stamina is reduced
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::MaxStaminaMovement() const -> SI16
|
|
{
|
|
return maxStaminaMovement;
|
|
}
|
|
auto CServerData::MaxStaminaMovement( SI16 value ) -> void
|
|
{
|
|
maxStaminaMovement = value;
|
|
}
|
|
|
|
auto CServerData::BuildSystemTimeValue( cSD_TID timerId ) const -> TIMERVAL
|
|
{
|
|
return BuildTimeValue( static_cast<R64>( SystemTimer( timerId )));
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::PetBondingEnabled()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets status of server accouncements for players connecting/disconnecting
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::PetBondingEnabled() const -> bool
|
|
{
|
|
return boolVals.test( BIT_PETBONDINGENABLED );
|
|
}
|
|
auto CServerData::PetBondingEnabled( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_PETBONDINGENABLED, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::SystemTimer()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets a specific server timer
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::SystemTimer( cSD_TID timerid ) const -> UI16
|
|
{
|
|
return serverTimers[timerid];
|
|
}
|
|
auto CServerData::SystemTimer( cSD_TID timerid, UI16 value ) -> void
|
|
{
|
|
serverTimers[timerid] = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - Directory()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets directory paths
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::Directory( CSDDirectoryPaths dp ) -> std::string
|
|
{
|
|
std::string rValue;
|
|
if( dp != CSDDP_COUNT )
|
|
{
|
|
rValue = serverDirectories[dp];
|
|
}
|
|
return rValue;
|
|
}
|
|
auto CServerData::Directory( CSDDirectoryPaths dp, std::string value ) -> void
|
|
{
|
|
bool create_dir = false;
|
|
|
|
if( dp != CSDDP_COUNT )
|
|
{
|
|
std::string verboseDirectory;
|
|
switch( dp )
|
|
{
|
|
case CSDDP_ROOT: verboseDirectory = "Root directory"; break;
|
|
case CSDDP_DATA: verboseDirectory = "Data directory"; break;
|
|
case CSDDP_DEFS: verboseDirectory = "DFNs directory"; break;
|
|
case CSDDP_ACCESS: verboseDirectory = "Access directory"; break;
|
|
case CSDDP_ACCOUNTS: verboseDirectory = "Accounts directory"; break;
|
|
case CSDDP_SCRIPTS: verboseDirectory = "Scripts directory"; break;
|
|
case CSDDP_SCRIPTDATA: verboseDirectory = "ScriptData directory";
|
|
create_dir = true;
|
|
break;
|
|
case CSDDP_BACKUP: verboseDirectory = "Backup directory"; break;
|
|
case CSDDP_MSGBOARD: verboseDirectory = "Messageboard directory"; break;
|
|
case CSDDP_SHARED: verboseDirectory = "Shared directory";
|
|
create_dir = true;
|
|
break;
|
|
case CSDDP_HTML: verboseDirectory = "HTML directory"; break;
|
|
case CSDDP_LOGS: verboseDirectory = "Logs directory"; break;
|
|
case CSDDP_DICTIONARIES: verboseDirectory = "Dictionary directory"; break;
|
|
case CSDDP_BOOKS: verboseDirectory = "Books directory"; break;
|
|
case CSDDP_COUNT:
|
|
default: verboseDirectory = "Unknown directory"; break;
|
|
};
|
|
// First, let's normalize the path name and fix common errors
|
|
// remove all trailing and leading spaces...
|
|
auto sText = oldstrutil::trim( value );
|
|
|
|
if( sText.empty() )
|
|
{
|
|
Console.Error( oldstrutil::format( " %s directory is blank, set in uox.ini", verboseDirectory.c_str() ));
|
|
Shutdown( FATAL_UOX3_DIR_NOT_FOUND );
|
|
}
|
|
else
|
|
{
|
|
// Make sure we're terminated with a directory separator
|
|
// Just incase it's not set in the .ini
|
|
// and convert the windows backward slashes to forward slashes
|
|
|
|
sText = oldstrutil::fixDirectory( sText );
|
|
|
|
bool error = false;
|
|
if( !resettingDefaults )
|
|
{
|
|
error = true;
|
|
//auto curWorkingDir = fixDirectory( std::filesystem::current_path().string() );
|
|
|
|
auto npath = std::filesystem::path( sText );
|
|
|
|
if( std::filesystem::exists( npath ))
|
|
{
|
|
error = false;
|
|
}
|
|
else if( create_dir )
|
|
{
|
|
// Create missing directory
|
|
std::filesystem::create_directory( npath );
|
|
error = false;
|
|
}
|
|
}
|
|
|
|
if( error )
|
|
{
|
|
Console.Error( oldstrutil::format( "%s %s does not exist", verboseDirectory.c_str(), sText.c_str() ));
|
|
Shutdown( FATAL_UOX3_DIR_NOT_FOUND );
|
|
}
|
|
else
|
|
{
|
|
// There was a check to see if text was empty, to set to "./". However, if text was blank, we bailed out in the
|
|
// beginning of the routine
|
|
serverDirectories[dp] = sText;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ExpansionCoreShardEra()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Set core era ruleset for shard
|
|
//| Notes - 0 = Core (used to inherit CoreShardEra setting)
|
|
//| 1 = UO - Original UO release
|
|
//| 2 = T2A - The Second Age
|
|
//| 3 = UOR - Rennaissance
|
|
//| 4 = TD - Third Dawn
|
|
//| 5 = LBR - Lord Blackthorn's Revenge
|
|
//| 6 = AoS - Age of Shadows
|
|
//| 7 = SE - Samurai Empire
|
|
//| 8 = ML - Mondain's Legacy
|
|
//| 9 = SA - Stygian Abyss
|
|
//| 10 = HS - High Seas
|
|
//| 11 = ToL - Time of Legends
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ExpansionCoreShardEra( void ) const -> UI08
|
|
{
|
|
return coreShardEra;
|
|
}
|
|
auto CServerData::ExpansionCoreShardEra( UI08 setting ) -> void
|
|
{
|
|
if( setting >= ER_COUNT )
|
|
{
|
|
setting = ER_COUNT - 1;
|
|
}
|
|
coreShardEra = setting;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ExpansionArmorCalculation()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Set era ruleset for armor/defense calculation
|
|
//| Notes - 0 = Core (used to inherit CoreShardEra setting)
|
|
//| 1 = UO - Original UO release
|
|
//| 2 = T2A - The Second Age
|
|
//| 3 = UOR - Rennaissance
|
|
//| 4 = TD - Third Dawn
|
|
//| 5 = LBR - Lord Blackthorn's Revenge
|
|
//| 6 = AoS - Age of Shadows
|
|
//| 7 = SE - Samurai Empire
|
|
//| 8 = ML - Mondain's Legacy
|
|
//| 9 = SA - Stygian Abyss
|
|
//| 10 = HS - High Seas
|
|
//| 11 = ToL - Time of Legends
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ExpansionArmorCalculation() const -> UI08
|
|
{
|
|
if( static_cast<ExpansionRuleset>( expansionArmorCalculation ) == ER_CORE )
|
|
{
|
|
// Inherit CoreShardEra setting
|
|
return ExpansionCoreShardEra();
|
|
}
|
|
return expansionArmorCalculation;
|
|
}
|
|
auto CServerData::ExpansionArmorCalculation( UI08 setting ) -> void
|
|
{
|
|
if( setting >= ER_COUNT )
|
|
{
|
|
setting = ER_COUNT - 1;
|
|
}
|
|
else if( static_cast<ExpansionRuleset>( setting ) == ER_CORE )
|
|
{
|
|
setting = ExpansionCoreShardEra();
|
|
}
|
|
expansionArmorCalculation = setting;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ExpansionStrengthDamageBonus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Set era ruleset for strength damage bonus
|
|
//| Notes - 0 = Core (used to inherit CoreShardEra setting)
|
|
//| 1 = UO - Original UO release
|
|
//| 2 = T2A - The Second Age
|
|
//| 3 = UOR - Rennaissance
|
|
//| 4 = TD - Third Dawn
|
|
//| 5 = LBR - Lord Blackthorn's Revenge
|
|
//| 6 = AoS - Age of Shadows
|
|
//| 7 = SE - Samurai Empire
|
|
//| 8 = ML - Mondain's Legacy
|
|
//| 9 = SA - Stygian Abyss
|
|
//| 10 = HS - High Seas
|
|
//| 11 = ToL - Time of Legends
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ExpansionStrengthDamageBonus() const -> UI08
|
|
{
|
|
if( static_cast<ExpansionRuleset>( expansionStrengthDamageBonus ) == ER_CORE )
|
|
{
|
|
// Inherit CoreShardEra setting
|
|
return ExpansionCoreShardEra();
|
|
}
|
|
return expansionStrengthDamageBonus;
|
|
}
|
|
auto CServerData::ExpansionStrengthDamageBonus( UI08 setting ) -> void
|
|
{
|
|
if( setting >= ER_COUNT )
|
|
{
|
|
setting = ER_COUNT - 1;
|
|
}
|
|
expansionStrengthDamageBonus = setting;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ExpansionTacticsDamageBonus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Set era ruleset for tactics damage bonus
|
|
//| Notes - 0 = Core (used to inherit CoreShardEra setting)
|
|
//| 1 = UO - Original UO release
|
|
//| 2 = T2A - The Second Age
|
|
//| 3 = UOR - Rennaissance
|
|
//| 4 = TD - Third Dawn
|
|
//| 5 = LBR - Lord Blackthorn's Revenge
|
|
//| 6 = AoS - Age of Shadows
|
|
//| 7 = SE - Samurai Empire
|
|
//| 8 = ML - Mondain's Legacy
|
|
//| 9 = SA - Stygian Abyss
|
|
//| 10 = HS - High Seas
|
|
//| 11 = ToL - Time of Legends
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ExpansionTacticsDamageBonus() const -> UI08
|
|
{
|
|
if( static_cast<ExpansionRuleset>( expansionTacticsDamageBonus ) == ER_CORE )
|
|
{
|
|
// Inherit CoreShardEra setting
|
|
return ExpansionCoreShardEra();
|
|
}
|
|
return expansionTacticsDamageBonus;
|
|
}
|
|
auto CServerData::ExpansionTacticsDamageBonus( UI08 setting ) -> void
|
|
{
|
|
if( setting >= ER_COUNT )
|
|
{
|
|
setting = ER_COUNT - 1;
|
|
}
|
|
expansionTacticsDamageBonus = setting;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ExpansionAnatomyDamageBonus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Set era ruleset for anatomy damage bonus
|
|
//| Notes - 0 = Core (used to inherit CoreShardEra setting)
|
|
//| 1 = UO - Original UO release
|
|
//| 2 = T2A - The Second Age
|
|
//| 3 = UOR - Rennaissance
|
|
//| 4 = TD - Third Dawn
|
|
//| 5 = LBR - Lord Blackthorn's Revenge
|
|
//| 6 = AoS - Age of Shadows
|
|
//| 7 = SE - Samurai Empire
|
|
//| 8 = ML - Mondain's Legacy
|
|
//| 9 = SA - Stygian Abyss
|
|
//| 10 = HS - High Seas
|
|
//| 11 = ToL - Time of Legends
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ExpansionAnatomyDamageBonus() const -> UI08
|
|
{
|
|
if( static_cast<ExpansionRuleset>( expansionAnatomyDamageBonus ) == ER_CORE )
|
|
{
|
|
// Inherit CoreShardEra setting
|
|
return ExpansionCoreShardEra();
|
|
}
|
|
return expansionAnatomyDamageBonus;
|
|
}
|
|
auto CServerData::ExpansionAnatomyDamageBonus( UI08 setting ) -> void
|
|
{
|
|
if( setting >= ER_COUNT )
|
|
{
|
|
setting = ER_COUNT - 1;
|
|
}
|
|
expansionAnatomyDamageBonus = setting;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ExpansionLumberjackDamageBonus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Set era ruleset for lumberjack damage bonus
|
|
//| Notes - 0 = Core (used to inherit CoreShardEra setting)
|
|
//| 1 = UO - Original UO release
|
|
//| 2 = T2A - The Second Age
|
|
//| 3 = UOR - Rennaissance
|
|
//| 4 = TD - Third Dawn
|
|
//| 5 = LBR - Lord Blackthorn's Revenge
|
|
//| 6 = AoS - Age of Shadows
|
|
//| 7 = SE - Samurai Empire
|
|
//| 8 = ML - Mondain's Legacy
|
|
//| 9 = SA - Stygian Abyss
|
|
//| 10 = HS - High Seas
|
|
//| 11 = ToL - Time of Legends
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ExpansionLumberjackDamageBonus() const -> UI08
|
|
{
|
|
if( static_cast<ExpansionRuleset>( expansionLumberjackDamageBonus ) == ER_CORE )
|
|
{
|
|
// Inherit CoreShardEra setting
|
|
return ExpansionCoreShardEra();
|
|
}
|
|
return expansionLumberjackDamageBonus;
|
|
}
|
|
auto CServerData::ExpansionLumberjackDamageBonus( UI08 setting ) -> void
|
|
{
|
|
if( setting >= ER_COUNT )
|
|
{
|
|
setting = ER_COUNT - 1;
|
|
}
|
|
expansionLumberjackDamageBonus = setting;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ExpansionRacialDamageBonus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Set era ruleset for racial damage bonus
|
|
//| Notes - 0 = Core (used to inherit CoreShardEra setting)
|
|
//| 1 = UO - Original UO release
|
|
//| 2 = T2A - The Second Age
|
|
//| 3 = UOR - Rennaissance
|
|
//| 4 = TD - Third Dawn
|
|
//| 5 = LBR - Lord Blackthorn's Revenge
|
|
//| 6 = AoS - Age of Shadows
|
|
//| 7 = SE - Samurai Empire
|
|
//| 8 = ML - Mondain's Legacy
|
|
//| 9 = SA - Stygian Abyss
|
|
//| 10 = HS - High Seas
|
|
//| 11 = ToL - Time of Legends
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ExpansionRacialDamageBonus() const -> UI08
|
|
{
|
|
if( static_cast<ExpansionRuleset>( expansionRacialDamageBonus ) == ER_CORE )
|
|
{
|
|
// Inherit CoreShardEra setting
|
|
return ExpansionCoreShardEra();
|
|
}
|
|
return expansionRacialDamageBonus;
|
|
}
|
|
auto CServerData::ExpansionRacialDamageBonus( UI08 setting ) -> void
|
|
{
|
|
if( setting >= ER_COUNT )
|
|
{
|
|
setting = ER_COUNT - 1;
|
|
}
|
|
expansionRacialDamageBonus = setting;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ExpansionDamageBonusCap()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Set era ruleset for cap applied to damage bonus
|
|
//| Notes - 0 = Core (used to inherit CoreShardEra setting)
|
|
//| 1 = UO - Original UO release
|
|
//| 2 = T2A - The Second Age
|
|
//| 3 = UOR - Rennaissance
|
|
//| 4 = TD - Third Dawn
|
|
//| 5 = LBR - Lord Blackthorn's Revenge
|
|
//| 6 = AoS - Age of Shadows
|
|
//| 7 = SE - Samurai Empire
|
|
//| 8 = ML - Mondain's Legacy
|
|
//| 9 = SA - Stygian Abyss
|
|
//| 10 = HS - High Seas
|
|
//| 11 = ToL - Time of Legends
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ExpansionDamageBonusCap() const -> UI08
|
|
{
|
|
if( static_cast<ExpansionRuleset>( expansionDamageBonusCap ) == ER_CORE )
|
|
{
|
|
// Inherit CoreShardEra setting
|
|
return ExpansionCoreShardEra();
|
|
}
|
|
return expansionDamageBonusCap;
|
|
}
|
|
auto CServerData::ExpansionDamageBonusCap( UI08 setting ) -> void
|
|
{
|
|
if( setting >= ER_COUNT )
|
|
{
|
|
setting = ER_COUNT - 1;
|
|
}
|
|
expansionDamageBonusCap = setting;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ExpansionShieldParry()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Set era ruleset for shield parry
|
|
//| Notes - 0 = Core (used to inherit CoreShardEra setting)
|
|
//| 1 = UO - Original UO release
|
|
//| 2 = T2A - The Second Age
|
|
//| 3 = UOR - Rennaissance
|
|
//| 4 = TD - Third Dawn
|
|
//| 5 = LBR - Lord Blackthorn's Revenge
|
|
//| 6 = AoS - Age of Shadows
|
|
//| 7 = SE - Samurai Empire
|
|
//| 8 = ML - Mondain's Legacy
|
|
//| 9 = SA - Stygian Abyss
|
|
//| 10 = HS - High Seas
|
|
//| 11 = ToL - Time of Legends
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ExpansionShieldParry() const -> UI08
|
|
{
|
|
if( static_cast<ExpansionRuleset>( expansionShieldParry ) == ER_CORE )
|
|
{
|
|
// Inherit CoreShardEra setting
|
|
return ExpansionCoreShardEra();
|
|
}
|
|
return expansionShieldParry;
|
|
}
|
|
auto CServerData::ExpansionShieldParry( UI08 setting ) -> void
|
|
{
|
|
if( setting >= ER_COUNT )
|
|
{
|
|
setting = ER_COUNT - 1;
|
|
}
|
|
expansionShieldParry = setting;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ExpansionWeaponParry()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Set era ruleset for weapon parry
|
|
//| Notes - 0 = Core (used to inherit CoreShardEra setting)
|
|
//| 1 = UO - Original UO release
|
|
//| 2 = T2A - The Second Age
|
|
//| 3 = UOR - Rennaissance
|
|
//| 4 = TD - Third Dawn
|
|
//| 5 = LBR - Lord Blackthorn's Revenge
|
|
//| 6 = AoS - Age of Shadows
|
|
//| 7 = SE - Samurai Empire
|
|
//| 8 = ML - Mondain's Legacy
|
|
//| 9 = SA - Stygian Abyss
|
|
//| 10 = HS - High Seas
|
|
//| 11 = ToL - Time of Legends
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ExpansionWeaponParry() const -> UI08
|
|
{
|
|
if( static_cast<ExpansionRuleset>( expansionWeaponParry ) == ER_CORE )
|
|
{
|
|
// Inherit CoreShardEra setting
|
|
return ExpansionCoreShardEra();
|
|
}
|
|
return expansionWeaponParry;
|
|
}
|
|
auto CServerData::ExpansionWeaponParry( UI08 setting ) -> void
|
|
{
|
|
if( setting >= ER_COUNT )
|
|
{
|
|
setting = ER_COUNT - 1;
|
|
}
|
|
expansionWeaponParry = setting;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ExpansionWrestlingParry()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Set era ruleset for wrestling parry
|
|
//| Notes - 0 = Core (used to inherit CoreShardEra setting)
|
|
//| 1 = UO - Original UO release
|
|
//| 2 = T2A - The Second Age
|
|
//| 3 = UOR - Rennaissance
|
|
//| 4 = TD - Third Dawn
|
|
//| 5 = LBR - Lord Blackthorn's Revenge
|
|
//| 6 = AoS - Age of Shadows
|
|
//| 7 = SE - Samurai Empire
|
|
//| 8 = ML - Mondain's Legacy
|
|
//| 9 = SA - Stygian Abyss
|
|
//| 10 = HS - High Seas
|
|
//| 11 = ToL - Time of Legends
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ExpansionWrestlingParry() const -> UI08
|
|
{
|
|
if( static_cast<ExpansionRuleset>( expansionWrestlingParry ) == ER_CORE )
|
|
{
|
|
// Inherit CoreShardEra setting
|
|
return ExpansionCoreShardEra();
|
|
}
|
|
return expansionWrestlingParry;
|
|
}
|
|
auto CServerData::ExpansionWrestlingParry( UI08 setting ) -> void
|
|
{
|
|
if( setting >= ER_COUNT )
|
|
{
|
|
setting = ER_COUNT - 1;
|
|
}
|
|
expansionWrestlingParry = setting;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ExpansionCombatHitChance()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Set era ruleset for combat hit chance calculations
|
|
//| Notes - 0 = Core (used to inherit CoreShardEra setting)
|
|
//| 1 = UO - Original UO release
|
|
//| 2 = T2A - The Second Age
|
|
//| 3 = UOR - Rennaissance
|
|
//| 4 = TD - Third Dawn
|
|
//| 5 = LBR - Lord Blackthorn's Revenge
|
|
//| 6 = AoS - Age of Shadows
|
|
//| 7 = SE - Samurai Empire
|
|
//| 8 = ML - Mondain's Legacy
|
|
//| 9 = SA - Stygian Abyss
|
|
//| 10 = HS - High Seas
|
|
//| 11 = ToL - Time of Legends
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ExpansionCombatHitChance() const -> UI08
|
|
{
|
|
if( static_cast<ExpansionRuleset>( expansionCombatHitChance ) == ER_CORE )
|
|
{
|
|
// Inherit CoreShardEra setting
|
|
return ExpansionCoreShardEra();
|
|
}
|
|
return expansionCombatHitChance;
|
|
}
|
|
auto CServerData::ExpansionCombatHitChance( UI08 setting ) -> void
|
|
{
|
|
if( setting >= ER_COUNT )
|
|
{
|
|
setting = ER_COUNT - 1;
|
|
}
|
|
expansionCombatHitChance = setting;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::HumanHealthRegenBonus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default health regen bonus for human race
|
|
//| Can be overridden/extended to other races via races.dfn
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::HumanHealthRegenBonus() const -> SI16
|
|
{
|
|
return humanHealthRegenBonus;
|
|
}
|
|
auto CServerData::HumanHealthRegenBonus( SI16 value ) -> void
|
|
{
|
|
humanHealthRegenBonus = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::HumanStaminaRegenBonus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default stamina regen bonus for human race
|
|
//| Can be overridden/extended to other races via races.dfn
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::HumanStaminaRegenBonus() const -> SI16
|
|
{
|
|
return humanStaminaRegenBonus;
|
|
}
|
|
auto CServerData::HumanStaminaRegenBonus( SI16 value ) -> void
|
|
{
|
|
humanStaminaRegenBonus = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::HumanManaRegenBonus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default mana regen bonus for human race
|
|
//| Can be overridden/extended to other races via races.dfn
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::HumanManaRegenBonus() const -> SI16
|
|
{
|
|
return humanManaRegenBonus;
|
|
}
|
|
auto CServerData::HumanManaRegenBonus( SI16 value ) -> void
|
|
{
|
|
humanManaRegenBonus = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::HumanMaxWeightBonus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default max weight bonus for human race
|
|
//| Can be overridden/extended to other races via races.dfn
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::HumanMaxWeightBonus() const -> SI16
|
|
{
|
|
return humanMaxWeightBonus;
|
|
}
|
|
auto CServerData::HumanMaxWeightBonus( SI16 value ) -> void
|
|
{
|
|
humanMaxWeightBonus = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ElfHealthRegenBonus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default health regen bonus for elf race
|
|
//| Can be overridden/extended to other races via races.dfn
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ElfHealthRegenBonus() const -> SI16
|
|
{
|
|
return elfHealthRegenBonus;
|
|
}
|
|
auto CServerData::ElfHealthRegenBonus( SI16 value ) -> void
|
|
{
|
|
elfHealthRegenBonus = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ElfStaminaRegenBonus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default stamina regen bonus for elf race
|
|
//| Can be overridden/extended to other races via races.dfn
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ElfStaminaRegenBonus() const -> SI16
|
|
{
|
|
return elfStaminaRegenBonus;
|
|
}
|
|
auto CServerData::ElfStaminaRegenBonus( SI16 value ) -> void
|
|
{
|
|
elfStaminaRegenBonus = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ElfManaRegenBonus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default mana regen bonus for elf race
|
|
//| Can be overridden/extended to other races via races.dfn
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ElfManaRegenBonus() const -> SI16
|
|
{
|
|
return elfManaRegenBonus;
|
|
}
|
|
auto CServerData::ElfManaRegenBonus( SI16 value ) -> void
|
|
{
|
|
elfManaRegenBonus = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ElfMaxWeightBonus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default max weight bonus for elf race
|
|
//| Can be overridden/extended to other races via races.dfn
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ElfMaxWeightBonus() const -> SI16
|
|
{
|
|
return elfMaxWeightBonus;
|
|
}
|
|
auto CServerData::ElfMaxWeightBonus( SI16 value ) -> void
|
|
{
|
|
elfMaxWeightBonus = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::GargoyleHealthRegenBonus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default health regen bonus for gargoyle race
|
|
//| Can be overridden/extended to other races via races.dfn
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::GargoyleHealthRegenBonus() const -> SI16
|
|
{
|
|
return gargoyleHealthRegenBonus;
|
|
}
|
|
auto CServerData::GargoyleHealthRegenBonus( SI16 value ) -> void
|
|
{
|
|
gargoyleHealthRegenBonus = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::GargoyleStaminaRegenBonus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default stamina regen bonus for gargoyle race
|
|
//| Can be overridden/extended to other races via races.dfn
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::GargoyleStaminaRegenBonus() const -> SI16
|
|
{
|
|
return gargoyleStaminaRegenBonus;
|
|
}
|
|
auto CServerData::GargoyleStaminaRegenBonus( SI16 value ) -> void
|
|
{
|
|
gargoyleStaminaRegenBonus = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::GargoyleManaRegenBonus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default mana regen bonus for gargoyle race
|
|
//| Can be overridden/extended to other races via races.dfn
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::GargoyleManaRegenBonus() const -> SI16
|
|
{
|
|
return gargoyleManaRegenBonus;
|
|
}
|
|
auto CServerData::GargoyleManaRegenBonus( SI16 value ) -> void
|
|
{
|
|
gargoyleManaRegenBonus = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::GargoyleMaxWeightBonus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default max weight bonus for gargoyle race
|
|
//| Can be overridden/extended to other races via races.dfn
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::GargoyleMaxWeightBonus() const -> SI16
|
|
{
|
|
return gargoyleMaxWeightBonus;
|
|
}
|
|
auto CServerData::GargoyleMaxWeightBonus( SI16 value ) -> void
|
|
{
|
|
gargoyleMaxWeightBonus = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ShootOnAnimalBack()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether players can shoot arrows while riding mounts
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ShootOnAnimalBack() const -> bool
|
|
{
|
|
return boolVals.test( BIT_SHOOTONANIMALBACK );
|
|
}
|
|
auto CServerData::ShootOnAnimalBack( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_SHOOTONANIMALBACK, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::NPCTrainingStatus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether NPCs can train players in skills
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::NPCTrainingStatus() const -> bool
|
|
{
|
|
return boolVals.test( BIT_NPCTRAINING );
|
|
}
|
|
auto CServerData::NPCTrainingStatus( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_NPCTRAINING, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::DumpPaths()
|
|
//| Date - 02/26/2002
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Needed a function that would dump out the paths. If you add any paths to the
|
|
//| server please make sure that you place exports to the console here to please
|
|
//| so it can be looked up if needed.
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::DumpPaths() -> void
|
|
{
|
|
Console.PrintSectionBegin();
|
|
Console << "PathDump: \n";
|
|
Console << " Root : " << Directory( CSDDP_ROOT ) << "\n";
|
|
Console << " Accounts : " << Directory( CSDDP_ACCOUNTS ) << "\n";
|
|
Console << " Access : " << Directory( CSDDP_ACCESS ) << "\n";
|
|
Console << " Mul(Data) : " << Directory( CSDDP_DATA ) << "\n";
|
|
Console << " DFN(Defs) : " << Directory( CSDDP_DEFS ) << "\n";
|
|
Console << " JScript : " << Directory( CSDDP_SCRIPTS ) << "\n";
|
|
Console << " JScriptData : " << Directory( CSDDP_SCRIPTDATA ) << "\n";
|
|
Console << " HTML : " << Directory( CSDDP_HTML ) << "\n";
|
|
Console << " MSGBoards : " << Directory( CSDDP_MSGBOARD ) << "\n";
|
|
Console << " Books : " << Directory( CSDDP_BOOKS ) << "\n";
|
|
Console << " Shared : " << Directory( CSDDP_SHARED ) << "\n";
|
|
Console << " Backups : " << Directory( CSDDP_BACKUP ) << "\n";
|
|
Console << " Logs : " << Directory( CSDDP_LOGS ) << "\n";
|
|
Console.PrintSectionBegin();
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::PlayerCorpseLootDecay()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether loot decays along with player corpses or is left on ground
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::PlayerCorpseLootDecay() const -> bool
|
|
{
|
|
return boolVals.test( BIT_LOOTDECAYSONPLAYERCORPSE );
|
|
}
|
|
auto CServerData::PlayerCorpseLootDecay( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_LOOTDECAYSONPLAYERCORPSE, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::NpcCorpseLootDecay()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether loot decays along with npc corpses or is left on ground
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::NpcCorpseLootDecay() const -> bool
|
|
{
|
|
return boolVals.test( BIT_LOOTDECAYSONNPCCORPSE );
|
|
}
|
|
auto CServerData::NpcCorpseLootDecay( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_LOOTDECAYSONNPCCORPSE, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::GuardsStatus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether guards are enabled globally or not
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::GuardsStatus() const -> bool
|
|
{
|
|
return boolVals.test( BIT_GUARDSENABLED );
|
|
}
|
|
auto CServerData::GuardStatus( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_GUARDSENABLED, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::DeathAnimationStatus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether death animation plays when a player dies
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::DeathAnimationStatus() const -> bool
|
|
{
|
|
return boolVals.test( BIT_PLAYDEATHANIMATION );
|
|
}
|
|
auto CServerData::DeathAnimationStatus( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_PLAYDEATHANIMATION, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::WorldAmbientSounds()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets intensity of ambient world sounds, bird chirps, animal sounds, etc
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::WorldAmbientSounds() const -> SI16
|
|
{
|
|
return ambientSounds;
|
|
}
|
|
auto CServerData::WorldAmbientSounds( SI16 value ) -> void
|
|
{
|
|
if( value < 0 )
|
|
{
|
|
ambientSounds = 0;
|
|
}
|
|
else
|
|
{
|
|
ambientSounds = value;
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::AmbientFootsteps()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether context-specific footstep sounds are enabled or not
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::AmbientFootsteps() const -> bool
|
|
{
|
|
return boolVals.test( BIT_AMBIENTFOOTSTEPS );
|
|
}
|
|
auto CServerData::AmbientFootsteps( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_AMBIENTFOOTSTEPS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::InternalAccountStatus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether automatic account creation is enabled
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::InternalAccountStatus() const -> bool
|
|
{
|
|
return boolVals.test( BIT_INTERNALACCOUNTS );
|
|
}
|
|
auto CServerData::InternalAccountStatus( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_INTERNALACCOUNTS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::YoungPlayerSystem()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether the Young Player system is enabled
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::YoungPlayerSystem() const -> bool
|
|
{
|
|
return boolVals.test( BIT_YOUNGPLAYERSYSTEM );
|
|
}
|
|
auto CServerData::YoungPlayerSystem( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_YOUNGPLAYERSYSTEM, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::KarmaLocking()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether the KarmaLocking system is enabled
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::KarmaLocking() const -> bool
|
|
{
|
|
return boolVals.test( BIT_KARMALOCKING );
|
|
}
|
|
auto CServerData::KarmaLocking( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_KARMALOCKING, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ShowOfflinePCs()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether GMs can see offline players
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ShowOfflinePCs() const -> bool
|
|
{
|
|
return boolVals.test( BIT_SHOWOFFLINEPCS );
|
|
}
|
|
auto CServerData::ShowOfflinePCs( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_SHOWOFFLINEPCS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::RogueStatus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether stealing skill is enabled
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::RogueStatus() const -> bool
|
|
{
|
|
return boolVals.test( BIT_ROGUESTATUS );
|
|
}
|
|
auto CServerData::RogueStatus( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_ROGUESTATUS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::SnoopIsCrime()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether snooping is considered a crime
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::SnoopIsCrime() const -> bool
|
|
{
|
|
return boolVals.test( BIT_SNOOPISCRIME );
|
|
}
|
|
auto CServerData::SnoopIsCrime( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_SNOOPISCRIME, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::SnoopAwareness()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether targets of snooping become more aware of it over time
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::SnoopAwareness() const -> bool
|
|
{
|
|
return boolVals.test( BIT_SNOOPAWARENESS );
|
|
}
|
|
auto CServerData::SnoopAwareness( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_SNOOPAWARENESS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::StatsAffectSkillChecks()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether stats like strength, dexterity and intelligence provide
|
|
//| bonuses to skillchecks
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::StatsAffectSkillChecks() const -> bool
|
|
{
|
|
return boolVals.test( BIT_STATSAFFECTSKILLCHECKS );
|
|
}
|
|
auto CServerData::StatsAffectSkillChecks( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_STATSAFFECTSKILLCHECKS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ExtendedStartingStats()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether extended starting stats are enabled
|
|
//| If enabled players start with 90 total statpoints instead of 80
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ExtendedStartingStats() const -> bool
|
|
{
|
|
return boolVals.test( BIT_EXTENDEDSTARTINGSTATS );
|
|
}
|
|
auto CServerData::ExtendedStartingStats( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_EXTENDEDSTARTINGSTATS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ExtendedStartingSkills()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether extended starting skills are enabled
|
|
//| If enabled, players start with 4 skills instead of 3, and have a total of
|
|
//| 120 skillpoints at the start instead of 100
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ExtendedStartingSkills() const -> bool
|
|
{
|
|
return boolVals.test( BIT_EXTENDEDSTARTINGSKILLS );
|
|
}
|
|
auto CServerData::ExtendedStartingSkills( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_EXTENDEDSTARTINGSKILLS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::PlayerPersecutionStatus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether player ghosts can drain mana from other players by attacking them
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::PlayerPersecutionStatus() const -> bool
|
|
{
|
|
return boolVals.test( BIT_PERSECUTIONSTATUS );
|
|
}
|
|
auto CServerData::PlayerPersecutionStatus( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_PERSECUTIONSTATUS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::HtmlStatsStatus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether html stats are enabled or disabled
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::HtmlStatsStatus() const -> SI16
|
|
{
|
|
return htmlStatusEnabled;
|
|
}
|
|
auto CServerData::HtmlStatsStatus( SI16 value ) -> void
|
|
{
|
|
htmlStatusEnabled = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::GlobalRestockMultiplier()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the global restock multiplier, which is applied to restock property
|
|
//| of items as they are loaded in from the DFNs
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::GlobalRestockMultiplier() const -> float
|
|
{
|
|
return globalRestockMultiplier;
|
|
}
|
|
auto CServerData::GlobalRestockMultiplier( R32 value ) -> void
|
|
{
|
|
globalRestockMultiplier = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::BODGoldRewardMultiplier()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets a multiplier that adjusts amount of Gold rewarded to players for
|
|
//| handing in completed Bulk Order Deeds
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::BODGoldRewardMultiplier() const -> float
|
|
{
|
|
return bodGoldRewardMultiplier;
|
|
}
|
|
auto CServerData::BODGoldRewardMultiplier( R32 value ) -> void
|
|
{
|
|
bodGoldRewardMultiplier = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::BODFameRewardMultiplier()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets a multiplier that adjusts amount of Fame rewarded to players for
|
|
//| handing in completed Bulk Order Deeds
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::BODFameRewardMultiplier() const -> float
|
|
{
|
|
return bodFameRewardMultiplier;
|
|
}
|
|
auto CServerData::BODFameRewardMultiplier( R32 value ) -> void
|
|
{
|
|
bodFameRewardMultiplier = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::SellByNameStatus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether items are sold by their name, not just ID/Colour
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::SellByNameStatus() const -> bool
|
|
{
|
|
return boolVals.test( BIT_SELLBYNAME );
|
|
}
|
|
auto CServerData::SellByNameStatus( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_SELLBYNAME, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::SellMaxItemsStatus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the maximum amount of items that can be sold in one go to a vendor
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::SellMaxItemsStatus() const -> SI16
|
|
{
|
|
return sellMaxItems;
|
|
}
|
|
auto CServerData::SellMaxItemsStatus( SI16 value ) -> void
|
|
{
|
|
sellMaxItems = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::TradeSystemStatus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether the advanced trade system is enabled or not.
|
|
//| If enabled, prices of goods with NPC vendors will fluctuate with demand
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::TradeSystemStatus() const -> bool
|
|
{
|
|
return boolVals.test( BIT_TRADESYSSTATUS );
|
|
}
|
|
auto CServerData::TradeSystemStatus( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_TRADESYSSTATUS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::RankSystemStatus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether rank system is enabled or not. If enabled, it allows for
|
|
//| variable quality of crafted items
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::RankSystemStatus() const -> bool
|
|
{
|
|
return boolVals.test( BIT_RANKSYSSTATUS );
|
|
}
|
|
auto CServerData::RankSystemStatus( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_RANKSYSSTATUS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::DisplayMakersMark()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether maker's mark is displayed for crafted items that have this
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::DisplayMakersMark( void ) const -> bool
|
|
{
|
|
return boolVals.test( BIT_DISPLAYMAKERSMARK );
|
|
}
|
|
auto CServerData::DisplayMakersMark( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_DISPLAYMAKERSMARK, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CutScrollRequirementStatus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether skill requirements are cut when casting spells from scrolls
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CutScrollRequirementStatus() const -> bool
|
|
{
|
|
return boolVals.test( BIT_CUTSCROLLREQ );
|
|
}
|
|
auto CServerData::CutScrollRequirementStatus( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_CUTSCROLLREQ, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CheckPetControlDifficulty()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether pet control difficulty is enabled or not
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CheckPetControlDifficulty() const -> bool
|
|
{
|
|
|
|
return boolVals.test( BIT_CHECKPETCONTROLDIFFICULTY );
|
|
}
|
|
auto CServerData::CheckPetControlDifficulty( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_CHECKPETCONTROLDIFFICULTY, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::PoisonCorrosionSystem()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether poison will corrode weapons and damage their durability
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::PoisonCorrosionSystem( void ) const -> bool
|
|
{
|
|
return boolVals.test( BIT_POISONCORROSIONSYSTEM );
|
|
}
|
|
auto CServerData::PoisonCorrosionSystem( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_POISONCORROSIONSYSTEM, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CheckItemsSpeed()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets how often in seconds items are checked for decay and other things
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CheckItemsSpeed() const -> double
|
|
{
|
|
return checkItems;
|
|
}
|
|
auto CServerData::CheckItemsSpeed( R64 value ) -> void
|
|
{
|
|
if( value < 0.0 )
|
|
{
|
|
checkItems = 0.0;
|
|
}
|
|
else
|
|
{
|
|
checkItems = value;
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CheckBoatSpeed()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets how often in seconds boats are checked for decay and other things
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CheckBoatSpeed() const -> double
|
|
{
|
|
return checkBoats;
|
|
}
|
|
auto CServerData::CheckBoatSpeed( R64 value ) -> void
|
|
{
|
|
if( value < 0.0 )
|
|
{
|
|
checkBoats = 0.0;
|
|
}
|
|
else
|
|
{
|
|
checkBoats = value;
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CheckNpcAISpeed()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets how often in seconds NPCs will execute their AI routines
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CheckNpcAISpeed() const -> double
|
|
{
|
|
return checkNpcAi;
|
|
}
|
|
auto CServerData::CheckNpcAISpeed( R64 value ) -> void
|
|
{
|
|
if( value < 0.0 )
|
|
{
|
|
checkNpcAi = 0.0;
|
|
}
|
|
else
|
|
{
|
|
checkNpcAi = value;
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CheckSpawnRegionSpeed()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets how often (in seconds) spawn regions are checked for new spawns
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CheckSpawnRegionSpeed() const -> double
|
|
{
|
|
return checkSpawnRegions;
|
|
}
|
|
auto CServerData::CheckSpawnRegionSpeed( R64 value ) -> void
|
|
{
|
|
if( value < 0.0 )
|
|
{
|
|
checkSpawnRegions = 0.0;
|
|
}
|
|
else
|
|
{
|
|
checkSpawnRegions = value;
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::MsgBoardPostingLevel()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the posting level for bulletin boards
|
|
//| UNUSED?
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::MsgBoardPostingLevel() const -> UI08
|
|
{
|
|
return msgPostingLevel;
|
|
}
|
|
auto CServerData::MsgBoardPostingLevel( UI08 value ) -> void
|
|
{
|
|
msgPostingLevel = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::MsgBoardPostRemovalLevel()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the post removal level for bulleting boards
|
|
//| UNUSED?
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::MsgBoardPostRemovalLevel() const -> UI08
|
|
{
|
|
return msgRemovalLevel;
|
|
}
|
|
auto CServerData::MsgBoardPostRemovalLevel( UI08 value ) -> void
|
|
{
|
|
msgRemovalLevel = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::MineCheck()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the type of check used when players attempt to use the mining skill
|
|
//| 0 = mine anywhere
|
|
//| 1 = mine mountainsides/cavefloors only
|
|
//| 2 = mine in mining regions only (not working?)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::MineCheck() const -> UI08
|
|
{
|
|
return mineCheck;
|
|
}
|
|
auto CServerData::MineCheck( UI08 value ) -> void
|
|
{
|
|
mineCheck = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::FreeshardServerPoll()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether UOX3 will respond to freeshard server poll requests
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::FreeshardServerPoll() const -> bool
|
|
{
|
|
return boolVals.test( BIT_FREESHARDSERVERPOLL );
|
|
}
|
|
auto CServerData::FreeshardServerPoll( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_FREESHARDSERVERPOLL, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatArmorClassDamageBonus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether weapons get a double damage bonus versus armors of matching AC
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatArmorClassDamageBonus() const -> bool
|
|
{
|
|
return boolVals.test( BIT_ARMORCLASSDAMAGEBONUS );
|
|
}
|
|
auto CServerData::CombatArmorClassDamageBonus( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_ARMORCLASSDAMAGEBONUS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatDisplayHitMessage()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether combat hit messages are displayed in combat
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatDisplayHitMessage() const -> bool
|
|
{
|
|
return boolVals.test( BIT_SHOWHITMESSAGE );
|
|
}
|
|
auto CServerData::CombatDisplayHitMessage( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_SHOWHITMESSAGE, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatDisplayDamageNumbers()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether combat damage numbers are displayed in combat
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatDisplayDamageNumbers() const -> bool
|
|
{
|
|
return boolVals.test( BIT_SHOWDAMAGENUMBERS );
|
|
}
|
|
auto CServerData::CombatDisplayDamageNumbers( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_SHOWDAMAGENUMBERS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatAttackSpeedFromStamina()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether combat attack speed is derived from stamina instead of dexterity
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatAttackSpeedFromStamina() const -> bool
|
|
{
|
|
return boolVals.test( BIT_ATTSPEEDFROMSTAMINA );
|
|
}
|
|
auto CServerData::CombatAttackSpeedFromStamina( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_ATTSPEEDFROMSTAMINA, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::GlobalAttackSpeed()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the global attack speed in combat
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::GlobalAttackSpeed() const -> double
|
|
{
|
|
return globalAttackSpeed;
|
|
}
|
|
auto CServerData::GlobalAttackSpeed( R64 value ) -> void
|
|
{
|
|
if( value < 0.0 )
|
|
{
|
|
globalAttackSpeed = 0.0;
|
|
}
|
|
else
|
|
{
|
|
globalAttackSpeed = value;
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::NPCSpellCastSpeed()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the global NPC spell casting speed
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::NPCSpellCastSpeed() const -> double
|
|
{
|
|
return npcSpellcastSpeed;
|
|
}
|
|
auto CServerData::NPCSpellCastSpeed( R64 value ) -> void
|
|
{
|
|
if( value < 0.0 )
|
|
{
|
|
npcSpellcastSpeed = 0.0;
|
|
}
|
|
else
|
|
{
|
|
npcSpellcastSpeed = value;
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::FishingStaminaLoss()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the stamina loss for using the fishing skill
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::FishingStaminaLoss() const -> SI16
|
|
{
|
|
return fishingstaminaloss;
|
|
}
|
|
auto CServerData::FishingStaminaLoss( SI16 value ) -> void
|
|
{
|
|
fishingstaminaloss = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::HealthRegenMode()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Set calculation mode for passive hitpoint regeneration for players and npcs
|
|
//| Notes - 0 = Disabled, no passive regen
|
|
//| 1 = Enabled
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::HealthRegenMode() const -> UI08
|
|
{
|
|
return healthRegenMode;
|
|
}
|
|
auto CServerData::HealthRegenMode( UI08 mode ) -> void
|
|
{
|
|
if( mode >= HREG_COUNT )
|
|
{
|
|
mode = HREG_COUNT - 1;
|
|
}
|
|
healthRegenMode = mode;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::StaminaRegenMode()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Set calculation mode for passive stamina regeneration for players and npcs
|
|
//| Notes - 0 = Disabled, no passive regen
|
|
//| 1 = LBR - Calculations meant for Lord Blackthorn's Revenge or earlier
|
|
//| 2 = AoS - Calculations meant for Age of Shadows or later
|
|
//| 3 = SA - Calculations meant for Stygian Abyss or later
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::StaminaRegenMode() const -> UI08
|
|
{
|
|
return staminaRegenMode;
|
|
}
|
|
auto CServerData::StaminaRegenMode( UI08 mode ) -> void
|
|
{
|
|
if( mode >= SREG_COUNT )
|
|
{
|
|
mode = SREG_COUNT - 1;
|
|
}
|
|
staminaRegenMode = mode;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ManaRegenMode()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Set calculation mode for passive stamina regeneration for players and npcs
|
|
//| Notes - 0 = Disabled, no passive regen
|
|
//| 1 = LBR - Calculations meant for Lord Blackthorn's Revenge or earlier
|
|
//| 2 = AoS - Calculations meant for Age of Shadows or later
|
|
//| 3 = SA - Calculations meant for Stygian Abyss or later
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ManaRegenMode() const -> UI08
|
|
{
|
|
return manaRegenMode;
|
|
}
|
|
auto CServerData::ManaRegenMode( UI08 mode ) -> void
|
|
{
|
|
if( mode >= MREG_COUNT )
|
|
{
|
|
mode = MREG_COUNT - 1;
|
|
}
|
|
manaRegenMode = mode;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::HealthRegenCap()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets cap for health regen points
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::HealthRegenCap() const -> SI16
|
|
{
|
|
return healthRegenCap;
|
|
}
|
|
auto CServerData::HealthRegenCap( SI16 value ) -> void
|
|
{
|
|
healthRegenCap = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::StaminaRegenCap()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets cap for stamina regen points
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::StaminaRegenCap() const -> SI16
|
|
{
|
|
return staminaRegenCap;
|
|
}
|
|
auto CServerData::StaminaRegenCap( SI16 value ) -> void
|
|
{
|
|
staminaRegenCap = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ManaRegenCap()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets cap for mana regen points
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ManaRegenCap() const -> SI16
|
|
{
|
|
return manaRegenCap;
|
|
}
|
|
auto CServerData::ManaRegenCap( SI16 value ) -> void
|
|
{
|
|
manaRegenCap = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatNpcDamageRate()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the NPC damage divisor. If character is a player, damage from NPCs is
|
|
//| divided by this value.
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatNpcDamageRate() const -> SI16
|
|
{
|
|
return combatNpcDamageRate;
|
|
}
|
|
auto CServerData::CombatNpcDamageRate( SI16 value ) -> void
|
|
{
|
|
combatNpcDamageRate = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::AlchemyDamageBonusEnabled()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether Alchemy Damage Bonus Modifier is enabled
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::AlchemyDamageBonusEnabled() const -> bool
|
|
{
|
|
return boolVals.test( BIT_ALCHEMYDAMAGEBONUSENABLED );
|
|
}
|
|
auto CServerData::AlchemyDamageBonusEnabled( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_ALCHEMYDAMAGEBONUSENABLED, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::AlchemyDamageBonusModifier()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the Alchemy Damage Bonus Modifier, which gives bonus damage to
|
|
//| explosion potions based on this formula:
|
|
//| bonusDamage = attackerAlchemySkill / alchemyDamageBonusModifier
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::AlchemyDamageBonusModifier() const -> UI08
|
|
{
|
|
return alchemyDamageBonusModifier;
|
|
}
|
|
auto CServerData::AlchemyDamageBonusModifier( UI08 value ) -> void
|
|
{
|
|
alchemyDamageBonusModifier = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::WeaponDamageBonusType()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the Weapon Damage Bonus Type, which determines how bonuses to weapon
|
|
//| damage is applied to weapons:
|
|
//| 0 - Apply flat weapon damage bonus to .hidamage
|
|
//| 1 - Split weapon damage bonus between .lodamage and .hidamage
|
|
//| 2 - Apply flat weapon damage bonus to BOTH .lodamage and .hidamage (Default)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::WeaponDamageBonusType() const -> UI08
|
|
{
|
|
return combatWeaponDamageBonusType;
|
|
}
|
|
auto CServerData::WeaponDamageBonusType( UI08 value ) -> void
|
|
{
|
|
combatWeaponDamageBonusType = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ItemsInterruptCasting()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether manipulation of items interrupts casting
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ItemsInterruptCasting() const -> bool
|
|
{
|
|
return boolVals.test( BIT_ITEMSINTERRUPTCASTING );
|
|
}
|
|
auto CServerData::ItemsInterruptCasting( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_ITEMSINTERRUPTCASTING, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatAttackStamina()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the amount of stamina lost by swinging weapon in combat
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatAttackStamina() const -> SI16
|
|
{
|
|
return combatAttackStamina;
|
|
}
|
|
auto CServerData::CombatAttackStamina( SI16 value ) -> void
|
|
{
|
|
combatAttackStamina = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::SkillLevel()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the global difficulty level for crafting items
|
|
//| 1 = easy, 5 = default, 10 = difficult
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::SkillLevel() const -> UI08
|
|
{
|
|
return skillLevel;
|
|
}
|
|
auto CServerData::SkillLevel( UI08 value ) -> void
|
|
{
|
|
skillLevel = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::EscortsEnabled()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether escorts are enabled or not
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::EscortsEnabled() const -> bool
|
|
{
|
|
return boolVals.test( BIT_ESCORTSTATUS );
|
|
}
|
|
auto CServerData::EscortsEnabled( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_ESCORTSTATUS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ItemsDetectSpeech()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether items can trigger onSpeech JS event
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ItemsDetectSpeech() const -> bool
|
|
{
|
|
return boolVals.test( BIT_ITEMSDETECTSPEECH );
|
|
}
|
|
auto CServerData::ItemsDetectSpeech( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_ITEMSDETECTSPEECH, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ForceNewAnimationPacket()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether server should force the use of new animation packet for NPCs
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ForceNewAnimationPacket() const -> bool
|
|
{
|
|
return boolVals.test( BIT_FORCENEWANIMATIONPACKET );
|
|
}
|
|
auto CServerData::ForceNewAnimationPacket( bool newVal ) -> void
|
|
{
|
|
if( ClientSupport4000()
|
|
|| ClientSupport5000()
|
|
|| ClientSupport6000()
|
|
|| ClientSupport6050() )
|
|
{
|
|
boolVals.set( BIT_FORCENEWANIMATIONPACKET, false );
|
|
Console.Warning( "FORCENEWANIMATIONPACKET setting not compatible with support for client versions below 7.0.0.0. Setting disabled!" );
|
|
}
|
|
else
|
|
{
|
|
boolVals.set( BIT_FORCENEWANIMATIONPACKET, newVal );
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::MapDiffsEnabled()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether server should load diff files for maps and statics
|
|
//| Notes - Diff files are not used by client versions newer than 7.0.8.2
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::MapDiffsEnabled() const -> bool
|
|
{
|
|
return boolVals.test( BIT_MAPDIFFSENABLED );
|
|
}
|
|
auto CServerData::MapDiffsEnabled( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_MAPDIFFSENABLED, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::MaxPlayerPackItems()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the max item capacity for player (and NPC) backpacks
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::MaxPlayerPackItems() const -> UI16
|
|
{
|
|
return maxPlayerPackItems;
|
|
}
|
|
auto CServerData::MaxPlayerPackItems( UI16 newVal ) -> void
|
|
{
|
|
maxPlayerPackItems = newVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::MaxPlayerPackWeight()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the max weight capacity for player (and NPC) backpacks
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::MaxPlayerPackWeight() const -> SI32
|
|
{
|
|
return maxPlayerPackWeight;
|
|
}
|
|
auto CServerData::MaxPlayerPackWeight( SI32 newVal ) -> void
|
|
{
|
|
maxPlayerPackWeight = newVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::MaxPlayerBankItems()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the max item capacity for player bankboxes
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::MaxPlayerBankItems() const -> UI16
|
|
{
|
|
return maxPlayerBankItems;
|
|
}
|
|
auto CServerData::MaxPlayerBankItems( UI16 newVal ) -> void
|
|
{
|
|
maxPlayerBankItems = newVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::MaxPlayerBankWeight()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the max weight capacity for player (and NPC) bankboxes
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::MaxPlayerBankWeight() const -> SI32
|
|
{
|
|
return maxPlayerBankWeight;
|
|
}
|
|
auto CServerData::MaxPlayerBankWeight( SI32 newVal ) -> void
|
|
{
|
|
maxPlayerBankWeight = newVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::BasicTooltipsOnly()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether basic tooltips are enabled or not (instead of advanced tooltips)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::BasicTooltipsOnly() const -> bool
|
|
{
|
|
return boolVals.test( BIT_BASICTOOLTIPSONLY );
|
|
}
|
|
auto CServerData::BasicTooltipsOnly( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_BASICTOOLTIPSONLY, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ShowNpcTitlesInTooltips()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether NPC titles show up in tooltips
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ShowNpcTitlesInTooltips() const -> bool
|
|
{
|
|
return boolVals.test( BIT_SHOWNPCTITLESINTOOLTIPS );
|
|
}
|
|
auto CServerData::ShowNpcTitlesInTooltips( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_SHOWNPCTITLESINTOOLTIPS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ShowNpcTitlesOverhead()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether NPC titles show up along with name over their heads
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ShowNpcTitlesOverhead() const -> bool
|
|
{
|
|
return boolVals.test( BIT_SHOWNPCTITLESOVERHEAD );
|
|
}
|
|
auto CServerData::ShowNpcTitlesOverhead( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_SHOWNPCTITLESOVERHEAD, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ShowInvulnerableTagOverhead()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether (invulnerable) tags show over character heads when invulnerable
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ShowInvulnerableTagOverhead() const -> bool
|
|
{
|
|
return boolVals.test( BIT_SHOWINVULNERABLETAGOVERHEAD );
|
|
}
|
|
auto CServerData::ShowInvulnerableTagOverhead( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_SHOWINVULNERABLETAGOVERHEAD, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ShowRaceWithName()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether character races show up in tooltips
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ShowRaceWithName() const -> bool
|
|
{
|
|
return boolVals.test( BIT_SHOWRACEWITHNAME );
|
|
}
|
|
auto CServerData::ShowRaceWithName( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_SHOWRACEWITHNAME, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ShowRaceInPaperdoll()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether character races show up in tooltips
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ShowRaceInPaperdoll() const -> bool
|
|
{
|
|
return boolVals.test( BIT_SHOWRACEINPAPERDOLL );
|
|
}
|
|
auto CServerData::ShowRaceInPaperdoll( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_SHOWRACEINPAPERDOLL, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ShowGuildInfoInTooltip()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether guild info shows in character tooltips
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ShowGuildInfoInTooltip() const -> bool
|
|
{
|
|
return boolVals.test( BIT_SHOWGUILDINFOINTOOLTIP );
|
|
}
|
|
auto CServerData::ShowGuildInfoInTooltip( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_SHOWGUILDINFOINTOOLTIP, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ShowReputationTitleInTooltip()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether reputation title (fame/karma) shows up in character tooltip
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ShowReputationTitleInTooltip() const -> bool
|
|
{
|
|
return boolVals.test( BIT_SHOWREPTITLEINTOOLTIP );
|
|
}
|
|
auto CServerData::ShowReputationTitleInTooltip( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_SHOWREPTITLEINTOOLTIP, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::EnableNPCGuildDiscounts()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether a discounted price is given when buying items from shopkeepers
|
|
//| that belong to the same NPC Guild as the player
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::EnableNPCGuildDiscounts() const -> bool
|
|
{
|
|
return boolVals.test( BIT_ENABLENPCGUILDDISCOUNTS );
|
|
}
|
|
auto CServerData::EnableNPCGuildDiscounts( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_ENABLENPCGUILDDISCOUNTS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::EnableNPCGuildPremiums()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether a premium price is offered when selling items to shopkeepers
|
|
//| that belong to the same NPC Guild as the player
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::EnableNPCGuildPremiums() const -> bool
|
|
{
|
|
return boolVals.test( BIT_ENABLENPCGUILDPREMIUMS );
|
|
}
|
|
auto CServerData::EnableNPCGuildPremiums( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_ENABLENPCGUILDPREMIUMS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CastSpellsWhileMoving()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether character races show up in tooltips
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CastSpellsWhileMoving() const -> bool
|
|
{
|
|
return boolVals.test( BIT_CASTSPELLSWHILEMOVING );
|
|
}
|
|
auto CServerData::CastSpellsWhileMoving( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_CASTSPELLSWHILEMOVING, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::PetCombatTraining()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether pets can gain skills/stats from fighting
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::PetCombatTraining() const -> bool
|
|
{
|
|
return boolVals.test( BIT_PETCOMBATTRAINING );
|
|
}
|
|
auto CServerData::PetCombatTraining( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_PETCOMBATTRAINING, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::NpcCombatTraining()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether (non-tamed, non-hireling) NPCs can gain skills/stats from fighting
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::NpcCombatTraining() const -> bool
|
|
{
|
|
return boolVals.test( BIT_NPCCOMBATTRAINING );
|
|
}
|
|
auto CServerData::NpcCombatTraining( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_NPCCOMBATTRAINING, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::HirelingCombatTraining()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether hireling NPCs can gain skills/stats from fighting
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::HirelingCombatTraining() const -> bool
|
|
{
|
|
return boolVals.test( BIT_HIRELINGCOMBATTRAINING );
|
|
}
|
|
auto CServerData::HirelingCombatTraining( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_HIRELINGCOMBATTRAINING, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ShowItemResistStats()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether elemental resist shows up in item tooltips
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ShowItemResistStats() const -> bool
|
|
{
|
|
return boolVals.test( BIT_SHOWITEMRESISTSTATS );
|
|
}
|
|
auto CServerData::ShowItemResistStats( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_SHOWITEMRESISTSTATS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ShowWeaponDamageTypes()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether damage types show up in weapon tooltips
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ShowWeaponDamageTypes() const -> bool
|
|
{
|
|
return boolVals.test( BIT_SHOWWEAPONDAMAGETYPES );
|
|
}
|
|
auto CServerData::ShowWeaponDamageTypes( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_SHOWWEAPONDAMAGETYPES, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::GlobalItemDecay()
|
|
//| Date - 2/07/2010
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether decay is enabled or disabled, on a global scale
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::GlobalItemDecay() const -> bool
|
|
{
|
|
return boolVals.test( BIT_GLOBALITEMDECAY );
|
|
}
|
|
auto CServerData::GlobalItemDecay( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_GLOBALITEMDECAY, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ScriptItemsDecayable()
|
|
//| Date - 2/07/2010
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether items added through scripts decay or not
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ScriptItemsDecayable() const -> bool
|
|
{
|
|
return boolVals.test( BIT_SCRIPTITEMSDECAYABLE );
|
|
}
|
|
auto CServerData::ScriptItemsDecayable( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_SCRIPTITEMSDECAYABLE, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::BaseItemsDecayable()
|
|
//| Date - 2/07/2010
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether base items added will decay or not
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::BaseItemsDecayable() const -> bool
|
|
{
|
|
return boolVals.test( BIT_BASEITEMSDECAYABLE );
|
|
}
|
|
auto CServerData::BaseItemsDecayable( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_BASEITEMSDECAYABLE, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ItemDecayInHouses()
|
|
//| Date - 2/07/2010
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether items inside houses will decay or not
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ItemDecayInHouses() const -> bool
|
|
{
|
|
return boolVals.test( BIT_ITEMDECAYINHOUSES );
|
|
}
|
|
auto CServerData::ItemDecayInHouses( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_ITEMDECAYINHOUSES, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ProtectPrivateHouses()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether players without explicit access are prevented from entering private houses
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ProtectPrivateHouses() const -> bool
|
|
{
|
|
return boolVals.test( BIT_PROTECTPRIVATEHOUSES);
|
|
}
|
|
auto CServerData::ProtectPrivateHouses( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_PROTECTPRIVATEHOUSES, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::TrackHousesPerAccount()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether house ownership is tracked per account (true) or character (false )
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::TrackHousesPerAccount() const -> bool
|
|
{
|
|
return boolVals.test( BIT_TRACKHOUSESPERACCOUNT);
|
|
}
|
|
auto CServerData::TrackHousesPerAccount( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_TRACKHOUSESPERACCOUNT, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CanOwnAndCoOwnHouses()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether players can both own and co-own houses at the same time
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CanOwnAndCoOwnHouses() const -> bool
|
|
{
|
|
return boolVals.test( BIT_CANOWNANDCOOWNHOUSES);
|
|
}
|
|
auto CServerData::CanOwnAndCoOwnHouses( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_CANOWNANDCOOWNHOUSES, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CoOwnHousesOnSameAccount()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether characters on same account as house owner will be treated as
|
|
//| if they are co-owners of the house
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CoOwnHousesOnSameAccount() const -> bool
|
|
{
|
|
return boolVals.test( BIT_COOWNHOUSESONSAMEACCOUNT);
|
|
}
|
|
auto CServerData::CoOwnHousesOnSameAccount( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_COOWNHOUSESONSAMEACCOUNT, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData:SafeCoOwnerLogout()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether co-owners of a house can safely log out in the house without
|
|
//| being booted out of the house
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::SafeCoOwnerLogout() const -> bool
|
|
{
|
|
return boolVals.test( BIT_SAFECOOWNERLOGOUT );
|
|
}
|
|
auto CServerData::SafeCoOwnerLogout( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_SAFECOOWNERLOGOUT, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::SafeFriendLogout()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether friends of a house can safely log out in the house without
|
|
//| being booted out of the house
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::SafeFriendLogout() const -> bool
|
|
{
|
|
return boolVals.test( BIT_SAFEFRIENDLOGOUT );
|
|
}
|
|
auto CServerData::SafeFriendLogout( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_SAFEFRIENDLOGOUT, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::SafeGuestLogout()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether guests of a house can safely log out in the house without
|
|
//| being booted out of the house
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::SafeGuestLogout() const -> bool
|
|
{
|
|
return boolVals.test( BIT_SAFEGUESTLOGOUT );
|
|
}
|
|
auto CServerData::SafeGuestLogout( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_SAFEGUESTLOGOUT, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::KeylessOwnerAccess()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether owner of a house can access locked doors without a key
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::KeylessOwnerAccess() const -> bool
|
|
{
|
|
return boolVals.test( BIT_KEYLESSOWNERACCESS );
|
|
}
|
|
auto CServerData::KeylessOwnerAccess( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_KEYLESSOWNERACCESS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::KeylessCoOwnerAccess()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether co-owners of a house can access locked doors without a key
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::KeylessCoOwnerAccess() const -> bool
|
|
{
|
|
return boolVals.test( BIT_KEYLESSCOOWNERACCESS );
|
|
}
|
|
auto CServerData::KeylessCoOwnerAccess( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_KEYLESSCOOWNERACCESS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::KeylessFriendAccess()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether friends of a house can access locked doors without a key
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::KeylessFriendAccess() const -> bool
|
|
{
|
|
return boolVals.test( BIT_KEYLESSFRIENDACCESS );
|
|
}
|
|
auto CServerData::KeylessFriendAccess( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_KEYLESSFRIENDACCESS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::KeylessGuestAccess()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether guests of a house can access locked doors without a key
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::KeylessGuestAccess() const -> bool
|
|
{
|
|
return boolVals.test( BIT_KEYLESSGUESTACCESS );
|
|
}
|
|
auto CServerData::KeylessGuestAccess( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_KEYLESSGUESTACCESS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::PaperdollGuildButton()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether guild menu can be accessed from paperdoll button or not
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::PaperdollGuildButton() const -> bool
|
|
{
|
|
return boolVals.test( BIT_PAPERDOLLGUILDBUTTON );
|
|
}
|
|
auto CServerData::PaperdollGuildButton( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_PAPERDOLLGUILDBUTTON, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatMonstersVsAnimals()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether monsters will attack animals or not
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatMonstersVsAnimals() const -> bool
|
|
{
|
|
return boolVals.test( BIT_MONSTERSVSANIMALS );
|
|
}
|
|
auto CServerData::CombatMonstersVsAnimals( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_MONSTERSVSANIMALS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::OfferBODsFromItemSales()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether Bulk Order Deeds should be offered to players upon selling
|
|
//| items to a vendor that supports that feature (like a blacksmith)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::OfferBODsFromItemSales() const -> bool
|
|
{
|
|
return boolVals.test( BIT_OFFERBODSFROMITEMSALES );
|
|
}
|
|
auto CServerData::OfferBODsFromItemSales( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_OFFERBODSFROMITEMSALES, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::OfferBODsFromContextMenu()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether Bulk Order Deeds should be offered to players via
|
|
//| context menu option on vendors that supports that feature (like a blacksmith)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::OfferBODsFromContextMenu() const -> bool
|
|
{
|
|
return boolVals.test( BIT_OFFERBODSFROMCONTEXTMENU );
|
|
}
|
|
auto CServerData::OfferBODsFromContextMenu( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_OFFERBODSFROMCONTEXTMENU, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::BODsFromCraftedItemsOnly()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether Bulk Order Deed offers will be triggered by selling any
|
|
//| items to a vendor that supports the feature, or just from selling crafted items.
|
|
//| Depends on OFFERBODSFROMITEMSALES feature being enabled.
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::BODsFromCraftedItemsOnly() const -> bool
|
|
{
|
|
return boolVals.test( BIT_BODSFROMCRAFTEDITEMSONLY );
|
|
}
|
|
auto CServerData::BODsFromCraftedItemsOnly( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_BODSFROMCRAFTEDITEMSONLY, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::MaxHousesOwnable()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the max amount of houses that a player can own
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::MaxHousesOwnable() const -> UI16
|
|
{
|
|
return maxHousesOwnable;
|
|
}
|
|
auto CServerData::MaxHousesOwnable( UI16 value ) -> void
|
|
{
|
|
maxHousesOwnable = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::MaxHousesCoOwnable()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the max amount of houses that a player can co-own
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::MaxHousesCoOwnable() const -> UI16
|
|
{
|
|
return maxHousesCoOwnable;
|
|
}
|
|
auto CServerData::MaxHousesCoOwnable( UI16 value ) -> void
|
|
{
|
|
maxHousesCoOwnable = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatAnimalsAttackChance()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the chance of monsters attacking animals
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatAnimalsAttackChance() const -> UI16
|
|
{
|
|
return combatAnimalAttackChance;
|
|
}
|
|
auto CServerData::CombatAnimalsAttackChance( UI16 value ) -> void
|
|
{
|
|
if( value > 1000 )
|
|
{
|
|
value = 1000;
|
|
}
|
|
combatAnimalAttackChance = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatArcheryHitBonus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the delay hit bonus (in percentage) in combat for Archery. Can be negative!
|
|
//| This bonus was mentioned in official patch notes for Publish 5 (UOR patch).
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatArcheryHitBonus() const -> SI08
|
|
{
|
|
return combatArcheryHitBonus;
|
|
}
|
|
auto CServerData::CombatArcheryHitBonus( SI08 value ) -> void
|
|
{
|
|
if( value > 100 )
|
|
{
|
|
value = 100;
|
|
}
|
|
combatArcheryHitBonus = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatArcheryShootDelay()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the delay (in seconds, with decimals) after archers stop moving until
|
|
//| they can fire a shot in combat
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatArcheryShootDelay() const -> double
|
|
{
|
|
return archeryShootDelay;
|
|
}
|
|
auto CServerData::CombatArcheryShootDelay( R64 value ) -> void
|
|
{
|
|
if( value < 0.0 )
|
|
{
|
|
archeryShootDelay = 0.0;
|
|
}
|
|
else
|
|
{
|
|
archeryShootDelay = value;
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatWeaponDamageChance()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets chance for weapons to take damage in combat (on hit)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatWeaponDamageChance() const -> UI08
|
|
{
|
|
return combatWeaponDamageChance;
|
|
}
|
|
auto CServerData::CombatWeaponDamageChance( UI08 value ) -> void
|
|
{
|
|
if( value > 100 )
|
|
{
|
|
value = 100;
|
|
}
|
|
combatWeaponDamageChance = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatWeaponDamageMin()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the min amount of damage (in hitpoints) weapons will take from combat
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatWeaponDamageMin() const -> UI08
|
|
{
|
|
return combatWeaponDamageMin;
|
|
}
|
|
auto CServerData::CombatWeaponDamageMin( UI08 value ) -> void
|
|
{
|
|
combatWeaponDamageMin = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatWeaponDamageMax()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the max amount of damage (in hitpoints) weapons will take from combat
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatWeaponDamageMax() const -> UI08
|
|
{
|
|
return combatWeaponDamageMax;
|
|
}
|
|
auto CServerData::CombatWeaponDamageMax( UI08 value ) -> void
|
|
{
|
|
combatWeaponDamageMax = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatArmorDamageChance()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the chance to damage armor in combat
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatArmorDamageChance() const -> UI08
|
|
{
|
|
return combatArmorDamageChance;
|
|
}
|
|
auto CServerData::CombatArmorDamageChance( UI08 value ) -> void
|
|
{
|
|
if( value > 100 )
|
|
{
|
|
value = 100;
|
|
}
|
|
combatArmorDamageChance = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatArmorDamageMin()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the min damage dealt to armor in combat
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatArmorDamageMin() const -> UI08
|
|
{
|
|
return combatArmorDamageMin;
|
|
}
|
|
auto CServerData::CombatArmorDamageMin( UI08 value ) -> void
|
|
{
|
|
combatArmorDamageMin = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatArmorDamageMax()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the max damage dealt to armor in combat
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatArmorDamageMax() const -> UI08
|
|
{
|
|
return combatArmorDamageMax;
|
|
}
|
|
auto CServerData::CombatArmorDamageMax( UI08 value ) -> void
|
|
{
|
|
combatArmorDamageMax = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatParryDamageChance()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the chance to damage items used to parry in combat
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatParryDamageChance() const -> UI08
|
|
{
|
|
return combatParryDamageChance;
|
|
}
|
|
auto CServerData::CombatParryDamageChance( UI08 value ) -> void
|
|
{
|
|
if( value > 100 )
|
|
{
|
|
value = 100;
|
|
}
|
|
combatParryDamageChance = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatParryDamageMin()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the min damage dealt to items used to parry in combat
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatParryDamageMin() const -> UI08
|
|
{
|
|
return combatParryDamageMin;
|
|
}
|
|
auto CServerData::CombatParryDamageMin( UI08 value ) -> void
|
|
{
|
|
combatParryDamageMin = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatParryDamageMax()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the max damage dealt to items used to parry in combat
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatParryDamageMax() const -> UI08
|
|
{
|
|
return combatParryDamageMax;
|
|
}
|
|
auto CServerData::CombatParryDamageMax( UI08 value ) -> void
|
|
{
|
|
combatParryDamageMax = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatBloodEffectChance()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the chance to spawn blood splatter effects during combat
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatBloodEffectChance() const -> UI08
|
|
{
|
|
return combatBloodEffectChance;
|
|
}
|
|
auto CServerData::CombatBloodEffectChance( UI08 value ) -> void
|
|
{
|
|
if( value > 100 )
|
|
{
|
|
value = 100;
|
|
}
|
|
combatBloodEffectChance = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::HungerSystemEnabled()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether hunger system is enabled or disabled
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::HungerSystemEnabled() const -> bool
|
|
{
|
|
return boolVals.test( BIT_HUNGERSYSTEMENABLED );
|
|
}
|
|
auto CServerData::HungerSystemEnabled( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_HUNGERSYSTEMENABLED, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::HungerAffectHealthRegen()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether hunger system affects passive health regen
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::HungerAffectHealthRegen() const -> bool
|
|
{
|
|
return boolVals.test( BIT_HUNGERAFFECTHEALTHREGEN );
|
|
}
|
|
auto CServerData::HungerAffectHealthRegen( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_HUNGERAFFECTHEALTHREGEN, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ThirstSystemEnabled()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether hunger system is enabled or disabled
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ThirstSystemEnabled() const -> bool
|
|
{
|
|
return boolVals.test( BIT_THIRSTSYSTEMENABLED );
|
|
}
|
|
auto CServerData::ThirstSystemEnabled( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_THIRSTSYSTEMENABLED, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ThirstAffectStaminaRegen()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether hunger system affects passive health regen
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ThirstAffectStaminaRegen() const -> bool
|
|
{
|
|
return boolVals.test( BIT_THIRSTAFFECTSTAMINAREGEN );
|
|
}
|
|
auto CServerData::ThirstAffectStaminaRegen( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_THIRSTAFFECTSTAMINAREGEN, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::HungerDamage()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the damage taken from players being hungry
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::HungerDamage() const -> SI16
|
|
{
|
|
return hungerDamage;
|
|
}
|
|
auto CServerData::HungerDamage( SI16 value ) -> void
|
|
{
|
|
hungerDamage = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ThirstDrain()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the stamina drain from players being thirsty
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ThirstDrain() const -> SI16
|
|
{
|
|
return thirstDrain;
|
|
}
|
|
auto CServerData::ThirstDrain( SI16 value ) -> void
|
|
{
|
|
thirstDrain = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::PetOfflineTimeout()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the interval in seconds between checks for the player offline time
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::PetOfflineTimeout() const -> UI16
|
|
{
|
|
return petOfflineTimeout;
|
|
}
|
|
auto CServerData::PetOfflineTimeout( UI16 value ) -> void
|
|
{
|
|
petOfflineTimeout = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::PetHungerOffline()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether pets should hunger while the player (owner) is offline or not
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::PetHungerOffline() const -> bool
|
|
{
|
|
return boolVals.test( BIT_PETHUNGEROFFLINE );
|
|
}
|
|
auto CServerData::PetHungerOffline( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_PETHUNGEROFFLINE, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::PetThirstOffline()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether pets should thirst while the player (owner) is offline or not
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::PetThirstOffline() const -> bool
|
|
{
|
|
return boolVals.test( BIT_PETTHIRSTOFFLINE );
|
|
}
|
|
auto CServerData::PetThirstOffline( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_PETTHIRSTOFFLINE, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::BuyThreshold()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the threshold for when money is taken from a player's bank account
|
|
//| when buying something from a vendor instead of from their backpack
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::BuyThreshold() const -> SI16
|
|
{
|
|
return buyThreshold;
|
|
}
|
|
auto CServerData::BuyThreshold( SI16 value ) -> void
|
|
{
|
|
buyThreshold = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CharHideWhileMounted()
|
|
//| Date - 09/22/2002
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether players can hide while mounted or not
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CharHideWhileMounted() const -> bool
|
|
{
|
|
return boolVals.test( BIT_HIDEWHILEMOUNTED );
|
|
}
|
|
auto CServerData::CharHideWhileMounted( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_HIDEWHILEMOUNTED, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::WeightPerStr()
|
|
//| Date - 3/12/2003
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets amount of weight one can hold per point of STR
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::WeightPerStr() const -> float
|
|
{
|
|
return weightPerSTR;
|
|
}
|
|
auto CServerData::WeightPerStr( R32 newVal ) -> void
|
|
{
|
|
weightPerSTR = newVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerOverloadPackets()
|
|
//| Date - 11/20/2005
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether packet handling in JS is enabled or disabled
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerOverloadPackets() const -> bool
|
|
{
|
|
return boolVals.test( BIT_OVERLOADPACKETS );
|
|
}
|
|
auto CServerData::ServerOverloadPackets( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_OVERLOADPACKETS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ArmorAffectManaRegen()
|
|
//| Date - 3/20/2005
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether armor affects mana regeneration or not
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ArmorAffectManaRegen() const -> bool
|
|
{
|
|
return boolVals.test( BIT_ARMORAFFECTMANAREGEN );
|
|
}
|
|
auto CServerData::ArmorAffectManaRegen( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_ARMORAFFECTMANAREGEN, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::HealingAffectHealthRegen()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether passive healing regen gets bonus from Healing skill
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::HealingAffectHealthRegen() const -> bool
|
|
{
|
|
return boolVals.test( BIT_HEALINGAFFECTHEALTHREGEN );
|
|
}
|
|
auto CServerData::HealingAffectHealthRegen( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_HEALINGAFFECTHEALTHREGEN, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::AdvancedPathfinding()
|
|
//| Date - 7/16/2005
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether NPCs use the A* Pathfinding routine or not
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::AdvancedPathfinding() const -> bool
|
|
{
|
|
return boolVals.test( BIT_ADVANCEDPATHFIND );
|
|
}
|
|
auto CServerData::AdvancedPathfinding( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_ADVANCEDPATHFIND, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::LootingIsCrime()
|
|
//| Date - 4/09/2007
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether looting of corpses can be a crime or not
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::LootingIsCrime() const -> bool
|
|
{
|
|
return boolVals.test( BIT_LOOTINGISCRIME );
|
|
}
|
|
auto CServerData::LootingIsCrime( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_LOOTINGISCRIME, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::TravelSpellsFromBoatKeys()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether travel spells (recall, gate) are usable with boat keys to teleport
|
|
//| directly to boat's location
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::TravelSpellsFromBoatKeys() const -> bool
|
|
{
|
|
return boolVals.test( BIT_TRAVELSPELLSFROMBOATKEYS );
|
|
}
|
|
auto CServerData::TravelSpellsFromBoatKeys( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_TRAVELSPELLSFROMBOATKEYS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::TravelSpellsWhileOverweight()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether travel spells (recall, gate) are allowed while overweight
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::TravelSpellsWhileOverweight() const -> bool
|
|
{
|
|
return boolVals.test( BIT_TRAVELSPELLSWHILEOVERWEIGHT );
|
|
}
|
|
auto CServerData::TravelSpellsWhileOverweight( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_TRAVELSPELLSWHILEOVERWEIGHT, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::MarkRunesInMultis()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether server allows marking recall runes in multis (houses, boats)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::MarkRunesInMultis() const -> bool
|
|
{
|
|
return boolVals.test( BIT_MARKRUNESINMULTIS );
|
|
}
|
|
auto CServerData::MarkRunesInMultis( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_MARKRUNESINMULTIS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::TravelSpellsBetweenWorlds()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether travel spells (recall, gate) are allowed between worlds
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::TravelSpellsBetweenWorlds() const -> bool
|
|
{
|
|
return boolVals.test( BIT_TRAVELSPELLSBETWEENWORLDS );
|
|
}
|
|
auto CServerData::TravelSpellsBetweenWorlds( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_TRAVELSPELLSBETWEENWORLDS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::TravelSpellsWhileAggressor()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether travel spells (recall, gate) are allowed while marked as an aggressor
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::TravelSpellsWhileAggressor() const -> bool
|
|
{
|
|
return boolVals.test( BIT_TRAVELSPELLSWHILEAGGRESSOR );
|
|
}
|
|
auto CServerData::TravelSpellsWhileAggressor( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_TRAVELSPELLSWHILEAGGRESSOR, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::AutoUnequippedCasting()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether spells will auto unequipe the hands that is not a spellbook or spellchanneling type.
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::AutoUnequippedCasting() const -> bool
|
|
{
|
|
return boolVals.test( BIT_AUTOUNEQUIPPEDCASTING );
|
|
}
|
|
auto CServerData::AutoUnequippedCasting( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_AUTOUNEQUIPPEDCASTING, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::MaxControlSlots()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the max amount of control slots a player has available (0 for disable)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::MaxControlSlots() const -> UI08
|
|
{
|
|
return maxControlSlots;
|
|
}
|
|
auto CServerData::MaxControlSlots( UI08 newVal ) -> void
|
|
{
|
|
maxControlSlots = newVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::MaxFollowers()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the max amount of active followers/pets a player can have (0 for disable)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::MaxFollowers() const -> UI08
|
|
{
|
|
return maxFollowers;
|
|
}
|
|
auto CServerData::MaxFollowers( UI08 newVal ) -> void
|
|
{
|
|
maxFollowers = newVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::MaxPetOwners()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the max amount of different owners a pet can have in its lifetime
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::MaxPetOwners() const -> UI08
|
|
{
|
|
return maxPetOwners;
|
|
}
|
|
auto CServerData::MaxPetOwners( UI08 newVal ) -> void
|
|
{
|
|
maxPetOwners = newVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::GetPetLoyaltyGainOnSuccess()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the pet loyalty gained on successful use of pet command
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::GetPetLoyaltyGainOnSuccess() const -> UI16
|
|
{
|
|
return petLoyaltyGainOnSuccess;
|
|
}
|
|
auto CServerData::SetPetLoyaltyGainOnSuccess( UI16 newVal ) -> void
|
|
{
|
|
petLoyaltyGainOnSuccess = newVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::GetPetLoyaltyLossOnFailure()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the pet loyalty loss for failed use of pet command
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::GetPetLoyaltyLossOnFailure() const -> UI16
|
|
{
|
|
return petLoyaltyLossOnFailure;
|
|
}
|
|
auto CServerData::SetPetLoyaltyLossOnFailure( UI16 newVal ) -> void
|
|
{
|
|
petLoyaltyLossOnFailure = newVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::MaxSafeTeleportsPerDay()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the max amount of teleports to safety players get per day via help menu when stuck
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::MaxSafeTeleportsPerDay() const -> UI08
|
|
{
|
|
return maxSafeTeleports;
|
|
}
|
|
auto CServerData::MaxSafeTeleportsPerDay( UI08 newVal ) -> void
|
|
{
|
|
maxSafeTeleports = newVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::TeleportToNearestSafeLocation()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether players who use the safe teleport via help menu will teleport
|
|
//| to the nearest safe location, or to a random safe location anywhere on the map
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::TeleportToNearestSafeLocation() const -> bool
|
|
{
|
|
return boolVals.test( BIT_TELEPORTTONEARESTSAFELOC );
|
|
}
|
|
auto CServerData::TeleportToNearestSafeLocation( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_TELEPORTTONEARESTSAFELOC, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::AllowAwakeNPCs()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether the feature that allows permanently awake NPCs (ones marked
|
|
//| as such) is enabled or not
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::AllowAwakeNPCs() const -> bool
|
|
{
|
|
return boolVals.test( BIT_ALLOWAWAKENPCS );
|
|
}
|
|
auto CServerData::AllowAwakeNPCs( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_ALLOWAWAKENPCS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ToolUseLimit()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether tools have usage limits (based on item health)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ToolUseLimit() const -> bool
|
|
{
|
|
return boolVals.test( BIT_TOOLUSELIMIT );
|
|
}
|
|
auto CServerData::ToolUseLimit( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_TOOLUSELIMIT, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ToolUseBreak()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether tools will break if they reach 0 health
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ToolUseBreak() const -> bool
|
|
{
|
|
return boolVals.test( BIT_TOOLUSEBREAK );
|
|
}
|
|
auto CServerData::ToolUseBreak( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_TOOLUSEBREAK, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ItemRepairDurabilityLoss()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether items will have their durability reduced when repaired
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ItemRepairDurabilityLoss() const -> bool
|
|
{
|
|
return boolVals.test( BIT_ITEMREPAIRDURABILITYLOSS );
|
|
}
|
|
auto CServerData::ItemRepairDurabilityLoss( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_ITEMREPAIRDURABILITYLOSS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::HideStatsForUnknownMagicItems()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether stats are displayed for unknown/unidentified magic items
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::HideStatsForUnknownMagicItems() const -> bool
|
|
{
|
|
return boolVals.test( BIT_HIDESTATSFORUNKNOWNMAGICITEMS );
|
|
}
|
|
auto CServerData::HideStatsForUnknownMagicItems( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_HIDESTATSFORUNKNOWNMAGICITEMS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CraftColouredWeapons()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether players can craft weapons from coloured ore
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CraftColouredWeapons() const -> bool
|
|
{
|
|
return boolVals.test( BIT_CRAFTCOLOUREDWEAPONS );
|
|
}
|
|
auto CServerData::CraftColouredWeapons( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_CRAFTCOLOUREDWEAPONS, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::BackupRatio()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the ratio of worldsaves that get backed up
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::BackupRatio() const -> SI16
|
|
{
|
|
return backupRatio;
|
|
}
|
|
auto CServerData::BackupRatio( SI16 value ) -> void
|
|
{
|
|
backupRatio = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatMaxRange()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the maximum range at which combat can be engaged
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatMaxRange() const -> SI16
|
|
{
|
|
return combatMaxRange;
|
|
}
|
|
auto CServerData::CombatMaxRange( SI16 value ) -> void
|
|
{
|
|
combatMaxRange = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatMaxSpellRange()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the maximum range at which spells can be cast in combat
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatMaxSpellRange() const -> SI16
|
|
{
|
|
return combatMaxSpellRange;
|
|
}
|
|
auto CServerData::CombatMaxSpellRange( SI16 value ) -> void
|
|
{
|
|
combatMaxSpellRange = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatMaxNpcAggroRange()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the maximum range at which NPCs can aggro targets on their own
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatMaxNpcAggroRange() const -> SI16
|
|
{
|
|
return combatMaxNpcAggroRange;
|
|
}
|
|
auto CServerData::CombatMaxNpcAggroRange( SI16 value ) -> void
|
|
{
|
|
combatMaxNpcAggroRange = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatAnimalsGuarded()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether animals are under the protection of town guards or not
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatAnimalsGuarded() const -> bool
|
|
{
|
|
return boolVals.test( BIT_ANIMALSGUARDED );
|
|
}
|
|
auto CServerData::CombatAnimalsGuarded( bool newVal ) -> void
|
|
{
|
|
boolVals.set( BIT_ANIMALSGUARDED, newVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatNPCBaseFleeAt()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the global health threshold where NPCs start fleeing in combat
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatNPCBaseFleeAt() const -> SI16
|
|
{
|
|
return combatNpcBaseFleeAt;
|
|
}
|
|
auto CServerData::CombatNPCBaseFleeAt( SI16 value ) -> void
|
|
{
|
|
combatNpcBaseFleeAt = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::CombatNPCBaseReattackAt()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the global health threshold where NPCs reattack after fleeing in combat
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::CombatNPCBaseReattackAt() const -> SI16
|
|
{
|
|
return combatNpcBaseReattackAt;
|
|
}
|
|
auto CServerData::CombatNPCBaseReattackAt( SI16 value ) -> void
|
|
{
|
|
combatNpcBaseReattackAt = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::NPCWalkingSpeed()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the global, default walking speed for NPCs
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::NPCWalkingSpeed() const -> double
|
|
{
|
|
return npcWalkingSpeed;
|
|
}
|
|
auto CServerData::NPCWalkingSpeed( R64 value ) -> void
|
|
{
|
|
npcWalkingSpeed = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::NPCRunningSpeed()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the global, default running speed for NPCs
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::NPCRunningSpeed() const -> double
|
|
{
|
|
return npcRunningSpeed;
|
|
}
|
|
auto CServerData::NPCRunningSpeed( R64 value ) -> void
|
|
{
|
|
npcRunningSpeed = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::NPCFleeingSpeed()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the global, default speed at which NPCs flee in combat
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::NPCFleeingSpeed() const -> double
|
|
{
|
|
return npcFleeingSpeed;
|
|
}
|
|
auto CServerData::NPCFleeingSpeed( R64 value ) -> void
|
|
{
|
|
npcFleeingSpeed = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::NPCMountedWalkingSpeed()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the global, default walking speed for mounted NPCs
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::NPCMountedWalkingSpeed() const -> double
|
|
{
|
|
return npcMountedWalkingSpeed;
|
|
}
|
|
auto CServerData::NPCMountedWalkingSpeed( R64 value ) -> void
|
|
{
|
|
npcMountedWalkingSpeed = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::NPCMountedRunningSpeed()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the global, default running speed for mounted NPCs
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::NPCMountedRunningSpeed() const -> double
|
|
{
|
|
return npcMountedRunningSpeed;
|
|
}
|
|
auto CServerData::NPCMountedRunningSpeed( R64 value ) -> void
|
|
{
|
|
npcMountedRunningSpeed = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::NPCMountedFleeingSpeed()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the global, default speed at which mounted NPCs flee in combat
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::NPCMountedFleeingSpeed() const -> double
|
|
{
|
|
return npcMountedFleeingSpeed;
|
|
}
|
|
auto CServerData::NPCMountedFleeingSpeed( R64 value ) -> void
|
|
{
|
|
npcMountedFleeingSpeed = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::TitleColour()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default text colour for titles in gumps
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::TitleColour() const -> UI16
|
|
{
|
|
return titleColour;
|
|
}
|
|
auto CServerData::TitleColour( UI16 value ) -> void
|
|
{
|
|
titleColour = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::LeftTextColour()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default text colour for left text in gumps (2 column ones)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::LeftTextColour() const -> UI16
|
|
{
|
|
return leftTextColour;
|
|
}
|
|
auto CServerData::LeftTextColour( UI16 value ) -> void
|
|
{
|
|
leftTextColour = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::RightTextColour()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default text colour for right text in gumps (2 column ones)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::RightTextColour() const -> UI16
|
|
{
|
|
return rightTextColour;
|
|
}
|
|
auto CServerData::RightTextColour( UI16 value ) -> void
|
|
{
|
|
rightTextColour = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ButtonCancel()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default Button ID for cancel button in gumps
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ButtonCancel() const -> UI16
|
|
{
|
|
return buttonCancel;
|
|
}
|
|
auto CServerData::ButtonCancel( UI16 value ) -> void
|
|
{
|
|
buttonCancel = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ButtonLeft()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default Button ID for left button (navigation) in gumps
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ButtonLeft() const -> UI16
|
|
{
|
|
return buttonLeft;
|
|
}
|
|
auto CServerData::ButtonLeft( UI16 value ) -> void
|
|
{
|
|
buttonLeft = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ButtonRight()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default Button ID for right button (navigation) in gumps
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ButtonRight() const -> UI16
|
|
{
|
|
return buttonRight;
|
|
}
|
|
auto CServerData::ButtonRight( UI16 value ) -> void
|
|
{
|
|
buttonRight = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::BackgroundPic()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default Gump ID for background gump
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::BackgroundPic() const -> UI16
|
|
{
|
|
return backgroundPic;
|
|
}
|
|
auto CServerData::BackgroundPic( UI16 value ) -> void
|
|
{
|
|
backgroundPic = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::TownNumSecsPollOpen()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the time (in seconds) for which a town voting poll is open
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::TownNumSecsPollOpen() const -> UI32
|
|
{
|
|
return numSecsPollOpen;
|
|
}
|
|
auto CServerData::TownNumSecsPollOpen( UI32 value ) -> void
|
|
{
|
|
numSecsPollOpen = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::TownNumSecsAsMayor()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the time (in seconds) that a PC would be a mayor
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::TownNumSecsAsMayor() const -> UI32
|
|
{
|
|
return numSecsAsMayor;
|
|
}
|
|
auto CServerData::TownNumSecsAsMayor( UI32 value ) -> void
|
|
{
|
|
numSecsAsMayor = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::TownTaxPeriod()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the time (in seconds) between periods of taxes for PCs
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::TownTaxPeriod() const -> UI32
|
|
{
|
|
return taxPeriod;
|
|
}
|
|
auto CServerData::TownTaxPeriod( UI32 value ) -> void
|
|
{
|
|
taxPeriod = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::TownGuardPayment()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the time (in seconds) between payments for guards
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::TownGuardPayment() const -> UI32
|
|
{
|
|
return guardPayment;
|
|
}
|
|
auto CServerData::TownGuardPayment( UI32 value ) -> void
|
|
{
|
|
guardPayment = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::RepMaxKills()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the threshold in player kills before a player turns red (murderer)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::RepMaxKills() const -> UI16
|
|
{
|
|
return maxMurdersAllowed;
|
|
}
|
|
auto CServerData::RepMaxKills( UI16 value ) -> void
|
|
{
|
|
maxMurdersAllowed = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ResLogs()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the maximum number of logs in a given resource area
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ResLogs() const -> SI16
|
|
{
|
|
return logsPerArea;
|
|
}
|
|
auto CServerData::ResLogs( SI16 value ) -> void
|
|
{
|
|
logsPerArea = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ResLogTime()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the time it takes for 1 single log to respawn in a resource area
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ResLogTime() const -> UI16
|
|
{
|
|
return logsRespawnTimer;
|
|
}
|
|
auto CServerData::ResLogTime( UI16 value ) -> void
|
|
{
|
|
logsRespawnTimer = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ResOre()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the maximum number of ore in a given resource area
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ResOre() const -> SI16
|
|
{
|
|
return orePerArea;
|
|
}
|
|
auto CServerData::ResOre( SI16 value ) -> void
|
|
{
|
|
orePerArea = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ResOreTime()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the time it takes for 1 single ore to respawn in a resource area
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ResOreTime() const -> UI16
|
|
{
|
|
return oreRespawnTimer;
|
|
}
|
|
auto CServerData::ResOreTime( UI16 value ) -> void
|
|
{
|
|
oreRespawnTimer = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ResourceAreaSize()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the size of each resource area to split the world into (min 8x8)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ResourceAreaSize() const -> UI16
|
|
{
|
|
return resourceAreaSize;
|
|
}
|
|
auto CServerData::ResourceAreaSize( UI16 value ) -> void
|
|
{
|
|
if( value < 8 )
|
|
{
|
|
value = 8;
|
|
}
|
|
resourceAreaSize = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ResFish()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the maximum number of fish in a given resource area
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ResFish() const -> SI16
|
|
{
|
|
return fishPerArea;
|
|
}
|
|
auto CServerData::ResFish( SI16 value ) -> void
|
|
{
|
|
fishPerArea = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ResFishTime()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the time it takes for 1 single fish to respawn in a resource area
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ResFishTime() const -> UI16
|
|
{
|
|
return fishRespawnTimer;
|
|
}
|
|
auto CServerData::ResFishTime( UI16 value ) -> void
|
|
{
|
|
fishRespawnTimer = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::AccountFlushTimer()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets how often (in mins) online accounts are checked to see if they really ARE online
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::AccountFlushTimer() const -> double
|
|
{
|
|
return flushTime;
|
|
}
|
|
auto CServerData::AccountFlushTimer( R64 value ) -> void
|
|
{
|
|
flushTime = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::GetClientFeature()
|
|
//| CServerData::SetClientFeature()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets a specific client-side feature
|
|
//| Notes - See ClientFeatures enum in cServerData.h for full list
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::GetClientFeature( ClientFeatures bitNum ) const -> bool
|
|
{
|
|
return clientFeatures.test( bitNum );
|
|
}
|
|
auto CServerData::SetClientFeature( ClientFeatures bitNum, bool nVal ) -> void
|
|
{
|
|
clientFeatures.set( bitNum, nVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::GetClientFeatures()
|
|
//| CServerData::SetClientFeatures()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets which client side features to enable for connecting clients
|
|
//| Notes - See ClientFeatures enum in cServerData.h for full list
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::GetClientFeatures() const -> UI32
|
|
{
|
|
return static_cast<UI32>( clientFeatures.to_ulong() );
|
|
}
|
|
auto CServerData::SetClientFeatures( UI32 nVal ) -> void
|
|
{
|
|
clientFeatures = nVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::GetServerFeature()
|
|
//| CServerData::SetServerFeature()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets a specific server-side feature
|
|
//| Notes - See ServerFeatures enum in cServerData.h for full list
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::GetServerFeature( ServerFeatures bitNum ) const -> bool
|
|
{
|
|
return serverFeatures.test( bitNum );
|
|
}
|
|
auto CServerData::SetServerFeature( ServerFeatures bitNum, bool nVal ) -> void
|
|
{
|
|
serverFeatures.set( bitNum, nVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::GetServerFeatures()
|
|
//| CServerData::SetServerFeatures()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets which server side features to enable
|
|
//| Notes - See ServerFeatures enum in cServerData.h for full list
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::GetServerFeatures() const -> size_t
|
|
{
|
|
return serverFeatures.to_ulong();
|
|
}
|
|
auto CServerData::SetServerFeatures( size_t nVal ) -> void
|
|
{
|
|
serverFeatures = nVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::GetSpawnRegionsFacetStatus()
|
|
//| CServerData::SetSpawnRegionsFacetStatus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets active status of spawn regions per facet
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::GetSpawnRegionsFacetStatus( UI32 value ) const -> bool
|
|
{
|
|
return spawnRegionsFacets.test( value );
|
|
}
|
|
auto CServerData::SetSpawnRegionsFacetStatus( UI32 nVal, bool status ) -> void
|
|
{
|
|
spawnRegionsFacets.set( nVal, status );
|
|
}
|
|
auto CServerData::GetSpawnRegionsFacetStatus() const -> UI32
|
|
{
|
|
return static_cast<UI32>( spawnRegionsFacets.to_ulong() );
|
|
}
|
|
auto CServerData::SetSpawnRegionsFacetStatus( UI32 nVal ) -> void
|
|
{
|
|
spawnRegionsFacets = nVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::GetMoongateFacetStatus()
|
|
//| CServerData::SetMoongateFacetStatus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets active status of moongates per facet
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::GetMoongateFacetStatus( UI32 value ) const -> bool
|
|
{
|
|
return moongateFacets.test( value );
|
|
}
|
|
auto CServerData::SetMoongateFacetStatus( UI32 nVal, bool status ) -> void
|
|
{
|
|
moongateFacets.set( nVal, status );
|
|
}
|
|
auto CServerData::GetMoongateFacetStatus() const -> UI32
|
|
{
|
|
return static_cast<UI32>( moongateFacets.to_ulong() );
|
|
}
|
|
auto CServerData::SetMoongateFacetStatus( UI32 nVal ) -> void
|
|
{
|
|
moongateFacets = nVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::GetAssistantNegotiation()
|
|
//| CServerData::SetAssistantNegotiation()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets status of feature negotiation with assist tools like Razor and AssistUO
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::GetAssistantNegotiation() const -> bool
|
|
{
|
|
return boolVals.test( BIT_ASSISTANTNEGOTIATION );
|
|
}
|
|
auto CServerData::SetAssistantNegotiation( bool nVal ) -> void
|
|
{
|
|
boolVals.set( BIT_ASSISTANTNEGOTIATION, nVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::GetClassicUOMapTracker()
|
|
//| CServerData::SetClassicUOMapTracker()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether server should respond to ClassicUO's WorldMap Tracker packets
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::GetClassicUOMapTracker() const -> bool
|
|
{
|
|
return boolVals.test( BIT_CLASSICUOMAPTRACKER );
|
|
}
|
|
auto CServerData::SetClassicUOMapTracker( bool nVal ) -> void
|
|
{
|
|
boolVals.set( BIT_CLASSICUOMAPTRACKER, nVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::UseUnicodeMessages()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether server should send messages originating on server as unicode
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::UseUnicodeMessages() const -> bool
|
|
{
|
|
return boolVals.test( BIT_USEUNICODEMESSAGES );
|
|
}
|
|
auto CServerData::UseUnicodeMessages( bool nVal ) -> void
|
|
{
|
|
boolVals.set( BIT_USEUNICODEMESSAGES, nVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::GetDisabledAssistantFeature()
|
|
//| CServerData::SetDisabledAssistantFeature()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets which assistant features to enable for connecting clients
|
|
//| Notes - Example of assistant: Razor, AssistUO
|
|
//| See ClientFeatures enum in cServerData.h for full list
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::GetDisabledAssistantFeature( AssistantFeatures bitNum ) const -> bool
|
|
{
|
|
return 0 != ( CServerData::DisabledAssistantFeatures & bitNum );
|
|
}
|
|
auto CServerData::SetDisabledAssistantFeature( AssistantFeatures bitNum, bool nVal ) -> void
|
|
{
|
|
if( nVal )
|
|
{
|
|
CServerData::DisabledAssistantFeatures |= bitNum;
|
|
}
|
|
else
|
|
{
|
|
CServerData::DisabledAssistantFeatures &= ~bitNum;
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::GetDisabledAssistantFeatures()
|
|
//| CServerData::SetDisabledAssistantFeatures()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets which assistant features to enable for connecting clients
|
|
//| Notes - Example of assistant: Razor, AssistUO
|
|
//| See ClientFeatures enum in cServerData.h for full list
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::GetDisabledAssistantFeatures() const -> UI64
|
|
{
|
|
return CServerData::DisabledAssistantFeatures;
|
|
}
|
|
auto CServerData::SetDisabledAssistantFeatures( UI64 nVal ) -> void
|
|
{
|
|
CServerData::DisabledAssistantFeatures = nVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::KickOnAssistantSilence()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets whether player is kicked if there's no response from assistant tool
|
|
//| to verify it complies with the allowed assistant features
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::KickOnAssistantSilence() const -> bool
|
|
{
|
|
return boolVals.test( BIT_KICKONASSISTANTSILENCE );
|
|
}
|
|
auto CServerData::KickOnAssistantSilence( bool nVal ) -> void
|
|
{
|
|
boolVals.set( BIT_KICKONASSISTANTSILENCE, nVal );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::SaveIni()
|
|
//| Date - 02/21/2002
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Save the uox.ini out. This is the default save
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Returns - [true] If successfull
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::SaveIni() -> bool
|
|
{
|
|
auto s = actualINI;
|
|
if( s.empty() )
|
|
{
|
|
s = Directory( CSDDP_ROOT );
|
|
s += "uox.ini"s;
|
|
}
|
|
return SaveIni( s );
|
|
}
|
|
|
|
// Map of era enums to era strings, used for conversion between the two types
|
|
static const std::unordered_map<ExpansionRuleset, std::string> eraNames
|
|
{
|
|
{ ER_UO, "uo"s },
|
|
{ ER_T2A, "t2a"s },
|
|
{ ER_UOR, "uor"s },
|
|
{ ER_TD, "td"s },
|
|
{ ER_LBR, "lbr"s },
|
|
{ ER_AOS, "aos"s },
|
|
{ ER_SE, "se"s },
|
|
{ ER_ML, "ml"s },
|
|
{ ER_SA, "sa"s },
|
|
{ ER_HS, "hs"s },
|
|
{ ER_TOL, "tol"s }
|
|
};
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::EraEnumToString()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Pass an era enum in, get an era string back
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::EraEnumToString( ExpansionRuleset eraEnum, bool coreEnum ) -> std::string
|
|
{
|
|
std::string eraName = "lbr"; // default
|
|
if( !coreEnum && eraEnum == static_cast<ExpansionRuleset>( ExpansionCoreShardEra() ))
|
|
{
|
|
// Enum matches the core shard era setting; return it as "core"
|
|
eraName = "core";
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
eraName = eraNames.at( eraEnum );
|
|
}
|
|
catch( const std::out_of_range &e )
|
|
{
|
|
Console.Error( oldstrutil::format( "Unknown era enum detected, exception thrown: %s", e.what() ));
|
|
}
|
|
}
|
|
|
|
return eraName;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::EraStringToEnum()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Pass an era string in, get an era enum back
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::EraStringToEnum( const std::string &eraString, bool useDefault, bool inheritCore ) -> ExpansionRuleset
|
|
{
|
|
auto rValue = ER_CORE;
|
|
if( useDefault )
|
|
{
|
|
rValue = ER_LBR; // Default era if specified era is not found
|
|
}
|
|
|
|
auto searchEra = oldstrutil::lower( eraString );
|
|
if( inheritCore && searchEra == "core" )
|
|
{
|
|
// Inherit setting from CORESHARDERA setting
|
|
return static_cast<ExpansionRuleset>( ExpansionCoreShardEra() );
|
|
}
|
|
|
|
// Look for string with era name in eras map
|
|
auto iter = std::find_if( eraNames.begin(), eraNames.end(), [&searchEra]( const std::pair<ExpansionRuleset, std::string> &value ) {
|
|
return searchEra == std::get<1>( value );
|
|
});
|
|
|
|
if( iter != eraNames.end() )
|
|
{
|
|
rValue = iter->first;
|
|
}
|
|
|
|
return rValue;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::SaveIni()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - This is the full uox.ini save routing.
|
|
//|
|
|
//| Changes - 02/21/2002 - Fixed paths not being saved back out
|
|
//|
|
|
//| Changes - 02/21/2002 - Added ini support for the isloation system
|
|
//| At this point it just defaults to Isolation level 1.
|
|
//|
|
|
//| Changes - 02/27/2002 - Made sure that ALL directory paths are
|
|
//| written out to the ini file.
|
|
//|
|
|
//| Changes - 04/03/2004 - Added new tags to the system group
|
|
//|
|
|
//| SERVERNAME : Name of the server.
|
|
//| NETRCVTIMEOUT : Timeout in seconds for recieving data
|
|
//| NETSNDTIMEOUT : Timeout in seconds for sending data
|
|
//| UOGENABLED : Does this server respond to UOGInfo Requests?
|
|
//| 0-No 1-Yes
|
|
//|
|
|
//| Changes - 04/03/2004 - Added new group [facet] with these tags
|
|
//|
|
|
//| USEFACETSAVES : Does the server seperate facet data?
|
|
//| 0-No : All data will be saved into the shared folder
|
|
//| 1-Yes: Each Facet will save its data into its own shared folder
|
|
//| MAP0-MAP3 : Format= MAPx=Mapname,MapAccess
|
|
//|
|
|
//| Where Mapname is the name of the map and
|
|
//| MapAccess the set of bit flags that allow/deny features and map access
|
|
//|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::SaveIni( const std::string &filename ) -> bool
|
|
{
|
|
auto rValue = false;
|
|
auto ofsOutput = std::ofstream( filename );
|
|
if( ofsOutput.is_open() )
|
|
{
|
|
ofsOutput << "// UOX Initialization File. V";
|
|
ofsOutput << ( static_cast<UI16>( 1 ) << 8 | static_cast<UI16>( 2 )) << '\n' << "//================================" << '\n' << '\n';
|
|
ofsOutput << "[system]" << '\n' << "{" << '\n';
|
|
ofsOutput << "SERVERNAME=" << ServerName() << '\n';
|
|
ofsOutput << "EXTERNALIP=" << ExternalIP() << '\n';
|
|
ofsOutput << "PORT=" << ServerPort() << '\n';
|
|
ofsOutput << "SECRETSHARDKEY=" << SecretShardKey() << '\n';
|
|
ofsOutput << "SERVERLANGUAGE=" << ServerLanguage() << '\n';
|
|
ofsOutput << "NETRCVTIMEOUT=" << ServerNetRcvTimeout() << '\n';
|
|
ofsOutput << "NETSNDTIMEOUT=" << ServerNetSndTimeout() << '\n';
|
|
ofsOutput << "NETRETRYCOUNT=" << ServerNetRetryCount() << '\n';
|
|
ofsOutput << "CONSOLELOG=" << ( ServerConsoleLog() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "NETWORKLOG=" << ( ServerNetworkLog() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "SPEECHLOG=" << ( ServerSpeechLog() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "COMMANDPREFIX=" << ServerCommandPrefix() << '\n';
|
|
ofsOutput << "ANNOUNCEWORLDSAVES=" << ( ServerAnnounceSavesStatus() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "JOINPARTMSGS=" << ( ServerJoinPartAnnouncementsStatus() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "BACKUPSENABLED=" << ( ServerBackupStatus() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "BACKUPSAVERATIO=" << BackupRatio() << '\n';
|
|
ofsOutput << "SAVESTIMER=" << ServerSavesTimerStatus() << '\n';
|
|
ofsOutput << "UOGENABLED=" << ( ServerUOGEnabled() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "FREESHARDSERVERPOLL=" << ( FreeshardServerPoll() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "RANDOMSTARTINGLOCATION=" << ( ServerRandomStartingLocation() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "ASSISTANTNEGOTIATION=" << ( GetAssistantNegotiation() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "KICKONASSISTANTSILENCE=" << ( KickOnAssistantSilence() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "CLASSICUOMAPTRACKER=" << ( GetClassicUOMapTracker() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "JSENGINESIZE=" << static_cast<UI16>( GetJSEngineSize() ) << '\n';
|
|
ofsOutput << "USEUNICODEMESSAGES=" << ( UseUnicodeMessages() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "CONTEXTMENUS=" << ( ServerContextMenus() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "SYSMESSAGECOLOUR=" << SysMsgColour() << '\n';
|
|
ofsOutput << "MAXCLIENTBYTESIN=" << static_cast<UI32>( MaxClientBytesIn() ) << '\n';
|
|
ofsOutput << "MAXCLIENTBYTESOUT=" << static_cast<UI32>( MaxClientBytesOut() ) << '\n';
|
|
ofsOutput << "NETTRAFFICTIMEBAN=" << static_cast<UI32>( NetTrafficTimeban() ) << '\n';
|
|
ofsOutput << "APSPERFTHRESHOLD=" << static_cast<UI16>( APSPerfThreshold() ) << '\n';
|
|
ofsOutput << "APSINTERVAL=" << static_cast<UI16>( APSInterval() ) << '\n';
|
|
ofsOutput << "APSDELAYSTEP=" << static_cast<UI16>( APSDelayStep() ) << '\n';
|
|
ofsOutput << "APSDELAYMAXCAP=" << static_cast<UI16>( APSDelayMaxCap() ) << '\n';
|
|
ofsOutput << "}" << '\n' << '\n';
|
|
|
|
ofsOutput << "[clientsupport]" << '\n' << "{" << '\n';
|
|
ofsOutput << "CLIENTSUPPORT4000=" << ( ClientSupport4000() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "CLIENTSUPPORT5000=" << ( ClientSupport5000() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "CLIENTSUPPORT6000=" << ( ClientSupport6000() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "CLIENTSUPPORT6050=" << ( ClientSupport6050() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "CLIENTSUPPORT7000=" << ( ClientSupport7000() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "CLIENTSUPPORT7090=" << ( ClientSupport7090() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "CLIENTSUPPORT70160=" << ( ClientSupport70160() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "CLIENTSUPPORT70240=" << ( ClientSupport70240() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "CLIENTSUPPORT70300=" << ( ClientSupport70300() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "CLIENTSUPPORT70331=" << ( ClientSupport70331() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "CLIENTSUPPORT704565=" << ( ClientSupport704565() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "CLIENTSUPPORT70610=" << ( ClientSupport70610() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[directories]" << '\n' << "{" << '\n';
|
|
ofsOutput << "DIRECTORY=" << Directory( CSDDP_ROOT ) << '\n';
|
|
ofsOutput << "DATADIRECTORY=" << Directory( CSDDP_DATA ) << '\n';
|
|
ofsOutput << "DEFSDIRECTORY=" << Directory( CSDDP_DEFS ) << '\n';
|
|
ofsOutput << "BOOKSDIRECTORY=" << Directory( CSDDP_BOOKS ) << '\n';
|
|
ofsOutput << "ACTSDIRECTORY=" << Directory( CSDDP_ACCOUNTS ) << '\n';
|
|
ofsOutput << "SCRIPTSDIRECTORY=" << Directory( CSDDP_SCRIPTS ) << '\n';
|
|
ofsOutput << "SCRIPTDATADIRECTORY=" << Directory( CSDDP_SCRIPTDATA ) << '\n';
|
|
ofsOutput << "BACKUPDIRECTORY=" << Directory( CSDDP_BACKUP ) << '\n';
|
|
ofsOutput << "MSGBOARDDIRECTORY=" << Directory( CSDDP_MSGBOARD ) << '\n';
|
|
ofsOutput << "SHAREDDIRECTORY=" << Directory( CSDDP_SHARED ) << '\n';
|
|
ofsOutput << "ACCESSDIRECTORY=" << Directory( CSDDP_ACCESS ) << '\n';
|
|
ofsOutput << "HTMLDIRECTORY=" << Directory( CSDDP_HTML ) << '\n';
|
|
ofsOutput << "LOGSDIRECTORY=" << Directory( CSDDP_LOGS ) << '\n';
|
|
ofsOutput << "DICTIONARYDIRECTORY=" << Directory( CSDDP_DICTIONARIES ) << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[skill & stats]" << '\n' << "{" << '\n';
|
|
ofsOutput << "SKILLLEVEL=" << static_cast<UI16>( SkillLevel() ) << '\n';
|
|
ofsOutput << "SKILLCAP=" << ServerSkillTotalCapStatus() << '\n';
|
|
ofsOutput << "SKILLCAPSINGLE=" << ServerSkillCapStatus() << '\n';
|
|
ofsOutput << "SKILLDELAY=" << static_cast<UI16>( ServerSkillDelayStatus() ) << '\n';
|
|
ofsOutput << "STATCAP=" << ServerStatCapStatus() << '\n';
|
|
ofsOutput << "STATSAFFECTSKILLCHECKS=" << ( StatsAffectSkillChecks() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "EXTENDEDSTARTINGSTATS=" << ( ExtendedStartingStats() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "EXTENDEDSTARTINGSKILLS=" << ( ExtendedStartingSkills() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "MAXSTEALTHMOVEMENTS=" << MaxStealthMovement() << '\n';
|
|
ofsOutput << "MAXSTAMINAMOVEMENTS=" << MaxStaminaMovement() << '\n';
|
|
ofsOutput << "SNOOPISCRIME=" << ( SnoopIsCrime() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "SNOOPAWARENESS=" << ( SnoopAwareness() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "ARMORAFFECTMANAREGEN=" << ( ArmorAffectManaRegen() ? 1 : 0) << '\n';
|
|
ofsOutput << "HEALTHREGENMODE=" << static_cast<UI16>( HealthRegenMode() ) << '\n';
|
|
ofsOutput << "STAMINAREGENMODE=" << static_cast<UI16>( StaminaRegenMode() ) << '\n';
|
|
ofsOutput << "MANAREGENMODE=" << static_cast<UI16>( ManaRegenMode() ) << '\n';
|
|
ofsOutput << "HEALINGAFFECTHEALTHREGEN=" << ( HealingAffectHealthRegen() ? 1 : 0) << '\n';
|
|
ofsOutput << "HEALTHREGENCAP=" << HealthRegenCap() << '\n';
|
|
ofsOutput << "STAMINAREGENCAP=" << StaminaRegenCap() << '\n';
|
|
ofsOutput << "MANAREGENCAP=" << ManaRegenCap() << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[timers]" << '\n' << "{" << '\n';
|
|
ofsOutput << "CORPSEDECAYTIMER=" << SystemTimer( tSERVER_CORPSEDECAY ) << '\n';
|
|
ofsOutput << "NPCCORPSEDECAYTIMER=" << SystemTimer( tSERVER_NPCCORPSEDECAY ) << '\n';
|
|
ofsOutput << "WEATHERTIMER=" << SystemTimer( tSERVER_WEATHER ) << '\n';
|
|
ofsOutput << "SHOPSPAWNTIMER=" << SystemTimer( tSERVER_SHOPSPAWN ) << '\n';
|
|
ofsOutput << "DECAYTIMER=" << SystemTimer( tSERVER_DECAY ) << '\n';
|
|
ofsOutput << "DECAYTIMERINHOUSE=" << SystemTimer( tSERVER_DECAYINHOUSE ) << '\n';
|
|
ofsOutput << "INVISIBILITYTIMER=" << SystemTimer( tSERVER_INVISIBILITY ) << '\n';
|
|
ofsOutput << "OBJECTUSETIMER=" << SystemTimer( tSERVER_OBJECTUSAGE ) << '\n';
|
|
ofsOutput << "GATETIMER=" << SystemTimer( tSERVER_GATE ) << '\n';
|
|
ofsOutput << "POISONTIMER=" << SystemTimer( tSERVER_POISON ) << '\n';
|
|
ofsOutput << "LOGINTIMEOUT=" << SystemTimer( tSERVER_LOGINTIMEOUT ) << '\n';
|
|
ofsOutput << "HITPOINTREGENTIMER=" << SystemTimer( tSERVER_HITPOINTREGEN ) << '\n';
|
|
ofsOutput << "STAMINAREGENTIMER=" << SystemTimer( tSERVER_STAMINAREGEN ) << '\n';
|
|
ofsOutput << "MANAREGENTIMER=" << SystemTimer( tSERVER_MANAREGEN ) << '\n';
|
|
ofsOutput << "BASEFISHINGTIMER=" << SystemTimer( tSERVER_FISHINGBASE ) << '\n';
|
|
ofsOutput << "RANDOMFISHINGTIMER=" << SystemTimer( tSERVER_FISHINGRANDOM ) << '\n';
|
|
ofsOutput << "SPIRITSPEAKTIMER=" << SystemTimer( tSERVER_SPIRITSPEAK ) << '\n';
|
|
ofsOutput << "PETOFFLINECHECKTIMER=" << SystemTimer( tSERVER_PETOFFLINECHECK ) << '\n';
|
|
ofsOutput << "NPCFLAGUPDATETIMER=" << SystemTimer( tSERVER_NPCFLAGUPDATETIMER ) << '\n';
|
|
ofsOutput << "BLOODDECAYTIMER=" << SystemTimer( tSERVER_BLOODDECAY ) << '\n';
|
|
ofsOutput << "BLOODDECAYCORPSETIMER=" << SystemTimer( tSERVER_BLOODDECAYCORPSE ) << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "// Supported era values: core, uo, t2a, uor, td, lbr, aos, se, ml, sa, hs, tol" << '\n';
|
|
ofsOutput << '\n' << "// Note: A value of 'core' inherits whatever is set in CORESHARDERA" << '\n';
|
|
ofsOutput << "[expansion settings]" << '\n' << "{" << '\n';
|
|
ofsOutput << "CORESHARDERA=" << EraEnumToString( static_cast<ExpansionRuleset>( ExpansionCoreShardEra() ), true ) << '\n';
|
|
ofsOutput << "ARMORCALCULATION=" << EraEnumToString( static_cast<ExpansionRuleset>( expansionArmorCalculation )) << '\n';
|
|
ofsOutput << "STRENGTHDAMAGEBONUS=" << EraEnumToString( static_cast<ExpansionRuleset>( expansionStrengthDamageBonus )) << '\n';
|
|
ofsOutput << "TACTICSDAMAGEBONUS=" << EraEnumToString( static_cast<ExpansionRuleset>( expansionTacticsDamageBonus )) << '\n';
|
|
ofsOutput << "ANATOMYDAMAGEBONUS=" << EraEnumToString( static_cast<ExpansionRuleset>( expansionAnatomyDamageBonus )) << '\n';
|
|
ofsOutput << "LUMBERJACKDAMAGEBONUS=" << EraEnumToString( static_cast<ExpansionRuleset>( expansionLumberjackDamageBonus )) << '\n';
|
|
ofsOutput << "RACIALDAMAGEBONUS=" << EraEnumToString( static_cast<ExpansionRuleset>( expansionRacialDamageBonus )) << '\n';
|
|
ofsOutput << "DAMAGEBONUSCAP=" << EraEnumToString( static_cast<ExpansionRuleset>( expansionDamageBonusCap )) << '\n';
|
|
ofsOutput << "SHIELDPARRY=" << EraEnumToString( static_cast<ExpansionRuleset>( expansionShieldParry )) << '\n';
|
|
ofsOutput << "WEAPONPARRY=" << EraEnumToString( static_cast<ExpansionRuleset>( expansionWeaponParry )) << '\n';
|
|
ofsOutput << "WRESTLINGPARRY=" << EraEnumToString( static_cast<ExpansionRuleset>( expansionWrestlingParry )) << '\n';
|
|
ofsOutput << "COMBATHITCHANCE=" << EraEnumToString( static_cast<ExpansionRuleset>( expansionCombatHitChance )) << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "// Note: Can be overridden/expanded to other races via races.dfn" << '\n';
|
|
ofsOutput << "[default race bonuses]" << '\n' << "{" << '\n';
|
|
ofsOutput << "HUMANHEALTHREGENBONUS=" << HumanHealthRegenBonus() << '\n';
|
|
ofsOutput << "HUMANSTAMINAREGENBONUS=" << HumanStaminaRegenBonus() << '\n';
|
|
ofsOutput << "HUMANMANAREGENBONUS=" << HumanManaRegenBonus() << '\n';
|
|
ofsOutput << "HUMANMAXWEIGHTBONUS=" << HumanMaxWeightBonus() << '\n';
|
|
ofsOutput << "ELFHEALTHREGENBONUS=" << ElfHealthRegenBonus() << '\n';
|
|
ofsOutput << "ELFSTAMINAREGENBONUS=" << ElfStaminaRegenBonus() << '\n';
|
|
ofsOutput << "ELFMANAREGENBONUS=" << ElfManaRegenBonus() << '\n';
|
|
ofsOutput << "ELFMAXWEIGHTBONUS=" << ElfMaxWeightBonus() << '\n';
|
|
ofsOutput << "GARGOYLEHEALTHREGENBONUS=" << GargoyleHealthRegenBonus() << '\n';
|
|
ofsOutput << "GARGOYLESTAMINAREGENBONUS=" << GargoyleStaminaRegenBonus() << '\n';
|
|
ofsOutput << "GARGOYLEMANAREGENBONUS=" << GargoyleManaRegenBonus() << '\n';
|
|
ofsOutput << "GARGOYLEMAXWEIGHTBONUS=" << GargoyleMaxWeightBonus() << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[settings]" << '\n' << "{" << '\n';
|
|
ofsOutput << "LOOTDECAYSWITHPLAYERCORPSE=" << ( PlayerCorpseLootDecay() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "LOOTDECAYSWITHNPCCORPSE=" << ( NpcCorpseLootDecay() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "GUARDSACTIVE=" << ( GuardsStatus() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "DEATHANIMATION=" << ( DeathAnimationStatus() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AMBIENTSOUNDS=" << WorldAmbientSounds() << '\n';
|
|
ofsOutput << "AMBIENTFOOTSTEPS=" << ( AmbientFootsteps() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "INTERNALACCOUNTCREATION=" << ( InternalAccountStatus() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "SHOWOFFLINEPCS=" << ( ShowOfflinePCs() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "ROGUESENABLED=" << ( RogueStatus() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "PLAYERPERSECUTION=" << ( PlayerPersecutionStatus() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "ACCOUNTFLUSH=" << AccountFlushTimer() << '\n';
|
|
ofsOutput << "HTMLSTATUSENABLED=" << HtmlStatsStatus() << '\n';
|
|
ofsOutput << "SELLBYNAME=" << ( SellByNameStatus() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "SELLMAXITEMS=" << SellMaxItemsStatus() << '\n';
|
|
ofsOutput << "GLOBALRESTOCKMULTIPLIER=" << GlobalRestockMultiplier() << '\n';
|
|
ofsOutput << "BANKBUYTHRESHOLD=" << BuyThreshold() << '\n';
|
|
ofsOutput << "TRADESYSTEM=" << ( TradeSystemStatus() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "RANKSYSTEM=" << ( RankSystemStatus() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "DISPLAYMAKERSMARK=" << ( DisplayMakersMark() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "CUTSCROLLREQUIREMENTS=" << ( CutScrollRequirementStatus() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "NPCTRAININGENABLED=" << ( NPCTrainingStatus() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "HIDEWHILEMOUNTED=" << ( CharHideWhileMounted() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "WEIGHTPERSTR=" << static_cast<R32>( WeightPerStr() ) << '\n';
|
|
ofsOutput << "POLYDURATION=" << SystemTimer( tSERVER_POLYMORPH ) << '\n';
|
|
ofsOutput << "CLIENTFEATURES=" << GetClientFeatures() << '\n';
|
|
ofsOutput << "SERVERFEATURES=" << GetServerFeatures() << '\n';
|
|
ofsOutput << "SPAWNREGIONSFACETS=" << GetSpawnRegionsFacetStatus() << '\n';
|
|
ofsOutput << "MOONGATEFACETS=" << GetMoongateFacetStatus() << '\n';
|
|
ofsOutput << "OVERLOADPACKETS=" << ( ServerOverloadPackets() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "ADVANCEDPATHFINDING=" << ( AdvancedPathfinding() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "LOOTINGISCRIME=" << ( LootingIsCrime() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "BASICTOOLTIPSONLY=" << ( BasicTooltipsOnly() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "SHOWREPUTATIONTITLEINTOOLTIP=" << ( ShowReputationTitleInTooltip() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "SHOWGUILDINFOINTOOLTIP=" << ( ShowGuildInfoInTooltip() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "SHOWNPCTITLESINTOOLTIPS=" << ( ShowNpcTitlesInTooltips() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "SHOWNPCTITLESOVERHEAD=" << ( ShowNpcTitlesOverhead() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "SHOWINVULNERABLETAGOVERHEAD=" << ( ShowInvulnerableTagOverhead() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "SHOWRACEWITHNAME=" << ( ShowRaceWithName() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "SHOWRACEINPAPERDOLL=" << ( ShowRaceInPaperdoll() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "GLOBALITEMDECAY=" << ( GlobalItemDecay() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "SCRIPTITEMSDECAYABLE=" << ( ScriptItemsDecayable() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "BASEITEMSDECAYABLE=" << ( BaseItemsDecayable() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "PAPERDOLLGUILDBUTTON=" << ( PaperdollGuildButton() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "FISHINGSTAMINALOSS=" << FishingStaminaLoss() << '\n';
|
|
ofsOutput << "ITEMSDETECTSPEECH=" << ItemsDetectSpeech() << '\n';
|
|
ofsOutput << "MAXPLAYERPACKITEMS=" << MaxPlayerPackItems() << '\n';
|
|
ofsOutput << "MAXPLAYERBANKITEMS=" << MaxPlayerBankItems() << '\n';
|
|
ofsOutput << "MAXPLAYERPACKWEIGHT=" << MaxPlayerPackWeight() << '\n';
|
|
ofsOutput << "MAXPLAYERBANKWEIGHT=" << MaxPlayerBankWeight() << '\n';
|
|
ofsOutput << "FORCENEWANIMATIONPACKET=" << ForceNewAnimationPacket() << '\n';
|
|
ofsOutput << "MAPDIFFSENABLED=" << MapDiffsEnabled() << '\n';
|
|
ofsOutput << "TOOLUSELIMIT=" << ToolUseLimit() << '\n';
|
|
ofsOutput << "TOOLUSEBREAK=" << ToolUseBreak() << '\n';
|
|
ofsOutput << "ITEMREPAIRDURABILITYLOSS=" << ItemRepairDurabilityLoss() << '\n';
|
|
ofsOutput << "CRAFTCOLOUREDWEAPONS=" << CraftColouredWeapons() << '\n';
|
|
ofsOutput << "MAXSAFETELEPORTSPERDAY=" << static_cast<UI16>( MaxSafeTeleportsPerDay() ) << '\n';
|
|
ofsOutput << "TELEPORTTONEARESTSAFELOCATION=" << ( TeleportToNearestSafeLocation() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "ALLOWAWAKENPCS=" << ( AllowAwakeNPCs() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "ENABLENPCGUILDDISCOUNTS=" << ( EnableNPCGuildDiscounts() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "ENABLENPCGUILDPREMIUMS=" << ( EnableNPCGuildPremiums() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "YOUNGPLAYERSYSTEM=" << ( YoungPlayerSystem() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "KARMALOCKING=" << ( KarmaLocking() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[pets and followers]" << '\n' << "{" << '\n';
|
|
ofsOutput << "MAXCONTROLSLOTS=" << static_cast<UI16>( MaxControlSlots() ) << '\n';
|
|
ofsOutput << "MAXFOLLOWERS=" << static_cast<UI16>( MaxFollowers() ) << '\n';
|
|
ofsOutput << "MAXPETOWNERS=" << static_cast<UI16>( MaxPetOwners() ) << '\n';
|
|
ofsOutput << "CHECKPETCONTROLDIFFICULTY=" << ( CheckPetControlDifficulty() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "PETLOYALTYGAINONSUCCESS=" << static_cast<UI16>( GetPetLoyaltyGainOnSuccess() ) << '\n';
|
|
ofsOutput << "PETLOYALTYLOSSONFAILURE=" << static_cast<UI16>( GetPetLoyaltyLossOnFailure() ) << '\n';
|
|
ofsOutput << "PETLOYALTYRATE=" << SystemTimer( tSERVER_LOYALTYRATE ) << '\n';
|
|
ofsOutput << "PETBONDINGENABLED=" << ( PetBondingEnabled() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[speedup]" << '\n' << "{" << '\n';
|
|
ofsOutput << "CHECKITEMS=" << CheckItemsSpeed() << '\n';
|
|
ofsOutput << "CHECKBOATS=" << CheckBoatSpeed() << '\n';
|
|
ofsOutput << "CHECKNPCAI=" << CheckNpcAISpeed() << '\n';
|
|
ofsOutput << "CHECKSPAWNREGIONS=" << CheckSpawnRegionSpeed() << '\n';
|
|
ofsOutput << "NPCMOVEMENTSPEED=" << NPCWalkingSpeed() << '\n';
|
|
ofsOutput << "NPCRUNNINGSPEED=" << NPCRunningSpeed() << '\n';
|
|
ofsOutput << "NPCFLEEINGSPEED=" << NPCFleeingSpeed() << '\n';
|
|
ofsOutput << "NPCMOUNTEDWALKINGSPEED=" << NPCMountedWalkingSpeed() << '\n';
|
|
ofsOutput << "NPCMOUNTEDRUNNINGSPEED=" << NPCMountedRunningSpeed() << '\n';
|
|
ofsOutput << "NPCMOUNTEDFLEEINGSPEED=" << NPCMountedFleeingSpeed() << '\n';
|
|
ofsOutput << "NPCSPELLCASTSPEED=" << NPCSpellCastSpeed() << '\n';
|
|
ofsOutput << "GLOBALATTACKSPEED=" << GlobalAttackSpeed() << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[message boards]" << '\n' << "{" << '\n';
|
|
ofsOutput << "POSTINGLEVEL=" << static_cast<UI16>( MsgBoardPostingLevel() ) << '\n';
|
|
ofsOutput << "REMOVALLEVEL=" << static_cast<UI16>( MsgBoardPostRemovalLevel() ) << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[escorts]" << '\n' << "{" << '\n';
|
|
ofsOutput << "ESCORTENABLED=" << ( EscortsEnabled() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "ESCORTINITEXPIRE=" << SystemTimer( tSERVER_ESCORTWAIT ) << '\n';
|
|
ofsOutput << "ESCORTACTIVEEXPIRE=" << SystemTimer( tSERVER_ESCORTACTIVE ) << '\n';
|
|
ofsOutput << "ESCORTDONEEXPIRE=" << SystemTimer( tSERVER_ESCORTDONE ) << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[worldlight]" << '\n' << "{" << '\n';
|
|
ofsOutput << "DUNGEONLEVEL=" << static_cast<UI16>( DungeonLightLevel() ) << '\n';
|
|
ofsOutput << "BRIGHTLEVEL=" << static_cast<UI16>( WorldLightBrightLevel() ) << '\n';
|
|
ofsOutput << "DARKLEVEL=" << static_cast<UI16>( WorldLightDarkLevel() ) << '\n';
|
|
ofsOutput << "SECONDSPERUOMINUTE=" << ServerSecondsPerUOMinute() << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[tracking]" << '\n' << "{" << '\n';
|
|
ofsOutput << "BASERANGE=" << TrackingBaseRange() << '\n';
|
|
ofsOutput << "BASETIMER=" << TrackingBaseTimer() << '\n';
|
|
ofsOutput << "MAXTARGETS=" << static_cast<UI16>( TrackingMaxTargets() ) << '\n';
|
|
ofsOutput << "MSGREDISPLAYTIME=" << TrackingRedisplayTime() << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[reputation]" << '\n' << "{" << '\n';
|
|
ofsOutput << "MURDERDECAYTIMER=" << SystemTimer( tSERVER_MURDERDECAY ) << '\n';
|
|
ofsOutput << "MAXKILLS=" << RepMaxKills() << '\n';
|
|
ofsOutput << "CRIMINALTIMER=" << SystemTimer( tSERVER_CRIMINAL ) << '\n';
|
|
ofsOutput << "AGGRESSORFLAGTIMER=" << SystemTimer( tSERVER_AGGRESSORFLAG ) << '\n';
|
|
ofsOutput << "PERMAGREYFLAGTIMER=" << SystemTimer( tSERVER_PERMAGREYFLAG ) << '\n';
|
|
ofsOutput << "STEALINGFLAGTIMER=" << SystemTimer( tSERVER_STEALINGFLAG ) << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[resources]" << '\n' << "{" << '\n';
|
|
ofsOutput << "RESOURCEAREASIZE=" << ResourceAreaSize() << '\n';
|
|
ofsOutput << "MINECHECK=" << static_cast<UI16>( MineCheck() ) << '\n';
|
|
ofsOutput << "OREPERAREA=" << ResOre() << '\n';
|
|
ofsOutput << "ORERESPAWNTIMER=" << ResOreTime() << '\n';
|
|
ofsOutput << "LOGSPERAREA=" << ResLogs() << '\n';
|
|
ofsOutput << "LOGSRESPAWNTIMER=" << ResLogTime() << '\n';
|
|
ofsOutput << "FISHPERAREA=" << ResFish() << '\n';
|
|
ofsOutput << "FISHRESPAWNTIMER=" << ResFishTime() << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[hunger]" << '\n' << "{" << '\n';
|
|
ofsOutput << "HUNGERENABLED=" << ( HungerSystemEnabled() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "HUNGERRATE=" << SystemTimer( tSERVER_HUNGERRATE ) << '\n';
|
|
ofsOutput << "HUNGERDMGVAL=" << HungerDamage() << '\n';
|
|
ofsOutput << "HUNGERAFFECTHEALTHREGEN=" << ( HungerAffectHealthRegen() ? 1 : 0) << '\n';
|
|
ofsOutput << "PETHUNGEROFFLINE=" << ( PetHungerOffline() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "PETOFFLINETIMEOUT=" << PetOfflineTimeout() << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[thirst]" << '\n' << "{" << '\n';
|
|
ofsOutput << "THIRSTENABLED=" << ( ThirstSystemEnabled() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "THIRSTRATE=" << SystemTimer( tSERVER_THIRSTRATE ) << '\n';
|
|
ofsOutput << "THIRSTDRAINVAL=" << ThirstDrain() << '\n';
|
|
ofsOutput << "THIRSTAFFECTSTAMINAREGEN=" << ( ThirstAffectStaminaRegen() ? 1 : 0) << '\n';
|
|
ofsOutput << "PETTHIRSTOFFLINE=" << ( PetThirstOffline() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[combat]" << '\n' << "{" << '\n';
|
|
ofsOutput << "MAXRANGE=" << CombatMaxRange() << '\n';
|
|
ofsOutput << "SPELLMAXRANGE=" << CombatMaxSpellRange() << '\n';
|
|
ofsOutput << "MAXNPCAGGRORANGE=" << CombatMaxNpcAggroRange() << '\n';
|
|
ofsOutput << "DISPLAYHITMSG=" << ( CombatDisplayHitMessage() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "DISPLAYDAMAGENUMBERS=" << ( CombatDisplayDamageNumbers() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "MONSTERSVSANIMALS=" << ( CombatMonstersVsAnimals() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "ANIMALATTACKCHANCE=" << static_cast<UI16>( CombatAnimalsAttackChance() ) << '\n';
|
|
ofsOutput << "ANIMALSGUARDED=" << ( CombatAnimalsGuarded() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "NPCDAMAGERATE=" << CombatNpcDamageRate() << '\n';
|
|
ofsOutput << "NPCBASEFLEEAT=" << CombatNPCBaseFleeAt() << '\n';
|
|
ofsOutput << "NPCBASEREATTACKAT=" << CombatNPCBaseReattackAt() << '\n';
|
|
ofsOutput << "ATTACKSTAMINA=" << CombatAttackStamina() << '\n';
|
|
ofsOutput << "ATTACKSPEEDFROMSTAMINA=" << ( CombatAttackSpeedFromStamina() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "ARCHERYHITBONUS=" << static_cast<SI16>( CombatArcheryHitBonus() ) << '\n';
|
|
ofsOutput << "ARCHERYSHOOTDELAY=" << CombatArcheryShootDelay() << '\n';
|
|
ofsOutput << "SHOOTONANIMALBACK=" << ( ShootOnAnimalBack() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "WEAPONDAMAGECHANCE=" << static_cast<UI16>( CombatWeaponDamageChance() ) << '\n';
|
|
ofsOutput << "WEAPONDAMAGEMIN=" << static_cast<UI16>( CombatWeaponDamageMin() ) << '\n';
|
|
ofsOutput << "WEAPONDAMAGEMAX=" << static_cast<UI16>( CombatWeaponDamageMax() ) << '\n';
|
|
ofsOutput << "ARMORDAMAGECHANCE=" << static_cast<UI16>( CombatArmorDamageChance() ) << '\n';
|
|
ofsOutput << "ARMORDAMAGEMIN=" << static_cast<UI16>( CombatArmorDamageMin() ) << '\n';
|
|
ofsOutput << "ARMORDAMAGEMAX=" << static_cast<UI16>( CombatArmorDamageMax() ) << '\n';
|
|
ofsOutput << "PARRYDAMAGECHANCE=" << static_cast<UI16>( CombatParryDamageChance() ) << '\n';
|
|
ofsOutput << "PARRYDAMAGEMIN=" << static_cast<UI16>( CombatParryDamageMin() ) << '\n';
|
|
ofsOutput << "PARRYDAMAGEMAX=" << static_cast<UI16>( CombatParryDamageMax() ) << '\n';
|
|
ofsOutput << "ARMORCLASSDAMAGEBONUS=" << ( CombatArmorClassDamageBonus() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "ALCHEMYBONUSENABLED=" << ( AlchemyDamageBonusEnabled() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "ALCHEMYBONUSMODIFIER=" << static_cast<UI16>( AlchemyDamageBonusModifier() ) << '\n';
|
|
ofsOutput << "BLOODEFFECTCHANCE=" << static_cast<UI16>( CombatBloodEffectChance() ) << '\n';
|
|
ofsOutput << "ITEMSINTERRUPTCASTING=" << ( ItemsInterruptCasting() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "PETCOMBATTRAINING=" << ( PetCombatTraining() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "HIRELINGCOMBATTRAINING=" << ( HirelingCombatTraining() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "NPCCOMBATTRAINING=" << ( NpcCombatTraining() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "SHOWITEMRESISTSTATS=" << ( ShowItemResistStats() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "SHOWWEAPONDAMAGETYPES=" << ( ShowWeaponDamageTypes() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "WEAPONDAMAGEBONUSTYPE=" << static_cast<UI16>( WeaponDamageBonusType() ) << '\n';
|
|
ofsOutput << "WEAPONSWINGSPEEDINCREASECAP=" << SwingSpeedIncreaseCap() << '\n';
|
|
//ofsOutput << "PHYSICALRESISTCAP=" << PhysicalResistCap() << '\n';
|
|
//ofsOutput << "FIRERESISTCAP=" << FireResistCap() << '\n';
|
|
//ofsOutput << "COLDRESISTCAP=" << ColdResistCap() << '\n';
|
|
//ofsOutput << "POISONRESISTCAP=" << PoisonResistCap() << '\n';
|
|
//ofsOutput << "ENERGYRESISTCAP=" << EnergyResistCap() << '\n';
|
|
//ofsOutput << "DEFENSECHANCEINCREASECAP=" << DefenseChanceIncreaseCap() << '\n';
|
|
ofsOutput << "DAMAGEINCREASECAP=" << DamageIncreaseCap() << '\n';
|
|
ofsOutput << "POISONCORROSIONSYSTEM=" << ( PoisonCorrosionSystem() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[magic]" << '\n' << "{" << '\n';
|
|
ofsOutput << "TRAVELSPELLSFROMBOATKEYS=" << ( TravelSpellsFromBoatKeys() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "TRAVELSPELLSWHILEOVERWEIGHT=" << ( TravelSpellsWhileOverweight() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "MARKRUNESINMULTIS=" << ( MarkRunesInMultis() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "TRAVELSPELLSBETWEENWORLDS=" << ( TravelSpellsBetweenWorlds() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "TRAVELSPELLSWHILEAGGRESSOR=" << ( TravelSpellsWhileAggressor() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "HIDESTATSFORUNKNOWNMAGICITEMS=" << HideStatsForUnknownMagicItems() << '\n';
|
|
ofsOutput << "CASTSPELLSWHILEMOVING=" << ( CastSpellsWhileMoving() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AUTOUNEQUIPPEDCASTING=" << ( AutoUnequippedCasting() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[start locations]" << '\n' << "{" << '\n';
|
|
for( size_t lCtr = 0; lCtr < startlocations.size(); ++lCtr )
|
|
{
|
|
ofsOutput << "LOCATION=" << startlocations[lCtr].newTown << "," << startlocations[lCtr].newDescription << "," << startlocations[lCtr].x << "," << startlocations[lCtr].y << "," << startlocations[lCtr].z << "," << startlocations[lCtr].worldNum << "," << startlocations[lCtr].instanceId << "," << startlocations[lCtr].clilocDesc << '\n';
|
|
}
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[young start locations]" << '\n' << "{" << '\n';
|
|
for( size_t lCtr = 0; lCtr < youngStartlocations.size(); ++lCtr )
|
|
{
|
|
ofsOutput << "YOUNGLOCATION=" << youngStartlocations[lCtr].newTown << "," << youngStartlocations[lCtr].newDescription << "," << youngStartlocations[lCtr].x << "," << youngStartlocations[lCtr].y << "," << youngStartlocations[lCtr].z << "," << youngStartlocations[lCtr].worldNum << "," << youngStartlocations[lCtr].instanceId << "," << youngStartlocations[lCtr].clilocDesc << '\n';
|
|
}
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[startup]" << '\n' << "{" << '\n';
|
|
ofsOutput << "STARTGOLD=" << ServerStartGold() << '\n';
|
|
ofsOutput << "STARTPRIVS=" << ServerStartPrivs() << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[gumps]" << '\n' << "{" << '\n';
|
|
ofsOutput << "TITLECOLOUR=" << TitleColour() << '\n';
|
|
ofsOutput << "LEFTTEXTCOLOUR=" << LeftTextColour() << '\n';
|
|
ofsOutput << "RIGHTTEXTCOLOUR=" << RightTextColour() << '\n';
|
|
ofsOutput << "BUTTONCANCEL=" << ButtonCancel() << '\n';
|
|
ofsOutput << "BUTTONLEFT=" << ButtonLeft() << '\n';
|
|
ofsOutput << "BUTTONRIGHT=" << ButtonRight() << '\n';
|
|
ofsOutput << "BACKGROUNDPIC=" << BackgroundPic() << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[houses]" << '\n' << "{" << '\n';
|
|
ofsOutput << "TRACKHOUSESPERACCOUNT=" << ( TrackHousesPerAccount() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "CANOWNANDCOOWNHOUSES=" << ( CanOwnAndCoOwnHouses() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "COOWNHOUSESONSAMEACCOUNT=" << ( CoOwnHousesOnSameAccount() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "ITEMDECAYINHOUSES=" << ( ItemDecayInHouses() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "PROTECTPRIVATEHOUSES=" << ( ProtectPrivateHouses() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "MAXHOUSESOWNABLE=" << MaxHousesOwnable() << '\n';
|
|
ofsOutput << "MAXHOUSESCOOWNABLE=" << MaxHousesCoOwnable() << '\n';
|
|
ofsOutput << "SAFECOOWNERLOGOUT=" << ( SafeCoOwnerLogout() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "SAFEFRIENDLOGOUT=" << ( SafeFriendLogout() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "SAFEGUESTLOGOUT=" << ( SafeGuestLogout() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "KEYLESSOWNERACCESS=" << ( KeylessOwnerAccess() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "KEYLESSCOOWNERACCESS=" << ( KeylessCoOwnerAccess() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "KEYLESSFRIENDACCESS=" << ( KeylessFriendAccess() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "KEYLESSGUESTACCESS=" << ( KeylessGuestAccess() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[bulk order deeds]" << '\n' << "{" << '\n';
|
|
ofsOutput << "OFFERBODSFROMITEMSALES=" << ( OfferBODsFromItemSales() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "OFFERBODSFROMCONTEXTMENU=" << ( OfferBODsFromContextMenu() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "BODSFROMCRAFTEDITEMSONLY=" << ( BODsFromCraftedItemsOnly() ? 1 : 0 ) << '\n';
|
|
ofsOutput << "BODGOLDREWARDMULTIPLIER=" << BODGoldRewardMultiplier() << '\n';
|
|
ofsOutput << "BODFAMEREWARDMULTIPLIER=" << BODFameRewardMultiplier() << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[towns]" << '\n' << "{" << '\n';
|
|
ofsOutput << "POLLTIME=" << TownNumSecsPollOpen() << '\n';
|
|
ofsOutput << "MAYORTIME=" << TownNumSecsAsMayor() << '\n';
|
|
ofsOutput << "TAXPERIOD=" << TownTaxPeriod() << '\n';
|
|
ofsOutput << "GUARDSPAID=" << TownGuardPayment() << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput << '\n' << "[disabled assistant features]" << '\n' << "{" << '\n';
|
|
ofsOutput << "AF_FILTERWEATHER=" << ( GetDisabledAssistantFeature( AF_FILTERWEATHER ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_FILTERLIGHT=" << ( GetDisabledAssistantFeature( AF_FILTERLIGHT ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_SMARTTARGET=" << ( GetDisabledAssistantFeature( AF_SMARTTARGET ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_RANGEDTARGET=" << ( GetDisabledAssistantFeature( AF_RANGEDTARGET ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_AUTOOPENDOORS=" << ( GetDisabledAssistantFeature( AF_AUTOOPENDOORS ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_DEQUIPONCAST=" << ( GetDisabledAssistantFeature( AF_DEQUIPONCAST ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_AUTOPOTIONEQUIP=" << ( GetDisabledAssistantFeature( AF_AUTOPOTIONEQUIP ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_POISONEDCHECKS=" << ( GetDisabledAssistantFeature( AF_POISONEDCHECKS ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_LOOPEDMACROS=" << ( GetDisabledAssistantFeature( AF_LOOPEDMACROS ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_USEONCEAGENT=" << ( GetDisabledAssistantFeature( AF_USEONCEAGENT ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_RESTOCKAGENT=" << ( GetDisabledAssistantFeature( AF_RESTOCKAGENT ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_SELLAGENT=" << ( GetDisabledAssistantFeature( AF_SELLAGENT ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_BUYAGENT=" << ( GetDisabledAssistantFeature( AF_BUYAGENT ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_POTIONHOTKEYS=" << ( GetDisabledAssistantFeature( AF_POTIONHOTKEYS ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_RANDOMTARGETS=" << ( GetDisabledAssistantFeature( AF_RANDOMTARGETS ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_CLOSESTTARGETS=" << ( GetDisabledAssistantFeature( AF_CLOSESTTARGETS ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_OVERHEADHEALTH=" << ( GetDisabledAssistantFeature( AF_OVERHEADHEALTH ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_AUTOLOOTAGENT=" << ( GetDisabledAssistantFeature( AF_AUTOLOOTAGENT ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_BONECUTTERAGENT=" << ( GetDisabledAssistantFeature( AF_BONECUTTERAGENT ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_JSCRIPTMACROS=" << ( GetDisabledAssistantFeature( AF_JSCRIPTMACROS ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_AUTOREMOUNT=" << ( GetDisabledAssistantFeature( AF_AUTOREMOUNT ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_AUTOBANDAGE=" << ( GetDisabledAssistantFeature( AF_AUTOBANDAGE ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_ENEMYTARGETSHARE=" << ( GetDisabledAssistantFeature( AF_ENEMYTARGETSHARE ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_FILTERSEASON=" << ( GetDisabledAssistantFeature( AF_FILTERSEASON ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_SPELLTARGETSHARE=" << ( GetDisabledAssistantFeature( AF_SPELLTARGETSHARE ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_HUMANOIDHEALTHCHECKS=" << ( GetDisabledAssistantFeature( AF_HUMANOIDHEALTHCHECKS ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "AF_SPEECHJOURNALCHECKS=" << ( GetDisabledAssistantFeature( AF_SPEECHJOURNALCHECKS ) ? 1 : 0 ) << '\n';
|
|
ofsOutput << "}" << '\n';
|
|
|
|
ofsOutput.close();
|
|
rValue = true;
|
|
}
|
|
else
|
|
{
|
|
Console.Error( oldstrutil::format( "Unable to open file %s for writing", filename.c_str() ));
|
|
}
|
|
return rValue;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::Load()
|
|
//| Date - January 13, 2001
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Load up the uox.ini file and parse it into the internals
|
|
//| Returns - pointer to the valid inmemory serverdata storage(this)
|
|
//| nullptr is there is an error, or invalid file type
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::Load( const std::string &filename ) -> bool
|
|
{
|
|
auto iniFile = filename;
|
|
if( iniFile.empty() )
|
|
{
|
|
iniFile = Directory( CSDDP_ROOT ) + "uox.ini"s;
|
|
}
|
|
actualINI = iniFile;
|
|
auto rValue = ParseIni( iniFile );
|
|
PostLoadDefaults();
|
|
return rValue;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::TrackingBaseRange()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the base (minimum) range even beginner trackers can track at
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::TrackingBaseRange() const -> UI16
|
|
{
|
|
return trackingBaseRange;
|
|
}
|
|
auto CServerData::TrackingBaseRange( UI16 value ) -> void
|
|
{
|
|
trackingBaseRange = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::TrackingMaxTargets()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the max amount of targets someone can see in the tracking window
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::TrackingMaxTargets() const -> UI08
|
|
{
|
|
return trackingMaxTargets;
|
|
}
|
|
auto CServerData::TrackingMaxTargets( UI08 value ) -> void
|
|
{
|
|
if( value >= MAX_TRACKINGTARGETS )
|
|
{
|
|
trackingMaxTargets = MAX_TRACKINGTARGETS;
|
|
}
|
|
else
|
|
{
|
|
trackingMaxTargets = value;
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::TrackingBaseTimer()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the max amount of time a grandmaster tracker can track someone
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::TrackingBaseTimer() const -> UI16
|
|
{
|
|
return trackingBaseTimer;
|
|
}
|
|
auto CServerData::TrackingBaseTimer( UI16 value ) -> void
|
|
{
|
|
trackingBaseTimer = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::TrackingRedisplayTime()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets how often in seconds the tracking message is updated and displayed
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::TrackingRedisplayTime() const -> UI16
|
|
{
|
|
return trackingMsgRedisplayTimer;
|
|
}
|
|
auto CServerData::TrackingRedisplayTime( UI16 value ) -> void
|
|
{
|
|
trackingMsgRedisplayTimer = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::SwingSpeedIncreaseCap()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets cap for swing speed increase
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::SwingSpeedIncreaseCap() const -> SI16
|
|
{
|
|
return swingSpeedIncreaseCap;
|
|
}
|
|
auto CServerData::SwingSpeedIncreaseCap( SI16 value ) -> void
|
|
{
|
|
swingSpeedIncreaseCap = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::PhysicalResistCap()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets cap for physical resist
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::PhysicalResistCap() const -> SI16
|
|
{
|
|
return physicalResistCap;
|
|
}
|
|
auto CServerData::PhysicalResistCap( SI16 value ) -> void
|
|
{
|
|
physicalResistCap = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::FireResistCap()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets cap for fire resist
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::FireResistCap() const -> SI16
|
|
{
|
|
return fireResistCap;
|
|
}
|
|
auto CServerData::FireResistCap( SI16 value ) -> void
|
|
{
|
|
fireResistCap = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ColdResistCap()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets cap for cold resist
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ColdResistCap() const -> SI16
|
|
{
|
|
return coldResistCap;
|
|
}
|
|
auto CServerData::ColdResistCap( SI16 value ) -> void
|
|
{
|
|
coldResistCap = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::PoisonResistCap()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets cap for poison resist
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::PoisonResistCap() const -> SI16
|
|
{
|
|
return poisonResistCap;
|
|
}
|
|
auto CServerData::PoisonResistCap( SI16 value ) -> void
|
|
{
|
|
poisonResistCap = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::EnergyResistCap()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets cap for energy resist
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::EnergyResistCap() const -> SI16
|
|
{
|
|
return energyResistCap;
|
|
}
|
|
auto CServerData::EnergyResistCap( SI16 value ) -> void
|
|
{
|
|
energyResistCap = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::DefenseChanceIncreaseCap()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets cap for defense chance increase
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::DefenseChanceIncreaseCap() const -> SI16
|
|
{
|
|
return defenseChanceIncreaseCap;
|
|
}
|
|
auto CServerData::DefenseChanceIncreaseCap( SI16 value ) -> void
|
|
{
|
|
defenseChanceIncreaseCap = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::DamageIncreaseCap()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets cap for damage increase
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::DamageIncreaseCap() const -> SI16
|
|
{
|
|
return damageIncreaseCap;
|
|
}
|
|
auto CServerData::DamageIncreaseCap( SI16 value ) -> void
|
|
{
|
|
damageIncreaseCap = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ParseIni()
|
|
//| Date - 02/26/2001
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Parse the uox.ini file into its required information.
|
|
//|
|
|
//| Changes - 02/26/2002 - Make sure that we parse out the logs, access
|
|
//| and other directories that we were not parsing/
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ParseIni( const std::string& filename ) -> bool
|
|
{
|
|
auto rValue = false;
|
|
auto input = std::ifstream( filename );
|
|
enum search_t { header, startsection, endsection };
|
|
auto retrieveContents = []( const std::string& input ) -> std::optional<std::string>
|
|
{
|
|
auto pos1 = input.find("[" );
|
|
if( pos1 != std::string::npos )
|
|
{
|
|
auto pos2 = input.find( "]", pos1 );
|
|
if( pos2 != std::string::npos )
|
|
{
|
|
// We have the bounds
|
|
auto contents = oldstrutil::trim( input.substr( pos1 + 1, ( pos2 - pos1 ) - 1 ));
|
|
return contents;
|
|
}
|
|
}
|
|
return {};
|
|
};
|
|
auto state = search_t( header );
|
|
if( input.is_open() )
|
|
{
|
|
startlocations.clear();
|
|
youngStartlocations.clear();
|
|
char input_buffer[4096];
|
|
while( input.good() && !input.eof() )
|
|
{
|
|
input.getline( input_buffer, 4095 );
|
|
if( input.gcount() > 0 )
|
|
{
|
|
input_buffer[input.gcount()] = 0;
|
|
auto line = oldstrutil::trim( oldstrutil::removeTrailing( std::string( input_buffer ), "//" ));
|
|
if( !line.empty() )
|
|
{
|
|
switch( static_cast<int>( state ))
|
|
{
|
|
case static_cast<int>( search_t::header ):
|
|
{
|
|
if( line[0] == '[' )
|
|
{
|
|
auto contents = retrieveContents( line );
|
|
if( contents.has_value() )
|
|
{
|
|
state = search_t::startsection;
|
|
}
|
|
}
|
|
}
|
|
[[fallthrough]];
|
|
case static_cast<int>( search_t::startsection ):
|
|
{
|
|
if( line[0] == '{' )
|
|
{
|
|
state = search_t::endsection;
|
|
}
|
|
}
|
|
[[fallthrough]];
|
|
case static_cast<int>( search_t::endsection ):
|
|
{
|
|
if( line[0] != '}' )
|
|
{
|
|
auto [key, value] = oldstrutil::split( line, "=" );
|
|
try
|
|
{
|
|
if( HandleLine( key, value ))
|
|
{
|
|
rValue = true;
|
|
}
|
|
}
|
|
catch( const std::exception &e )
|
|
{
|
|
Console.Error( "Error parsing ini file" );
|
|
Console.Error( oldstrutil::format( "Entry was: %s = %s", key.c_str(), value.c_str() ));
|
|
Console.Error( oldstrutil::format( "Exception was: %s", e.what() ));
|
|
exit( 1 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
state = search_t::header;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return rValue;
|
|
/*
|
|
bool rValue = false;
|
|
if( !filename.empty() ) {
|
|
|
|
Console << "Processing INI Settings ";
|
|
|
|
Script toParse( filename, NUM_DEFS, false );
|
|
// Lock this file tight, No access at anytime when open(should only be open and closed anyhow. For Thread blocking)
|
|
if( !toParse.IsErrored() ) {
|
|
//serverList.clear();
|
|
startlocations.clear();
|
|
for (auto &[id,section] : toParse.collection() ){
|
|
if( section){
|
|
for (auto &sec : section->collection() ){
|
|
auto tag = sec->tag;
|
|
auto data = oldstrutil::simplify( sec->data );
|
|
if( !HandleLine( tag, data )) {
|
|
Console.Warning( oldstrutil::format( "Unhandled tag '%s'", tag.c_str() ));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Console.PrintDone();
|
|
rValue = true;
|
|
}
|
|
else
|
|
{
|
|
Console.Warning( oldstrutil::format( "%s File not found, Using default settings.", filename.c_str() ));
|
|
cwmWorldState->ServerData()->save();
|
|
}
|
|
}
|
|
return rValue;
|
|
*/
|
|
}
|
|
|
|
//==================================================================================================
|
|
auto CServerData::HandleLine( const std::string& tag, const std::string& value ) -> bool
|
|
{
|
|
bool rValue = true;
|
|
auto titer = uox3IniCaseValue.find( tag );
|
|
if( titer == uox3IniCaseValue.end() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
switch( titer->second )
|
|
{
|
|
case 1: // SERVERNAME
|
|
ServerName( value );
|
|
break;
|
|
case 2: // CONSOLELOG
|
|
ServerConsoleLog(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 3: // COMMANDPREFIX
|
|
ServerCommandPrefix(( value.data()[0] )); // return the first character of the return string only
|
|
break;
|
|
case 4: // ANNOUNCEWORLDSAVES
|
|
ServerAnnounceSaves(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 ? true : false ));
|
|
break;
|
|
case 26: // JOINPARTMSGS
|
|
ServerJoinPartAnnouncements(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 ? true : false ));
|
|
break;
|
|
case 5: // BACKUPSENABLED
|
|
ServerBackups(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) > 0 ? true : false ));
|
|
break;
|
|
case 6: // SAVESTIMER
|
|
ServerSavesTimer( static_cast<UI32>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 7: // SKILLCAP
|
|
ServerSkillTotalCap( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 8: // SKILLDELAY
|
|
ServerSkillDelay( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 9: // STATCAP
|
|
ServerStatCap( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 10: // MAXSTEALTHMOVEMENTS
|
|
MaxStealthMovement( static_cast<SI16>( std::stoi( value, nullptr, 0 )));
|
|
break;
|
|
case 11: // MAXSTAMINAMOVEMENTS
|
|
MaxStaminaMovement( static_cast<SI16>( std::stoi( value, nullptr, 0 )));
|
|
break;
|
|
case 12: // ARMORAFFECTMANAREGEN
|
|
ArmorAffectManaRegen(( static_cast<UI08>( std::stoul( value, nullptr, 0 )) > 0 ? true : false ));
|
|
break;
|
|
case 13: // CORPSEDECAYTIMER
|
|
SystemTimer( tSERVER_CORPSEDECAY, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 14: // WEATHERTIMER
|
|
SystemTimer( tSERVER_WEATHER, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 15: // SHOPSPAWNTIMER
|
|
SystemTimer( tSERVER_SHOPSPAWN, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 16: // DECAYTIMER
|
|
SystemTimer( tSERVER_DECAY, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 17: // INVISIBILITYTIMER
|
|
SystemTimer( tSERVER_INVISIBILITY, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 18: // OBJECTUSETIMER
|
|
SystemTimer( tSERVER_OBJECTUSAGE, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 19: // GATETIMER
|
|
SystemTimer( tSERVER_GATE, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 20: // POISONTIMER
|
|
SystemTimer( tSERVER_POISON, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 21: // LOGINTIMEOUT
|
|
SystemTimer( tSERVER_LOGINTIMEOUT, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 22: // HITPOINTREGENTIMER
|
|
SystemTimer( tSERVER_HITPOINTREGEN, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 23: // STAMINAREGENTIMER
|
|
SystemTimer( tSERVER_STAMINAREGEN, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 24: // BASEFISHINGTIMER
|
|
SystemTimer( tSERVER_FISHINGBASE, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 34: // MAXPETOWNERS
|
|
MaxPetOwners( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 35: // MAXFOLLOWERS
|
|
MaxFollowers( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 36: // MAXCONTROLSLOTS
|
|
MaxControlSlots( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 37: // MANAREGENTIMER
|
|
SystemTimer( tSERVER_MANAREGEN, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 38: // RANDOMFISHINGTIMER
|
|
SystemTimer( tSERVER_FISHINGRANDOM, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 39: // SPIRITSPEAKTIMER
|
|
SystemTimer( tSERVER_SPIRITSPEAK, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 40: // DIRECTORY
|
|
{
|
|
Directory( CSDDP_ROOT, value );
|
|
break;
|
|
}
|
|
case 41: // DATADIRECTORY
|
|
{
|
|
Directory( CSDDP_DATA, value );
|
|
break;
|
|
}
|
|
case 42: // DEFSDIRECTORY
|
|
{
|
|
Directory( CSDDP_DEFS, value );
|
|
break;
|
|
}
|
|
case 43: // ACTSDIRECTORY
|
|
{
|
|
Directory( CSDDP_ACCOUNTS, value );
|
|
break;
|
|
}
|
|
case 25: // SCRIPTSDIRECTORY
|
|
{
|
|
Directory( CSDDP_SCRIPTS, value );
|
|
break;
|
|
}
|
|
case 44: // BACKUPDIRECTORY
|
|
{
|
|
Directory( CSDDP_BACKUP, value );
|
|
break;
|
|
}
|
|
case 45: // MSGBOARDDIRECTORY
|
|
{
|
|
Directory( CSDDP_MSGBOARD, value );
|
|
break;
|
|
}
|
|
case 46: // SHAREDDIRECTORY
|
|
{
|
|
Directory( CSDDP_SHARED, value );
|
|
break;
|
|
}
|
|
case 47: // LOOTDECAYSWITHPLAYERCORPSE
|
|
PlayerCorpseLootDecay( static_cast<UI16>( std::stoul( value, nullptr, 0 )) != 0 );
|
|
break;
|
|
case 49: // GUARDSACTIVE
|
|
GuardStatus( static_cast<UI16>( std::stoul( value, nullptr, 0 )) != 0 );
|
|
break;
|
|
case 27: // DEATHANIMATION
|
|
DeathAnimationStatus( static_cast<UI16>( std::stoul( value, nullptr, 0 )) != 0 );
|
|
break;
|
|
case 50: // AMBIENTSOUNDS
|
|
WorldAmbientSounds( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 51: // AMBIENTFOOTSTEPS
|
|
AmbientFootsteps( static_cast<UI16>( std::stoul( value, nullptr, 0 )) != 0 );
|
|
break;
|
|
case 52: // INTERNALACCOUNTCREATION
|
|
InternalAccountStatus( static_cast<UI16>( std::stoul( value, nullptr, 0 ))!= 0 );
|
|
break;
|
|
case 53: // SHOWOFFLINEPCS
|
|
ShowOfflinePCs( static_cast<UI16>( std::stoul( value, nullptr, 0 )) != 0 );
|
|
break;
|
|
case 54: // ROGUESENABLED
|
|
RogueStatus( static_cast<UI16>( std::stoul( value, nullptr, 0 )) != 0 );
|
|
break;
|
|
case 55: // PLAYERPERSECUTION
|
|
PlayerPersecutionStatus( static_cast<UI16>( std::stoul( value, nullptr, 0 )) != 0 );
|
|
break;
|
|
case 56: // ACCOUNTFLUSH
|
|
AccountFlushTimer( std::stod( value ));
|
|
break;
|
|
case 57: // HTMLSTATUSENABLED
|
|
HtmlStatsStatus( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 58: // SELLBYNAME
|
|
SellByNameStatus( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 59: // SELLMAXITEMS
|
|
SellMaxItemsStatus( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 60: // TRADESYSTEM
|
|
TradeSystemStatus( static_cast<UI16>( std::stoul( value, nullptr, 0 )) != 0 );
|
|
break;
|
|
case 61: // RANKSYSTEM
|
|
RankSystemStatus( static_cast<UI16>( std::stoul( value, nullptr, 0 )) != 0 );
|
|
break;
|
|
case 62: // CUTSCROLLREQUIREMENTS
|
|
CutScrollRequirementStatus( static_cast<UI16>( std::stoul( value, nullptr, 0 )) != 0);
|
|
break;
|
|
case 63: // CHECKITEMS
|
|
CheckItemsSpeed( std::stod( value ));
|
|
break;
|
|
case 64: // CHECKBOATS
|
|
CheckBoatSpeed( std::stod( value ));
|
|
break;
|
|
case 65: // CHECKNPCAI
|
|
CheckNpcAISpeed( std::stod( value ));
|
|
break;
|
|
case 66: // CHECKSPAWNREGIONS
|
|
CheckSpawnRegionSpeed( std::stod( value ));
|
|
break;
|
|
case 67: // POSTINGLEVEL
|
|
MsgBoardPostingLevel( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 68: // REMOVALLEVEL
|
|
MsgBoardPostRemovalLevel( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 69: // ESCORTENABLED
|
|
EscortsEnabled( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 70: // ESCORTINITEXPIRE
|
|
SystemTimer( tSERVER_ESCORTWAIT, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 71: // ESCORTACTIVEEXPIRE
|
|
SystemTimer( tSERVER_ESCORTACTIVE, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 72: // MOON1
|
|
ServerMoon( 0, static_cast<SI16>( std::stoi( value, nullptr, 0 )));
|
|
break;
|
|
case 73: // MOON2
|
|
ServerMoon( 1, static_cast<SI16>( std::stoi( value, nullptr, 0 )));
|
|
break;
|
|
case 74: // DUNGEONLEVEL
|
|
DungeonLightLevel( static_cast<LIGHTLEVEL>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 75: // CURRENTLEVEL
|
|
WorldLightCurrentLevel( static_cast<LIGHTLEVEL>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 76: // BRIGHTLEVEL
|
|
WorldLightBrightLevel( static_cast<LIGHTLEVEL>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 77: // BASERANGE
|
|
TrackingBaseRange( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 78: // BASETIMER
|
|
TrackingBaseTimer( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 79: // MAXTARGETS
|
|
TrackingMaxTargets( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 80: // MSGREDISPLAYTIME
|
|
TrackingRedisplayTime( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 81: // MURDERDECAYTIMER
|
|
SystemTimer( tSERVER_MURDERDECAY, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 82: // MAXKILLS
|
|
RepMaxKills( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 83: // CRIMINALTIMER
|
|
SystemTimer( tSERVER_CRIMINAL, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 84: // MINECHECK
|
|
MineCheck( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 85: // OREPERAREA
|
|
ResOre( static_cast<SI16>( std::stoi( value, nullptr, 0 )));
|
|
break;
|
|
case 86: // ORERESPAWNTIMER
|
|
ResOreTime( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 87: // RESOURCEAREASIZE
|
|
ResourceAreaSize( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 88: // LOGSPERAREA
|
|
ResLogs( static_cast<SI16>( std::stoi( value, nullptr, 0 )));
|
|
break;
|
|
case 89: // LOGSRESPAWNTIMER
|
|
ResLogTime( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 90: // STATSAFFECTSKILLCHECKS
|
|
StatsAffectSkillChecks( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 91: // HUNGERRATE
|
|
SystemTimer( tSERVER_HUNGERRATE, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 92: // HUNGERDMGVAL
|
|
HungerDamage( static_cast<SI16>( std::stoi( value, nullptr, 0 )));
|
|
break;
|
|
case 93: // MAXRANGE
|
|
CombatMaxRange( static_cast<SI16>( std::stoi( value, nullptr, 0 )));
|
|
break;
|
|
case 94: // SPELLMAXRANGE
|
|
CombatMaxSpellRange( static_cast<SI16>( std::stoi( value, nullptr, 0 )));
|
|
break;
|
|
case 95: // DISPLAYHITMSG
|
|
CombatDisplayHitMessage( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 96: // MONSTERSVSANIMALS
|
|
CombatMonstersVsAnimals( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 97: // ANIMALATTACKCHANCE
|
|
CombatAnimalsAttackChance( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 98: // ANIMALSGUARDED
|
|
CombatAnimalsGuarded( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 99: // NPCDAMAGERATE
|
|
CombatNpcDamageRate( static_cast<SI16>( std::stoi( value, nullptr, 0 )));
|
|
break;
|
|
case 100: // NPCBASEFLEEAT
|
|
CombatNPCBaseFleeAt( static_cast<SI16>( std::stoi( value, nullptr, 0 )));
|
|
break;
|
|
case 101: // NPCBASEREATTACKAT
|
|
CombatNPCBaseReattackAt( static_cast<SI16>( std::stoi( value, nullptr, 0 )));
|
|
break;
|
|
case 102: // ATTACKSTAMINA
|
|
CombatAttackStamina( static_cast<SI16>( std::stoi( value, nullptr, 0 )));
|
|
break;
|
|
case 103: // LOCATION
|
|
ServerLocation( value );
|
|
break;
|
|
case 104: // STARTGOLD
|
|
ServerStartGold( static_cast<SI16>( std::stoi( value, nullptr, 0 )));
|
|
break;
|
|
case 105: // STARTPRIVS
|
|
ServerStartPrivs( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 106: // ESCORTDONEEXPIRE
|
|
SystemTimer( tSERVER_ESCORTDONE, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 107: // DARKLEVEL
|
|
WorldLightDarkLevel( static_cast<LIGHTLEVEL>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 108: // TITLECOLOUR
|
|
TitleColour( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 109: // LEFTTEXTCOLOUR
|
|
LeftTextColour( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 110: // RIGHTTEXTCOLOUR
|
|
RightTextColour( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 111: // BUTTONCANCEL
|
|
ButtonCancel( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 112: // BUTTONLEFT
|
|
ButtonLeft( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 113: // BUTTONRIGHT
|
|
ButtonRight( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 114: // BACKGROUNDPIC
|
|
BackgroundPic( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 115: // POLLTIME
|
|
TownNumSecsPollOpen( static_cast<UI32>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 116: // MAYORTIME
|
|
TownNumSecsAsMayor( static_cast<UI32>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 117: // TAXPERIOD
|
|
TownTaxPeriod( static_cast<UI32>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 118: // GUARDSPAID
|
|
TownGuardPayment( static_cast<UI32>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 119: // DAY
|
|
ServerTimeDay( static_cast<SI16>( std::stoi( value, nullptr, 0 )));
|
|
break;
|
|
case 120: // HOURS
|
|
ServerTimeHours( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 121: // MINUTES
|
|
ServerTimeMinutes( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 122: // SECONDS
|
|
ServerTimeSeconds( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 123: // AMPM
|
|
ServerTimeAMPM( static_cast<UI16>( std::stoul( value, nullptr, 0 )) != 0 );
|
|
break;
|
|
case 124: // SKILLLEVEL
|
|
SkillLevel( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 125: // SNOOPISCRIME
|
|
SnoopIsCrime( static_cast<UI16>( std::stoul( value, nullptr, 0 )) != 0 );
|
|
break;
|
|
case 126: // BOOKSDIRECTORY
|
|
Directory( CSDDP_BOOKS, value );
|
|
break;
|
|
case 127: // SKILLCAPSINGLE
|
|
ServerSkillCap( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 128: // PORT
|
|
ServerPort( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 129: // ACCESSDIRECTORY
|
|
Directory( CSDDP_ACCESS, value );
|
|
break;
|
|
case 130: // LOGSDIRECTORY
|
|
Directory( CSDDP_LOGS, value );
|
|
break;
|
|
case 131: // NOT USED
|
|
break;
|
|
case 132: // HTMLDIRECTORY
|
|
Directory( CSDDP_HTML, value );
|
|
break;
|
|
case 133: // SHOOTONANIMALBACK
|
|
ShootOnAnimalBack( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 134: // NPCTRAININGENABLED
|
|
NPCTrainingStatus( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 135: // DICTIONARYDIRECTORY
|
|
Directory( CSDDP_DICTIONARIES, value );
|
|
break;
|
|
case 136: // BACKUPSAVERATIO
|
|
BackupRatio( static_cast<SI16>( std::stoi( value, nullptr, 0 )));
|
|
break;
|
|
case 137: // HIDEWHILEMOUNTED
|
|
CharHideWhileMounted( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 138: // SECONDSPERUOMINUTE
|
|
ServerSecondsPerUOMinute( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 139: // WEIGHTPERSTR
|
|
//WeightPerStr( value.toUByte() );
|
|
WeightPerStr( std::stof( value ));
|
|
break;
|
|
case 140: // POLYDURATION
|
|
SystemTimer( tSERVER_POLYMORPH, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 141: // UOGENABLED
|
|
ServerUOGEnabled( static_cast<UI16>( std::stoul( value, nullptr, 0 ))==1 );
|
|
break;
|
|
case 142: // NETRCVTIMEOUT
|
|
ServerNetRcvTimeout( static_cast<UI32>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 143: // NETSNDTIMEOUT
|
|
ServerNetSndTimeout( static_cast<UI32>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 144: // NETRETRYCOUNT
|
|
ServerNetRetryCount( static_cast<UI32>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 145: // CLIENTFEATURES
|
|
SetClientFeatures( static_cast<UI32>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 146: // PACKETOVERLOADS
|
|
ServerOverloadPackets(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 147: // NPCMOVEMENTSPEED
|
|
NPCWalkingSpeed( std::stod( value ));
|
|
break;
|
|
case 148: // PETHUNGEROFFLINE
|
|
PetHungerOffline(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 149: // PETOFFLINETIMEOUT
|
|
PetOfflineTimeout( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 150: // PETOFFLINECHECKTIMER
|
|
SystemTimer( tSERVER_PETOFFLINECHECK, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 152: // ADVANCEDPATHFINDING
|
|
AdvancedPathfinding(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 153: // SERVERFEATURES
|
|
SetServerFeatures( static_cast<UI32>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 154: // LOOTINGISCRIME
|
|
LootingIsCrime(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 155: // NPCRUNNINGSPEED
|
|
NPCRunningSpeed( std::stod( value ));
|
|
break;
|
|
case 156: // NPCFLEEINGSPEED
|
|
NPCFleeingSpeed( std::stod( value ));
|
|
break;
|
|
case 157: // BASICTOOLTIPSONLY
|
|
BasicTooltipsOnly(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 158: // GLOBALITEMDECAY
|
|
GlobalItemDecay(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 159: // SCRIPTITEMSDECAYABLE
|
|
ScriptItemsDecayable(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 160: // BASEITEMSDECAYABLE
|
|
BaseItemsDecayable(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 161: // ITEMDECAYINHOUSES
|
|
ItemDecayInHouses(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 162: // SPAWNREGIONSFACETS
|
|
SetSpawnRegionsFacetStatus( static_cast<UI32>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 163: // PAPERDOLLGUILDBUTTON
|
|
PaperdollGuildButton( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 164: // ATTACKSPEEDFROMSTAMINA
|
|
CombatAttackSpeedFromStamina( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 169: // DISPLAYDAMAGENUMBERS
|
|
CombatDisplayDamageNumbers( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 170: // CLIENTSUPPORT4000
|
|
ClientSupport4000( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 171: // CLIENTSUPPORT5000
|
|
ClientSupport5000( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 172: // CLIENTSUPPORT6000
|
|
ClientSupport6000( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 173: // CLIENTSUPPORT6050
|
|
ClientSupport6050( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 174: // CLIENTSUPPORT7000
|
|
ClientSupport7000( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 175: // CLIENTSUPPORT7090
|
|
ClientSupport7090( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 176: // CLIENTSUPPORT70160
|
|
ClientSupport70160( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 177: // CLIENTSUPPORT70240
|
|
ClientSupport70240( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 178: // CLIENTSUPPORT70300
|
|
ClientSupport70300( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 179: // CLIENTSUPPORT70331
|
|
ClientSupport70331( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 180: // CLIENTSUPPORT704565
|
|
ClientSupport704565( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 181: // CLIENTSUPPORT70610
|
|
ClientSupport70610( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 182: // EXTENDEDSTARTINGSTATS
|
|
ExtendedStartingStats( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 183: // EXTENDEDSTARTINGSKILLS
|
|
ExtendedStartingSkills( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 184: // WEAPONDAMAGECHANCE
|
|
CombatWeaponDamageChance( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 185: // ARMORDAMAGECHANCE
|
|
CombatArmorDamageChance( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 186: // WEAPONDAMAGEMIN
|
|
CombatWeaponDamageMin( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 187: // WEAPONDAMAGEMAX
|
|
CombatWeaponDamageMax( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 188: // ARMORDAMAGEMIN
|
|
CombatArmorDamageMin( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 189: // ARMORDAMAGEMAX
|
|
CombatArmorDamageMax( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 190: // GLOBALATTACKSPEED
|
|
GlobalAttackSpeed( std::stod( value ));
|
|
break;
|
|
case 191: // NPCSPELLCASTSPEED
|
|
NPCSpellCastSpeed( std::stod( value ));
|
|
break;
|
|
case 192: // FISHINGSTAMINALOSS
|
|
FishingStaminaLoss( std::stof( value ));
|
|
break;
|
|
case 193: // RANDOMSTARTINGLOCATION
|
|
ServerRandomStartingLocation( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 194: // ASSISTANTNEGOTIATION
|
|
SetAssistantNegotiation(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 195: // KICKONASSISTANTSILENCE
|
|
KickOnAssistantSilence(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 196: // AF_FILTERWEATHER
|
|
SetDisabledAssistantFeature( AF_FILTERWEATHER, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 197: // AF_FILTERLIGHT
|
|
SetDisabledAssistantFeature( AF_FILTERLIGHT, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 198: // AF_SMARTTARGET
|
|
SetDisabledAssistantFeature( AF_SMARTTARGET, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 199: // AF_RANGEDTARGET
|
|
SetDisabledAssistantFeature( AF_RANGEDTARGET, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 200: // AF_AUTOOPENDOORS
|
|
SetDisabledAssistantFeature( AF_AUTOOPENDOORS, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 201: // AF_DEQUIPONCAST
|
|
SetDisabledAssistantFeature( AF_DEQUIPONCAST, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 202: // AF_AUTOPOTIONEQUIP
|
|
SetDisabledAssistantFeature( AF_AUTOPOTIONEQUIP, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 203: // AF_POISONEDCHECKS
|
|
SetDisabledAssistantFeature( AF_POISONEDCHECKS, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 204: // AF_LOOPEDMACROS
|
|
SetDisabledAssistantFeature( AF_LOOPEDMACROS, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 205: // AF_USEONCEAGENT
|
|
SetDisabledAssistantFeature( AF_USEONCEAGENT, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 206: // AF_RESTOCKAGENT
|
|
SetDisabledAssistantFeature( AF_RESTOCKAGENT, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 207: // AF_SELLAGENT
|
|
SetDisabledAssistantFeature( AF_SELLAGENT, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 208: // AF_BUYAGENT
|
|
SetDisabledAssistantFeature( AF_BUYAGENT, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 209: // AF_POTIONHOTKEYS
|
|
SetDisabledAssistantFeature( AF_POTIONHOTKEYS, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 210: // AF_RANDOMTARGETS
|
|
SetDisabledAssistantFeature( AF_RANDOMTARGETS, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 211: // AF_CLOSESTTARGETS
|
|
SetDisabledAssistantFeature( AF_CLOSESTTARGETS, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 212: // AF_OVERHEADHEALTH
|
|
SetDisabledAssistantFeature( AF_OVERHEADHEALTH, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 213: // AF_AUTOLOOTAGENT
|
|
SetDisabledAssistantFeature( AF_AUTOLOOTAGENT, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 214: // AF_BONECUTTERAGENT
|
|
SetDisabledAssistantFeature( AF_BONECUTTERAGENT, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 215: // AF_JSCRIPTMACROS
|
|
SetDisabledAssistantFeature( AF_JSCRIPTMACROS, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 216: // AF_AUTOREMOUNT
|
|
SetDisabledAssistantFeature( AF_AUTOREMOUNT, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 218: // CLASSICUOMAPTRACKER
|
|
SetClassicUOMapTracker(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 219: // DECAYTIMERINHOUSE
|
|
SystemTimer( tSERVER_DECAYINHOUSE, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 220: // PROTECTPRIVATEHOUSES
|
|
ProtectPrivateHouses( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 221: // TRACKHOUSESPERACCOUNT
|
|
TrackHousesPerAccount( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 222: // MAXHOUSESOWNABLE
|
|
MaxHousesOwnable( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 223: // MAXHOUSESCOOWNABLE
|
|
MaxHousesCoOwnable( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 224: // CANOWNANDCOOWNHOUSES
|
|
CanOwnAndCoOwnHouses( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 225: // COOWNHOUSESONSAMEACCOUNT
|
|
CoOwnHousesOnSameAccount( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 226: // ITEMSDETECTSPEECH
|
|
ItemsDetectSpeech( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 227: // MAXPLAYERPACKITEMS
|
|
MaxPlayerPackItems( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 228: // MAXPLAYERBANKITEMS
|
|
MaxPlayerBankItems( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 229: // FORCENEWANIMATIONPACKET
|
|
ForceNewAnimationPacket( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 230: // MAPDIFFSENABLED
|
|
MapDiffsEnabled( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 231: // CORESHARDERA
|
|
ExpansionCoreShardEra( EraStringToEnum( oldstrutil::trim( value )));
|
|
break;
|
|
case 232: // ARMORCALCULATION
|
|
ExpansionArmorCalculation( EraStringToEnum( oldstrutil::trim( value )));
|
|
break;
|
|
case 233: // STRENGTHDAMAGEBONUS
|
|
ExpansionStrengthDamageBonus( EraStringToEnum( oldstrutil::trim( value )));
|
|
break;
|
|
case 234: // TACTICSDAMAGEBONUS
|
|
ExpansionTacticsDamageBonus( EraStringToEnum( oldstrutil::trim( value )));
|
|
break;
|
|
case 235: // ANATOMYDAMAGEBONUS
|
|
ExpansionAnatomyDamageBonus( EraStringToEnum( oldstrutil::trim( value )));
|
|
break;
|
|
case 236: // LUMBERJACKDAMAGEBONUS
|
|
ExpansionLumberjackDamageBonus( EraStringToEnum( oldstrutil::trim( value )));
|
|
break;
|
|
case 237: // RACIALDAMAGEBONUS
|
|
ExpansionRacialDamageBonus( EraStringToEnum( oldstrutil::trim( value )));
|
|
break;
|
|
case 238: // DAMAGEBONUSCAP
|
|
ExpansionDamageBonusCap( EraStringToEnum( oldstrutil::trim( value )));
|
|
break;
|
|
case 239: // SHIELDPARRY
|
|
ExpansionShieldParry( EraStringToEnum( oldstrutil::trim( value )));
|
|
break;
|
|
case 240: // PARRYDAMAGECHANCE
|
|
CombatParryDamageChance( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 241: // PARRYDAMAGEMIN
|
|
CombatParryDamageMin( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 242: // PARRYDAMAGEMAX
|
|
CombatParryDamageMax( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 243: // ARMORCLASSDAMAGEBONUS
|
|
CombatArmorClassDamageBonus( static_cast<SI08>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 244: // FREESHARDSERVERPOLL
|
|
FreeshardServerPoll(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 245: // ALCHEMYBONUSENABLED
|
|
AlchemyDamageBonusEnabled( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 246: // ALCHEMYBONUSMODIFIER
|
|
AlchemyDamageBonusModifier( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 247: // NPCFLAGUPDATETIMER
|
|
SystemTimer( tSERVER_NPCFLAGUPDATETIMER, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 248: // JSENGINESIZE
|
|
SetJSEngineSize( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 249: // USEUNICODEMESSAGES
|
|
UseUnicodeMessages( static_cast<UI16>( std::stoul( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 250: // SCRIPTDATADIRECTORY
|
|
{
|
|
Directory( CSDDP_SCRIPTDATA, value );
|
|
break;
|
|
}
|
|
case 251: // THIRSTRATE
|
|
SystemTimer( tSERVER_THIRSTRATE, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 252: // THIRSTDRAINVAL
|
|
ThirstDrain( static_cast<SI16>( std::stoi( value, nullptr, 0 )));
|
|
break;
|
|
case 253: // PETTHIRSTOFFLINE
|
|
PetThirstOffline(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 254: // ExternalIP
|
|
ExternalIP( value );
|
|
break;
|
|
case 255: // BLOODDECAYTIMER
|
|
SystemTimer( tSERVER_BLOODDECAY, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 256: // BLOODDECAYCORPSETIMER
|
|
SystemTimer( tSERVER_BLOODDECAYCORPSE, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 257: // BLOODEFFECTCHANCE
|
|
CombatBloodEffectChance( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 258: // NPCCORPSEDECAYTIMER
|
|
SystemTimer( tSERVER_NPCCORPSEDECAY, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 259: // HUNGERENABLED
|
|
HungerSystemEnabled(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 260: // THIRSTENABLED
|
|
ThirstSystemEnabled(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 261: // TRAVELSPELLSFROMBOATKEYS
|
|
TravelSpellsFromBoatKeys(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 262: // TRAVELSPELLSWHILEOVERWEIGHT
|
|
TravelSpellsWhileOverweight(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 263: // MARKRUNESINMULTIS
|
|
MarkRunesInMultis(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 264: // TRAVELSPELLSBETWEENWORLD
|
|
TravelSpellsBetweenWorlds(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 265: // TRAVELSPELLSWHILEAGGRESSOR
|
|
TravelSpellsWhileAggressor(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 266: // BUYBANKTHRESHOLD
|
|
BuyThreshold( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 267: // NETWORKLOG
|
|
ServerNetworkLog(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 268: // SPEECHLOG
|
|
ServerSpeechLog(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 269: // NPCMOUNTEDWALKINGSPEED
|
|
NPCMountedWalkingSpeed( std::stod( value ));
|
|
break;
|
|
case 270: // NPCMOUNTEDRUNNINGSPEED
|
|
NPCMountedRunningSpeed( std::stod( value ));
|
|
break;
|
|
case 271: // NPCMOUNTEDFLEEINGSPEED
|
|
NPCMountedFleeingSpeed( std::stod( value ));
|
|
break;
|
|
case 272: // CONTEXTMENUS
|
|
ServerContextMenus(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 273: // SERVERLANGUAGE
|
|
ServerLanguage( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 274: // CHECKPETCONTROLDIFFICULTY
|
|
CheckPetControlDifficulty(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 275: // PETLOYALTYGAINONSUCCESS
|
|
SetPetLoyaltyGainOnSuccess( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 276: // PETLOYALTYLOSSONFAILURE
|
|
SetPetLoyaltyLossOnFailure( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 277: // LOYALTYRATE
|
|
SystemTimer( tSERVER_LOYALTYRATE, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 278: // SHOWNPCTITLESINTOOLTIPS
|
|
ShowNpcTitlesInTooltips(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 279: // FISHPERAREA
|
|
ResFish( static_cast<SI16>( std::stoi( value, nullptr, 0 )));
|
|
break;
|
|
case 280: // FISHRESPAWNTIMER
|
|
ResFishTime( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 281: // ARCHERYHITBONUS
|
|
CombatArcheryHitBonus( static_cast<SI16>( std::stoi( value, nullptr, 0 )));
|
|
break;
|
|
case 282: // ITEMSINTERRUPTCASTING
|
|
ItemsInterruptCasting(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 283: // SYSMESSAGECOLOUR
|
|
SysMsgColour( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 284: // AF_AUTOBANDAGE
|
|
SetDisabledAssistantFeature( AF_AUTOBANDAGE, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 285: // AF_ENEMYTARGETSHARE
|
|
SetDisabledAssistantFeature( AF_ENEMYTARGETSHARE, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 286: // AF_FILTERSEASON
|
|
SetDisabledAssistantFeature( AF_FILTERSEASON, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 287: // AF_SPELLTARGETSHARE
|
|
SetDisabledAssistantFeature( AF_SPELLTARGETSHARE, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 288: // AF_HUMANOIDHEALTHCHECKS
|
|
SetDisabledAssistantFeature( AF_HUMANOIDHEALTHCHECKS, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 289: // AF_SPEECHJOURNALCHECKS
|
|
SetDisabledAssistantFeature( AF_SPEECHJOURNALCHECKS, static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 );
|
|
break;
|
|
case 290: // ARCHERYSHOOTDELAY
|
|
CombatArcheryShootDelay( std::stod( value ));
|
|
break;
|
|
case 291: // MAXCLIENTBYTESIN
|
|
MaxClientBytesIn( static_cast<UI32>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 292: // MAXCLIENTBYTESOUT
|
|
MaxClientBytesOut( static_cast<UI32>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 293: // NETTRAFFICTIMEBAN
|
|
NetTrafficTimeban( static_cast<UI32>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 294: // TOOLUSELIMIT
|
|
ToolUseLimit(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 295: // TOOLUSEBREAK
|
|
ToolUseBreak(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 296: // ITEMREPAIRDURABILITYLOSS
|
|
ItemRepairDurabilityLoss(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 297: // HIDESTATSFORUNKNOWNMAGICITEMS
|
|
HideStatsForUnknownMagicItems(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 298: // CRAFTCOLOUREDWEAPONS
|
|
CraftColouredWeapons(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 299: // MAXSAFETELEPORTSPERDAY
|
|
MaxSafeTeleportsPerDay( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 300: // TELEPORTONEARESTSAFELOCATION
|
|
TeleportToNearestSafeLocation(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 301: // ALLOWAWAKENPCS
|
|
AllowAwakeNPCs(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 302: // DISPLAYMAKERSMARK
|
|
DisplayMakersMark( static_cast<UI16>( std::stoul( value, nullptr, 0 )) != 0 );
|
|
break;
|
|
case 303: // SHOWNPCTITLESOVERHEAD
|
|
ShowNpcTitlesOverhead(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 304: // SHOWINVULNERABLETAGOVERHEAD
|
|
ShowInvulnerableTagOverhead(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 305: // PETCOMBATTRAINING
|
|
PetCombatTraining(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 306: // HIRELINGCOMBATTRAINING
|
|
HirelingCombatTraining(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 307: // NPCCOMBATTRAINING
|
|
NpcCombatTraining(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 308: // GLOBALRESTOCKMULTIPLIER
|
|
GlobalRestockMultiplier( std::stof( value ));
|
|
break;
|
|
case 309: // SHOWITEMRESISTSTATS
|
|
ShowItemResistStats(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 310: // SHOWWEAPONDAMAGETYPES
|
|
ShowWeaponDamageTypes(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 311: // SHOWRACEWITHNAME
|
|
ShowRaceWithName(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 312: // SHOWRACEINPAPERDOLL
|
|
ShowRaceInPaperdoll(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 313: // WEAPONPARRY
|
|
ExpansionWeaponParry( EraStringToEnum( oldstrutil::trim( value )));
|
|
break;
|
|
case 314: // WRESTLINGPARRY
|
|
ExpansionWrestlingParry( EraStringToEnum( oldstrutil::trim( value )));
|
|
break;
|
|
case 315: // COMBATHITCHANCE
|
|
ExpansionCombatHitChance( EraStringToEnum( oldstrutil::trim( value )));
|
|
break;
|
|
case 316: // CASTSPELLSWHILEMOVING
|
|
CastSpellsWhileMoving(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 317: // SHOWREPUTATIONTITLEINTOOLTIP
|
|
ShowReputationTitleInTooltip(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 318: // SHOWGUILDINFOINTOOLTIP
|
|
ShowGuildInfoInTooltip(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 319: // MAXPLAYERPACKWEIGHT
|
|
MaxPlayerPackWeight( static_cast<SI32>( std::stoi( value, nullptr, 0 )));
|
|
break;
|
|
case 320: // MAXPLAYERBANKWEIGHT
|
|
MaxPlayerBankWeight( static_cast<SI32>( std::stoi( value, nullptr, 0 )));
|
|
break;
|
|
case 321: // SAFECOOWNERLOGOUT
|
|
SafeCoOwnerLogout(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 322: // SAFEFRIENDLOGOUT
|
|
SafeFriendLogout(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 323: // SAFEGUESTLOGOUT
|
|
SafeGuestLogout(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 324: // KEYLESSOWNERACCESS
|
|
KeylessOwnerAccess(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 325: // KEYLESSCOOWNERACCESS
|
|
KeylessCoOwnerAccess(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 326: // KEYLESSFRIENDACCESS
|
|
KeylessFriendAccess(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 327: // KEYLESSGUESTACCESS
|
|
KeylessGuestAccess( ( static_cast<UI16>( std::stoul( value, nullptr, 0 ) ) >= 1 ? true : false ) );
|
|
break;
|
|
case 328: // WEAPONDAMAGEBONUSTYPE
|
|
WeaponDamageBonusType( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 329: // OFFERBODSFROMITEMSALES
|
|
OfferBODsFromItemSales(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 330: // OFFERBODSFROMCONTEXTMENU
|
|
OfferBODsFromContextMenu(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 331: // BODSFROMCRAFTEDITEMSONLY
|
|
BODsFromCraftedItemsOnly(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 332: // BODGOLDREWARDMULTIPLIER
|
|
BODGoldRewardMultiplier( std::stof( value ));
|
|
break;
|
|
case 333: // BODFAMEREWARDMULTIPLIER
|
|
BODFameRewardMultiplier( std::stof( value ));
|
|
break;
|
|
case 334: // ENABLENPCGUILDDISCOUNTS
|
|
EnableNPCGuildDiscounts(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 335: // ENABLENPCGUILDPREMIUMS
|
|
EnableNPCGuildPremiums(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 336: // AGGRESSORFLAGTIMER
|
|
SystemTimer( tSERVER_AGGRESSORFLAG, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 337: // PERMAGREYFLAGTIMER
|
|
SystemTimer( tSERVER_PERMAGREYFLAG, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 338: // STEALINGFLAGTIMER
|
|
SystemTimer( tSERVER_STEALINGFLAG, static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 339: // SNOOPAWARENESS
|
|
SnoopAwareness( static_cast<UI16>( std::stoul( value, nullptr, 0 )) != 0 );
|
|
break;
|
|
case 340: // APSPERFTHRESHOLD
|
|
APSPerfThreshold( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 341: // APSINTERVAL
|
|
APSInterval( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 342: // APSDELAYSTEP
|
|
APSDelayStep( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 343: // APSDELAYMAXCAP
|
|
APSDelayMaxCap( static_cast<UI16>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 344: // YOUNGPLAYERSYSTEM
|
|
YoungPlayerSystem( static_cast<UI16>( std::stoul( value, nullptr, 0 )) != 0 );
|
|
break;
|
|
case 345: // YOUNGLOCATION
|
|
YoungServerLocation( value );
|
|
break;
|
|
case 346: // SECRETSHARDKEY
|
|
SecretShardKey( value );
|
|
break;
|
|
case 347: // MOONGATEFACETS
|
|
SetMoongateFacetStatus( static_cast<UI32>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 348: // AUTOUNEQUIPPEDCASTING
|
|
AutoUnequippedCasting(( static_cast<UI16>( std::stoul( value, nullptr, 0 )) >= 1 ? true : false ));
|
|
break;
|
|
case 349: // LOOTDECAYSWITHNPCCORPSE
|
|
NpcCorpseLootDecay( static_cast<UI16>( std::stoul( value, nullptr, 0 )) != 0 );
|
|
break;
|
|
case 350: // HEALTHREGENCAP
|
|
HealthRegenCap( std::stoi( value, nullptr, 0 ));
|
|
break;
|
|
case 351: // STAMINAREGENCAP
|
|
StaminaRegenCap( std::stoi( value, nullptr, 0 ));
|
|
break;
|
|
case 352: // MANAREGENCAP
|
|
ManaRegenCap( std::stoi( value, nullptr, 0 ));
|
|
break;
|
|
case 353: // SWINGSPEEDINCREASE
|
|
SwingSpeedIncreaseCap( std::stoi( value, nullptr, 0 ));
|
|
break;
|
|
case 354: // KARMALOCKING
|
|
KarmaLocking( static_cast<UI16>( std::stoul( value, nullptr, 0 )) != 0 );
|
|
break;
|
|
case 362: // HEALINGAFFECTHEALTHREGEN
|
|
HealingAffectHealthRegen(( static_cast<UI08>( std::stoul( value, nullptr, 0 )) > 0 ? true : false ));
|
|
break;
|
|
case 363: // HEALTHREGENMODE
|
|
HealthRegenMode( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 364: // STAMINAREGENMODE
|
|
StaminaRegenMode( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 365: // MANAREGENMODE
|
|
ManaRegenMode( static_cast<UI08>( std::stoul( value, nullptr, 0 )));
|
|
break;
|
|
case 366: // HUNGERAFFECTHEALTHREGEN
|
|
HungerAffectHealthRegen(( static_cast<UI08>( std::stoul( value, nullptr, 0 )) > 0 ? true : false ));
|
|
break;
|
|
case 367: // THIRSTAFFECTSTAMINAREGEN
|
|
ThirstAffectStaminaRegen(( static_cast<UI08>( std::stoul( value, nullptr, 0 )) > 0 ? true : false ));
|
|
break;
|
|
case 368: // HUMANHEALTHREGENBONUS
|
|
HumanHealthRegenBonus( std::stoi( value, nullptr, 0 ));
|
|
break;
|
|
case 369: // HUMANSTAMINAREGENBONUS
|
|
HumanStaminaRegenBonus( std::stoi( value, nullptr, 0 ));
|
|
break;
|
|
case 370: // HUMANMANAREGENBONUS
|
|
HumanManaRegenBonus( std::stoi( value, nullptr, 0 ));
|
|
break;
|
|
case 371: // ELFHEALTHREGENBONUS
|
|
ElfHealthRegenBonus( std::stoi( value, nullptr, 0 ));
|
|
break;
|
|
case 372: // ELFSTAMINAREGENBONUS
|
|
ElfStaminaRegenBonus( std::stoi( value, nullptr, 0 ));
|
|
break;
|
|
case 373: // ELFMANAREGENBONUS
|
|
ElfManaRegenBonus( std::stoi( value, nullptr, 0 ));
|
|
break;
|
|
case 374: // GARGOYLEHEALTHREGENBONUS
|
|
GargoyleHealthRegenBonus( std::stoi( value, nullptr, 0 ));
|
|
break;
|
|
case 375: // GARGOYLESTAMINAREGENBONUS
|
|
GargoyleStaminaRegenBonus( std::stoi( value, nullptr, 0 ));
|
|
break;
|
|
case 376: // GARGOYLEMANAREGENBONUS
|
|
GargoyleManaRegenBonus( std::stoi( value, nullptr, 0 ));
|
|
break;
|
|
case 377: // HUMANMAXWEIGHTBONUS
|
|
HumanMaxWeightBonus( std::stoi( value, nullptr, 0 ));
|
|
break;
|
|
case 378: // ELFMAXWEIGHTBONUS
|
|
ElfMaxWeightBonus( std::stoi( value, nullptr, 0 ));
|
|
break;
|
|
case 379: // GARGOYLEMAXWEIGHTBONUS
|
|
GargoyleMaxWeightBonus( std::stoi( value, nullptr, 0 ));
|
|
break;
|
|
case 380: // MAXNPCAGGRORANGE
|
|
CombatMaxNpcAggroRange( static_cast<SI16>( std::stoi( value, nullptr, 0 )));
|
|
break;
|
|
case 381: // POISONCORROSIONSYSTEM
|
|
PoisonCorrosionSystem(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
case 382: // PETBONDINGENABLED
|
|
PetBondingEnabled(( static_cast<SI16>( std::stoi( value, nullptr, 0 )) == 1 ));
|
|
break;
|
|
default:
|
|
rValue = false;
|
|
break;
|
|
}
|
|
return rValue;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerStartGold()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default amount of starting gold for new characters
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerStartGold() const -> SI16
|
|
{
|
|
return startGold;
|
|
}
|
|
auto CServerData::ServerStartGold( SI16 value ) -> void
|
|
{
|
|
if( value >= 0 )
|
|
{
|
|
startGold = value;
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerStartPrivs()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default starting privs for new characters
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerStartPrivs() const -> UI16
|
|
{
|
|
return startPrivs;
|
|
}
|
|
auto CServerData::ServerStartPrivs( UI16 value ) -> void
|
|
{
|
|
startPrivs = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerMoon()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the phase of one of the game's two moons
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerMoon( SI16 slot ) const -> SI16
|
|
{
|
|
SI16 rValue = -1;
|
|
if( slot >= 0 && slot <= 1 )
|
|
{
|
|
rValue = moon[slot];
|
|
}
|
|
return rValue;
|
|
}
|
|
auto CServerData::ServerMoon( SI16 slot, SI16 value ) -> void
|
|
{
|
|
if( slot >= 0 && slot <= 1 && value >= 0 )
|
|
{
|
|
moon[slot] = value;
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::DungeonLightLevel()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default, global light level for dungeons
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::DungeonLightLevel() const -> LIGHTLEVEL
|
|
{
|
|
return dungeonLightLevel;
|
|
}
|
|
auto CServerData::DungeonLightLevel( LIGHTLEVEL value ) -> void
|
|
{
|
|
dungeonLightLevel = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::WorldLightCurrentLevel()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default, global current light level outside of dungeons
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::WorldLightCurrentLevel() const -> LIGHTLEVEL
|
|
{
|
|
return currentLightLevel;
|
|
}
|
|
auto CServerData::WorldLightCurrentLevel( LIGHTLEVEL value ) -> void
|
|
{
|
|
currentLightLevel = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::WorldLightBrightLevel()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default, global light level for the brightest time of day
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::WorldLightBrightLevel() const -> LIGHTLEVEL
|
|
{
|
|
return brightnessLightLevel;
|
|
}
|
|
auto CServerData::WorldLightBrightLevel( LIGHTLEVEL value ) -> void
|
|
{
|
|
brightnessLightLevel = value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::WorldLightDarkLevel()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default, global light level for the darkest time of day
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::WorldLightDarkLevel() const -> LIGHTLEVEL
|
|
{
|
|
return darknessLightLevel;
|
|
}
|
|
auto CServerData::WorldLightDarkLevel( LIGHTLEVEL value ) -> void
|
|
{
|
|
darknessLightLevel=value;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::PostLoadDefaults()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - If no start locations have been provided in ini, use hardcoded defaults
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::PostLoadDefaults() -> void
|
|
{
|
|
if( startlocations.empty() )
|
|
{
|
|
ServerLocation( "Yew,Center,545,982,0,0,0,1075072" );
|
|
ServerLocation( "Minoc,Tavern,2477,411,15,0,0,1075073" );
|
|
ServerLocation( "Britain,Sweet Dreams Inn,1495,1629,10,0,0,1075074" );
|
|
ServerLocation( "Moonglow,Docks,4406,1045,0,0,0,1075075" );
|
|
ServerLocation( "Trinsic,West Gate,1832,2779,0,0,0,1075076" );
|
|
ServerLocation( "Magincia,Docks,3675,2259,26,0,0,1075077" );
|
|
ServerLocation( "Jhelom,Docks,1492,3696,0,0,0,1075078" );
|
|
ServerLocation( "Skara Brae,Docks,639,2236,0,0,0,1075079" );
|
|
ServerLocation( "Vesper,Ironwood Inn,2771,977,0,0,0,1075080" );
|
|
}
|
|
|
|
// Also load young player start locations, which default to same as normal players
|
|
if( YoungPlayerSystem() && youngStartlocations.empty() )
|
|
{
|
|
YoungServerLocation( "Yew,Center,545,982,0,0,0,1075072" );
|
|
YoungServerLocation( "Minoc,Tavern,2477,411,15,0,0,1075073" );
|
|
YoungServerLocation( "Britain,Sweet Dreams Inn,1495,1629,10,0,0,1075074" );
|
|
YoungServerLocation( "Moonglow,Docks,4406,1045,0,0,0,1075075" );
|
|
YoungServerLocation( "Trinsic,West Gate,1832,2779,0,0,0,1075076" );
|
|
YoungServerLocation( "Magincia,Docks,3675,2259,26,0,0,1075077" );
|
|
YoungServerLocation( "Jhelom,Docks,1492,3696,0,0,0,1075078" );
|
|
YoungServerLocation( "Skara Brae,Docks,639,2236,0,0,0,1075079" );
|
|
YoungServerLocation( "Vesper,Ironwood Inn,2771,977,0,0,0,1075080" );
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerLocation()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets server start locations
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerLocation( size_t locNum ) -> __STARTLOCATIONDATA__*
|
|
{
|
|
__STARTLOCATIONDATA__ *rValue = nullptr;
|
|
if( locNum < startlocations.size() )
|
|
{
|
|
rValue = &startlocations[locNum];
|
|
}
|
|
return rValue;
|
|
}
|
|
|
|
auto CServerData::ServerLocation( std::string toSet ) -> void
|
|
{
|
|
auto temp = toSet;
|
|
temp = oldstrutil::trim( oldstrutil::removeTrailing( temp, "//" ));
|
|
auto csecs = oldstrutil::sections( temp, "," );
|
|
|
|
__STARTLOCATIONDATA__ toAdd;
|
|
if( csecs.size() >= 7 )
|
|
{
|
|
toAdd.oldTown = oldstrutil::trim( oldstrutil::removeTrailing( csecs[0], "//" ));
|
|
toAdd.oldDescription = oldstrutil::trim( oldstrutil::removeTrailing( csecs[1], "//" ));
|
|
toAdd.newTown = toAdd.oldTown;
|
|
toAdd.newDescription = toAdd.oldDescription;
|
|
|
|
toAdd.x = static_cast<SI16>( std::stoi( oldstrutil::trim( oldstrutil::removeTrailing( csecs[2], "//" )), nullptr, 0 ));
|
|
toAdd.y = static_cast<SI16>( std::stoi( oldstrutil::trim( oldstrutil::removeTrailing( csecs[3], "//" )), nullptr, 0 ));
|
|
toAdd.z = static_cast<SI16>( std::stoi( oldstrutil::trim( oldstrutil::removeTrailing( csecs[4], "//" )), nullptr, 0 ));
|
|
toAdd.worldNum = static_cast<SI16>( std::stoi( oldstrutil::trim( oldstrutil::removeTrailing( csecs[5], "//" )), nullptr, 0 ));
|
|
if( csecs.size() == 7 )
|
|
{
|
|
toAdd.clilocDesc = static_cast<UI32>( std::stoul( oldstrutil::trim( oldstrutil::removeTrailing( csecs[6], "//" )), nullptr, 0 ));
|
|
}
|
|
else
|
|
{
|
|
toAdd.instanceId = static_cast<SI16>( std::stoi( oldstrutil::trim( oldstrutil::removeTrailing( csecs[6], "//" )), nullptr, 0 ));
|
|
toAdd.clilocDesc = static_cast<UI32>( std::stoul( oldstrutil::trim( oldstrutil::removeTrailing( csecs[7], "//" )), nullptr, 0 ));
|
|
}
|
|
startlocations.push_back( toAdd );
|
|
}
|
|
else
|
|
{
|
|
Console.Error( "Malformed location entry in ini file" );
|
|
}
|
|
}
|
|
|
|
auto CServerData::NumServerLocations() const -> size_t
|
|
{
|
|
return startlocations.size();
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::YoungServerLocation()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets server start location(s) for Young players
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::YoungServerLocation( size_t locNum ) -> __STARTLOCATIONDATA__*
|
|
{
|
|
__STARTLOCATIONDATA__ *rValue = nullptr;
|
|
if( locNum < youngStartlocations.size() )
|
|
{
|
|
rValue = &youngStartlocations[locNum];
|
|
}
|
|
return rValue;
|
|
}
|
|
|
|
auto CServerData::YoungServerLocation( std::string toSet ) -> void
|
|
{
|
|
auto temp = toSet;
|
|
temp = oldstrutil::trim( oldstrutil::removeTrailing( temp, "//" ));
|
|
auto csecs = oldstrutil::sections( temp, "," );
|
|
|
|
__STARTLOCATIONDATA__ toAdd;
|
|
if( csecs.size() >= 7 )
|
|
{
|
|
toAdd.oldTown = oldstrutil::trim( oldstrutil::removeTrailing( csecs[0], "//" ));
|
|
toAdd.oldDescription = oldstrutil::trim( oldstrutil::removeTrailing( csecs[1], "//" ));
|
|
toAdd.newTown = toAdd.oldTown;
|
|
toAdd.newDescription = toAdd.oldDescription;
|
|
|
|
toAdd.x = static_cast<SI16>( std::stoi( oldstrutil::trim( oldstrutil::removeTrailing( csecs[2], "//" )), nullptr, 0 ));
|
|
toAdd.y = static_cast<SI16>( std::stoi( oldstrutil::trim( oldstrutil::removeTrailing( csecs[3], "//" )), nullptr, 0 ));
|
|
toAdd.z = static_cast<SI16>( std::stoi( oldstrutil::trim( oldstrutil::removeTrailing( csecs[4], "//" )), nullptr, 0 ));
|
|
toAdd.worldNum = static_cast<SI16>( std::stoi( oldstrutil::trim( oldstrutil::removeTrailing( csecs[5], "//" )), nullptr, 0 ));
|
|
if( csecs.size() == 7 )
|
|
{
|
|
toAdd.clilocDesc = static_cast<UI32>( std::stoul( oldstrutil::trim( oldstrutil::removeTrailing( csecs[6], "//" )), nullptr, 0 ));
|
|
}
|
|
else
|
|
{
|
|
toAdd.instanceId = static_cast<SI16>( std::stoi( oldstrutil::trim( oldstrutil::removeTrailing( csecs[6], "//" )), nullptr, 0 ));
|
|
toAdd.clilocDesc = static_cast<UI32>( std::stoul( oldstrutil::trim( oldstrutil::removeTrailing( csecs[7], "//" )), nullptr, 0 ));
|
|
}
|
|
youngStartlocations.push_back( toAdd );
|
|
}
|
|
else
|
|
{
|
|
Console.Error( "Malformed young start location entry in ini file" );
|
|
}
|
|
}
|
|
|
|
auto CServerData::NumYoungServerLocations() const -> size_t
|
|
{
|
|
return youngStartlocations.size();
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerSecondsPerUOMinute()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the number of real life seconds per UO minute
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerSecondsPerUOMinute() const -> UI16
|
|
{
|
|
return secondsPerUoMinute;
|
|
}
|
|
auto CServerData::ServerSecondsPerUOMinute( UI16 newVal ) -> void
|
|
{
|
|
secondsPerUoMinute = newVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::ServerLanguage()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the default (if any) language used for the server
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::ServerLanguage() const -> UI16
|
|
{
|
|
return serverLanguage;
|
|
}
|
|
auto CServerData::ServerLanguage( UI16 newVal ) -> void
|
|
{
|
|
if( newVal < DL_COUNT )
|
|
{
|
|
serverLanguage = newVal;
|
|
}
|
|
else
|
|
{
|
|
serverLanguage = DL_DEFAULT;
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::MaxClientBytesIn()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets max incoming bytes received from a socket in each 10 second period
|
|
//| If amount exceeds this cap, client might receive a warning/get kicked
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::MaxClientBytesIn() const -> UI32
|
|
{
|
|
return maxBytesIn;
|
|
}
|
|
auto CServerData::MaxClientBytesIn( UI32 newVal ) -> void
|
|
{
|
|
maxBytesIn = newVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::MaxClientBytesOut()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets max outgoing bytes sent to a socket in each 10 second period
|
|
//| If amount exceeds this cap, client might receive a warning/get kicked
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::MaxClientBytesOut() const -> UI32
|
|
{
|
|
return maxBytesOut;
|
|
}
|
|
auto CServerData::MaxClientBytesOut( UI32 newVal ) -> void
|
|
{
|
|
maxBytesOut = newVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::NetTrafficTimeban()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets max amount of time a player will be temporarily banned for if they
|
|
//| exceed their alotted network traffic budget
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::NetTrafficTimeban() const -> UI32
|
|
{
|
|
return trafficTimeban;
|
|
}
|
|
auto CServerData::NetTrafficTimeban( UI32 newVal ) -> void
|
|
{
|
|
trafficTimeban = newVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::GetJSEngineSize()
|
|
//| CServerData::SetJSEngineSize()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets jsEngineSize (in MB), used to define max bytes per JSRuntime
|
|
//| before a last ditch GC effort is made
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::GetJSEngineSize() const -> UI16
|
|
{
|
|
return jsEngineSize;
|
|
}
|
|
auto CServerData::SetJSEngineSize( UI16 newVal ) -> void
|
|
{
|
|
jsEngineSize = newVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::APSPerfThreshold()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the performance threshold (simulation cycles) below which the
|
|
//| APS - Adaptive Performance System - kicks in. A value of 0 disables the system
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::APSPerfThreshold() const -> UI16
|
|
{
|
|
return apsPerfThreshold;
|
|
}
|
|
auto CServerData::APSPerfThreshold( UI16 newVal ) -> void
|
|
{
|
|
apsPerfThreshold = newVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::APSInterval()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the interval at which APS will check shard performance and make
|
|
//| adjustments if necessary
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::APSInterval() const -> UI16
|
|
{
|
|
return apsInterval;
|
|
}
|
|
auto CServerData::APSInterval( UI16 newVal ) -> void
|
|
{
|
|
apsInterval = newVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::APSDelayStep()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the step value - in milliseconds - that is used by APS to
|
|
//| gradually increase/decrease the delay effect for checking NPC AI/movement stuff
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::APSDelayStep() const -> UI16
|
|
{
|
|
return apsDelayStep;
|
|
}
|
|
auto CServerData::APSDelayStep( UI16 newVal ) -> void
|
|
{
|
|
apsDelayStep = newVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::APSDelayMaxCap()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets/Sets the max cap - in milliseconds - for how much NPC AI/movement stuff can
|
|
//| be delayed by APS in an effort to restore shard performance to above threshold levels
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::APSDelayMaxCap() const -> UI16
|
|
{
|
|
return apsDelayMaxCap;
|
|
}
|
|
auto CServerData::APSDelayMaxCap( UI16 newVal ) -> void
|
|
{
|
|
apsDelayMaxCap = newVal;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::SaveTime()
|
|
//| Date - January 28th, 2007
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Outputs server time information to time.wsc in the /shared/ directory
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::SaveTime() -> void
|
|
{
|
|
std::string timeFile = cwmWorldState->ServerData()->Directory( CSDDP_SHARED ) + "time.wsc";
|
|
std::ofstream timeDestination( timeFile.c_str() );
|
|
if( !timeDestination )
|
|
{
|
|
Console.Error( oldstrutil::format( "Failed to open %s for writing", timeFile.c_str() ));
|
|
return;
|
|
}
|
|
|
|
timeDestination << "[TIME]" << '\n' << "{" << '\n';
|
|
timeDestination << "CURRENTLIGHT=" << static_cast<UI16>( WorldLightCurrentLevel() ) << '\n';
|
|
timeDestination << "DAY=" << ServerTimeDay() << '\n';
|
|
timeDestination << "HOUR=" << static_cast<UI16>( ServerTimeHours() ) << '\n';
|
|
timeDestination << "MINUTE=" << static_cast<UI16>( ServerTimeMinutes() ) << '\n';
|
|
timeDestination << "AMPM=" << ( ServerTimeAMPM() ? 1 : 0 ) << '\n';
|
|
timeDestination << "MOON=" << ServerMoon( 0 ) << "," << ServerMoon( 1 ) << '\n';
|
|
timeDestination << "}" << '\n' << '\n';
|
|
|
|
timeDestination.close();
|
|
}
|
|
|
|
auto ReadWorldTagData( std::istream &inStream, std::string &tag, std::string &data ) -> void;
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CServerData::LoadTime()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Loads server time information from time.wsc in the /shared/ directory
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CServerData::LoadTime() -> void
|
|
{
|
|
std::ifstream input;
|
|
std::string filename = cwmWorldState->ServerData()->Directory( CSDDP_SHARED ) + "time.wsc";
|
|
|
|
input.open( filename.c_str(), std::ios_base::in );
|
|
input.seekg( 0, std::ios::beg );
|
|
|
|
|
|
if( input.is_open() )
|
|
{
|
|
char line[1024];
|
|
while( !input.eof() && !input.fail() )
|
|
{
|
|
input.getline( line, 1023 );
|
|
line[input.gcount()] = 0;
|
|
std::string sLine( line );
|
|
sLine = oldstrutil::trim( oldstrutil::removeTrailing( sLine, "//" ));
|
|
if( !sLine.empty() )
|
|
{
|
|
if( oldstrutil::upper( sLine ) == "[TIME]" )
|
|
{
|
|
LoadTimeTags( input );
|
|
}
|
|
}
|
|
}
|
|
input.close();
|
|
}
|
|
}
|
|
|
|
//==============================================================================================
|
|
auto CServerData::LoadTimeTags( std::istream &input ) -> void
|
|
{
|
|
std::string UTag, tag, data;
|
|
while( tag != "o---o" )
|
|
{
|
|
ReadWorldTagData( input, tag, data );
|
|
if( tag != "o---o" )
|
|
{
|
|
UTag = oldstrutil::upper( tag );
|
|
|
|
if( UTag == "AMPM" )
|
|
{
|
|
ServerTimeAMPM(( std::stoi( data, nullptr, 0 ) == 1 ));
|
|
}
|
|
else if( UTag == "CURRENTLIGHT" )
|
|
{
|
|
WorldLightCurrentLevel( static_cast<UI16>( std::stoul( data, nullptr, 0 )));
|
|
}
|
|
else if( UTag == "DAY" )
|
|
{
|
|
ServerTimeDay( static_cast<SI16>( std::stoi( data, nullptr, 0 )));
|
|
}
|
|
else if( UTag == "HOUR" )
|
|
{
|
|
ServerTimeHours( static_cast<UI16>( std::stoul( data, nullptr, 0 )));
|
|
}
|
|
else if( UTag == "MINUTE" )
|
|
{
|
|
ServerTimeMinutes( static_cast<UI16>( std::stoul( data, nullptr, 0 )));
|
|
}
|
|
else if( UTag == "MOON" )
|
|
{
|
|
auto csecs = oldstrutil::sections( data, "," );
|
|
if( csecs.size() > 1 )
|
|
{
|
|
ServerMoon( 0, static_cast<SI16>( std::stoi( oldstrutil::trim( oldstrutil::removeTrailing( csecs[0], "//" )), nullptr, 0 )));
|
|
ServerMoon( 1, static_cast<SI16>( std::stoi( oldstrutil::trim( oldstrutil::removeTrailing( csecs[1], "//" )), nullptr, 0 )));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
tag = "";
|
|
}
|
|
|
|
//==============================================================================================
|
|
auto CServerData::ServerTimeDay() const -> SI16
|
|
{
|
|
return days;
|
|
}
|
|
//==============================================================================================
|
|
auto CServerData::ServerTimeDay( SI16 nValue ) -> void
|
|
{
|
|
days = nValue;
|
|
}
|
|
//==============================================================================================
|
|
auto CServerData::ServerTimeHours() const -> UI08
|
|
{
|
|
return hours;
|
|
}
|
|
//==============================================================================================
|
|
auto CServerData::ServerTimeHours( UI08 nValue ) -> void
|
|
{
|
|
hours = nValue;
|
|
}
|
|
//==============================================================================================
|
|
auto CServerData::ServerTimeMinutes() const -> UI08
|
|
{
|
|
return minutes;
|
|
}
|
|
|
|
//==============================================================================================
|
|
auto CServerData::ServerTimeMinutes( UI08 nValue ) -> void
|
|
{
|
|
minutes = nValue;
|
|
}
|
|
//==============================================================================================
|
|
auto CServerData::ServerTimeSeconds() const -> UI08
|
|
{
|
|
return seconds;
|
|
}
|
|
//==============================================================================================
|
|
auto CServerData::ServerTimeSeconds( UI08 nValue) -> void
|
|
{
|
|
seconds = nValue;
|
|
}
|
|
//==============================================================================================
|
|
auto CServerData::ServerTimeAMPM() const -> bool
|
|
{
|
|
return ampm;
|
|
}
|
|
//==============================================================================================
|
|
auto CServerData::ServerTimeAMPM( bool nValue ) -> void
|
|
{
|
|
ampm = nValue;
|
|
}
|
|
|
|
//==============================================================================================
|
|
auto CServerData::IncSecond() -> bool
|
|
{
|
|
bool rValue = false;
|
|
++seconds;
|
|
if( seconds == 60 )
|
|
{
|
|
seconds = 0;
|
|
rValue = IncMinute();
|
|
}
|
|
return rValue;
|
|
}
|
|
|
|
//==============================================================================================
|
|
auto CServerData::IncMoon( SI32 mNumber ) -> void
|
|
{
|
|
moon[mNumber] = static_cast<SI16>(( moon[mNumber] + 1 ) % 8 );
|
|
}
|
|
|
|
//==============================================================================================
|
|
auto CServerData::IncMinute() -> bool
|
|
{
|
|
bool rValue = false;
|
|
++minutes;
|
|
if( minutes%8 == 0 )
|
|
{
|
|
IncMoon( 0 );
|
|
}
|
|
if( minutes%3 == 0 )
|
|
{
|
|
IncMoon( 1 );
|
|
}
|
|
|
|
if( minutes == 60 )
|
|
{
|
|
minutes = 0;
|
|
rValue = IncHour();
|
|
}
|
|
return rValue;
|
|
}
|
|
|
|
//==============================================================================================
|
|
auto CServerData::IncHour() -> bool
|
|
{
|
|
++hours;
|
|
bool retVal = false;
|
|
if( hours == 12 )
|
|
{
|
|
if( ampm )
|
|
{
|
|
retVal = IncDay();
|
|
}
|
|
hours = 0;
|
|
ampm = !ampm;
|
|
}
|
|
return retVal;
|
|
}
|
|
|
|
//==============================================================================================
|
|
auto CServerData::IncDay() -> bool
|
|
{
|
|
++days;
|
|
return true;
|
|
}
|
|
|
|
|
|
//==============================================================================================
|
|
auto CServerData::ServerEntry( UI16 entryNum ) -> PhysicalServer *
|
|
{
|
|
PhysicalServer *rValue = nullptr;
|
|
if( entryNum < serverList.size() )
|
|
{
|
|
rValue = &serverList[entryNum];
|
|
}
|
|
return rValue;
|
|
}
|
|
//==============================================================================================
|
|
auto CServerData::ServerCount() const -> UI16
|
|
{
|
|
return static_cast<UI16>( serverList.size() );
|
|
}
|
|
//==============================================================================================
|
|
// PhysicalServer
|
|
//==============================================================================================
|
|
|
|
//==============================================================================================
|
|
auto PhysicalServer::SetName( const std::string& newName ) -> void
|
|
{
|
|
name = newName;
|
|
}
|
|
//==============================================================================================
|
|
auto PhysicalServer::SetDomain( const std::string& newDomain ) -> void
|
|
{
|
|
domain = newDomain;
|
|
}
|
|
//==============================================================================================
|
|
auto PhysicalServer::SetIP( const std::string& newIP ) -> void
|
|
{
|
|
ip = newIP;
|
|
}
|
|
//==============================================================================================
|
|
auto PhysicalServer::SetPort( UI16 newPort ) -> void
|
|
{
|
|
port = newPort;
|
|
}
|
|
//==============================================================================================
|
|
auto PhysicalServer::GetName() const -> const std::string&
|
|
{
|
|
return name;
|
|
}
|
|
//==============================================================================================
|
|
auto PhysicalServer::GetDomain() const -> const std::string &
|
|
{
|
|
return domain;
|
|
}
|
|
//==============================================================================================
|
|
auto PhysicalServer::GetIP() const -> const std::string &
|
|
{
|
|
return ip;
|
|
}
|
|
//==============================================================================================
|
|
auto PhysicalServer::GetPort() const -> UI16
|
|
{
|
|
return port;
|
|
}
|