Beiträge von Shinex

Shinex · 15. September 2022

Zitat von Tennse

Zitat von Steap

Do you want a internal webbrowser to access your external website? Im pretty sure that's what Shinex explained you

nope,this itemshop are only in game (it can work without connection to website)

Then you need to edit the pythonfiles

Shinex · 15. September 2022

uishop.py root or Game Sourcecode, i think it was

cmd_general.cpp:

do_in_game_mall

config.cpp:

g_strWebMallURL

Shinex · 14. September 2022

Zitat von x3Syntax

Zitat von Shinex

Mir ist schon wieder was eingefallen Idee für ein gutes System so weit es das nicht schon gibt, mit einem Mouse Hover im Gilden Mitglieder Bereich auf den Namen der Member den letzten Online Status anzeigen damit der Leader besser entscheiden kann wen man rausschmeisen kann.

Letzte online Zeit und die Möglichkeit eine Begründung der Abwesenheit da zu lassen? Wie wäre es damit?

Jo, gibt es sowas schon? Außer diese Profil-Systeme

Shinex · 14. September 2022

Mir ist schon wieder was eingefallen Idee für ein gutes System so weit es das nicht schon gibt, mit einem Mouse Hover im Gilden Mitglieder Bereich auf den Namen der Member den letzten Online Status anzeigen damit der Leader besser entscheiden kann wen man rausschmeisen kann.

Shinex · 8. September 2022

Beim Live-Stream gucken ist mir noch etwas simples eingefallen was man umsetzen könnte, Ihr kennt sicherlich die Funktion, dass der Button beim Wiederbeleben gedrückt bleibt und der Char dann automatisch aufsteht, dasselbe könnte man mit dem Ausloggen, Char Button whatever machen wenn man sich wegen der 10 Sekunden nicht ausloggen kann, selbe Geschichte beim Teleporten usw. Also halt das ein kleiner Timer beim Button abläuft und die Funktion danach automatisch ausgeführt wird.

Shinex · 8. September 2022

Moin Leute. Ich war jetzt ein paar Jahre nicht mehr in der Szene aktiv und hätte deswegen ein paar Fragen an euch.

Kann man die aktuellen und älteren Serverfiles problemlos auf FreebSD13.1 & mysql5.6 laufen lassen?

Welche FreeBSD-Version ist die beste um den Game-Sourcecode problemlos zu compilen (Erfahrungsgemäß)?
Kann man die aktuellste Visual-Studio Version 22 benutzen zum compilen von der Binary?

Was gibt es mittlerweile für bekannte Fehler oder Exploits worauf man acht geben sollte, gibt es da eine Liste oder kann da jemand genauer drauf eingehen?

Gerne könnt ihr mir ein paar Basics erzählen worauf man achten sollten & was sich mittlerweile alles so verändert hat, Ich dannke

Shinex · 3. September 2022

Zitat von Steap

Ich finde die Idee actually verdammt gut. Ich spiele oft Surf & Bhop in CS:GO und dort gibt es in den meisten Fällen ein Webradio. Dort wird ein Radio mit den besten Songs aus den internationalen Charts abgespielt und die Leute lieben es. Ich glaube, hierbei ist wichtig zu erwähnen, dass es purely um den Zusammenhören-Aspekt geht und die Möglichkeit, Problemlos ohne Links, den Raum zu betreten. IchBinKrasser

Vordefinierte Kanäle

Es wird einen Musik-Button im Interface zu sehen geben, welcher das Radio-Interface öffnet. Dort bietet man internationale und Ländercharts an. Die Umsetzung kann man sich hier abgucken, scheint sehr einfach zu sein: Bitte melden Sie sich an, um diesen Link zu sehen.

Benutzerdefinierte Kanäle

Neben den vordefinierten Kanäle, können Spieler auch benutzerdefinierte Räume erstellen, wo eigene Musik über ein Warteschlangen-Konzept abgespielt wird. Spieler können im Interface einen Link zur Playlist hinzufügen (kann man auch per Chatbefehl ermöglichen). Jeder Spieler im Raum erhält nun eine Nachricht im globalen Chat, mit dem Bitte melden Sie sich an, um diesen Link zu sehen. und rechts daneben ein anklickbarer Link mit dem Namen [Dagegen]. Klicken mehr als 50% im Raum auf den Link, wird der Titel aus der Playlist entfernt. Sind mehr als 30 Minuten keine Spieler mehr im Raum oder alle sind offline, wird der Raum geschlossen. Watch2Gether wirft einem für diese Funktionalität bereits mit der simplen API alles vor die Füße: Bitte melden Sie sich an, um diesen Link zu sehen.

Sonstige Ideen
Nicht auf Maps reduzieren
Sollte auch in Ladebildschirmen noch abspielen
Interface simple halten
Im globalen Chat alle 10 Minuten die Links der aktuell abgespielten Titel aus den vordefinierten Kanälen posten (mit einem Beitritt-Link). Diese Funktion soll man in den Optionen für sich deaktivieren können. Um nicht direkt 20 Länder zu posten, kann man dies auf die internationalen Charts und die Charts vom eigenen Land reduzieren.
Keine externen Möglichkeiten! Es gibt genug Möglichkeiten, sowas im Spiel zu integrieren.
Ich würde sowas wirklich verdammt gerne sehen. Würde ich mich in Metin2 etwas wohler mit dem Code fühlen, wäre dies einer meiner Prioritäten für Systemideen. Man sollte Features, welche Spieler zusammenbringen, nicht unterschätzen.

Alles anzeigen

Genau, besser hätte ich es nicht sagen können.

Das System hat aufjedenfall Potential und ich Stelle mir das total genial vor, weil es oft genug Momente gibt wo Spieler einfach nur am switchen, uppen oder gammeln sind und da wäre so ein System im Client eine super Abwechslung, klar gibt's auch externe Programme dafür aber darum geht's ja eben nicht. Ich hoffe einer hat Bock sich dem anzunehmen, könnte ich mir auf jeden Server vorstellen.

Shinex · 3. September 2022

Moin Jungs.
Mir ist da gerade eine Idee eingefallen die man vorallem aus so Spielen wie Smeet (Virtual World) kennt, ein System wo man YouTube Songs oder ganze Playlisten abspielen kann zusammen mit anderen, dass jeder immer maximal einen Song reinpacken kann der dann in einer Warteschlange ist. (Wie Watch2Gether) Evnetuell dafür noch eine extra Map die zum Musik hören und switchen wathever gedacht ist oder ein extra Chat Bereich (Fenster), oder über einen Button in der Freundesliste oder im PN-Fenster.

Ich finde die Idee ziemlich cool, villeicht hat hier ja einer Bock das umzusetzen.

Shinex · 28. Juni 2020

Moin Leute ich habe da mal ein kleines Problem, Ich habe mir 30.000 Rangpunkt eingestellt wie hier:

Bitte melden Sie sich an, um diesen Link zu sehen.

Geht so weit alles, Jedoch werden mir auf einem zweiten Fenster (Char) die Rangpunkte nach dem Teleportieren von dem jewals anderen nicht angezeigt, wisst ihr woran dass liegen kann?

Ich habe ein eigenes login,loading interface von poccix.. Kann es eventuell irgendwo daran liegen?

Spoiler anzeigen

Python

Hier meine loading
import ui
import uiScriptLocale
import net
import app
import dbg
import player
import background
import wndMgr
import localeInfo
import chrmgr
import colorInfo
import constInfo
import playerSettingModule
import stringCommander
import emotion
####################################
# 빠른 실행을 위한 모듈 로딩 분담
####################################
import uiRefine
import uiToolTip
import uiAttachMetin
import uiPickMoney
import uiChat
import uiMessenger
import uiHelp
import uiWhisper
import uiPointReset
import uiShop
import uiExchange
import uiSystem
import uiOption
import uiRestart
####################################
class LoadingWindow(ui.ScriptWindow):
def __init__(self, stream):
print "NEW LOADING WINDOW -------------------------------------------------------------------------------"
ui.Window.__init__(self)
net.SetPhaseWindow(net.PHASE_WINDOW_LOAD, self)
self.stream=stream
self.loadingGage=0
self.update=0
self.playerX=0
self.playerY=0
self.loadStepList=[]
def __del__(self):
print "---------------------------------------------------------------------------- DELETE LOADING WINDOW"
net.SetPhaseWindow(net.PHASE_WINDOW_LOAD, 0)
ui.Window.__del__(self)
def Open(self):
print "OPEN LOADING WINDOW -------------------------------------------------------------------------------"
#app.HideCursor()
try:
pyScrLoader = ui.PythonScriptLoader()
pyScrLoader.LoadScriptFile(self, "ui_poccix_loading.py")
except:
import exception
exception.Abort("LodingWindow.Open - LoadScriptFile Error")
try:
self.loadingGage=self.GetChild("gauge_full")
self.text_loading = self.GetChild("text_percent")
except:
import exception
exception.Abort("LodingWindow.Open - LoadScriptFile Error")
self.loadingGage.SetPercentage(2, 100)
self.Show()
chrSlot=self.stream.GetCharacterSlot()
net.SendSelectCharacterPacket(chrSlot)
app.SetFrameSkip(0)
def Close(self):
print "---------------------------------------------------------------------------- CLOSE LOADING WINDOW"
app.SetFrameSkip(1)
self.loadStepList=[]
self.text_loading = None
self.loadingGage=0
self.ClearDictionary()
self.Hide()
def OnPressEscapeKey(self):
app.SetFrameSkip(1)
self.stream.SetLoginPhase()
return TRUE
def __SetNext(self, next):
if next:
self.update=ui.__mem_func__(next)
else:
self.update=0
def __SetProgress(self, p):
if self.loadingGage:
self.loadingGage.SetPercentage(100*p/100, 100)
self.text_loading.SetText(str(100*p/100) + "%")
def DEBUG_LoadData(self, playerX, playerY):
self.playerX=playerX
self.playerY=playerY
self.__RegisterSkill() ## 로딩 중간에 실행 하면 문제 발생
self.__RegisterTitleName()
self.__RegisterColor()
self.__InitData()
self.__LoadMap()
self.__LoadSound()
self.__LoadEffect()
self.__LoadWarrior()
self.__LoadAssassin()
self.__LoadSura()
self.__LoadShaman()
self.__LoadSkill()
self.__LoadEnemy()
self.__LoadNPC()
self.__StartGame()
def LoadData(self, playerX, playerY):
self.playerX=playerX
self.playerY=playerY
self.__RegisterDungeonMapName()
self.__RegisterSkill() ## 로딩 중간에 실행 하면 문제 발생
self.__RegisterTitleName()
self.__RegisterColor()
self.__RegisterEmotionIcon()
self.loadStepList=[
(0, ui.__mem_func__(self.__InitData)),
(10, ui.__mem_func__(self.__LoadMap)),
(30, ui.__mem_func__(self.__LoadSound)),
(40, ui.__mem_func__(self.__LoadEffect)),
(50, ui.__mem_func__(self.__LoadWarrior)),
(60, ui.__mem_func__(self.__LoadAssassin)),
(70, ui.__mem_func__(self.__LoadSura)),
(80, ui.__mem_func__(self.__LoadShaman)),
(90, ui.__mem_func__(self.__LoadSkill)),
(93, ui.__mem_func__(self.__LoadEnemy)),
(97, ui.__mem_func__(self.__LoadNPC)),
# GUILD_BUILDING
(98, ui.__mem_func__(self.__LoadGuildBuilding)),
# END_OF_GUILD_BUILDING
(100, ui.__mem_func__(self.__StartGame)),
]
self.__SetProgress(0)
#self.__SetNext(self.__LoadMap)
def OnUpdate(self):
if len(self.loadStepList)>0:
(progress, runFunc)=self.loadStepList[0]
runFunc()
self.loadStepList.pop(0)
self.__SetProgress(progress)
def __InitData(self):
playerSettingModule.LoadGameData("INIT")
def __RegisterDungeonMapName(self):
background.RegisterDungeonMapName("metin2_map_spiderdungeon")
background.RegisterDungeonMapName("metin2_map_monkeydungeon")
background.RegisterDungeonMapName("metin2_map_monkeydungeon_02")
background.RegisterDungeonMapName("metin2_map_monkeydungeon_03")
background.RegisterDungeonMapName("metin2_map_deviltower1")
def __RegisterSkill(self):
race = net.GetMainActorRace()
group = net.GetMainActorSkillGroup()
empire = net.GetMainActorEmpire()
playerSettingModule.RegisterSkill(race, group, empire)
def __RegisterTitleName(self):
for i in xrange(len(localeInfo.TITLE_NAME_LIST)):
chrmgr.RegisterTitleName(i, localeInfo.TITLE_NAME_LIST[i])
def __RegisterColor(self):
## Name
NAME_COLOR_DICT = {
chrmgr.NAMECOLOR_PC : colorInfo.CHR_NAME_RGB_PC,
chrmgr.NAMECOLOR_NPC : colorInfo.CHR_NAME_RGB_NPC,
chrmgr.NAMECOLOR_MOB : colorInfo.CHR_NAME_RGB_MOB,
chrmgr.NAMECOLOR_PVP : colorInfo.CHR_NAME_RGB_PVP,
chrmgr.NAMECOLOR_PK : colorInfo.CHR_NAME_RGB_PK,
chrmgr.NAMECOLOR_PARTY : colorInfo.CHR_NAME_RGB_PARTY,
chrmgr.NAMECOLOR_WARP : colorInfo.CHR_NAME_RGB_WARP,
chrmgr.NAMECOLOR_WAYPOINT : colorInfo.CHR_NAME_RGB_WAYPOINT,
chrmgr.NAMECOLOR_EMPIRE_MOB : colorInfo.CHR_NAME_RGB_EMPIRE_MOB,
chrmgr.NAMECOLOR_EMPIRE_NPC : colorInfo.CHR_NAME_RGB_EMPIRE_NPC,
chrmgr.NAMECOLOR_EMPIRE_PC+1 : colorInfo.CHR_NAME_RGB_EMPIRE_PC_A,
chrmgr.NAMECOLOR_EMPIRE_PC+2 : colorInfo.CHR_NAME_RGB_EMPIRE_PC_B,
chrmgr.NAMECOLOR_EMPIRE_PC+3 : colorInfo.CHR_NAME_RGB_EMPIRE_PC_C,
}
for name, rgb in NAME_COLOR_DICT.items():
chrmgr.RegisterNameColor(name, rgb[0], rgb[1], rgb[2])
## Title
TITLE_COLOR_DICT = ( colorInfo.TITLE_RGB_GOOD_6,
colorInfo.TITLE_RGB_GOOD_5,
colorInfo.TITLE_RGB_GOOD_4,
colorInfo.TITLE_RGB_GOOD_3,
colorInfo.TITLE_RGB_GOOD_2,
colorInfo.TITLE_RGB_GOOD_1,
colorInfo.TITLE_RGB_NORMAL,
colorInfo.TITLE_RGB_EVIL_1,
colorInfo.TITLE_RGB_EVIL_2,
colorInfo.TITLE_RGB_EVIL_3,
colorInfo.TITLE_RGB_EVIL_4,
colorInfo.TITLE_RGB_EVIL_5,
colorInfo.TITLE_RGB_EVIL_6, )
count = 0
for rgb in TITLE_COLOR_DICT:
chrmgr.RegisterTitleColor(count, rgb[0], rgb[1], rgb[2])
count += 1
def __RegisterEmotionIcon(self):
emotion.RegisterEmotionIcons()
def __LoadMap(self):
net.Warp(self.playerX, self.playerY)
def __LoadSound(self):
playerSettingModule.LoadGameData("SOUND")
def __LoadEffect(self):
playerSettingModule.LoadGameData("EFFECT")
def __LoadWarrior(self):
playerSettingModule.LoadGameData("WARRIOR")
def __LoadAssassin(self):
playerSettingModule.LoadGameData("ASSASSIN")
def __LoadSura(self):
playerSettingModule.LoadGameData("SURA")
def __LoadShaman(self):
playerSettingModule.LoadGameData("SHAMAN")
def __LoadSkill(self):
playerSettingModule.LoadGameData("SKILL")
def __LoadEnemy(self):
playerSettingModule.LoadGameData("ENEMY")
def __LoadNPC(self):
playerSettingModule.LoadGameData("NPC")
# GUILD_BUILDING
def __LoadGuildBuilding(self):
playerSettingModule.LoadGuildBuildingList(localeInfo.GUILD_BUILDING_LIST_TXT)
# END_OF_GUILD_BUILDING
def __StartGame(self):
self.__RegisterColor()
background.SetViewDistanceSet(background.DISTANCE0, 25600)
"""
background.SetViewDistanceSet(background.DISTANCE1, 19200)
background.SetViewDistanceSet(background.DISTANCE2, 12800)
background.SetViewDistanceSet(background.DISTANCE3, 9600)
background.SetViewDistanceSet(background.DISTANCE4, 6400)
"""
background.SelectViewDistanceNum(background.DISTANCE0)
app.SetGlobalCenterPosition(self.playerX, self.playerY)
net.StartGame()

Alles anzeigen

Shinex · 10. Juni 2019

Moin, Ich habe einen Fehler mit dem Rangsystem wenn man sich in einem zweiten Client einloggt bzw, neu einloggt sieht man den Rangnamen nicht von anderen Spielern erst wenn ich z.B verwandelt bin sieht man den Rangnamen, kann mir jemand helfen?

Ich habe auch die Rangpunkte erweiterung drin.

Shinex · 25. Februar 2019

Ist ja auch so wichtig den Source zu haben von dem pvp crapserver wo 2-3 sachen geändert sind

Shinex · 24. Februar 2019

Moin Leute, Mein Core ist gecrasht und dass mit dem Debugen ist Neuland für mich und deswegen hoffe ich auf Hilfe von hier welcher Fehler dies verursacht..

(bt)

Spoiler anzeigen

(bt full)

Spoiler anzeigen

Code

_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffaab0, _M_right = 0xffffaab0},
_M_node_count = 0}}}}
wedding_manager = {<singleton<marriage::WeddingManager>> = {
_vptr.singleton = 0x846e3c8 <vtable for marriage::WeddingManager+8>, static ms_singleton = 0xffffa744}, m_mapWedding = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, marriage::WeddingMap*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, marriage::WeddingMap*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffa74c, _M_right = 0xffffa74c},
_M_node_count = 0}}}}
SkillPowerByLevel = {<singleton<CTableBySkill>> = {
_vptr.singleton = 0x84815c0 <vtable for CTableBySkill+8>,
static ms_singleton = 0xffffaee4},
m_aiSkillPowerByLevelFromType = {0x28e35600, 0x28e356c0, 0x28e35780,
0x28e35840, 0x28e35900, 0x28e359c0, 0x28e35a80, 0x28e35b40},
--Type <RET> for more, q to quit, c to continue without paging--
m_aiSkillDamageByLevel = 0x0}
polymorph_utils = {<singleton<CPolymorphUtils>> = {
_vptr.singleton = 0x845cac8 <vtable for CPolymorphUtils+8>,
static ms_singleton = 0xffffaf3c}, m_mapSPDType = {
table_ = {<boost::unordered_detail::hash_table<boost::unordered_detail::map<unsigned int, boost::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int> > > >> = {<boost::unordered_detail::hash_buckets<std::allocator<std::pair<unsigned int const, unsigned int> >, boost::unordered_detail::ungrouped>> = {buckets_ = 0x28c133a0,
bucket_count_ = 11,
allocators_ = {<boost::details::compressed_pair_imp<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, unsigned int> > > >, std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<unsigned int const, unsigned int> >, boost::unordered_detail::ungrouped> >, 3>> = {<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, unsigned int> > > >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, unsigned int> > > >> = {<No data fields>}, <No data fields>}, <std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<unsigned int const, unsigned int> >, boost::unordered_detail::ungrouped> >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<unsigned int const, unsigned int> >, boost::unordered_detail::ungrouped> >> = {<No data fields>}, <No data fields>}, <No data fields>}, <No data fields>}}, <boos--Type <RET> for more, q to quit, c to continue without paging--
t::unordered_detail::hash_buffered_functions<boost::hash<unsigned int>, std::equal_to<unsigned int> >> = {current_ = false, funcs_ = {{data_ = {buf = "",
align_ = 0 '\000'}}, {data_ = {buf = "",
align_ = 0 '\000'}}}}, size_ = 2, mlf_ = 1,
cached_begin_bucket_ = 0x28c133a8,
max_load_ = 11}, <No data fields>}}, m_mapATKType = {
table_ = {<boost::unordered_detail::hash_table<boost::unordered_detail::map<unsigned int, boost::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int> > > >> = {<boost::unordered_detail::hash_buckets<std::allocator<std::pair<unsigned int const, unsigned int> >, boost::unordered_detail::ungrouped>> = {buckets_ = 0x0,
bucket_count_ = 11,
allocators_ = {<boost::details::compressed_pair_imp<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, unsigned int> > > >, std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<unsigned int const, unsigned int> >, boost::unordered_detail::ungrouped> >, 3>> = {<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, unsigned int> > > >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, unsigned int> > > >> = {<No data fields>}, <No data fields>}, <std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<unsigned int const, unsigned int> >, boost::unordered_detail::ungrouped> >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<u--Type <RET> for more, q to quit, c to continue without paging--
nsigned int const, unsigned int> >, boost::unordered_detail::ungrouped> >> = {<No data fields>}, <No data fields>}, <No data fields>}, <No data fields>}}, <boost::unordered_detail::hash_buffered_functions<boost::hash<unsigned int>, std::equal_to<unsigned int> >> = {current_ = false, funcs_ = {{data_ = {buf = "",
align_ = 0 '\000'}}, {data_ = {buf = "",
align_ = 0 '\000'}}}}, size_ = 0, mlf_ = 1,
cached_begin_bucket_ = 0x0,
max_load_ = 0}, <No data fields>}}, m_mapDEFType = {
table_ = {<boost::unordered_detail::hash_table<boost::unordered_detail::map<unsigned int, boost::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int> > > >> = {<boost::unordered_detail::hash_buckets<std::allocator<std::pair<unsigned int const, unsigned int> >, boost::unordered_detail::ungrouped>> = {buckets_ = 0x0,
bucket_count_ = 11,
allocators_ = {<boost::details::compressed_pair_imp<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, unsigned int> > > >, std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<unsigned int const, unsigned int> >, boost::unordered_detail::ungrouped> >, 3>> = {<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, unsigned int> > > >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, unsigned int> > > >> = {<No data fields>}, <No data fields>}, <std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<unsign--Type <RET> for more, q to quit, c to continue without paging--
ed int const, unsigned int> >, boost::unordered_detail::ungrouped> >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<unsigned int const, unsigned int> >, boost::unordered_detail::ungrouped> >> = {<No data fields>}, <No data fields>}, <No data fields>}, <No data fields>}}, <boost::unordered_detail::hash_buffered_functions<boost::hash<unsigned int>, std::equal_to<unsigned int> >> = {current_ = false, funcs_ = {{data_ = {buf = "",
align_ = 0 '\000'}}, {data_ = {buf = "",
align_ = 0 '\000'}}}}, size_ = 0, mlf_ = 1,
cached_begin_bucket_ = 0x0, max_load_ = 0}, <No data fields>}}}
dsManager = {<singleton<DSManager>> = {
_vptr.singleton = 0x847f2a0 <vtable for DSManager+8>,
static ms_singleton = 0xffffa6d0}, m_pTable = 0x0}
refine_manager = {<singleton<CRefineManager>> = {
_vptr.singleton = 0x8463b28 <vtable for CRefineManager+8>,
static ms_singleton = 0xffffa728}, m_map_RefineRecipe = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, SRefineTable> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, SRefineTable> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffa730,
_M_right = 0xffffa730}, _M_node_count = 0}}}}
--Type <RET> for more, q to quit, c to continue without paging--
passpod = {<singleton<CPasspod>> = {
_vptr.singleton = 0x845c8f0 <vtable for CPasspod+8>,
static ms_singleton = 0xffffa6d8}, m_sock = -1, m_lpFDW = 0x0}
o9r = {<singleton<COver9RefineManager>> = {
_vptr.singleton = 0x8481560 <vtable for COver9RefineManager+8>,
static ms_singleton = 0xffffae80}, m_mapItem = {
table_ = {<boost::unordered_detail::hash_table<boost::unordered_detail::map<unsigned int, boost::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int> > > >> = {<boost::unordered_detail::hash_buckets<std::allocator<std::pair<unsigned int const, unsigned int> >, boost::unordered_detail::ungrouped>> = {buckets_ = 0x0,
bucket_count_ = 11,
allocators_ = {<boost::details::compressed_pair_imp<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, unsigned int> > > >, std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<unsigned int const, unsigned int> >, boost::unordered_detail::ungrouped> >, 3>> = {<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, unsigned int> > > >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, unsigned int> > > >> = {<No data fields>}, <No data fields>}, <std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<unsigned int const, unsigned int> >, boost::unordered_detail::ungrouped> >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<u--Type <RET> for more, q to quit, c to continue without paging--
nsigned int const, unsigned int> >, boost::unordered_detail::ungrouped> >> = {<No data fields>}, <No data fields>}, <No data fields>}, <No data fields>}}, <boost::unordered_detail::hash_buffered_functions<boost::hash<unsigned int>, std::equal_to<unsigned int> >> = {current_ = false, funcs_ = {{data_ = {buf = "",
align_ = 0 '\000'}}, {data_ = {buf = "",
align_ = 0 '\000'}}}}, size_ = 0, mlf_ = 1,
cached_begin_bucket_ = 0x0, max_load_ = 0}, <No data fields>}}}
__FUNCTION__ = "main"
title = {<singleton<TitleManager>> = {
_vptr.singleton = 0x8480a48 <vtable for TitleManager+8>,
static ms_singleton = 0xffffa6b4}, <No data fields>}
party_manager = {<singleton<CPartyManager>> = {
_vptr.singleton = 0x845c3b0 <vtable for CPartyManager+8>,
static ms_singleton = 0xffffa8f8}, m_map_pkParty = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CParty*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CParty*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffa900, _M_right = 0xffffa900},
_M_node_count = 0}}}, m_map_pkMobParty = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned i--Type <RET> for more, q to quit, c to continue without paging--
nt const, CParty*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CParty*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffa918, _M_right = 0xffffa918},
_M_node_count = 0}}}, m_set_pkPCParty = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<CParty*> >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<CParty*> >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<CParty*, CParty*, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffa930,
_M_right = 0xffffa930}, _M_node_count = 0}}},
m_bEnablePCParty = false}
arena_manager = {<singleton<CArenaManager>> = {
_vptr.singleton = 0x8481520 <vtable for CArenaManager+8>,
static ms_singleton = 0xffffa760}, m_mapArenaMap = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CArenaMap*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CArenaMap*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {--Type <RET> for more, q to quit, c to continue without paging--
<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffa768,
_M_right = 0xffffa768}, _M_node_count = 0}}}}
horsename_manager = {<singleton<CHorseNameManager>> = {
_vptr.singleton = 0x84525f8 <vtable for CHorseNameManager+8>,
static ms_singleton = 0xffffa77c}, m_mapHorseNames = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffa784, _M_right = 0xffffa784},
_M_node_count = 0}}}}
sectree_manager = {<singleton<SECTREE_MANAGER>> = {
_vptr.singleton = 0x8464788 <vtable for SECTREE_MANAGER+8>,
static ms_singleton = 0xffffab34},
static current_sectree_version = 768, m_map_pkSectree = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, SECTREE_MAP*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, SECTREE_MAP*> > >> = {<No data fields>}, <No data fie--Type <RET> for more, q to quit, c to continue without paging--
lds>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffab3c,
_M_right = 0xffffab3c}, _M_node_count = 0}}},
m_map_pkArea = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<int const, std::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, TAreaInfo, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, TAreaInfo> > > > > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<int const, std::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, TAreaInfo, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, TAreaInfo> > > > > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<int, int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffab54,
_M_right = 0xffffab54}, _M_node_count = 0}}},
m_vec_mapRegion = {<std::_Vector_base<SMapRegion, std::allocator<SMapRegion> >> = {
_M_impl = {<std::allocator<SMapRegion>> = {<__gnu_cxx::new_allocator--Type <RET> for more, q to quit, c to continue without paging--
<SMapRegion>> = {<No data fields>}, <No data fields>}, _M_start = 0x0,
_M_finish = 0x0, _M_end_of_storage = 0x0}}, <No data fields>},
m_mapNPCPosition = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, std::vector<npc_info, std::allocator<npc_info> > > > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, std::vector<npc_info, std::allocator<npc_info> > > > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffab78,
_M_right = 0xffffab78}, _M_node_count = 0}}},
next_private_index_map_ = {<std::tr1::__unordered_map<long, int, std::tr1::hash<long>, std::equal_to<long>, std::allocator<std::pair<long const, int> >, false>> = {<std::tr1::_Hashtable<long, std::pair<long const, int>, std::allocator<std::pair<long const, int> >, std::_Select1st<std::pair<long const, int> >, std::equal_to<long>, std::tr1::hash<long>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, false, true>> = {<std::tr1::__detail::_Rehash_base<std::tr1::__detail::_Prime_rehash_policy, std::tr1::_Hashtable<long, std::pair<long const, int>, std::allocator<std::pair<long const, int> >, std::_Select1st<std::pair<long const, int> >, std::equal_to<long>, std::tr1::hash<long>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_--Type <RET> for more, q to quit, c to continue without paging--
Prime_rehash_policy, false, false, true> >> = {<No data fields>}, <std::tr1::__detail::_Hash_code_base<long, std::pair<long const, int>, std::_Select1st<std::pair<long const, int> >, std::equal_to<long>, std::tr1::hash<long>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, false>> = {
_M_extract = {<std::unary_function<std::pair<long const, int>, long const>> = {<No data fields>}, <No data fields>},
_M_eq = {<std::binary_function<long, long, bool>> = {<No data fields>}, <No data fields>},
_M_h1 = {<std::unary_function<long, unsigned int>> = {<No data fields>}, <No data fields>},
_M_h2 = {<No data fields>}}, <std::tr1::__detail::_Map_base<long, std::pair<long const, int>, std::_Select1st<std::pair<long const, int> >, true, std::tr1::_Hashtable<long, std::pair<long const, int>, std::allocator<std::pair<long const, int> >, std::_Select1st<std::pair<long const, int> >, std::equal_to<long>, std::tr1::hash<long>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, false, true> >> = {<No data fields>},
_M_node_allocator = {<__gnu_cxx::new_allocator<std::tr1::__detail::_Hash_node<std::pair<long const, int>, false> >> = {<No data fields>}, <No data fields>}, _M_buckets = 0x28c13100, _M_bucket_count = 11,
_M_element_count = 0, _M_rehash_policy = {
_M_max_load_factor = 1, _M_growth_factor = 2,
_M_next_resize = 11}}, <No data fields>}, <No data fields>}}
--Type <RET> for more, q to quit, c to continue without paging--
pvp_manager = {<singleton<CPVPManager>> = {
_vptr.singleton = 0x845d070 <vtable for CPVPManager+8>,
static ms_singleton = 0xffffa80c}, m_map_pkPVP = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CPVP*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CPVP*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffa814, _M_right = 0xffffa814},
_M_node_count = 0}}}, m_map_pkPVPSetByID = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, std::tr1::unordered_set<CPVP*, std::tr1::hash<CPVP*>, std::equal_to<CPVP*>, std::allocator<CPVP*> > > > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, std::tr1::unordered_set<CPVP*, std::tr1::hash<CPVP*>, std::equal_to<CPVP*>, std::allocator<CPVP*> > > > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffa82c, _M_right = 0xffffa82c},
_M_node_count = 0}}}}
profiler = {<singleton<CProfiler>> = {
--Type <RET> for more, q to quit, c to continue without paging--
_vptr.singleton = 0x8481500 <vtable for CProfiler+8>,
static ms_singleton = 0xffffb5cc}, m_ProfileStackDataCount = 0,
m_ProfileStackDatas = {{iCallStep = 0, iStartTime = 0, iEndTime = 0,
strName = {static npos = <optimized out>,
_M_dataplus = {<std::allocator<char>> = {<__gnu_cxx::new_allocator<char>> = {<No data fields>}, <No data fields>},
_M_p = 0x86abc8c <std::string::_Rep::_S_empty_rep_storage@@GLIBCXX_3.4+12> ""}}} <repeats 64 times>}, m_ProfileAccumDataMap = {
table_ = {<boost::unordered_detail::hash_table<boost::unordered_detail::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, boost::hash<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::equal_to<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CProfiler::SProfileAccumData> > > >> = {<boost::unordered_detail::hash_buckets<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CProfiler::SProfileAccumData> >, boost::unordered_detail::ungrouped>> = {buckets_ = 0x0,
bucket_count_ = 11,
allocators_ = {<boost::details::compressed_pair_imp<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CProfiler::SProfileAccumData> > > >, std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<--Type <RET> for more, q to quit, c to continue without paging--
char> > const, CProfiler::SProfileAccumData> >, boost::unordered_detail::ungrouped> >, 3>> = {<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CProfiler::SProfileAccumData> > > >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CProfiler::SProfileAccumData> > > >> = {<No data fields>}, <No data fields>}, <std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CProfiler::SProfileAccumData> >, boost::unordered_detail::ungrouped> >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CProfiler::SProfileAccumData> >, boost::unordered_detail::ungrouped> >> = {<No data fields>}, <No data fields>}, <No data fields>}, <No data fields>}}, <boost::unordered_detail::hash_buffered_functions<boost::hash<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::equal_to<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >> = {current_ = false, funcs_ = {{data_ = {buf = "",
align_ = 0 '\000'}}, {data_ = {buf = "",
align_ = 0 '\000'}}}}, size_ = 0, mlf_ = 1,
cached_begin_bucket_ = 0x0,
max_load_ = 0}, <No data fields>}},
m_vec_Accum = {<std::_Vector_base<CProfiler::SProfileAccumData*, std::allocator<CProfiler::SProfileAccumData*> >> = {
--Type <RET> for more, q to quit, c to continue without paging--
_M_impl = {<std::allocator<CProfiler::SProfileAccumData*>> = {<__gnu_cxx::new_allocator<CProfiler::SProfileAccumData*>> = {<No data fields>}, <No data fields>}, _M_start = 0x0, _M_finish = 0x0,
_M_end_of_storage = 0x0}}, <No data fields>},
m_iAccumDepth = 0, m_iCallStep = 0}
HSManager = {<singleton<CHackShieldManager>> = {
_vptr.singleton = 0x84815a0 <vtable for CHackShieldManager+8>,
static ms_singleton = 0xffffa6c8}, impl_ = 0x0}
SSManager = {<singleton<CSpeedServerManager>> = {
_vptr.singleton = 0x846f860 <vtable for CSpeedServerManager+8>,
static ms_singleton = 0xffffc3f8}, Empire = {{empire = 0 '\000',
file_name = '\000' <repeats 255 times>, current_hme = {hour = 0,
min = 0, exp = 0}, holiday_map = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<Date const, std::list<HME, std::allocator<HME> > > > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<Date const, std::list<HME, std::allocator<HME> > > > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<Date, Date, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffc510,
_M_right = 0xffffc510}, _M_node_count = 0}}},
wday_exp_table = {
{<std::_List_base<HME, std::allocator<HME> >> = {
--Type <RET> for more, q to quit, c to continue without paging--
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc524,
_M_prev = 0xffffc524}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc52c,
_M_prev = 0xffffc52c}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc534,
_M_prev = 0xffffc534}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc53c,
_M_prev = 0xffffc53c}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc544,
--Type <RET> for more, q to quit, c to continue without paging--
_M_prev = 0xffffc544}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc54c,
_M_prev = 0xffffc54c}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc554,
_M_prev = 0xffffc554}}}, <No data fields>}}}, {
empire = 0 '\000', file_name = '\000' <repeats 255 times>,
current_hme = {hour = 0, min = 0, exp = 0}, holiday_map = {
_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<Date const, std::list<HME, std::allocator<HME> > > > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<Date const, std::list<HME, std::allocator<HME> > > > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<Date, Date, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffc670,
_M_right = 0xffffc670}, _M_node_count = 0}}},
wday_exp_table = {
--Type <RET> for more, q to quit, c to continue without paging--
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc684,
_M_prev = 0xffffc684}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc68c,
_M_prev = 0xffffc68c}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc694,
_M_prev = 0xffffc694}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc69c,
_M_prev = 0xffffc69c}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data field--Type <RET> for more, q to quit, c to continue without paging--
s>}, _M_node = {_M_next = 0xffffc6a4,
_M_prev = 0xffffc6a4}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc6ac,
_M_prev = 0xffffc6ac}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc6b4,
_M_prev = 0xffffc6b4}}}, <No data fields>}}}, {
empire = 0 '\000', file_name = '\000' <repeats 255 times>,
current_hme = {hour = 0, min = 0, exp = 0}, holiday_map = {
_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<Date const, std::list<HME, std::allocator<HME> > > > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<Date const, std::list<HME, std::allocator<HME> > > > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<Date, Date, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffc7d0,
_M_right = 0xffffc7d0}, _M_node_count = 0}}},
--Type <RET> for more, q to quit, c to continue without paging--
wday_exp_table = {
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc7e4,
_M_prev = 0xffffc7e4}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc7ec,
_M_prev = 0xffffc7ec}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc7f4,
_M_prev = 0xffffc7f4}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc7fc,
_M_prev = 0xffffc7fc}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu--Type <RET> for more, q to quit, c to continue without paging--
_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc804,
_M_prev = 0xffffc804}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc80c,
_M_prev = 0xffffc80c}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc814,
_M_prev = 0xffffc814}}}, <No data fields>}}}, {
empire = 157 '\235',
file_name = "\223f(\020\000\000\000h\310\377\377\023\000\000\000<Gg(@pg((pg(h\310\377\377\360\232f(\320\310\377\377/", '\000' <repeats 11 times>, "\022\000\000\000\320\310\377\377\277\310\377\377<Gg(\300\310\377\377^*g(\330\324\377\377W\243f(\244\201\001\000\000\000\000\000\000\000\000\000Y\300\016\000q\202q\\\000\000\000\000n\340g(R*g(\364Q\250T\277\310\377\377o\000\000\000\000\340g(\277\310\377\377\000\000\000\000o\000\000\000\000\000\000\000\021\342\260On\340g(\320\310\377\377\000\000\000/usr/lib/private\000/usr/lib32/private\000co"..., current_hme = {hour = 0, min = 0, exp = 0}, holiday_map = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<Date c--Type <RET> for more, q to quit, c to continue without paging--
onst, std::list<HME, std::allocator<HME> > > > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<Date const, std::list<HME, std::allocator<HME> > > > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<Date, Date, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffc930,
_M_right = 0xffffc930}, _M_node_count = 0}}},
wday_exp_table = {
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc944,
_M_prev = 0xffffc944}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc94c,
_M_prev = 0xffffc94c}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc954,
_M_prev = 0xffffc954}}}, <No data fields>},
--Type <RET> for more, q to quit, c to continue without paging--
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc95c,
_M_prev = 0xffffc95c}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc964,
_M_prev = 0xffffc964}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc96c,
_M_prev = 0xffffc96c}}}, <No data fields>},
{<std::_List_base<HME, std::allocator<HME> >> = {
_M_impl = {<std::allocator<std::_List_node<HME> >> = {<__gnu_cxx::new_allocator<std::_List_node<HME> >> = {<No data fields>}, <No data fields>}, _M_node = {_M_next = 0xffffc974,
_M_prev = 0xffffc974}}}, <No data fields>}}}}}
skill_manager = {<singleton<CSkillManager>> = {
_vptr.singleton = 0x846d0a8 <vtable for CSkillManager+8>,
static ms_singleton = 0xffffa70c}, m_map_pkSkillProto = {_M_t = {
--Type <RET> for more, q to quit, c to continue without paging--
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CSkillProto*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CSkillProto*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffa714,
_M_right = 0xffffa714}, _M_node_count = 0}}}}
account_db = {<singleton<AccountDB>> = {
_vptr.singleton = 0x844eab0 <vtable for AccountDB+8>,
static ms_singleton = 0xffffc97c},
m_sql_direct = {<CAsyncSQL> = {<No data fields>}, <No data fields>},
m_sql = {<CAsyncSQL> = {<No data fields>}, <No data fields>},
m_IsConnect = true}
war_map_manager = {<singleton<CWarMapManager>> = {
_vptr.singleton = 0x846e038 <vtable for CWarMapManager+8>,
static ms_singleton = 0xffffa840}, m_map_kWarMapInfo = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<long const, SWarMapInfo*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<long const, SWarMapInfo*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<long, long, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x28ceafe0, _M_left = 0x28ceafe0,
--Type <RET> for more, q to quit, c to continue without paging--
_M_right = 0x28e33020}, _M_node_count = 2}}}, m_mapWarMap = {
_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<long const, CWarMap*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<long const, CWarMap*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<long, long, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffa860,
_M_right = 0xffffa860}, _M_node_count = 0}}}}
ba = {<singleton<CBattleArena>> = {
_vptr.singleton = 0x843baf8 <vtable for CBattleArena+8>,
static ms_singleton = 0xffffa6f4}, m_pEvent = {px = 0x0},
m_status = STATUS_CLOSE, m_nMapIndex = 0, m_nEmpire = 0,
m_bForceEnd = false}
XTManager = {<singleton<CXTrapManager>> = {
_vptr.singleton = 0x846fd58 <vtable for CXTrapManager+8>,
static ms_singleton = 0xffffaec0}, m_pImpl = 0x28c133d0,
m_mapClientSessions = {
table_ = {<boost::unordered_detail::hash_table<boost::unordered_detail::map<unsigned int, boost::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, CXTrapManager::sSessionInfo> > > >> = {<boost::unordered_detail::hash_buckets<std::allocator<std::pair<unsigned int const, CXTrapManager::sSessionInfo> >, boost::unordered_detail::ungrouped>> = {
--Type <RET> for more, q to quit, c to continue without paging--
buckets_ = 0x0, bucket_count_ = 11,
allocators_ = {<boost::details::compressed_pair_imp<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, CXTrapManager::sSessionInfo> > > >, std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<unsigned int const, CXTrapManager::sSessionInfo> >, boost::unordered_detail::ungrouped> >, 3>> = {<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, CXTrapManager::sSessionInfo> > > >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, CXTrapManager::sSessionInfo> > > >> = {<No data fields>}, <No data fields>}, <std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<unsigned int const, CXTrapManager::sSessionInfo> >, boost::unordered_detail::ungrouped> >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<unsigned int const, CXTrapManager::sSessionInfo> >, boost::unordered_detail::ungrouped> >> = {<No data fields>}, <No data fields>}, <No data fields>}, <No data fields>}}, <boost::unordered_detail::hash_buffered_functions<boost::hash<unsigned int>, std::equal_to<unsigned int> >> = {current_ = false, funcs_ = {{data_ = {
buf = "", align_ = 0 '\000'}}, {data_ = {buf = "",
align_ = 0 '\000'}}}}, size_ = 0, mlf_ = 1,
cached_begin_bucket_ = 0x0, max_load_ = 0}, <No data fields>}}}
quest_manager = {<singleton<quest::CQuestManager>> = {
_vptr.singleton = 0x84632c0 <vtable for quest::CQuestManager+8>,
static ms_singleton = 0xffffb16c}, m_mapEventName = {_M_t = {
--Type <RET> for more, q to quit, c to continue without paging--
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, int> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, int> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffb174, _M_right = 0xffffb174},
_M_node_count = 0}}}, m_pSelectedDungeon = 0x0,
m_dwServerTimerArg = 0, m_mapServerTimer = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int> const, boost::intrusive_ptr<event> > > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int> const, boost::intrusive_ptr<event> > > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int>, std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int>, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
--Type <RET> for more, q to quit, c to continue without paging--
_M_left = 0xffffb194, _M_right = 0xffffb194},
_M_node_count = 0}}}, m_iRunningEventIndex = 0,
m_mapEventFlag = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, int> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, int> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffb1b0, _M_right = 0xffffb1b0},
_M_node_count = 0}}}, L = 0x0, m_bNoSend = false,
m_registeredNPCVnum = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<unsigned int> >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<unsigned int> >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffb1d0, _M_right = 0xffffb1d0},
_M_node_count = 0}}}, m_mapNPC = {_M_t = {
--Type <RET> for more, q to quit, c to continue without paging--
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, quest::NPC> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, quest::NPC> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffb1e8,
_M_right = 0xffffb1e8}, _M_node_count = 0}}},
m_mapNPCNameID = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, unsigned int> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, unsigned int> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffb200, _M_right = 0xffffb200},
_M_node_count = 0}}}, m_mapTimerID = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, unsigned int> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<std::basic_stri--Type <RET> for more, q to quit, c to continue without paging--
ng<char, std::char_traits<char>, std::allocator<char> > const, unsigned int> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffb218, _M_right = 0xffffb218},
_M_node_count = 0}}}, m_CurrentRunningState = 0x0, m_mapPC = {
_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, quest::PC> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, quest::PC> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffb234,
_M_right = 0xffffb234}, _M_node_count = 0}}},
m_pCurrentCharacter = 0x0, m_pCurrentNPCCharacter = 0x0,
m_pCurrentPartyMember = 0x0, m_pCurrentPC = 0x0, m_strScript = {
static npos = <optimized out>,
_M_dataplus = {<std::allocator<char>> = {<__gnu_cxx::new_allocator<char>> = {<No data fields>}, <No data fields>},
_M_p = 0x86abc8c <std::string::_Rep::_S_empty_rep_storage@@GLIBCXX--Type <RET> for more, q to quit, c to continue without paging--
_3.4+12> ""}}, m_iCurrentSkin = 0, m_hmQuestName = {
table_ = {<boost::unordered_detail::hash_table<boost::unordered_detail::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, quest::CQuestManager::stringhash, std::equal_to<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, int> > > >> = {<boost::unordered_detail::hash_buckets<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, int> >, boost::unordered_detail::ungrouped>> = {buckets_ = 0x0, bucket_count_ = 11,
allocators_ = {<boost::details::compressed_pair_imp<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, int> > > >, std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, int> >, boost::unordered_detail::ungrouped> >, 3>> = {<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, int> > > >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, int> > > >> = {<No data fields>}, <No data fields>}, <std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, int> >, boost::unordered_detail::ungrouped> >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_node<std::allocator<std::p--Type <RET> for more, q to quit, c to continue without paging--
air<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, int> >, boost::unordered_detail::ungrouped> >> = {<No data fields>}, <No data fields>}, <No data fields>}, <No data fields>}}, <boost::unordered_detail::hash_buffered_functions<quest::CQuestManager::stringhash, std::equal_to<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >> = {
current_ = false, funcs_ = {{data_ = {buf = "",
align_ = 0 '\000'}}, {data_ = {buf = "",
align_ = 0 '\000'}}}}, size_ = 0, mlf_ = 1,
cached_begin_bucket_ = 0x0,
max_load_ = 0}, <No data fields>}}, m_hmQuestStartScript = {
table_ = {<boost::unordered_detail::hash_table<boost::unordered_detail::map<unsigned int, boost::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, std::vector<char, std::allocator<char> > > > > >> = {<boost::unordered_detail::hash_buckets<std::allocator<std::pair<unsigned int const, std::vector<char, std::allocator<char> > > >, boost::unordered_detail::ungrouped>> = {buckets_ = 0x0, bucket_count_ = 11,
allocators_ = {<boost::details::compressed_pair_imp<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, std::vector<char, std::allocator<char> > > > > >, std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<unsigned int const, std::vector<char, std::allocator<char> > > >, boost::unordered_detail::ungrouped> >, 3>> = {<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, std::vector<char, std::allocator<char> > > > > >> = {<__gn--Type <RET> for more, q to quit, c to continue without paging--
u_cxx::new_allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, std::vector<char, std::allocator<char> > > > > >> = {<No data fields>}, <No data fields>}, <std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<unsigned int const, std::vector<char, std::allocator<char> > > >, boost::unordered_detail::ungrouped> >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<unsigned int const, std::vector<char, std::allocator<char> > > >, boost::unordered_detail::ungrouped> >> = {<No data fields>}, <No data fields>}, <No data fields>}, <No data fields>}}, <boost::unordered_detail::hash_buffered_functions<boost::hash<unsigned int>, std::equal_to<unsigned int> >> = {current_ = false, funcs_ = {{data_ = {
buf = "", align_ = 0 '\000'}}, {data_ = {buf = "",
align_ = 0 '\000'}}}}, size_ = 0, mlf_ = 1,
cached_begin_bucket_ = 0x0,
max_load_ = 0}, <No data fields>}}, m_mapQuestNameByIndex = {
_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
--Type <RET> for more, q to quit, c to continue without paging--
_M_left = 0xffffb29c, _M_right = 0xffffb29c},
_M_node_count = 0}}}, m_bError = false,
m_pOtherPCBlockRootPC = 0x0,
m_vecPCStack = {<std::_Vector_base<unsigned int, std::allocator<unsigned int> >> = {
_M_impl = {<std::allocator<unsigned int>> = {<__gnu_cxx::new_allocator<unsigned int>> = {<No data fields>}, <No data fields>}, _M_start = 0x0,
_M_finish = 0x0, _M_end_of_storage = 0x0}}, <No data fields>}}
shop_manager = {<singleton<CShopManager>> = {
_vptr.singleton = 0x847fa98 <vtable for CShopManager+8>,
static ms_singleton = 0xffffa8ac}, m_map_pkShop = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CShop*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CShop*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffa8b4, _M_right = 0xffffa8b4},
_M_node_count = 0}}}, m_map_pkShopByNPCVnum = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CShop*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CShop*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned i--Type <RET> for more, q to quit, c to continue without paging--
nt, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffa8cc, _M_right = 0xffffa8cc},
_M_node_count = 0}}}, m_map_pkShopByPC = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CShop*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CShop*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffa8e4, _M_right = 0xffffa8e4},
_M_node_count = 0}}}}
guild_manager = {<singleton<CGuildManager>> = {
_vptr.singleton = 0x8451bd0 <vtable for CGuildManager+8>,
static ms_singleton = 0xffffac28}, m_mapGuild = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CGuild*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CGuild*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffac30, _M_right = 0xffffac30},
_M_node_count = 0}}}, m_GuildWar = {_M_t = {
--Type <RET> for more, q to quit, c to continue without paging--
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int, unsigned int> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int, unsigned int> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<std::pair<unsigned int, unsigned int>, std::pair<unsigned int, unsigned int>, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffac48, _M_right = 0xffffac48},
_M_node_count = 0}}}, m_GuildWarEndTime = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<std::pair<unsigned int, unsigned int> const, unsigned int> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<std::pair<unsigned int, unsigned int> const, unsigned int> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<std::pair<unsigned int, unsigned int>, std::pair<unsigned int, unsigned int>, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffac60, _M_right = 0xffffac60},
_M_node_count = 0}}}, m_map_pkGuildByPID = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CGuild*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CGuild*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
--Type <RET> for more, q to quit, c to continue without paging--
_M_left = 0xffffac78, _M_right = 0xffffac78},
_M_node_count = 0}}}, m_map_kReserveWar = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CGuildWarReserveForGame*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CGuildWarReserveForGame*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffac90, _M_right = 0xffffac90},
_M_node_count = 0}}},
m_vec_kReserveWar = {<std::_Vector_base<CGuildWarReserveForGame*, std::allocator<CGuildWarReserveForGame*> >> = {
_M_impl = {<std::allocator<CGuildWarReserveForGame*>> = {<__gnu_cxx::new_allocator<CGuildWarReserveForGame*>> = {<No data fields>}, <No data fields>}, _M_start = 0x0, _M_finish = 0x0,
_M_end_of_storage = 0x0}}, <No data fields>}}
item_addon_manager = {<singleton<CItemAddonManager>> = {
_vptr.singleton = 0x8457f18 <vtable for CItemAddonManager+8>,
static ms_singleton = 0xffffa6b8}, <No data fields>}
Monarch = {<singleton<CMonarch>> = {
_vptr.singleton = 0x845b240 <vtable for CMonarch+8>,
static ms_singleton = 0xffffb2c4}, m_MonarchInfo = {pid = {0, 0,
--Type <RET> for more, q to quit, c to continue without paging--
0, 0}, money = {0, 0, 0, 0}, name = {'\000' <repeats 31 times>,
'\000' <repeats 31 times>, '\000' <repeats 31 times>,
'\000' <repeats 31 times>}, date = {'\000' <repeats 31 times>,
'\000' <repeats 31 times>, '\000' <repeats 31 times>,
'\000' <repeats 31 times>}}, m_PowerUp = {0, 0, 0, 0},
m_DefenseUp = {0, 0, 0, 0}, m_PowerUpCT = {0, 0, 0, 0},
m_DefenseUpCT = {0, 0, 0, 0}}
threeway_war = {<singleton<CThreeWayWar>> = {
_vptr.singleton = 0x846ea58 <vtable for CThreeWayWar+8>,
static ms_singleton = 0xffffb008}, KillScore_ = {0, 0, 0},
RegenFlag_ = 0, MapIndexSet_ = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<int> >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<int> >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<int, int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x28e330c0, _M_left = 0x28e33060,
_M_right = 0x28e331c0}, _M_node_count = 12}}},
PassInfoMap_ = {<std::_Vector_base<ForkedPassMapInfo, std::allocator<ForkedPassMapInfo> >> = {
_M_impl = {<std::allocator<ForkedPassMapInfo>> = {<__gnu_cxx::new_allocator<ForkedPassMapInfo>> = {<No data fields>}, <No data fields>},
_M_start = 0x28e35cc0, _M_finish = 0x28e35d50,
--Type <RET> for more, q to quit, c to continue without paging--
_M_end_of_storage = 0x28e35d80}}, <No data fields>},
SungZiInfoMap_ = {<std::_Vector_base<ForkedSungziMapInfo, std::allocator<ForkedSungziMapInfo> >> = {
_M_impl = {<std::allocator<ForkedSungziMapInfo>> = {<__gnu_cxx::new_allocator<ForkedSungziMapInfo>> = {<No data fields>}, <No data fields>},
_M_start = 0x28e35c00, _M_finish = 0x28e35c6c,
_M_end_of_storage = 0x28e35c90}}, <No data fields>},
RegisterUserMap_ = {
table_ = {<boost::unordered_detail::hash_table<boost::unordered_detail::map<unsigned int, boost::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int> > > >> = {<boost::unordered_detail::hash_buckets<std::allocator<std::pair<unsigned int const, unsigned int> >, boost::unordered_detail::ungrouped>> = {buckets_ = 0x0,
bucket_count_ = 11,
allocators_ = {<boost::details::compressed_pair_imp<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, unsigned int> > > >, std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<unsigned int const, unsigned int> >, boost::unordered_detail::ungrouped> >, 3>> = {<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, unsigned int> > > >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, unsigned int> > > >> = {<No data fields>}, <No data fields>}, <std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<unsign--Type <RET> for more, q to quit, c to continue without paging--
ed int const, unsigned int> >, boost::unordered_detail::ungrouped> >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<unsigned int const, unsigned int> >, boost::unordered_detail::ungrouped> >> = {<No data fields>}, <No data fields>}, <No data fields>}, <No data fields>}}, <boost::unordered_detail::hash_buffered_functions<boost::hash<unsigned int>, std::equal_to<unsigned int> >> = {current_ = false, funcs_ = {{data_ = {buf = "",
align_ = 0 '\000'}}, {data_ = {buf = "",
align_ = 0 '\000'}}}}, size_ = 0, mlf_ = 1,
cached_begin_bucket_ = 0x0,
max_load_ = 0}, <No data fields>}}, ReviveTokenMap_ = {
table_ = {<boost::unordered_detail::hash_table<boost::unordered_detail::map<unsigned int, boost::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, int> > > >> = {<boost::unordered_detail::hash_buckets<std::allocator<std::pair<unsigned int const, int> >, boost::unordered_detail::ungrouped>> = {buckets_ = 0x0, bucket_count_ = 11,
allocators_ = {<boost::details::compressed_pair_imp<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, int> > > >, std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<unsigned int const, int> >, boost::unordered_detail::ungrouped> >, 3>> = {<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, int> > > >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<unsigned int const, int> > > >> = {<No data fields>}, <No data fields>}, <std::allocator<boost::unordered_detai--Type <RET> for more, q to quit, c to continue without paging--
l::hash_node<std::allocator<std::pair<unsigned int const, int> >, boost::unordered_detail::ungrouped> >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<unsigned int const, int> >, boost::unordered_detail::ungrouped> >> = {<No data fields>}, <No data fields>}, <No data fields>}, <No data fields>}}, <boost::unordered_detail::hash_buffered_functions<boost::hash<unsigned int>, std::equal_to<unsigned int> >> = {current_ = false,
funcs_ = {{data_ = {buf = "", align_ = 0 '\000'}}, {data_ = {
buf = "", align_ = 0 '\000'}}}}, size_ = 0, mlf_ = 1,
cached_begin_bucket_ = 0x0, max_load_ = 0}, <No data fields>}}}
mob_manager = {<singleton<CMobManager>> = {
_vptr.singleton = 0x845b088 <vtable for CMobManager+8>,
static ms_singleton = 0xffffabac}, m_map_pkMobByVnum = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CMob*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CMob*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffabb4, _M_right = 0xffffabb4},
_M_node_count = 0}}}, m_map_pkMobByName = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CMob*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<std::basic_string<char--Type <RET> for more, q to quit, c to continue without paging--
, std::char_traits<char>, std::allocator<char> > const, CMob*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffabcc, _M_right = 0xffffabcc},
_M_node_count = 0}}}, m_map_pkMobGroup = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CMobGroup*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CMobGroup*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffabe4,
_M_right = 0xffffabe4}, _M_node_count = 0}}},
m_map_pkMobGroupGroup = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CMobGroupGroup*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CMobGroupGroup*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
--Type <RET> for more, q to quit, c to continue without paging--
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffabfc, _M_right = 0xffffabfc},
_M_node_count = 0}}}, m_mapRegenCount = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, double> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, double> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffac14, _M_right = 0xffffac14},
_M_node_count = 0}}}}
target_manager = {<singleton<CTargetManager>> = {
_vptr.singleton = 0x846d338 <vtable for CTargetManager+8>,
static ms_singleton = 0xffffa798}, m_map_kListEvent = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, std::list<boost::intrusive_ptr<event>, std::allocator<boost::intrusive_ptr<event> > > > > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, std::list<boost::intrusive_ptr<event>, std::allocator<boost::intrusive_ptr<event> > > > > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffa7a0, _M_right = 0xffffa7a0},
--Type <RET> for more, q to quit, c to continue without paging--
_M_node_count = 0}}}, m_iID = 0}
marriage_manager = {<singleton<marriage::CManager>> = {
_vptr.singleton = 0x845a7d0 <vtable for marriage::CManager+8>,
static ms_singleton = 0xffffa948},
m_Marriages = {<std::tr1::__unordered_set<marriage::TMarriage*, std::tr1::hash<marriage::TMarriage*>, std::equal_to<marriage::TMarriage*>, std::allocator<marriage::TMarriage*>, false>> = {<std::tr1::_Hashtable<marriage::TMarriage*, marriage::TMarriage*, std::allocator<marriage::TMarriage*>, std::_Identity<marriage::TMarriage*>, std::equal_to<marriage::TMarriage*>, std::tr1::hash<marriage::TMarriage*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true>> = {<std::tr1::__detail::_Rehash_base<std::tr1::__detail::_Prime_rehash_policy, std::tr1::_Hashtable<marriage::TMarriage*, marriage::TMarriage*, std::allocator<marriage::TMarriage*>, std::_Identity<marriage::TMarriage*>, std::equal_to<marriage::TMarriage*>, std::tr1::hash<marriage::TMarriage*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true> >> = {<No data fields>}, <std::tr1::__detail::_Hash_code_base<marriage::TMarriage*, marriage::TMarriage*, std::_Identity<marriage::TMarriage*>, std::equal_to<marriage::TMarriage*>, std::tr1::hash<marriage::TMarriage*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, false>> = {
_M_extract = {<std::unary_function<marriage::TMarriage*, marriage::TMarriage*>> = {<No data fields>}, <No data fields>},
--Type <RET> for more, q to quit, c to continue without paging--
_M_eq = {<std::binary_function<marriage::TMarriage*, marriage::TMarriage*, bool>> = {<No data fields>}, <No data fields>},
_M_h1 = {<std::unary_function<marriage::TMarriage*, unsigned int>> = {<No data fields>}, <No data fields>},
_M_h2 = {<No data fields>}}, <std::tr1::__detail::_Map_base<marriage::TMarriage*, marriage::TMarriage*, std::_Identity<marriage::TMarriage*>, true, std::tr1::_Hashtable<marriage::TMarriage*, marriage::TMarriage*, std::allocator<marriage::TMarriage*>, std::_Identity<marriage::TMarriage*>, std::equal_to<marriage::TMarriage*>, std::tr1::hash<marriage::TMarriage*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true> >> = {<No data fields>},
_M_node_allocator = {<__gnu_cxx::new_allocator<std::tr1::__detail::_Hash_node<marriage::TMarriage*, false> >> = {<No data fields>}, <No data fields>}, _M_buckets = 0x28c132e0, _M_bucket_count = 11, _M_element_count = 0,
_M_rehash_policy = {_M_max_load_factor = 1,
_M_growth_factor = 2,
_M_next_resize = 11}}, <No data fields>}, <No data fields>},
m_MarriageByPID = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, marriage::TMarriage*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, marriage::TMarriage*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned i--Type <RET> for more, q to quit, c to continue without paging--
nt, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffa970, _M_right = 0xffffa970},
_M_node_count = 0}}}, m_setWedding = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int, unsigned int> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int, unsigned int> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<std::pair<unsigned int, unsigned int>, std::pair<unsigned int, unsigned int>, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffa988, _M_right = 0xffffa988},
_M_node_count = 0}}}}
desc_manager = {<singleton<DESC_MANAGER>> = {
_vptr.singleton = 0x844f3b0 <vtable for DESC_MANAGER+8>,
static ms_singleton = 0xffffb084},
m_bDisconnectInvalidCRC = false, m_map_handle_random_key = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, unsigned int> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, unsigned int> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffb090,
--Type <RET> for more, q to quit, c to continue without paging--
_M_right = 0xffffb090}, _M_node_count = 0}}},
m_set_pkClientDesc = {<std::tr1::__unordered_set<CLIENT_DESC*, std::tr1::hash<CLIENT_DESC*>, std::equal_to<CLIENT_DESC*>, std::allocator<CLIENT_DESC*>, false>> = {<std::tr1::_Hashtable<CLIENT_DESC*, CLIENT_DESC*, std::allocator<CLIENT_DESC*>, std::_Identity<CLIENT_DESC*>, std::equal_to<CLIENT_DESC*>, std::tr1::hash<CLIENT_DESC*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true>> = {<std::tr1::__detail::_Rehash_base<std::tr1::__detail::_Prime_rehash_policy, std::tr1::_Hashtable<CLIENT_DESC*, CLIENT_DESC*, std::allocator<CLIENT_DESC*>, std::_Identity<CLIENT_DESC*>, std::equal_to<CLIENT_DESC*>, std::tr1::hash<CLIENT_DESC*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true> >> = {<No data fields>}, <std::tr1::__detail::_Hash_code_base<CLIENT_DESC*, CLIENT_DESC*, std::_Identity<CLIENT_DESC*>, std::equal_to<CLIENT_DESC*>, std::tr1::hash<CLIENT_DESC*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, false>> = {
_M_extract = {<std::unary_function<CLIENT_DESC*, CLIENT_DESC*>> = {<No data fields>}, <No data fields>},
_M_eq = {<std::binary_function<CLIENT_DESC*, CLIENT_DESC*, bool>> = {<No data fields>}, <No data fields>},
_M_h1 = {<std::unary_function<CLIENT_DESC*, unsigned int>> = {<No data fields>}, <No data fields>},
_M_h2 = {<No data fields>}}, <std::tr1::__detail::_Map_base<CL--Type <RET> for more, q to quit, c to continue without paging--
IENT_DESC*, CLIENT_DESC*, std::_Identity<CLIENT_DESC*>, true, std::tr1::_Hashtable<CLIENT_DESC*, CLIENT_DESC*, std::allocator<CLIENT_DESC*>, std::_Identity<CLIENT_DESC*>, std::equal_to<CLIENT_DESC*>, std::tr1::hash<CLIENT_DESC*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true> >> = {<No data fields>},
_M_node_allocator = {<__gnu_cxx::new_allocator<std::tr1::__detail::_Hash_node<CLIENT_DESC*, false> >> = {<No data fields>}, <No data fields>},
_M_buckets = 0x28c13310, _M_bucket_count = 11,
_M_element_count = 1, _M_rehash_policy = {
_M_max_load_factor = 1, _M_growth_factor = 2,
_M_next_resize = 11}}, <No data fields>}, <No data fields>},
m_set_pkDesc = {<std::tr1::__unordered_set<DESC*, std::tr1::hash<DESC*>, std::equal_to<DESC*>, std::allocator<DESC*>, false>> = {<std::tr1::_Hashtable<DESC*, DESC*, std::allocator<DESC*>, std::_Identity<DESC*>, std::equal_to<DESC*>, std::tr1::hash<DESC*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true>> = {<std::tr1::__detail::_Rehash_base<std::tr1::__detail::_Prime_rehash_policy, std::tr1::_Hashtable<DESC*, DESC*, std::allocator<DESC*>, std::_Identity<DESC*>, std::equal_to<DESC*>, std::tr1::hash<DESC*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true> >> = {<No data fields>}, <std::tr1::__detail::_Hash_code_base<DESC*, DESC*, std::_Identity<DESC*>, std::equal_to<DESC*>, std::tr1::hash<DESC*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail--Type <RET> for more, q to quit, c to continue without paging--
::_Default_ranged_hash, false>> = {
_M_extract = {<std::unary_function<DESC*, DESC*>> = {<No data fields>}, <No data fields>},
_M_eq = {<std::binary_function<DESC*, DESC*, bool>> = {<No data fields>}, <No data fields>},
_M_h1 = {<std::unary_function<DESC*, unsigned int>> = {<No data fields>}, <No data fields>},
_M_h2 = {<No data fields>}}, <std::tr1::__detail::_Map_base<DESC*, DESC*, std::_Identity<DESC*>, true, std::tr1::_Hashtable<DESC*, DESC*, std::allocator<DESC*>, std::_Identity<DESC*>, std::equal_to<DESC*>, std::tr1::hash<DESC*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true> >> = {<No data fields>},
_M_node_allocator = {<__gnu_cxx::new_allocator<std::tr1::__detail::_Hash_node<DESC*, false> >> = {<No data fields>}, <No data fields>},
_M_buckets = 0x28c13340, _M_bucket_count = 11,
_M_element_count = 1, _M_rehash_policy = {
_M_max_load_factor = 1, _M_growth_factor = 2,
_M_next_resize = 11}}, <No data fields>}, <No data fields>},
m_map_handle = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<int const, DESC*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<int const, DESC*> > >> = {<No data fields>}, <No data fields>},
--Type <RET> for more, q to quit, c to continue without paging--
_M_key_compare = {<std::binary_function<int, int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffb0e8,
_M_right = 0xffffb0e8}, _M_node_count = 0}}},
m_map_handshake = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, DESC*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, DESC*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffb100, _M_right = 0xffffb100},
_M_node_count = 0}}}, m_map_loginName = {
table_ = {<boost::unordered_detail::hash_table<boost::unordered_detail::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, boost::hash<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::equal_to<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, DESC*> > > >> = {<boost::unordered_detail::hash_buckets<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, DESC*> >, boost::unordered_detail::ungrouped>> = {buckets_ = 0x2916e9a0, bucket_count_ = 11,
allocators_ = {<boost::details::compressed_pair_imp<std::alloc--Type <RET> for more, q to quit, c to continue without paging--
ator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, DESC*> > > >, std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, DESC*> >, boost::unordered_detail::ungrouped> >, 3>> = {<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, DESC*> > > >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, DESC*> > > >> = {<No data fields>}, <No data fields>}, <std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, DESC*> >, boost::unordered_detail::ungrouped> >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, DESC*> >, boost::unordered_detail::ungrouped> >> = {<No data fields>}, <No data fields>}, <No data fields>}, <No data fields>}}, <boost::unordered_detail::hash_buffered_functions<boost::hash<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::equal_to<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >> = {current_ = false, funcs_ = {{
data_ = {buf = "", align_ = 0 '\000'}}, {data_ = {
buf = "", align_ = 0 '\000'}}}}, size_ = 0, mlf_ = 1,
cached_begin_bucket_ = 0x2916e9cc,
max_load_ = 11}, <No data fields>}}, m_map_pkLoginKey = {
--Type <RET> for more, q to quit, c to continue without paging--
_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CLoginKey*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CLoginKey*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffb134,
_M_right = 0xffffb134}, _M_node_count = 0}}},
m_iSocketsConnected = 1, m_iHandleCount = 31, m_iLocalUserCount = 0,
m_aiEmpireUserCount = {0, 0, 0, 0}, m_bDestroyed = false,
m_pPackageCrypt = 0x28c13370}
spam_mgr = {<singleton<SpamManager>> = {
_vptr.singleton = 0x8481580 <vtable for SpamManager+8>,
static ms_singleton = 0xffffa6e4},
m_vec_word = {<std::_Vector_base<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int>, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int> > >> = {
_M_impl = {<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int> >> = {<__gnu_cxx::new_allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int> >> = {<No data fields>}, <No data fields>},
--Type <RET> for more, q to quit, c to continue without paging--
_M_start = 0x0, _M_finish = 0x0,
_M_end_of_storage = 0x0}}, <No data fields>}}
strPackageCryptInfoDir = {static npos = <optimized out>,
_M_dataplus = {<std::allocator<char>> = {<__gnu_cxx::new_allocator<char>> = {<No data fields>}, <No data fields>}, _M_p = 0x29edc40c "package/"}}
item_manager = {<singleton<ITEM_MANAGER>> = {
_vptr.singleton = 0x8458818 <vtable for ITEM_MANAGER+8>,
static ms_singleton = 0xffffacb0},
m_vec_prototype = {<std::_Vector_base<SItemTable, std::allocator<SItemTable> >> = {
_M_impl = {<std::allocator<SItemTable>> = {<__gnu_cxx::new_allocator<SItemTable>> = {<No data fields>}, <No data fields>}, _M_start = 0x0,
_M_finish = 0x0, _M_end_of_storage = 0x0}}, <No data fields>},
m_vec_item_vnum_range_info = {<std::_Vector_base<SItemTable*, std::allocator<SItemTable*> >> = {
_M_impl = {<std::allocator<SItemTable*>> = {<__gnu_cxx::new_allocator<SItemTable*>> = {<No data fields>}, <No data fields>}, _M_start = 0x0,
_M_finish = 0x0, _M_end_of_storage = 0x0}}, <No data fields>},
m_map_ItemRefineFrom = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, unsigned int> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, unsigned int> > >> = {<No data fields>}, <No data fields>},
--Type <RET> for more, q to quit, c to continue without paging--
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffacd0,
_M_right = 0xffffacd0}, _M_node_count = 0}}},
m_iTopOfTable = 0, m_VIDMap = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CItem*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CItem*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffacec, _M_right = 0xffffacec},
_M_node_count = 0}}}, m_dwVIDCount = 0, m_dwCurrentID = 0,
m_ItemIDRange = {dwMin = 0, dwMax = 0, dwUsableItemIDMin = 0},
m_ItemIDSpareRange = {dwMin = 0, dwMax = 0, dwUsableItemIDMin = 0},
m_set_pkItemForDelayedSave = {<std::tr1::__unordered_set<CItem*, std::tr1::hash<CItem*>, std::equal_to<CItem*>, std::allocator<CItem*>, false>> = {<std::tr1::_Hashtable<CItem*, CItem*, std::allocator<CItem*>, std::_Identity<CItem*>, std::equal_to<CItem*>, std::tr1::hash<CItem*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true>> = {<std::tr1::__detail::_Rehash_base<std::tr1::__detail::_Prime_rehash_policy, std::tr1::_Hashtable<CItem*, CItem*, std::allocator<CItem*>, std::_Identity<CItem*>, std::equal_to<CItem*>, std::tr1::hash<CIte--Type <RET> for more, q to quit, c to continue without paging--
m*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true> >> = {<No data fields>}, <std::tr1::__detail::_Hash_code_base<CItem*, CItem*, std::_Identity<CItem*>, std::equal_to<CItem*>, std::tr1::hash<CItem*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, false>> = {
_M_extract = {<std::unary_function<CItem*, CItem*>> = {<No data fields>}, <No data fields>},
_M_eq = {<std::binary_function<CItem*, CItem*, bool>> = {<No data fields>}, <No data fields>},
_M_h1 = {<std::unary_function<CItem*, unsigned int>> = {<No data fields>}, <No data fields>},
_M_h2 = {<No data fields>}}, <std::tr1::__detail::_Map_base<CItem*, CItem*, std::_Identity<CItem*>, true, std::tr1::_Hashtable<CItem*, CItem*, std::allocator<CItem*>, std::_Identity<CItem*>, std::equal_to<CItem*>, std::tr1::hash<CItem*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true> >> = {<No data fields>},
_M_node_allocator = {<__gnu_cxx::new_allocator<std::tr1::__detail::_Hash_node<CItem*, false> >> = {<No data fields>}, <No data fields>},
_M_buckets = 0x28c13280, _M_bucket_count = 11,
_M_element_count = 0, _M_rehash_policy = {
_M_max_load_factor = 1, _M_growth_factor = 2,
_M_next_resize = 11}}, <No data fields>}, <No data fields>},
--Type <RET> for more, q to quit, c to continue without paging--
m_map_pkItemByID = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CItem*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CItem*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffad44, _M_right = 0xffffad44},
_M_node_count = 0}}}, m_map_dwEtcItemDropProb = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, unsigned int> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, unsigned int> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffad5c,
_M_right = 0xffffad5c}, _M_node_count = 0}}},
m_map_pkDropItemGroup = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CDropItemGroup*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CDropItemGroup*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, --Type <RET> for more, q to quit, c to continue without paging--
bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffad74, _M_right = 0xffffad74},
_M_node_count = 0}}}, m_map_pkSpecialItemGroup = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CSpecialItemGroup*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CSpecialItemGroup*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffad8c, _M_right = 0xffffad8c},
_M_node_count = 0}}}, m_map_pkQuestItemGroup = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CSpecialItemGroup*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CSpecialItemGroup*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffada4, _M_right = 0xffffada4},
_M_node_count = 0}}}, m_map_pkSpecialAttrGroup = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned i--Type <RET> for more, q to quit, c to continue without paging--
nt const, CSpecialAttrGroup*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CSpecialAttrGroup*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffadbc, _M_right = 0xffffadbc},
_M_node_count = 0}}}, m_map_pkMobItemGroup = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CMobItemGroup*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CMobItemGroup*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffadd4, _M_right = 0xffffadd4},
_M_node_count = 0}}}, m_map_pkLevelItemGroup = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CLevelItemGroup*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CLevelItemGroup*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
--Type <RET> for more, q to quit, c to continue without paging--
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffadec, _M_right = 0xffffadec},
_M_node_count = 0}}}, m_map_pkGloveItemGroup = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CBuyerThiefGlovesItemGroup*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CBuyerThiefGlovesItemGroup*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffae04, _M_right = 0xffffae04},
_M_node_count = 0}}}, m_ItemToSpecialGroup = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, int> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, int> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffae1c, _M_right = 0xffffae1c},
_M_node_count = 0}}}, m_map_new_to_ori = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, unsigned int> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, unsigned int> > >> = {<No data fields>}, <No data fie--Type <RET> for more, q to quit, c to continue without paging--
lds>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffae34,
_M_right = 0xffffae34}, _M_node_count = 0}}}, m_map_vid = {
_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, SItemTable> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, SItemTable> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffae4c,
_M_right = 0xffffae4c}, _M_node_count = 0}}},
static MAX_NORM_ATTR_NUM = 5, static MAX_RARE_ATTR_NUM = 2}
messenger_manager = {<singleton<MessengerManager>> = {
_vptr.singleton = 0x845ab80 <vtable for MessengerManager+8>,
static ms_singleton = 0xffffa9f8}, m_set_loginAccount = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<std::basic_string<char, --Type <RET> for more, q to quit, c to continue without paging--
std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffaa00, _M_right = 0xffffaa00},
_M_node_count = 0}}}, m_Relation = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, std::set<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > > > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, std::set<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > > > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffaa18, _M_right = 0xffffaa18},
_M_node_count = 0}}}, m_InverseRelation = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<std::basic--Type <RET> for more, q to quit, c to continue without paging--
_string<char, std::char_traits<char>, std::allocator<char> > const, std::set<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > > > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, std::set<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > > > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffaa30, _M_right = 0xffffaa30},
_M_node_count = 0}}}, m_set_requestToAdd = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<unsigned int> >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<unsigned int> >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffaa48, _M_right = 0xffffaa48},
--Type <RET> for more, q to quit, c to continue without paging--
_M_node_count = 0}}}}
dungeon_manager = {<singleton<CDungeonManager>> = {
_vptr.singleton = 0x844fb90 <vtable for CDungeonManager+8>,
static ms_singleton = 0xffffa874}, m_map_pkDungeon = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, CDungeon*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CDungeon*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffa87c,
_M_right = 0xffffa87c}, _M_node_count = 0}}},
m_map_pkMapDungeon = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<long const, CDungeon*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<long const, CDungeon*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<long, long, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffa894,
_M_right = 0xffffa894}, _M_node_count = 0}}}, next_id_ = 0}
banword_manager = {<singleton<CBanwordManager>> = {
_vptr.singleton = 0x843d0c0 <vtable for CBanwordManager+8>,
static ms_singleton = 0xffffae60}, m_hashmap_words = {
--Type <RET> for more, q to quit, c to continue without paging--
table_ = {<boost::unordered_detail::hash_table<boost::unordered_detail::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, boost::hash<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::equal_to<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, bool> > > >> = {<boost::unordered_detail::hash_buckets<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, bool> >, boost::unordered_detail::ungrouped>> = {buckets_ = 0x0, bucket_count_ = 11,
allocators_ = {<boost::details::compressed_pair_imp<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, bool> > > >, std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, bool> >, boost::unordered_detail::ungrouped> >, 3>> = {<std::allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, bool> > > >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_bucket<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, bool> > > >> = {<No data fields>}, <No data fields>}, <std::allocator<boost::unordered_detail::hash_node<std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, bool> >, boost::unordered_detail::ungrouped> >> = {<__gnu_cxx::new_allocator<boost::unordered_detail::hash_node<std::allocator<s--Type <RET> for more, q to quit, c to continue without paging--
td::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, bool> >, boost::unordered_detail::ungrouped> >> = {<No data fields>}, <No data fields>}, <No data fields>}, <No data fields>}}, <boost::unordered_detail::hash_buffered_functions<boost::hash<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::equal_to<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >> = {current_ = false, funcs_ = {{
data_ = {buf = "", align_ = 0 '\000'}}, {data_ = {
buf = "", align_ = 0 '\000'}}}}, size_ = 0, mlf_ = 1,
cached_begin_bucket_ = 0x0, max_load_ = 0}, <No data fields>}}}
building_manager = {<singleton<building::CManager>> = {
_vptr.singleton = 0x843db18 <vtable for building::CManager+8>,
static ms_singleton = 0xffffaac4},
m_vec_kObjectProto = {<std::_Vector_base<building::SObjectProto, std::allocator<building::SObjectProto> >> = {
_M_impl = {<std::allocator<building::SObjectProto>> = {<__gnu_cxx::new_allocator<building::SObjectProto>> = {<No data fields>}, <No data fields>}, _M_start = 0x0, _M_finish = 0x0,
_M_end_of_storage = 0x0}}, <No data fields>},
m_map_pkObjectProto = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, building::SObjectProto*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, building::SObjectProto*> > >> = {<No data fields>}, <No data fields>},
--Type <RET> for more, q to quit, c to continue without paging--
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffaad8, _M_right = 0xffffaad8},
_M_node_count = 0}}}, m_map_pkLand = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, building::CLand*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, building::CLand*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffaaf0, _M_right = 0xffffaaf0},
_M_node_count = 0}}}, m_map_pkObjByID = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, building::CObject*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, building::CObject*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffab08, _M_right = 0xffffab08},
_M_node_count = 0}}}, m_map_pkObjByVID = {_M_t = {
--Type <RET> for more, q to quit, c to continue without paging--
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, building::CObject*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, building::CObject*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffab20, _M_right = 0xffffab20},
_M_node_count = 0}}}}
char_manager = {<singleton<CHARACTER_MANAGER>> = {
_vptr.singleton = 0x8444c30 <vtable for CHARACTER_MANAGER+8>,
static ms_singleton = 0xffffbe94}, m_iMobItemRate = 100,
m_iMobDamageRate = 100, m_iMobGoldAmountRate = 100,
m_iMobGoldDropRate = 100, m_iMobExpRate = 100,
m_iMobItemRatePremium = 100, m_iMobGoldAmountRatePremium = 100,
m_iMobGoldDropRatePremium = 100, m_iMobExpRatePremium = 100,
m_iUserDamageRate = 100, m_iUserDamageRatePremium = 100,
m_iVIDCount = 0,
m_map_pkChrByVID = {<std::tr1::__unordered_map<unsigned int, CHARACTER*, std::tr1::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, CHARACTER*> >, false>> = {<std::tr1::_Hashtable<unsigned int, std::pair<unsigned int const, CHARACTER*>, std::allocator<std::pair<unsigned int const, CHARACTER*> >, std::_Select1st<std::pair<unsigned int const, CH--Type <RET> for more, q to quit, c to continue without paging--
ARACTER*> >, std::equal_to<unsigned int>, std::tr1::hash<unsigned int>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, false, true>> = {<std::tr1::__detail::_Rehash_base<std::tr1::__detail::_Prime_rehash_policy, std::tr1::_Hashtable<unsigned int, std::pair<unsigned int const, CHARACTER*>, std::allocator<std::pair<unsigned int const, CHARACTER*> >, std::_Select1st<std::pair<unsigned int const, CHARACTER*> >, std::equal_to<unsigned int>, std::tr1::hash<unsigned int>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, false, true> >> = {<No data fields>}, <std::tr1::__detail::_Hash_code_base<unsigned int, std::pair<unsigned int const, CHARACTER*>, std::_Select1st<std::pair<unsigned int const, CHARACTER*> >, std::equal_to<unsigned int>, std::tr1::hash<unsigned int>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, false>> = {
_M_extract = {<std::unary_function<std::pair<unsigned int const, CHARACTER*>, unsigned int const>> = {<No data fields>}, <No data fields>},
_M_eq = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>},
_M_h1 = {<std::unary_function<unsigned int, unsigned int>> = {<No data fields>}, <No data fields>},
_M_h2 = {<No data fields>}}, <std::tr1::__detail::_Map_base<unsigned int, std::pair<unsigned int const, CHARACTER*>, std::_Select1st<std::pair<unsigned int const, CHARACTER*> >, true, std::tr1::_Hashtable<unsigned int, std::pair<unsigned int const, CHARACTER*>, std::allocator<std::pair<unsigned int co--Type <RET> for more, q to quit, c to continue without paging--
nst, CHARACTER*> >, std::_Select1st<std::pair<unsigned int const, CHARACTER*> >, std::equal_to<unsigned int>, std::tr1::hash<unsigned int>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, false, true> >> = {<No data fields>},
_M_node_allocator = {<__gnu_cxx::new_allocator<std::tr1::__detail::_Hash_node<std::pair<unsigned int const, CHARACTER*>, false> >> = {<No data fields>}, <No data fields>}, _M_buckets = 0x28c13130, _M_bucket_count = 11,
_M_element_count = 0, _M_rehash_policy = {
_M_max_load_factor = 1, _M_growth_factor = 2,
_M_next_resize = 11}}, <No data fields>}, <No data fields>},
m_map_pkChrByPID = {<std::tr1::__unordered_map<unsigned int, CHARACTER*, std::tr1::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, CHARACTER*> >, false>> = {<std::tr1::_Hashtable<unsigned int, std::pair<unsigned int const, CHARACTER*>, std::allocator<std::pair<unsigned int const, CHARACTER*> >, std::_Select1st<std::pair<unsigned int const, CHARACTER*> >, std::equal_to<unsigned int>, std::tr1::hash<unsigned int>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, false, true>> = {<std::tr1::__detail::_Rehash_base<std::tr1::__detail::_Prime_rehash_policy, std::tr1::_Hashtable<unsigned int, std::pair<unsigned int const, CHARACTER*>, std::allocator<std::pair<unsigned int const, CHARACTER*> >, std::_Select1st<std::pair<unsigned int const, CHARACTER*> >, std::equal_to<unsigned int>, std::tr1::hash<unsigned int>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std:--Type <RET> for more, q to quit, c to continue without paging--
:tr1::__detail::_Prime_rehash_policy, false, false, true> >> = {<No data fields>}, <std::tr1::__detail::_Hash_code_base<unsigned int, std::pair<unsigned int const, CHARACTER*>, std::_Select1st<std::pair<unsigned int const, CHARACTER*> >, std::equal_to<unsigned int>, std::tr1::hash<unsigned int>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, false>> = {
_M_extract = {<std::unary_function<std::pair<unsigned int const, CHARACTER*>, unsigned int const>> = {<No data fields>}, <No data fields>},
_M_eq = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>},
_M_h1 = {<std::unary_function<unsigned int, unsigned int>> = {<No data fields>}, <No data fields>},
_M_h2 = {<No data fields>}}, <std::tr1::__detail::_Map_base<unsigned int, std::pair<unsigned int const, CHARACTER*>, std::_Select1st<std::pair<unsigned int const, CHARACTER*> >, true, std::tr1::_Hashtable<unsigned int, std::pair<unsigned int const, CHARACTER*>, std::allocator<std::pair<unsigned int const, CHARACTER*> >, std::_Select1st<std::pair<unsigned int const, CHARACTER*> >, std::equal_to<unsigned int>, std::tr1::hash<unsigned int>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, false, true> >> = {<No data fields>},
_M_node_allocator = {<__gnu_cxx::new_allocator<std::tr1::__detail::_Hash_node<std::pair<unsigned int const, CHARACTER*>, false> >> = {<No data fields>}, <No data fields>}, _M_buckets = 0x28c13160, _M_bucket_count = 11,
_M_element_count = 0, _M_rehash_policy = {
--Type <RET> for more, q to quit, c to continue without paging--
_M_max_load_factor = 1, _M_growth_factor = 2,
_M_next_resize = 11}}, <No data fields>}, <No data fields>},
m_map_pkPCChr = {<std::tr1::__unordered_map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, CHARACTER*, std::tr1::hash<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::equal_to<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CHARACTER*> >, false>> = {<std::tr1::_Hashtable<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CHARACTER*>, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CHARACTER*> >, std::_Select1st<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CHARACTER*> >, std::equal_to<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::tr1::hash<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, false, true>> = {<std::tr1::__detail::_Rehash_base<std::tr1::__detail::_Prime_rehash_policy, std::tr1::_Hashtable<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CHARACTER*>, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CHARACTER*> >, std::_Select1st<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<ch--Type <RET> for more, q to quit, c to continue without paging--
ar> > const, CHARACTER*> >, std::equal_to<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::tr1::hash<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, false, true> >> = {<No data fields>}, <std::tr1::__detail::_Hash_code_base<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CHARACTER*>, std::_Select1st<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CHARACTER*> >, std::equal_to<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::tr1::hash<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, false>> = {
_M_extract = {<std::unary_function<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CHARACTER*>, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const>> = {<No data fields>}, <No data fields>},
_M_eq = {<std::binary_function<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool>> = {<No data fields>}, <No data fields>},
_M_h1 = {<std::unary_function<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int>> = {<No data fields>}, <No data fields>},
--Type <RET> for more, q to quit, c to continue without paging--
_M_h2 = {<No data fields>}}, <std::tr1::__detail::_Map_base<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CHARACTER*>, std::_Select1st<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CHARACTER*> >, true, std::tr1::_Hashtable<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CHARACTER*>, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CHARACTER*> >, std::_Select1st<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CHARACTER*> >, std::equal_to<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::tr1::hash<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, false, true> >> = {<No data fields>},
_M_node_allocator = {<__gnu_cxx::new_allocator<std::tr1::__detail::_Hash_node<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, CHARACTER*>, false> >> = {<No data fields>}, <No data fields>}, _M_buckets = 0x28c13190, _M_bucket_count = 11, _M_element_count = 0,
_M_rehash_policy = {_M_max_load_factor = 1,
_M_growth_factor = 2,
_M_next_resize = 11}}, <No data fields>}, <No data fields>},
dummy1 = '\000' <repeats 1023 times>,
--Type <RET> for more, q to quit, c to continue without paging--
m_set_pkChrState = {<std::tr1::__unordered_set<CHARACTER*, std::tr1::hash<CHARACTER*>, std::equal_to<CHARACTER*>, std::allocator<CHARACTER*>, false>> = {<std::tr1::_Hashtable<CHARACTER*, CHARACTER*, std::allocator<CHARACTER*>, std::_Identity<CHARACTER*>, std::equal_to<CHARACTER*>, std::tr1::hash<CHARACTER*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true>> = {<std::tr1::__detail::_Rehash_base<std::tr1::__detail::_Prime_rehash_policy, std::tr1::_Hashtable<CHARACTER*, CHARACTER*, std::allocator<CHARACTER*>, std::_Identity<CHARACTER*>, std::equal_to<CHARACTER*>, std::tr1::hash<CHARACTER*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true> >> = {<No data fields>}, <std::tr1::__detail::_Hash_code_base<CHARACTER*, CHARACTER*, std::_Identity<CHARACTER*>, std::equal_to<CHARACTER*>, std::tr1::hash<CHARACTER*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, false>> = {
_M_extract = {<std::unary_function<CHARACTER*, CHARACTER*>> = {<No data fields>}, <No data fields>},
_M_eq = {<std::binary_function<CHARACTER*, CHARACTER*, bool>> = {<No data fields>}, <No data fields>},
_M_h1 = {<std::unary_function<CHARACTER*, unsigned int>> = {<No data fields>}, <No data fields>},
_M_h2 = {<No data fields>}}, <std::tr1::__detail::_Map_base<CHARACTER*, CHARACTER*, std::_Identity<CHARACTER*>, true, std::tr1::_Hashtable<CHARACTER*, CHARACTER*, std::allocator<CHARACTER*>, std::_Identity<CHARACTER*>, std--Type <RET> for more, q to quit, c to continue without paging--
::equal_to<CHARACTER*>, std::tr1::hash<CHARACTER*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true> >> = {<No data fields>},
_M_node_allocator = {<__gnu_cxx::new_allocator<std::tr1::__detail::_Hash_node<CHARACTER*, false> >> = {<No data fields>}, <No data fields>},
_M_buckets = 0x28c131c0, _M_bucket_count = 11,
_M_element_count = 0, _M_rehash_policy = {
_M_max_load_factor = 1, _M_growth_factor = 2,
_M_next_resize = 11}}, <No data fields>}, <No data fields>},
m_set_pkChrForDelayedSave = {<std::tr1::__unordered_set<CHARACTER*, std::tr1::hash<CHARACTER*>, std::equal_to<CHARACTER*>, std::allocator<CHARACTER*>, false>> = {<std::tr1::_Hashtable<CHARACTER*, CHARACTER*, std::allocator<CHARACTER*>, std::_Identity<CHARACTER*>, std::equal_to<CHARACTER*>, std::tr1::hash<CHARACTER*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true>> = {<std::tr1::__detail::_Rehash_base<std::tr1::__detail::_Prime_rehash_policy, std::tr1::_Hashtable<CHARACTER*, CHARACTER*, std::allocator<CHARACTER*>, std::_Identity<CHARACTER*>, std::equal_to<CHARACTER*>, std::tr1::hash<CHARACTER*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true> >> = {<No data fields>}, <std::tr1::__detail::_Hash_code_base<CHARACTER*, CHARACTER*, std::_Identity<CHARACTER*>, std::equal_to<CHARACTER*>, std::tr1::hash<CHARACTER*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, false>> = {
--Type <RET> for more, q to quit, c to continue without paging--
_M_extract = {<std::unary_function<CHARACTER*, CHARACTER*>> = {<No data fields>}, <No data fields>},
_M_eq = {<std::binary_function<CHARACTER*, CHARACTER*, bool>> = {<No data fields>}, <No data fields>},
_M_h1 = {<std::unary_function<CHARACTER*, unsigned int>> = {<No data fields>}, <No data fields>},
_M_h2 = {<No data fields>}}, <std::tr1::__detail::_Map_base<CHARACTER*, CHARACTER*, std::_Identity<CHARACTER*>, true, std::tr1::_Hashtable<CHARACTER*, CHARACTER*, std::allocator<CHARACTER*>, std::_Identity<CHARACTER*>, std::equal_to<CHARACTER*>, std::tr1::hash<CHARACTER*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true> >> = {<No data fields>},
_M_node_allocator = {<__gnu_cxx::new_allocator<std::tr1::__detail::_Hash_node<CHARACTER*, false> >> = {<No data fields>}, <No data fields>},
_M_buckets = 0x28c131f0, _M_bucket_count = 11,
_M_element_count = 0, _M_rehash_policy = {
_M_max_load_factor = 1, _M_growth_factor = 2,
_M_next_resize = 11}}, <No data fields>}, <No data fields>},
m_set_pkChrMonsterLog = {<std::tr1::__unordered_set<CHARACTER*, std::tr1::hash<CHARACTER*>, std::equal_to<CHARACTER*>, std::allocator<CHARACTER*>, false>> = {<std::tr1::_Hashtable<CHARACTER*, CHARACTER*, std::allocator<CHARACTER*>, std::_Identity<CHARACTER*>, std::equal_to<CHARACTER*>, std::tr1::hash<CHARACTER*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged--Type <RET> for more, q to quit, c to continue without paging--
_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true>> = {<std::tr1::__detail::_Rehash_base<std::tr1::__detail::_Prime_rehash_policy, std::tr1::_Hashtable<CHARACTER*, CHARACTER*, std::allocator<CHARACTER*>, std::_Identity<CHARACTER*>, std::equal_to<CHARACTER*>, std::tr1::hash<CHARACTER*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true> >> = {<No data fields>}, <std::tr1::__detail::_Hash_code_base<CHARACTER*, CHARACTER*, std::_Identity<CHARACTER*>, std::equal_to<CHARACTER*>, std::tr1::hash<CHARACTER*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, false>> = {
_M_extract = {<std::unary_function<CHARACTER*, CHARACTER*>> = {<No data fields>}, <No data fields>},
_M_eq = {<std::binary_function<CHARACTER*, CHARACTER*, bool>> = {<No data fields>}, <No data fields>},
_M_h1 = {<std::unary_function<CHARACTER*, unsigned int>> = {<No data fields>}, <No data fields>},
_M_h2 = {<No data fields>}}, <std::tr1::__detail::_Map_base<CHARACTER*, CHARACTER*, std::_Identity<CHARACTER*>, true, std::tr1::_Hashtable<CHARACTER*, CHARACTER*, std::allocator<CHARACTER*>, std::_Identity<CHARACTER*>, std::equal_to<CHARACTER*>, std::tr1::hash<CHARACTER*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true> >> = {<No data fields>},
_M_node_allocator = {<__gnu_cxx::new_allocator<std::tr1::__detail::_Hash_node<CHARACTER*, false> >> = {<No data fields>}, <No data fields>},
--Type <RET> for more, q to quit, c to continue without paging--
_M_buckets = 0x28c13220, _M_bucket_count = 11,
_M_element_count = 0, _M_rehash_policy = {
_M_max_load_factor = 1, _M_growth_factor = 2,
_M_next_resize = 11}}, <No data fields>}, <No data fields>},
m_pkChrSelectedStone = 0x0, m_map_dwMobKillCount = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, unsigned int> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, unsigned int> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffc390,
_M_right = 0xffffc390}, _M_node_count = 0}}},
m_set_dwRegisteredRaceNum = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<unsigned int> >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<unsigned int> >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x28c0d340,
_M_left = 0x28c0d320, _M_right = 0x28c0d360},
_M_node_count = 3}}}, m_map_pkChrByRaceNum = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned i--Type <RET> for more, q to quit, c to continue without paging--
nt const, std::tr1::unordered_set<CHARACTER*, std::tr1::hash<CHARACTER*>, std::equal_to<CHARACTER*>, std::allocator<CHARACTER*> > > > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, std::tr1::unordered_set<CHARACTER*, std::tr1::hash<CHARACTER*>, std::equal_to<CHARACTER*>, std::allocator<CHARACTER*> > > > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffc3c0, _M_right = 0xffffc3c0},
_M_node_count = 0}}}, m_bUsePendingDestroy = false,
m_set_pkChrPendingDestroy = {<std::tr1::__unordered_set<CHARACTER*, std::tr1::hash<CHARACTER*>, std::equal_to<CHARACTER*>, std::allocator<CHARACTER*>, false>> = {<std::tr1::_Hashtable<CHARACTER*, CHARACTER*, std::allocator<CHARACTER*>, std::_Identity<CHARACTER*>, std::equal_to<CHARACTER*>, std::tr1::hash<CHARACTER*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true>> = {<std::tr1::__detail::_Rehash_base<std::tr1::__detail::_Prime_rehash_policy, std::tr1::_Hashtable<CHARACTER*, CHARACTER*, std::allocator<CHARACTER*>, std::_Identity<CHARACTER*>, std::equal_to<CHARACTER*>, std::tr1::hash<CHARACTER*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true> >> = {<No data fields>}, <std::tr1::__detail::_Hash_code_base<CHARACTER*, CHARACTER*, std::_Identity<CHARACTER*>, std::equal_to<CHARACTER*>, std::tr1::hash<CHARACTER*>, std::tr1::__detail::--Type <RET> for more, q to quit, c to continue without paging--
_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, false>> = {
_M_extract = {<std::unary_function<CHARACTER*, CHARACTER*>> = {<No data fields>}, <No data fields>},
_M_eq = {<std::binary_function<CHARACTER*, CHARACTER*, bool>> = {<No data fields>}, <No data fields>},
_M_h1 = {<std::unary_function<CHARACTER*, unsigned int>> = {<No data fields>}, <No data fields>},
_M_h2 = {<No data fields>}}, <std::tr1::__detail::_Map_base<CHARACTER*, CHARACTER*, std::_Identity<CHARACTER*>, true, std::tr1::_Hashtable<CHARACTER*, CHARACTER*, std::allocator<CHARACTER*>, std::_Identity<CHARACTER*>, std::equal_to<CHARACTER*>, std::tr1::hash<CHARACTER*>, std::tr1::__detail::_Mod_range_hashing, std::tr1::__detail::_Default_ranged_hash, std::tr1::__detail::_Prime_rehash_policy, false, true, true> >> = {<No data fields>},
_M_node_allocator = {<__gnu_cxx::new_allocator<std::tr1::__detail::_Hash_node<CHARACTER*, false> >> = {<No data fields>}, <No data fields>},
_M_buckets = 0x28c13250, _M_bucket_count = 11,
_M_element_count = 0, _M_rehash_policy = {
_M_max_load_factor = 1, _M_growth_factor = 2,
_M_next_resize = 11}}, <No data fields>}, <No data fields>}}
motion_manager = {<singleton<CMotionManager>> = {
_vptr.singleton = 0x845b818 <vtable for CMotionManager+8>,
static ms_singleton = 0xffffa7d8}, m_map_pkMotionSet = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned i--Type <RET> for more, q to quit, c to continue without paging--
nt const, CMotionSet*> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, CMotionSet*> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {_M_color = std::_S_red,
_M_parent = 0x0, _M_left = 0xffffa7e0,
_M_right = 0xffffa7e0}, _M_node_count = 0}}},
m_map_normalAttackDuration = {_M_t = {
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned int const, float> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned int const, float> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned int, unsigned int, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffa7f8, _M_right = 0xffffa7f8},
_M_node_count = 0}}}}
log_manager = {<singleton<LogManager>> = {
_vptr.singleton = 0x845a440 <vtable for LogManager+8>,
static ms_singleton = 0xffffba04}, m_sql = <incomplete type>,
m_bIsConnect = true}
pcbang_manager = {<singleton<CPCBangManager>> = {
_vptr.singleton = 0x845c9b0 <vtable for CPCBangManager+8>,
static ms_singleton = 0xffffa7b8}, m_map_ip = {_M_t = {
--Type <RET> for more, q to quit, c to continue without paging--
_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<unsigned long const, unsigned long> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<unsigned long const, unsigned long> > >> = {<No data fields>}, <No data fields>},
_M_key_compare = {<std::binary_function<unsigned long, unsigned long, bool>> = {<No data fields>}, <No data fields>}, _M_header = {
_M_color = std::_S_red, _M_parent = 0x0,
_M_left = 0xffffa7c0, _M_right = 0xffffa7c0},
_M_node_count = 0}}}, m_minSavablePlayTime = 10}
trafficProfiler = {<singleton<TrafficProfiler>> = {
_vptr.singleton = 0x843c500 <vtable for TrafficProfiler+8>,
static ms_singleton = 0xffffaf0c}, m_pfProfileLogFile = 0x0,
m_dwFlushCycle = 0, m_tmProfileStartTime = 0, m_dwTotalTraffic = 0,
m_dwTotalPacket = 0, m_aTrafficVec = {
{<std::_Vector_base<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int> > >> = {
_M_impl = {<std::allocator<std::pair<unsigned int, unsigned int> >> = {<__gnu_cxx::new_allocator<std::pair<unsigned int, unsigned int> >> = {<No data fields>}, <No data fields>}, _M_start = 0x28ceb800,
_M_finish = 0x28cec000,
_M_end_of_storage = 0x28cec000}}, <No data fields>},
{<std::_Vector_base<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int> > >> = {
--Type <RET> for more, q to quit, c to continue without paging--
_M_impl = {<std::allocator<std::pair<unsigned int, unsigned int> >> = {<__gnu_cxx::new_allocator<std::pair<unsigned int, unsigned int> >> = {<No data fields>}, <No data fields>}, _M_start = 0x28cec000,
_M_finish = 0x28cec800,
_M_end_of_storage = 0x28cec800}}, <No data fields>}}}

Alles anzeigen

Shinex · 21. Februar 2019

Zitat von Mr Robot

Guten Tag,

ich bin auf der Suche nach einigen Quests.
- Reichwechseln
- Geschlechtsumwandlung
- Status Neuverteilung
- Fertigkeiten Neuverteilen

Wäre cool, wenn die jemand hätte und mir zur Verfügung stellen könnte.

MfG

Alles anzeigen

Shinex · 21. Februar 2019

Hi, not working for me it does nothing what can be wrong?

Shinex · 20. Februar 2019

Zitat von LordZiege

eventuell läuft die datenbank über txt und deswegen kann es nicht übernommen werden. Kannst du denn sonstige sachen ändern oder neues hinzufügen was nach einem neustart erhalten bleibt?

Nein läuft per sql, und alles andere klappt die Tabellen kann ich so weit ausfüllen und sie bleiben dann auch nur bei der specular Tabelle resetet er sie immer wieder auf 0 nach nem Reload oder Reboot

Shinex · 20. Februar 2019

Moin, Hab ein Problem dass eine Spalte ( specular ) in der Datenbank nach reload p oder reboot wieder auf 0 gesetzt wird, jemand eine Ahnung wie ich dass ändern kann?

Hab schon einiges in der ClientManagerBoot.cpp probiert aber nichts hat geklappt

Shinex · 18. November 2016

Kann jemand die BSD für den Source woanders hochladen?

Mega hat leider eine 6GB begrenzung.. fie nono

Shinex · 9. November 2016

Ja bitte, Kommt drauf an.. Dumper Source oder Binary?

Von Binary sich einen item_proto entpacker machen wär interessant und hilfreich..

Meld dich mal in Skype bitte: rikyu.elitepvpers

Shinex · 9. November 2016

Weiß jemand wie man anhandy einer Client Source sich einen item_proto entpacker zusammenbasteln kann und / oder sich die Binary so umschreiben, dass sie z.B von 40K Clienten eine Item_Proto lädt anscheind hat der Vorbesitzer dort irgendwas verändert, die item_proto lässt sich mit keinem Dumper entpacken und sonst klappt auch keine einzige item_proto in dem Clienten die von einem der puplic Entpacker stammt, inkls. Original txt Files aus der Datenbank

Shinex · 9. November 2016

Ist keiner vorhanden

Beiträge von Shinex

iteshop taskbar and chnnel switch

iteshop taskbar and chnnel switch

Idee für ein System

Idee für ein System

Idee für ein System

Ein paar Fragen...

Idee für ein System

Idee für ein System

Problem Rangpunkte

Rangnamen Bug

[Venaria2 - Source]

Core Crash

Suche Quests

Admin Whisper

item_proto

item_proto

BSD Ready for Source

Arianea Serverfiles

ITEM PROTO

Arianea Serverfiles