ryzom/server/src/entities_game_service/database_plr.cpp

   1
   2 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   3 // Copyright (C) 2010  Winch Gate Property Limited
   4 //
   5 // This program is free software: you can redistribute it and/or modify
   6 // it under the terms of the GNU Affero General Public License as
   7 // published by the Free Software Foundation, either version 3 of the
   8 // License, or (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU Affero General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU Affero General Public License
  16 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 /////////////////////////////////////////////////////////////////
  19 // WARNING : this is a generated file, don't change it !
  20 /////////////////////////////////////////////////////////////////
  21
  22 #include "stdpch.h"
  23 #include "database_plr.h"
  24
  25
  26
  27 TCDBBank CBankAccessor_PLR::BankTag;
  28
  29                 CBankAccessor_PLR::TGameTime    CBankAccessor_PLR::_GameTime;
  30 CBankAccessor_PLR::TINTERFACES  CBankAccessor_PLR::_INTERFACES;
  31 CBankAccessor_PLR::TUSER        CBankAccessor_PLR::_USER;
  32 CBankAccessor_PLR::TDEFENSE     CBankAccessor_PLR::_DEFENSE;
  33 CBankAccessor_PLR::TFLAGS       CBankAccessor_PLR::_FLAGS;
  34 CBankAccessor_PLR::TTARGET      CBankAccessor_PLR::_TARGET;
  35 CBankAccessor_PLR::TGROUP       CBankAccessor_PLR::_GROUP;
  36 CBankAccessor_PLR::TDM_GIFT     CBankAccessor_PLR::_DM_GIFT;
  37 CBankAccessor_PLR::TEXCHANGE    CBankAccessor_PLR::_EXCHANGE;
  38 CBankAccessor_PLR::TINVENTORY   CBankAccessor_PLR::_INVENTORY;
  39 CBankAccessor_PLR::TMODIFIERS   CBankAccessor_PLR::_MODIFIERS;
  40 CBankAccessor_PLR::TDISABLE_CONSUMABLE  CBankAccessor_PLR::_DISABLE_CONSUMABLE;
  41 CBankAccessor_PLR::TBOTCHAT     CBankAccessor_PLR::_BOTCHAT;
  42 CBankAccessor_PLR::TASCENSOR    CBankAccessor_PLR::_ASCENSOR;
  43 CBankAccessor_PLR::TCHOOSE_MISSIONS     CBankAccessor_PLR::_CHOOSE_MISSIONS;
  44 CBankAccessor_PLR::TTRADING     CBankAccessor_PLR::_TRADING;
  45 CBankAccessor_PLR::TBRICK_FAMILY        CBankAccessor_PLR::_BRICK_FAMILY;
  46 CBankAccessor_PLR::TFABER_PLANS CBankAccessor_PLR::_FABER_PLANS;
  47 CBankAccessor_PLR::TMISSIONS    CBankAccessor_PLR::_MISSIONS;
  48 CBankAccessor_PLR::TEXECUTE_PHRASE      CBankAccessor_PLR::_EXECUTE_PHRASE;
  49 CBankAccessor_PLR::TCHARACTER_INFO      CBankAccessor_PLR::_CHARACTER_INFO;
  50 CBankAccessor_PLR::TPACK_ANIMAL CBankAccessor_PLR::_PACK_ANIMAL;
  51 CBankAccessor_PLR::TDEBUG_INFO  CBankAccessor_PLR::_DEBUG_INFO;
  52 CBankAccessor_PLR::TMP_EVAL     CBankAccessor_PLR::_MP_EVAL;
  53 CBankAccessor_PLR::TCOMPASS     CBankAccessor_PLR::_COMPASS;
  54 CBankAccessor_PLR::TFAME        CBankAccessor_PLR::_FAME;
  55 CBankAccessor_PLR::TSTATIC_DATA CBankAccessor_PLR::_STATIC_DATA;
  56 CBankAccessor_PLR::TDYN_CHAT    CBankAccessor_PLR::_DYN_CHAT;
  57 CBankAccessor_PLR::TPVP_EFFECTS CBankAccessor_PLR::_PVP_EFFECTS;
  58 CBankAccessor_PLR::TWEATHER     CBankAccessor_PLR::_WEATHER;
  59
  60 void CBankAccessor_PLR::init()
  61 {
  62         static bool inited = false;
  63         if (!inited)
  64         {
  65                 // retreive the bank structure
  66                 CCDBStructBanks *bank = CCDBStructBanks::instance();
  67                 BankTag = CCDBStructBanks::readBankName("PLR");
  68
  69                 ICDBStructNode *node;
  70
  71                 // branch init
  72
  73                 node  = bank->getICDBStructNodeFromName( BankTag, "GameTime" );
  74                 nlassert(node != NULL);
  75                 // call sub branch init
  76                 _GameTime.init(node);
  77
  78                 node  = bank->getICDBStructNodeFromName( BankTag, "INTERFACES" );
  79                 nlassert(node != NULL);
  80                 // call sub branch init
  81                 _INTERFACES.init(node);
  82
  83                 node  = bank->getICDBStructNodeFromName( BankTag, "USER" );
  84                 nlassert(node != NULL);
  85                 // call sub branch init
  86                 _USER.init(node);
  87
  88                 node  = bank->getICDBStructNodeFromName( BankTag, "DEFENSE" );
  89                 nlassert(node != NULL);
  90                 // call sub branch init
  91                 _DEFENSE.init(node);
  92
  93                 node  = bank->getICDBStructNodeFromName( BankTag, "FLAGS" );
  94                 nlassert(node != NULL);
  95                 // call sub branch init
  96                 _FLAGS.init(node);
  97
  98                 node  = bank->getICDBStructNodeFromName( BankTag, "TARGET" );
  99                 nlassert(node != NULL);
 100                 // call sub branch init
 101                 _TARGET.init(node);
 102
 103                 node  = bank->getICDBStructNodeFromName( BankTag, "GROUP" );
 104                 nlassert(node != NULL);
 105                 // call sub branch init
 106                 _GROUP.init(node);
 107
 108                 node  = bank->getICDBStructNodeFromName( BankTag, "DM_GIFT" );
 109                 nlassert(node != NULL);
 110                 // call sub branch init
 111                 _DM_GIFT.init(node);
 112
 113                 node  = bank->getICDBStructNodeFromName( BankTag, "EXCHANGE" );
 114                 nlassert(node != NULL);
 115                 // call sub branch init
 116                 _EXCHANGE.init(node);
 117
 118                 node  = bank->getICDBStructNodeFromName( BankTag, "INVENTORY" );
 119                 nlassert(node != NULL);
 120                 // call sub branch init
 121                 _INVENTORY.init(node);
 122
 123                 node  = bank->getICDBStructNodeFromName( BankTag, "MODIFIERS" );
 124                 nlassert(node != NULL);
 125                 // call sub branch init
 126                 _MODIFIERS.init(node);
 127
 128                 node  = bank->getICDBStructNodeFromName( BankTag, "DISABLE_CONSUMABLE" );
 129                 nlassert(node != NULL);
 130                 // call sub branch init
 131                 _DISABLE_CONSUMABLE.init(node);
 132
 133                 node  = bank->getICDBStructNodeFromName( BankTag, "BOTCHAT" );
 134                 nlassert(node != NULL);
 135                 // call sub branch init
 136                 _BOTCHAT.init(node);
 137
 138                 node  = bank->getICDBStructNodeFromName( BankTag, "ASCENSOR" );
 139                 nlassert(node != NULL);
 140                 // call sub branch init
 141                 _ASCENSOR.init(node);
 142
 143                 node  = bank->getICDBStructNodeFromName( BankTag, "CHOOSE_MISSIONS" );
 144                 nlassert(node != NULL);
 145                 // call sub branch init
 146                 _CHOOSE_MISSIONS.init(node);
 147
 148                 node  = bank->getICDBStructNodeFromName( BankTag, "TRADING" );
 149                 nlassert(node != NULL);
 150                 // call sub branch init
 151                 _TRADING.init(node);
 152
 153                 node  = bank->getICDBStructNodeFromName( BankTag, "BRICK_FAMILY" );
 154                 nlassert(node != NULL);
 155                 // call sub branch init
 156                 _BRICK_FAMILY.init(node);
 157
 158                 node  = bank->getICDBStructNodeFromName( BankTag, "FABER_PLANS" );
 159                 nlassert(node != NULL);
 160                 // call sub branch init
 161                 _FABER_PLANS.init(node);
 162
 163                 node  = bank->getICDBStructNodeFromName( BankTag, "MISSIONS" );
 164                 nlassert(node != NULL);
 165                 // call sub branch init
 166                 _MISSIONS.init(node);
 167
 168                 node  = bank->getICDBStructNodeFromName( BankTag, "EXECUTE_PHRASE" );
 169                 nlassert(node != NULL);
 170                 // call sub branch init
 171                 _EXECUTE_PHRASE.init(node);
 172
 173                 node  = bank->getICDBStructNodeFromName( BankTag, "CHARACTER_INFO" );
 174                 nlassert(node != NULL);
 175                 // call sub branch init
 176                 _CHARACTER_INFO.init(node);
 177
 178                 node  = bank->getICDBStructNodeFromName( BankTag, "PACK_ANIMAL" );
 179                 nlassert(node != NULL);
 180                 // call sub branch init
 181                 _PACK_ANIMAL.init(node);
 182
 183                 node  = bank->getICDBStructNodeFromName( BankTag, "DEBUG_INFO" );
 184                 nlassert(node != NULL);
 185                 // call sub branch init
 186                 _DEBUG_INFO.init(node);
 187
 188                 node  = bank->getICDBStructNodeFromName( BankTag, "MP_EVAL" );
 189                 nlassert(node != NULL);
 190                 // call sub branch init
 191                 _MP_EVAL.init(node);
 192
 193                 node  = bank->getICDBStructNodeFromName( BankTag, "COMPASS" );
 194                 nlassert(node != NULL);
 195                 // call sub branch init
 196                 _COMPASS.init(node);
 197
 198                 node  = bank->getICDBStructNodeFromName( BankTag, "FAME" );
 199                 nlassert(node != NULL);
 200                 // call sub branch init
 201                 _FAME.init(node);
 202
 203                 node  = bank->getICDBStructNodeFromName( BankTag, "STATIC_DATA" );
 204                 nlassert(node != NULL);
 205                 // call sub branch init
 206                 _STATIC_DATA.init(node);
 207
 208                 node  = bank->getICDBStructNodeFromName( BankTag, "DYN_CHAT" );
 209                 nlassert(node != NULL);
 210                 // call sub branch init
 211                 _DYN_CHAT.init(node);
 212
 213                 node  = bank->getICDBStructNodeFromName( BankTag, "PVP_EFFECTS" );
 214                 nlassert(node != NULL);
 215                 // call sub branch init
 216                 _PVP_EFFECTS.init(node);
 217
 218                 node  = bank->getICDBStructNodeFromName( BankTag, "WEATHER" );
 219                 nlassert(node != NULL);
 220                 // call sub branch init
 221                 _WEATHER.init(node);
 222
 223
 224                 inited = true;
 225         }
 226 }
 227
 228 void CBankAccessor_PLR::TGameTime::init(ICDBStructNode *parent)
 229 {
 230         ICDBStructNode *node = parent;
 231
 232         _BranchNode = node;
 233
 234         // leaf init
 235
 236         node  = parent->getNode( ICDBStructNode::CTextId("Hours"), false );
 237         nlassert(node != NULL);
 238         _Hours = node;
 239
 240
 241         // branch init
 242
 243 }
 244
 245
 246 void CBankAccessor_PLR::TINTERFACES::init(ICDBStructNode *parent)
 247 {
 248         ICDBStructNode *node = parent;
 249
 250         _BranchNode = node;
 251
 252         // leaf init
 253
 254         node  = parent->getNode( ICDBStructNode::CTextId("FLAGS"), false );
 255         nlassert(node != NULL);
 256         _FLAGS = node;
 257
 258         node  = parent->getNode( ICDBStructNode::CTextId("NB_BONUS_LANDMARKS"), false );
 259         nlassert(node != NULL);
 260         _NB_BONUS_LANDMARKS = node;
 261
 262
 263         // branch init
 264
 265 }
 266
 267
 268 void CBankAccessor_PLR::TUSER::init(ICDBStructNode *parent)
 269 {
 270         ICDBStructNode *node = parent;
 271
 272         _BranchNode = node;
 273
 274         // leaf init
 275
 276         node  = parent->getNode( ICDBStructNode::CTextId("HAIR_TYPE"), false );
 277         nlassert(node != NULL);
 278         _HAIR_TYPE = node;
 279
 280         node  = parent->getNode( ICDBStructNode::CTextId("HAIR_COLOR"), false );
 281         nlassert(node != NULL);
 282         _HAIR_COLOR = node;
 283
 284         node  = parent->getNode( ICDBStructNode::CTextId("DEATH_XP_MALUS"), false );
 285         nlassert(node != NULL);
 286         _DEATH_XP_MALUS = node;
 287
 288         node  = parent->getNode( ICDBStructNode::CTextId("IN_DUEL"), false );
 289         nlassert(node != NULL);
 290         _IN_DUEL = node;
 291
 292         node  = parent->getNode( ICDBStructNode::CTextId("IN_PVP_CHALLENGE"), false );
 293         nlassert(node != NULL);
 294         _IN_PVP_CHALLENGE = node;
 295
 296         node  = parent->getNode( ICDBStructNode::CTextId("MOUNT_WALK_SPEED"), false );
 297         nlassert(node != NULL);
 298         _MOUNT_WALK_SPEED = node;
 299
 300         node  = parent->getNode( ICDBStructNode::CTextId("MOUNT_RUN_SPEED"), false );
 301         nlassert(node != NULL);
 302         _MOUNT_RUN_SPEED = node;
 303
 304         node  = parent->getNode( ICDBStructNode::CTextId("TEAM_MEMBER"), false );
 305         nlassert(node != NULL);
 306         _TEAM_MEMBER = node;
 307
 308         node  = parent->getNode( ICDBStructNode::CTextId("TEAM_LEADER"), false );
 309         nlassert(node != NULL);
 310         _TEAM_LEADER = node;
 311
 312         node  = parent->getNode( ICDBStructNode::CTextId("OUTPOST_ADMIN"), false );
 313         nlassert(node != NULL);
 314         _OUTPOST_ADMIN = node;
 315
 316         node  = parent->getNode( ICDBStructNode::CTextId("BERSERK"), false );
 317         nlassert(node != NULL);
 318         _BERSERK = node;
 319
 320         node  = parent->getNode( ICDBStructNode::CTextId("ACT_TSTART"), false );
 321         nlassert(node != NULL);
 322         _ACT_TSTART = node;
 323
 324         node  = parent->getNode( ICDBStructNode::CTextId("ACT_TEND"), false );
 325         nlassert(node != NULL);
 326         _ACT_TEND = node;
 327
 328         node  = parent->getNode( ICDBStructNode::CTextId("ACT_TYPE"), false );
 329         nlassert(node != NULL);
 330         _ACT_TYPE = node;
 331
 332         node  = parent->getNode( ICDBStructNode::CTextId("ACT_NUMBER"), false );
 333         nlassert(node != NULL);
 334         _ACT_NUMBER = node;
 335
 336         node  = parent->getNode( ICDBStructNode::CTextId("ACT_REFUSED_NUM"), false );
 337         nlassert(node != NULL);
 338         _ACT_REFUSED_NUM = node;
 339
 340         node  = parent->getNode( ICDBStructNode::CTextId("ACT_CANCELED_NUM"), false );
 341         nlassert(node != NULL);
 342         _ACT_CANCELED_NUM = node;
 343
 344         node  = parent->getNode( ICDBStructNode::CTextId("SPEED_FACTOR"), false );
 345         nlassert(node != NULL);
 346         _SPEED_FACTOR = node;
 347
 348         node  = parent->getNode( ICDBStructNode::CTextId("SKILL_POINTS"), false );
 349         nlassert(node != NULL);
 350         _SKILL_POINTS = node;
 351
 352         node  = parent->getNode( ICDBStructNode::CTextId("IS_NEWBIE"), false );
 353         nlassert(node != NULL);
 354         _IS_NEWBIE = node;
 355
 356         node  = parent->getNode( ICDBStructNode::CTextId("IS_TRIAL"), false );
 357         nlassert(node != NULL);
 358         _IS_TRIAL = node;
 359
 360         node  = parent->getNode( ICDBStructNode::CTextId("DEFAULT_WEIGHT_HANDS"), false );
 361         nlassert(node != NULL);
 362         _DEFAULT_WEIGHT_HANDS = node;
 363
 364         node  = parent->getNode( ICDBStructNode::CTextId("IS_INVISIBLE"), false );
 365         nlassert(node != NULL);
 366         _IS_INVISIBLE = node;
 367
 368         node  = parent->getNode( ICDBStructNode::CTextId("COUNTER"), false );
 369         nlassert(node != NULL);
 370         _COUNTER = node;
 371
 372
 373         // branch init
 374
 375         for (uint i=0; i<4; ++i)
 376         {
 377                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("SKILL_POINTS_%u", i)), false );
 378                 nlassert(node != NULL);
 379                 _SKILL_POINTS_[i].init(node, i);
 380         }
 381
 382         for (uint i=0; i<7; ++i)
 383         {
 384                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("FACTION_POINTS_%u", i)), false );
 385                 nlassert(node != NULL);
 386                 _FACTION_POINTS_[i].init(node, i);
 387         }
 388
 389         for (uint i=0; i<6; ++i)
 390         {
 391                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("RRPS_LEVELS%u", i)), false );
 392                 nlassert(node != NULL);
 393                 _RRPS_LEVELS[i].init(node, i);
 394         }
 395
 396         node  = parent->getNode( ICDBStructNode::CTextId("NPC_CONTROL"), false );
 397         nlassert(node != NULL);
 398         _NPC_CONTROL.init(node);
 399
 400 }
 401
 402
 403 void CBankAccessor_PLR::TUSER::TSKILL_POINTS_::init(ICDBStructNode *parent, uint index)
 404 {
 405         ICDBStructNode *node = parent;
 406
 407         _BranchNode = node;
 408
 409         // leaf init
 410
 411         node  = parent->getNode( ICDBStructNode::CTextId("VALUE"), false );
 412         nlassert(node != NULL);
 413         _VALUE = node;
 414
 415
 416         // branch init
 417
 418 }
 419
 420
 421 void CBankAccessor_PLR::TUSER::TFACTION_POINTS_::init(ICDBStructNode *parent, uint index)
 422 {
 423         ICDBStructNode *node = parent;
 424
 425         _BranchNode = node;
 426
 427         // leaf init
 428
 429         node  = parent->getNode( ICDBStructNode::CTextId("VALUE"), false );
 430         nlassert(node != NULL);
 431         _VALUE = node;
 432
 433
 434         // branch init
 435
 436 }
 437
 438
 439 void CBankAccessor_PLR::TUSER::TRRPS_LEVELS::init(ICDBStructNode *parent, uint index)
 440 {
 441         ICDBStructNode *node = parent;
 442
 443         _BranchNode = node;
 444
 445         // leaf init
 446
 447         node  = parent->getNode( ICDBStructNode::CTextId("VALUE"), false );
 448         nlassert(node != NULL);
 449         _VALUE = node;
 450
 451
 452         // branch init
 453
 454 }
 455
 456
 457 void CBankAccessor_PLR::TUSER::TNPC_CONTROL::init(ICDBStructNode *parent)
 458 {
 459         ICDBStructNode *node = parent;
 460
 461         _BranchNode = node;
 462
 463         // leaf init
 464
 465         node  = parent->getNode( ICDBStructNode::CTextId("SHEET"), false );
 466         nlassert(node != NULL);
 467         _SHEET = node;
 468
 469         node  = parent->getNode( ICDBStructNode::CTextId("RUN"), false );
 470         nlassert(node != NULL);
 471         _RUN = node;
 472
 473         node  = parent->getNode( ICDBStructNode::CTextId("WALK"), false );
 474         nlassert(node != NULL);
 475         _WALK = node;
 476
 477
 478         // branch init
 479
 480 }
 481
 482
 483 void CBankAccessor_PLR::TDEFENSE::init(ICDBStructNode *parent)
 484 {
 485         ICDBStructNode *node = parent;
 486
 487         _BranchNode = node;
 488
 489         // leaf init
 490
 491         node  = parent->getNode( ICDBStructNode::CTextId("DEFENSE_MODE"), false );
 492         nlassert(node != NULL);
 493         _DEFENSE_MODE = node;
 494
 495         node  = parent->getNode( ICDBStructNode::CTextId("PROTECTED_SLOT"), false );
 496         nlassert(node != NULL);
 497         _PROTECTED_SLOT = node;
 498
 499
 500         // branch init
 501
 502         node  = parent->getNode( ICDBStructNode::CTextId("SLOTS"), false );
 503         nlassert(node != NULL);
 504         _SLOTS.init(node);
 505
 506 }
 507
 508
 509 void CBankAccessor_PLR::TDEFENSE::TSLOTS::init(ICDBStructNode *parent)
 510 {
 511         ICDBStructNode *node = parent;
 512
 513         _BranchNode = node;
 514
 515         // leaf init
 516
 517
 518         // branch init
 519
 520         for (uint i=0; i<6; ++i)
 521         {
 522                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
 523                 nlassert(node != NULL);
 524                 _Array[i].init(node, i);
 525         }
 526
 527 }
 528
 529
 530 void CBankAccessor_PLR::TDEFENSE::TSLOTS::TArray::init(ICDBStructNode *parent, uint index)
 531 {
 532         ICDBStructNode *node = parent;
 533
 534         _BranchNode = node;
 535
 536         // leaf init
 537
 538         node  = parent->getNode( ICDBStructNode::CTextId("MODIFIER"), false );
 539         nlassert(node != NULL);
 540         _MODIFIER = node;
 541
 542
 543         // branch init
 544
 545 }
 546
 547
 548 void CBankAccessor_PLR::TFLAGS::init(ICDBStructNode *parent)
 549 {
 550         ICDBStructNode *node = parent;
 551
 552         _BranchNode = node;
 553
 554         // leaf init
 555
 556         node  = parent->getNode( ICDBStructNode::CTextId("CRITICAL"), false );
 557         nlassert(node != NULL);
 558         _CRITICAL = node;
 559
 560         node  = parent->getNode( ICDBStructNode::CTextId("PARRY"), false );
 561         nlassert(node != NULL);
 562         _PARRY = node;
 563
 564         node  = parent->getNode( ICDBStructNode::CTextId("DODGE"), false );
 565         nlassert(node != NULL);
 566         _DODGE = node;
 567
 568
 569         // branch init
 570
 571         node  = parent->getNode( ICDBStructNode::CTextId("BRICK_TICK_RANGE"), false );
 572         nlassert(node != NULL);
 573         _BRICK_TICK_RANGE.init(node);
 574
 575 }
 576
 577
 578 void CBankAccessor_PLR::TFLAGS::TBRICK_TICK_RANGE::init(ICDBStructNode *parent)
 579 {
 580         ICDBStructNode *node = parent;
 581
 582         _BranchNode = node;
 583
 584         // leaf init
 585
 586
 587         // branch init
 588
 589         for (uint i=0; i<64; ++i)
 590         {
 591                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
 592                 nlassert(node != NULL);
 593                 _Array[i].init(node, i);
 594         }
 595
 596 }
 597
 598
 599 void CBankAccessor_PLR::TFLAGS::TBRICK_TICK_RANGE::TArray::init(ICDBStructNode *parent, uint index)
 600 {
 601         ICDBStructNode *node = parent;
 602
 603         _BranchNode = node;
 604
 605         // leaf init
 606
 607         node  = parent->getNode( ICDBStructNode::CTextId("TICK_RANGE"), false );
 608         nlassert(node != NULL);
 609         _TICK_RANGE = node;
 610
 611
 612         // branch init
 613
 614 }
 615
 616
 617 void CBankAccessor_PLR::TTARGET::init(ICDBStructNode *parent)
 618 {
 619         ICDBStructNode *node = parent;
 620
 621         _BranchNode = node;
 622
 623         // leaf init
 624
 625         node  = parent->getNode( ICDBStructNode::CTextId("CONTEXT_VAL"), false );
 626         nlassert(node != NULL);
 627         _CONTEXT_VAL = node;
 628
 629         node  = parent->getNode( ICDBStructNode::CTextId("AGGRESSIVE"), false );
 630         nlassert(node != NULL);
 631         _AGGRESSIVE = node;
 632
 633         node  = parent->getNode( ICDBStructNode::CTextId("FORCE_RATIO"), false );
 634         nlassert(node != NULL);
 635         _FORCE_RATIO = node;
 636
 637
 638         // branch init
 639
 640         node  = parent->getNode( ICDBStructNode::CTextId("BARS"), false );
 641         nlassert(node != NULL);
 642         _BARS.init(node);
 643
 644         node  = parent->getNode( ICDBStructNode::CTextId("CONTEXT_MENU"), false );
 645         nlassert(node != NULL);
 646         _CONTEXT_MENU.init(node);
 647
 648 }
 649
 650
 651 void CBankAccessor_PLR::TTARGET::TBARS::init(ICDBStructNode *parent)
 652 {
 653         ICDBStructNode *node = parent;
 654
 655         _BranchNode = node;
 656
 657         // leaf init
 658
 659         node  = parent->getNode( ICDBStructNode::CTextId("UID"), false );
 660         nlassert(node != NULL);
 661         _UID = node;
 662
 663         node  = parent->getNode( ICDBStructNode::CTextId("HP"), false );
 664         nlassert(node != NULL);
 665         _HP = node;
 666
 667         node  = parent->getNode( ICDBStructNode::CTextId("SAP"), false );
 668         nlassert(node != NULL);
 669         _SAP = node;
 670
 671         node  = parent->getNode( ICDBStructNode::CTextId("STA"), false );
 672         nlassert(node != NULL);
 673         _STA = node;
 674
 675         node  = parent->getNode( ICDBStructNode::CTextId("FOCUS"), false );
 676         nlassert(node != NULL);
 677         _FOCUS = node;
 678
 679         node  = parent->getNode( ICDBStructNode::CTextId("PLAYER_LEVEL"), false );
 680         nlassert(node != NULL);
 681         _PLAYER_LEVEL = node;
 682
 683
 684         // branch init
 685
 686 }
 687
 688
 689 void CBankAccessor_PLR::TTARGET::TCONTEXT_MENU::init(ICDBStructNode *parent)
 690 {
 691         ICDBStructNode *node = parent;
 692
 693         _BranchNode = node;
 694
 695         // leaf init
 696
 697         node  = parent->getNode( ICDBStructNode::CTextId("PROGRAMMES"), false );
 698         nlassert(node != NULL);
 699         _PROGRAMMES = node;
 700
 701         node  = parent->getNode( ICDBStructNode::CTextId("WEB_PAGE_TITLE"), false );
 702         nlassert(node != NULL);
 703         _WEB_PAGE_TITLE = node;
 704
 705         node  = parent->getNode( ICDBStructNode::CTextId("WEB_PAGE_URL"), false );
 706         nlassert(node != NULL);
 707         _WEB_PAGE_URL = node;
 708
 709         node  = parent->getNode( ICDBStructNode::CTextId("OUTPOST"), false );
 710         nlassert(node != NULL);
 711         _OUTPOST = node;
 712
 713         node  = parent->getNode( ICDBStructNode::CTextId("COUNTER"), false );
 714         nlassert(node != NULL);
 715         _COUNTER = node;
 716
 717
 718         // branch init
 719
 720         node  = parent->getNode( ICDBStructNode::CTextId("MISSIONS_OPTIONS"), false );
 721         nlassert(node != NULL);
 722         _MISSIONS_OPTIONS.init(node);
 723
 724         node  = parent->getNode( ICDBStructNode::CTextId("MISSION_RING"), false );
 725         nlassert(node != NULL);
 726         _MISSION_RING.init(node);
 727
 728 }
 729
 730
 731 void CBankAccessor_PLR::TTARGET::TCONTEXT_MENU::TMISSIONS_OPTIONS::init(ICDBStructNode *parent)
 732 {
 733         ICDBStructNode *node = parent;
 734
 735         _BranchNode = node;
 736
 737         // leaf init
 738
 739
 740         // branch init
 741
 742         for (uint i=0; i<8; ++i)
 743         {
 744                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
 745                 nlassert(node != NULL);
 746                 _Array[i].init(node, i);
 747         }
 748
 749 }
 750
 751
 752 void CBankAccessor_PLR::TTARGET::TCONTEXT_MENU::TMISSIONS_OPTIONS::TArray::init(ICDBStructNode *parent, uint index)
 753 {
 754         ICDBStructNode *node = parent;
 755
 756         _BranchNode = node;
 757
 758         // leaf init
 759
 760         node  = parent->getNode( ICDBStructNode::CTextId("TITLE"), false );
 761         nlassert(node != NULL);
 762         _TITLE = node;
 763
 764         node  = parent->getNode( ICDBStructNode::CTextId("PLAYER_GIFT_NEEDED"), false );
 765         nlassert(node != NULL);
 766         _PLAYER_GIFT_NEEDED = node;
 767
 768         node  = parent->getNode( ICDBStructNode::CTextId("PRIORITY"), false );
 769         nlassert(node != NULL);
 770         _PRIORITY = node;
 771
 772
 773         // branch init
 774
 775 }
 776
 777
 778 void CBankAccessor_PLR::TTARGET::TCONTEXT_MENU::TMISSION_RING::init(ICDBStructNode *parent)
 779 {
 780         ICDBStructNode *node = parent;
 781
 782         _BranchNode = node;
 783
 784         // leaf init
 785
 786
 787         // branch init
 788
 789         for (uint i=0; i<4; ++i)
 790         {
 791                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
 792                 nlassert(node != NULL);
 793                 _Array[i].init(node, i);
 794         }
 795
 796 }
 797
 798
 799 void CBankAccessor_PLR::TTARGET::TCONTEXT_MENU::TMISSION_RING::TArray::init(ICDBStructNode *parent, uint index)
 800 {
 801         ICDBStructNode *node = parent;
 802
 803         _BranchNode = node;
 804
 805         // leaf init
 806
 807         node  = parent->getNode( ICDBStructNode::CTextId("TITLE"), false );
 808         nlassert(node != NULL);
 809         _TITLE = node;
 810
 811         node  = parent->getNode( ICDBStructNode::CTextId("ID"), false );
 812         nlassert(node != NULL);
 813         _ID = node;
 814
 815
 816         // branch init
 817
 818 }
 819
 820
 821 void CBankAccessor_PLR::TGROUP::init(ICDBStructNode *parent)
 822 {
 823         ICDBStructNode *node = parent;
 824
 825         _BranchNode = node;
 826
 827         // leaf init
 828
 829         node  = parent->getNode( ICDBStructNode::CTextId("LEADER_INDEX"), false );
 830         nlassert(node != NULL);
 831         _LEADER_INDEX = node;
 832
 833         node  = parent->getNode( ICDBStructNode::CTextId("SUCCESSOR_INDEX"), false );
 834         nlassert(node != NULL);
 835         _SUCCESSOR_INDEX = node;
 836
 837
 838         // branch init
 839
 840         for (uint i=0; i<8; ++i)
 841         {
 842                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
 843                 nlassert(node != NULL);
 844                 _Array[i].init(node, i);
 845         }
 846
 847         node  = parent->getNode( ICDBStructNode::CTextId("MISSIONS"), false );
 848         nlassert(node != NULL);
 849         _MISSIONS.init(node);
 850
 851 }
 852
 853
 854 void CBankAccessor_PLR::TGROUP::TArray::init(ICDBStructNode *parent, uint index)
 855 {
 856         ICDBStructNode *node = parent;
 857
 858         _BranchNode = node;
 859
 860         // leaf init
 861
 862         node  = parent->getNode( ICDBStructNode::CTextId("PRESENT"), false );
 863         nlassert(node != NULL);
 864         _PRESENT = node;
 865
 866         node  = parent->getNode( ICDBStructNode::CTextId("UID"), false );
 867         nlassert(node != NULL);
 868         _UID = node;
 869
 870         node  = parent->getNode( ICDBStructNode::CTextId("NAME"), false );
 871         nlassert(node != NULL);
 872         _NAME = node;
 873
 874         node  = parent->getNode( ICDBStructNode::CTextId("HP"), false );
 875         nlassert(node != NULL);
 876         _HP = node;
 877
 878         node  = parent->getNode( ICDBStructNode::CTextId("SAP"), false );
 879         nlassert(node != NULL);
 880         _SAP = node;
 881
 882         node  = parent->getNode( ICDBStructNode::CTextId("STA"), false );
 883         nlassert(node != NULL);
 884         _STA = node;
 885
 886         node  = parent->getNode( ICDBStructNode::CTextId("POS"), false );
 887         nlassert(node != NULL);
 888         _POS = node;
 889
 890
 891         // branch init
 892
 893 }
 894
 895
 896 void CBankAccessor_PLR::TGROUP::TMISSIONS::init(ICDBStructNode *parent)
 897 {
 898         ICDBStructNode *node = parent;
 899
 900         _BranchNode = node;
 901
 902         // leaf init
 903
 904
 905         // branch init
 906
 907         for (uint i=0; i<15; ++i)
 908         {
 909                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
 910                 nlassert(node != NULL);
 911                 _Array[i].init(node, i);
 912         }
 913
 914 }
 915
 916
 917 void CBankAccessor_PLR::TGROUP::TMISSIONS::TArray::init(ICDBStructNode *parent, uint index)
 918 {
 919         ICDBStructNode *node = parent;
 920
 921         _BranchNode = node;
 922
 923         // leaf init
 924
 925         node  = parent->getNode( ICDBStructNode::CTextId("TYPE"), false );
 926         nlassert(node != NULL);
 927         _TYPE = node;
 928
 929         node  = parent->getNode( ICDBStructNode::CTextId("ICON"), false );
 930         nlassert(node != NULL);
 931         _ICON = node;
 932
 933         node  = parent->getNode( ICDBStructNode::CTextId("TITLE"), false );
 934         nlassert(node != NULL);
 935         _TITLE = node;
 936
 937         node  = parent->getNode( ICDBStructNode::CTextId("DETAIL_TEXT"), false );
 938         nlassert(node != NULL);
 939         _DETAIL_TEXT = node;
 940
 941         node  = parent->getNode( ICDBStructNode::CTextId("BEGIN_DATE"), false );
 942         nlassert(node != NULL);
 943         _BEGIN_DATE = node;
 944
 945         node  = parent->getNode( ICDBStructNode::CTextId("END_DATE"), false );
 946         nlassert(node != NULL);
 947         _END_DATE = node;
 948
 949         node  = parent->getNode( ICDBStructNode::CTextId("OR_STEPS"), false );
 950         nlassert(node != NULL);
 951         _OR_STEPS = node;
 952
 953         node  = parent->getNode( ICDBStructNode::CTextId("FINISHED"), false );
 954         nlassert(node != NULL);
 955         _FINISHED = node;
 956
 957         node  = parent->getNode( ICDBStructNode::CTextId("ABANDONNABLE"), false );
 958         nlassert(node != NULL);
 959         _ABANDONNABLE = node;
 960
 961         node  = parent->getNode( ICDBStructNode::CTextId("SLEEP"), false );
 962         nlassert(node != NULL);
 963         _SLEEP = node;
 964
 965
 966         // branch init
 967
 968         node  = parent->getNode( ICDBStructNode::CTextId("GOALS"), false );
 969         nlassert(node != NULL);
 970         _GOALS.init(node);
 971
 972         for (uint i=0; i<8; ++i)
 973         {
 974                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("TARGET%u", i)), false );
 975                 nlassert(node != NULL);
 976                 _TARGET[i].init(node, i);
 977         }
 978
 979         node  = parent->getNode( ICDBStructNode::CTextId("HISTO"), false );
 980         nlassert(node != NULL);
 981         _HISTO.init(node);
 982
 983 }
 984
 985
 986 void CBankAccessor_PLR::TGROUP::TMISSIONS::TArray::TGOALS::init(ICDBStructNode *parent)
 987 {
 988         ICDBStructNode *node = parent;
 989
 990         _BranchNode = node;
 991
 992         // leaf init
 993
 994
 995         // branch init
 996
 997         for (uint i=0; i<20; ++i)
 998         {
 999                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
1000                 nlassert(node != NULL);
1001                 _Array[i].init(node, i);
1002         }
1003
1004 }
1005
1006
1007 void CBankAccessor_PLR::TGROUP::TMISSIONS::TArray::TGOALS::TArray::init(ICDBStructNode *parent, uint index)
1008 {
1009         ICDBStructNode *node = parent;
1010
1011         _BranchNode = node;
1012
1013         // leaf init
1014
1015         node  = parent->getNode( ICDBStructNode::CTextId("TEXT"), false );
1016         nlassert(node != NULL);
1017         _TEXT = node;
1018
1019         node  = parent->getNode( ICDBStructNode::CTextId("NPC_ALIAS"), false );
1020         nlassert(node != NULL);
1021         _NPC_ALIAS = node;
1022
1023
1024         // branch init
1025
1026 }
1027
1028
1029 void CBankAccessor_PLR::TGROUP::TMISSIONS::TArray::TTARGET::init(ICDBStructNode *parent, uint index)
1030 {
1031         ICDBStructNode *node = parent;
1032
1033         _BranchNode = node;
1034
1035         // leaf init
1036
1037         node  = parent->getNode( ICDBStructNode::CTextId("TITLE"), false );
1038         nlassert(node != NULL);
1039         _TITLE = node;
1040
1041         node  = parent->getNode( ICDBStructNode::CTextId("X"), false );
1042         nlassert(node != NULL);
1043         _X = node;
1044
1045         node  = parent->getNode( ICDBStructNode::CTextId("Y"), false );
1046         nlassert(node != NULL);
1047         _Y = node;
1048
1049
1050         // branch init
1051
1052 }
1053
1054
1055 void CBankAccessor_PLR::TGROUP::TMISSIONS::TArray::THISTO::init(ICDBStructNode *parent)
1056 {
1057         ICDBStructNode *node = parent;
1058
1059         _BranchNode = node;
1060
1061         // leaf init
1062
1063
1064         // branch init
1065
1066         for (uint i=0; i<30; ++i)
1067         {
1068                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
1069                 nlassert(node != NULL);
1070                 _Array[i].init(node, i);
1071         }
1072
1073 }
1074
1075
1076 void CBankAccessor_PLR::TGROUP::TMISSIONS::TArray::THISTO::TArray::init(ICDBStructNode *parent, uint index)
1077 {
1078         ICDBStructNode *node = parent;
1079
1080         _BranchNode = node;
1081
1082         // leaf init
1083
1084         node  = parent->getNode( ICDBStructNode::CTextId("TEXT"), false );
1085         nlassert(node != NULL);
1086         _TEXT = node;
1087
1088
1089         // branch init
1090
1091 }
1092
1093
1094 void CBankAccessor_PLR::TDM_GIFT::init(ICDBStructNode *parent)
1095 {
1096         ICDBStructNode *node = parent;
1097
1098         _BranchNode = node;
1099
1100         // leaf init
1101
1102         node  = parent->getNode( ICDBStructNode::CTextId("TEXT"), false );
1103         nlassert(node != NULL);
1104         _TEXT = node;
1105
1106
1107         // branch init
1108
1109 }
1110
1111
1112 void CBankAccessor_PLR::TEXCHANGE::init(ICDBStructNode *parent)
1113 {
1114         ICDBStructNode *node = parent;
1115
1116         _BranchNode = node;
1117
1118         // leaf init
1119
1120         node  = parent->getNode( ICDBStructNode::CTextId("TEXT"), false );
1121         nlassert(node != NULL);
1122         _TEXT = node;
1123
1124         node  = parent->getNode( ICDBStructNode::CTextId("ID"), false );
1125         nlassert(node != NULL);
1126         _ID = node;
1127
1128         node  = parent->getNode( ICDBStructNode::CTextId("BEGUN"), false );
1129         nlassert(node != NULL);
1130         _BEGUN = node;
1131
1132         node  = parent->getNode( ICDBStructNode::CTextId("ACCEPTED"), false );
1133         nlassert(node != NULL);
1134         _ACCEPTED = node;
1135
1136         node  = parent->getNode( ICDBStructNode::CTextId("MONEY"), false );
1137         nlassert(node != NULL);
1138         _MONEY = node;
1139
1140         node  = parent->getNode( ICDBStructNode::CTextId("FORCE_REFUSE"), false );
1141         nlassert(node != NULL);
1142         _FORCE_REFUSE = node;
1143
1144         node  = parent->getNode( ICDBStructNode::CTextId("COUNTER"), false );
1145         nlassert(node != NULL);
1146         _COUNTER = node;
1147
1148
1149         // branch init
1150
1151         node  = parent->getNode( ICDBStructNode::CTextId("GIVE"), false );
1152         nlassert(node != NULL);
1153         _GIVE.init(node);
1154
1155         node  = parent->getNode( ICDBStructNode::CTextId("RECEIVE"), false );
1156         nlassert(node != NULL);
1157         _RECEIVE.init(node);
1158
1159 }
1160
1161
1162 void CBankAccessor_PLR::TEXCHANGE::TGIVE::init(ICDBStructNode *parent)
1163 {
1164         ICDBStructNode *node = parent;
1165
1166         _BranchNode = node;
1167
1168         // leaf init
1169
1170
1171         // branch init
1172
1173         for (uint i=0; i<10; ++i)
1174         {
1175                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
1176                 nlassert(node != NULL);
1177                 _Array[i].init(node, i);
1178         }
1179
1180 }
1181
1182
1183 void CBankAccessor_PLR::TEXCHANGE::TGIVE::TArray::init(ICDBStructNode *parent, uint index)
1184 {
1185         ICDBStructNode *node = parent;
1186
1187         _BranchNode = node;
1188
1189         // leaf init
1190
1191         node  = parent->getNode( ICDBStructNode::CTextId("SHEET"), false );
1192         nlassert(node != NULL);
1193         _SHEET = node;
1194
1195         node  = parent->getNode( ICDBStructNode::CTextId("QUALITY"), false );
1196         nlassert(node != NULL);
1197         _QUALITY = node;
1198
1199         node  = parent->getNode( ICDBStructNode::CTextId("QUANTITY"), false );
1200         nlassert(node != NULL);
1201         _QUANTITY = node;
1202
1203         node  = parent->getNode( ICDBStructNode::CTextId("CREATE_TIME"), false );
1204         nlassert(node != NULL);
1205         _CREATE_TIME = node;
1206
1207         node  = parent->getNode( ICDBStructNode::CTextId("SERIAL"), false );
1208         nlassert(node != NULL);
1209         _SERIAL = node;
1210
1211         node  = parent->getNode( ICDBStructNode::CTextId("USER_COLOR"), false );
1212         nlassert(node != NULL);
1213         _USER_COLOR = node;
1214
1215         node  = parent->getNode( ICDBStructNode::CTextId("WEIGHT"), false );
1216         nlassert(node != NULL);
1217         _WEIGHT = node;
1218
1219         node  = parent->getNode( ICDBStructNode::CTextId("NAMEID"), false );
1220         nlassert(node != NULL);
1221         _NAMEID = node;
1222
1223         node  = parent->getNode( ICDBStructNode::CTextId("INFO_VERSION"), false );
1224         nlassert(node != NULL);
1225         _INFO_VERSION = node;
1226
1227         node  = parent->getNode( ICDBStructNode::CTextId("ENCHANT"), false );
1228         nlassert(node != NULL);
1229         _ENCHANT = node;
1230
1231         node  = parent->getNode( ICDBStructNode::CTextId("RM_CLASS_TYPE"), false );
1232         nlassert(node != NULL);
1233         _RM_CLASS_TYPE = node;
1234
1235         node  = parent->getNode( ICDBStructNode::CTextId("RM_FABER_STAT_TYPE"), false );
1236         nlassert(node != NULL);
1237         _RM_FABER_STAT_TYPE = node;
1238
1239         node  = parent->getNode( ICDBStructNode::CTextId("PREREQUISIT_VALID"), false );
1240         nlassert(node != NULL);
1241         _PREREQUISIT_VALID = node;
1242
1243
1244         // branch init
1245
1246 }
1247
1248
1249 void CBankAccessor_PLR::TEXCHANGE::TRECEIVE::init(ICDBStructNode *parent)
1250 {
1251         ICDBStructNode *node = parent;
1252
1253         _BranchNode = node;
1254
1255         // leaf init
1256
1257
1258         // branch init
1259
1260         for (uint i=0; i<10; ++i)
1261         {
1262                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
1263                 nlassert(node != NULL);
1264                 _Array[i].init(node, i);
1265         }
1266
1267 }
1268
1269
1270 void CBankAccessor_PLR::TEXCHANGE::TRECEIVE::TArray::init(ICDBStructNode *parent, uint index)
1271 {
1272         ICDBStructNode *node = parent;
1273
1274         _BranchNode = node;
1275
1276         // leaf init
1277
1278         node  = parent->getNode( ICDBStructNode::CTextId("SHEET"), false );
1279         nlassert(node != NULL);
1280         _SHEET = node;
1281
1282         node  = parent->getNode( ICDBStructNode::CTextId("QUALITY"), false );
1283         nlassert(node != NULL);
1284         _QUALITY = node;
1285
1286         node  = parent->getNode( ICDBStructNode::CTextId("QUANTITY"), false );
1287         nlassert(node != NULL);
1288         _QUANTITY = node;
1289
1290         node  = parent->getNode( ICDBStructNode::CTextId("CREATE_TIME"), false );
1291         nlassert(node != NULL);
1292         _CREATE_TIME = node;
1293
1294         node  = parent->getNode( ICDBStructNode::CTextId("SERIAL"), false );
1295         nlassert(node != NULL);
1296         _SERIAL = node;
1297
1298         node  = parent->getNode( ICDBStructNode::CTextId("USER_COLOR"), false );
1299         nlassert(node != NULL);
1300         _USER_COLOR = node;
1301
1302         node  = parent->getNode( ICDBStructNode::CTextId("WEIGHT"), false );
1303         nlassert(node != NULL);
1304         _WEIGHT = node;
1305
1306         node  = parent->getNode( ICDBStructNode::CTextId("NAMEID"), false );
1307         nlassert(node != NULL);
1308         _NAMEID = node;
1309
1310         node  = parent->getNode( ICDBStructNode::CTextId("INFO_VERSION"), false );
1311         nlassert(node != NULL);
1312         _INFO_VERSION = node;
1313
1314         node  = parent->getNode( ICDBStructNode::CTextId("ENCHANT"), false );
1315         nlassert(node != NULL);
1316         _ENCHANT = node;
1317
1318         node  = parent->getNode( ICDBStructNode::CTextId("RM_CLASS_TYPE"), false );
1319         nlassert(node != NULL);
1320         _RM_CLASS_TYPE = node;
1321
1322         node  = parent->getNode( ICDBStructNode::CTextId("RM_FABER_STAT_TYPE"), false );
1323         nlassert(node != NULL);
1324         _RM_FABER_STAT_TYPE = node;
1325
1326         node  = parent->getNode( ICDBStructNode::CTextId("PREREQUISIT_VALID"), false );
1327         nlassert(node != NULL);
1328         _PREREQUISIT_VALID = node;
1329
1330
1331         // branch init
1332
1333 }
1334
1335
1336 void CBankAccessor_PLR::TINVENTORY::init(ICDBStructNode *parent)
1337 {
1338         ICDBStructNode *node = parent;
1339
1340         _BranchNode = node;
1341
1342         // leaf init
1343
1344         node  = parent->getNode( ICDBStructNode::CTextId("MONEY"), false );
1345         nlassert(node != NULL);
1346         _MONEY = node;
1347
1348         node  = parent->getNode( ICDBStructNode::CTextId("COUNTER"), false );
1349         nlassert(node != NULL);
1350         _COUNTER = node;
1351
1352
1353         // branch init
1354
1355         node  = parent->getNode( ICDBStructNode::CTextId("HAND"), false );
1356         nlassert(node != NULL);
1357         _HAND.init(node);
1358
1359         node  = parent->getNode( ICDBStructNode::CTextId("EQUIP"), false );
1360         nlassert(node != NULL);
1361         _EQUIP.init(node);
1362
1363         node  = parent->getNode( ICDBStructNode::CTextId("HOTBAR"), false );
1364         nlassert(node != NULL);
1365         _HOTBAR.init(node);
1366
1367         node  = parent->getNode( ICDBStructNode::CTextId("TEMP"), false );
1368         nlassert(node != NULL);
1369         _TEMP.init(node);
1370
1371         node  = parent->getNode( ICDBStructNode::CTextId("SHARE"), false );
1372         nlassert(node != NULL);
1373         _SHARE.init(node);
1374
1375         node  = parent->getNode( ICDBStructNode::CTextId("ROOM"), false );
1376         nlassert(node != NULL);
1377         _ROOM.init(node);
1378
1379 }
1380
1381
1382 void CBankAccessor_PLR::TINVENTORY::THAND::init(ICDBStructNode *parent)
1383 {
1384         ICDBStructNode *node = parent;
1385
1386         _BranchNode = node;
1387
1388         // leaf init
1389
1390
1391         // branch init
1392
1393         for (uint i=0; i<2; ++i)
1394         {
1395                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
1396                 nlassert(node != NULL);
1397                 _Array[i].init(node, i);
1398         }
1399
1400 }
1401
1402
1403 void CBankAccessor_PLR::TINVENTORY::THAND::TArray::init(ICDBStructNode *parent, uint index)
1404 {
1405         ICDBStructNode *node = parent;
1406
1407         _BranchNode = node;
1408
1409         // leaf init
1410
1411         node  = parent->getNode( ICDBStructNode::CTextId("INDEX_IN_BAG"), false );
1412         nlassert(node != NULL);
1413         _INDEX_IN_BAG = node;
1414
1415
1416         // branch init
1417
1418 }
1419
1420
1421 void CBankAccessor_PLR::TINVENTORY::TEQUIP::init(ICDBStructNode *parent)
1422 {
1423         ICDBStructNode *node = parent;
1424
1425         _BranchNode = node;
1426
1427         // leaf init
1428
1429
1430         // branch init
1431
1432         for (uint i=0; i<19; ++i)
1433         {
1434                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
1435                 nlassert(node != NULL);
1436                 _Array[i].init(node, i);
1437         }
1438
1439 }
1440
1441
1442 void CBankAccessor_PLR::TINVENTORY::TEQUIP::TArray::init(ICDBStructNode *parent, uint index)
1443 {
1444         ICDBStructNode *node = parent;
1445
1446         _BranchNode = node;
1447
1448         // leaf init
1449
1450         node  = parent->getNode( ICDBStructNode::CTextId("INDEX_IN_BAG"), false );
1451         nlassert(node != NULL);
1452         _INDEX_IN_BAG = node;
1453
1454
1455         // branch init
1456
1457 }
1458
1459
1460 void CBankAccessor_PLR::TINVENTORY::THOTBAR::init(ICDBStructNode *parent)
1461 {
1462         ICDBStructNode *node = parent;
1463
1464         _BranchNode = node;
1465
1466         // leaf init
1467
1468
1469         // branch init
1470
1471         for (uint i=0; i<5; ++i)
1472         {
1473                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
1474                 nlassert(node != NULL);
1475                 _Array[i].init(node, i);
1476         }
1477
1478 }
1479
1480
1481 void CBankAccessor_PLR::TINVENTORY::THOTBAR::TArray::init(ICDBStructNode *parent, uint index)
1482 {
1483         ICDBStructNode *node = parent;
1484
1485         _BranchNode = node;
1486
1487         // leaf init
1488
1489         node  = parent->getNode( ICDBStructNode::CTextId("INDEX_IN_BAG"), false );
1490         nlassert(node != NULL);
1491         _INDEX_IN_BAG = node;
1492
1493
1494         // branch init
1495
1496 }
1497
1498
1499 void CBankAccessor_PLR::TINVENTORY::TTEMP::init(ICDBStructNode *parent)
1500 {
1501         ICDBStructNode *node = parent;
1502
1503         _BranchNode = node;
1504
1505         // leaf init
1506
1507         node  = parent->getNode( ICDBStructNode::CTextId("TYPE"), false );
1508         nlassert(node != NULL);
1509         _TYPE = node;
1510
1511         node  = parent->getNode( ICDBStructNode::CTextId("ENABLE_TAKE"), false );
1512         nlassert(node != NULL);
1513         _ENABLE_TAKE = node;
1514
1515
1516         // branch init
1517
1518         for (uint i=0; i<16; ++i)
1519         {
1520                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
1521                 nlassert(node != NULL);
1522                 _Array[i].init(node, i);
1523         }
1524
1525 }
1526
1527
1528 void CBankAccessor_PLR::TINVENTORY::TTEMP::TArray::init(ICDBStructNode *parent, uint index)
1529 {
1530         ICDBStructNode *node = parent;
1531
1532         _BranchNode = node;
1533
1534         // leaf init
1535
1536         node  = parent->getNode( ICDBStructNode::CTextId("SHEET"), false );
1537         nlassert(node != NULL);
1538         _SHEET = node;
1539
1540         node  = parent->getNode( ICDBStructNode::CTextId("QUALITY"), false );
1541         nlassert(node != NULL);
1542         _QUALITY = node;
1543
1544         node  = parent->getNode( ICDBStructNode::CTextId("QUANTITY"), false );
1545         nlassert(node != NULL);
1546         _QUANTITY = node;
1547
1548         node  = parent->getNode( ICDBStructNode::CTextId("CREATE_TIME"), false );
1549         nlassert(node != NULL);
1550         _CREATE_TIME = node;
1551
1552         node  = parent->getNode( ICDBStructNode::CTextId("SERIAL"), false );
1553         nlassert(node != NULL);
1554         _SERIAL = node;
1555
1556         node  = parent->getNode( ICDBStructNode::CTextId("USER_COLOR"), false );
1557         nlassert(node != NULL);
1558         _USER_COLOR = node;
1559
1560         node  = parent->getNode( ICDBStructNode::CTextId("WEIGHT"), false );
1561         nlassert(node != NULL);
1562         _WEIGHT = node;
1563
1564         node  = parent->getNode( ICDBStructNode::CTextId("NAMEID"), false );
1565         nlassert(node != NULL);
1566         _NAMEID = node;
1567
1568         node  = parent->getNode( ICDBStructNode::CTextId("INFO_VERSION"), false );
1569         nlassert(node != NULL);
1570         _INFO_VERSION = node;
1571
1572         node  = parent->getNode( ICDBStructNode::CTextId("ENCHANT"), false );
1573         nlassert(node != NULL);
1574         _ENCHANT = node;
1575
1576         node  = parent->getNode( ICDBStructNode::CTextId("RM_CLASS_TYPE"), false );
1577         nlassert(node != NULL);
1578         _RM_CLASS_TYPE = node;
1579
1580         node  = parent->getNode( ICDBStructNode::CTextId("RM_FABER_STAT_TYPE"), false );
1581         nlassert(node != NULL);
1582         _RM_FABER_STAT_TYPE = node;
1583
1584         node  = parent->getNode( ICDBStructNode::CTextId("PREREQUISIT_VALID"), false );
1585         nlassert(node != NULL);
1586         _PREREQUISIT_VALID = node;
1587
1588
1589         // branch init
1590
1591 }
1592
1593
1594 void CBankAccessor_PLR::TINVENTORY::TSHARE::init(ICDBStructNode *parent)
1595 {
1596         ICDBStructNode *node = parent;
1597
1598         _BranchNode = node;
1599
1600         // leaf init
1601
1602         node  = parent->getNode( ICDBStructNode::CTextId("SESSION"), false );
1603         nlassert(node != NULL);
1604         _SESSION = node;
1605
1606
1607         // branch init
1608
1609         for (uint i=0; i<16; ++i)
1610         {
1611                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
1612                 nlassert(node != NULL);
1613                 _Array[i].init(node, i);
1614         }
1615
1616         for (uint i=0; i<8; ++i)
1617         {
1618                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("TM_%u", i)), false );
1619                 nlassert(node != NULL);
1620                 _TM_[i].init(node, i);
1621         }
1622
1623 }
1624
1625
1626 void CBankAccessor_PLR::TINVENTORY::TSHARE::TArray::init(ICDBStructNode *parent, uint index)
1627 {
1628         ICDBStructNode *node = parent;
1629
1630         _BranchNode = node;
1631
1632         // leaf init
1633
1634         node  = parent->getNode( ICDBStructNode::CTextId("SHEET"), false );
1635         nlassert(node != NULL);
1636         _SHEET = node;
1637
1638         node  = parent->getNode( ICDBStructNode::CTextId("QUALITY"), false );
1639         nlassert(node != NULL);
1640         _QUALITY = node;
1641
1642         node  = parent->getNode( ICDBStructNode::CTextId("QUANTITY"), false );
1643         nlassert(node != NULL);
1644         _QUANTITY = node;
1645
1646         node  = parent->getNode( ICDBStructNode::CTextId("CREATE_TIME"), false );
1647         nlassert(node != NULL);
1648         _CREATE_TIME = node;
1649
1650         node  = parent->getNode( ICDBStructNode::CTextId("SERIAL"), false );
1651         nlassert(node != NULL);
1652         _SERIAL = node;
1653
1654         node  = parent->getNode( ICDBStructNode::CTextId("USER_COLOR"), false );
1655         nlassert(node != NULL);
1656         _USER_COLOR = node;
1657
1658         node  = parent->getNode( ICDBStructNode::CTextId("WEIGHT"), false );
1659         nlassert(node != NULL);
1660         _WEIGHT = node;
1661
1662         node  = parent->getNode( ICDBStructNode::CTextId("NAMEID"), false );
1663         nlassert(node != NULL);
1664         _NAMEID = node;
1665
1666         node  = parent->getNode( ICDBStructNode::CTextId("INFO_VERSION"), false );
1667         nlassert(node != NULL);
1668         _INFO_VERSION = node;
1669
1670         node  = parent->getNode( ICDBStructNode::CTextId("ENCHANT"), false );
1671         nlassert(node != NULL);
1672         _ENCHANT = node;
1673
1674         node  = parent->getNode( ICDBStructNode::CTextId("RM_CLASS_TYPE"), false );
1675         nlassert(node != NULL);
1676         _RM_CLASS_TYPE = node;
1677
1678         node  = parent->getNode( ICDBStructNode::CTextId("RM_FABER_STAT_TYPE"), false );
1679         nlassert(node != NULL);
1680         _RM_FABER_STAT_TYPE = node;
1681
1682         node  = parent->getNode( ICDBStructNode::CTextId("PREREQUISIT_VALID"), false );
1683         nlassert(node != NULL);
1684         _PREREQUISIT_VALID = node;
1685
1686         node  = parent->getNode( ICDBStructNode::CTextId("NB_MEMBER"), false );
1687         nlassert(node != NULL);
1688         _NB_MEMBER = node;
1689
1690         node  = parent->getNode( ICDBStructNode::CTextId("WANTED"), false );
1691         nlassert(node != NULL);
1692         _WANTED = node;
1693
1694         node  = parent->getNode( ICDBStructNode::CTextId("CHANCE"), false );
1695         nlassert(node != NULL);
1696         _CHANCE = node;
1697
1698
1699         // branch init
1700
1701 }
1702
1703
1704 void CBankAccessor_PLR::TINVENTORY::TSHARE::TTM_::init(ICDBStructNode *parent, uint index)
1705 {
1706         ICDBStructNode *node = parent;
1707
1708         _BranchNode = node;
1709
1710         // leaf init
1711
1712         node  = parent->getNode( ICDBStructNode::CTextId("NAME"), false );
1713         nlassert(node != NULL);
1714         _NAME = node;
1715
1716         node  = parent->getNode( ICDBStructNode::CTextId("VALID"), false );
1717         nlassert(node != NULL);
1718         _VALID = node;
1719
1720
1721         // branch init
1722
1723 }
1724
1725
1726 void CBankAccessor_PLR::TINVENTORY::TROOM::init(ICDBStructNode *parent)
1727 {
1728         ICDBStructNode *node = parent;
1729
1730         _BranchNode = node;
1731
1732         // leaf init
1733
1734         node  = parent->getNode( ICDBStructNode::CTextId("SESSION"), false );
1735         nlassert(node != NULL);
1736         _SESSION = node;
1737
1738         node  = parent->getNode( ICDBStructNode::CTextId("BULK_MAX"), false );
1739         nlassert(node != NULL);
1740         _BULK_MAX = node;
1741
1742         node  = parent->getNode( ICDBStructNode::CTextId("MONEY"), false );
1743         nlassert(node != NULL);
1744         _MONEY = node;
1745
1746
1747         // branch init
1748
1749 }
1750
1751
1752 void CBankAccessor_PLR::TMODIFIERS::init(ICDBStructNode *parent)
1753 {
1754         ICDBStructNode *node = parent;
1755
1756         _BranchNode = node;
1757
1758         // leaf init
1759
1760         node  = parent->getNode( ICDBStructNode::CTextId("TOTAL_MALUS_EQUIP"), false );
1761         nlassert(node != NULL);
1762         _TOTAL_MALUS_EQUIP = node;
1763
1764
1765         // branch init
1766
1767         node  = parent->getNode( ICDBStructNode::CTextId("BONUS"), false );
1768         nlassert(node != NULL);
1769         _BONUS.init(node);
1770
1771         node  = parent->getNode( ICDBStructNode::CTextId("MALUS"), false );
1772         nlassert(node != NULL);
1773         _MALUS.init(node);
1774
1775 }
1776
1777
1778 void CBankAccessor_PLR::TMODIFIERS::TBONUS::init(ICDBStructNode *parent)
1779 {
1780         ICDBStructNode *node = parent;
1781
1782         _BranchNode = node;
1783
1784         // leaf init
1785
1786
1787         // branch init
1788
1789         for (uint i=0; i<12; ++i)
1790         {
1791                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
1792                 nlassert(node != NULL);
1793                 _Array[i].init(node, i);
1794         }
1795
1796 }
1797
1798
1799 void CBankAccessor_PLR::TMODIFIERS::TBONUS::TArray::init(ICDBStructNode *parent, uint index)
1800 {
1801         ICDBStructNode *node = parent;
1802
1803         _BranchNode = node;
1804
1805         // leaf init
1806
1807         node  = parent->getNode( ICDBStructNode::CTextId("SHEET"), false );
1808         nlassert(node != NULL);
1809         _SHEET = node;
1810
1811         node  = parent->getNode( ICDBStructNode::CTextId("DISABLED"), false );
1812         nlassert(node != NULL);
1813         _DISABLED = node;
1814
1815         node  = parent->getNode( ICDBStructNode::CTextId("DISABLED_TIME"), false );
1816         nlassert(node != NULL);
1817         _DISABLED_TIME = node;
1818
1819
1820         // branch init
1821
1822 }
1823
1824
1825 void CBankAccessor_PLR::TMODIFIERS::TMALUS::init(ICDBStructNode *parent)
1826 {
1827         ICDBStructNode *node = parent;
1828
1829         _BranchNode = node;
1830
1831         // leaf init
1832
1833
1834         // branch init
1835
1836         for (uint i=0; i<12; ++i)
1837         {
1838                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
1839                 nlassert(node != NULL);
1840                 _Array[i].init(node, i);
1841         }
1842
1843 }
1844
1845
1846 void CBankAccessor_PLR::TMODIFIERS::TMALUS::TArray::init(ICDBStructNode *parent, uint index)
1847 {
1848         ICDBStructNode *node = parent;
1849
1850         _BranchNode = node;
1851
1852         // leaf init
1853
1854         node  = parent->getNode( ICDBStructNode::CTextId("SHEET"), false );
1855         nlassert(node != NULL);
1856         _SHEET = node;
1857
1858         node  = parent->getNode( ICDBStructNode::CTextId("DISABLED"), false );
1859         nlassert(node != NULL);
1860         _DISABLED = node;
1861
1862         node  = parent->getNode( ICDBStructNode::CTextId("DISABLED_TIME"), false );
1863         nlassert(node != NULL);
1864         _DISABLED_TIME = node;
1865
1866
1867         // branch init
1868
1869 }
1870
1871
1872 void CBankAccessor_PLR::TDISABLE_CONSUMABLE::init(ICDBStructNode *parent)
1873 {
1874         ICDBStructNode *node = parent;
1875
1876         _BranchNode = node;
1877
1878         // leaf init
1879
1880
1881         // branch init
1882
1883         for (uint i=0; i<12; ++i)
1884         {
1885                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
1886                 nlassert(node != NULL);
1887                 _Array[i].init(node, i);
1888         }
1889
1890 }
1891
1892
1893 void CBankAccessor_PLR::TDISABLE_CONSUMABLE::TArray::init(ICDBStructNode *parent, uint index)
1894 {
1895         ICDBStructNode *node = parent;
1896
1897         _BranchNode = node;
1898
1899         // leaf init
1900
1901         node  = parent->getNode( ICDBStructNode::CTextId("FAMILY"), false );
1902         nlassert(node != NULL);
1903         _FAMILY = node;
1904
1905         node  = parent->getNode( ICDBStructNode::CTextId("DISABLE_TIME"), false );
1906         nlassert(node != NULL);
1907         _DISABLE_TIME = node;
1908
1909
1910         // branch init
1911
1912 }
1913
1914
1915 void CBankAccessor_PLR::TBOTCHAT::init(ICDBStructNode *parent)
1916 {
1917         ICDBStructNode *node = parent;
1918
1919         _BranchNode = node;
1920
1921         // leaf init
1922
1923         node  = parent->getNode( ICDBStructNode::CTextId("PLAYER_GIFT"), false );
1924         nlassert(node != NULL);
1925         _PLAYER_GIFT = node;
1926
1927         node  = parent->getNode( ICDBStructNode::CTextId("CREATE_GUILD"), false );
1928         nlassert(node != NULL);
1929         _CREATE_GUILD = node;
1930
1931         node  = parent->getNode( ICDBStructNode::CTextId("TRADE"), false );
1932         nlassert(node != NULL);
1933         _TRADE = node;
1934
1935         node  = parent->getNode( ICDBStructNode::CTextId("CHOOSE_MISSION"), false );
1936         nlassert(node != NULL);
1937         _CHOOSE_MISSION = node;
1938
1939         node  = parent->getNode( ICDBStructNode::CTextId("DM_TITLE"), false );
1940         nlassert(node != NULL);
1941         _DM_TITLE = node;
1942
1943         node  = parent->getNode( ICDBStructNode::CTextId("DM_DESCRIPTION"), false );
1944         nlassert(node != NULL);
1945         _DM_DESCRIPTION = node;
1946
1947         node  = parent->getNode( ICDBStructNode::CTextId("ROLEMASTER_TYPE"), false );
1948         nlassert(node != NULL);
1949         _ROLEMASTER_TYPE = node;
1950
1951
1952         // branch init
1953
1954         for (uint i=0; i<3; ++i)
1955         {
1956                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("DM_CHOICE%u", i)), false );
1957                 nlassert(node != NULL);
1958                 _DM_CHOICE[i].init(node, i);
1959         }
1960
1961 }
1962
1963
1964 void CBankAccessor_PLR::TBOTCHAT::TDM_CHOICE::init(ICDBStructNode *parent, uint index)
1965 {
1966         ICDBStructNode *node = parent;
1967
1968         _BranchNode = node;
1969
1970         // leaf init
1971
1972         node  = parent->getNode( ICDBStructNode::CTextId("TITLE"), false );
1973         nlassert(node != NULL);
1974         _TITLE = node;
1975
1976
1977         // branch init
1978
1979         for (uint i=0; i<8; ++i)
1980         {
1981                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
1982                 nlassert(node != NULL);
1983                 _Array[i].init(node, i);
1984         }
1985
1986 }
1987
1988
1989 void CBankAccessor_PLR::TBOTCHAT::TDM_CHOICE::TArray::init(ICDBStructNode *parent, uint index)
1990 {
1991         ICDBStructNode *node = parent;
1992
1993         _BranchNode = node;
1994
1995         // leaf init
1996
1997         node  = parent->getNode( ICDBStructNode::CTextId("TEXT"), false );
1998         nlassert(node != NULL);
1999         _TEXT = node;
2000
2001
2002         // branch init
2003
2004 }
2005
2006
2007 void CBankAccessor_PLR::TASCENSOR::init(ICDBStructNode *parent)
2008 {
2009         ICDBStructNode *node = parent;
2010
2011         _BranchNode = node;
2012
2013         // leaf init
2014
2015         node  = parent->getNode( ICDBStructNode::CTextId("SESSION"), false );
2016         nlassert(node != NULL);
2017         _SESSION = node;
2018
2019         node  = parent->getNode( ICDBStructNode::CTextId("PAGE_ID"), false );
2020         nlassert(node != NULL);
2021         _PAGE_ID = node;
2022
2023         node  = parent->getNode( ICDBStructNode::CTextId("HAS_NEXT"), false );
2024         nlassert(node != NULL);
2025         _HAS_NEXT = node;
2026
2027
2028         // branch init
2029
2030         for (uint i=0; i<8; ++i)
2031         {
2032                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
2033                 nlassert(node != NULL);
2034                 _Array[i].init(node, i);
2035         }
2036
2037 }
2038
2039
2040 void CBankAccessor_PLR::TASCENSOR::TArray::init(ICDBStructNode *parent, uint index)
2041 {
2042         ICDBStructNode *node = parent;
2043
2044         _BranchNode = node;
2045
2046         // leaf init
2047
2048         node  = parent->getNode( ICDBStructNode::CTextId("ICON"), false );
2049         nlassert(node != NULL);
2050         _ICON = node;
2051
2052         node  = parent->getNode( ICDBStructNode::CTextId("NAME"), false );
2053         nlassert(node != NULL);
2054         _NAME = node;
2055
2056
2057         // branch init
2058
2059 }
2060
2061
2062 void CBankAccessor_PLR::TCHOOSE_MISSIONS::init(ICDBStructNode *parent)
2063 {
2064         ICDBStructNode *node = parent;
2065
2066         _BranchNode = node;
2067
2068         // leaf init
2069
2070         node  = parent->getNode( ICDBStructNode::CTextId("SESSION"), false );
2071         nlassert(node != NULL);
2072         _SESSION = node;
2073
2074         node  = parent->getNode( ICDBStructNode::CTextId("PAGE_ID"), false );
2075         nlassert(node != NULL);
2076         _PAGE_ID = node;
2077
2078         node  = parent->getNode( ICDBStructNode::CTextId("HAS_NEXT"), false );
2079         nlassert(node != NULL);
2080         _HAS_NEXT = node;
2081
2082
2083         // branch init
2084
2085         for (uint i=0; i<8; ++i)
2086         {
2087                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
2088                 nlassert(node != NULL);
2089                 _Array[i].init(node, i);
2090         }
2091
2092 }
2093
2094
2095 void CBankAccessor_PLR::TCHOOSE_MISSIONS::TArray::init(ICDBStructNode *parent, uint index)
2096 {
2097         ICDBStructNode *node = parent;
2098
2099         _BranchNode = node;
2100
2101         // leaf init
2102
2103         node  = parent->getNode( ICDBStructNode::CTextId("ICON"), false );
2104         nlassert(node != NULL);
2105         _ICON = node;
2106
2107         node  = parent->getNode( ICDBStructNode::CTextId("TEXT"), false );
2108         nlassert(node != NULL);
2109         _TEXT = node;
2110
2111         node  = parent->getNode( ICDBStructNode::CTextId("DETAIL_TEXT"), false );
2112         nlassert(node != NULL);
2113         _DETAIL_TEXT = node;
2114
2115         node  = parent->getNode( ICDBStructNode::CTextId("PREREQ_STATE"), false );
2116         nlassert(node != NULL);
2117         _PREREQ_STATE = node;
2118
2119
2120         // branch init
2121
2122 }
2123
2124
2125 void CBankAccessor_PLR::TTRADING::init(ICDBStructNode *parent)
2126 {
2127         ICDBStructNode *node = parent;
2128
2129         _BranchNode = node;
2130
2131         // leaf init
2132
2133         node  = parent->getNode( ICDBStructNode::CTextId("SESSION"), false );
2134         nlassert(node != NULL);
2135         _SESSION = node;
2136
2137         node  = parent->getNode( ICDBStructNode::CTextId("PAGE_ID"), false );
2138         nlassert(node != NULL);
2139         _PAGE_ID = node;
2140
2141         node  = parent->getNode( ICDBStructNode::CTextId("HAS_NEXT"), false );
2142         nlassert(node != NULL);
2143         _HAS_NEXT = node;
2144
2145         node  = parent->getNode( ICDBStructNode::CTextId("ROLEMASTER_FLAGS"), false );
2146         nlassert(node != NULL);
2147         _ROLEMASTER_FLAGS = node;
2148
2149         node  = parent->getNode( ICDBStructNode::CTextId("ROLEMASTER_RACE"), false );
2150         nlassert(node != NULL);
2151         _ROLEMASTER_RACE = node;
2152
2153         node  = parent->getNode( ICDBStructNode::CTextId("BUILDING_LOSS_WARNING"), false );
2154         nlassert(node != NULL);
2155         _BUILDING_LOSS_WARNING = node;
2156
2157         node  = parent->getNode( ICDBStructNode::CTextId("RAW_MATERIAL_SELLER"), false );
2158         nlassert(node != NULL);
2159         _RAW_MATERIAL_SELLER = node;
2160
2161         node  = parent->getNode( ICDBStructNode::CTextId("ITEM_TYPE_SELLER_BITFILED_0_63"), false );
2162         nlassert(node != NULL);
2163         _ITEM_TYPE_SELLER_BITFILED_0_63 = node;
2164
2165         node  = parent->getNode( ICDBStructNode::CTextId("ITEM_TYPE_SELLER_BITFILED_64_127"), false );
2166         nlassert(node != NULL);
2167         _ITEM_TYPE_SELLER_BITFILED_64_127 = node;
2168
2169         node  = parent->getNode( ICDBStructNode::CTextId("FAME_PRICE_FACTOR"), false );
2170         nlassert(node != NULL);
2171         _FAME_PRICE_FACTOR = node;
2172
2173
2174         // branch init
2175
2176         for (uint i=0; i<8; ++i)
2177         {
2178                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
2179                 nlassert(node != NULL);
2180                 _Array[i].init(node, i);
2181         }
2182
2183 }
2184
2185
2186 void CBankAccessor_PLR::TTRADING::TArray::init(ICDBStructNode *parent, uint index)
2187 {
2188         ICDBStructNode *node = parent;
2189
2190         _BranchNode = node;
2191
2192         // leaf init
2193
2194         node  = parent->getNode( ICDBStructNode::CTextId("SHEET"), false );
2195         nlassert(node != NULL);
2196         _SHEET = node;
2197
2198         node  = parent->getNode( ICDBStructNode::CTextId("QUALITY"), false );
2199         nlassert(node != NULL);
2200         _QUALITY = node;
2201
2202         node  = parent->getNode( ICDBStructNode::CTextId("QUANTITY"), false );
2203         nlassert(node != NULL);
2204         _QUANTITY = node;
2205
2206         node  = parent->getNode( ICDBStructNode::CTextId("CREATE_TIME"), false );
2207         nlassert(node != NULL);
2208         _CREATE_TIME = node;
2209
2210         node  = parent->getNode( ICDBStructNode::CTextId("SERIAL"), false );
2211         nlassert(node != NULL);
2212         _SERIAL = node;
2213
2214         node  = parent->getNode( ICDBStructNode::CTextId("USER_COLOR"), false );
2215         nlassert(node != NULL);
2216         _USER_COLOR = node;
2217
2218         node  = parent->getNode( ICDBStructNode::CTextId("WEIGHT"), false );
2219         nlassert(node != NULL);
2220         _WEIGHT = node;
2221
2222         node  = parent->getNode( ICDBStructNode::CTextId("NAMEID"), false );
2223         nlassert(node != NULL);
2224         _NAMEID = node;
2225
2226         node  = parent->getNode( ICDBStructNode::CTextId("INFO_VERSION"), false );
2227         nlassert(node != NULL);
2228         _INFO_VERSION = node;
2229
2230         node  = parent->getNode( ICDBStructNode::CTextId("ENCHANT"), false );
2231         nlassert(node != NULL);
2232         _ENCHANT = node;
2233
2234         node  = parent->getNode( ICDBStructNode::CTextId("RM_CLASS_TYPE"), false );
2235         nlassert(node != NULL);
2236         _RM_CLASS_TYPE = node;
2237
2238         node  = parent->getNode( ICDBStructNode::CTextId("RM_FABER_STAT_TYPE"), false );
2239         nlassert(node != NULL);
2240         _RM_FABER_STAT_TYPE = node;
2241
2242         node  = parent->getNode( ICDBStructNode::CTextId("PREREQUISIT_VALID"), false );
2243         nlassert(node != NULL);
2244         _PREREQUISIT_VALID = node;
2245
2246         node  = parent->getNode( ICDBStructNode::CTextId("CURRENCY"), false );
2247         nlassert(node != NULL);
2248         _CURRENCY = node;
2249
2250         node  = parent->getNode( ICDBStructNode::CTextId("RRP_LEVEL"), false );
2251         nlassert(node != NULL);
2252         _RRP_LEVEL = node;
2253
2254         node  = parent->getNode( ICDBStructNode::CTextId("MONEY_SHEET"), false );
2255         nlassert(node != NULL);
2256         _MONEY_SHEET = node;
2257
2258         node  = parent->getNode( ICDBStructNode::CTextId("BASE_SKILL"), false );
2259         nlassert(node != NULL);
2260         _BASE_SKILL = node;
2261
2262         node  = parent->getNode( ICDBStructNode::CTextId("FACTION_TYPE"), false );
2263         nlassert(node != NULL);
2264         _FACTION_TYPE = node;
2265
2266         node  = parent->getNode( ICDBStructNode::CTextId("PRICE"), false );
2267         nlassert(node != NULL);
2268         _PRICE = node;
2269
2270         node  = parent->getNode( ICDBStructNode::CTextId("PRICE_RETIRE"), false );
2271         nlassert(node != NULL);
2272         _PRICE_RETIRE = node;
2273
2274         node  = parent->getNode( ICDBStructNode::CTextId("RESALE_TIME_LEFT"), false );
2275         nlassert(node != NULL);
2276         _RESALE_TIME_LEFT = node;
2277
2278         node  = parent->getNode( ICDBStructNode::CTextId("VENDOR_NAMEID"), false );
2279         nlassert(node != NULL);
2280         _VENDOR_NAMEID = node;
2281
2282         node  = parent->getNode( ICDBStructNode::CTextId("FACTION_POINT_PRICE"), false );
2283         nlassert(node != NULL);
2284         _FACTION_POINT_PRICE = node;
2285
2286         node  = parent->getNode( ICDBStructNode::CTextId("SLOT_TYPE"), false );
2287         nlassert(node != NULL);
2288         _SLOT_TYPE = node;
2289
2290         node  = parent->getNode( ICDBStructNode::CTextId("SELLER_TYPE"), false );
2291         nlassert(node != NULL);
2292         _SELLER_TYPE = node;
2293
2294
2295         // branch init
2296
2297 }
2298
2299
2300 void CBankAccessor_PLR::TBRICK_FAMILY::init(ICDBStructNode *parent)
2301 {
2302         ICDBStructNode *node = parent;
2303
2304         _BranchNode = node;
2305
2306         // leaf init
2307
2308
2309         // branch init
2310
2311         for (uint i=0; i<1024; ++i)
2312         {
2313                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
2314                 nlassert(node != NULL);
2315                 _Array[i].init(node, i);
2316         }
2317
2318 }
2319
2320
2321 void CBankAccessor_PLR::TBRICK_FAMILY::TArray::init(ICDBStructNode *parent, uint index)
2322 {
2323         ICDBStructNode *node = parent;
2324
2325         _BranchNode = node;
2326
2327         // leaf init
2328
2329         node  = parent->getNode( ICDBStructNode::CTextId("BRICKS"), false );
2330         nlassert(node != NULL);
2331         _BRICKS = node;
2332
2333
2334         // branch init
2335
2336 }
2337
2338
2339 void CBankAccessor_PLR::TFABER_PLANS::init(ICDBStructNode *parent)
2340 {
2341         ICDBStructNode *node = parent;
2342
2343         _BranchNode = node;
2344
2345         // leaf init
2346
2347
2348         // branch init
2349
2350         for (uint i=0; i<64; ++i)
2351         {
2352                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
2353                 nlassert(node != NULL);
2354                 _Array[i].init(node, i);
2355         }
2356
2357 }
2358
2359
2360 void CBankAccessor_PLR::TFABER_PLANS::TArray::init(ICDBStructNode *parent, uint index)
2361 {
2362         ICDBStructNode *node = parent;
2363
2364         _BranchNode = node;
2365
2366         // leaf init
2367
2368         node  = parent->getNode( ICDBStructNode::CTextId("KNOWN"), false );
2369         nlassert(node != NULL);
2370         _KNOWN = node;
2371
2372
2373         // branch init
2374
2375 }
2376
2377
2378 void CBankAccessor_PLR::TMISSIONS::init(ICDBStructNode *parent)
2379 {
2380         ICDBStructNode *node = parent;
2381
2382         _BranchNode = node;
2383
2384         // leaf init
2385
2386
2387         // branch init
2388
2389         for (uint i=0; i<15; ++i)
2390         {
2391                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
2392                 nlassert(node != NULL);
2393                 _Array[i].init(node, i);
2394         }
2395
2396 }
2397
2398
2399 void CBankAccessor_PLR::TMISSIONS::TArray::init(ICDBStructNode *parent, uint index)
2400 {
2401         ICDBStructNode *node = parent;
2402
2403         _BranchNode = node;
2404
2405         // leaf init
2406
2407         node  = parent->getNode( ICDBStructNode::CTextId("TYPE"), false );
2408         nlassert(node != NULL);
2409         _TYPE = node;
2410
2411         node  = parent->getNode( ICDBStructNode::CTextId("ICON"), false );
2412         nlassert(node != NULL);
2413         _ICON = node;
2414
2415         node  = parent->getNode( ICDBStructNode::CTextId("TITLE"), false );
2416         nlassert(node != NULL);
2417         _TITLE = node;
2418
2419         node  = parent->getNode( ICDBStructNode::CTextId("DETAIL_TEXT"), false );
2420         nlassert(node != NULL);
2421         _DETAIL_TEXT = node;
2422
2423         node  = parent->getNode( ICDBStructNode::CTextId("BEGIN_DATE"), false );
2424         nlassert(node != NULL);
2425         _BEGIN_DATE = node;
2426
2427         node  = parent->getNode( ICDBStructNode::CTextId("END_DATE"), false );
2428         nlassert(node != NULL);
2429         _END_DATE = node;
2430
2431         node  = parent->getNode( ICDBStructNode::CTextId("OR_STEPS"), false );
2432         nlassert(node != NULL);
2433         _OR_STEPS = node;
2434
2435         node  = parent->getNode( ICDBStructNode::CTextId("FINISHED"), false );
2436         nlassert(node != NULL);
2437         _FINISHED = node;
2438
2439         node  = parent->getNode( ICDBStructNode::CTextId("ABANDONNABLE"), false );
2440         nlassert(node != NULL);
2441         _ABANDONNABLE = node;
2442
2443         node  = parent->getNode( ICDBStructNode::CTextId("SLEEP"), false );
2444         nlassert(node != NULL);
2445         _SLEEP = node;
2446
2447
2448         // branch init
2449
2450         node  = parent->getNode( ICDBStructNode::CTextId("GOALS"), false );
2451         nlassert(node != NULL);
2452         _GOALS.init(node);
2453
2454         for (uint i=0; i<8; ++i)
2455         {
2456                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("TARGET%u", i)), false );
2457                 nlassert(node != NULL);
2458                 _TARGET[i].init(node, i);
2459         }
2460
2461         node  = parent->getNode( ICDBStructNode::CTextId("HISTO"), false );
2462         nlassert(node != NULL);
2463         _HISTO.init(node);
2464
2465 }
2466
2467
2468 void CBankAccessor_PLR::TMISSIONS::TArray::TGOALS::init(ICDBStructNode *parent)
2469 {
2470         ICDBStructNode *node = parent;
2471
2472         _BranchNode = node;
2473
2474         // leaf init
2475
2476
2477         // branch init
2478
2479         for (uint i=0; i<20; ++i)
2480         {
2481                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
2482                 nlassert(node != NULL);
2483                 _Array[i].init(node, i);
2484         }
2485
2486 }
2487
2488
2489 void CBankAccessor_PLR::TMISSIONS::TArray::TGOALS::TArray::init(ICDBStructNode *parent, uint index)
2490 {
2491         ICDBStructNode *node = parent;
2492
2493         _BranchNode = node;
2494
2495         // leaf init
2496
2497         node  = parent->getNode( ICDBStructNode::CTextId("TEXT"), false );
2498         nlassert(node != NULL);
2499         _TEXT = node;
2500
2501         node  = parent->getNode( ICDBStructNode::CTextId("NPC_ALIAS"), false );
2502         nlassert(node != NULL);
2503         _NPC_ALIAS = node;
2504
2505
2506         // branch init
2507
2508 }
2509
2510
2511 void CBankAccessor_PLR::TMISSIONS::TArray::TTARGET::init(ICDBStructNode *parent, uint index)
2512 {
2513         ICDBStructNode *node = parent;
2514
2515         _BranchNode = node;
2516
2517         // leaf init
2518
2519         node  = parent->getNode( ICDBStructNode::CTextId("TITLE"), false );
2520         nlassert(node != NULL);
2521         _TITLE = node;
2522
2523         node  = parent->getNode( ICDBStructNode::CTextId("X"), false );
2524         nlassert(node != NULL);
2525         _X = node;
2526
2527         node  = parent->getNode( ICDBStructNode::CTextId("Y"), false );
2528         nlassert(node != NULL);
2529         _Y = node;
2530
2531
2532         // branch init
2533
2534 }
2535
2536
2537 void CBankAccessor_PLR::TMISSIONS::TArray::THISTO::init(ICDBStructNode *parent)
2538 {
2539         ICDBStructNode *node = parent;
2540
2541         _BranchNode = node;
2542
2543         // leaf init
2544
2545
2546         // branch init
2547
2548         for (uint i=0; i<30; ++i)
2549         {
2550                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
2551                 nlassert(node != NULL);
2552                 _Array[i].init(node, i);
2553         }
2554
2555 }
2556
2557
2558 void CBankAccessor_PLR::TMISSIONS::TArray::THISTO::TArray::init(ICDBStructNode *parent, uint index)
2559 {
2560         ICDBStructNode *node = parent;
2561
2562         _BranchNode = node;
2563
2564         // leaf init
2565
2566         node  = parent->getNode( ICDBStructNode::CTextId("TEXT"), false );
2567         nlassert(node != NULL);
2568         _TEXT = node;
2569
2570
2571         // branch init
2572
2573 }
2574
2575
2576 void CBankAccessor_PLR::TEXECUTE_PHRASE::init(ICDBStructNode *parent)
2577 {
2578         ICDBStructNode *node = parent;
2579
2580         _BranchNode = node;
2581
2582         // leaf init
2583
2584         node  = parent->getNode( ICDBStructNode::CTextId("PHRASE"), false );
2585         nlassert(node != NULL);
2586         _PHRASE = node;
2587
2588         node  = parent->getNode( ICDBStructNode::CTextId("SHEET"), false );
2589         nlassert(node != NULL);
2590         _SHEET = node;
2591
2592         node  = parent->getNode( ICDBStructNode::CTextId("NEXT_COUNTER"), false );
2593         nlassert(node != NULL);
2594         _NEXT_COUNTER = node;
2595
2596         node  = parent->getNode( ICDBStructNode::CTextId("CYCLE_COUNTER"), false );
2597         nlassert(node != NULL);
2598         _CYCLE_COUNTER = node;
2599
2600
2601         // branch init
2602
2603         node  = parent->getNode( ICDBStructNode::CTextId("LINK"), false );
2604         nlassert(node != NULL);
2605         _LINK.init(node);
2606
2607 }
2608
2609
2610 void CBankAccessor_PLR::TEXECUTE_PHRASE::TLINK::init(ICDBStructNode *parent)
2611 {
2612         ICDBStructNode *node = parent;
2613
2614         _BranchNode = node;
2615
2616         // leaf init
2617
2618
2619         // branch init
2620
2621         for (uint i=0; i<10; ++i)
2622         {
2623                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
2624                 nlassert(node != NULL);
2625                 _Array[i].init(node, i);
2626         }
2627
2628 }
2629
2630
2631 void CBankAccessor_PLR::TEXECUTE_PHRASE::TLINK::TArray::init(ICDBStructNode *parent, uint index)
2632 {
2633         ICDBStructNode *node = parent;
2634
2635         _BranchNode = node;
2636
2637         // leaf init
2638
2639         node  = parent->getNode( ICDBStructNode::CTextId("PHRASE"), false );
2640         nlassert(node != NULL);
2641         _PHRASE = node;
2642
2643         node  = parent->getNode( ICDBStructNode::CTextId("COUNTER"), false );
2644         nlassert(node != NULL);
2645         _COUNTER = node;
2646
2647         node  = parent->getNode( ICDBStructNode::CTextId("HP_COST"), false );
2648         nlassert(node != NULL);
2649         _HP_COST = node;
2650
2651         node  = parent->getNode( ICDBStructNode::CTextId("SAP_COST"), false );
2652         nlassert(node != NULL);
2653         _SAP_COST = node;
2654
2655         node  = parent->getNode( ICDBStructNode::CTextId("STA_COST"), false );
2656         nlassert(node != NULL);
2657         _STA_COST = node;
2658
2659         node  = parent->getNode( ICDBStructNode::CTextId("TARGET_NAME"), false );
2660         nlassert(node != NULL);
2661         _TARGET_NAME = node;
2662
2663         node  = parent->getNode( ICDBStructNode::CTextId("TARGET_HP"), false );
2664         nlassert(node != NULL);
2665         _TARGET_HP = node;
2666
2667         node  = parent->getNode( ICDBStructNode::CTextId("TARGET_SAP"), false );
2668         nlassert(node != NULL);
2669         _TARGET_SAP = node;
2670
2671         node  = parent->getNode( ICDBStructNode::CTextId("TARGET_STA"), false );
2672         nlassert(node != NULL);
2673         _TARGET_STA = node;
2674
2675
2676         // branch init
2677
2678 }
2679
2680
2681 void CBankAccessor_PLR::TCHARACTER_INFO::init(ICDBStructNode *parent)
2682 {
2683         ICDBStructNode *node = parent;
2684
2685         _BranchNode = node;
2686
2687         // leaf init
2688
2689
2690         // branch init
2691
2692         for (uint i=0; i<8; ++i)
2693         {
2694                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("CHARACTERISTICS%u", i)), false );
2695                 nlassert(node != NULL);
2696                 _CHARACTERISTICS[i].init(node, i);
2697         }
2698
2699         for (uint i=0; i<4; ++i)
2700         {
2701                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("SCORES%u", i)), false );
2702                 nlassert(node != NULL);
2703                 _SCORES[i].init(node, i);
2704         }
2705
2706         node  = parent->getNode( ICDBStructNode::CTextId("MAGIC_RESISTANCE"), false );
2707         nlassert(node != NULL);
2708         _MAGIC_RESISTANCE.init(node);
2709
2710         node  = parent->getNode( ICDBStructNode::CTextId("MAGIC_PROTECTION"), false );
2711         nlassert(node != NULL);
2712         _MAGIC_PROTECTION.init(node);
2713
2714         node  = parent->getNode( ICDBStructNode::CTextId("DODGE"), false );
2715         nlassert(node != NULL);
2716         _DODGE.init(node);
2717
2718         node  = parent->getNode( ICDBStructNode::CTextId("PARRY"), false );
2719         nlassert(node != NULL);
2720         _PARRY.init(node);
2721
2722         node  = parent->getNode( ICDBStructNode::CTextId("SKILLS"), false );
2723         nlassert(node != NULL);
2724         _SKILLS.init(node);
2725
2726         node  = parent->getNode( ICDBStructNode::CTextId("XP_CATALYSER"), false );
2727         nlassert(node != NULL);
2728         _XP_CATALYSER.init(node);
2729
2730         node  = parent->getNode( ICDBStructNode::CTextId("RING_XP_CATALYSER"), false );
2731         nlassert(node != NULL);
2732         _RING_XP_CATALYSER.init(node);
2733
2734         node  = parent->getNode( ICDBStructNode::CTextId("PVP_FACTION_TAG"), false );
2735         nlassert(node != NULL);
2736         _PVP_FACTION_TAG.init(node);
2737
2738         node  = parent->getNode( ICDBStructNode::CTextId("PVP_OUTPOST"), false );
2739         nlassert(node != NULL);
2740         _PVP_OUTPOST.init(node);
2741
2742         node  = parent->getNode( ICDBStructNode::CTextId("SUCCESS_MODIFIER"), false );
2743         nlassert(node != NULL);
2744         _SUCCESS_MODIFIER.init(node);
2745
2746 }
2747
2748
2749 void CBankAccessor_PLR::TCHARACTER_INFO::TCHARACTERISTICS::init(ICDBStructNode *parent, uint index)
2750 {
2751         ICDBStructNode *node = parent;
2752
2753         _BranchNode = node;
2754
2755         // leaf init
2756
2757         node  = parent->getNode( ICDBStructNode::CTextId("VALUE"), false );
2758         nlassert(node != NULL);
2759         _VALUE = node;
2760
2761
2762         // branch init
2763
2764 }
2765
2766
2767 void CBankAccessor_PLR::TCHARACTER_INFO::TSCORES::init(ICDBStructNode *parent, uint index)
2768 {
2769         ICDBStructNode *node = parent;
2770
2771         _BranchNode = node;
2772
2773         // leaf init
2774
2775         node  = parent->getNode( ICDBStructNode::CTextId("Base"), false );
2776         nlassert(node != NULL);
2777         _Base = node;
2778
2779         node  = parent->getNode( ICDBStructNode::CTextId("Max"), false );
2780         nlassert(node != NULL);
2781         _Max = node;
2782
2783         node  = parent->getNode( ICDBStructNode::CTextId("BaseRegen"), false );
2784         nlassert(node != NULL);
2785         _BaseRegen = node;
2786
2787         node  = parent->getNode( ICDBStructNode::CTextId("Regen"), false );
2788         nlassert(node != NULL);
2789         _Regen = node;
2790
2791
2792         // branch init
2793
2794 }
2795
2796
2797 void CBankAccessor_PLR::TCHARACTER_INFO::TMAGIC_RESISTANCE::init(ICDBStructNode *parent)
2798 {
2799         ICDBStructNode *node = parent;
2800
2801         _BranchNode = node;
2802
2803         // leaf init
2804
2805         node  = parent->getNode( ICDBStructNode::CTextId("MaxResistanceBonus"), false );
2806         nlassert(node != NULL);
2807         _MaxResistanceBonus = node;
2808
2809
2810         // branch init
2811
2812         for (uint i=0; i<5; ++i)
2813         {
2814                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
2815                 nlassert(node != NULL);
2816                 _Array[i].init(node, i);
2817         }
2818
2819 }
2820
2821
2822 void CBankAccessor_PLR::TCHARACTER_INFO::TMAGIC_RESISTANCE::TArray::init(ICDBStructNode *parent, uint index)
2823 {
2824         ICDBStructNode *node = parent;
2825
2826         _BranchNode = node;
2827
2828         // leaf init
2829
2830         node  = parent->getNode( ICDBStructNode::CTextId("VALUE"), false );
2831         nlassert(node != NULL);
2832         _VALUE = node;
2833
2834
2835         // branch init
2836
2837 }
2838
2839
2840 void CBankAccessor_PLR::TCHARACTER_INFO::TMAGIC_PROTECTION::init(ICDBStructNode *parent)
2841 {
2842         ICDBStructNode *node = parent;
2843
2844         _BranchNode = node;
2845
2846         // leaf init
2847
2848         node  = parent->getNode( ICDBStructNode::CTextId("MaxProtectionClampValue"), false );
2849         nlassert(node != NULL);
2850         _MaxProtectionClampValue = node;
2851
2852         node  = parent->getNode( ICDBStructNode::CTextId("MaxAbsorptionFactor"), false );
2853         nlassert(node != NULL);
2854         _MaxAbsorptionFactor = node;
2855
2856
2857         // branch init
2858
2859         for (uint i=0; i<7; ++i)
2860         {
2861                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
2862                 nlassert(node != NULL);
2863                 _Array[i].init(node, i);
2864         }
2865
2866 }
2867
2868
2869 void CBankAccessor_PLR::TCHARACTER_INFO::TMAGIC_PROTECTION::TArray::init(ICDBStructNode *parent, uint index)
2870 {
2871         ICDBStructNode *node = parent;
2872
2873         _BranchNode = node;
2874
2875         // leaf init
2876
2877         node  = parent->getNode( ICDBStructNode::CTextId("VALUE"), false );
2878         nlassert(node != NULL);
2879         _VALUE = node;
2880
2881
2882         // branch init
2883
2884 }
2885
2886
2887 void CBankAccessor_PLR::TCHARACTER_INFO::TDODGE::init(ICDBStructNode *parent)
2888 {
2889         ICDBStructNode *node = parent;
2890
2891         _BranchNode = node;
2892
2893         // leaf init
2894
2895         node  = parent->getNode( ICDBStructNode::CTextId("Base"), false );
2896         nlassert(node != NULL);
2897         _Base = node;
2898
2899         node  = parent->getNode( ICDBStructNode::CTextId("Current"), false );
2900         nlassert(node != NULL);
2901         _Current = node;
2902
2903
2904         // branch init
2905
2906 }
2907
2908
2909 void CBankAccessor_PLR::TCHARACTER_INFO::TPARRY::init(ICDBStructNode *parent)
2910 {
2911         ICDBStructNode *node = parent;
2912
2913         _BranchNode = node;
2914
2915         // leaf init
2916
2917         node  = parent->getNode( ICDBStructNode::CTextId("Base"), false );
2918         nlassert(node != NULL);
2919         _Base = node;
2920
2921         node  = parent->getNode( ICDBStructNode::CTextId("Current"), false );
2922         nlassert(node != NULL);
2923         _Current = node;
2924
2925
2926         // branch init
2927
2928 }
2929
2930
2931 void CBankAccessor_PLR::TCHARACTER_INFO::TSKILLS::init(ICDBStructNode *parent)
2932 {
2933         ICDBStructNode *node = parent;
2934
2935         _BranchNode = node;
2936
2937         // leaf init
2938
2939
2940         // branch init
2941
2942         for (uint i=0; i<225; ++i)
2943         {
2944                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
2945                 nlassert(node != NULL);
2946                 _Array[i].init(node, i);
2947         }
2948
2949 }
2950
2951
2952 void CBankAccessor_PLR::TCHARACTER_INFO::TSKILLS::TArray::init(ICDBStructNode *parent, uint index)
2953 {
2954         ICDBStructNode *node = parent;
2955
2956         _BranchNode = node;
2957
2958         // leaf init
2959
2960         node  = parent->getNode( ICDBStructNode::CTextId("SKILL"), false );
2961         nlassert(node != NULL);
2962         _SKILL = node;
2963
2964         node  = parent->getNode( ICDBStructNode::CTextId("BaseSKILL"), false );
2965         nlassert(node != NULL);
2966         _BaseSKILL = node;
2967
2968         node  = parent->getNode( ICDBStructNode::CTextId("PROGRESS_BAR"), false );
2969         nlassert(node != NULL);
2970         _PROGRESS_BAR = node;
2971
2972
2973         // branch init
2974
2975 }
2976
2977
2978 void CBankAccessor_PLR::TCHARACTER_INFO::TXP_CATALYSER::init(ICDBStructNode *parent)
2979 {
2980         ICDBStructNode *node = parent;
2981
2982         _BranchNode = node;
2983
2984         // leaf init
2985
2986         node  = parent->getNode( ICDBStructNode::CTextId("Level"), false );
2987         nlassert(node != NULL);
2988         _Level = node;
2989
2990         node  = parent->getNode( ICDBStructNode::CTextId("Count"), false );
2991         nlassert(node != NULL);
2992         _Count = node;
2993
2994
2995         // branch init
2996
2997 }
2998
2999
3000 void CBankAccessor_PLR::TCHARACTER_INFO::TRING_XP_CATALYSER::init(ICDBStructNode *parent)
3001 {
3002         ICDBStructNode *node = parent;
3003
3004         _BranchNode = node;
3005
3006         // leaf init
3007
3008         node  = parent->getNode( ICDBStructNode::CTextId("Level"), false );
3009         nlassert(node != NULL);
3010         _Level = node;
3011
3012         node  = parent->getNode( ICDBStructNode::CTextId("Count"), false );
3013         nlassert(node != NULL);
3014         _Count = node;
3015
3016
3017         // branch init
3018
3019 }
3020
3021
3022 void CBankAccessor_PLR::TCHARACTER_INFO::TPVP_FACTION_TAG::init(ICDBStructNode *parent)
3023 {
3024         ICDBStructNode *node = parent;
3025
3026         _BranchNode = node;
3027
3028         // leaf init
3029
3030         node  = parent->getNode( ICDBStructNode::CTextId("TAG_PVP"), false );
3031         nlassert(node != NULL);
3032         _TAG_PVP = node;
3033
3034         node  = parent->getNode( ICDBStructNode::CTextId("ACTIVATION_TIME"), false );
3035         nlassert(node != NULL);
3036         _ACTIVATION_TIME = node;
3037
3038         node  = parent->getNode( ICDBStructNode::CTextId("FLAG_PVP_TIME_LEFT"), false );
3039         nlassert(node != NULL);
3040         _FLAG_PVP_TIME_LEFT = node;
3041
3042         node  = parent->getNode( ICDBStructNode::CTextId("COUNTER"), false );
3043         nlassert(node != NULL);
3044         _COUNTER = node;
3045
3046
3047         // branch init
3048
3049 }
3050
3051
3052 void CBankAccessor_PLR::TCHARACTER_INFO::TPVP_OUTPOST::init(ICDBStructNode *parent)
3053 {
3054         ICDBStructNode *node = parent;
3055
3056         _BranchNode = node;
3057
3058         // leaf init
3059
3060         node  = parent->getNode( ICDBStructNode::CTextId("FLAG_PVP"), false );
3061         nlassert(node != NULL);
3062         _FLAG_PVP = node;
3063
3064         node  = parent->getNode( ICDBStructNode::CTextId("RIGHT_TO_BANISH"), false );
3065         nlassert(node != NULL);
3066         _RIGHT_TO_BANISH = node;
3067
3068         node  = parent->getNode( ICDBStructNode::CTextId("ROUND_LVL_CUR"), false );
3069         nlassert(node != NULL);
3070         _ROUND_LVL_CUR = node;
3071
3072         node  = parent->getNode( ICDBStructNode::CTextId("ROUND_END_DATE"), false );
3073         nlassert(node != NULL);
3074         _ROUND_END_DATE = node;
3075
3076         node  = parent->getNode( ICDBStructNode::CTextId("FLAG_PVP_TIME_END"), false );
3077         nlassert(node != NULL);
3078         _FLAG_PVP_TIME_END = node;
3079
3080
3081         // branch init
3082
3083 }
3084
3085
3086 void CBankAccessor_PLR::TCHARACTER_INFO::TSUCCESS_MODIFIER::init(ICDBStructNode *parent)
3087 {
3088         ICDBStructNode *node = parent;
3089
3090         _BranchNode = node;
3091
3092         // leaf init
3093
3094         node  = parent->getNode( ICDBStructNode::CTextId("DODGE"), false );
3095         nlassert(node != NULL);
3096         _DODGE = node;
3097
3098         node  = parent->getNode( ICDBStructNode::CTextId("PARRY"), false );
3099         nlassert(node != NULL);
3100         _PARRY = node;
3101
3102         node  = parent->getNode( ICDBStructNode::CTextId("CRAFT"), false );
3103         nlassert(node != NULL);
3104         _CRAFT = node;
3105
3106         node  = parent->getNode( ICDBStructNode::CTextId("MELEE"), false );
3107         nlassert(node != NULL);
3108         _MELEE = node;
3109
3110         node  = parent->getNode( ICDBStructNode::CTextId("RANGE"), false );
3111         nlassert(node != NULL);
3112         _RANGE = node;
3113
3114         node  = parent->getNode( ICDBStructNode::CTextId("MAGIC"), false );
3115         nlassert(node != NULL);
3116         _MAGIC = node;
3117
3118
3119         // branch init
3120
3121         node  = parent->getNode( ICDBStructNode::CTextId("ECO"), false );
3122         nlassert(node != NULL);
3123         _ECO.init(node);
3124
3125 }
3126
3127
3128 void CBankAccessor_PLR::TCHARACTER_INFO::TSUCCESS_MODIFIER::TECO::init(ICDBStructNode *parent)
3129 {
3130         ICDBStructNode *node = parent;
3131
3132         _BranchNode = node;
3133
3134         // leaf init
3135
3136
3137         // branch init
3138
3139         for (uint i=0; i<7; ++i)
3140         {
3141                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
3142                 nlassert(node != NULL);
3143                 _Array[i].init(node, i);
3144         }
3145
3146 }
3147
3148
3149 void CBankAccessor_PLR::TCHARACTER_INFO::TSUCCESS_MODIFIER::TECO::TArray::init(ICDBStructNode *parent, uint index)
3150 {
3151         ICDBStructNode *node = parent;
3152
3153         _BranchNode = node;
3154
3155         // leaf init
3156
3157         node  = parent->getNode( ICDBStructNode::CTextId("FORAGE"), false );
3158         nlassert(node != NULL);
3159         _FORAGE = node;
3160
3161
3162         // branch init
3163
3164 }
3165
3166
3167 void CBankAccessor_PLR::TPACK_ANIMAL::init(ICDBStructNode *parent)
3168 {
3169         ICDBStructNode *node = parent;
3170
3171         _BranchNode = node;
3172
3173         // leaf init
3174
3175
3176         // branch init
3177
3178         for (uint i=0; i<7; ++i)
3179         {
3180                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("BEAST%u", i)), false );
3181                 nlassert(node != NULL);
3182                 _BEAST[i].init(node, i);
3183         }
3184
3185 }
3186
3187
3188 void CBankAccessor_PLR::TPACK_ANIMAL::TBEAST::init(ICDBStructNode *parent, uint index)
3189 {
3190         ICDBStructNode *node = parent;
3191
3192         _BranchNode = node;
3193
3194         // leaf init
3195
3196         node  = parent->getNode( ICDBStructNode::CTextId("UID"), false );
3197         nlassert(node != NULL);
3198         _UID = node;
3199
3200         node  = parent->getNode( ICDBStructNode::CTextId("TYPE"), false );
3201         nlassert(node != NULL);
3202         _TYPE = node;
3203
3204         node  = parent->getNode( ICDBStructNode::CTextId("STATUS"), false );
3205         nlassert(node != NULL);
3206         _STATUS = node;
3207
3208         node  = parent->getNode( ICDBStructNode::CTextId("HP"), false );
3209         nlassert(node != NULL);
3210         _HP = node;
3211
3212         node  = parent->getNode( ICDBStructNode::CTextId("BULK_MAX"), false );
3213         nlassert(node != NULL);
3214         _BULK_MAX = node;
3215
3216         node  = parent->getNode( ICDBStructNode::CTextId("POS"), false );
3217         nlassert(node != NULL);
3218         _POS = node;
3219
3220         node  = parent->getNode( ICDBStructNode::CTextId("HUNGER"), false );
3221         nlassert(node != NULL);
3222         _HUNGER = node;
3223
3224         node  = parent->getNode( ICDBStructNode::CTextId("DESPAWN"), false );
3225         nlassert(node != NULL);
3226         _DESPAWN = node;
3227
3228         node  = parent->getNode( ICDBStructNode::CTextId("NAME"), false );
3229         nlassert(node != NULL);
3230         _NAME = node;
3231
3232
3233         // branch init
3234
3235 }
3236
3237
3238 void CBankAccessor_PLR::TDEBUG_INFO::init(ICDBStructNode *parent)
3239 {
3240         ICDBStructNode *node = parent;
3241
3242         _BranchNode = node;
3243
3244         // leaf init
3245
3246         node  = parent->getNode( ICDBStructNode::CTextId("Ping"), false );
3247         nlassert(node != NULL);
3248         _Ping = node;
3249
3250
3251         // branch init
3252
3253 }
3254
3255
3256 void CBankAccessor_PLR::TMP_EVAL::init(ICDBStructNode *parent)
3257 {
3258         ICDBStructNode *node = parent;
3259
3260         _BranchNode = node;
3261
3262         // leaf init
3263
3264         node  = parent->getNode( ICDBStructNode::CTextId("COST"), false );
3265         nlassert(node != NULL);
3266         _COST = node;
3267
3268
3269         // branch init
3270
3271         node  = parent->getNode( ICDBStructNode::CTextId("RESULT"), false );
3272         nlassert(node != NULL);
3273         _RESULT.init(node);
3274
3275         node  = parent->getNode( ICDBStructNode::CTextId("RESULT_CRITICAL"), false );
3276         nlassert(node != NULL);
3277         _RESULT_CRITICAL.init(node);
3278
3279 }
3280
3281
3282 void CBankAccessor_PLR::TMP_EVAL::TRESULT::init(ICDBStructNode *parent)
3283 {
3284         ICDBStructNode *node = parent;
3285
3286         _BranchNode = node;
3287
3288         // leaf init
3289
3290         node  = parent->getNode( ICDBStructNode::CTextId("VALID"), false );
3291         nlassert(node != NULL);
3292         _VALID = node;
3293
3294         node  = parent->getNode( ICDBStructNode::CTextId("SMALL_SEED"), false );
3295         nlassert(node != NULL);
3296         _SMALL_SEED = node;
3297
3298         node  = parent->getNode( ICDBStructNode::CTextId("MEDIUM_SEED"), false );
3299         nlassert(node != NULL);
3300         _MEDIUM_SEED = node;
3301
3302         node  = parent->getNode( ICDBStructNode::CTextId("BIG_SEED"), false );
3303         nlassert(node != NULL);
3304         _BIG_SEED = node;
3305
3306         node  = parent->getNode( ICDBStructNode::CTextId("VERY_BIG_SEED"), false );
3307         nlassert(node != NULL);
3308         _VERY_BIG_SEED = node;
3309
3310         node  = parent->getNode( ICDBStructNode::CTextId("EXPIRY_DATE"), false );
3311         nlassert(node != NULL);
3312         _EXPIRY_DATE = node;
3313
3314
3315         // branch init
3316
3317 }
3318
3319
3320 void CBankAccessor_PLR::TMP_EVAL::TRESULT_CRITICAL::init(ICDBStructNode *parent)
3321 {
3322         ICDBStructNode *node = parent;
3323
3324         _BranchNode = node;
3325
3326         // leaf init
3327
3328         node  = parent->getNode( ICDBStructNode::CTextId("VALID"), false );
3329         nlassert(node != NULL);
3330         _VALID = node;
3331
3332         node  = parent->getNode( ICDBStructNode::CTextId("SMALL_SEED"), false );
3333         nlassert(node != NULL);
3334         _SMALL_SEED = node;
3335
3336         node  = parent->getNode( ICDBStructNode::CTextId("MEDIUM_SEED"), false );
3337         nlassert(node != NULL);
3338         _MEDIUM_SEED = node;
3339
3340         node  = parent->getNode( ICDBStructNode::CTextId("BIG_SEED"), false );
3341         nlassert(node != NULL);
3342         _BIG_SEED = node;
3343
3344         node  = parent->getNode( ICDBStructNode::CTextId("VERY_BIG_SEED"), false );
3345         nlassert(node != NULL);
3346         _VERY_BIG_SEED = node;
3347
3348         node  = parent->getNode( ICDBStructNode::CTextId("EXPIRY_DATE"), false );
3349         nlassert(node != NULL);
3350         _EXPIRY_DATE = node;
3351
3352
3353         // branch init
3354
3355 }
3356
3357
3358 void CBankAccessor_PLR::TCOMPASS::init(ICDBStructNode *parent)
3359 {
3360         ICDBStructNode *node = parent;
3361
3362         _BranchNode = node;
3363
3364         // leaf init
3365
3366         node  = parent->getNode( ICDBStructNode::CTextId("HOME_POINT"), false );
3367         nlassert(node != NULL);
3368         _HOME_POINT = node;
3369
3370         node  = parent->getNode( ICDBStructNode::CTextId("BIND_POINT"), false );
3371         nlassert(node != NULL);
3372         _BIND_POINT = node;
3373
3374         node  = parent->getNode( ICDBStructNode::CTextId("TARGET"), false );
3375         nlassert(node != NULL);
3376         _TARGET = node;
3377
3378
3379         // branch init
3380
3381 }
3382
3383
3384 void CBankAccessor_PLR::TFAME::init(ICDBStructNode *parent)
3385 {
3386         ICDBStructNode *node = parent;
3387
3388         _BranchNode = node;
3389
3390         // leaf init
3391
3392         node  = parent->getNode( ICDBStructNode::CTextId("CULT_ALLEGIANCE"), false );
3393         nlassert(node != NULL);
3394         _CULT_ALLEGIANCE = node;
3395
3396         node  = parent->getNode( ICDBStructNode::CTextId("CIV_ALLEGIANCE"), false );
3397         nlassert(node != NULL);
3398         _CIV_ALLEGIANCE = node;
3399
3400         node  = parent->getNode( ICDBStructNode::CTextId("THRESHOLD_TRADE"), false );
3401         nlassert(node != NULL);
3402         _THRESHOLD_TRADE = node;
3403
3404         node  = parent->getNode( ICDBStructNode::CTextId("THRESHOLD_KOS"), false );
3405         nlassert(node != NULL);
3406         _THRESHOLD_KOS = node;
3407
3408
3409         // branch init
3410
3411         for (uint i=0; i<7; ++i)
3412         {
3413                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("PLAYER%u", i)), false );
3414                 nlassert(node != NULL);
3415                 _PLAYER[i].init(node, i);
3416         }
3417
3418         for (uint i=0; i<53; ++i)
3419         {
3420                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("TRIBE%u", i)), false );
3421                 nlassert(node != NULL);
3422                 _TRIBE[i].init(node, i);
3423         }
3424
3425 }
3426
3427
3428 void CBankAccessor_PLR::TFAME::TPLAYER::init(ICDBStructNode *parent, uint index)
3429 {
3430         ICDBStructNode *node = parent;
3431
3432         _BranchNode = node;
3433
3434         // leaf init
3435
3436         node  = parent->getNode( ICDBStructNode::CTextId("VALUE"), false );
3437         nlassert(node != NULL);
3438         _VALUE = node;
3439
3440         node  = parent->getNode( ICDBStructNode::CTextId("THRESHOLD"), false );
3441         nlassert(node != NULL);
3442         _THRESHOLD = node;
3443
3444         node  = parent->getNode( ICDBStructNode::CTextId("TREND"), false );
3445         nlassert(node != NULL);
3446         _TREND = node;
3447
3448
3449         // branch init
3450
3451 }
3452
3453
3454 void CBankAccessor_PLR::TFAME::TTRIBE::init(ICDBStructNode *parent, uint index)
3455 {
3456         ICDBStructNode *node = parent;
3457
3458         _BranchNode = node;
3459
3460         // leaf init
3461
3462         node  = parent->getNode( ICDBStructNode::CTextId("VALUE"), false );
3463         nlassert(node != NULL);
3464         _VALUE = node;
3465
3466         node  = parent->getNode( ICDBStructNode::CTextId("THRESHOLD"), false );
3467         nlassert(node != NULL);
3468         _THRESHOLD = node;
3469
3470         node  = parent->getNode( ICDBStructNode::CTextId("TREND"), false );
3471         nlassert(node != NULL);
3472         _TREND = node;
3473
3474
3475         // branch init
3476
3477 }
3478
3479
3480 void CBankAccessor_PLR::TSTATIC_DATA::init(ICDBStructNode *parent)
3481 {
3482         ICDBStructNode *node = parent;
3483
3484         _BranchNode = node;
3485
3486         // leaf init
3487
3488         node  = parent->getNode( ICDBStructNode::CTextId("BAG_BULK_MAX"), false );
3489         nlassert(node != NULL);
3490         _BAG_BULK_MAX = node;
3491
3492
3493         // branch init
3494
3495 }
3496
3497
3498 void CBankAccessor_PLR::TDYN_CHAT::init(ICDBStructNode *parent)
3499 {
3500         ICDBStructNode *node = parent;
3501
3502         _BranchNode = node;
3503
3504         // leaf init
3505
3506
3507         // branch init
3508
3509         for (uint i=0; i<8; ++i)
3510         {
3511                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("CHANNEL%u", i)), false );
3512                 nlassert(node != NULL);
3513                 _CHANNEL[i].init(node, i);
3514         }
3515
3516 }
3517
3518
3519 void CBankAccessor_PLR::TDYN_CHAT::TCHANNEL::init(ICDBStructNode *parent, uint index)
3520 {
3521         ICDBStructNode *node = parent;
3522
3523         _BranchNode = node;
3524
3525         // leaf init
3526
3527         node  = parent->getNode( ICDBStructNode::CTextId("NAME"), false );
3528         nlassert(node != NULL);
3529         _NAME = node;
3530
3531         node  = parent->getNode( ICDBStructNode::CTextId("ID"), false );
3532         nlassert(node != NULL);
3533         _ID = node;
3534
3535         node  = parent->getNode( ICDBStructNode::CTextId("WRITE_RIGHT"), false );
3536         nlassert(node != NULL);
3537         _WRITE_RIGHT = node;
3538
3539
3540         // branch init
3541
3542 }
3543
3544
3545 void CBankAccessor_PLR::TPVP_EFFECTS::init(ICDBStructNode *parent)
3546 {
3547         ICDBStructNode *node = parent;
3548
3549         _BranchNode = node;
3550
3551         // leaf init
3552
3553
3554         // branch init
3555
3556         node  = parent->getNode( ICDBStructNode::CTextId("PVP_FACTION_POINTS"), false );
3557         nlassert(node != NULL);
3558         _PVP_FACTION_POINTS.init(node);
3559
3560         for (uint i=0; i<59; ++i)
3561         {
3562                 node  = parent->getNode( ICDBStructNode::CTextId(NLMISC::toString("%u", i)), false );
3563                 nlassert(node != NULL);
3564                 _Array[i].init(node, i);
3565         }
3566
3567 }
3568
3569
3570 void CBankAccessor_PLR::TPVP_EFFECTS::TPVP_FACTION_POINTS::init(ICDBStructNode *parent)
3571 {
3572         ICDBStructNode *node = parent;
3573
3574         _BranchNode = node;
3575
3576         // leaf init
3577
3578         node  = parent->getNode( ICDBStructNode::CTextId("CIV"), false );
3579         nlassert(node != NULL);
3580         _CIV = node;
3581
3582         node  = parent->getNode( ICDBStructNode::CTextId("CIV_POINTS"), false );
3583         nlassert(node != NULL);
3584         _CIV_POINTS = node;
3585
3586         node  = parent->getNode( ICDBStructNode::CTextId("CULT"), false );
3587         nlassert(node != NULL);
3588         _CULT = node;
3589
3590         node  = parent->getNode( ICDBStructNode::CTextId("CULT_POINTS"), false );
3591         nlassert(node != NULL);
3592         _CULT_POINTS = node;
3593
3594
3595         // branch init
3596
3597 }
3598
3599
3600 void CBankAccessor_PLR::TPVP_EFFECTS::TArray::init(ICDBStructNode *parent, uint index)
3601 {
3602         ICDBStructNode *node = parent;
3603
3604         _BranchNode = node;
3605
3606         // leaf init
3607
3608         node  = parent->getNode( ICDBStructNode::CTextId("ID"), false );
3609         nlassert(node != NULL);
3610         _ID = node;
3611
3612         node  = parent->getNode( ICDBStructNode::CTextId("ISBONUS"), false );
3613         nlassert(node != NULL);
3614         _ISBONUS = node;
3615
3616         node  = parent->getNode( ICDBStructNode::CTextId("PARAM"), false );
3617         nlassert(node != NULL);
3618         _PARAM = node;
3619
3620
3621         // branch init
3622
3623 }
3624
3625
3626 void CBankAccessor_PLR::TWEATHER::init(ICDBStructNode *parent)
3627 {
3628         ICDBStructNode *node = parent;
3629
3630         _BranchNode = node;
3631
3632         // leaf init
3633
3634         node  = parent->getNode( ICDBStructNode::CTextId("VALUE"), false );
3635         nlassert(node != NULL);
3636         _VALUE = node;
3637
3638
3639         // branch init
3640
3641 }
3642