?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add infos into target window
[ryzomcore.git] / ryzom / server / src / entities_game_service / database_plr.h
blob89af126c854d1859b6bd460478e3314400445735
1
2
3 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
4 // Copyright (C) 2010 Winch Gate Property Limited
5 //
6 // This program is free software: you can redistribute it and/or modify
7 // it under the terms of the GNU Affero General Public License as
8 // published by the Free Software Foundation, either version 3 of the
9 // License, or (at your option) any later version.
10 //
11 // This program is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU Affero General Public License for more details.
15 //
16 // You should have received a copy of the GNU Affero General Public License
17 // along with this program. If not, see <http://www.gnu.org/licenses/>.
18
19 /////////////////////////////////////////////////////////////////
20 // WARNING : this is a generated file, don't change it !
21 /////////////////////////////////////////////////////////////////
22
23 #ifndef INCLUDED_DATABASE_database_PLR_H
24 #define INCLUDED_DATABASE_database_PLR_H
25
26 #include "nel/misc/string_common.h"
27 #include "cdb_group.h"
28 #include "player_manager/cdb.h"
29 #include "player_manager/cdb_synchronised.h"
30
31
32
33
34 #ifndef _SET_PROP_ACCESSOR_
35 #define _SET_PROP_ACCESSOR_
36 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, bool value, bool forceSending = false)
37 {
38 db.x_setProp(node, uint64(value), forceSending);
39 }
40 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, uint8 value, bool forceSending = false)
41 {
42 db.x_setProp(node, uint64(value), forceSending);
43 }
44 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, uint16 value, bool forceSending = false)
45 {
46 db.x_setProp(node, uint64(value), forceSending);
47 }
48 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, uint32 value, bool forceSending = false)
49 {
50 db.x_setProp(node, uint64(value), forceSending);
51 }
52 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, uint64 value, bool forceSending = false)
53 {
54 db.x_setProp(node, uint64(value), forceSending);
55 }
56 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, sint8 value, bool forceSending = false)
57 {
58 db.x_setProp(node, uint64(value), forceSending);
59 }
60 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, sint16 value, bool forceSending = false)
61 {
62 db.x_setProp(node, uint64(value), forceSending);
63 }
64 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, sint32 value, bool forceSending = false)
65 {
66 db.x_setProp(node, uint64(value), forceSending);
67 }
68 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, sint64 value, bool forceSending = false)
69 {
70 db.x_setProp(node, uint64(value), forceSending);
71 }
72 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, const std::string &value, bool forceSending = false)
73 {
74 db.x_setPropString(node, value, forceSending);
75 }
76 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, const ucstring &value, bool forceSending = false)
77 {
78 db.x_setPropString(node, value, forceSending);
79 }
80 inline void _setProp(CCDBSynchronised &db, ICDBStructNode *node, const NLMISC::CSheetId &value, bool forceSending = false)
81 {
82 db.x_setProp(node, uint64(value.asInt()), forceSending);
83 }
84
85
86 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, bool &value)
87 {
88 value = db.x_getProp(node) != 0;
89 }
90 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, uint8 &value)
91 {
92 value = uint8(db.x_getProp(node));
93 }
94 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, uint16 &value)
95 {
96 value = uint16(db.x_getProp(node));
97 }
98 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, uint32 &value)
99 {
100 value = uint32(db.x_getProp(node));
101 }
102 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, uint64 &value)
103 {
104 value = db.x_getProp(node);
105 }
106 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, sint8 &value)
107 {
108 value = uint8(db.x_getProp(node));
109 }
110 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, sint16 &value)
111 {
112 value = uint16(db.x_getProp(node));
113 }
114 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, sint32 &value)
115 {
116 value = uint32(db.x_getProp(node));
117 }
118 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, sint64 &value)
119 {
120 value = db.x_getProp(node);
121 }
122 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, std::string &value)
123 {
124 value = db.x_getPropString(node);
125 }
126 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, ucstring &value)
127 {
128 value = db.x_getPropUcstring(node);
129 }
130 inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, NLMISC::CSheetId &value)
131 {
132 value = uint32(db.x_getProp(node));
133 }
134 #endif // _SET_PROP_ACCESSOR_
135
136
137
138 class CBankAccessor_PLR : public CCDBSynchronised
139 {
140 public:
141 static TCDBBank BankTag;
142
143
144 class TGameTime
145 {
146 public:
147
148
149 private:
150 ICDBStructNode *_BranchNode;
151
152 ICDBStructNode *_Hours;
153
154
155 public:
156 void init(ICDBStructNode *parent);
157
158 // accessor to branch node
159 ICDBStructNode *getCDBNode()
160 {
161 return _BranchNode;
162 }
163
164
165 void setHours(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
166 {
167
168
169 _setProp(dbGroup, _Hours, value, forceSending);
170 }
171
172 uint16 getHours(const CCDBSynchronised &dbGroup)
173 {
174 uint16 value;
175 _getProp(dbGroup, _Hours, value);
176
177 return value;
178 }
179
180 ICDBStructNode *getHoursCDBNode()
181 {
182 return _Hours;
183 }
184
185 };
186
187 class TINTERFACES
188 {
189 public:
190
191
192 private:
193 ICDBStructNode *_BranchNode;
194
195 ICDBStructNode *_FLAGS;
196 ICDBStructNode *_NB_BONUS_LANDMARKS;
197
198
199 public:
200 void init(ICDBStructNode *parent);
201
202 // accessor to branch node
203 ICDBStructNode *getCDBNode()
204 {
205 return _BranchNode;
206 }
207
208
209 void setFLAGS(CCDBSynchronised &dbGroup, uint64 value, bool forceSending = false)
210 {
211
212
213 _setProp(dbGroup, _FLAGS, value, forceSending);
214 }
215
216 uint64 getFLAGS(const CCDBSynchronised &dbGroup)
217 {
218 uint64 value;
219 _getProp(dbGroup, _FLAGS, value);
220
221 return value;
222 }
223
224 ICDBStructNode *getFLAGSCDBNode()
225 {
226 return _FLAGS;
227 }
228
229 void setNB_BONUS_LANDMARKS(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
230 {
231
232
233 _setProp(dbGroup, _NB_BONUS_LANDMARKS, value, forceSending);
234 }
235
236 uint16 getNB_BONUS_LANDMARKS(const CCDBSynchronised &dbGroup)
237 {
238 uint16 value;
239 _getProp(dbGroup, _NB_BONUS_LANDMARKS, value);
240
241 return value;
242 }
243
244 ICDBStructNode *getNB_BONUS_LANDMARKSCDBNode()
245 {
246 return _NB_BONUS_LANDMARKS;
247 }
248
249 };
250
251 class TUSER
252 {
253 public:
254
255 class TSKILL_POINTS_
256 {
257 public:
258
259
260 private:
261 ICDBStructNode *_BranchNode;
262
263 ICDBStructNode *_VALUE;
264
265
266 public:
267 void init(ICDBStructNode *parent, uint index);
268
269 // accessor to branch node
270 ICDBStructNode *getCDBNode()
271 {
272 return _BranchNode;
273 }
274
275
276 void setVALUE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
277 {
278
279
280 _setProp(dbGroup, _VALUE, value, forceSending);
281 }
282
283 uint32 getVALUE(const CCDBSynchronised &dbGroup)
284 {
285 uint32 value;
286 _getProp(dbGroup, _VALUE, value);
287
288 return value;
289 }
290
291 ICDBStructNode *getVALUECDBNode()
292 {
293 return _VALUE;
294 }
295
296 };
297
298 class TFACTION_POINTS_
299 {
300 public:
301
302
303 private:
304 ICDBStructNode *_BranchNode;
305
306 ICDBStructNode *_VALUE;
307
308
309 public:
310 void init(ICDBStructNode *parent, uint index);
311
312 // accessor to branch node
313 ICDBStructNode *getCDBNode()
314 {
315 return _BranchNode;
316 }
317
318
319 void setVALUE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
320 {
321
322
323 _setProp(dbGroup, _VALUE, value, forceSending);
324 }
325
326 uint32 getVALUE(const CCDBSynchronised &dbGroup)
327 {
328 uint32 value;
329 _getProp(dbGroup, _VALUE, value);
330
331 return value;
332 }
333
334 ICDBStructNode *getVALUECDBNode()
335 {
336 return _VALUE;
337 }
338
339 };
340
341 class TRRPS_LEVELS
342 {
343 public:
344
345
346 private:
347 ICDBStructNode *_BranchNode;
348
349 ICDBStructNode *_VALUE;
350
351
352 public:
353 void init(ICDBStructNode *parent, uint index);
354
355 // accessor to branch node
356 ICDBStructNode *getCDBNode()
357 {
358 return _BranchNode;
359 }
360
361
362 void setVALUE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
363 {
364
365
366 _setProp(dbGroup, _VALUE, value, forceSending);
367 }
368
369 uint32 getVALUE(const CCDBSynchronised &dbGroup)
370 {
371 uint32 value;
372 _getProp(dbGroup, _VALUE, value);
373
374 return value;
375 }
376
377 ICDBStructNode *getVALUECDBNode()
378 {
379 return _VALUE;
380 }
381
382 };
383
384 class TNPC_CONTROL
385 {
386 public:
387
388
389 private:
390 ICDBStructNode *_BranchNode;
391
392 ICDBStructNode *_SHEET;
393 ICDBStructNode *_RUN;
394 ICDBStructNode *_WALK;
395
396
397 public:
398 void init(ICDBStructNode *parent);
399
400 // accessor to branch node
401 ICDBStructNode *getCDBNode()
402 {
403 return _BranchNode;
404 }
405
406
407 void setSHEET(CCDBSynchronised &dbGroup, NLMISC::CSheetId value, bool forceSending = false)
408 {
409
410
411 _setProp(dbGroup, _SHEET, value, forceSending);
412 }
413
414 NLMISC::CSheetId getSHEET(const CCDBSynchronised &dbGroup)
415 {
416 NLMISC::CSheetId value;
417 _getProp(dbGroup, _SHEET, value);
418
419 return value;
420 }
421
422 ICDBStructNode *getSHEETCDBNode()
423 {
424 return _SHEET;
425 }
426
427 void setRUN(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
428 {
429
430
431 _setProp(dbGroup, _RUN, value, forceSending);
432 }
433
434 uint32 getRUN(const CCDBSynchronised &dbGroup)
435 {
436 uint32 value;
437 _getProp(dbGroup, _RUN, value);
438
439 return value;
440 }
441
442 ICDBStructNode *getRUNCDBNode()
443 {
444 return _RUN;
445 }
446
447 void setWALK(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
448 {
449
450
451 _setProp(dbGroup, _WALK, value, forceSending);
452 }
453
454 uint32 getWALK(const CCDBSynchronised &dbGroup)
455 {
456 uint32 value;
457 _getProp(dbGroup, _WALK, value);
458
459 return value;
460 }
461
462 ICDBStructNode *getWALKCDBNode()
463 {
464 return _WALK;
465 }
466
467 };
468
469
470 private:
471 ICDBStructNode *_BranchNode;
472
473 ICDBStructNode *_HAIR_TYPE;
474 ICDBStructNode *_HAIR_COLOR;
475 ICDBStructNode *_DEATH_XP_MALUS;
476 ICDBStructNode *_IN_DUEL;
477 ICDBStructNode *_IN_PVP_CHALLENGE;
478 ICDBStructNode *_MOUNT_WALK_SPEED;
479 ICDBStructNode *_MOUNT_RUN_SPEED;
480 ICDBStructNode *_TEAM_MEMBER;
481 ICDBStructNode *_TEAM_LEADER;
482 ICDBStructNode *_OUTPOST_ADMIN;
483 ICDBStructNode *_BERSERK;
484 ICDBStructNode *_ACT_TSTART;
485 ICDBStructNode *_ACT_TEND;
486 ICDBStructNode *_ACT_TYPE;
487 ICDBStructNode *_ACT_NUMBER;
488 ICDBStructNode *_ACT_REFUSED_NUM;
489 ICDBStructNode *_ACT_CANCELED_NUM;
490 ICDBStructNode *_SPEED_FACTOR;
491 ICDBStructNode *_SKILL_POINTS;
492 ICDBStructNode *_IS_NEWBIE;
493 ICDBStructNode *_IS_TRIAL;
494 ICDBStructNode *_DEFAULT_WEIGHT_HANDS;
495 ICDBStructNode *_IS_INVISIBLE;
496 ICDBStructNode *_COUNTER;
497 TSKILL_POINTS_ _SKILL_POINTS_[4];
498 TFACTION_POINTS_ _FACTION_POINTS_[7];
499 TRRPS_LEVELS _RRPS_LEVELS[6];
500 TNPC_CONTROL _NPC_CONTROL;
501
502
503 public:
504 void init(ICDBStructNode *parent);
505
506 // accessor to branch node
507 ICDBStructNode *getCDBNode()
508 {
509 return _BranchNode;
510 }
511
512
513 void setHAIR_TYPE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
514 {
515
516
517 _setProp(dbGroup, _HAIR_TYPE, value, forceSending);
518 }
519
520 uint8 getHAIR_TYPE(const CCDBSynchronised &dbGroup)
521 {
522 uint8 value;
523 _getProp(dbGroup, _HAIR_TYPE, value);
524
525 return value;
526 }
527
528 ICDBStructNode *getHAIR_TYPECDBNode()
529 {
530 return _HAIR_TYPE;
531 }
532
533 void setHAIR_COLOR(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
534 {
535
536 // Check that the value is not out of database precision
537 STOP_IF(value > (1<<3)-1, "setHAIR_COLOR : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 3 bits");
538
539
540 _setProp(dbGroup, _HAIR_COLOR, value, forceSending);
541 }
542
543 uint8 getHAIR_COLOR(const CCDBSynchronised &dbGroup)
544 {
545 uint8 value;
546 _getProp(dbGroup, _HAIR_COLOR, value);
547
548 return value;
549 }
550
551 ICDBStructNode *getHAIR_COLORCDBNode()
552 {
553 return _HAIR_COLOR;
554 }
555
556 void setDEATH_XP_MALUS(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
557 {
558
559
560 _setProp(dbGroup, _DEATH_XP_MALUS, value, forceSending);
561 }
562
563 uint8 getDEATH_XP_MALUS(const CCDBSynchronised &dbGroup)
564 {
565 uint8 value;
566 _getProp(dbGroup, _DEATH_XP_MALUS, value);
567
568 return value;
569 }
570
571 ICDBStructNode *getDEATH_XP_MALUSCDBNode()
572 {
573 return _DEATH_XP_MALUS;
574 }
575
576 void setIN_DUEL(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
577 {
578
579
580 _setProp(dbGroup, _IN_DUEL, value, forceSending);
581 }
582
583 bool getIN_DUEL(const CCDBSynchronised &dbGroup)
584 {
585 bool value;
586 _getProp(dbGroup, _IN_DUEL, value);
587
588 return value;
589 }
590
591 ICDBStructNode *getIN_DUELCDBNode()
592 {
593 return _IN_DUEL;
594 }
595
596 void setIN_PVP_CHALLENGE(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
597 {
598
599
600 _setProp(dbGroup, _IN_PVP_CHALLENGE, value, forceSending);
601 }
602
603 bool getIN_PVP_CHALLENGE(const CCDBSynchronised &dbGroup)
604 {
605 bool value;
606 _getProp(dbGroup, _IN_PVP_CHALLENGE, value);
607
608 return value;
609 }
610
611 ICDBStructNode *getIN_PVP_CHALLENGECDBNode()
612 {
613 return _IN_PVP_CHALLENGE;
614 }
615
616 void setMOUNT_WALK_SPEED(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
617 {
618
619
620 _setProp(dbGroup, _MOUNT_WALK_SPEED, value, forceSending);
621 }
622
623 uint16 getMOUNT_WALK_SPEED(const CCDBSynchronised &dbGroup)
624 {
625 uint16 value;
626 _getProp(dbGroup, _MOUNT_WALK_SPEED, value);
627
628 return value;
629 }
630
631 ICDBStructNode *getMOUNT_WALK_SPEEDCDBNode()
632 {
633 return _MOUNT_WALK_SPEED;
634 }
635
636 void setMOUNT_RUN_SPEED(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
637 {
638
639
640 _setProp(dbGroup, _MOUNT_RUN_SPEED, value, forceSending);
641 }
642
643 uint16 getMOUNT_RUN_SPEED(const CCDBSynchronised &dbGroup)
644 {
645 uint16 value;
646 _getProp(dbGroup, _MOUNT_RUN_SPEED, value);
647
648 return value;
649 }
650
651 ICDBStructNode *getMOUNT_RUN_SPEEDCDBNode()
652 {
653 return _MOUNT_RUN_SPEED;
654 }
655
656 void setTEAM_MEMBER(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
657 {
658
659
660 _setProp(dbGroup, _TEAM_MEMBER, value, forceSending);
661 }
662
663 bool getTEAM_MEMBER(const CCDBSynchronised &dbGroup)
664 {
665 bool value;
666 _getProp(dbGroup, _TEAM_MEMBER, value);
667
668 return value;
669 }
670
671 ICDBStructNode *getTEAM_MEMBERCDBNode()
672 {
673 return _TEAM_MEMBER;
674 }
675
676 void setTEAM_LEADER(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
677 {
678
679
680 _setProp(dbGroup, _TEAM_LEADER, value, forceSending);
681 }
682
683 bool getTEAM_LEADER(const CCDBSynchronised &dbGroup)
684 {
685 bool value;
686 _getProp(dbGroup, _TEAM_LEADER, value);
687
688 return value;
689 }
690
691 ICDBStructNode *getTEAM_LEADERCDBNode()
692 {
693 return _TEAM_LEADER;
694 }
695
696 void setOUTPOST_ADMIN(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
697 {
698
699
700 _setProp(dbGroup, _OUTPOST_ADMIN, value, forceSending);
701 }
702
703 bool getOUTPOST_ADMIN(const CCDBSynchronised &dbGroup)
704 {
705 bool value;
706 _getProp(dbGroup, _OUTPOST_ADMIN, value);
707
708 return value;
709 }
710
711 ICDBStructNode *getOUTPOST_ADMINCDBNode()
712 {
713 return _OUTPOST_ADMIN;
714 }
715
716 void setBERSERK(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
717 {
718
719
720 _setProp(dbGroup, _BERSERK, value, forceSending);
721 }
722
723 bool getBERSERK(const CCDBSynchronised &dbGroup)
724 {
725 bool value;
726 _getProp(dbGroup, _BERSERK, value);
727
728 return value;
729 }
730
731 ICDBStructNode *getBERSERKCDBNode()
732 {
733 return _BERSERK;
734 }
735
736 void setACT_TSTART(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
737 {
738
739
740 _setProp(dbGroup, _ACT_TSTART, value, forceSending);
741 }
742
743 uint32 getACT_TSTART(const CCDBSynchronised &dbGroup)
744 {
745 uint32 value;
746 _getProp(dbGroup, _ACT_TSTART, value);
747
748 return value;
749 }
750
751 ICDBStructNode *getACT_TSTARTCDBNode()
752 {
753 return _ACT_TSTART;
754 }
755
756 void setACT_TEND(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
757 {
758
759
760 _setProp(dbGroup, _ACT_TEND, value, forceSending);
761 }
762
763 uint32 getACT_TEND(const CCDBSynchronised &dbGroup)
764 {
765 uint32 value;
766 _getProp(dbGroup, _ACT_TEND, value);
767
768 return value;
769 }
770
771 ICDBStructNode *getACT_TENDCDBNode()
772 {
773 return _ACT_TEND;
774 }
775
776 void setACT_TYPE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
777 {
778
779 // Check that the value is not out of database precision
780 STOP_IF(value > (1<<4)-1, "setACT_TYPE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 4 bits");
781
782
783 _setProp(dbGroup, _ACT_TYPE, value, forceSending);
784 }
785
786 uint8 getACT_TYPE(const CCDBSynchronised &dbGroup)
787 {
788 uint8 value;
789 _getProp(dbGroup, _ACT_TYPE, value);
790
791 return value;
792 }
793
794 ICDBStructNode *getACT_TYPECDBNode()
795 {
796 return _ACT_TYPE;
797 }
798
799 void setACT_NUMBER(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
800 {
801
802
803 _setProp(dbGroup, _ACT_NUMBER, value, forceSending);
804 }
805
806 uint8 getACT_NUMBER(const CCDBSynchronised &dbGroup)
807 {
808 uint8 value;
809 _getProp(dbGroup, _ACT_NUMBER, value);
810
811 return value;
812 }
813
814 ICDBStructNode *getACT_NUMBERCDBNode()
815 {
816 return _ACT_NUMBER;
817 }
818
819 void setACT_REFUSED_NUM(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
820 {
821
822
823 _setProp(dbGroup, _ACT_REFUSED_NUM, value, forceSending);
824 }
825
826 uint8 getACT_REFUSED_NUM(const CCDBSynchronised &dbGroup)
827 {
828 uint8 value;
829 _getProp(dbGroup, _ACT_REFUSED_NUM, value);
830
831 return value;
832 }
833
834 ICDBStructNode *getACT_REFUSED_NUMCDBNode()
835 {
836 return _ACT_REFUSED_NUM;
837 }
838
839 void setACT_CANCELED_NUM(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
840 {
841
842
843 _setProp(dbGroup, _ACT_CANCELED_NUM, value, forceSending);
844 }
845
846 uint8 getACT_CANCELED_NUM(const CCDBSynchronised &dbGroup)
847 {
848 uint8 value;
849 _getProp(dbGroup, _ACT_CANCELED_NUM, value);
850
851 return value;
852 }
853
854 ICDBStructNode *getACT_CANCELED_NUMCDBNode()
855 {
856 return _ACT_CANCELED_NUM;
857 }
858
859 void setSPEED_FACTOR(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
860 {
861
862
863 _setProp(dbGroup, _SPEED_FACTOR, value, forceSending);
864 }
865
866 uint8 getSPEED_FACTOR(const CCDBSynchronised &dbGroup)
867 {
868 uint8 value;
869 _getProp(dbGroup, _SPEED_FACTOR, value);
870
871 return value;
872 }
873
874 ICDBStructNode *getSPEED_FACTORCDBNode()
875 {
876 return _SPEED_FACTOR;
877 }
878
879 void setSKILL_POINTS(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
880 {
881
882
883 _setProp(dbGroup, _SKILL_POINTS, value, forceSending);
884 }
885
886 uint32 getSKILL_POINTS(const CCDBSynchronised &dbGroup)
887 {
888 uint32 value;
889 _getProp(dbGroup, _SKILL_POINTS, value);
890
891 return value;
892 }
893
894 ICDBStructNode *getSKILL_POINTSCDBNode()
895 {
896 return _SKILL_POINTS;
897 }
898
899 void setIS_NEWBIE(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
900 {
901
902
903 _setProp(dbGroup, _IS_NEWBIE, value, forceSending);
904 }
905
906 bool getIS_NEWBIE(const CCDBSynchronised &dbGroup)
907 {
908 bool value;
909 _getProp(dbGroup, _IS_NEWBIE, value);
910
911 return value;
912 }
913
914 ICDBStructNode *getIS_NEWBIECDBNode()
915 {
916 return _IS_NEWBIE;
917 }
918
919 void setIS_TRIAL(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
920 {
921
922
923 _setProp(dbGroup, _IS_TRIAL, value, forceSending);
924 }
925
926 bool getIS_TRIAL(const CCDBSynchronised &dbGroup)
927 {
928 bool value;
929 _getProp(dbGroup, _IS_TRIAL, value);
930
931 return value;
932 }
933
934 ICDBStructNode *getIS_TRIALCDBNode()
935 {
936 return _IS_TRIAL;
937 }
938
939 void setDEFAULT_WEIGHT_HANDS(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
940 {
941
942
943 _setProp(dbGroup, _DEFAULT_WEIGHT_HANDS, value, forceSending);
944 }
945
946 uint32 getDEFAULT_WEIGHT_HANDS(const CCDBSynchronised &dbGroup)
947 {
948 uint32 value;
949 _getProp(dbGroup, _DEFAULT_WEIGHT_HANDS, value);
950
951 return value;
952 }
953
954 ICDBStructNode *getDEFAULT_WEIGHT_HANDSCDBNode()
955 {
956 return _DEFAULT_WEIGHT_HANDS;
957 }
958
959 void setIS_INVISIBLE(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
960 {
961
962
963 _setProp(dbGroup, _IS_INVISIBLE, value, forceSending);
964 }
965
966 bool getIS_INVISIBLE(const CCDBSynchronised &dbGroup)
967 {
968 bool value;
969 _getProp(dbGroup, _IS_INVISIBLE, value);
970
971 return value;
972 }
973
974 ICDBStructNode *getIS_INVISIBLECDBNode()
975 {
976 return _IS_INVISIBLE;
977 }
978
979 void setCOUNTER(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
980 {
981
982 // Check that the value is not out of database precision
983 STOP_IF(value > (1<<4)-1, "setCOUNTER : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 4 bits");
984
985
986 _setProp(dbGroup, _COUNTER, value, forceSending);
987 }
988
989 uint8 getCOUNTER(const CCDBSynchronised &dbGroup)
990 {
991 uint8 value;
992 _getProp(dbGroup, _COUNTER, value);
993
994 return value;
995 }
996
997 ICDBStructNode *getCOUNTERCDBNode()
998 {
999 return _COUNTER;
1000 }
1001 TSKILL_POINTS_ &getSKILL_POINTS_(uint32 index)
1002 {
1003 nlassert(index < 4);
1004 return _SKILL_POINTS_[index];
1005 }
1006 TFACTION_POINTS_ &getFACTION_POINTS_(uint32 index)
1007 {
1008 nlassert(index < 7);
1009 return _FACTION_POINTS_[index];
1010 }
1011 TRRPS_LEVELS &getRRPS_LEVELS(uint32 index)
1012 {
1013 nlassert(index < 6);
1014 return _RRPS_LEVELS[index];
1015 }
1016 TNPC_CONTROL &getNPC_CONTROL()
1017 {
1018 return _NPC_CONTROL;
1019 }
1020
1021 };
1022
1023 class TDEFENSE
1024 {
1025 public:
1026
1027 class TSLOTS
1028 {
1029 public:
1030
1031 class TArray
1032 {
1033 public:
1034
1035
1036 private:
1037 ICDBStructNode *_BranchNode;
1038
1039 ICDBStructNode *_MODIFIER;
1040
1041
1042 public:
1043 void init(ICDBStructNode *parent, uint index);
1044
1045 // accessor to branch node
1046 ICDBStructNode *getCDBNode()
1047 {
1048 return _BranchNode;
1049 }
1050
1051
1052 void setMODIFIER(CCDBSynchronised &dbGroup, sint8 value, bool forceSending = false)
1053 {
1054
1055
1056 _setProp(dbGroup, _MODIFIER, value, forceSending);
1057 }
1058
1059 sint8 getMODIFIER(const CCDBSynchronised &dbGroup)
1060 {
1061 sint8 value;
1062 _getProp(dbGroup, _MODIFIER, value);
1063
1064 return value;
1065 }
1066
1067 ICDBStructNode *getMODIFIERCDBNode()
1068 {
1069 return _MODIFIER;
1070 }
1071
1072 };
1073
1074
1075 private:
1076 ICDBStructNode *_BranchNode;
1077
1078 TArray _Array[6];
1079
1080
1081 public:
1082 void init(ICDBStructNode *parent);
1083
1084 // accessor to branch node
1085 ICDBStructNode *getCDBNode()
1086 {
1087 return _BranchNode;
1088 }
1089
1090 TArray &getArray(uint32 index)
1091 {
1092 nlassert(index < 6);
1093 return _Array[index];
1094 }
1095
1096 };
1097
1098
1099 private:
1100 ICDBStructNode *_BranchNode;
1101
1102 ICDBStructNode *_DEFENSE_MODE;
1103 ICDBStructNode *_PROTECTED_SLOT;
1104 TSLOTS _SLOTS;
1105
1106
1107 public:
1108 void init(ICDBStructNode *parent);
1109
1110 // accessor to branch node
1111 ICDBStructNode *getCDBNode()
1112 {
1113 return _BranchNode;
1114 }
1115
1116
1117 void setDEFENSE_MODE(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
1118 {
1119
1120
1121 _setProp(dbGroup, _DEFENSE_MODE, value, forceSending);
1122 }
1123
1124 bool getDEFENSE_MODE(const CCDBSynchronised &dbGroup)
1125 {
1126 bool value;
1127 _getProp(dbGroup, _DEFENSE_MODE, value);
1128
1129 return value;
1130 }
1131
1132 ICDBStructNode *getDEFENSE_MODECDBNode()
1133 {
1134 return _DEFENSE_MODE;
1135 }
1136
1137 void setPROTECTED_SLOT(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
1138 {
1139
1140 // Check that the value is not out of database precision
1141 STOP_IF(value > (1<<3)-1, "setPROTECTED_SLOT : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 3 bits");
1142
1143
1144 _setProp(dbGroup, _PROTECTED_SLOT, value, forceSending);
1145 }
1146
1147 uint8 getPROTECTED_SLOT(const CCDBSynchronised &dbGroup)
1148 {
1149 uint8 value;
1150 _getProp(dbGroup, _PROTECTED_SLOT, value);
1151
1152 return value;
1153 }
1154
1155 ICDBStructNode *getPROTECTED_SLOTCDBNode()
1156 {
1157 return _PROTECTED_SLOT;
1158 }
1159 TSLOTS &getSLOTS()
1160 {
1161 return _SLOTS;
1162 }
1163
1164 };
1165
1166 class TFLAGS
1167 {
1168 public:
1169
1170 class TBRICK_TICK_RANGE
1171 {
1172 public:
1173
1174 class TArray
1175 {
1176 public:
1177
1178
1179 private:
1180 ICDBStructNode *_BranchNode;
1181
1182 ICDBStructNode *_TICK_RANGE;
1183
1184
1185 public:
1186 void init(ICDBStructNode *parent, uint index);
1187
1188 // accessor to branch node
1189 ICDBStructNode *getCDBNode()
1190 {
1191 return _BranchNode;
1192 }
1193
1194
1195 void setTICK_RANGE(CCDBSynchronised &dbGroup, uint64 value, bool forceSending = false)
1196 {
1197
1198
1199 _setProp(dbGroup, _TICK_RANGE, value, forceSending);
1200 }
1201
1202 uint64 getTICK_RANGE(const CCDBSynchronised &dbGroup)
1203 {
1204 uint64 value;
1205 _getProp(dbGroup, _TICK_RANGE, value);
1206
1207 return value;
1208 }
1209
1210 ICDBStructNode *getTICK_RANGECDBNode()
1211 {
1212 return _TICK_RANGE;
1213 }
1214
1215 };
1216
1217
1218 private:
1219 ICDBStructNode *_BranchNode;
1220
1221 TArray _Array[64];
1222
1223
1224 public:
1225 void init(ICDBStructNode *parent);
1226
1227 // accessor to branch node
1228 ICDBStructNode *getCDBNode()
1229 {
1230 return _BranchNode;
1231 }
1232
1233 TArray &getArray(uint32 index)
1234 {
1235 nlassert(index < 64);
1236 return _Array[index];
1237 }
1238
1239 };
1240
1241
1242 private:
1243 ICDBStructNode *_BranchNode;
1244
1245 ICDBStructNode *_CRITICAL;
1246 ICDBStructNode *_PARRY;
1247 ICDBStructNode *_DODGE;
1248 TBRICK_TICK_RANGE _BRICK_TICK_RANGE;
1249
1250
1251 public:
1252 void init(ICDBStructNode *parent);
1253
1254 // accessor to branch node
1255 ICDBStructNode *getCDBNode()
1256 {
1257 return _BranchNode;
1258 }
1259
1260
1261 void setCRITICAL(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
1262 {
1263
1264
1265 _setProp(dbGroup, _CRITICAL, value, forceSending);
1266 }
1267
1268 uint8 getCRITICAL(const CCDBSynchronised &dbGroup)
1269 {
1270 uint8 value;
1271 _getProp(dbGroup, _CRITICAL, value);
1272
1273 return value;
1274 }
1275
1276 ICDBStructNode *getCRITICALCDBNode()
1277 {
1278 return _CRITICAL;
1279 }
1280
1281 void setPARRY(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
1282 {
1283
1284
1285 _setProp(dbGroup, _PARRY, value, forceSending);
1286 }
1287
1288 uint8 getPARRY(const CCDBSynchronised &dbGroup)
1289 {
1290 uint8 value;
1291 _getProp(dbGroup, _PARRY, value);
1292
1293 return value;
1294 }
1295
1296 ICDBStructNode *getPARRYCDBNode()
1297 {
1298 return _PARRY;
1299 }
1300
1301 void setDODGE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
1302 {
1303
1304
1305 _setProp(dbGroup, _DODGE, value, forceSending);
1306 }
1307
1308 uint8 getDODGE(const CCDBSynchronised &dbGroup)
1309 {
1310 uint8 value;
1311 _getProp(dbGroup, _DODGE, value);
1312
1313 return value;
1314 }
1315
1316 ICDBStructNode *getDODGECDBNode()
1317 {
1318 return _DODGE;
1319 }
1320 TBRICK_TICK_RANGE &getBRICK_TICK_RANGE()
1321 {
1322 return _BRICK_TICK_RANGE;
1323 }
1324
1325 };
1326
1327 class TTARGET
1328 {
1329 public:
1330
1331 class TBARS
1332 {
1333 public:
1334
1335
1336 private:
1337 ICDBStructNode *_BranchNode;
1338
1339 ICDBStructNode *_UID;
1340 ICDBStructNode *_HP;
1341 ICDBStructNode *_SAP;
1342 ICDBStructNode *_STA;
1343 ICDBStructNode *_FOCUS;
1344 ICDBStructNode *_PLAYER_LEVEL;
1345
1346
1347 public:
1348 void init(ICDBStructNode *parent);
1349
1350 // accessor to branch node
1351 ICDBStructNode *getCDBNode()
1352 {
1353 return _BranchNode;
1354 }
1355
1356
1357 void setUID(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
1358 {
1359
1360 // Check that the value is not out of database precision
1361 STOP_IF(value > (1<<20)-1, "setUID : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 20 bits");
1362
1363
1364 _setProp(dbGroup, _UID, value, forceSending);
1365 }
1366
1367 uint32 getUID(const CCDBSynchronised &dbGroup)
1368 {
1369 uint32 value;
1370 _getProp(dbGroup, _UID, value);
1371
1372 return value;
1373 }
1374
1375 ICDBStructNode *getUIDCDBNode()
1376 {
1377 return _UID;
1378 }
1379
1380 void setHP(CCDBSynchronised &dbGroup, sint8 value, bool forceSending = false)
1381 {
1382
1383
1384 _setProp(dbGroup, _HP, value, forceSending);
1385 }
1386
1387 sint8 getHP(const CCDBSynchronised &dbGroup)
1388 {
1389 sint8 value;
1390 _getProp(dbGroup, _HP, value);
1391
1392 return value;
1393 }
1394
1395 ICDBStructNode *getHPCDBNode()
1396 {
1397 return _HP;
1398 }
1399
1400 void setSAP(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
1401 {
1402
1403 // Check that the value is not out of database precision
1404 STOP_IF(value > (1<<7)-1, "setSAP : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 7 bits");
1405
1406
1407 _setProp(dbGroup, _SAP, value, forceSending);
1408 }
1409
1410 uint8 getSAP(const CCDBSynchronised &dbGroup)
1411 {
1412 uint8 value;
1413 _getProp(dbGroup, _SAP, value);
1414
1415 return value;
1416 }
1417
1418 ICDBStructNode *getSAPCDBNode()
1419 {
1420 return _SAP;
1421 }
1422
1423 void setSTA(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
1424 {
1425
1426 // Check that the value is not out of database precision
1427 STOP_IF(value > (1<<7)-1, "setSTA : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 7 bits");
1428
1429
1430 _setProp(dbGroup, _STA, value, forceSending);
1431 }
1432
1433 uint8 getSTA(const CCDBSynchronised &dbGroup)
1434 {
1435 uint8 value;
1436 _getProp(dbGroup, _STA, value);
1437
1438 return value;
1439 }
1440
1441 ICDBStructNode *getSTACDBNode()
1442 {
1443 return _STA;
1444 }
1445
1446 void setFOCUS(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
1447 {
1448
1449 // Check that the value is not out of database precision
1450 STOP_IF(value > (1<<7)-1, "setFOCUS : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 7 bits");
1451
1452
1453 _setProp(dbGroup, _FOCUS, value, forceSending);
1454 }
1455
1456 uint8 getFOCUS(const CCDBSynchronised &dbGroup)
1457 {
1458 uint8 value;
1459 _getProp(dbGroup, _FOCUS, value);
1460
1461 return value;
1462 }
1463
1464 ICDBStructNode *getFOCUSCDBNode()
1465 {
1466 return _FOCUS;
1467 }
1468
1469 void setPLAYER_LEVEL(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
1470 {
1471
1472
1473 _setProp(dbGroup, _PLAYER_LEVEL, value, forceSending);
1474 }
1475
1476 uint8 getPLAYER_LEVEL(const CCDBSynchronised &dbGroup)
1477 {
1478 uint8 value;
1479 _getProp(dbGroup, _PLAYER_LEVEL, value);
1480
1481 return value;
1482 }
1483
1484 ICDBStructNode *getPLAYER_LEVELCDBNode()
1485 {
1486 return _PLAYER_LEVEL;
1487 }
1488
1489 };
1490
1491 class TCONTEXT_MENU
1492 {
1493 public:
1494
1495 class TMISSIONS_OPTIONS
1496 {
1497 public:
1498
1499 class TArray
1500 {
1501 public:
1502
1503
1504 private:
1505 ICDBStructNode *_BranchNode;
1506
1507 ICDBStructNode *_TITLE;
1508 ICDBStructNode *_PLAYER_GIFT_NEEDED;
1509 ICDBStructNode *_PRIORITY;
1510
1511
1512 public:
1513 void init(ICDBStructNode *parent, uint index);
1514
1515 // accessor to branch node
1516 ICDBStructNode *getCDBNode()
1517 {
1518 return _BranchNode;
1519 }
1520
1521
1522 void setTITLE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
1523 {
1524
1525
1526 _setProp(dbGroup, _TITLE, value, forceSending);
1527 }
1528
1529 uint32 getTITLE(const CCDBSynchronised &dbGroup)
1530 {
1531 uint32 value;
1532 _getProp(dbGroup, _TITLE, value);
1533
1534 return value;
1535 }
1536
1537 ICDBStructNode *getTITLECDBNode()
1538 {
1539 return _TITLE;
1540 }
1541
1542 void setPLAYER_GIFT_NEEDED(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
1543 {
1544
1545
1546 _setProp(dbGroup, _PLAYER_GIFT_NEEDED, value, forceSending);
1547 }
1548
1549 bool getPLAYER_GIFT_NEEDED(const CCDBSynchronised &dbGroup)
1550 {
1551 bool value;
1552 _getProp(dbGroup, _PLAYER_GIFT_NEEDED, value);
1553
1554 return value;
1555 }
1556
1557 ICDBStructNode *getPLAYER_GIFT_NEEDEDCDBNode()
1558 {
1559 return _PLAYER_GIFT_NEEDED;
1560 }
1561
1562 void setPRIORITY(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
1563 {
1564
1565 // Check that the value is not out of database precision
1566 STOP_IF(value > (1<<2)-1, "setPRIORITY : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 2 bits");
1567
1568
1569 _setProp(dbGroup, _PRIORITY, value, forceSending);
1570 }
1571
1572 uint8 getPRIORITY(const CCDBSynchronised &dbGroup)
1573 {
1574 uint8 value;
1575 _getProp(dbGroup, _PRIORITY, value);
1576
1577 return value;
1578 }
1579
1580 ICDBStructNode *getPRIORITYCDBNode()
1581 {
1582 return _PRIORITY;
1583 }
1584
1585 };
1586
1587
1588 private:
1589 ICDBStructNode *_BranchNode;
1590
1591 TArray _Array[8];
1592
1593
1594 public:
1595 void init(ICDBStructNode *parent);
1596
1597 // accessor to branch node
1598 ICDBStructNode *getCDBNode()
1599 {
1600 return _BranchNode;
1601 }
1602
1603 TArray &getArray(uint32 index)
1604 {
1605 nlassert(index < 8);
1606 return _Array[index];
1607 }
1608
1609 };
1610
1611 class TMISSION_RING
1612 {
1613 public:
1614
1615 class TArray
1616 {
1617 public:
1618
1619
1620 private:
1621 ICDBStructNode *_BranchNode;
1622
1623 ICDBStructNode *_TITLE;
1624 ICDBStructNode *_ID;
1625
1626
1627 public:
1628 void init(ICDBStructNode *parent, uint index);
1629
1630 // accessor to branch node
1631 ICDBStructNode *getCDBNode()
1632 {
1633 return _BranchNode;
1634 }
1635
1636
1637 void setTITLE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
1638 {
1639
1640
1641 _setProp(dbGroup, _TITLE, value, forceSending);
1642 }
1643
1644 uint32 getTITLE(const CCDBSynchronised &dbGroup)
1645 {
1646 uint32 value;
1647 _getProp(dbGroup, _TITLE, value);
1648
1649 return value;
1650 }
1651
1652 ICDBStructNode *getTITLECDBNode()
1653 {
1654 return _TITLE;
1655 }
1656
1657 void setID(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
1658 {
1659
1660
1661 _setProp(dbGroup, _ID, value, forceSending);
1662 }
1663
1664 uint32 getID(const CCDBSynchronised &dbGroup)
1665 {
1666 uint32 value;
1667 _getProp(dbGroup, _ID, value);
1668
1669 return value;
1670 }
1671
1672 ICDBStructNode *getIDCDBNode()
1673 {
1674 return _ID;
1675 }
1676
1677 };
1678
1679
1680 private:
1681 ICDBStructNode *_BranchNode;
1682
1683 TArray _Array[4];
1684
1685
1686 public:
1687 void init(ICDBStructNode *parent);
1688
1689 // accessor to branch node
1690 ICDBStructNode *getCDBNode()
1691 {
1692 return _BranchNode;
1693 }
1694
1695 TArray &getArray(uint32 index)
1696 {
1697 nlassert(index < 4);
1698 return _Array[index];
1699 }
1700
1701 };
1702
1703
1704 private:
1705 ICDBStructNode *_BranchNode;
1706
1707 ICDBStructNode *_PROGRAMMES;
1708 ICDBStructNode *_WEB_PAGE_TITLE;
1709 ICDBStructNode *_WEB_PAGE_URL;
1710 ICDBStructNode *_OUTPOST;
1711 ICDBStructNode *_COUNTER;
1712 TMISSIONS_OPTIONS _MISSIONS_OPTIONS;
1713 TMISSION_RING _MISSION_RING;
1714
1715
1716 public:
1717 void init(ICDBStructNode *parent);
1718
1719 // accessor to branch node
1720 ICDBStructNode *getCDBNode()
1721 {
1722 return _BranchNode;
1723 }
1724
1725
1726 void setPROGRAMMES(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
1727 {
1728
1729
1730 _setProp(dbGroup, _PROGRAMMES, value, forceSending);
1731 }
1732
1733 uint32 getPROGRAMMES(const CCDBSynchronised &dbGroup)
1734 {
1735 uint32 value;
1736 _getProp(dbGroup, _PROGRAMMES, value);
1737
1738 return value;
1739 }
1740
1741 ICDBStructNode *getPROGRAMMESCDBNode()
1742 {
1743 return _PROGRAMMES;
1744 }
1745
1746 void setWEB_PAGE_TITLE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
1747 {
1748
1749
1750 _setProp(dbGroup, _WEB_PAGE_TITLE, value, forceSending);
1751 }
1752
1753 uint32 getWEB_PAGE_TITLE(const CCDBSynchronised &dbGroup)
1754 {
1755 uint32 value;
1756 _getProp(dbGroup, _WEB_PAGE_TITLE, value);
1757
1758 return value;
1759 }
1760
1761 ICDBStructNode *getWEB_PAGE_TITLECDBNode()
1762 {
1763 return _WEB_PAGE_TITLE;
1764 }
1765
1766 void setWEB_PAGE_URL(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
1767 {
1768
1769
1770 _setProp(dbGroup, _WEB_PAGE_URL, value, forceSending);
1771 }
1772
1773 uint32 getWEB_PAGE_URL(const CCDBSynchronised &dbGroup)
1774 {
1775 uint32 value;
1776 _getProp(dbGroup, _WEB_PAGE_URL, value);
1777
1778 return value;
1779 }
1780
1781 ICDBStructNode *getWEB_PAGE_URLCDBNode()
1782 {
1783 return _WEB_PAGE_URL;
1784 }
1785
1786 void setOUTPOST(CCDBSynchronised &dbGroup, NLMISC::CSheetId value, bool forceSending = false)
1787 {
1788
1789
1790 _setProp(dbGroup, _OUTPOST, value, forceSending);
1791 }
1792
1793 NLMISC::CSheetId getOUTPOST(const CCDBSynchronised &dbGroup)
1794 {
1795 NLMISC::CSheetId value;
1796 _getProp(dbGroup, _OUTPOST, value);
1797
1798 return value;
1799 }
1800
1801 ICDBStructNode *getOUTPOSTCDBNode()
1802 {
1803 return _OUTPOST;
1804 }
1805
1806 void setCOUNTER(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
1807 {
1808
1809 // Check that the value is not out of database precision
1810 STOP_IF(value > (1<<4)-1, "setCOUNTER : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 4 bits");
1811
1812
1813 _setProp(dbGroup, _COUNTER, value, forceSending);
1814 }
1815
1816 uint8 getCOUNTER(const CCDBSynchronised &dbGroup)
1817 {
1818 uint8 value;
1819 _getProp(dbGroup, _COUNTER, value);
1820
1821 return value;
1822 }
1823
1824 ICDBStructNode *getCOUNTERCDBNode()
1825 {
1826 return _COUNTER;
1827 }
1828 TMISSIONS_OPTIONS &getMISSIONS_OPTIONS()
1829 {
1830 return _MISSIONS_OPTIONS;
1831 }
1832 TMISSION_RING &getMISSION_RING()
1833 {
1834 return _MISSION_RING;
1835 }
1836
1837 };
1838
1839
1840 private:
1841 ICDBStructNode *_BranchNode;
1842
1843 ICDBStructNode *_CONTEXT_VAL;
1844 ICDBStructNode *_AGGRESSIVE;
1845 ICDBStructNode *_FORCE_RATIO;
1846 TBARS _BARS;
1847 TCONTEXT_MENU _CONTEXT_MENU;
1848
1849
1850 public:
1851 void init(ICDBStructNode *parent);
1852
1853 // accessor to branch node
1854 ICDBStructNode *getCDBNode()
1855 {
1856 return _BranchNode;
1857 }
1858
1859
1860 void setCONTEXT_VAL(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
1861 {
1862
1863
1864 _setProp(dbGroup, _CONTEXT_VAL, value, forceSending);
1865 }
1866
1867 uint16 getCONTEXT_VAL(const CCDBSynchronised &dbGroup)
1868 {
1869 uint16 value;
1870 _getProp(dbGroup, _CONTEXT_VAL, value);
1871
1872 return value;
1873 }
1874
1875 ICDBStructNode *getCONTEXT_VALCDBNode()
1876 {
1877 return _CONTEXT_VAL;
1878 }
1879
1880 void setAGGRESSIVE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
1881 {
1882
1883 // Check that the value is not out of database precision
1884 STOP_IF(value > (1<<3)-1, "setAGGRESSIVE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 3 bits");
1885
1886
1887 _setProp(dbGroup, _AGGRESSIVE, value, forceSending);
1888 }
1889
1890 uint8 getAGGRESSIVE(const CCDBSynchronised &dbGroup)
1891 {
1892 uint8 value;
1893 _getProp(dbGroup, _AGGRESSIVE, value);
1894
1895 return value;
1896 }
1897
1898 ICDBStructNode *getAGGRESSIVECDBNode()
1899 {
1900 return _AGGRESSIVE;
1901 }
1902
1903 void setFORCE_RATIO(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
1904 {
1905
1906 // Check that the value is not out of database precision
1907 STOP_IF(value > (1<<4)-1, "setFORCE_RATIO : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 4 bits");
1908
1909
1910 _setProp(dbGroup, _FORCE_RATIO, value, forceSending);
1911 }
1912
1913 uint8 getFORCE_RATIO(const CCDBSynchronised &dbGroup)
1914 {
1915 uint8 value;
1916 _getProp(dbGroup, _FORCE_RATIO, value);
1917
1918 return value;
1919 }
1920
1921 ICDBStructNode *getFORCE_RATIOCDBNode()
1922 {
1923 return _FORCE_RATIO;
1924 }
1925 TBARS &getBARS()
1926 {
1927 return _BARS;
1928 }
1929 TCONTEXT_MENU &getCONTEXT_MENU()
1930 {
1931 return _CONTEXT_MENU;
1932 }
1933
1934 };
1935
1936 class TGROUP
1937 {
1938 public:
1939
1940 class TArray
1941 {
1942 public:
1943
1944
1945 private:
1946 ICDBStructNode *_BranchNode;
1947
1948 ICDBStructNode *_PRESENT;
1949 ICDBStructNode *_UID;
1950 ICDBStructNode *_NAME;
1951 ICDBStructNode *_HP;
1952 ICDBStructNode *_SAP;
1953 ICDBStructNode *_STA;
1954 ICDBStructNode *_POS;
1955
1956
1957 public:
1958 void init(ICDBStructNode *parent, uint index);
1959
1960 // accessor to branch node
1961 ICDBStructNode *getCDBNode()
1962 {
1963 return _BranchNode;
1964 }
1965
1966
1967 void setPRESENT(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
1968 {
1969
1970
1971 _setProp(dbGroup, _PRESENT, value, forceSending);
1972 }
1973
1974 bool getPRESENT(const CCDBSynchronised &dbGroup)
1975 {
1976 bool value;
1977 _getProp(dbGroup, _PRESENT, value);
1978
1979 return value;
1980 }
1981
1982 ICDBStructNode *getPRESENTCDBNode()
1983 {
1984 return _PRESENT;
1985 }
1986
1987 void setUID(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
1988 {
1989
1990 // Check that the value is not out of database precision
1991 STOP_IF(value > (1<<20)-1, "setUID : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 20 bits");
1992
1993
1994 _setProp(dbGroup, _UID, value, forceSending);
1995 }
1996
1997 uint32 getUID(const CCDBSynchronised &dbGroup)
1998 {
1999 uint32 value;
2000 _getProp(dbGroup, _UID, value);
2001
2002 return value;
2003 }
2004
2005 ICDBStructNode *getUIDCDBNode()
2006 {
2007 return _UID;
2008 }
2009
2010 void setNAME(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
2011 {
2012
2013
2014 _setProp(dbGroup, _NAME, value, forceSending);
2015 }
2016
2017 uint32 getNAME(const CCDBSynchronised &dbGroup)
2018 {
2019 uint32 value;
2020 _getProp(dbGroup, _NAME, value);
2021
2022 return value;
2023 }
2024
2025 ICDBStructNode *getNAMECDBNode()
2026 {
2027 return _NAME;
2028 }
2029
2030 void setHP(CCDBSynchronised &dbGroup, sint8 value, bool forceSending = false)
2031 {
2032
2033
2034 _setProp(dbGroup, _HP, value, forceSending);
2035 }
2036
2037 sint8 getHP(const CCDBSynchronised &dbGroup)
2038 {
2039 sint8 value;
2040 _getProp(dbGroup, _HP, value);
2041
2042 return value;
2043 }
2044
2045 ICDBStructNode *getHPCDBNode()
2046 {
2047 return _HP;
2048 }
2049
2050 void setSAP(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
2051 {
2052
2053 // Check that the value is not out of database precision
2054 STOP_IF(value > (1<<7)-1, "setSAP : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 7 bits");
2055
2056
2057 _setProp(dbGroup, _SAP, value, forceSending);
2058 }
2059
2060 uint8 getSAP(const CCDBSynchronised &dbGroup)
2061 {
2062 uint8 value;
2063 _getProp(dbGroup, _SAP, value);
2064
2065 return value;
2066 }
2067
2068 ICDBStructNode *getSAPCDBNode()
2069 {
2070 return _SAP;
2071 }
2072
2073 void setSTA(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
2074 {
2075
2076 // Check that the value is not out of database precision
2077 STOP_IF(value > (1<<7)-1, "setSTA : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 7 bits");
2078
2079
2080 _setProp(dbGroup, _STA, value, forceSending);
2081 }
2082
2083 uint8 getSTA(const CCDBSynchronised &dbGroup)
2084 {
2085 uint8 value;
2086 _getProp(dbGroup, _STA, value);
2087
2088 return value;
2089 }
2090
2091 ICDBStructNode *getSTACDBNode()
2092 {
2093 return _STA;
2094 }
2095
2096 void setPOS(CCDBSynchronised &dbGroup, uint64 value, bool forceSending = false)
2097 {
2098
2099
2100 _setProp(dbGroup, _POS, value, forceSending);
2101 }
2102
2103 uint64 getPOS(const CCDBSynchronised &dbGroup)
2104 {
2105 uint64 value;
2106 _getProp(dbGroup, _POS, value);
2107
2108 return value;
2109 }
2110
2111 ICDBStructNode *getPOSCDBNode()
2112 {
2113 return _POS;
2114 }
2115
2116 };
2117
2118 class TMISSIONS
2119 {
2120 public:
2121
2122 class TArray
2123 {
2124 public:
2125
2126 class TGOALS
2127 {
2128 public:
2129
2130 class TArray
2131 {
2132 public:
2133
2134
2135 private:
2136 ICDBStructNode *_BranchNode;
2137
2138 ICDBStructNode *_TEXT;
2139 ICDBStructNode *_NPC_ALIAS;
2140
2141
2142 public:
2143 void init(ICDBStructNode *parent, uint index);
2144
2145 // accessor to branch node
2146 ICDBStructNode *getCDBNode()
2147 {
2148 return _BranchNode;
2149 }
2150
2151
2152 void setTEXT(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
2153 {
2154
2155
2156 _setProp(dbGroup, _TEXT, value, forceSending);
2157 }
2158
2159 uint32 getTEXT(const CCDBSynchronised &dbGroup)
2160 {
2161 uint32 value;
2162 _getProp(dbGroup, _TEXT, value);
2163
2164 return value;
2165 }
2166
2167 ICDBStructNode *getTEXTCDBNode()
2168 {
2169 return _TEXT;
2170 }
2171
2172 void setNPC_ALIAS(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
2173 {
2174
2175
2176 _setProp(dbGroup, _NPC_ALIAS, value, forceSending);
2177 }
2178
2179 uint32 getNPC_ALIAS(const CCDBSynchronised &dbGroup)
2180 {
2181 uint32 value;
2182 _getProp(dbGroup, _NPC_ALIAS, value);
2183
2184 return value;
2185 }
2186
2187 ICDBStructNode *getNPC_ALIASCDBNode()
2188 {
2189 return _NPC_ALIAS;
2190 }
2191
2192 };
2193
2194
2195 private:
2196 ICDBStructNode *_BranchNode;
2197
2198 TArray _Array[20];
2199
2200
2201 public:
2202 void init(ICDBStructNode *parent);
2203
2204 // accessor to branch node
2205 ICDBStructNode *getCDBNode()
2206 {
2207 return _BranchNode;
2208 }
2209
2210 TArray &getArray(uint32 index)
2211 {
2212 nlassert(index < 20);
2213 return _Array[index];
2214 }
2215
2216 };
2217
2218 class TTARGET
2219 {
2220 public:
2221
2222
2223 private:
2224 ICDBStructNode *_BranchNode;
2225
2226 ICDBStructNode *_TITLE;
2227 ICDBStructNode *_X;
2228 ICDBStructNode *_Y;
2229
2230
2231 public:
2232 void init(ICDBStructNode *parent, uint index);
2233
2234 // accessor to branch node
2235 ICDBStructNode *getCDBNode()
2236 {
2237 return _BranchNode;
2238 }
2239
2240
2241 void setTITLE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
2242 {
2243
2244
2245 _setProp(dbGroup, _TITLE, value, forceSending);
2246 }
2247
2248 uint32 getTITLE(const CCDBSynchronised &dbGroup)
2249 {
2250 uint32 value;
2251 _getProp(dbGroup, _TITLE, value);
2252
2253 return value;
2254 }
2255
2256 ICDBStructNode *getTITLECDBNode()
2257 {
2258 return _TITLE;
2259 }
2260
2261 void setX(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
2262 {
2263
2264
2265 _setProp(dbGroup, _X, value, forceSending);
2266 }
2267
2268 uint32 getX(const CCDBSynchronised &dbGroup)
2269 {
2270 uint32 value;
2271 _getProp(dbGroup, _X, value);
2272
2273 return value;
2274 }
2275
2276 ICDBStructNode *getXCDBNode()
2277 {
2278 return _X;
2279 }
2280
2281 void setY(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
2282 {
2283
2284
2285 _setProp(dbGroup, _Y, value, forceSending);
2286 }
2287
2288 uint32 getY(const CCDBSynchronised &dbGroup)
2289 {
2290 uint32 value;
2291 _getProp(dbGroup, _Y, value);
2292
2293 return value;
2294 }
2295
2296 ICDBStructNode *getYCDBNode()
2297 {
2298 return _Y;
2299 }
2300
2301 };
2302
2303 class THISTO
2304 {
2305 public:
2306
2307 class TArray
2308 {
2309 public:
2310
2311
2312 private:
2313 ICDBStructNode *_BranchNode;
2314
2315 ICDBStructNode *_TEXT;
2316
2317
2318 public:
2319 void init(ICDBStructNode *parent, uint index);
2320
2321 // accessor to branch node
2322 ICDBStructNode *getCDBNode()
2323 {
2324 return _BranchNode;
2325 }
2326
2327
2328 void setTEXT(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
2329 {
2330
2331
2332 _setProp(dbGroup, _TEXT, value, forceSending);
2333 }
2334
2335 uint32 getTEXT(const CCDBSynchronised &dbGroup)
2336 {
2337 uint32 value;
2338 _getProp(dbGroup, _TEXT, value);
2339
2340 return value;
2341 }
2342
2343 ICDBStructNode *getTEXTCDBNode()
2344 {
2345 return _TEXT;
2346 }
2347
2348 };
2349
2350
2351 private:
2352 ICDBStructNode *_BranchNode;
2353
2354 TArray _Array[30];
2355
2356
2357 public:
2358 void init(ICDBStructNode *parent);
2359
2360 // accessor to branch node
2361 ICDBStructNode *getCDBNode()
2362 {
2363 return _BranchNode;
2364 }
2365
2366 TArray &getArray(uint32 index)
2367 {
2368 nlassert(index < 30);
2369 return _Array[index];
2370 }
2371
2372 };
2373
2374
2375 private:
2376 ICDBStructNode *_BranchNode;
2377
2378 ICDBStructNode *_TYPE;
2379 ICDBStructNode *_ICON;
2380 ICDBStructNode *_TITLE;
2381 ICDBStructNode *_DETAIL_TEXT;
2382 ICDBStructNode *_BEGIN_DATE;
2383 ICDBStructNode *_END_DATE;
2384 ICDBStructNode *_OR_STEPS;
2385 ICDBStructNode *_FINISHED;
2386 ICDBStructNode *_ABANDONNABLE;
2387 ICDBStructNode *_SLEEP;
2388 TGOALS _GOALS;
2389 TTARGET _TARGET[8];
2390 THISTO _HISTO;
2391
2392
2393 public:
2394 void init(ICDBStructNode *parent, uint index);
2395
2396 // accessor to branch node
2397 ICDBStructNode *getCDBNode()
2398 {
2399 return _BranchNode;
2400 }
2401
2402
2403 void setTYPE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
2404 {
2405
2406 // Check that the value is not out of database precision
2407 STOP_IF(value > (1<<2)-1, "setTYPE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 2 bits");
2408
2409
2410 _setProp(dbGroup, _TYPE, value, forceSending);
2411 }
2412
2413 uint8 getTYPE(const CCDBSynchronised &dbGroup)
2414 {
2415 uint8 value;
2416 _getProp(dbGroup, _TYPE, value);
2417
2418 return value;
2419 }
2420
2421 ICDBStructNode *getTYPECDBNode()
2422 {
2423 return _TYPE;
2424 }
2425
2426 void setICON(CCDBSynchronised &dbGroup, NLMISC::CSheetId value, bool forceSending = false)
2427 {
2428
2429
2430 _setProp(dbGroup, _ICON, value, forceSending);
2431 }
2432
2433 NLMISC::CSheetId getICON(const CCDBSynchronised &dbGroup)
2434 {
2435 NLMISC::CSheetId value;
2436 _getProp(dbGroup, _ICON, value);
2437
2438 return value;
2439 }
2440
2441 ICDBStructNode *getICONCDBNode()
2442 {
2443 return _ICON;
2444 }
2445
2446 void setTITLE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
2447 {
2448
2449
2450 _setProp(dbGroup, _TITLE, value, forceSending);
2451 }
2452
2453 uint32 getTITLE(const CCDBSynchronised &dbGroup)
2454 {
2455 uint32 value;
2456 _getProp(dbGroup, _TITLE, value);
2457
2458 return value;
2459 }
2460
2461 ICDBStructNode *getTITLECDBNode()
2462 {
2463 return _TITLE;
2464 }
2465
2466 void setDETAIL_TEXT(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
2467 {
2468
2469
2470 _setProp(dbGroup, _DETAIL_TEXT, value, forceSending);
2471 }
2472
2473 uint32 getDETAIL_TEXT(const CCDBSynchronised &dbGroup)
2474 {
2475 uint32 value;
2476 _getProp(dbGroup, _DETAIL_TEXT, value);
2477
2478 return value;
2479 }
2480
2481 ICDBStructNode *getDETAIL_TEXTCDBNode()
2482 {
2483 return _DETAIL_TEXT;
2484 }
2485
2486 void setBEGIN_DATE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
2487 {
2488
2489
2490 _setProp(dbGroup, _BEGIN_DATE, value, forceSending);
2491 }
2492
2493 uint32 getBEGIN_DATE(const CCDBSynchronised &dbGroup)
2494 {
2495 uint32 value;
2496 _getProp(dbGroup, _BEGIN_DATE, value);
2497
2498 return value;
2499 }
2500
2501 ICDBStructNode *getBEGIN_DATECDBNode()
2502 {
2503 return _BEGIN_DATE;
2504 }
2505
2506 void setEND_DATE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
2507 {
2508
2509
2510 _setProp(dbGroup, _END_DATE, value, forceSending);
2511 }
2512
2513 uint32 getEND_DATE(const CCDBSynchronised &dbGroup)
2514 {
2515 uint32 value;
2516 _getProp(dbGroup, _END_DATE, value);
2517
2518 return value;
2519 }
2520
2521 ICDBStructNode *getEND_DATECDBNode()
2522 {
2523 return _END_DATE;
2524 }
2525
2526 void setOR_STEPS(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
2527 {
2528
2529
2530 _setProp(dbGroup, _OR_STEPS, value, forceSending);
2531 }
2532
2533 bool getOR_STEPS(const CCDBSynchronised &dbGroup)
2534 {
2535 bool value;
2536 _getProp(dbGroup, _OR_STEPS, value);
2537
2538 return value;
2539 }
2540
2541 ICDBStructNode *getOR_STEPSCDBNode()
2542 {
2543 return _OR_STEPS;
2544 }
2545
2546 void setFINISHED(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
2547 {
2548
2549 // Check that the value is not out of database precision
2550 STOP_IF(value > (1<<2)-1, "setFINISHED : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 2 bits");
2551
2552
2553 _setProp(dbGroup, _FINISHED, value, forceSending);
2554 }
2555
2556 uint8 getFINISHED(const CCDBSynchronised &dbGroup)
2557 {
2558 uint8 value;
2559 _getProp(dbGroup, _FINISHED, value);
2560
2561 return value;
2562 }
2563
2564 ICDBStructNode *getFINISHEDCDBNode()
2565 {
2566 return _FINISHED;
2567 }
2568
2569 void setABANDONNABLE(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
2570 {
2571
2572
2573 _setProp(dbGroup, _ABANDONNABLE, value, forceSending);
2574 }
2575
2576 bool getABANDONNABLE(const CCDBSynchronised &dbGroup)
2577 {
2578 bool value;
2579 _getProp(dbGroup, _ABANDONNABLE, value);
2580
2581 return value;
2582 }
2583
2584 ICDBStructNode *getABANDONNABLECDBNode()
2585 {
2586 return _ABANDONNABLE;
2587 }
2588
2589 void setSLEEP(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
2590 {
2591
2592
2593 _setProp(dbGroup, _SLEEP, value, forceSending);
2594 }
2595
2596 bool getSLEEP(const CCDBSynchronised &dbGroup)
2597 {
2598 bool value;
2599 _getProp(dbGroup, _SLEEP, value);
2600
2601 return value;
2602 }
2603
2604 ICDBStructNode *getSLEEPCDBNode()
2605 {
2606 return _SLEEP;
2607 }
2608 TGOALS &getGOALS()
2609 {
2610 return _GOALS;
2611 }
2612 TTARGET &getTARGET(uint32 index)
2613 {
2614 nlassert(index < 8);
2615 return _TARGET[index];
2616 }
2617 THISTO &getHISTO()
2618 {
2619 return _HISTO;
2620 }
2621
2622 };
2623
2624
2625 private:
2626 ICDBStructNode *_BranchNode;
2627
2628 TArray _Array[15];
2629
2630
2631 public:
2632 void init(ICDBStructNode *parent);
2633
2634 // accessor to branch node
2635 ICDBStructNode *getCDBNode()
2636 {
2637 return _BranchNode;
2638 }
2639
2640 TArray &getArray(uint32 index)
2641 {
2642 nlassert(index < 15);
2643 return _Array[index];
2644 }
2645
2646 };
2647
2648
2649 private:
2650 ICDBStructNode *_BranchNode;
2651
2652 ICDBStructNode *_LEADER_INDEX;
2653 ICDBStructNode *_SUCCESSOR_INDEX;
2654 TArray _Array[8];
2655 TMISSIONS _MISSIONS;
2656
2657
2658 public:
2659 void init(ICDBStructNode *parent);
2660
2661 // accessor to branch node
2662 ICDBStructNode *getCDBNode()
2663 {
2664 return _BranchNode;
2665 }
2666
2667
2668 void setLEADER_INDEX(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
2669 {
2670
2671 // Check that the value is not out of database precision
2672 STOP_IF(value > (1<<4)-1, "setLEADER_INDEX : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 4 bits");
2673
2674
2675 _setProp(dbGroup, _LEADER_INDEX, value, forceSending);
2676 }
2677
2678 uint8 getLEADER_INDEX(const CCDBSynchronised &dbGroup)
2679 {
2680 uint8 value;
2681 _getProp(dbGroup, _LEADER_INDEX, value);
2682
2683 return value;
2684 }
2685
2686 ICDBStructNode *getLEADER_INDEXCDBNode()
2687 {
2688 return _LEADER_INDEX;
2689 }
2690
2691 void setSUCCESSOR_INDEX(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
2692 {
2693
2694 // Check that the value is not out of database precision
2695 STOP_IF(value > (1<<4)-1, "setSUCCESSOR_INDEX : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 4 bits");
2696
2697
2698 _setProp(dbGroup, _SUCCESSOR_INDEX, value, forceSending);
2699 }
2700
2701 uint8 getSUCCESSOR_INDEX(const CCDBSynchronised &dbGroup)
2702 {
2703 uint8 value;
2704 _getProp(dbGroup, _SUCCESSOR_INDEX, value);
2705
2706 return value;
2707 }
2708
2709 ICDBStructNode *getSUCCESSOR_INDEXCDBNode()
2710 {
2711 return _SUCCESSOR_INDEX;
2712 }
2713 TArray &getArray(uint32 index)
2714 {
2715 nlassert(index < 8);
2716 return _Array[index];
2717 }
2718 TMISSIONS &getMISSIONS()
2719 {
2720 return _MISSIONS;
2721 }
2722
2723 };
2724
2725 class TDM_GIFT
2726 {
2727 public:
2728
2729
2730 private:
2731 ICDBStructNode *_BranchNode;
2732
2733 ICDBStructNode *_TEXT;
2734
2735
2736 public:
2737 void init(ICDBStructNode *parent);
2738
2739 // accessor to branch node
2740 ICDBStructNode *getCDBNode()
2741 {
2742 return _BranchNode;
2743 }
2744
2745
2746 void setTEXT(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
2747 {
2748
2749
2750 _setProp(dbGroup, _TEXT, value, forceSending);
2751 }
2752
2753 uint32 getTEXT(const CCDBSynchronised &dbGroup)
2754 {
2755 uint32 value;
2756 _getProp(dbGroup, _TEXT, value);
2757
2758 return value;
2759 }
2760
2761 ICDBStructNode *getTEXTCDBNode()
2762 {
2763 return _TEXT;
2764 }
2765
2766 };
2767
2768 class TEXCHANGE
2769 {
2770 public:
2771
2772 class TGIVE
2773 {
2774 public:
2775
2776 class TArray
2777 {
2778 public:
2779
2780
2781 private:
2782 ICDBStructNode *_BranchNode;
2783
2784 ICDBStructNode *_SHEET;
2785 ICDBStructNode *_QUALITY;
2786 ICDBStructNode *_QUANTITY;
2787 ICDBStructNode *_CREATE_TIME;
2788 ICDBStructNode *_SERIAL;
2789 ICDBStructNode *_USER_COLOR;
2790 ICDBStructNode *_WEIGHT;
2791 ICDBStructNode *_NAMEID;
2792 ICDBStructNode *_INFO_VERSION;
2793 ICDBStructNode *_ENCHANT;
2794 ICDBStructNode *_RM_CLASS_TYPE;
2795 ICDBStructNode *_RM_FABER_STAT_TYPE;
2796 ICDBStructNode *_PREREQUISIT_VALID;
2797
2798
2799 public:
2800 void init(ICDBStructNode *parent, uint index);
2801
2802 // accessor to branch node
2803 ICDBStructNode *getCDBNode()
2804 {
2805 return _BranchNode;
2806 }
2807
2808
2809 void setSHEET(CCDBSynchronised &dbGroup, NLMISC::CSheetId value, bool forceSending = false)
2810 {
2811
2812
2813 _setProp(dbGroup, _SHEET, value, forceSending);
2814 }
2815
2816 NLMISC::CSheetId getSHEET(const CCDBSynchronised &dbGroup)
2817 {
2818 NLMISC::CSheetId value;
2819 _getProp(dbGroup, _SHEET, value);
2820
2821 return value;
2822 }
2823
2824 ICDBStructNode *getSHEETCDBNode()
2825 {
2826 return _SHEET;
2827 }
2828
2829 void setQUALITY(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
2830 {
2831
2832 // Check that the value is not out of database precision
2833 STOP_IF(value > (1<<10)-1, "setQUALITY : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 10 bits");
2834
2835
2836 _setProp(dbGroup, _QUALITY, value, forceSending);
2837 }
2838
2839 uint16 getQUALITY(const CCDBSynchronised &dbGroup)
2840 {
2841 uint16 value;
2842 _getProp(dbGroup, _QUALITY, value);
2843
2844 return value;
2845 }
2846
2847 ICDBStructNode *getQUALITYCDBNode()
2848 {
2849 return _QUALITY;
2850 }
2851
2852 void setQUANTITY(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
2853 {
2854
2855 // Check that the value is not out of database precision
2856 STOP_IF(value > (1<<10)-1, "setQUANTITY : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 10 bits");
2857
2858
2859 _setProp(dbGroup, _QUANTITY, value, forceSending);
2860 }
2861
2862 uint16 getQUANTITY(const CCDBSynchronised &dbGroup)
2863 {
2864 uint16 value;
2865 _getProp(dbGroup, _QUANTITY, value);
2866
2867 return value;
2868 }
2869
2870 ICDBStructNode *getQUANTITYCDBNode()
2871 {
2872 return _QUANTITY;
2873 }
2874
2875 void setCREATE_TIME(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
2876 {
2877
2878
2879 _setProp(dbGroup, _CREATE_TIME, value, forceSending);
2880 }
2881
2882 uint32 getCREATE_TIME(const CCDBSynchronised &dbGroup)
2883 {
2884 uint32 value;
2885 _getProp(dbGroup, _CREATE_TIME, value);
2886
2887 return value;
2888 }
2889
2890 ICDBStructNode *getCREATE_TIMECDBNode()
2891 {
2892 return _CREATE_TIME;
2893 }
2894
2895 void setSERIAL(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
2896 {
2897
2898
2899 _setProp(dbGroup, _SERIAL, value, forceSending);
2900 }
2901
2902 uint32 getSERIAL(const CCDBSynchronised &dbGroup)
2903 {
2904 uint32 value;
2905 _getProp(dbGroup, _SERIAL, value);
2906
2907 return value;
2908 }
2909
2910 ICDBStructNode *getSERIALCDBNode()
2911 {
2912 return _SERIAL;
2913 }
2914
2915 void setUSER_COLOR(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
2916 {
2917
2918 // Check that the value is not out of database precision
2919 STOP_IF(value > (1<<3)-1, "setUSER_COLOR : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 3 bits");
2920
2921
2922 _setProp(dbGroup, _USER_COLOR, value, forceSending);
2923 }
2924
2925 uint8 getUSER_COLOR(const CCDBSynchronised &dbGroup)
2926 {
2927 uint8 value;
2928 _getProp(dbGroup, _USER_COLOR, value);
2929
2930 return value;
2931 }
2932
2933 ICDBStructNode *getUSER_COLORCDBNode()
2934 {
2935 return _USER_COLOR;
2936 }
2937
2938 void setWEIGHT(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
2939 {
2940
2941
2942 _setProp(dbGroup, _WEIGHT, value, forceSending);
2943 }
2944
2945 uint16 getWEIGHT(const CCDBSynchronised &dbGroup)
2946 {
2947 uint16 value;
2948 _getProp(dbGroup, _WEIGHT, value);
2949
2950 return value;
2951 }
2952
2953 ICDBStructNode *getWEIGHTCDBNode()
2954 {
2955 return _WEIGHT;
2956 }
2957
2958 void setNAMEID(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
2959 {
2960
2961
2962 _setProp(dbGroup, _NAMEID, value, forceSending);
2963 }
2964
2965 uint32 getNAMEID(const CCDBSynchronised &dbGroup)
2966 {
2967 uint32 value;
2968 _getProp(dbGroup, _NAMEID, value);
2969
2970 return value;
2971 }
2972
2973 ICDBStructNode *getNAMEIDCDBNode()
2974 {
2975 return _NAMEID;
2976 }
2977
2978 void setINFO_VERSION(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
2979 {
2980
2981
2982 _setProp(dbGroup, _INFO_VERSION, value, forceSending);
2983 }
2984
2985 uint8 getINFO_VERSION(const CCDBSynchronised &dbGroup)
2986 {
2987 uint8 value;
2988 _getProp(dbGroup, _INFO_VERSION, value);
2989
2990 return value;
2991 }
2992
2993 ICDBStructNode *getINFO_VERSIONCDBNode()
2994 {
2995 return _INFO_VERSION;
2996 }
2997
2998 void setENCHANT(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
2999 {
3000
3001 // Check that the value is not out of database precision
3002 STOP_IF(value > (1<<10)-1, "setENCHANT : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 10 bits");
3003
3004
3005 _setProp(dbGroup, _ENCHANT, value, forceSending);
3006 }
3007
3008 uint16 getENCHANT(const CCDBSynchronised &dbGroup)
3009 {
3010 uint16 value;
3011 _getProp(dbGroup, _ENCHANT, value);
3012
3013 return value;
3014 }
3015
3016 ICDBStructNode *getENCHANTCDBNode()
3017 {
3018 return _ENCHANT;
3019 }
3020
3021 void setRM_CLASS_TYPE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
3022 {
3023
3024 // Check that the value is not out of database precision
3025 STOP_IF(value > (1<<3)-1, "setRM_CLASS_TYPE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 3 bits");
3026
3027
3028 _setProp(dbGroup, _RM_CLASS_TYPE, value, forceSending);
3029 }
3030
3031 uint8 getRM_CLASS_TYPE(const CCDBSynchronised &dbGroup)
3032 {
3033 uint8 value;
3034 _getProp(dbGroup, _RM_CLASS_TYPE, value);
3035
3036 return value;
3037 }
3038
3039 ICDBStructNode *getRM_CLASS_TYPECDBNode()
3040 {
3041 return _RM_CLASS_TYPE;
3042 }
3043
3044 void setRM_FABER_STAT_TYPE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
3045 {
3046
3047 // Check that the value is not out of database precision
3048 STOP_IF(value > (1<<6)-1, "setRM_FABER_STAT_TYPE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 6 bits");
3049
3050
3051 _setProp(dbGroup, _RM_FABER_STAT_TYPE, value, forceSending);
3052 }
3053
3054 uint8 getRM_FABER_STAT_TYPE(const CCDBSynchronised &dbGroup)
3055 {
3056 uint8 value;
3057 _getProp(dbGroup, _RM_FABER_STAT_TYPE, value);
3058
3059 return value;
3060 }
3061
3062 ICDBStructNode *getRM_FABER_STAT_TYPECDBNode()
3063 {
3064 return _RM_FABER_STAT_TYPE;
3065 }
3066
3067 void setPREREQUISIT_VALID(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
3068 {
3069
3070
3071 _setProp(dbGroup, _PREREQUISIT_VALID, value, forceSending);
3072 }
3073
3074 bool getPREREQUISIT_VALID(const CCDBSynchronised &dbGroup)
3075 {
3076 bool value;
3077 _getProp(dbGroup, _PREREQUISIT_VALID, value);
3078
3079 return value;
3080 }
3081
3082 ICDBStructNode *getPREREQUISIT_VALIDCDBNode()
3083 {
3084 return _PREREQUISIT_VALID;
3085 }
3086
3087 };
3088
3089
3090 private:
3091 ICDBStructNode *_BranchNode;
3092
3093 TArray _Array[10];
3094
3095
3096 public:
3097 void init(ICDBStructNode *parent);
3098
3099 // accessor to branch node
3100 ICDBStructNode *getCDBNode()
3101 {
3102 return _BranchNode;
3103 }
3104
3105 TArray &getArray(uint32 index)
3106 {
3107 nlassert(index < 10);
3108 return _Array[index];
3109 }
3110
3111 };
3112
3113 class TRECEIVE
3114 {
3115 public:
3116
3117 class TArray
3118 {
3119 public:
3120
3121
3122 private:
3123 ICDBStructNode *_BranchNode;
3124
3125 ICDBStructNode *_SHEET;
3126 ICDBStructNode *_QUALITY;
3127 ICDBStructNode *_QUANTITY;
3128 ICDBStructNode *_CREATE_TIME;
3129 ICDBStructNode *_SERIAL;
3130 ICDBStructNode *_USER_COLOR;
3131 ICDBStructNode *_WEIGHT;
3132 ICDBStructNode *_NAMEID;
3133 ICDBStructNode *_INFO_VERSION;
3134 ICDBStructNode *_ENCHANT;
3135 ICDBStructNode *_RM_CLASS_TYPE;
3136 ICDBStructNode *_RM_FABER_STAT_TYPE;
3137 ICDBStructNode *_PREREQUISIT_VALID;
3138
3139
3140 public:
3141 void init(ICDBStructNode *parent, uint index);
3142
3143 // accessor to branch node
3144 ICDBStructNode *getCDBNode()
3145 {
3146 return _BranchNode;
3147 }
3148
3149
3150 void setSHEET(CCDBSynchronised &dbGroup, NLMISC::CSheetId value, bool forceSending = false)
3151 {
3152
3153
3154 _setProp(dbGroup, _SHEET, value, forceSending);
3155 }
3156
3157 NLMISC::CSheetId getSHEET(const CCDBSynchronised &dbGroup)
3158 {
3159 NLMISC::CSheetId value;
3160 _getProp(dbGroup, _SHEET, value);
3161
3162 return value;
3163 }
3164
3165 ICDBStructNode *getSHEETCDBNode()
3166 {
3167 return _SHEET;
3168 }
3169
3170 void setQUALITY(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
3171 {
3172
3173 // Check that the value is not out of database precision
3174 STOP_IF(value > (1<<10)-1, "setQUALITY : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 10 bits");
3175
3176
3177 _setProp(dbGroup, _QUALITY, value, forceSending);
3178 }
3179
3180 uint16 getQUALITY(const CCDBSynchronised &dbGroup)
3181 {
3182 uint16 value;
3183 _getProp(dbGroup, _QUALITY, value);
3184
3185 return value;
3186 }
3187
3188 ICDBStructNode *getQUALITYCDBNode()
3189 {
3190 return _QUALITY;
3191 }
3192
3193 void setQUANTITY(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
3194 {
3195
3196 // Check that the value is not out of database precision
3197 STOP_IF(value > (1<<10)-1, "setQUANTITY : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 10 bits");
3198
3199
3200 _setProp(dbGroup, _QUANTITY, value, forceSending);
3201 }
3202
3203 uint16 getQUANTITY(const CCDBSynchronised &dbGroup)
3204 {
3205 uint16 value;
3206 _getProp(dbGroup, _QUANTITY, value);
3207
3208 return value;
3209 }
3210
3211 ICDBStructNode *getQUANTITYCDBNode()
3212 {
3213 return _QUANTITY;
3214 }
3215
3216 void setCREATE_TIME(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
3217 {
3218
3219
3220 _setProp(dbGroup, _CREATE_TIME, value, forceSending);
3221 }
3222
3223 uint32 getCREATE_TIME(const CCDBSynchronised &dbGroup)
3224 {
3225 uint32 value;
3226 _getProp(dbGroup, _CREATE_TIME, value);
3227
3228 return value;
3229 }
3230
3231 ICDBStructNode *getCREATE_TIMECDBNode()
3232 {
3233 return _CREATE_TIME;
3234 }
3235
3236 void setSERIAL(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
3237 {
3238
3239
3240 _setProp(dbGroup, _SERIAL, value, forceSending);
3241 }
3242
3243 uint32 getSERIAL(const CCDBSynchronised &dbGroup)
3244 {
3245 uint32 value;
3246 _getProp(dbGroup, _SERIAL, value);
3247
3248 return value;
3249 }
3250
3251 ICDBStructNode *getSERIALCDBNode()
3252 {
3253 return _SERIAL;
3254 }
3255
3256 void setUSER_COLOR(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
3257 {
3258
3259 // Check that the value is not out of database precision
3260 STOP_IF(value > (1<<3)-1, "setUSER_COLOR : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 3 bits");
3261
3262
3263 _setProp(dbGroup, _USER_COLOR, value, forceSending);
3264 }
3265
3266 uint8 getUSER_COLOR(const CCDBSynchronised &dbGroup)
3267 {
3268 uint8 value;
3269 _getProp(dbGroup, _USER_COLOR, value);
3270
3271 return value;
3272 }
3273
3274 ICDBStructNode *getUSER_COLORCDBNode()
3275 {
3276 return _USER_COLOR;
3277 }
3278
3279 void setWEIGHT(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
3280 {
3281
3282
3283 _setProp(dbGroup, _WEIGHT, value, forceSending);
3284 }
3285
3286 uint16 getWEIGHT(const CCDBSynchronised &dbGroup)
3287 {
3288 uint16 value;
3289 _getProp(dbGroup, _WEIGHT, value);
3290
3291 return value;
3292 }
3293
3294 ICDBStructNode *getWEIGHTCDBNode()
3295 {
3296 return _WEIGHT;
3297 }
3298
3299 void setNAMEID(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
3300 {
3301
3302
3303 _setProp(dbGroup, _NAMEID, value, forceSending);
3304 }
3305
3306 uint32 getNAMEID(const CCDBSynchronised &dbGroup)
3307 {
3308 uint32 value;
3309 _getProp(dbGroup, _NAMEID, value);
3310
3311 return value;
3312 }
3313
3314 ICDBStructNode *getNAMEIDCDBNode()
3315 {
3316 return _NAMEID;
3317 }
3318
3319 void setINFO_VERSION(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
3320 {
3321
3322
3323 _setProp(dbGroup, _INFO_VERSION, value, forceSending);
3324 }
3325
3326 uint8 getINFO_VERSION(const CCDBSynchronised &dbGroup)
3327 {
3328 uint8 value;
3329 _getProp(dbGroup, _INFO_VERSION, value);
3330
3331 return value;
3332 }
3333
3334 ICDBStructNode *getINFO_VERSIONCDBNode()
3335 {
3336 return _INFO_VERSION;
3337 }
3338
3339 void setENCHANT(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
3340 {
3341
3342 // Check that the value is not out of database precision
3343 STOP_IF(value > (1<<10)-1, "setENCHANT : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 10 bits");
3344
3345
3346 _setProp(dbGroup, _ENCHANT, value, forceSending);
3347 }
3348
3349 uint16 getENCHANT(const CCDBSynchronised &dbGroup)
3350 {
3351 uint16 value;
3352 _getProp(dbGroup, _ENCHANT, value);
3353
3354 return value;
3355 }
3356
3357 ICDBStructNode *getENCHANTCDBNode()
3358 {
3359 return _ENCHANT;
3360 }
3361
3362 void setRM_CLASS_TYPE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
3363 {
3364
3365 // Check that the value is not out of database precision
3366 STOP_IF(value > (1<<3)-1, "setRM_CLASS_TYPE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 3 bits");
3367
3368
3369 _setProp(dbGroup, _RM_CLASS_TYPE, value, forceSending);
3370 }
3371
3372 uint8 getRM_CLASS_TYPE(const CCDBSynchronised &dbGroup)
3373 {
3374 uint8 value;
3375 _getProp(dbGroup, _RM_CLASS_TYPE, value);
3376
3377 return value;
3378 }
3379
3380 ICDBStructNode *getRM_CLASS_TYPECDBNode()
3381 {
3382 return _RM_CLASS_TYPE;
3383 }
3384
3385 void setRM_FABER_STAT_TYPE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
3386 {
3387
3388 // Check that the value is not out of database precision
3389 STOP_IF(value > (1<<6)-1, "setRM_FABER_STAT_TYPE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 6 bits");
3390
3391
3392 _setProp(dbGroup, _RM_FABER_STAT_TYPE, value, forceSending);
3393 }
3394
3395 uint8 getRM_FABER_STAT_TYPE(const CCDBSynchronised &dbGroup)
3396 {
3397 uint8 value;
3398 _getProp(dbGroup, _RM_FABER_STAT_TYPE, value);
3399
3400 return value;
3401 }
3402
3403 ICDBStructNode *getRM_FABER_STAT_TYPECDBNode()
3404 {
3405 return _RM_FABER_STAT_TYPE;
3406 }
3407
3408 void setPREREQUISIT_VALID(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
3409 {
3410
3411
3412 _setProp(dbGroup, _PREREQUISIT_VALID, value, forceSending);
3413 }
3414
3415 bool getPREREQUISIT_VALID(const CCDBSynchronised &dbGroup)
3416 {
3417 bool value;
3418 _getProp(dbGroup, _PREREQUISIT_VALID, value);
3419
3420 return value;
3421 }
3422
3423 ICDBStructNode *getPREREQUISIT_VALIDCDBNode()
3424 {
3425 return _PREREQUISIT_VALID;
3426 }
3427
3428 };
3429
3430
3431 private:
3432 ICDBStructNode *_BranchNode;
3433
3434 TArray _Array[10];
3435
3436
3437 public:
3438 void init(ICDBStructNode *parent);
3439
3440 // accessor to branch node
3441 ICDBStructNode *getCDBNode()
3442 {
3443 return _BranchNode;
3444 }
3445
3446 TArray &getArray(uint32 index)
3447 {
3448 nlassert(index < 10);
3449 return _Array[index];
3450 }
3451
3452 };
3453
3454
3455 private:
3456 ICDBStructNode *_BranchNode;
3457
3458 ICDBStructNode *_TEXT;
3459 ICDBStructNode *_ID;
3460 ICDBStructNode *_BEGUN;
3461 ICDBStructNode *_ACCEPTED;
3462 ICDBStructNode *_MONEY;
3463 ICDBStructNode *_FORCE_REFUSE;
3464 ICDBStructNode *_COUNTER;
3465 TGIVE _GIVE;
3466 TRECEIVE _RECEIVE;
3467
3468
3469 public:
3470 void init(ICDBStructNode *parent);
3471
3472 // accessor to branch node
3473 ICDBStructNode *getCDBNode()
3474 {
3475 return _BranchNode;
3476 }
3477
3478
3479 void setTEXT(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
3480 {
3481
3482
3483 _setProp(dbGroup, _TEXT, value, forceSending);
3484 }
3485
3486 uint32 getTEXT(const CCDBSynchronised &dbGroup)
3487 {
3488 uint32 value;
3489 _getProp(dbGroup, _TEXT, value);
3490
3491 return value;
3492 }
3493
3494 ICDBStructNode *getTEXTCDBNode()
3495 {
3496 return _TEXT;
3497 }
3498
3499 void setID(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
3500 {
3501
3502
3503 _setProp(dbGroup, _ID, value, forceSending);
3504 }
3505
3506 uint8 getID(const CCDBSynchronised &dbGroup)
3507 {
3508 uint8 value;
3509 _getProp(dbGroup, _ID, value);
3510
3511 return value;
3512 }
3513
3514 ICDBStructNode *getIDCDBNode()
3515 {
3516 return _ID;
3517 }
3518
3519 void setBEGUN(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
3520 {
3521
3522
3523 _setProp(dbGroup, _BEGUN, value, forceSending);
3524 }
3525
3526 bool getBEGUN(const CCDBSynchronised &dbGroup)
3527 {
3528 bool value;
3529 _getProp(dbGroup, _BEGUN, value);
3530
3531 return value;
3532 }
3533
3534 ICDBStructNode *getBEGUNCDBNode()
3535 {
3536 return _BEGUN;
3537 }
3538
3539 void setACCEPTED(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
3540 {
3541
3542
3543 _setProp(dbGroup, _ACCEPTED, value, forceSending);
3544 }
3545
3546 bool getACCEPTED(const CCDBSynchronised &dbGroup)
3547 {
3548 bool value;
3549 _getProp(dbGroup, _ACCEPTED, value);
3550
3551 return value;
3552 }
3553
3554 ICDBStructNode *getACCEPTEDCDBNode()
3555 {
3556 return _ACCEPTED;
3557 }
3558
3559 void setMONEY(CCDBSynchronised &dbGroup, uint64 value, bool forceSending = false)
3560 {
3561
3562
3563 _setProp(dbGroup, _MONEY, value, forceSending);
3564 }
3565
3566 uint64 getMONEY(const CCDBSynchronised &dbGroup)
3567 {
3568 uint64 value;
3569 _getProp(dbGroup, _MONEY, value);
3570
3571 return value;
3572 }
3573
3574 ICDBStructNode *getMONEYCDBNode()
3575 {
3576 return _MONEY;
3577 }
3578
3579 void setFORCE_REFUSE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
3580 {
3581
3582 // Check that the value is not out of database precision
3583 STOP_IF(value > (1<<4)-1, "setFORCE_REFUSE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 4 bits");
3584
3585
3586 _setProp(dbGroup, _FORCE_REFUSE, value, forceSending);
3587 }
3588
3589 uint8 getFORCE_REFUSE(const CCDBSynchronised &dbGroup)
3590 {
3591 uint8 value;
3592 _getProp(dbGroup, _FORCE_REFUSE, value);
3593
3594 return value;
3595 }
3596
3597 ICDBStructNode *getFORCE_REFUSECDBNode()
3598 {
3599 return _FORCE_REFUSE;
3600 }
3601
3602 void setCOUNTER(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
3603 {
3604
3605 // Check that the value is not out of database precision
3606 STOP_IF(value > (1<<4)-1, "setCOUNTER : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 4 bits");
3607
3608
3609 _setProp(dbGroup, _COUNTER, value, forceSending);
3610 }
3611
3612 uint8 getCOUNTER(const CCDBSynchronised &dbGroup)
3613 {
3614 uint8 value;
3615 _getProp(dbGroup, _COUNTER, value);
3616
3617 return value;
3618 }
3619
3620 ICDBStructNode *getCOUNTERCDBNode()
3621 {
3622 return _COUNTER;
3623 }
3624 TGIVE &getGIVE()
3625 {
3626 return _GIVE;
3627 }
3628 TRECEIVE &getRECEIVE()
3629 {
3630 return _RECEIVE;
3631 }
3632
3633 };
3634
3635 class TINVENTORY
3636 {
3637 public:
3638
3639 class THAND
3640 {
3641 public:
3642
3643 class TArray
3644 {
3645 public:
3646
3647
3648 private:
3649 ICDBStructNode *_BranchNode;
3650
3651 ICDBStructNode *_INDEX_IN_BAG;
3652
3653
3654 public:
3655 void init(ICDBStructNode *parent, uint index);
3656
3657 // accessor to branch node
3658 ICDBStructNode *getCDBNode()
3659 {
3660 return _BranchNode;
3661 }
3662
3663
3664 void setINDEX_IN_BAG(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
3665 {
3666
3667 // Check that the value is not out of database precision
3668 STOP_IF(value > (1<<9)-1, "setINDEX_IN_BAG : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 9 bits");
3669
3670
3671 _setProp(dbGroup, _INDEX_IN_BAG, value, forceSending);
3672 }
3673
3674 uint16 getINDEX_IN_BAG(const CCDBSynchronised &dbGroup)
3675 {
3676 uint16 value;
3677 _getProp(dbGroup, _INDEX_IN_BAG, value);
3678
3679 return value;
3680 }
3681
3682 ICDBStructNode *getINDEX_IN_BAGCDBNode()
3683 {
3684 return _INDEX_IN_BAG;
3685 }
3686
3687 };
3688
3689
3690 private:
3691 ICDBStructNode *_BranchNode;
3692
3693 TArray _Array[2];
3694
3695
3696 public:
3697 void init(ICDBStructNode *parent);
3698
3699 // accessor to branch node
3700 ICDBStructNode *getCDBNode()
3701 {
3702 return _BranchNode;
3703 }
3704
3705 TArray &getArray(uint32 index)
3706 {
3707 nlassert(index < 2);
3708 return _Array[index];
3709 }
3710
3711 };
3712
3713 class TEQUIP
3714 {
3715 public:
3716
3717 class TArray
3718 {
3719 public:
3720
3721
3722 private:
3723 ICDBStructNode *_BranchNode;
3724
3725 ICDBStructNode *_INDEX_IN_BAG;
3726
3727
3728 public:
3729 void init(ICDBStructNode *parent, uint index);
3730
3731 // accessor to branch node
3732 ICDBStructNode *getCDBNode()
3733 {
3734 return _BranchNode;
3735 }
3736
3737
3738 void setINDEX_IN_BAG(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
3739 {
3740
3741 // Check that the value is not out of database precision
3742 STOP_IF(value > (1<<9)-1, "setINDEX_IN_BAG : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 9 bits");
3743
3744
3745 _setProp(dbGroup, _INDEX_IN_BAG, value, forceSending);
3746 }
3747
3748 uint16 getINDEX_IN_BAG(const CCDBSynchronised &dbGroup)
3749 {
3750 uint16 value;
3751 _getProp(dbGroup, _INDEX_IN_BAG, value);
3752
3753 return value;
3754 }
3755
3756 ICDBStructNode *getINDEX_IN_BAGCDBNode()
3757 {
3758 return _INDEX_IN_BAG;
3759 }
3760
3761 };
3762
3763
3764 private:
3765 ICDBStructNode *_BranchNode;
3766
3767 TArray _Array[19];
3768
3769
3770 public:
3771 void init(ICDBStructNode *parent);
3772
3773 // accessor to branch node
3774 ICDBStructNode *getCDBNode()
3775 {
3776 return _BranchNode;
3777 }
3778
3779 TArray &getArray(uint32 index)
3780 {
3781 nlassert(index < 19);
3782 return _Array[index];
3783 }
3784
3785 };
3786
3787 class THOTBAR
3788 {
3789 public:
3790
3791 class TArray
3792 {
3793 public:
3794
3795
3796 private:
3797 ICDBStructNode *_BranchNode;
3798
3799 ICDBStructNode *_INDEX_IN_BAG;
3800
3801
3802 public:
3803 void init(ICDBStructNode *parent, uint index);
3804
3805 // accessor to branch node
3806 ICDBStructNode *getCDBNode()
3807 {
3808 return _BranchNode;
3809 }
3810
3811
3812 void setINDEX_IN_BAG(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
3813 {
3814
3815 // Check that the value is not out of database precision
3816 STOP_IF(value > (1<<9)-1, "setINDEX_IN_BAG : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 9 bits");
3817
3818
3819 _setProp(dbGroup, _INDEX_IN_BAG, value, forceSending);
3820 }
3821
3822 uint16 getINDEX_IN_BAG(const CCDBSynchronised &dbGroup)
3823 {
3824 uint16 value;
3825 _getProp(dbGroup, _INDEX_IN_BAG, value);
3826
3827 return value;
3828 }
3829
3830 ICDBStructNode *getINDEX_IN_BAGCDBNode()
3831 {
3832 return _INDEX_IN_BAG;
3833 }
3834
3835 };
3836
3837
3838 private:
3839 ICDBStructNode *_BranchNode;
3840
3841 TArray _Array[5];
3842
3843
3844 public:
3845 void init(ICDBStructNode *parent);
3846
3847 // accessor to branch node
3848 ICDBStructNode *getCDBNode()
3849 {
3850 return _BranchNode;
3851 }
3852
3853 TArray &getArray(uint32 index)
3854 {
3855 nlassert(index < 5);
3856 return _Array[index];
3857 }
3858
3859 };
3860
3861 class TTEMP
3862 {
3863 public:
3864
3865 class TArray
3866 {
3867 public:
3868
3869
3870 private:
3871 ICDBStructNode *_BranchNode;
3872
3873 ICDBStructNode *_SHEET;
3874 ICDBStructNode *_QUALITY;
3875 ICDBStructNode *_QUANTITY;
3876 ICDBStructNode *_CREATE_TIME;
3877 ICDBStructNode *_SERIAL;
3878 ICDBStructNode *_USER_COLOR;
3879 ICDBStructNode *_WEIGHT;
3880 ICDBStructNode *_NAMEID;
3881 ICDBStructNode *_INFO_VERSION;
3882 ICDBStructNode *_ENCHANT;
3883 ICDBStructNode *_RM_CLASS_TYPE;
3884 ICDBStructNode *_RM_FABER_STAT_TYPE;
3885 ICDBStructNode *_PREREQUISIT_VALID;
3886
3887
3888 public:
3889 void init(ICDBStructNode *parent, uint index);
3890
3891 // accessor to branch node
3892 ICDBStructNode *getCDBNode()
3893 {
3894 return _BranchNode;
3895 }
3896
3897
3898 void setSHEET(CCDBSynchronised &dbGroup, NLMISC::CSheetId value, bool forceSending = false)
3899 {
3900
3901
3902 _setProp(dbGroup, _SHEET, value, forceSending);
3903 }
3904
3905 NLMISC::CSheetId getSHEET(const CCDBSynchronised &dbGroup)
3906 {
3907 NLMISC::CSheetId value;
3908 _getProp(dbGroup, _SHEET, value);
3909
3910 return value;
3911 }
3912
3913 ICDBStructNode *getSHEETCDBNode()
3914 {
3915 return _SHEET;
3916 }
3917
3918 void setQUALITY(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
3919 {
3920
3921 // Check that the value is not out of database precision
3922 STOP_IF(value > (1<<12)-1, "setQUALITY : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 12 bits");
3923
3924
3925 _setProp(dbGroup, _QUALITY, value, forceSending);
3926 }
3927
3928 uint16 getQUALITY(const CCDBSynchronised &dbGroup)
3929 {
3930 uint16 value;
3931 _getProp(dbGroup, _QUALITY, value);
3932
3933 return value;
3934 }
3935
3936 ICDBStructNode *getQUALITYCDBNode()
3937 {
3938 return _QUALITY;
3939 }
3940
3941 void setQUANTITY(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
3942 {
3943
3944 // Check that the value is not out of database precision
3945 STOP_IF(value > (1<<12)-1, "setQUANTITY : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 12 bits");
3946
3947
3948 _setProp(dbGroup, _QUANTITY, value, forceSending);
3949 }
3950
3951 uint16 getQUANTITY(const CCDBSynchronised &dbGroup)
3952 {
3953 uint16 value;
3954 _getProp(dbGroup, _QUANTITY, value);
3955
3956 return value;
3957 }
3958
3959 ICDBStructNode *getQUANTITYCDBNode()
3960 {
3961 return _QUANTITY;
3962 }
3963
3964 void setCREATE_TIME(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
3965 {
3966
3967
3968 _setProp(dbGroup, _CREATE_TIME, value, forceSending);
3969 }
3970
3971 uint32 getCREATE_TIME(const CCDBSynchronised &dbGroup)
3972 {
3973 uint32 value;
3974 _getProp(dbGroup, _CREATE_TIME, value);
3975
3976 return value;
3977 }
3978
3979 ICDBStructNode *getCREATE_TIMECDBNode()
3980 {
3981 return _CREATE_TIME;
3982 }
3983
3984 void setSERIAL(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
3985 {
3986
3987
3988 _setProp(dbGroup, _SERIAL, value, forceSending);
3989 }
3990
3991 uint32 getSERIAL(const CCDBSynchronised &dbGroup)
3992 {
3993 uint32 value;
3994 _getProp(dbGroup, _SERIAL, value);
3995
3996 return value;
3997 }
3998
3999 ICDBStructNode *getSERIALCDBNode()
4000 {
4001 return _SERIAL;
4002 }
4003
4004 void setUSER_COLOR(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
4005 {
4006
4007 // Check that the value is not out of database precision
4008 STOP_IF(value > (1<<3)-1, "setUSER_COLOR : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 3 bits");
4009
4010
4011 _setProp(dbGroup, _USER_COLOR, value, forceSending);
4012 }
4013
4014 uint8 getUSER_COLOR(const CCDBSynchronised &dbGroup)
4015 {
4016 uint8 value;
4017 _getProp(dbGroup, _USER_COLOR, value);
4018
4019 return value;
4020 }
4021
4022 ICDBStructNode *getUSER_COLORCDBNode()
4023 {
4024 return _USER_COLOR;
4025 }
4026
4027 void setWEIGHT(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
4028 {
4029
4030
4031 _setProp(dbGroup, _WEIGHT, value, forceSending);
4032 }
4033
4034 uint16 getWEIGHT(const CCDBSynchronised &dbGroup)
4035 {
4036 uint16 value;
4037 _getProp(dbGroup, _WEIGHT, value);
4038
4039 return value;
4040 }
4041
4042 ICDBStructNode *getWEIGHTCDBNode()
4043 {
4044 return _WEIGHT;
4045 }
4046
4047 void setNAMEID(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
4048 {
4049
4050
4051 _setProp(dbGroup, _NAMEID, value, forceSending);
4052 }
4053
4054 uint32 getNAMEID(const CCDBSynchronised &dbGroup)
4055 {
4056 uint32 value;
4057 _getProp(dbGroup, _NAMEID, value);
4058
4059 return value;
4060 }
4061
4062 ICDBStructNode *getNAMEIDCDBNode()
4063 {
4064 return _NAMEID;
4065 }
4066
4067 void setINFO_VERSION(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
4068 {
4069
4070
4071 _setProp(dbGroup, _INFO_VERSION, value, forceSending);
4072 }
4073
4074 uint8 getINFO_VERSION(const CCDBSynchronised &dbGroup)
4075 {
4076 uint8 value;
4077 _getProp(dbGroup, _INFO_VERSION, value);
4078
4079 return value;
4080 }
4081
4082 ICDBStructNode *getINFO_VERSIONCDBNode()
4083 {
4084 return _INFO_VERSION;
4085 }
4086
4087 void setENCHANT(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
4088 {
4089
4090 // Check that the value is not out of database precision
4091 STOP_IF(value > (1<<10)-1, "setENCHANT : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 10 bits");
4092
4093
4094 _setProp(dbGroup, _ENCHANT, value, forceSending);
4095 }
4096
4097 uint16 getENCHANT(const CCDBSynchronised &dbGroup)
4098 {
4099 uint16 value;
4100 _getProp(dbGroup, _ENCHANT, value);
4101
4102 return value;
4103 }
4104
4105 ICDBStructNode *getENCHANTCDBNode()
4106 {
4107 return _ENCHANT;
4108 }
4109
4110 void setRM_CLASS_TYPE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
4111 {
4112
4113 // Check that the value is not out of database precision
4114 STOP_IF(value > (1<<3)-1, "setRM_CLASS_TYPE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 3 bits");
4115
4116
4117 _setProp(dbGroup, _RM_CLASS_TYPE, value, forceSending);
4118 }
4119
4120 uint8 getRM_CLASS_TYPE(const CCDBSynchronised &dbGroup)
4121 {
4122 uint8 value;
4123 _getProp(dbGroup, _RM_CLASS_TYPE, value);
4124
4125 return value;
4126 }
4127
4128 ICDBStructNode *getRM_CLASS_TYPECDBNode()
4129 {
4130 return _RM_CLASS_TYPE;
4131 }
4132
4133 void setRM_FABER_STAT_TYPE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
4134 {
4135
4136 // Check that the value is not out of database precision
4137 STOP_IF(value > (1<<6)-1, "setRM_FABER_STAT_TYPE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 6 bits");
4138
4139
4140 _setProp(dbGroup, _RM_FABER_STAT_TYPE, value, forceSending);
4141 }
4142
4143 uint8 getRM_FABER_STAT_TYPE(const CCDBSynchronised &dbGroup)
4144 {
4145 uint8 value;
4146 _getProp(dbGroup, _RM_FABER_STAT_TYPE, value);
4147
4148 return value;
4149 }
4150
4151 ICDBStructNode *getRM_FABER_STAT_TYPECDBNode()
4152 {
4153 return _RM_FABER_STAT_TYPE;
4154 }
4155
4156 void setPREREQUISIT_VALID(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
4157 {
4158
4159
4160 _setProp(dbGroup, _PREREQUISIT_VALID, value, forceSending);
4161 }
4162
4163 bool getPREREQUISIT_VALID(const CCDBSynchronised &dbGroup)
4164 {
4165 bool value;
4166 _getProp(dbGroup, _PREREQUISIT_VALID, value);
4167
4168 return value;
4169 }
4170
4171 ICDBStructNode *getPREREQUISIT_VALIDCDBNode()
4172 {
4173 return _PREREQUISIT_VALID;
4174 }
4175
4176 };
4177
4178
4179 private:
4180 ICDBStructNode *_BranchNode;
4181
4182 ICDBStructNode *_TYPE;
4183 ICDBStructNode *_ENABLE_TAKE;
4184 TArray _Array[16];
4185
4186
4187 public:
4188 void init(ICDBStructNode *parent);
4189
4190 // accessor to branch node
4191 ICDBStructNode *getCDBNode()
4192 {
4193 return _BranchNode;
4194 }
4195
4196
4197 void setTYPE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
4198 {
4199
4200
4201 _setProp(dbGroup, _TYPE, value, forceSending);
4202 }
4203
4204 uint8 getTYPE(const CCDBSynchronised &dbGroup)
4205 {
4206 uint8 value;
4207 _getProp(dbGroup, _TYPE, value);
4208
4209 return value;
4210 }
4211
4212 ICDBStructNode *getTYPECDBNode()
4213 {
4214 return _TYPE;
4215 }
4216
4217 void setENABLE_TAKE(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
4218 {
4219
4220
4221 _setProp(dbGroup, _ENABLE_TAKE, value, forceSending);
4222 }
4223
4224 bool getENABLE_TAKE(const CCDBSynchronised &dbGroup)
4225 {
4226 bool value;
4227 _getProp(dbGroup, _ENABLE_TAKE, value);
4228
4229 return value;
4230 }
4231
4232 ICDBStructNode *getENABLE_TAKECDBNode()
4233 {
4234 return _ENABLE_TAKE;
4235 }
4236 TArray &getArray(uint32 index)
4237 {
4238 nlassert(index < 16);
4239 return _Array[index];
4240 }
4241
4242 };
4243
4244 class TSHARE
4245 {
4246 public:
4247
4248 class TArray
4249 {
4250 public:
4251
4252
4253 private:
4254 ICDBStructNode *_BranchNode;
4255
4256 ICDBStructNode *_SHEET;
4257 ICDBStructNode *_QUALITY;
4258 ICDBStructNode *_QUANTITY;
4259 ICDBStructNode *_CREATE_TIME;
4260 ICDBStructNode *_SERIAL;
4261 ICDBStructNode *_USER_COLOR;
4262 ICDBStructNode *_WEIGHT;
4263 ICDBStructNode *_NAMEID;
4264 ICDBStructNode *_INFO_VERSION;
4265 ICDBStructNode *_ENCHANT;
4266 ICDBStructNode *_RM_CLASS_TYPE;
4267 ICDBStructNode *_RM_FABER_STAT_TYPE;
4268 ICDBStructNode *_PREREQUISIT_VALID;
4269 ICDBStructNode *_NB_MEMBER;
4270 ICDBStructNode *_WANTED;
4271 ICDBStructNode *_CHANCE;
4272
4273
4274 public:
4275 void init(ICDBStructNode *parent, uint index);
4276
4277 // accessor to branch node
4278 ICDBStructNode *getCDBNode()
4279 {
4280 return _BranchNode;
4281 }
4282
4283
4284 void setSHEET(CCDBSynchronised &dbGroup, NLMISC::CSheetId value, bool forceSending = false)
4285 {
4286
4287
4288 _setProp(dbGroup, _SHEET, value, forceSending);
4289 }
4290
4291 NLMISC::CSheetId getSHEET(const CCDBSynchronised &dbGroup)
4292 {
4293 NLMISC::CSheetId value;
4294 _getProp(dbGroup, _SHEET, value);
4295
4296 return value;
4297 }
4298
4299 ICDBStructNode *getSHEETCDBNode()
4300 {
4301 return _SHEET;
4302 }
4303
4304 void setQUALITY(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
4305 {
4306
4307 // Check that the value is not out of database precision
4308 STOP_IF(value > (1<<10)-1, "setQUALITY : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 10 bits");
4309
4310
4311 _setProp(dbGroup, _QUALITY, value, forceSending);
4312 }
4313
4314 uint16 getQUALITY(const CCDBSynchronised &dbGroup)
4315 {
4316 uint16 value;
4317 _getProp(dbGroup, _QUALITY, value);
4318
4319 return value;
4320 }
4321
4322 ICDBStructNode *getQUALITYCDBNode()
4323 {
4324 return _QUALITY;
4325 }
4326
4327 void setQUANTITY(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
4328 {
4329
4330 // Check that the value is not out of database precision
4331 STOP_IF(value > (1<<10)-1, "setQUANTITY : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 10 bits");
4332
4333
4334 _setProp(dbGroup, _QUANTITY, value, forceSending);
4335 }
4336
4337 uint16 getQUANTITY(const CCDBSynchronised &dbGroup)
4338 {
4339 uint16 value;
4340 _getProp(dbGroup, _QUANTITY, value);
4341
4342 return value;
4343 }
4344
4345 ICDBStructNode *getQUANTITYCDBNode()
4346 {
4347 return _QUANTITY;
4348 }
4349
4350 void setCREATE_TIME(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
4351 {
4352
4353
4354 _setProp(dbGroup, _CREATE_TIME, value, forceSending);
4355 }
4356
4357 uint32 getCREATE_TIME(const CCDBSynchronised &dbGroup)
4358 {
4359 uint32 value;
4360 _getProp(dbGroup, _CREATE_TIME, value);
4361
4362 return value;
4363 }
4364
4365 ICDBStructNode *getCREATE_TIMECDBNode()
4366 {
4367 return _CREATE_TIME;
4368 }
4369
4370 void setSERIAL(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
4371 {
4372
4373
4374 _setProp(dbGroup, _SERIAL, value, forceSending);
4375 }
4376
4377 uint32 getSERIAL(const CCDBSynchronised &dbGroup)
4378 {
4379 uint32 value;
4380 _getProp(dbGroup, _SERIAL, value);
4381
4382 return value;
4383 }
4384
4385 ICDBStructNode *getSERIALCDBNode()
4386 {
4387 return _SERIAL;
4388 }
4389
4390 void setUSER_COLOR(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
4391 {
4392
4393 // Check that the value is not out of database precision
4394 STOP_IF(value > (1<<3)-1, "setUSER_COLOR : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 3 bits");
4395
4396
4397 _setProp(dbGroup, _USER_COLOR, value, forceSending);
4398 }
4399
4400 uint8 getUSER_COLOR(const CCDBSynchronised &dbGroup)
4401 {
4402 uint8 value;
4403 _getProp(dbGroup, _USER_COLOR, value);
4404
4405 return value;
4406 }
4407
4408 ICDBStructNode *getUSER_COLORCDBNode()
4409 {
4410 return _USER_COLOR;
4411 }
4412
4413 void setWEIGHT(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
4414 {
4415
4416
4417 _setProp(dbGroup, _WEIGHT, value, forceSending);
4418 }
4419
4420 uint16 getWEIGHT(const CCDBSynchronised &dbGroup)
4421 {
4422 uint16 value;
4423 _getProp(dbGroup, _WEIGHT, value);
4424
4425 return value;
4426 }
4427
4428 ICDBStructNode *getWEIGHTCDBNode()
4429 {
4430 return _WEIGHT;
4431 }
4432
4433 void setNAMEID(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
4434 {
4435
4436
4437 _setProp(dbGroup, _NAMEID, value, forceSending);
4438 }
4439
4440 uint32 getNAMEID(const CCDBSynchronised &dbGroup)
4441 {
4442 uint32 value;
4443 _getProp(dbGroup, _NAMEID, value);
4444
4445 return value;
4446 }
4447
4448 ICDBStructNode *getNAMEIDCDBNode()
4449 {
4450 return _NAMEID;
4451 }
4452
4453 void setINFO_VERSION(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
4454 {
4455
4456
4457 _setProp(dbGroup, _INFO_VERSION, value, forceSending);
4458 }
4459
4460 uint8 getINFO_VERSION(const CCDBSynchronised &dbGroup)
4461 {
4462 uint8 value;
4463 _getProp(dbGroup, _INFO_VERSION, value);
4464
4465 return value;
4466 }
4467
4468 ICDBStructNode *getINFO_VERSIONCDBNode()
4469 {
4470 return _INFO_VERSION;
4471 }
4472
4473 void setENCHANT(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
4474 {
4475
4476 // Check that the value is not out of database precision
4477 STOP_IF(value > (1<<10)-1, "setENCHANT : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 10 bits");
4478
4479
4480 _setProp(dbGroup, _ENCHANT, value, forceSending);
4481 }
4482
4483 uint16 getENCHANT(const CCDBSynchronised &dbGroup)
4484 {
4485 uint16 value;
4486 _getProp(dbGroup, _ENCHANT, value);
4487
4488 return value;
4489 }
4490
4491 ICDBStructNode *getENCHANTCDBNode()
4492 {
4493 return _ENCHANT;
4494 }
4495
4496 void setRM_CLASS_TYPE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
4497 {
4498
4499 // Check that the value is not out of database precision
4500 STOP_IF(value > (1<<3)-1, "setRM_CLASS_TYPE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 3 bits");
4501
4502
4503 _setProp(dbGroup, _RM_CLASS_TYPE, value, forceSending);
4504 }
4505
4506 uint8 getRM_CLASS_TYPE(const CCDBSynchronised &dbGroup)
4507 {
4508 uint8 value;
4509 _getProp(dbGroup, _RM_CLASS_TYPE, value);
4510
4511 return value;
4512 }
4513
4514 ICDBStructNode *getRM_CLASS_TYPECDBNode()
4515 {
4516 return _RM_CLASS_TYPE;
4517 }
4518
4519 void setRM_FABER_STAT_TYPE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
4520 {
4521
4522 // Check that the value is not out of database precision
4523 STOP_IF(value > (1<<6)-1, "setRM_FABER_STAT_TYPE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 6 bits");
4524
4525
4526 _setProp(dbGroup, _RM_FABER_STAT_TYPE, value, forceSending);
4527 }
4528
4529 uint8 getRM_FABER_STAT_TYPE(const CCDBSynchronised &dbGroup)
4530 {
4531 uint8 value;
4532 _getProp(dbGroup, _RM_FABER_STAT_TYPE, value);
4533
4534 return value;
4535 }
4536
4537 ICDBStructNode *getRM_FABER_STAT_TYPECDBNode()
4538 {
4539 return _RM_FABER_STAT_TYPE;
4540 }
4541
4542 void setPREREQUISIT_VALID(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
4543 {
4544
4545
4546 _setProp(dbGroup, _PREREQUISIT_VALID, value, forceSending);
4547 }
4548
4549 bool getPREREQUISIT_VALID(const CCDBSynchronised &dbGroup)
4550 {
4551 bool value;
4552 _getProp(dbGroup, _PREREQUISIT_VALID, value);
4553
4554 return value;
4555 }
4556
4557 ICDBStructNode *getPREREQUISIT_VALIDCDBNode()
4558 {
4559 return _PREREQUISIT_VALID;
4560 }
4561
4562 void setNB_MEMBER(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
4563 {
4564
4565 // Check that the value is not out of database precision
4566 STOP_IF(value > (1<<4)-1, "setNB_MEMBER : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 4 bits");
4567
4568
4569 _setProp(dbGroup, _NB_MEMBER, value, forceSending);
4570 }
4571
4572 uint8 getNB_MEMBER(const CCDBSynchronised &dbGroup)
4573 {
4574 uint8 value;
4575 _getProp(dbGroup, _NB_MEMBER, value);
4576
4577 return value;
4578 }
4579
4580 ICDBStructNode *getNB_MEMBERCDBNode()
4581 {
4582 return _NB_MEMBER;
4583 }
4584
4585 void setWANTED(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
4586 {
4587
4588
4589 _setProp(dbGroup, _WANTED, value, forceSending);
4590 }
4591
4592 bool getWANTED(const CCDBSynchronised &dbGroup)
4593 {
4594 bool value;
4595 _getProp(dbGroup, _WANTED, value);
4596
4597 return value;
4598 }
4599
4600 ICDBStructNode *getWANTEDCDBNode()
4601 {
4602 return _WANTED;
4603 }
4604
4605 void setCHANCE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
4606 {
4607
4608 // Check that the value is not out of database precision
4609 STOP_IF(value > (1<<7)-1, "setCHANCE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 7 bits");
4610
4611
4612 _setProp(dbGroup, _CHANCE, value, forceSending);
4613 }
4614
4615 uint8 getCHANCE(const CCDBSynchronised &dbGroup)
4616 {
4617 uint8 value;
4618 _getProp(dbGroup, _CHANCE, value);
4619
4620 return value;
4621 }
4622
4623 ICDBStructNode *getCHANCECDBNode()
4624 {
4625 return _CHANCE;
4626 }
4627
4628 };
4629
4630 class TTM_
4631 {
4632 public:
4633
4634
4635 private:
4636 ICDBStructNode *_BranchNode;
4637
4638 ICDBStructNode *_NAME;
4639 ICDBStructNode *_VALID;
4640
4641
4642 public:
4643 void init(ICDBStructNode *parent, uint index);
4644
4645 // accessor to branch node
4646 ICDBStructNode *getCDBNode()
4647 {
4648 return _BranchNode;
4649 }
4650
4651
4652 void setNAME(CCDBSynchronised &dbGroup, ucstring value, bool forceSending = false)
4653 {
4654
4655
4656 _setProp(dbGroup, _NAME, value, forceSending);
4657 }
4658
4659 ucstring getNAME(const CCDBSynchronised &dbGroup)
4660 {
4661 ucstring value;
4662 _getProp(dbGroup, _NAME, value);
4663
4664 return value;
4665 }
4666
4667 void setNAME(CCDBSynchronised &dbGroup, uint32 stringId, bool forceSending = false)
4668 {
4669 _setProp(dbGroup, _NAME, stringId, forceSending);
4670 }
4671 uint32 getNAME_id(const CCDBSynchronised &dbGroup)
4672 {
4673 uint32 value;
4674 _getProp(dbGroup, _NAME, value);
4675
4676 return value;
4677 }
4678
4679 ICDBStructNode *getNAMECDBNode()
4680 {
4681 return _NAME;
4682 }
4683
4684 void setVALID(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
4685 {
4686
4687
4688 _setProp(dbGroup, _VALID, value, forceSending);
4689 }
4690
4691 bool getVALID(const CCDBSynchronised &dbGroup)
4692 {
4693 bool value;
4694 _getProp(dbGroup, _VALID, value);
4695
4696 return value;
4697 }
4698
4699 ICDBStructNode *getVALIDCDBNode()
4700 {
4701 return _VALID;
4702 }
4703
4704 };
4705
4706
4707 private:
4708 ICDBStructNode *_BranchNode;
4709
4710 ICDBStructNode *_SESSION;
4711 TArray _Array[16];
4712 TTM_ _TM_[8];
4713
4714
4715 public:
4716 void init(ICDBStructNode *parent);
4717
4718 // accessor to branch node
4719 ICDBStructNode *getCDBNode()
4720 {
4721 return _BranchNode;
4722 }
4723
4724
4725 void setSESSION(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
4726 {
4727
4728
4729 _setProp(dbGroup, _SESSION, value, forceSending);
4730 }
4731
4732 uint8 getSESSION(const CCDBSynchronised &dbGroup)
4733 {
4734 uint8 value;
4735 _getProp(dbGroup, _SESSION, value);
4736
4737 return value;
4738 }
4739
4740 ICDBStructNode *getSESSIONCDBNode()
4741 {
4742 return _SESSION;
4743 }
4744 TArray &getArray(uint32 index)
4745 {
4746 nlassert(index < 16);
4747 return _Array[index];
4748 }
4749 TTM_ &getTM_(uint32 index)
4750 {
4751 nlassert(index < 8);
4752 return _TM_[index];
4753 }
4754
4755 };
4756
4757 class TROOM
4758 {
4759 public:
4760
4761
4762 private:
4763 ICDBStructNode *_BranchNode;
4764
4765 ICDBStructNode *_SESSION;
4766 ICDBStructNode *_BULK_MAX;
4767 ICDBStructNode *_MONEY;
4768
4769
4770 public:
4771 void init(ICDBStructNode *parent);
4772
4773 // accessor to branch node
4774 ICDBStructNode *getCDBNode()
4775 {
4776 return _BranchNode;
4777 }
4778
4779
4780 void setSESSION(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
4781 {
4782
4783
4784 _setProp(dbGroup, _SESSION, value, forceSending);
4785 }
4786
4787 uint16 getSESSION(const CCDBSynchronised &dbGroup)
4788 {
4789 uint16 value;
4790 _getProp(dbGroup, _SESSION, value);
4791
4792 return value;
4793 }
4794
4795 ICDBStructNode *getSESSIONCDBNode()
4796 {
4797 return _SESSION;
4798 }
4799
4800 void setBULK_MAX(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
4801 {
4802
4803
4804 _setProp(dbGroup, _BULK_MAX, value, forceSending);
4805 }
4806
4807 uint32 getBULK_MAX(const CCDBSynchronised &dbGroup)
4808 {
4809 uint32 value;
4810 _getProp(dbGroup, _BULK_MAX, value);
4811
4812 return value;
4813 }
4814
4815 ICDBStructNode *getBULK_MAXCDBNode()
4816 {
4817 return _BULK_MAX;
4818 }
4819
4820 void setMONEY(CCDBSynchronised &dbGroup, uint64 value, bool forceSending = false)
4821 {
4822
4823
4824 _setProp(dbGroup, _MONEY, value, forceSending);
4825 }
4826
4827 uint64 getMONEY(const CCDBSynchronised &dbGroup)
4828 {
4829 uint64 value;
4830 _getProp(dbGroup, _MONEY, value);
4831
4832 return value;
4833 }
4834
4835 ICDBStructNode *getMONEYCDBNode()
4836 {
4837 return _MONEY;
4838 }
4839
4840 };
4841
4842
4843 private:
4844 ICDBStructNode *_BranchNode;
4845
4846 ICDBStructNode *_MONEY;
4847 ICDBStructNode *_COUNTER;
4848 THAND _HAND;
4849 TEQUIP _EQUIP;
4850 THOTBAR _HOTBAR;
4851 TTEMP _TEMP;
4852 TSHARE _SHARE;
4853 TROOM _ROOM;
4854
4855
4856 public:
4857 void init(ICDBStructNode *parent);
4858
4859 // accessor to branch node
4860 ICDBStructNode *getCDBNode()
4861 {
4862 return _BranchNode;
4863 }
4864
4865
4866 void setMONEY(CCDBSynchronised &dbGroup, uint64 value, bool forceSending = false)
4867 {
4868
4869
4870 _setProp(dbGroup, _MONEY, value, forceSending);
4871 }
4872
4873 uint64 getMONEY(const CCDBSynchronised &dbGroup)
4874 {
4875 uint64 value;
4876 _getProp(dbGroup, _MONEY, value);
4877
4878 return value;
4879 }
4880
4881 ICDBStructNode *getMONEYCDBNode()
4882 {
4883 return _MONEY;
4884 }
4885
4886 void setCOUNTER(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
4887 {
4888
4889 // Check that the value is not out of database precision
4890 STOP_IF(value > (1<<4)-1, "setCOUNTER : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 4 bits");
4891
4892
4893 _setProp(dbGroup, _COUNTER, value, forceSending);
4894 }
4895
4896 uint8 getCOUNTER(const CCDBSynchronised &dbGroup)
4897 {
4898 uint8 value;
4899 _getProp(dbGroup, _COUNTER, value);
4900
4901 return value;
4902 }
4903
4904 ICDBStructNode *getCOUNTERCDBNode()
4905 {
4906 return _COUNTER;
4907 }
4908 THAND &getHAND()
4909 {
4910 return _HAND;
4911 }
4912 TEQUIP &getEQUIP()
4913 {
4914 return _EQUIP;
4915 }
4916 THOTBAR &getHOTBAR()
4917 {
4918 return _HOTBAR;
4919 }
4920 TTEMP &getTEMP()
4921 {
4922 return _TEMP;
4923 }
4924 TSHARE &getSHARE()
4925 {
4926 return _SHARE;
4927 }
4928 TROOM &getROOM()
4929 {
4930 return _ROOM;
4931 }
4932
4933 };
4934
4935 class TMODIFIERS
4936 {
4937 public:
4938
4939 class TBONUS
4940 {
4941 public:
4942
4943 class TArray
4944 {
4945 public:
4946
4947
4948 private:
4949 ICDBStructNode *_BranchNode;
4950
4951 ICDBStructNode *_SHEET;
4952 ICDBStructNode *_DISABLED;
4953 ICDBStructNode *_DISABLED_TIME;
4954
4955
4956 public:
4957 void init(ICDBStructNode *parent, uint index);
4958
4959 // accessor to branch node
4960 ICDBStructNode *getCDBNode()
4961 {
4962 return _BranchNode;
4963 }
4964
4965
4966 void setSHEET(CCDBSynchronised &dbGroup, NLMISC::CSheetId value, bool forceSending = false)
4967 {
4968
4969
4970 _setProp(dbGroup, _SHEET, value, forceSending);
4971 }
4972
4973 NLMISC::CSheetId getSHEET(const CCDBSynchronised &dbGroup)
4974 {
4975 NLMISC::CSheetId value;
4976 _getProp(dbGroup, _SHEET, value);
4977
4978 return value;
4979 }
4980
4981 ICDBStructNode *getSHEETCDBNode()
4982 {
4983 return _SHEET;
4984 }
4985
4986 void setDISABLED(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
4987 {
4988
4989
4990 _setProp(dbGroup, _DISABLED, value, forceSending);
4991 }
4992
4993 bool getDISABLED(const CCDBSynchronised &dbGroup)
4994 {
4995 bool value;
4996 _getProp(dbGroup, _DISABLED, value);
4997
4998 return value;
4999 }
5000
5001 ICDBStructNode *getDISABLEDCDBNode()
5002 {
5003 return _DISABLED;
5004 }
5005
5006 void setDISABLED_TIME(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
5007 {
5008
5009
5010 _setProp(dbGroup, _DISABLED_TIME, value, forceSending);
5011 }
5012
5013 uint32 getDISABLED_TIME(const CCDBSynchronised &dbGroup)
5014 {
5015 uint32 value;
5016 _getProp(dbGroup, _DISABLED_TIME, value);
5017
5018 return value;
5019 }
5020
5021 ICDBStructNode *getDISABLED_TIMECDBNode()
5022 {
5023 return _DISABLED_TIME;
5024 }
5025
5026 };
5027
5028
5029 private:
5030 ICDBStructNode *_BranchNode;
5031
5032 TArray _Array[12];
5033
5034
5035 public:
5036 void init(ICDBStructNode *parent);
5037
5038 // accessor to branch node
5039 ICDBStructNode *getCDBNode()
5040 {
5041 return _BranchNode;
5042 }
5043
5044 TArray &getArray(uint32 index)
5045 {
5046 nlassert(index < 12);
5047 return _Array[index];
5048 }
5049
5050 };
5051
5052 class TMALUS
5053 {
5054 public:
5055
5056 class TArray
5057 {
5058 public:
5059
5060
5061 private:
5062 ICDBStructNode *_BranchNode;
5063
5064 ICDBStructNode *_SHEET;
5065 ICDBStructNode *_DISABLED;
5066 ICDBStructNode *_DISABLED_TIME;
5067
5068
5069 public:
5070 void init(ICDBStructNode *parent, uint index);
5071
5072 // accessor to branch node
5073 ICDBStructNode *getCDBNode()
5074 {
5075 return _BranchNode;
5076 }
5077
5078
5079 void setSHEET(CCDBSynchronised &dbGroup, NLMISC::CSheetId value, bool forceSending = false)
5080 {
5081
5082
5083 _setProp(dbGroup, _SHEET, value, forceSending);
5084 }
5085
5086 NLMISC::CSheetId getSHEET(const CCDBSynchronised &dbGroup)
5087 {
5088 NLMISC::CSheetId value;
5089 _getProp(dbGroup, _SHEET, value);
5090
5091 return value;
5092 }
5093
5094 ICDBStructNode *getSHEETCDBNode()
5095 {
5096 return _SHEET;
5097 }
5098
5099 void setDISABLED(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
5100 {
5101
5102
5103 _setProp(dbGroup, _DISABLED, value, forceSending);
5104 }
5105
5106 bool getDISABLED(const CCDBSynchronised &dbGroup)
5107 {
5108 bool value;
5109 _getProp(dbGroup, _DISABLED, value);
5110
5111 return value;
5112 }
5113
5114 ICDBStructNode *getDISABLEDCDBNode()
5115 {
5116 return _DISABLED;
5117 }
5118
5119 void setDISABLED_TIME(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
5120 {
5121
5122
5123 _setProp(dbGroup, _DISABLED_TIME, value, forceSending);
5124 }
5125
5126 uint32 getDISABLED_TIME(const CCDBSynchronised &dbGroup)
5127 {
5128 uint32 value;
5129 _getProp(dbGroup, _DISABLED_TIME, value);
5130
5131 return value;
5132 }
5133
5134 ICDBStructNode *getDISABLED_TIMECDBNode()
5135 {
5136 return _DISABLED_TIME;
5137 }
5138
5139 };
5140
5141
5142 private:
5143 ICDBStructNode *_BranchNode;
5144
5145 TArray _Array[12];
5146
5147
5148 public:
5149 void init(ICDBStructNode *parent);
5150
5151 // accessor to branch node
5152 ICDBStructNode *getCDBNode()
5153 {
5154 return _BranchNode;
5155 }
5156
5157 TArray &getArray(uint32 index)
5158 {
5159 nlassert(index < 12);
5160 return _Array[index];
5161 }
5162
5163 };
5164
5165
5166 private:
5167 ICDBStructNode *_BranchNode;
5168
5169 ICDBStructNode *_TOTAL_MALUS_EQUIP;
5170 TBONUS _BONUS;
5171 TMALUS _MALUS;
5172
5173
5174 public:
5175 void init(ICDBStructNode *parent);
5176
5177 // accessor to branch node
5178 ICDBStructNode *getCDBNode()
5179 {
5180 return _BranchNode;
5181 }
5182
5183
5184 void setTOTAL_MALUS_EQUIP(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
5185 {
5186
5187
5188 _setProp(dbGroup, _TOTAL_MALUS_EQUIP, value, forceSending);
5189 }
5190
5191 uint8 getTOTAL_MALUS_EQUIP(const CCDBSynchronised &dbGroup)
5192 {
5193 uint8 value;
5194 _getProp(dbGroup, _TOTAL_MALUS_EQUIP, value);
5195
5196 return value;
5197 }
5198
5199 ICDBStructNode *getTOTAL_MALUS_EQUIPCDBNode()
5200 {
5201 return _TOTAL_MALUS_EQUIP;
5202 }
5203 TBONUS &getBONUS()
5204 {
5205 return _BONUS;
5206 }
5207 TMALUS &getMALUS()
5208 {
5209 return _MALUS;
5210 }
5211
5212 };
5213
5214 class TDISABLE_CONSUMABLE
5215 {
5216 public:
5217
5218 class TArray
5219 {
5220 public:
5221
5222
5223 private:
5224 ICDBStructNode *_BranchNode;
5225
5226 ICDBStructNode *_FAMILY;
5227 ICDBStructNode *_DISABLE_TIME;
5228
5229
5230 public:
5231 void init(ICDBStructNode *parent, uint index);
5232
5233 // accessor to branch node
5234 ICDBStructNode *getCDBNode()
5235 {
5236 return _BranchNode;
5237 }
5238
5239
5240 void setFAMILY(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
5241 {
5242
5243
5244 _setProp(dbGroup, _FAMILY, value, forceSending);
5245 }
5246
5247 uint16 getFAMILY(const CCDBSynchronised &dbGroup)
5248 {
5249 uint16 value;
5250 _getProp(dbGroup, _FAMILY, value);
5251
5252 return value;
5253 }
5254
5255 ICDBStructNode *getFAMILYCDBNode()
5256 {
5257 return _FAMILY;
5258 }
5259
5260 void setDISABLE_TIME(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
5261 {
5262
5263
5264 _setProp(dbGroup, _DISABLE_TIME, value, forceSending);
5265 }
5266
5267 uint32 getDISABLE_TIME(const CCDBSynchronised &dbGroup)
5268 {
5269 uint32 value;
5270 _getProp(dbGroup, _DISABLE_TIME, value);
5271
5272 return value;
5273 }
5274
5275 ICDBStructNode *getDISABLE_TIMECDBNode()
5276 {
5277 return _DISABLE_TIME;
5278 }
5279
5280 };
5281
5282
5283 private:
5284 ICDBStructNode *_BranchNode;
5285
5286 TArray _Array[12];
5287
5288
5289 public:
5290 void init(ICDBStructNode *parent);
5291
5292 // accessor to branch node
5293 ICDBStructNode *getCDBNode()
5294 {
5295 return _BranchNode;
5296 }
5297
5298 TArray &getArray(uint32 index)
5299 {
5300 nlassert(index < 12);
5301 return _Array[index];
5302 }
5303
5304 };
5305
5306 class TBOTCHAT
5307 {
5308 public:
5309
5310 class TDM_CHOICE
5311 {
5312 public:
5313
5314 class TArray
5315 {
5316 public:
5317
5318
5319 private:
5320 ICDBStructNode *_BranchNode;
5321
5322 ICDBStructNode *_TEXT;
5323
5324
5325 public:
5326 void init(ICDBStructNode *parent, uint index);
5327
5328 // accessor to branch node
5329 ICDBStructNode *getCDBNode()
5330 {
5331 return _BranchNode;
5332 }
5333
5334
5335 void setTEXT(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
5336 {
5337
5338
5339 _setProp(dbGroup, _TEXT, value, forceSending);
5340 }
5341
5342 uint32 getTEXT(const CCDBSynchronised &dbGroup)
5343 {
5344 uint32 value;
5345 _getProp(dbGroup, _TEXT, value);
5346
5347 return value;
5348 }
5349
5350 ICDBStructNode *getTEXTCDBNode()
5351 {
5352 return _TEXT;
5353 }
5354
5355 };
5356
5357
5358 private:
5359 ICDBStructNode *_BranchNode;
5360
5361 ICDBStructNode *_TITLE;
5362 TArray _Array[8];
5363
5364
5365 public:
5366 void init(ICDBStructNode *parent, uint index);
5367
5368 // accessor to branch node
5369 ICDBStructNode *getCDBNode()
5370 {
5371 return _BranchNode;
5372 }
5373
5374
5375 void setTITLE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
5376 {
5377
5378
5379 _setProp(dbGroup, _TITLE, value, forceSending);
5380 }
5381
5382 uint32 getTITLE(const CCDBSynchronised &dbGroup)
5383 {
5384 uint32 value;
5385 _getProp(dbGroup, _TITLE, value);
5386
5387 return value;
5388 }
5389
5390 ICDBStructNode *getTITLECDBNode()
5391 {
5392 return _TITLE;
5393 }
5394 TArray &getArray(uint32 index)
5395 {
5396 nlassert(index < 8);
5397 return _Array[index];
5398 }
5399
5400 };
5401
5402
5403 private:
5404 ICDBStructNode *_BranchNode;
5405
5406 ICDBStructNode *_PLAYER_GIFT;
5407 ICDBStructNode *_CREATE_GUILD;
5408 ICDBStructNode *_TRADE;
5409 ICDBStructNode *_CHOOSE_MISSION;
5410 ICDBStructNode *_DM_TITLE;
5411 ICDBStructNode *_DM_DESCRIPTION;
5412 ICDBStructNode *_ROLEMASTER_TYPE;
5413 TDM_CHOICE _DM_CHOICE[3];
5414
5415
5416 public:
5417 void init(ICDBStructNode *parent);
5418
5419 // accessor to branch node
5420 ICDBStructNode *getCDBNode()
5421 {
5422 return _BranchNode;
5423 }
5424
5425
5426 void setPLAYER_GIFT(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
5427 {
5428
5429
5430 _setProp(dbGroup, _PLAYER_GIFT, value, forceSending);
5431 }
5432
5433 uint32 getPLAYER_GIFT(const CCDBSynchronised &dbGroup)
5434 {
5435 uint32 value;
5436 _getProp(dbGroup, _PLAYER_GIFT, value);
5437
5438 return value;
5439 }
5440
5441 ICDBStructNode *getPLAYER_GIFTCDBNode()
5442 {
5443 return _PLAYER_GIFT;
5444 }
5445
5446 void setCREATE_GUILD(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
5447 {
5448
5449
5450 _setProp(dbGroup, _CREATE_GUILD, value, forceSending);
5451 }
5452
5453 uint32 getCREATE_GUILD(const CCDBSynchronised &dbGroup)
5454 {
5455 uint32 value;
5456 _getProp(dbGroup, _CREATE_GUILD, value);
5457
5458 return value;
5459 }
5460
5461 ICDBStructNode *getCREATE_GUILDCDBNode()
5462 {
5463 return _CREATE_GUILD;
5464 }
5465
5466 void setTRADE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
5467 {
5468
5469
5470 _setProp(dbGroup, _TRADE, value, forceSending);
5471 }
5472
5473 uint32 getTRADE(const CCDBSynchronised &dbGroup)
5474 {
5475 uint32 value;
5476 _getProp(dbGroup, _TRADE, value);
5477
5478 return value;
5479 }
5480
5481 ICDBStructNode *getTRADECDBNode()
5482 {
5483 return _TRADE;
5484 }
5485
5486 void setCHOOSE_MISSION(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
5487 {
5488
5489
5490 _setProp(dbGroup, _CHOOSE_MISSION, value, forceSending);
5491 }
5492
5493 uint32 getCHOOSE_MISSION(const CCDBSynchronised &dbGroup)
5494 {
5495 uint32 value;
5496 _getProp(dbGroup, _CHOOSE_MISSION, value);
5497
5498 return value;
5499 }
5500
5501 ICDBStructNode *getCHOOSE_MISSIONCDBNode()
5502 {
5503 return _CHOOSE_MISSION;
5504 }
5505
5506 void setDM_TITLE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
5507 {
5508
5509
5510 _setProp(dbGroup, _DM_TITLE, value, forceSending);
5511 }
5512
5513 uint32 getDM_TITLE(const CCDBSynchronised &dbGroup)
5514 {
5515 uint32 value;
5516 _getProp(dbGroup, _DM_TITLE, value);
5517
5518 return value;
5519 }
5520
5521 ICDBStructNode *getDM_TITLECDBNode()
5522 {
5523 return _DM_TITLE;
5524 }
5525
5526 void setDM_DESCRIPTION(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
5527 {
5528
5529
5530 _setProp(dbGroup, _DM_DESCRIPTION, value, forceSending);
5531 }
5532
5533 uint32 getDM_DESCRIPTION(const CCDBSynchronised &dbGroup)
5534 {
5535 uint32 value;
5536 _getProp(dbGroup, _DM_DESCRIPTION, value);
5537
5538 return value;
5539 }
5540
5541 ICDBStructNode *getDM_DESCRIPTIONCDBNode()
5542 {
5543 return _DM_DESCRIPTION;
5544 }
5545
5546 void setROLEMASTER_TYPE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
5547 {
5548
5549 // Check that the value is not out of database precision
5550 STOP_IF(value > (1<<2)-1, "setROLEMASTER_TYPE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 2 bits");
5551
5552
5553 _setProp(dbGroup, _ROLEMASTER_TYPE, value, forceSending);
5554 }
5555
5556 uint8 getROLEMASTER_TYPE(const CCDBSynchronised &dbGroup)
5557 {
5558 uint8 value;
5559 _getProp(dbGroup, _ROLEMASTER_TYPE, value);
5560
5561 return value;
5562 }
5563
5564 ICDBStructNode *getROLEMASTER_TYPECDBNode()
5565 {
5566 return _ROLEMASTER_TYPE;
5567 }
5568 TDM_CHOICE &getDM_CHOICE(uint32 index)
5569 {
5570 nlassert(index < 3);
5571 return _DM_CHOICE[index];
5572 }
5573
5574 };
5575
5576 class TASCENSOR
5577 {
5578 public:
5579
5580 class TArray
5581 {
5582 public:
5583
5584
5585 private:
5586 ICDBStructNode *_BranchNode;
5587
5588 ICDBStructNode *_ICON;
5589 ICDBStructNode *_NAME;
5590
5591
5592 public:
5593 void init(ICDBStructNode *parent, uint index);
5594
5595 // accessor to branch node
5596 ICDBStructNode *getCDBNode()
5597 {
5598 return _BranchNode;
5599 }
5600
5601
5602 void setICON(CCDBSynchronised &dbGroup, uint64 value, bool forceSending = false)
5603 {
5604
5605
5606 _setProp(dbGroup, _ICON, value, forceSending);
5607 }
5608
5609 uint64 getICON(const CCDBSynchronised &dbGroup)
5610 {
5611 uint64 value;
5612 _getProp(dbGroup, _ICON, value);
5613
5614 return value;
5615 }
5616
5617 ICDBStructNode *getICONCDBNode()
5618 {
5619 return _ICON;
5620 }
5621
5622 void setNAME(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
5623 {
5624
5625
5626 _setProp(dbGroup, _NAME, value, forceSending);
5627 }
5628
5629 uint32 getNAME(const CCDBSynchronised &dbGroup)
5630 {
5631 uint32 value;
5632 _getProp(dbGroup, _NAME, value);
5633
5634 return value;
5635 }
5636
5637 ICDBStructNode *getNAMECDBNode()
5638 {
5639 return _NAME;
5640 }
5641
5642 };
5643
5644
5645 private:
5646 ICDBStructNode *_BranchNode;
5647
5648 ICDBStructNode *_SESSION;
5649 ICDBStructNode *_PAGE_ID;
5650 ICDBStructNode *_HAS_NEXT;
5651 TArray _Array[8];
5652
5653
5654 public:
5655 void init(ICDBStructNode *parent);
5656
5657 // accessor to branch node
5658 ICDBStructNode *getCDBNode()
5659 {
5660 return _BranchNode;
5661 }
5662
5663
5664 void setSESSION(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
5665 {
5666
5667
5668 _setProp(dbGroup, _SESSION, value, forceSending);
5669 }
5670
5671 uint16 getSESSION(const CCDBSynchronised &dbGroup)
5672 {
5673 uint16 value;
5674 _getProp(dbGroup, _SESSION, value);
5675
5676 return value;
5677 }
5678
5679 ICDBStructNode *getSESSIONCDBNode()
5680 {
5681 return _SESSION;
5682 }
5683
5684 void setPAGE_ID(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
5685 {
5686
5687 // Check that the value is not out of database precision
5688 STOP_IF(value > (1<<6)-1, "setPAGE_ID : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 6 bits");
5689
5690
5691 _setProp(dbGroup, _PAGE_ID, value, forceSending);
5692 }
5693
5694 uint8 getPAGE_ID(const CCDBSynchronised &dbGroup)
5695 {
5696 uint8 value;
5697 _getProp(dbGroup, _PAGE_ID, value);
5698
5699 return value;
5700 }
5701
5702 ICDBStructNode *getPAGE_IDCDBNode()
5703 {
5704 return _PAGE_ID;
5705 }
5706
5707 void setHAS_NEXT(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
5708 {
5709
5710
5711 _setProp(dbGroup, _HAS_NEXT, value, forceSending);
5712 }
5713
5714 bool getHAS_NEXT(const CCDBSynchronised &dbGroup)
5715 {
5716 bool value;
5717 _getProp(dbGroup, _HAS_NEXT, value);
5718
5719 return value;
5720 }
5721
5722 ICDBStructNode *getHAS_NEXTCDBNode()
5723 {
5724 return _HAS_NEXT;
5725 }
5726 TArray &getArray(uint32 index)
5727 {
5728 nlassert(index < 8);
5729 return _Array[index];
5730 }
5731
5732 };
5733
5734 class TCHOOSE_MISSIONS
5735 {
5736 public:
5737
5738 class TArray
5739 {
5740 public:
5741
5742
5743 private:
5744 ICDBStructNode *_BranchNode;
5745
5746 ICDBStructNode *_ICON;
5747 ICDBStructNode *_TEXT;
5748 ICDBStructNode *_DETAIL_TEXT;
5749 ICDBStructNode *_PREREQ_STATE;
5750
5751
5752 public:
5753 void init(ICDBStructNode *parent, uint index);
5754
5755 // accessor to branch node
5756 ICDBStructNode *getCDBNode()
5757 {
5758 return _BranchNode;
5759 }
5760
5761
5762 void setICON(CCDBSynchronised &dbGroup, NLMISC::CSheetId value, bool forceSending = false)
5763 {
5764
5765
5766 _setProp(dbGroup, _ICON, value, forceSending);
5767 }
5768
5769 NLMISC::CSheetId getICON(const CCDBSynchronised &dbGroup)
5770 {
5771 NLMISC::CSheetId value;
5772 _getProp(dbGroup, _ICON, value);
5773
5774 return value;
5775 }
5776
5777 ICDBStructNode *getICONCDBNode()
5778 {
5779 return _ICON;
5780 }
5781
5782 void setTEXT(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
5783 {
5784
5785
5786 _setProp(dbGroup, _TEXT, value, forceSending);
5787 }
5788
5789 uint32 getTEXT(const CCDBSynchronised &dbGroup)
5790 {
5791 uint32 value;
5792 _getProp(dbGroup, _TEXT, value);
5793
5794 return value;
5795 }
5796
5797 ICDBStructNode *getTEXTCDBNode()
5798 {
5799 return _TEXT;
5800 }
5801
5802 void setDETAIL_TEXT(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
5803 {
5804
5805
5806 _setProp(dbGroup, _DETAIL_TEXT, value, forceSending);
5807 }
5808
5809 uint32 getDETAIL_TEXT(const CCDBSynchronised &dbGroup)
5810 {
5811 uint32 value;
5812 _getProp(dbGroup, _DETAIL_TEXT, value);
5813
5814 return value;
5815 }
5816
5817 ICDBStructNode *getDETAIL_TEXTCDBNode()
5818 {
5819 return _DETAIL_TEXT;
5820 }
5821
5822 void setPREREQ_STATE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
5823 {
5824
5825
5826 _setProp(dbGroup, _PREREQ_STATE, value, forceSending);
5827 }
5828
5829 uint8 getPREREQ_STATE(const CCDBSynchronised &dbGroup)
5830 {
5831 uint8 value;
5832 _getProp(dbGroup, _PREREQ_STATE, value);
5833
5834 return value;
5835 }
5836
5837 ICDBStructNode *getPREREQ_STATECDBNode()
5838 {
5839 return _PREREQ_STATE;
5840 }
5841
5842 };
5843
5844
5845 private:
5846 ICDBStructNode *_BranchNode;
5847
5848 ICDBStructNode *_SESSION;
5849 ICDBStructNode *_PAGE_ID;
5850 ICDBStructNode *_HAS_NEXT;
5851 TArray _Array[8];
5852
5853
5854 public:
5855 void init(ICDBStructNode *parent);
5856
5857 // accessor to branch node
5858 ICDBStructNode *getCDBNode()
5859 {
5860 return _BranchNode;
5861 }
5862
5863
5864 void setSESSION(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
5865 {
5866
5867
5868 _setProp(dbGroup, _SESSION, value, forceSending);
5869 }
5870
5871 uint16 getSESSION(const CCDBSynchronised &dbGroup)
5872 {
5873 uint16 value;
5874 _getProp(dbGroup, _SESSION, value);
5875
5876 return value;
5877 }
5878
5879 ICDBStructNode *getSESSIONCDBNode()
5880 {
5881 return _SESSION;
5882 }
5883
5884 void setPAGE_ID(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
5885 {
5886
5887 // Check that the value is not out of database precision
5888 STOP_IF(value > (1<<6)-1, "setPAGE_ID : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 6 bits");
5889
5890
5891 _setProp(dbGroup, _PAGE_ID, value, forceSending);
5892 }
5893
5894 uint8 getPAGE_ID(const CCDBSynchronised &dbGroup)
5895 {
5896 uint8 value;
5897 _getProp(dbGroup, _PAGE_ID, value);
5898
5899 return value;
5900 }
5901
5902 ICDBStructNode *getPAGE_IDCDBNode()
5903 {
5904 return _PAGE_ID;
5905 }
5906
5907 void setHAS_NEXT(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
5908 {
5909
5910
5911 _setProp(dbGroup, _HAS_NEXT, value, forceSending);
5912 }
5913
5914 bool getHAS_NEXT(const CCDBSynchronised &dbGroup)
5915 {
5916 bool value;
5917 _getProp(dbGroup, _HAS_NEXT, value);
5918
5919 return value;
5920 }
5921
5922 ICDBStructNode *getHAS_NEXTCDBNode()
5923 {
5924 return _HAS_NEXT;
5925 }
5926 TArray &getArray(uint32 index)
5927 {
5928 nlassert(index < 8);
5929 return _Array[index];
5930 }
5931
5932 };
5933
5934 class TTRADING
5935 {
5936 public:
5937
5938 class TArray
5939 {
5940 public:
5941
5942
5943 private:
5944 ICDBStructNode *_BranchNode;
5945
5946 ICDBStructNode *_SHEET;
5947 ICDBStructNode *_QUALITY;
5948 ICDBStructNode *_QUANTITY;
5949 ICDBStructNode *_CREATE_TIME;
5950 ICDBStructNode *_SERIAL;
5951 ICDBStructNode *_USER_COLOR;
5952 ICDBStructNode *_WEIGHT;
5953 ICDBStructNode *_NAMEID;
5954 ICDBStructNode *_INFO_VERSION;
5955 ICDBStructNode *_ENCHANT;
5956 ICDBStructNode *_RM_CLASS_TYPE;
5957 ICDBStructNode *_RM_FABER_STAT_TYPE;
5958 ICDBStructNode *_PREREQUISIT_VALID;
5959 ICDBStructNode *_CURRENCY;
5960 ICDBStructNode *_RRP_LEVEL;
5961 ICDBStructNode *_MONEY_SHEET;
5962 ICDBStructNode *_BASE_SKILL;
5963 ICDBStructNode *_FACTION_TYPE;
5964 ICDBStructNode *_PRICE;
5965 ICDBStructNode *_PRICE_RETIRE;
5966 ICDBStructNode *_RESALE_TIME_LEFT;
5967 ICDBStructNode *_VENDOR_NAMEID;
5968 ICDBStructNode *_FACTION_POINT_PRICE;
5969 ICDBStructNode *_SLOT_TYPE;
5970 ICDBStructNode *_SELLER_TYPE;
5971
5972
5973 public:
5974 void init(ICDBStructNode *parent, uint index);
5975
5976 // accessor to branch node
5977 ICDBStructNode *getCDBNode()
5978 {
5979 return _BranchNode;
5980 }
5981
5982
5983 void setSHEET(CCDBSynchronised &dbGroup, NLMISC::CSheetId value, bool forceSending = false)
5984 {
5985
5986
5987 _setProp(dbGroup, _SHEET, value, forceSending);
5988 }
5989
5990 NLMISC::CSheetId getSHEET(const CCDBSynchronised &dbGroup)
5991 {
5992 NLMISC::CSheetId value;
5993 _getProp(dbGroup, _SHEET, value);
5994
5995 return value;
5996 }
5997
5998 ICDBStructNode *getSHEETCDBNode()
5999 {
6000 return _SHEET;
6001 }
6002
6003 void setQUALITY(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
6004 {
6005
6006 // Check that the value is not out of database precision
6007 STOP_IF(value > (1<<10)-1, "setQUALITY : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 10 bits");
6008
6009
6010 _setProp(dbGroup, _QUALITY, value, forceSending);
6011 }
6012
6013 uint16 getQUALITY(const CCDBSynchronised &dbGroup)
6014 {
6015 uint16 value;
6016 _getProp(dbGroup, _QUALITY, value);
6017
6018 return value;
6019 }
6020
6021 ICDBStructNode *getQUALITYCDBNode()
6022 {
6023 return _QUALITY;
6024 }
6025
6026 void setQUANTITY(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
6027 {
6028
6029 // Check that the value is not out of database precision
6030 STOP_IF(value > (1<<10)-1, "setQUANTITY : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 10 bits");
6031
6032
6033 _setProp(dbGroup, _QUANTITY, value, forceSending);
6034 }
6035
6036 uint16 getQUANTITY(const CCDBSynchronised &dbGroup)
6037 {
6038 uint16 value;
6039 _getProp(dbGroup, _QUANTITY, value);
6040
6041 return value;
6042 }
6043
6044 ICDBStructNode *getQUANTITYCDBNode()
6045 {
6046 return _QUANTITY;
6047 }
6048
6049 void setCREATE_TIME(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
6050 {
6051
6052
6053 _setProp(dbGroup, _CREATE_TIME, value, forceSending);
6054 }
6055
6056 uint32 getCREATE_TIME(const CCDBSynchronised &dbGroup)
6057 {
6058 uint32 value;
6059 _getProp(dbGroup, _CREATE_TIME, value);
6060
6061 return value;
6062 }
6063
6064 ICDBStructNode *getCREATE_TIMECDBNode()
6065 {
6066 return _CREATE_TIME;
6067 }
6068
6069 void setSERIAL(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
6070 {
6071
6072
6073 _setProp(dbGroup, _SERIAL, value, forceSending);
6074 }
6075
6076 uint32 getSERIAL(const CCDBSynchronised &dbGroup)
6077 {
6078 uint32 value;
6079 _getProp(dbGroup, _SERIAL, value);
6080
6081 return value;
6082 }
6083
6084 ICDBStructNode *getSERIALCDBNode()
6085 {
6086 return _SERIAL;
6087 }
6088
6089 void setUSER_COLOR(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
6090 {
6091
6092 // Check that the value is not out of database precision
6093 STOP_IF(value > (1<<3)-1, "setUSER_COLOR : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 3 bits");
6094
6095
6096 _setProp(dbGroup, _USER_COLOR, value, forceSending);
6097 }
6098
6099 uint8 getUSER_COLOR(const CCDBSynchronised &dbGroup)
6100 {
6101 uint8 value;
6102 _getProp(dbGroup, _USER_COLOR, value);
6103
6104 return value;
6105 }
6106
6107 ICDBStructNode *getUSER_COLORCDBNode()
6108 {
6109 return _USER_COLOR;
6110 }
6111
6112 void setWEIGHT(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
6113 {
6114
6115
6116 _setProp(dbGroup, _WEIGHT, value, forceSending);
6117 }
6118
6119 uint16 getWEIGHT(const CCDBSynchronised &dbGroup)
6120 {
6121 uint16 value;
6122 _getProp(dbGroup, _WEIGHT, value);
6123
6124 return value;
6125 }
6126
6127 ICDBStructNode *getWEIGHTCDBNode()
6128 {
6129 return _WEIGHT;
6130 }
6131
6132 void setNAMEID(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
6133 {
6134
6135
6136 _setProp(dbGroup, _NAMEID, value, forceSending);
6137 }
6138
6139 uint32 getNAMEID(const CCDBSynchronised &dbGroup)
6140 {
6141 uint32 value;
6142 _getProp(dbGroup, _NAMEID, value);
6143
6144 return value;
6145 }
6146
6147 ICDBStructNode *getNAMEIDCDBNode()
6148 {
6149 return _NAMEID;
6150 }
6151
6152 void setINFO_VERSION(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
6153 {
6154
6155
6156 _setProp(dbGroup, _INFO_VERSION, value, forceSending);
6157 }
6158
6159 uint8 getINFO_VERSION(const CCDBSynchronised &dbGroup)
6160 {
6161 uint8 value;
6162 _getProp(dbGroup, _INFO_VERSION, value);
6163
6164 return value;
6165 }
6166
6167 ICDBStructNode *getINFO_VERSIONCDBNode()
6168 {
6169 return _INFO_VERSION;
6170 }
6171
6172 void setENCHANT(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
6173 {
6174
6175 // Check that the value is not out of database precision
6176 STOP_IF(value > (1<<10)-1, "setENCHANT : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 10 bits");
6177
6178
6179 _setProp(dbGroup, _ENCHANT, value, forceSending);
6180 }
6181
6182 uint16 getENCHANT(const CCDBSynchronised &dbGroup)
6183 {
6184 uint16 value;
6185 _getProp(dbGroup, _ENCHANT, value);
6186
6187 return value;
6188 }
6189
6190 ICDBStructNode *getENCHANTCDBNode()
6191 {
6192 return _ENCHANT;
6193 }
6194
6195 void setRM_CLASS_TYPE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
6196 {
6197
6198 // Check that the value is not out of database precision
6199 STOP_IF(value > (1<<3)-1, "setRM_CLASS_TYPE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 3 bits");
6200
6201
6202 _setProp(dbGroup, _RM_CLASS_TYPE, value, forceSending);
6203 }
6204
6205 uint8 getRM_CLASS_TYPE(const CCDBSynchronised &dbGroup)
6206 {
6207 uint8 value;
6208 _getProp(dbGroup, _RM_CLASS_TYPE, value);
6209
6210 return value;
6211 }
6212
6213 ICDBStructNode *getRM_CLASS_TYPECDBNode()
6214 {
6215 return _RM_CLASS_TYPE;
6216 }
6217
6218 void setRM_FABER_STAT_TYPE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
6219 {
6220
6221 // Check that the value is not out of database precision
6222 STOP_IF(value > (1<<6)-1, "setRM_FABER_STAT_TYPE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 6 bits");
6223
6224
6225 _setProp(dbGroup, _RM_FABER_STAT_TYPE, value, forceSending);
6226 }
6227
6228 uint8 getRM_FABER_STAT_TYPE(const CCDBSynchronised &dbGroup)
6229 {
6230 uint8 value;
6231 _getProp(dbGroup, _RM_FABER_STAT_TYPE, value);
6232
6233 return value;
6234 }
6235
6236 ICDBStructNode *getRM_FABER_STAT_TYPECDBNode()
6237 {
6238 return _RM_FABER_STAT_TYPE;
6239 }
6240
6241 void setPREREQUISIT_VALID(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
6242 {
6243
6244
6245 _setProp(dbGroup, _PREREQUISIT_VALID, value, forceSending);
6246 }
6247
6248 bool getPREREQUISIT_VALID(const CCDBSynchronised &dbGroup)
6249 {
6250 bool value;
6251 _getProp(dbGroup, _PREREQUISIT_VALID, value);
6252
6253 return value;
6254 }
6255
6256 ICDBStructNode *getPREREQUISIT_VALIDCDBNode()
6257 {
6258 return _PREREQUISIT_VALID;
6259 }
6260
6261 void setCURRENCY(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
6262 {
6263
6264 // Check that the value is not out of database precision
6265 STOP_IF(value > (1<<4)-1, "setCURRENCY : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 4 bits");
6266
6267
6268 _setProp(dbGroup, _CURRENCY, value, forceSending);
6269 }
6270
6271 uint8 getCURRENCY(const CCDBSynchronised &dbGroup)
6272 {
6273 uint8 value;
6274 _getProp(dbGroup, _CURRENCY, value);
6275
6276 return value;
6277 }
6278
6279 ICDBStructNode *getCURRENCYCDBNode()
6280 {
6281 return _CURRENCY;
6282 }
6283
6284 void setRRP_LEVEL(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
6285 {
6286
6287 // Check that the value is not out of database precision
6288 STOP_IF(value > (1<<4)-1, "setRRP_LEVEL : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 4 bits");
6289
6290
6291 _setProp(dbGroup, _RRP_LEVEL, value, forceSending);
6292 }
6293
6294 uint8 getRRP_LEVEL(const CCDBSynchronised &dbGroup)
6295 {
6296 uint8 value;
6297 _getProp(dbGroup, _RRP_LEVEL, value);
6298
6299 return value;
6300 }
6301
6302 ICDBStructNode *getRRP_LEVELCDBNode()
6303 {
6304 return _RRP_LEVEL;
6305 }
6306
6307 void setMONEY_SHEET(CCDBSynchronised &dbGroup, NLMISC::CSheetId value, bool forceSending = false)
6308 {
6309
6310
6311 _setProp(dbGroup, _MONEY_SHEET, value, forceSending);
6312 }
6313
6314 NLMISC::CSheetId getMONEY_SHEET(const CCDBSynchronised &dbGroup)
6315 {
6316 NLMISC::CSheetId value;
6317 _getProp(dbGroup, _MONEY_SHEET, value);
6318
6319 return value;
6320 }
6321
6322 ICDBStructNode *getMONEY_SHEETCDBNode()
6323 {
6324 return _MONEY_SHEET;
6325 }
6326
6327 void setBASE_SKILL(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
6328 {
6329
6330 // Check that the value is not out of database precision
6331 STOP_IF(value > (1<<4)-1, "setBASE_SKILL : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 4 bits");
6332
6333
6334 _setProp(dbGroup, _BASE_SKILL, value, forceSending);
6335 }
6336
6337 uint8 getBASE_SKILL(const CCDBSynchronised &dbGroup)
6338 {
6339 uint8 value;
6340 _getProp(dbGroup, _BASE_SKILL, value);
6341
6342 return value;
6343 }
6344
6345 ICDBStructNode *getBASE_SKILLCDBNode()
6346 {
6347 return _BASE_SKILL;
6348 }
6349
6350 void setFACTION_TYPE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
6351 {
6352
6353 // Check that the value is not out of database precision
6354 STOP_IF(value > (1<<4)-1, "setFACTION_TYPE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 4 bits");
6355
6356
6357 _setProp(dbGroup, _FACTION_TYPE, value, forceSending);
6358 }
6359
6360 uint8 getFACTION_TYPE(const CCDBSynchronised &dbGroup)
6361 {
6362 uint8 value;
6363 _getProp(dbGroup, _FACTION_TYPE, value);
6364
6365 return value;
6366 }
6367
6368 ICDBStructNode *getFACTION_TYPECDBNode()
6369 {
6370 return _FACTION_TYPE;
6371 }
6372
6373 void setPRICE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
6374 {
6375
6376
6377 _setProp(dbGroup, _PRICE, value, forceSending);
6378 }
6379
6380 uint32 getPRICE(const CCDBSynchronised &dbGroup)
6381 {
6382 uint32 value;
6383 _getProp(dbGroup, _PRICE, value);
6384
6385 return value;
6386 }
6387
6388 ICDBStructNode *getPRICECDBNode()
6389 {
6390 return _PRICE;
6391 }
6392
6393 void setPRICE_RETIRE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
6394 {
6395
6396
6397 _setProp(dbGroup, _PRICE_RETIRE, value, forceSending);
6398 }
6399
6400 uint32 getPRICE_RETIRE(const CCDBSynchronised &dbGroup)
6401 {
6402 uint32 value;
6403 _getProp(dbGroup, _PRICE_RETIRE, value);
6404
6405 return value;
6406 }
6407
6408 ICDBStructNode *getPRICE_RETIRECDBNode()
6409 {
6410 return _PRICE_RETIRE;
6411 }
6412
6413 void setRESALE_TIME_LEFT(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
6414 {
6415
6416
6417 _setProp(dbGroup, _RESALE_TIME_LEFT, value, forceSending);
6418 }
6419
6420 uint16 getRESALE_TIME_LEFT(const CCDBSynchronised &dbGroup)
6421 {
6422 uint16 value;
6423 _getProp(dbGroup, _RESALE_TIME_LEFT, value);
6424
6425 return value;
6426 }
6427
6428 ICDBStructNode *getRESALE_TIME_LEFTCDBNode()
6429 {
6430 return _RESALE_TIME_LEFT;
6431 }
6432
6433 void setVENDOR_NAMEID(CCDBSynchronised &dbGroup, ucstring value, bool forceSending = false)
6434 {
6435
6436
6437 _setProp(dbGroup, _VENDOR_NAMEID, value, forceSending);
6438 }
6439
6440 ucstring getVENDOR_NAMEID(const CCDBSynchronised &dbGroup)
6441 {
6442 ucstring value;
6443 _getProp(dbGroup, _VENDOR_NAMEID, value);
6444
6445 return value;
6446 }
6447
6448 void setVENDOR_NAMEID(CCDBSynchronised &dbGroup, uint32 stringId, bool forceSending = false)
6449 {
6450 _setProp(dbGroup, _VENDOR_NAMEID, stringId, forceSending);
6451 }
6452 uint32 getVENDOR_NAMEID_id(const CCDBSynchronised &dbGroup)
6453 {
6454 uint32 value;
6455 _getProp(dbGroup, _VENDOR_NAMEID, value);
6456
6457 return value;
6458 }
6459
6460 ICDBStructNode *getVENDOR_NAMEIDCDBNode()
6461 {
6462 return _VENDOR_NAMEID;
6463 }
6464
6465 void setFACTION_POINT_PRICE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
6466 {
6467
6468
6469 _setProp(dbGroup, _FACTION_POINT_PRICE, value, forceSending);
6470 }
6471
6472 uint32 getFACTION_POINT_PRICE(const CCDBSynchronised &dbGroup)
6473 {
6474 uint32 value;
6475 _getProp(dbGroup, _FACTION_POINT_PRICE, value);
6476
6477 return value;
6478 }
6479
6480 ICDBStructNode *getFACTION_POINT_PRICECDBNode()
6481 {
6482 return _FACTION_POINT_PRICE;
6483 }
6484
6485 void setSLOT_TYPE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
6486 {
6487
6488 // Check that the value is not out of database precision
6489 STOP_IF(value > (1<<2)-1, "setSLOT_TYPE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 2 bits");
6490
6491
6492 _setProp(dbGroup, _SLOT_TYPE, value, forceSending);
6493 }
6494
6495 uint8 getSLOT_TYPE(const CCDBSynchronised &dbGroup)
6496 {
6497 uint8 value;
6498 _getProp(dbGroup, _SLOT_TYPE, value);
6499
6500 return value;
6501 }
6502
6503 ICDBStructNode *getSLOT_TYPECDBNode()
6504 {
6505 return _SLOT_TYPE;
6506 }
6507
6508 void setSELLER_TYPE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
6509 {
6510
6511 // Check that the value is not out of database precision
6512 STOP_IF(value > (1<<3)-1, "setSELLER_TYPE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 3 bits");
6513
6514
6515 _setProp(dbGroup, _SELLER_TYPE, value, forceSending);
6516 }
6517
6518 uint8 getSELLER_TYPE(const CCDBSynchronised &dbGroup)
6519 {
6520 uint8 value;
6521 _getProp(dbGroup, _SELLER_TYPE, value);
6522
6523 return value;
6524 }
6525
6526 ICDBStructNode *getSELLER_TYPECDBNode()
6527 {
6528 return _SELLER_TYPE;
6529 }
6530
6531 };
6532
6533
6534 private:
6535 ICDBStructNode *_BranchNode;
6536
6537 ICDBStructNode *_SESSION;
6538 ICDBStructNode *_PAGE_ID;
6539 ICDBStructNode *_HAS_NEXT;
6540 ICDBStructNode *_ROLEMASTER_FLAGS;
6541 ICDBStructNode *_ROLEMASTER_RACE;
6542 ICDBStructNode *_BUILDING_LOSS_WARNING;
6543 ICDBStructNode *_RAW_MATERIAL_SELLER;
6544 ICDBStructNode *_ITEM_TYPE_SELLER_BITFILED_0_63;
6545 ICDBStructNode *_ITEM_TYPE_SELLER_BITFILED_64_127;
6546 ICDBStructNode *_FAME_PRICE_FACTOR;
6547 TArray _Array[8];
6548
6549
6550 public:
6551 void init(ICDBStructNode *parent);
6552
6553 // accessor to branch node
6554 ICDBStructNode *getCDBNode()
6555 {
6556 return _BranchNode;
6557 }
6558
6559
6560 void setSESSION(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
6561 {
6562
6563
6564 _setProp(dbGroup, _SESSION, value, forceSending);
6565 }
6566
6567 uint16 getSESSION(const CCDBSynchronised &dbGroup)
6568 {
6569 uint16 value;
6570 _getProp(dbGroup, _SESSION, value);
6571
6572 return value;
6573 }
6574
6575 ICDBStructNode *getSESSIONCDBNode()
6576 {
6577 return _SESSION;
6578 }
6579
6580 void setPAGE_ID(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
6581 {
6582
6583 // Check that the value is not out of database precision
6584 STOP_IF(value > (1<<7)-1, "setPAGE_ID : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 7 bits");
6585
6586
6587 _setProp(dbGroup, _PAGE_ID, value, forceSending);
6588 }
6589
6590 uint8 getPAGE_ID(const CCDBSynchronised &dbGroup)
6591 {
6592 uint8 value;
6593 _getProp(dbGroup, _PAGE_ID, value);
6594
6595 return value;
6596 }
6597
6598 ICDBStructNode *getPAGE_IDCDBNode()
6599 {
6600 return _PAGE_ID;
6601 }
6602
6603 void setHAS_NEXT(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
6604 {
6605
6606
6607 _setProp(dbGroup, _HAS_NEXT, value, forceSending);
6608 }
6609
6610 bool getHAS_NEXT(const CCDBSynchronised &dbGroup)
6611 {
6612 bool value;
6613 _getProp(dbGroup, _HAS_NEXT, value);
6614
6615 return value;
6616 }
6617
6618 ICDBStructNode *getHAS_NEXTCDBNode()
6619 {
6620 return _HAS_NEXT;
6621 }
6622
6623 void setROLEMASTER_FLAGS(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
6624 {
6625
6626 // Check that the value is not out of database precision
6627 STOP_IF(value > (1<<6)-1, "setROLEMASTER_FLAGS : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 6 bits");
6628
6629
6630 _setProp(dbGroup, _ROLEMASTER_FLAGS, value, forceSending);
6631 }
6632
6633 uint8 getROLEMASTER_FLAGS(const CCDBSynchronised &dbGroup)
6634 {
6635 uint8 value;
6636 _getProp(dbGroup, _ROLEMASTER_FLAGS, value);
6637
6638 return value;
6639 }
6640
6641 ICDBStructNode *getROLEMASTER_FLAGSCDBNode()
6642 {
6643 return _ROLEMASTER_FLAGS;
6644 }
6645
6646 void setROLEMASTER_RACE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
6647 {
6648
6649 // Check that the value is not out of database precision
6650 STOP_IF(value > (1<<2)-1, "setROLEMASTER_RACE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 2 bits");
6651
6652
6653 _setProp(dbGroup, _ROLEMASTER_RACE, value, forceSending);
6654 }
6655
6656 uint8 getROLEMASTER_RACE(const CCDBSynchronised &dbGroup)
6657 {
6658 uint8 value;
6659 _getProp(dbGroup, _ROLEMASTER_RACE, value);
6660
6661 return value;
6662 }
6663
6664 ICDBStructNode *getROLEMASTER_RACECDBNode()
6665 {
6666 return _ROLEMASTER_RACE;
6667 }
6668
6669 void setBUILDING_LOSS_WARNING(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
6670 {
6671
6672
6673 _setProp(dbGroup, _BUILDING_LOSS_WARNING, value, forceSending);
6674 }
6675
6676 bool getBUILDING_LOSS_WARNING(const CCDBSynchronised &dbGroup)
6677 {
6678 bool value;
6679 _getProp(dbGroup, _BUILDING_LOSS_WARNING, value);
6680
6681 return value;
6682 }
6683
6684 ICDBStructNode *getBUILDING_LOSS_WARNINGCDBNode()
6685 {
6686 return _BUILDING_LOSS_WARNING;
6687 }
6688
6689 void setRAW_MATERIAL_SELLER(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
6690 {
6691
6692
6693 _setProp(dbGroup, _RAW_MATERIAL_SELLER, value, forceSending);
6694 }
6695
6696 bool getRAW_MATERIAL_SELLER(const CCDBSynchronised &dbGroup)
6697 {
6698 bool value;
6699 _getProp(dbGroup, _RAW_MATERIAL_SELLER, value);
6700
6701 return value;
6702 }
6703
6704 ICDBStructNode *getRAW_MATERIAL_SELLERCDBNode()
6705 {
6706 return _RAW_MATERIAL_SELLER;
6707 }
6708
6709 void setITEM_TYPE_SELLER_BITFILED_0_63(CCDBSynchronised &dbGroup, uint64 value, bool forceSending = false)
6710 {
6711
6712
6713 _setProp(dbGroup, _ITEM_TYPE_SELLER_BITFILED_0_63, value, forceSending);
6714 }
6715
6716 uint64 getITEM_TYPE_SELLER_BITFILED_0_63(const CCDBSynchronised &dbGroup)
6717 {
6718 uint64 value;
6719 _getProp(dbGroup, _ITEM_TYPE_SELLER_BITFILED_0_63, value);
6720
6721 return value;
6722 }
6723
6724 ICDBStructNode *getITEM_TYPE_SELLER_BITFILED_0_63CDBNode()
6725 {
6726 return _ITEM_TYPE_SELLER_BITFILED_0_63;
6727 }
6728
6729 void setITEM_TYPE_SELLER_BITFILED_64_127(CCDBSynchronised &dbGroup, uint64 value, bool forceSending = false)
6730 {
6731
6732
6733 _setProp(dbGroup, _ITEM_TYPE_SELLER_BITFILED_64_127, value, forceSending);
6734 }
6735
6736 uint64 getITEM_TYPE_SELLER_BITFILED_64_127(const CCDBSynchronised &dbGroup)
6737 {
6738 uint64 value;
6739 _getProp(dbGroup, _ITEM_TYPE_SELLER_BITFILED_64_127, value);
6740
6741 return value;
6742 }
6743
6744 ICDBStructNode *getITEM_TYPE_SELLER_BITFILED_64_127CDBNode()
6745 {
6746 return _ITEM_TYPE_SELLER_BITFILED_64_127;
6747 }
6748
6749 void setFAME_PRICE_FACTOR(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
6750 {
6751
6752
6753 _setProp(dbGroup, _FAME_PRICE_FACTOR, value, forceSending);
6754 }
6755
6756 uint16 getFAME_PRICE_FACTOR(const CCDBSynchronised &dbGroup)
6757 {
6758 uint16 value;
6759 _getProp(dbGroup, _FAME_PRICE_FACTOR, value);
6760
6761 return value;
6762 }
6763
6764 ICDBStructNode *getFAME_PRICE_FACTORCDBNode()
6765 {
6766 return _FAME_PRICE_FACTOR;
6767 }
6768 TArray &getArray(uint32 index)
6769 {
6770 nlassert(index < 8);
6771 return _Array[index];
6772 }
6773
6774 };
6775
6776 class TBRICK_FAMILY
6777 {
6778 public:
6779
6780 class TArray
6781 {
6782 public:
6783
6784
6785 private:
6786 ICDBStructNode *_BranchNode;
6787
6788 ICDBStructNode *_BRICKS;
6789
6790
6791 public:
6792 void init(ICDBStructNode *parent, uint index);
6793
6794 // accessor to branch node
6795 ICDBStructNode *getCDBNode()
6796 {
6797 return _BranchNode;
6798 }
6799
6800
6801 void setBRICKS(CCDBSynchronised &dbGroup, uint64 value, bool forceSending = false)
6802 {
6803
6804
6805 _setProp(dbGroup, _BRICKS, value, forceSending);
6806 }
6807
6808 uint64 getBRICKS(const CCDBSynchronised &dbGroup)
6809 {
6810 uint64 value;
6811 _getProp(dbGroup, _BRICKS, value);
6812
6813 return value;
6814 }
6815
6816 ICDBStructNode *getBRICKSCDBNode()
6817 {
6818 return _BRICKS;
6819 }
6820
6821 };
6822
6823
6824 private:
6825 ICDBStructNode *_BranchNode;
6826
6827 TArray _Array[1024];
6828
6829
6830 public:
6831 void init(ICDBStructNode *parent);
6832
6833 // accessor to branch node
6834 ICDBStructNode *getCDBNode()
6835 {
6836 return _BranchNode;
6837 }
6838
6839 TArray &getArray(uint32 index)
6840 {
6841 nlassert(index < 1024);
6842 return _Array[index];
6843 }
6844
6845 };
6846
6847 class TFABER_PLANS
6848 {
6849 public:
6850
6851 class TArray
6852 {
6853 public:
6854
6855
6856 private:
6857 ICDBStructNode *_BranchNode;
6858
6859 ICDBStructNode *_KNOWN;
6860
6861
6862 public:
6863 void init(ICDBStructNode *parent, uint index);
6864
6865 // accessor to branch node
6866 ICDBStructNode *getCDBNode()
6867 {
6868 return _BranchNode;
6869 }
6870
6871
6872 void setKNOWN(CCDBSynchronised &dbGroup, uint64 value, bool forceSending = false)
6873 {
6874
6875
6876 _setProp(dbGroup, _KNOWN, value, forceSending);
6877 }
6878
6879 uint64 getKNOWN(const CCDBSynchronised &dbGroup)
6880 {
6881 uint64 value;
6882 _getProp(dbGroup, _KNOWN, value);
6883
6884 return value;
6885 }
6886
6887 ICDBStructNode *getKNOWNCDBNode()
6888 {
6889 return _KNOWN;
6890 }
6891
6892 };
6893
6894
6895 private:
6896 ICDBStructNode *_BranchNode;
6897
6898 TArray _Array[64];
6899
6900
6901 public:
6902 void init(ICDBStructNode *parent);
6903
6904 // accessor to branch node
6905 ICDBStructNode *getCDBNode()
6906 {
6907 return _BranchNode;
6908 }
6909
6910 TArray &getArray(uint32 index)
6911 {
6912 nlassert(index < 64);
6913 return _Array[index];
6914 }
6915
6916 };
6917
6918 class TMISSIONS
6919 {
6920 public:
6921
6922 class TArray
6923 {
6924 public:
6925
6926 class TGOALS
6927 {
6928 public:
6929
6930 class TArray
6931 {
6932 public:
6933
6934
6935 private:
6936 ICDBStructNode *_BranchNode;
6937
6938 ICDBStructNode *_TEXT;
6939 ICDBStructNode *_NPC_ALIAS;
6940
6941
6942 public:
6943 void init(ICDBStructNode *parent, uint index);
6944
6945 // accessor to branch node
6946 ICDBStructNode *getCDBNode()
6947 {
6948 return _BranchNode;
6949 }
6950
6951
6952 void setTEXT(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
6953 {
6954
6955
6956 _setProp(dbGroup, _TEXT, value, forceSending);
6957 }
6958
6959 uint32 getTEXT(const CCDBSynchronised &dbGroup)
6960 {
6961 uint32 value;
6962 _getProp(dbGroup, _TEXT, value);
6963
6964 return value;
6965 }
6966
6967 ICDBStructNode *getTEXTCDBNode()
6968 {
6969 return _TEXT;
6970 }
6971
6972 void setNPC_ALIAS(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
6973 {
6974
6975
6976 _setProp(dbGroup, _NPC_ALIAS, value, forceSending);
6977 }
6978
6979 uint32 getNPC_ALIAS(const CCDBSynchronised &dbGroup)
6980 {
6981 uint32 value;
6982 _getProp(dbGroup, _NPC_ALIAS, value);
6983
6984 return value;
6985 }
6986
6987 ICDBStructNode *getNPC_ALIASCDBNode()
6988 {
6989 return _NPC_ALIAS;
6990 }
6991
6992 };
6993
6994
6995 private:
6996 ICDBStructNode *_BranchNode;
6997
6998 TArray _Array[20];
6999
7000
7001 public:
7002 void init(ICDBStructNode *parent);
7003
7004 // accessor to branch node
7005 ICDBStructNode *getCDBNode()
7006 {
7007 return _BranchNode;
7008 }
7009
7010 TArray &getArray(uint32 index)
7011 {
7012 nlassert(index < 20);
7013 return _Array[index];
7014 }
7015
7016 };
7017
7018 class TTARGET
7019 {
7020 public:
7021
7022
7023 private:
7024 ICDBStructNode *_BranchNode;
7025
7026 ICDBStructNode *_TITLE;
7027 ICDBStructNode *_X;
7028 ICDBStructNode *_Y;
7029
7030
7031 public:
7032 void init(ICDBStructNode *parent, uint index);
7033
7034 // accessor to branch node
7035 ICDBStructNode *getCDBNode()
7036 {
7037 return _BranchNode;
7038 }
7039
7040
7041 void setTITLE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
7042 {
7043
7044
7045 _setProp(dbGroup, _TITLE, value, forceSending);
7046 }
7047
7048 uint32 getTITLE(const CCDBSynchronised &dbGroup)
7049 {
7050 uint32 value;
7051 _getProp(dbGroup, _TITLE, value);
7052
7053 return value;
7054 }
7055
7056 ICDBStructNode *getTITLECDBNode()
7057 {
7058 return _TITLE;
7059 }
7060
7061 void setX(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
7062 {
7063
7064
7065 _setProp(dbGroup, _X, value, forceSending);
7066 }
7067
7068 uint32 getX(const CCDBSynchronised &dbGroup)
7069 {
7070 uint32 value;
7071 _getProp(dbGroup, _X, value);
7072
7073 return value;
7074 }
7075
7076 ICDBStructNode *getXCDBNode()
7077 {
7078 return _X;
7079 }
7080
7081 void setY(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
7082 {
7083
7084
7085 _setProp(dbGroup, _Y, value, forceSending);
7086 }
7087
7088 uint32 getY(const CCDBSynchronised &dbGroup)
7089 {
7090 uint32 value;
7091 _getProp(dbGroup, _Y, value);
7092
7093 return value;
7094 }
7095
7096 ICDBStructNode *getYCDBNode()
7097 {
7098 return _Y;
7099 }
7100
7101 };
7102
7103 class THISTO
7104 {
7105 public:
7106
7107 class TArray
7108 {
7109 public:
7110
7111
7112 private:
7113 ICDBStructNode *_BranchNode;
7114
7115 ICDBStructNode *_TEXT;
7116
7117
7118 public:
7119 void init(ICDBStructNode *parent, uint index);
7120
7121 // accessor to branch node
7122 ICDBStructNode *getCDBNode()
7123 {
7124 return _BranchNode;
7125 }
7126
7127
7128 void setTEXT(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
7129 {
7130
7131
7132 _setProp(dbGroup, _TEXT, value, forceSending);
7133 }
7134
7135 uint32 getTEXT(const CCDBSynchronised &dbGroup)
7136 {
7137 uint32 value;
7138 _getProp(dbGroup, _TEXT, value);
7139
7140 return value;
7141 }
7142
7143 ICDBStructNode *getTEXTCDBNode()
7144 {
7145 return _TEXT;
7146 }
7147
7148 };
7149
7150
7151 private:
7152 ICDBStructNode *_BranchNode;
7153
7154 TArray _Array[30];
7155
7156
7157 public:
7158 void init(ICDBStructNode *parent);
7159
7160 // accessor to branch node
7161 ICDBStructNode *getCDBNode()
7162 {
7163 return _BranchNode;
7164 }
7165
7166 TArray &getArray(uint32 index)
7167 {
7168 nlassert(index < 30);
7169 return _Array[index];
7170 }
7171
7172 };
7173
7174
7175 private:
7176 ICDBStructNode *_BranchNode;
7177
7178 ICDBStructNode *_TYPE;
7179 ICDBStructNode *_ICON;
7180 ICDBStructNode *_TITLE;
7181 ICDBStructNode *_DETAIL_TEXT;
7182 ICDBStructNode *_BEGIN_DATE;
7183 ICDBStructNode *_END_DATE;
7184 ICDBStructNode *_OR_STEPS;
7185 ICDBStructNode *_FINISHED;
7186 ICDBStructNode *_ABANDONNABLE;
7187 ICDBStructNode *_SLEEP;
7188 TGOALS _GOALS;
7189 TTARGET _TARGET[8];
7190 THISTO _HISTO;
7191
7192
7193 public:
7194 void init(ICDBStructNode *parent, uint index);
7195
7196 // accessor to branch node
7197 ICDBStructNode *getCDBNode()
7198 {
7199 return _BranchNode;
7200 }
7201
7202
7203 void setTYPE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
7204 {
7205
7206 // Check that the value is not out of database precision
7207 STOP_IF(value > (1<<2)-1, "setTYPE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 2 bits");
7208
7209
7210 _setProp(dbGroup, _TYPE, value, forceSending);
7211 }
7212
7213 uint8 getTYPE(const CCDBSynchronised &dbGroup)
7214 {
7215 uint8 value;
7216 _getProp(dbGroup, _TYPE, value);
7217
7218 return value;
7219 }
7220
7221 ICDBStructNode *getTYPECDBNode()
7222 {
7223 return _TYPE;
7224 }
7225
7226 void setICON(CCDBSynchronised &dbGroup, NLMISC::CSheetId value, bool forceSending = false)
7227 {
7228
7229
7230 _setProp(dbGroup, _ICON, value, forceSending);
7231 }
7232
7233 NLMISC::CSheetId getICON(const CCDBSynchronised &dbGroup)
7234 {
7235 NLMISC::CSheetId value;
7236 _getProp(dbGroup, _ICON, value);
7237
7238 return value;
7239 }
7240
7241 ICDBStructNode *getICONCDBNode()
7242 {
7243 return _ICON;
7244 }
7245
7246 void setTITLE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
7247 {
7248
7249
7250 _setProp(dbGroup, _TITLE, value, forceSending);
7251 }
7252
7253 uint32 getTITLE(const CCDBSynchronised &dbGroup)
7254 {
7255 uint32 value;
7256 _getProp(dbGroup, _TITLE, value);
7257
7258 return value;
7259 }
7260
7261 ICDBStructNode *getTITLECDBNode()
7262 {
7263 return _TITLE;
7264 }
7265
7266 void setDETAIL_TEXT(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
7267 {
7268
7269
7270 _setProp(dbGroup, _DETAIL_TEXT, value, forceSending);
7271 }
7272
7273 uint32 getDETAIL_TEXT(const CCDBSynchronised &dbGroup)
7274 {
7275 uint32 value;
7276 _getProp(dbGroup, _DETAIL_TEXT, value);
7277
7278 return value;
7279 }
7280
7281 ICDBStructNode *getDETAIL_TEXTCDBNode()
7282 {
7283 return _DETAIL_TEXT;
7284 }
7285
7286 void setBEGIN_DATE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
7287 {
7288
7289
7290 _setProp(dbGroup, _BEGIN_DATE, value, forceSending);
7291 }
7292
7293 uint32 getBEGIN_DATE(const CCDBSynchronised &dbGroup)
7294 {
7295 uint32 value;
7296 _getProp(dbGroup, _BEGIN_DATE, value);
7297
7298 return value;
7299 }
7300
7301 ICDBStructNode *getBEGIN_DATECDBNode()
7302 {
7303 return _BEGIN_DATE;
7304 }
7305
7306 void setEND_DATE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
7307 {
7308
7309
7310 _setProp(dbGroup, _END_DATE, value, forceSending);
7311 }
7312
7313 uint32 getEND_DATE(const CCDBSynchronised &dbGroup)
7314 {
7315 uint32 value;
7316 _getProp(dbGroup, _END_DATE, value);
7317
7318 return value;
7319 }
7320
7321 ICDBStructNode *getEND_DATECDBNode()
7322 {
7323 return _END_DATE;
7324 }
7325
7326 void setOR_STEPS(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
7327 {
7328
7329
7330 _setProp(dbGroup, _OR_STEPS, value, forceSending);
7331 }
7332
7333 bool getOR_STEPS(const CCDBSynchronised &dbGroup)
7334 {
7335 bool value;
7336 _getProp(dbGroup, _OR_STEPS, value);
7337
7338 return value;
7339 }
7340
7341 ICDBStructNode *getOR_STEPSCDBNode()
7342 {
7343 return _OR_STEPS;
7344 }
7345
7346 void setFINISHED(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
7347 {
7348
7349 // Check that the value is not out of database precision
7350 STOP_IF(value > (1<<2)-1, "setFINISHED : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 2 bits");
7351
7352
7353 _setProp(dbGroup, _FINISHED, value, forceSending);
7354 }
7355
7356 uint8 getFINISHED(const CCDBSynchronised &dbGroup)
7357 {
7358 uint8 value;
7359 _getProp(dbGroup, _FINISHED, value);
7360
7361 return value;
7362 }
7363
7364 ICDBStructNode *getFINISHEDCDBNode()
7365 {
7366 return _FINISHED;
7367 }
7368
7369 void setABANDONNABLE(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
7370 {
7371
7372
7373 _setProp(dbGroup, _ABANDONNABLE, value, forceSending);
7374 }
7375
7376 bool getABANDONNABLE(const CCDBSynchronised &dbGroup)
7377 {
7378 bool value;
7379 _getProp(dbGroup, _ABANDONNABLE, value);
7380
7381 return value;
7382 }
7383
7384 ICDBStructNode *getABANDONNABLECDBNode()
7385 {
7386 return _ABANDONNABLE;
7387 }
7388
7389 void setSLEEP(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
7390 {
7391
7392
7393 _setProp(dbGroup, _SLEEP, value, forceSending);
7394 }
7395
7396 bool getSLEEP(const CCDBSynchronised &dbGroup)
7397 {
7398 bool value;
7399 _getProp(dbGroup, _SLEEP, value);
7400
7401 return value;
7402 }
7403
7404 ICDBStructNode *getSLEEPCDBNode()
7405 {
7406 return _SLEEP;
7407 }
7408 TGOALS &getGOALS()
7409 {
7410 return _GOALS;
7411 }
7412 TTARGET &getTARGET(uint32 index)
7413 {
7414 nlassert(index < 8);
7415 return _TARGET[index];
7416 }
7417 THISTO &getHISTO()
7418 {
7419 return _HISTO;
7420 }
7421
7422 };
7423
7424
7425 private:
7426 ICDBStructNode *_BranchNode;
7427
7428 TArray _Array[15];
7429
7430
7431 public:
7432 void init(ICDBStructNode *parent);
7433
7434 // accessor to branch node
7435 ICDBStructNode *getCDBNode()
7436 {
7437 return _BranchNode;
7438 }
7439
7440 TArray &getArray(uint32 index)
7441 {
7442 nlassert(index < 15);
7443 return _Array[index];
7444 }
7445
7446 };
7447
7448 class TEXECUTE_PHRASE
7449 {
7450 public:
7451
7452 class TLINK
7453 {
7454 public:
7455
7456 class TArray
7457 {
7458 public:
7459
7460
7461 private:
7462 ICDBStructNode *_BranchNode;
7463
7464 ICDBStructNode *_PHRASE;
7465 ICDBStructNode *_COUNTER;
7466 ICDBStructNode *_HP_COST;
7467 ICDBStructNode *_SAP_COST;
7468 ICDBStructNode *_STA_COST;
7469 ICDBStructNode *_TARGET_NAME;
7470 ICDBStructNode *_TARGET_HP;
7471 ICDBStructNode *_TARGET_SAP;
7472 ICDBStructNode *_TARGET_STA;
7473
7474
7475 public:
7476 void init(ICDBStructNode *parent, uint index);
7477
7478 // accessor to branch node
7479 ICDBStructNode *getCDBNode()
7480 {
7481 return _BranchNode;
7482 }
7483
7484
7485 void setPHRASE(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
7486 {
7487
7488
7489 _setProp(dbGroup, _PHRASE, value, forceSending);
7490 }
7491
7492 uint16 getPHRASE(const CCDBSynchronised &dbGroup)
7493 {
7494 uint16 value;
7495 _getProp(dbGroup, _PHRASE, value);
7496
7497 return value;
7498 }
7499
7500 ICDBStructNode *getPHRASECDBNode()
7501 {
7502 return _PHRASE;
7503 }
7504
7505 void setCOUNTER(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
7506 {
7507
7508 // Check that the value is not out of database precision
7509 STOP_IF(value > (1<<4)-1, "setCOUNTER : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 4 bits");
7510
7511
7512 _setProp(dbGroup, _COUNTER, value, forceSending);
7513 }
7514
7515 uint8 getCOUNTER(const CCDBSynchronised &dbGroup)
7516 {
7517 uint8 value;
7518 _getProp(dbGroup, _COUNTER, value);
7519
7520 return value;
7521 }
7522
7523 ICDBStructNode *getCOUNTERCDBNode()
7524 {
7525 return _COUNTER;
7526 }
7527
7528 void setHP_COST(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
7529 {
7530
7531
7532 _setProp(dbGroup, _HP_COST, value, forceSending);
7533 }
7534
7535 uint16 getHP_COST(const CCDBSynchronised &dbGroup)
7536 {
7537 uint16 value;
7538 _getProp(dbGroup, _HP_COST, value);
7539
7540 return value;
7541 }
7542
7543 ICDBStructNode *getHP_COSTCDBNode()
7544 {
7545 return _HP_COST;
7546 }
7547
7548 void setSAP_COST(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
7549 {
7550
7551
7552 _setProp(dbGroup, _SAP_COST, value, forceSending);
7553 }
7554
7555 uint16 getSAP_COST(const CCDBSynchronised &dbGroup)
7556 {
7557 uint16 value;
7558 _getProp(dbGroup, _SAP_COST, value);
7559
7560 return value;
7561 }
7562
7563 ICDBStructNode *getSAP_COSTCDBNode()
7564 {
7565 return _SAP_COST;
7566 }
7567
7568 void setSTA_COST(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
7569 {
7570
7571
7572 _setProp(dbGroup, _STA_COST, value, forceSending);
7573 }
7574
7575 uint16 getSTA_COST(const CCDBSynchronised &dbGroup)
7576 {
7577 uint16 value;
7578 _getProp(dbGroup, _STA_COST, value);
7579
7580 return value;
7581 }
7582
7583 ICDBStructNode *getSTA_COSTCDBNode()
7584 {
7585 return _STA_COST;
7586 }
7587
7588 void setTARGET_NAME(CCDBSynchronised &dbGroup, ucstring value, bool forceSending = false)
7589 {
7590
7591
7592 _setProp(dbGroup, _TARGET_NAME, value, forceSending);
7593 }
7594
7595 ucstring getTARGET_NAME(const CCDBSynchronised &dbGroup)
7596 {
7597 ucstring value;
7598 _getProp(dbGroup, _TARGET_NAME, value);
7599
7600 return value;
7601 }
7602
7603 void setTARGET_NAME(CCDBSynchronised &dbGroup, uint32 stringId, bool forceSending = false)
7604 {
7605 _setProp(dbGroup, _TARGET_NAME, stringId, forceSending);
7606 }
7607 uint32 getTARGET_NAME_id(const CCDBSynchronised &dbGroup)
7608 {
7609 uint32 value;
7610 _getProp(dbGroup, _TARGET_NAME, value);
7611
7612 return value;
7613 }
7614
7615 ICDBStructNode *getTARGET_NAMECDBNode()
7616 {
7617 return _TARGET_NAME;
7618 }
7619
7620 void setTARGET_HP(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
7621 {
7622
7623 // Check that the value is not out of database precision
7624 STOP_IF(value > (1<<7)-1, "setTARGET_HP : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 7 bits");
7625
7626
7627 _setProp(dbGroup, _TARGET_HP, value, forceSending);
7628 }
7629
7630 uint8 getTARGET_HP(const CCDBSynchronised &dbGroup)
7631 {
7632 uint8 value;
7633 _getProp(dbGroup, _TARGET_HP, value);
7634
7635 return value;
7636 }
7637
7638 ICDBStructNode *getTARGET_HPCDBNode()
7639 {
7640 return _TARGET_HP;
7641 }
7642
7643 void setTARGET_SAP(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
7644 {
7645
7646 // Check that the value is not out of database precision
7647 STOP_IF(value > (1<<7)-1, "setTARGET_SAP : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 7 bits");
7648
7649
7650 _setProp(dbGroup, _TARGET_SAP, value, forceSending);
7651 }
7652
7653 uint8 getTARGET_SAP(const CCDBSynchronised &dbGroup)
7654 {
7655 uint8 value;
7656 _getProp(dbGroup, _TARGET_SAP, value);
7657
7658 return value;
7659 }
7660
7661 ICDBStructNode *getTARGET_SAPCDBNode()
7662 {
7663 return _TARGET_SAP;
7664 }
7665
7666 void setTARGET_STA(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
7667 {
7668
7669 // Check that the value is not out of database precision
7670 STOP_IF(value > (1<<7)-1, "setTARGET_STA : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 7 bits");
7671
7672
7673 _setProp(dbGroup, _TARGET_STA, value, forceSending);
7674 }
7675
7676 uint8 getTARGET_STA(const CCDBSynchronised &dbGroup)
7677 {
7678 uint8 value;
7679 _getProp(dbGroup, _TARGET_STA, value);
7680
7681 return value;
7682 }
7683
7684 ICDBStructNode *getTARGET_STACDBNode()
7685 {
7686 return _TARGET_STA;
7687 }
7688
7689 };
7690
7691
7692 private:
7693 ICDBStructNode *_BranchNode;
7694
7695 TArray _Array[10];
7696
7697
7698 public:
7699 void init(ICDBStructNode *parent);
7700
7701 // accessor to branch node
7702 ICDBStructNode *getCDBNode()
7703 {
7704 return _BranchNode;
7705 }
7706
7707 TArray &getArray(uint32 index)
7708 {
7709 nlassert(index < 10);
7710 return _Array[index];
7711 }
7712
7713 };
7714
7715
7716 private:
7717 ICDBStructNode *_BranchNode;
7718
7719 ICDBStructNode *_PHRASE;
7720 ICDBStructNode *_SHEET;
7721 ICDBStructNode *_NEXT_COUNTER;
7722 ICDBStructNode *_CYCLE_COUNTER;
7723 TLINK _LINK;
7724
7725
7726 public:
7727 void init(ICDBStructNode *parent);
7728
7729 // accessor to branch node
7730 ICDBStructNode *getCDBNode()
7731 {
7732 return _BranchNode;
7733 }
7734
7735
7736 void setPHRASE(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
7737 {
7738
7739
7740 _setProp(dbGroup, _PHRASE, value, forceSending);
7741 }
7742
7743 uint16 getPHRASE(const CCDBSynchronised &dbGroup)
7744 {
7745 uint16 value;
7746 _getProp(dbGroup, _PHRASE, value);
7747
7748 return value;
7749 }
7750
7751 ICDBStructNode *getPHRASECDBNode()
7752 {
7753 return _PHRASE;
7754 }
7755
7756 void setSHEET(CCDBSynchronised &dbGroup, NLMISC::CSheetId value, bool forceSending = false)
7757 {
7758
7759
7760 _setProp(dbGroup, _SHEET, value, forceSending);
7761 }
7762
7763 NLMISC::CSheetId getSHEET(const CCDBSynchronised &dbGroup)
7764 {
7765 NLMISC::CSheetId value;
7766 _getProp(dbGroup, _SHEET, value);
7767
7768 return value;
7769 }
7770
7771 ICDBStructNode *getSHEETCDBNode()
7772 {
7773 return _SHEET;
7774 }
7775
7776 void setNEXT_COUNTER(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
7777 {
7778
7779
7780 _setProp(dbGroup, _NEXT_COUNTER, value, forceSending);
7781 }
7782
7783 uint8 getNEXT_COUNTER(const CCDBSynchronised &dbGroup)
7784 {
7785 uint8 value;
7786 _getProp(dbGroup, _NEXT_COUNTER, value);
7787
7788 return value;
7789 }
7790
7791 ICDBStructNode *getNEXT_COUNTERCDBNode()
7792 {
7793 return _NEXT_COUNTER;
7794 }
7795
7796 void setCYCLE_COUNTER(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
7797 {
7798
7799
7800 _setProp(dbGroup, _CYCLE_COUNTER, value, forceSending);
7801 }
7802
7803 uint8 getCYCLE_COUNTER(const CCDBSynchronised &dbGroup)
7804 {
7805 uint8 value;
7806 _getProp(dbGroup, _CYCLE_COUNTER, value);
7807
7808 return value;
7809 }
7810
7811 ICDBStructNode *getCYCLE_COUNTERCDBNode()
7812 {
7813 return _CYCLE_COUNTER;
7814 }
7815 TLINK &getLINK()
7816 {
7817 return _LINK;
7818 }
7819
7820 };
7821
7822 class TCHARACTER_INFO
7823 {
7824 public:
7825
7826 class TCHARACTERISTICS
7827 {
7828 public:
7829
7830
7831 private:
7832 ICDBStructNode *_BranchNode;
7833
7834 ICDBStructNode *_VALUE;
7835
7836
7837 public:
7838 void init(ICDBStructNode *parent, uint index);
7839
7840 // accessor to branch node
7841 ICDBStructNode *getCDBNode()
7842 {
7843 return _BranchNode;
7844 }
7845
7846
7847 void setVALUE(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
7848 {
7849
7850 // Check that the value is not out of database precision
7851 STOP_IF(value > (1<<12)-1, "setVALUE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 12 bits");
7852
7853
7854 _setProp(dbGroup, _VALUE, value, forceSending);
7855 }
7856
7857 uint16 getVALUE(const CCDBSynchronised &dbGroup)
7858 {
7859 uint16 value;
7860 _getProp(dbGroup, _VALUE, value);
7861
7862 return value;
7863 }
7864
7865 ICDBStructNode *getVALUECDBNode()
7866 {
7867 return _VALUE;
7868 }
7869
7870 };
7871
7872 class TSCORES
7873 {
7874 public:
7875
7876
7877 private:
7878 ICDBStructNode *_BranchNode;
7879
7880 ICDBStructNode *_Base;
7881 ICDBStructNode *_Max;
7882 ICDBStructNode *_BaseRegen;
7883 ICDBStructNode *_Regen;
7884
7885
7886 public:
7887 void init(ICDBStructNode *parent, uint index);
7888
7889 // accessor to branch node
7890 ICDBStructNode *getCDBNode()
7891 {
7892 return _BranchNode;
7893 }
7894
7895
7896 void setBase(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
7897 {
7898
7899 // Check that the value is not out of database precision
7900 STOP_IF(value > (1<<24)-1, "setBase : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 24 bits");
7901
7902
7903 _setProp(dbGroup, _Base, value, forceSending);
7904 }
7905
7906 uint32 getBase(const CCDBSynchronised &dbGroup)
7907 {
7908 uint32 value;
7909 _getProp(dbGroup, _Base, value);
7910
7911 return value;
7912 }
7913
7914 ICDBStructNode *getBaseCDBNode()
7915 {
7916 return _Base;
7917 }
7918
7919 void setMax(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
7920 {
7921
7922 // Check that the value is not out of database precision
7923 STOP_IF(value > (1<<24)-1, "setMax : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 24 bits");
7924
7925
7926 _setProp(dbGroup, _Max, value, forceSending);
7927 }
7928
7929 uint32 getMax(const CCDBSynchronised &dbGroup)
7930 {
7931 uint32 value;
7932 _getProp(dbGroup, _Max, value);
7933
7934 return value;
7935 }
7936
7937 ICDBStructNode *getMaxCDBNode()
7938 {
7939 return _Max;
7940 }
7941
7942 void setBaseRegen(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
7943 {
7944
7945 // Check that the value is not out of database precision
7946 STOP_IF(value > (1<<24)-1, "setBaseRegen : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 24 bits");
7947
7948
7949 _setProp(dbGroup, _BaseRegen, value, forceSending);
7950 }
7951
7952 uint32 getBaseRegen(const CCDBSynchronised &dbGroup)
7953 {
7954 uint32 value;
7955 _getProp(dbGroup, _BaseRegen, value);
7956
7957 return value;
7958 }
7959
7960 ICDBStructNode *getBaseRegenCDBNode()
7961 {
7962 return _BaseRegen;
7963 }
7964
7965 void setRegen(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
7966 {
7967
7968 // Check that the value is not out of database precision
7969 STOP_IF(value > (1<<24)-1, "setRegen : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 24 bits");
7970
7971
7972 _setProp(dbGroup, _Regen, value, forceSending);
7973 }
7974
7975 uint32 getRegen(const CCDBSynchronised &dbGroup)
7976 {
7977 uint32 value;
7978 _getProp(dbGroup, _Regen, value);
7979
7980 return value;
7981 }
7982
7983 ICDBStructNode *getRegenCDBNode()
7984 {
7985 return _Regen;
7986 }
7987
7988 };
7989
7990 class TMAGIC_RESISTANCE
7991 {
7992 public:
7993
7994 class TArray
7995 {
7996 public:
7997
7998
7999 private:
8000 ICDBStructNode *_BranchNode;
8001
8002 ICDBStructNode *_VALUE;
8003
8004
8005 public:
8006 void init(ICDBStructNode *parent, uint index);
8007
8008 // accessor to branch node
8009 ICDBStructNode *getCDBNode()
8010 {
8011 return _BranchNode;
8012 }
8013
8014
8015 void setVALUE(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
8016 {
8017
8018 // Check that the value is not out of database precision
8019 STOP_IF(value > (1<<9)-1, "setVALUE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 9 bits");
8020
8021
8022 _setProp(dbGroup, _VALUE, value, forceSending);
8023 }
8024
8025 uint16 getVALUE(const CCDBSynchronised &dbGroup)
8026 {
8027 uint16 value;
8028 _getProp(dbGroup, _VALUE, value);
8029
8030 return value;
8031 }
8032
8033 ICDBStructNode *getVALUECDBNode()
8034 {
8035 return _VALUE;
8036 }
8037
8038 };
8039
8040
8041 private:
8042 ICDBStructNode *_BranchNode;
8043
8044 ICDBStructNode *_MaxResistanceBonus;
8045 TArray _Array[5];
8046
8047
8048 public:
8049 void init(ICDBStructNode *parent);
8050
8051 // accessor to branch node
8052 ICDBStructNode *getCDBNode()
8053 {
8054 return _BranchNode;
8055 }
8056
8057
8058 void setMaxResistanceBonus(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
8059 {
8060
8061 // Check that the value is not out of database precision
8062 STOP_IF(value > (1<<9)-1, "setMaxResistanceBonus : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 9 bits");
8063
8064
8065 _setProp(dbGroup, _MaxResistanceBonus, value, forceSending);
8066 }
8067
8068 uint16 getMaxResistanceBonus(const CCDBSynchronised &dbGroup)
8069 {
8070 uint16 value;
8071 _getProp(dbGroup, _MaxResistanceBonus, value);
8072
8073 return value;
8074 }
8075
8076 ICDBStructNode *getMaxResistanceBonusCDBNode()
8077 {
8078 return _MaxResistanceBonus;
8079 }
8080 TArray &getArray(uint32 index)
8081 {
8082 nlassert(index < 5);
8083 return _Array[index];
8084 }
8085
8086 };
8087
8088 class TMAGIC_PROTECTION
8089 {
8090 public:
8091
8092 class TArray
8093 {
8094 public:
8095
8096
8097 private:
8098 ICDBStructNode *_BranchNode;
8099
8100 ICDBStructNode *_VALUE;
8101
8102
8103 public:
8104 void init(ICDBStructNode *parent, uint index);
8105
8106 // accessor to branch node
8107 ICDBStructNode *getCDBNode()
8108 {
8109 return _BranchNode;
8110 }
8111
8112
8113 void setVALUE(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
8114 {
8115
8116 // Check that the value is not out of database precision
8117 STOP_IF(value > (1<<9)-1, "setVALUE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 9 bits");
8118
8119
8120 _setProp(dbGroup, _VALUE, value, forceSending);
8121 }
8122
8123 uint16 getVALUE(const CCDBSynchronised &dbGroup)
8124 {
8125 uint16 value;
8126 _getProp(dbGroup, _VALUE, value);
8127
8128 return value;
8129 }
8130
8131 ICDBStructNode *getVALUECDBNode()
8132 {
8133 return _VALUE;
8134 }
8135
8136 };
8137
8138
8139 private:
8140 ICDBStructNode *_BranchNode;
8141
8142 ICDBStructNode *_MaxProtectionClampValue;
8143 ICDBStructNode *_MaxAbsorptionFactor;
8144 TArray _Array[7];
8145
8146
8147 public:
8148 void init(ICDBStructNode *parent);
8149
8150 // accessor to branch node
8151 ICDBStructNode *getCDBNode()
8152 {
8153 return _BranchNode;
8154 }
8155
8156
8157 void setMaxProtectionClampValue(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
8158 {
8159
8160 // Check that the value is not out of database precision
8161 STOP_IF(value > (1<<9)-1, "setMaxProtectionClampValue : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 9 bits");
8162
8163
8164 _setProp(dbGroup, _MaxProtectionClampValue, value, forceSending);
8165 }
8166
8167 uint16 getMaxProtectionClampValue(const CCDBSynchronised &dbGroup)
8168 {
8169 uint16 value;
8170 _getProp(dbGroup, _MaxProtectionClampValue, value);
8171
8172 return value;
8173 }
8174
8175 ICDBStructNode *getMaxProtectionClampValueCDBNode()
8176 {
8177 return _MaxProtectionClampValue;
8178 }
8179
8180 void setMaxAbsorptionFactor(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
8181 {
8182
8183 // Check that the value is not out of database precision
8184 STOP_IF(value > (1<<9)-1, "setMaxAbsorptionFactor : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 9 bits");
8185
8186
8187 _setProp(dbGroup, _MaxAbsorptionFactor, value, forceSending);
8188 }
8189
8190 uint16 getMaxAbsorptionFactor(const CCDBSynchronised &dbGroup)
8191 {
8192 uint16 value;
8193 _getProp(dbGroup, _MaxAbsorptionFactor, value);
8194
8195 return value;
8196 }
8197
8198 ICDBStructNode *getMaxAbsorptionFactorCDBNode()
8199 {
8200 return _MaxAbsorptionFactor;
8201 }
8202 TArray &getArray(uint32 index)
8203 {
8204 nlassert(index < 7);
8205 return _Array[index];
8206 }
8207
8208 };
8209
8210 class TDODGE
8211 {
8212 public:
8213
8214
8215 private:
8216 ICDBStructNode *_BranchNode;
8217
8218 ICDBStructNode *_Base;
8219 ICDBStructNode *_Current;
8220
8221
8222 public:
8223 void init(ICDBStructNode *parent);
8224
8225 // accessor to branch node
8226 ICDBStructNode *getCDBNode()
8227 {
8228 return _BranchNode;
8229 }
8230
8231
8232 void setBase(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
8233 {
8234
8235 // Check that the value is not out of database precision
8236 STOP_IF(value > (1<<9)-1, "setBase : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 9 bits");
8237
8238
8239 _setProp(dbGroup, _Base, value, forceSending);
8240 }
8241
8242 uint16 getBase(const CCDBSynchronised &dbGroup)
8243 {
8244 uint16 value;
8245 _getProp(dbGroup, _Base, value);
8246
8247 return value;
8248 }
8249
8250 ICDBStructNode *getBaseCDBNode()
8251 {
8252 return _Base;
8253 }
8254
8255 void setCurrent(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
8256 {
8257
8258 // Check that the value is not out of database precision
8259 STOP_IF(value > (1<<9)-1, "setCurrent : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 9 bits");
8260
8261
8262 _setProp(dbGroup, _Current, value, forceSending);
8263 }
8264
8265 uint16 getCurrent(const CCDBSynchronised &dbGroup)
8266 {
8267 uint16 value;
8268 _getProp(dbGroup, _Current, value);
8269
8270 return value;
8271 }
8272
8273 ICDBStructNode *getCurrentCDBNode()
8274 {
8275 return _Current;
8276 }
8277
8278 };
8279
8280 class TPARRY
8281 {
8282 public:
8283
8284
8285 private:
8286 ICDBStructNode *_BranchNode;
8287
8288 ICDBStructNode *_Base;
8289 ICDBStructNode *_Current;
8290
8291
8292 public:
8293 void init(ICDBStructNode *parent);
8294
8295 // accessor to branch node
8296 ICDBStructNode *getCDBNode()
8297 {
8298 return _BranchNode;
8299 }
8300
8301
8302 void setBase(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
8303 {
8304
8305 // Check that the value is not out of database precision
8306 STOP_IF(value > (1<<9)-1, "setBase : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 9 bits");
8307
8308
8309 _setProp(dbGroup, _Base, value, forceSending);
8310 }
8311
8312 uint16 getBase(const CCDBSynchronised &dbGroup)
8313 {
8314 uint16 value;
8315 _getProp(dbGroup, _Base, value);
8316
8317 return value;
8318 }
8319
8320 ICDBStructNode *getBaseCDBNode()
8321 {
8322 return _Base;
8323 }
8324
8325 void setCurrent(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
8326 {
8327
8328 // Check that the value is not out of database precision
8329 STOP_IF(value > (1<<9)-1, "setCurrent : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 9 bits");
8330
8331
8332 _setProp(dbGroup, _Current, value, forceSending);
8333 }
8334
8335 uint16 getCurrent(const CCDBSynchronised &dbGroup)
8336 {
8337 uint16 value;
8338 _getProp(dbGroup, _Current, value);
8339
8340 return value;
8341 }
8342
8343 ICDBStructNode *getCurrentCDBNode()
8344 {
8345 return _Current;
8346 }
8347
8348 };
8349
8350 class TSKILLS
8351 {
8352 public:
8353
8354 class TArray
8355 {
8356 public:
8357
8358
8359 private:
8360 ICDBStructNode *_BranchNode;
8361
8362 ICDBStructNode *_SKILL;
8363 ICDBStructNode *_BaseSKILL;
8364 ICDBStructNode *_PROGRESS_BAR;
8365
8366
8367 public:
8368 void init(ICDBStructNode *parent, uint index);
8369
8370 // accessor to branch node
8371 ICDBStructNode *getCDBNode()
8372 {
8373 return _BranchNode;
8374 }
8375
8376
8377 void setSKILL(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
8378 {
8379
8380 // Check that the value is not out of database precision
8381 STOP_IF(value > (1<<12)-1, "setSKILL : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 12 bits");
8382
8383
8384 _setProp(dbGroup, _SKILL, value, forceSending);
8385 }
8386
8387 uint16 getSKILL(const CCDBSynchronised &dbGroup)
8388 {
8389 uint16 value;
8390 _getProp(dbGroup, _SKILL, value);
8391
8392 return value;
8393 }
8394
8395 ICDBStructNode *getSKILLCDBNode()
8396 {
8397 return _SKILL;
8398 }
8399
8400 void setBaseSKILL(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
8401 {
8402
8403 // Check that the value is not out of database precision
8404 STOP_IF(value > (1<<12)-1, "setBaseSKILL : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 12 bits");
8405
8406
8407 _setProp(dbGroup, _BaseSKILL, value, forceSending);
8408 }
8409
8410 uint16 getBaseSKILL(const CCDBSynchronised &dbGroup)
8411 {
8412 uint16 value;
8413 _getProp(dbGroup, _BaseSKILL, value);
8414
8415 return value;
8416 }
8417
8418 ICDBStructNode *getBaseSKILLCDBNode()
8419 {
8420 return _BaseSKILL;
8421 }
8422
8423 void setPROGRESS_BAR(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
8424 {
8425
8426
8427 _setProp(dbGroup, _PROGRESS_BAR, value, forceSending);
8428 }
8429
8430 uint8 getPROGRESS_BAR(const CCDBSynchronised &dbGroup)
8431 {
8432 uint8 value;
8433 _getProp(dbGroup, _PROGRESS_BAR, value);
8434
8435 return value;
8436 }
8437
8438 ICDBStructNode *getPROGRESS_BARCDBNode()
8439 {
8440 return _PROGRESS_BAR;
8441 }
8442
8443 };
8444
8445
8446 private:
8447 ICDBStructNode *_BranchNode;
8448
8449 TArray _Array[225];
8450
8451
8452 public:
8453 void init(ICDBStructNode *parent);
8454
8455 // accessor to branch node
8456 ICDBStructNode *getCDBNode()
8457 {
8458 return _BranchNode;
8459 }
8460
8461 TArray &getArray(uint32 index)
8462 {
8463 nlassert(index < 225);
8464 return _Array[index];
8465 }
8466
8467 };
8468
8469 class TXP_CATALYSER
8470 {
8471 public:
8472
8473
8474 private:
8475 ICDBStructNode *_BranchNode;
8476
8477 ICDBStructNode *_Level;
8478 ICDBStructNode *_Count;
8479
8480
8481 public:
8482 void init(ICDBStructNode *parent);
8483
8484 // accessor to branch node
8485 ICDBStructNode *getCDBNode()
8486 {
8487 return _BranchNode;
8488 }
8489
8490
8491 void setLevel(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
8492 {
8493
8494 // Check that the value is not out of database precision
8495 STOP_IF(value > (1<<12)-1, "setLevel : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 12 bits");
8496
8497
8498 _setProp(dbGroup, _Level, value, forceSending);
8499 }
8500
8501 uint16 getLevel(const CCDBSynchronised &dbGroup)
8502 {
8503 uint16 value;
8504 _getProp(dbGroup, _Level, value);
8505
8506 return value;
8507 }
8508
8509 ICDBStructNode *getLevelCDBNode()
8510 {
8511 return _Level;
8512 }
8513
8514 void setCount(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
8515 {
8516
8517 // Check that the value is not out of database precision
8518 STOP_IF(value > (1<<12)-1, "setCount : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 12 bits");
8519
8520
8521 _setProp(dbGroup, _Count, value, forceSending);
8522 }
8523
8524 uint16 getCount(const CCDBSynchronised &dbGroup)
8525 {
8526 uint16 value;
8527 _getProp(dbGroup, _Count, value);
8528
8529 return value;
8530 }
8531
8532 ICDBStructNode *getCountCDBNode()
8533 {
8534 return _Count;
8535 }
8536
8537 };
8538
8539 class TRING_XP_CATALYSER
8540 {
8541 public:
8542
8543
8544 private:
8545 ICDBStructNode *_BranchNode;
8546
8547 ICDBStructNode *_Level;
8548 ICDBStructNode *_Count;
8549
8550
8551 public:
8552 void init(ICDBStructNode *parent);
8553
8554 // accessor to branch node
8555 ICDBStructNode *getCDBNode()
8556 {
8557 return _BranchNode;
8558 }
8559
8560
8561 void setLevel(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
8562 {
8563
8564 // Check that the value is not out of database precision
8565 STOP_IF(value > (1<<12)-1, "setLevel : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 12 bits");
8566
8567
8568 _setProp(dbGroup, _Level, value, forceSending);
8569 }
8570
8571 uint16 getLevel(const CCDBSynchronised &dbGroup)
8572 {
8573 uint16 value;
8574 _getProp(dbGroup, _Level, value);
8575
8576 return value;
8577 }
8578
8579 ICDBStructNode *getLevelCDBNode()
8580 {
8581 return _Level;
8582 }
8583
8584 void setCount(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
8585 {
8586
8587 // Check that the value is not out of database precision
8588 STOP_IF(value > (1<<12)-1, "setCount : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 12 bits");
8589
8590
8591 _setProp(dbGroup, _Count, value, forceSending);
8592 }
8593
8594 uint16 getCount(const CCDBSynchronised &dbGroup)
8595 {
8596 uint16 value;
8597 _getProp(dbGroup, _Count, value);
8598
8599 return value;
8600 }
8601
8602 ICDBStructNode *getCountCDBNode()
8603 {
8604 return _Count;
8605 }
8606
8607 };
8608
8609 class TPVP_FACTION_TAG
8610 {
8611 public:
8612
8613
8614 private:
8615 ICDBStructNode *_BranchNode;
8616
8617 ICDBStructNode *_TAG_PVP;
8618 ICDBStructNode *_ACTIVATION_TIME;
8619 ICDBStructNode *_FLAG_PVP_TIME_LEFT;
8620 ICDBStructNode *_COUNTER;
8621
8622
8623 public:
8624 void init(ICDBStructNode *parent);
8625
8626 // accessor to branch node
8627 ICDBStructNode *getCDBNode()
8628 {
8629 return _BranchNode;
8630 }
8631
8632
8633 void setTAG_PVP(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
8634 {
8635
8636
8637 _setProp(dbGroup, _TAG_PVP, value, forceSending);
8638 }
8639
8640 bool getTAG_PVP(const CCDBSynchronised &dbGroup)
8641 {
8642 bool value;
8643 _getProp(dbGroup, _TAG_PVP, value);
8644
8645 return value;
8646 }
8647
8648 ICDBStructNode *getTAG_PVPCDBNode()
8649 {
8650 return _TAG_PVP;
8651 }
8652
8653 void setACTIVATION_TIME(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
8654 {
8655
8656
8657 _setProp(dbGroup, _ACTIVATION_TIME, value, forceSending);
8658 }
8659
8660 uint32 getACTIVATION_TIME(const CCDBSynchronised &dbGroup)
8661 {
8662 uint32 value;
8663 _getProp(dbGroup, _ACTIVATION_TIME, value);
8664
8665 return value;
8666 }
8667
8668 ICDBStructNode *getACTIVATION_TIMECDBNode()
8669 {
8670 return _ACTIVATION_TIME;
8671 }
8672
8673 void setFLAG_PVP_TIME_LEFT(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
8674 {
8675
8676
8677 _setProp(dbGroup, _FLAG_PVP_TIME_LEFT, value, forceSending);
8678 }
8679
8680 uint32 getFLAG_PVP_TIME_LEFT(const CCDBSynchronised &dbGroup)
8681 {
8682 uint32 value;
8683 _getProp(dbGroup, _FLAG_PVP_TIME_LEFT, value);
8684
8685 return value;
8686 }
8687
8688 ICDBStructNode *getFLAG_PVP_TIME_LEFTCDBNode()
8689 {
8690 return _FLAG_PVP_TIME_LEFT;
8691 }
8692
8693 void setCOUNTER(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
8694 {
8695
8696
8697 _setProp(dbGroup, _COUNTER, value, forceSending);
8698 }
8699
8700 uint8 getCOUNTER(const CCDBSynchronised &dbGroup)
8701 {
8702 uint8 value;
8703 _getProp(dbGroup, _COUNTER, value);
8704
8705 return value;
8706 }
8707
8708 ICDBStructNode *getCOUNTERCDBNode()
8709 {
8710 return _COUNTER;
8711 }
8712
8713 };
8714
8715 class TPVP_OUTPOST
8716 {
8717 public:
8718
8719
8720 private:
8721 ICDBStructNode *_BranchNode;
8722
8723 ICDBStructNode *_FLAG_PVP;
8724 ICDBStructNode *_RIGHT_TO_BANISH;
8725 ICDBStructNode *_ROUND_LVL_CUR;
8726 ICDBStructNode *_ROUND_END_DATE;
8727 ICDBStructNode *_FLAG_PVP_TIME_END;
8728
8729
8730 public:
8731 void init(ICDBStructNode *parent);
8732
8733 // accessor to branch node
8734 ICDBStructNode *getCDBNode()
8735 {
8736 return _BranchNode;
8737 }
8738
8739
8740 void setFLAG_PVP(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
8741 {
8742
8743
8744 _setProp(dbGroup, _FLAG_PVP, value, forceSending);
8745 }
8746
8747 bool getFLAG_PVP(const CCDBSynchronised &dbGroup)
8748 {
8749 bool value;
8750 _getProp(dbGroup, _FLAG_PVP, value);
8751
8752 return value;
8753 }
8754
8755 ICDBStructNode *getFLAG_PVPCDBNode()
8756 {
8757 return _FLAG_PVP;
8758 }
8759
8760 void setRIGHT_TO_BANISH(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
8761 {
8762
8763
8764 _setProp(dbGroup, _RIGHT_TO_BANISH, value, forceSending);
8765 }
8766
8767 bool getRIGHT_TO_BANISH(const CCDBSynchronised &dbGroup)
8768 {
8769 bool value;
8770 _getProp(dbGroup, _RIGHT_TO_BANISH, value);
8771
8772 return value;
8773 }
8774
8775 ICDBStructNode *getRIGHT_TO_BANISHCDBNode()
8776 {
8777 return _RIGHT_TO_BANISH;
8778 }
8779
8780 void setROUND_LVL_CUR(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
8781 {
8782
8783
8784 _setProp(dbGroup, _ROUND_LVL_CUR, value, forceSending);
8785 }
8786
8787 uint32 getROUND_LVL_CUR(const CCDBSynchronised &dbGroup)
8788 {
8789 uint32 value;
8790 _getProp(dbGroup, _ROUND_LVL_CUR, value);
8791
8792 return value;
8793 }
8794
8795 ICDBStructNode *getROUND_LVL_CURCDBNode()
8796 {
8797 return _ROUND_LVL_CUR;
8798 }
8799
8800 void setROUND_END_DATE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
8801 {
8802
8803
8804 _setProp(dbGroup, _ROUND_END_DATE, value, forceSending);
8805 }
8806
8807 uint32 getROUND_END_DATE(const CCDBSynchronised &dbGroup)
8808 {
8809 uint32 value;
8810 _getProp(dbGroup, _ROUND_END_DATE, value);
8811
8812 return value;
8813 }
8814
8815 ICDBStructNode *getROUND_END_DATECDBNode()
8816 {
8817 return _ROUND_END_DATE;
8818 }
8819
8820 void setFLAG_PVP_TIME_END(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
8821 {
8822
8823
8824 _setProp(dbGroup, _FLAG_PVP_TIME_END, value, forceSending);
8825 }
8826
8827 uint32 getFLAG_PVP_TIME_END(const CCDBSynchronised &dbGroup)
8828 {
8829 uint32 value;
8830 _getProp(dbGroup, _FLAG_PVP_TIME_END, value);
8831
8832 return value;
8833 }
8834
8835 ICDBStructNode *getFLAG_PVP_TIME_ENDCDBNode()
8836 {
8837 return _FLAG_PVP_TIME_END;
8838 }
8839
8840 };
8841
8842 class TSUCCESS_MODIFIER
8843 {
8844 public:
8845
8846 class TECO
8847 {
8848 public:
8849
8850 class TArray
8851 {
8852 public:
8853
8854
8855 private:
8856 ICDBStructNode *_BranchNode;
8857
8858 ICDBStructNode *_FORAGE;
8859
8860
8861 public:
8862 void init(ICDBStructNode *parent, uint index);
8863
8864 // accessor to branch node
8865 ICDBStructNode *getCDBNode()
8866 {
8867 return _BranchNode;
8868 }
8869
8870
8871 void setFORAGE(CCDBSynchronised &dbGroup, sint16 value, bool forceSending = false)
8872 {
8873
8874
8875 _setProp(dbGroup, _FORAGE, value, forceSending);
8876 }
8877
8878 sint16 getFORAGE(const CCDBSynchronised &dbGroup)
8879 {
8880 sint16 value;
8881 _getProp(dbGroup, _FORAGE, value);
8882
8883 return value;
8884 }
8885
8886 ICDBStructNode *getFORAGECDBNode()
8887 {
8888 return _FORAGE;
8889 }
8890
8891 };
8892
8893
8894 private:
8895 ICDBStructNode *_BranchNode;
8896
8897 TArray _Array[7];
8898
8899
8900 public:
8901 void init(ICDBStructNode *parent);
8902
8903 // accessor to branch node
8904 ICDBStructNode *getCDBNode()
8905 {
8906 return _BranchNode;
8907 }
8908
8909 TArray &getArray(uint32 index)
8910 {
8911 nlassert(index < 7);
8912 return _Array[index];
8913 }
8914
8915 };
8916
8917
8918 private:
8919 ICDBStructNode *_BranchNode;
8920
8921 ICDBStructNode *_DODGE;
8922 ICDBStructNode *_PARRY;
8923 ICDBStructNode *_CRAFT;
8924 ICDBStructNode *_MELEE;
8925 ICDBStructNode *_RANGE;
8926 ICDBStructNode *_MAGIC;
8927 TECO _ECO;
8928
8929
8930 public:
8931 void init(ICDBStructNode *parent);
8932
8933 // accessor to branch node
8934 ICDBStructNode *getCDBNode()
8935 {
8936 return _BranchNode;
8937 }
8938
8939
8940 void setDODGE(CCDBSynchronised &dbGroup, sint16 value, bool forceSending = false)
8941 {
8942
8943
8944 _setProp(dbGroup, _DODGE, value, forceSending);
8945 }
8946
8947 sint16 getDODGE(const CCDBSynchronised &dbGroup)
8948 {
8949 sint16 value;
8950 _getProp(dbGroup, _DODGE, value);
8951
8952 return value;
8953 }
8954
8955 ICDBStructNode *getDODGECDBNode()
8956 {
8957 return _DODGE;
8958 }
8959
8960 void setPARRY(CCDBSynchronised &dbGroup, sint16 value, bool forceSending = false)
8961 {
8962
8963
8964 _setProp(dbGroup, _PARRY, value, forceSending);
8965 }
8966
8967 sint16 getPARRY(const CCDBSynchronised &dbGroup)
8968 {
8969 sint16 value;
8970 _getProp(dbGroup, _PARRY, value);
8971
8972 return value;
8973 }
8974
8975 ICDBStructNode *getPARRYCDBNode()
8976 {
8977 return _PARRY;
8978 }
8979
8980 void setCRAFT(CCDBSynchronised &dbGroup, sint16 value, bool forceSending = false)
8981 {
8982
8983
8984 _setProp(dbGroup, _CRAFT, value, forceSending);
8985 }
8986
8987 sint16 getCRAFT(const CCDBSynchronised &dbGroup)
8988 {
8989 sint16 value;
8990 _getProp(dbGroup, _CRAFT, value);
8991
8992 return value;
8993 }
8994
8995 ICDBStructNode *getCRAFTCDBNode()
8996 {
8997 return _CRAFT;
8998 }
8999
9000 void setMELEE(CCDBSynchronised &dbGroup, sint16 value, bool forceSending = false)
9001 {
9002
9003
9004 _setProp(dbGroup, _MELEE, value, forceSending);
9005 }
9006
9007 sint16 getMELEE(const CCDBSynchronised &dbGroup)
9008 {
9009 sint16 value;
9010 _getProp(dbGroup, _MELEE, value);
9011
9012 return value;
9013 }
9014
9015 ICDBStructNode *getMELEECDBNode()
9016 {
9017 return _MELEE;
9018 }
9019
9020 void setRANGE(CCDBSynchronised &dbGroup, sint16 value, bool forceSending = false)
9021 {
9022
9023
9024 _setProp(dbGroup, _RANGE, value, forceSending);
9025 }
9026
9027 sint16 getRANGE(const CCDBSynchronised &dbGroup)
9028 {
9029 sint16 value;
9030 _getProp(dbGroup, _RANGE, value);
9031
9032 return value;
9033 }
9034
9035 ICDBStructNode *getRANGECDBNode()
9036 {
9037 return _RANGE;
9038 }
9039
9040 void setMAGIC(CCDBSynchronised &dbGroup, sint16 value, bool forceSending = false)
9041 {
9042
9043
9044 _setProp(dbGroup, _MAGIC, value, forceSending);
9045 }
9046
9047 sint16 getMAGIC(const CCDBSynchronised &dbGroup)
9048 {
9049 sint16 value;
9050 _getProp(dbGroup, _MAGIC, value);
9051
9052 return value;
9053 }
9054
9055 ICDBStructNode *getMAGICCDBNode()
9056 {
9057 return _MAGIC;
9058 }
9059 TECO &getECO()
9060 {
9061 return _ECO;
9062 }
9063
9064 };
9065
9066
9067 private:
9068 ICDBStructNode *_BranchNode;
9069
9070 TCHARACTERISTICS _CHARACTERISTICS[8];
9071 TSCORES _SCORES[4];
9072 TMAGIC_RESISTANCE _MAGIC_RESISTANCE;
9073 TMAGIC_PROTECTION _MAGIC_PROTECTION;
9074 TDODGE _DODGE;
9075 TPARRY _PARRY;
9076 TSKILLS _SKILLS;
9077 TXP_CATALYSER _XP_CATALYSER;
9078 TRING_XP_CATALYSER _RING_XP_CATALYSER;
9079 TPVP_FACTION_TAG _PVP_FACTION_TAG;
9080 TPVP_OUTPOST _PVP_OUTPOST;
9081 TSUCCESS_MODIFIER _SUCCESS_MODIFIER;
9082
9083
9084 public:
9085 void init(ICDBStructNode *parent);
9086
9087 // accessor to branch node
9088 ICDBStructNode *getCDBNode()
9089 {
9090 return _BranchNode;
9091 }
9092
9093 TCHARACTERISTICS &getCHARACTERISTICS(uint32 index)
9094 {
9095 nlassert(index < 8);
9096 return _CHARACTERISTICS[index];
9097 }
9098 TSCORES &getSCORES(uint32 index)
9099 {
9100 nlassert(index < 4);
9101 return _SCORES[index];
9102 }
9103 TMAGIC_RESISTANCE &getMAGIC_RESISTANCE()
9104 {
9105 return _MAGIC_RESISTANCE;
9106 }
9107 TMAGIC_PROTECTION &getMAGIC_PROTECTION()
9108 {
9109 return _MAGIC_PROTECTION;
9110 }
9111 TDODGE &getDODGE()
9112 {
9113 return _DODGE;
9114 }
9115 TPARRY &getPARRY()
9116 {
9117 return _PARRY;
9118 }
9119 TSKILLS &getSKILLS()
9120 {
9121 return _SKILLS;
9122 }
9123 TXP_CATALYSER &getXP_CATALYSER()
9124 {
9125 return _XP_CATALYSER;
9126 }
9127 TRING_XP_CATALYSER &getRING_XP_CATALYSER()
9128 {
9129 return _RING_XP_CATALYSER;
9130 }
9131 TPVP_FACTION_TAG &getPVP_FACTION_TAG()
9132 {
9133 return _PVP_FACTION_TAG;
9134 }
9135 TPVP_OUTPOST &getPVP_OUTPOST()
9136 {
9137 return _PVP_OUTPOST;
9138 }
9139 TSUCCESS_MODIFIER &getSUCCESS_MODIFIER()
9140 {
9141 return _SUCCESS_MODIFIER;
9142 }
9143
9144 };
9145
9146 class TPACK_ANIMAL
9147 {
9148 public:
9149
9150 class TBEAST
9151 {
9152 public:
9153
9154
9155 private:
9156 ICDBStructNode *_BranchNode;
9157
9158 ICDBStructNode *_UID;
9159 ICDBStructNode *_TYPE;
9160 ICDBStructNode *_STATUS;
9161 ICDBStructNode *_HP;
9162 ICDBStructNode *_BULK_MAX;
9163 ICDBStructNode *_POS;
9164 ICDBStructNode *_HUNGER;
9165 ICDBStructNode *_DESPAWN;
9166 ICDBStructNode *_NAME;
9167
9168
9169 public:
9170 void init(ICDBStructNode *parent, uint index);
9171
9172 // accessor to branch node
9173 ICDBStructNode *getCDBNode()
9174 {
9175 return _BranchNode;
9176 }
9177
9178
9179 void setUID(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
9180 {
9181
9182 // Check that the value is not out of database precision
9183 STOP_IF(value > (1<<20)-1, "setUID : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 20 bits");
9184
9185
9186 _setProp(dbGroup, _UID, value, forceSending);
9187 }
9188
9189 uint32 getUID(const CCDBSynchronised &dbGroup)
9190 {
9191 uint32 value;
9192 _getProp(dbGroup, _UID, value);
9193
9194 return value;
9195 }
9196
9197 ICDBStructNode *getUIDCDBNode()
9198 {
9199 return _UID;
9200 }
9201
9202 void setTYPE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
9203 {
9204
9205 // Check that the value is not out of database precision
9206 STOP_IF(value > (1<<4)-1, "setTYPE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 4 bits");
9207
9208
9209 _setProp(dbGroup, _TYPE, value, forceSending);
9210 }
9211
9212 uint8 getTYPE(const CCDBSynchronised &dbGroup)
9213 {
9214 uint8 value;
9215 _getProp(dbGroup, _TYPE, value);
9216
9217 return value;
9218 }
9219
9220 ICDBStructNode *getTYPECDBNode()
9221 {
9222 return _TYPE;
9223 }
9224
9225 void setSTATUS(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
9226 {
9227
9228 // Check that the value is not out of database precision
9229 STOP_IF(value > (1<<5)-1, "setSTATUS : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 5 bits");
9230
9231
9232 _setProp(dbGroup, _STATUS, value, forceSending);
9233 }
9234
9235 uint8 getSTATUS(const CCDBSynchronised &dbGroup)
9236 {
9237 uint8 value;
9238 _getProp(dbGroup, _STATUS, value);
9239
9240 return value;
9241 }
9242
9243 ICDBStructNode *getSTATUSCDBNode()
9244 {
9245 return _STATUS;
9246 }
9247
9248 void setHP(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
9249 {
9250
9251 // Check that the value is not out of database precision
9252 STOP_IF(value > (1<<7)-1, "setHP : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 7 bits");
9253
9254
9255 _setProp(dbGroup, _HP, value, forceSending);
9256 }
9257
9258 uint8 getHP(const CCDBSynchronised &dbGroup)
9259 {
9260 uint8 value;
9261 _getProp(dbGroup, _HP, value);
9262
9263 return value;
9264 }
9265
9266 ICDBStructNode *getHPCDBNode()
9267 {
9268 return _HP;
9269 }
9270
9271 void setBULK_MAX(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
9272 {
9273
9274
9275 _setProp(dbGroup, _BULK_MAX, value, forceSending);
9276 }
9277
9278 uint32 getBULK_MAX(const CCDBSynchronised &dbGroup)
9279 {
9280 uint32 value;
9281 _getProp(dbGroup, _BULK_MAX, value);
9282
9283 return value;
9284 }
9285
9286 ICDBStructNode *getBULK_MAXCDBNode()
9287 {
9288 return _BULK_MAX;
9289 }
9290
9291 void setPOS(CCDBSynchronised &dbGroup, uint64 value, bool forceSending = false)
9292 {
9293
9294
9295 _setProp(dbGroup, _POS, value, forceSending);
9296 }
9297
9298 uint64 getPOS(const CCDBSynchronised &dbGroup)
9299 {
9300 uint64 value;
9301 _getProp(dbGroup, _POS, value);
9302
9303 return value;
9304 }
9305
9306 ICDBStructNode *getPOSCDBNode()
9307 {
9308 return _POS;
9309 }
9310
9311 void setHUNGER(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
9312 {
9313
9314 // Check that the value is not out of database precision
9315 STOP_IF(value > (1<<5)-1, "setHUNGER : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 5 bits");
9316
9317
9318 _setProp(dbGroup, _HUNGER, value, forceSending);
9319 }
9320
9321 uint8 getHUNGER(const CCDBSynchronised &dbGroup)
9322 {
9323 uint8 value;
9324 _getProp(dbGroup, _HUNGER, value);
9325
9326 return value;
9327 }
9328
9329 ICDBStructNode *getHUNGERCDBNode()
9330 {
9331 return _HUNGER;
9332 }
9333
9334 void setDESPAWN(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
9335 {
9336
9337 // Check that the value is not out of database precision
9338 STOP_IF(value > (1<<7)-1, "setDESPAWN : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 7 bits");
9339
9340
9341 _setProp(dbGroup, _DESPAWN, value, forceSending);
9342 }
9343
9344 uint8 getDESPAWN(const CCDBSynchronised &dbGroup)
9345 {
9346 uint8 value;
9347 _getProp(dbGroup, _DESPAWN, value);
9348
9349 return value;
9350 }
9351
9352 ICDBStructNode *getDESPAWNCDBNode()
9353 {
9354 return _DESPAWN;
9355 }
9356
9357 void setNAME(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
9358 {
9359
9360
9361 _setProp(dbGroup, _NAME, value, forceSending);
9362 }
9363
9364 uint32 getNAME(const CCDBSynchronised &dbGroup)
9365 {
9366 uint32 value;
9367 _getProp(dbGroup, _NAME, value);
9368
9369 return value;
9370 }
9371
9372 ICDBStructNode *getNAMECDBNode()
9373 {
9374 return _NAME;
9375 }
9376
9377 };
9378
9379
9380 private:
9381 ICDBStructNode *_BranchNode;
9382
9383 TBEAST _BEAST[7];
9384
9385
9386 public:
9387 void init(ICDBStructNode *parent);
9388
9389 // accessor to branch node
9390 ICDBStructNode *getCDBNode()
9391 {
9392 return _BranchNode;
9393 }
9394
9395 TBEAST &getBEAST(uint32 index)
9396 {
9397 nlassert(index < 7);
9398 return _BEAST[index];
9399 }
9400
9401 };
9402
9403 class TDEBUG_INFO
9404 {
9405 public:
9406
9407
9408 private:
9409 ICDBStructNode *_BranchNode;
9410
9411 ICDBStructNode *_Ping;
9412
9413
9414 public:
9415 void init(ICDBStructNode *parent);
9416
9417 // accessor to branch node
9418 ICDBStructNode *getCDBNode()
9419 {
9420 return _BranchNode;
9421 }
9422
9423
9424 void setPing(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
9425 {
9426
9427
9428 _setProp(dbGroup, _Ping, value, forceSending);
9429 }
9430
9431 uint32 getPing(const CCDBSynchronised &dbGroup)
9432 {
9433 uint32 value;
9434 _getProp(dbGroup, _Ping, value);
9435
9436 return value;
9437 }
9438
9439 ICDBStructNode *getPingCDBNode()
9440 {
9441 return _Ping;
9442 }
9443
9444 };
9445
9446 class TMP_EVAL
9447 {
9448 public:
9449
9450 class TRESULT
9451 {
9452 public:
9453
9454
9455 private:
9456 ICDBStructNode *_BranchNode;
9457
9458 ICDBStructNode *_VALID;
9459 ICDBStructNode *_SMALL_SEED;
9460 ICDBStructNode *_MEDIUM_SEED;
9461 ICDBStructNode *_BIG_SEED;
9462 ICDBStructNode *_VERY_BIG_SEED;
9463 ICDBStructNode *_EXPIRY_DATE;
9464
9465
9466 public:
9467 void init(ICDBStructNode *parent);
9468
9469 // accessor to branch node
9470 ICDBStructNode *getCDBNode()
9471 {
9472 return _BranchNode;
9473 }
9474
9475
9476 void setVALID(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
9477 {
9478
9479
9480 _setProp(dbGroup, _VALID, value, forceSending);
9481 }
9482
9483 bool getVALID(const CCDBSynchronised &dbGroup)
9484 {
9485 bool value;
9486 _getProp(dbGroup, _VALID, value);
9487
9488 return value;
9489 }
9490
9491 ICDBStructNode *getVALIDCDBNode()
9492 {
9493 return _VALID;
9494 }
9495
9496 void setSMALL_SEED(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
9497 {
9498
9499
9500 _setProp(dbGroup, _SMALL_SEED, value, forceSending);
9501 }
9502
9503 uint32 getSMALL_SEED(const CCDBSynchronised &dbGroup)
9504 {
9505 uint32 value;
9506 _getProp(dbGroup, _SMALL_SEED, value);
9507
9508 return value;
9509 }
9510
9511 ICDBStructNode *getSMALL_SEEDCDBNode()
9512 {
9513 return _SMALL_SEED;
9514 }
9515
9516 void setMEDIUM_SEED(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
9517 {
9518
9519
9520 _setProp(dbGroup, _MEDIUM_SEED, value, forceSending);
9521 }
9522
9523 uint32 getMEDIUM_SEED(const CCDBSynchronised &dbGroup)
9524 {
9525 uint32 value;
9526 _getProp(dbGroup, _MEDIUM_SEED, value);
9527
9528 return value;
9529 }
9530
9531 ICDBStructNode *getMEDIUM_SEEDCDBNode()
9532 {
9533 return _MEDIUM_SEED;
9534 }
9535
9536 void setBIG_SEED(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
9537 {
9538
9539
9540 _setProp(dbGroup, _BIG_SEED, value, forceSending);
9541 }
9542
9543 uint32 getBIG_SEED(const CCDBSynchronised &dbGroup)
9544 {
9545 uint32 value;
9546 _getProp(dbGroup, _BIG_SEED, value);
9547
9548 return value;
9549 }
9550
9551 ICDBStructNode *getBIG_SEEDCDBNode()
9552 {
9553 return _BIG_SEED;
9554 }
9555
9556 void setVERY_BIG_SEED(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
9557 {
9558
9559
9560 _setProp(dbGroup, _VERY_BIG_SEED, value, forceSending);
9561 }
9562
9563 uint32 getVERY_BIG_SEED(const CCDBSynchronised &dbGroup)
9564 {
9565 uint32 value;
9566 _getProp(dbGroup, _VERY_BIG_SEED, value);
9567
9568 return value;
9569 }
9570
9571 ICDBStructNode *getVERY_BIG_SEEDCDBNode()
9572 {
9573 return _VERY_BIG_SEED;
9574 }
9575
9576 void setEXPIRY_DATE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
9577 {
9578
9579
9580 _setProp(dbGroup, _EXPIRY_DATE, value, forceSending);
9581 }
9582
9583 uint32 getEXPIRY_DATE(const CCDBSynchronised &dbGroup)
9584 {
9585 uint32 value;
9586 _getProp(dbGroup, _EXPIRY_DATE, value);
9587
9588 return value;
9589 }
9590
9591 ICDBStructNode *getEXPIRY_DATECDBNode()
9592 {
9593 return _EXPIRY_DATE;
9594 }
9595
9596 };
9597
9598 class TRESULT_CRITICAL
9599 {
9600 public:
9601
9602
9603 private:
9604 ICDBStructNode *_BranchNode;
9605
9606 ICDBStructNode *_VALID;
9607 ICDBStructNode *_SMALL_SEED;
9608 ICDBStructNode *_MEDIUM_SEED;
9609 ICDBStructNode *_BIG_SEED;
9610 ICDBStructNode *_VERY_BIG_SEED;
9611 ICDBStructNode *_EXPIRY_DATE;
9612
9613
9614 public:
9615 void init(ICDBStructNode *parent);
9616
9617 // accessor to branch node
9618 ICDBStructNode *getCDBNode()
9619 {
9620 return _BranchNode;
9621 }
9622
9623
9624 void setVALID(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
9625 {
9626
9627
9628 _setProp(dbGroup, _VALID, value, forceSending);
9629 }
9630
9631 bool getVALID(const CCDBSynchronised &dbGroup)
9632 {
9633 bool value;
9634 _getProp(dbGroup, _VALID, value);
9635
9636 return value;
9637 }
9638
9639 ICDBStructNode *getVALIDCDBNode()
9640 {
9641 return _VALID;
9642 }
9643
9644 void setSMALL_SEED(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
9645 {
9646
9647
9648 _setProp(dbGroup, _SMALL_SEED, value, forceSending);
9649 }
9650
9651 uint32 getSMALL_SEED(const CCDBSynchronised &dbGroup)
9652 {
9653 uint32 value;
9654 _getProp(dbGroup, _SMALL_SEED, value);
9655
9656 return value;
9657 }
9658
9659 ICDBStructNode *getSMALL_SEEDCDBNode()
9660 {
9661 return _SMALL_SEED;
9662 }
9663
9664 void setMEDIUM_SEED(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
9665 {
9666
9667
9668 _setProp(dbGroup, _MEDIUM_SEED, value, forceSending);
9669 }
9670
9671 uint32 getMEDIUM_SEED(const CCDBSynchronised &dbGroup)
9672 {
9673 uint32 value;
9674 _getProp(dbGroup, _MEDIUM_SEED, value);
9675
9676 return value;
9677 }
9678
9679 ICDBStructNode *getMEDIUM_SEEDCDBNode()
9680 {
9681 return _MEDIUM_SEED;
9682 }
9683
9684 void setBIG_SEED(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
9685 {
9686
9687
9688 _setProp(dbGroup, _BIG_SEED, value, forceSending);
9689 }
9690
9691 uint32 getBIG_SEED(const CCDBSynchronised &dbGroup)
9692 {
9693 uint32 value;
9694 _getProp(dbGroup, _BIG_SEED, value);
9695
9696 return value;
9697 }
9698
9699 ICDBStructNode *getBIG_SEEDCDBNode()
9700 {
9701 return _BIG_SEED;
9702 }
9703
9704 void setVERY_BIG_SEED(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
9705 {
9706
9707
9708 _setProp(dbGroup, _VERY_BIG_SEED, value, forceSending);
9709 }
9710
9711 uint32 getVERY_BIG_SEED(const CCDBSynchronised &dbGroup)
9712 {
9713 uint32 value;
9714 _getProp(dbGroup, _VERY_BIG_SEED, value);
9715
9716 return value;
9717 }
9718
9719 ICDBStructNode *getVERY_BIG_SEEDCDBNode()
9720 {
9721 return _VERY_BIG_SEED;
9722 }
9723
9724 void setEXPIRY_DATE(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
9725 {
9726
9727
9728 _setProp(dbGroup, _EXPIRY_DATE, value, forceSending);
9729 }
9730
9731 uint32 getEXPIRY_DATE(const CCDBSynchronised &dbGroup)
9732 {
9733 uint32 value;
9734 _getProp(dbGroup, _EXPIRY_DATE, value);
9735
9736 return value;
9737 }
9738
9739 ICDBStructNode *getEXPIRY_DATECDBNode()
9740 {
9741 return _EXPIRY_DATE;
9742 }
9743
9744 };
9745
9746
9747 private:
9748 ICDBStructNode *_BranchNode;
9749
9750 ICDBStructNode *_COST;
9751 TRESULT _RESULT;
9752 TRESULT_CRITICAL _RESULT_CRITICAL;
9753
9754
9755 public:
9756 void init(ICDBStructNode *parent);
9757
9758 // accessor to branch node
9759 ICDBStructNode *getCDBNode()
9760 {
9761 return _BranchNode;
9762 }
9763
9764
9765 void setCOST(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
9766 {
9767
9768
9769 _setProp(dbGroup, _COST, value, forceSending);
9770 }
9771
9772 uint32 getCOST(const CCDBSynchronised &dbGroup)
9773 {
9774 uint32 value;
9775 _getProp(dbGroup, _COST, value);
9776
9777 return value;
9778 }
9779
9780 ICDBStructNode *getCOSTCDBNode()
9781 {
9782 return _COST;
9783 }
9784 TRESULT &getRESULT()
9785 {
9786 return _RESULT;
9787 }
9788 TRESULT_CRITICAL &getRESULT_CRITICAL()
9789 {
9790 return _RESULT_CRITICAL;
9791 }
9792
9793 };
9794
9795 class TCOMPASS
9796 {
9797 public:
9798
9799
9800 private:
9801 ICDBStructNode *_BranchNode;
9802
9803 ICDBStructNode *_HOME_POINT;
9804 ICDBStructNode *_BIND_POINT;
9805 ICDBStructNode *_TARGET;
9806
9807
9808 public:
9809 void init(ICDBStructNode *parent);
9810
9811 // accessor to branch node
9812 ICDBStructNode *getCDBNode()
9813 {
9814 return _BranchNode;
9815 }
9816
9817
9818 void setHOME_POINT(CCDBSynchronised &dbGroup, uint64 value, bool forceSending = false)
9819 {
9820
9821
9822 _setProp(dbGroup, _HOME_POINT, value, forceSending);
9823 }
9824
9825 uint64 getHOME_POINT(const CCDBSynchronised &dbGroup)
9826 {
9827 uint64 value;
9828 _getProp(dbGroup, _HOME_POINT, value);
9829
9830 return value;
9831 }
9832
9833 ICDBStructNode *getHOME_POINTCDBNode()
9834 {
9835 return _HOME_POINT;
9836 }
9837
9838 void setBIND_POINT(CCDBSynchronised &dbGroup, uint64 value, bool forceSending = false)
9839 {
9840
9841
9842 _setProp(dbGroup, _BIND_POINT, value, forceSending);
9843 }
9844
9845 uint64 getBIND_POINT(const CCDBSynchronised &dbGroup)
9846 {
9847 uint64 value;
9848 _getProp(dbGroup, _BIND_POINT, value);
9849
9850 return value;
9851 }
9852
9853 ICDBStructNode *getBIND_POINTCDBNode()
9854 {
9855 return _BIND_POINT;
9856 }
9857
9858 void setTARGET(CCDBSynchronised &dbGroup, uint64 value, bool forceSending = false)
9859 {
9860
9861
9862 _setProp(dbGroup, _TARGET, value, forceSending);
9863 }
9864
9865 uint64 getTARGET(const CCDBSynchronised &dbGroup)
9866 {
9867 uint64 value;
9868 _getProp(dbGroup, _TARGET, value);
9869
9870 return value;
9871 }
9872
9873 ICDBStructNode *getTARGETCDBNode()
9874 {
9875 return _TARGET;
9876 }
9877
9878 };
9879
9880 class TFAME
9881 {
9882 public:
9883
9884 class TPLAYER
9885 {
9886 public:
9887
9888
9889 private:
9890 ICDBStructNode *_BranchNode;
9891
9892 ICDBStructNode *_VALUE;
9893 ICDBStructNode *_THRESHOLD;
9894 ICDBStructNode *_TREND;
9895
9896
9897 public:
9898 void init(ICDBStructNode *parent, uint index);
9899
9900 // accessor to branch node
9901 ICDBStructNode *getCDBNode()
9902 {
9903 return _BranchNode;
9904 }
9905
9906
9907 void setVALUE(CCDBSynchronised &dbGroup, sint8 value, bool forceSending = false)
9908 {
9909
9910
9911 _setProp(dbGroup, _VALUE, value, forceSending);
9912 }
9913
9914 sint8 getVALUE(const CCDBSynchronised &dbGroup)
9915 {
9916 sint8 value;
9917 _getProp(dbGroup, _VALUE, value);
9918
9919 return value;
9920 }
9921
9922 ICDBStructNode *getVALUECDBNode()
9923 {
9924 return _VALUE;
9925 }
9926
9927 void setTHRESHOLD(CCDBSynchronised &dbGroup, sint8 value, bool forceSending = false)
9928 {
9929
9930
9931 _setProp(dbGroup, _THRESHOLD, value, forceSending);
9932 }
9933
9934 sint8 getTHRESHOLD(const CCDBSynchronised &dbGroup)
9935 {
9936 sint8 value;
9937 _getProp(dbGroup, _THRESHOLD, value);
9938
9939 return value;
9940 }
9941
9942 ICDBStructNode *getTHRESHOLDCDBNode()
9943 {
9944 return _THRESHOLD;
9945 }
9946
9947 void setTREND(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
9948 {
9949
9950
9951 _setProp(dbGroup, _TREND, value, forceSending);
9952 }
9953
9954 uint8 getTREND(const CCDBSynchronised &dbGroup)
9955 {
9956 uint8 value;
9957 _getProp(dbGroup, _TREND, value);
9958
9959 return value;
9960 }
9961
9962 ICDBStructNode *getTRENDCDBNode()
9963 {
9964 return _TREND;
9965 }
9966
9967 };
9968
9969 class TTRIBE
9970 {
9971 public:
9972
9973
9974 private:
9975 ICDBStructNode *_BranchNode;
9976
9977 ICDBStructNode *_VALUE;
9978 ICDBStructNode *_THRESHOLD;
9979 ICDBStructNode *_TREND;
9980
9981
9982 public:
9983 void init(ICDBStructNode *parent, uint index);
9984
9985 // accessor to branch node
9986 ICDBStructNode *getCDBNode()
9987 {
9988 return _BranchNode;
9989 }
9990
9991
9992 void setVALUE(CCDBSynchronised &dbGroup, sint8 value, bool forceSending = false)
9993 {
9994
9995
9996 _setProp(dbGroup, _VALUE, value, forceSending);
9997 }
9998
9999 sint8 getVALUE(const CCDBSynchronised &dbGroup)
10000 {
10001 sint8 value;
10002 _getProp(dbGroup, _VALUE, value);
10003
10004 return value;
10005 }
10006
10007 ICDBStructNode *getVALUECDBNode()
10008 {
10009 return _VALUE;
10010 }
10011
10012 void setTHRESHOLD(CCDBSynchronised &dbGroup, sint8 value, bool forceSending = false)
10013 {
10014
10015
10016 _setProp(dbGroup, _THRESHOLD, value, forceSending);
10017 }
10018
10019 sint8 getTHRESHOLD(const CCDBSynchronised &dbGroup)
10020 {
10021 sint8 value;
10022 _getProp(dbGroup, _THRESHOLD, value);
10023
10024 return value;
10025 }
10026
10027 ICDBStructNode *getTHRESHOLDCDBNode()
10028 {
10029 return _THRESHOLD;
10030 }
10031
10032 void setTREND(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
10033 {
10034
10035
10036 _setProp(dbGroup, _TREND, value, forceSending);
10037 }
10038
10039 uint8 getTREND(const CCDBSynchronised &dbGroup)
10040 {
10041 uint8 value;
10042 _getProp(dbGroup, _TREND, value);
10043
10044 return value;
10045 }
10046
10047 ICDBStructNode *getTRENDCDBNode()
10048 {
10049 return _TREND;
10050 }
10051
10052 };
10053
10054
10055 private:
10056 ICDBStructNode *_BranchNode;
10057
10058 ICDBStructNode *_CULT_ALLEGIANCE;
10059 ICDBStructNode *_CIV_ALLEGIANCE;
10060 ICDBStructNode *_THRESHOLD_TRADE;
10061 ICDBStructNode *_THRESHOLD_KOS;
10062 TPLAYER _PLAYER[7];
10063 TTRIBE _TRIBE[53];
10064
10065
10066 public:
10067 void init(ICDBStructNode *parent);
10068
10069 // accessor to branch node
10070 ICDBStructNode *getCDBNode()
10071 {
10072 return _BranchNode;
10073 }
10074
10075
10076 void setCULT_ALLEGIANCE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
10077 {
10078
10079 // Check that the value is not out of database precision
10080 STOP_IF(value > (1<<3)-1, "setCULT_ALLEGIANCE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 3 bits");
10081
10082
10083 _setProp(dbGroup, _CULT_ALLEGIANCE, value, forceSending);
10084 }
10085
10086 uint8 getCULT_ALLEGIANCE(const CCDBSynchronised &dbGroup)
10087 {
10088 uint8 value;
10089 _getProp(dbGroup, _CULT_ALLEGIANCE, value);
10090
10091 return value;
10092 }
10093
10094 ICDBStructNode *getCULT_ALLEGIANCECDBNode()
10095 {
10096 return _CULT_ALLEGIANCE;
10097 }
10098
10099 void setCIV_ALLEGIANCE(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
10100 {
10101
10102 // Check that the value is not out of database precision
10103 STOP_IF(value > (1<<3)-1, "setCIV_ALLEGIANCE : Value out of bound : trying to store "<<value<<" in a unsigned field limited to 3 bits");
10104
10105
10106 _setProp(dbGroup, _CIV_ALLEGIANCE, value, forceSending);
10107 }
10108
10109 uint8 getCIV_ALLEGIANCE(const CCDBSynchronised &dbGroup)
10110 {
10111 uint8 value;
10112 _getProp(dbGroup, _CIV_ALLEGIANCE, value);
10113
10114 return value;
10115 }
10116
10117 ICDBStructNode *getCIV_ALLEGIANCECDBNode()
10118 {
10119 return _CIV_ALLEGIANCE;
10120 }
10121
10122 void setTHRESHOLD_TRADE(CCDBSynchronised &dbGroup, sint8 value, bool forceSending = false)
10123 {
10124
10125
10126 _setProp(dbGroup, _THRESHOLD_TRADE, value, forceSending);
10127 }
10128
10129 sint8 getTHRESHOLD_TRADE(const CCDBSynchronised &dbGroup)
10130 {
10131 sint8 value;
10132 _getProp(dbGroup, _THRESHOLD_TRADE, value);
10133
10134 return value;
10135 }
10136
10137 ICDBStructNode *getTHRESHOLD_TRADECDBNode()
10138 {
10139 return _THRESHOLD_TRADE;
10140 }
10141
10142 void setTHRESHOLD_KOS(CCDBSynchronised &dbGroup, sint8 value, bool forceSending = false)
10143 {
10144
10145
10146 _setProp(dbGroup, _THRESHOLD_KOS, value, forceSending);
10147 }
10148
10149 sint8 getTHRESHOLD_KOS(const CCDBSynchronised &dbGroup)
10150 {
10151 sint8 value;
10152 _getProp(dbGroup, _THRESHOLD_KOS, value);
10153
10154 return value;
10155 }
10156
10157 ICDBStructNode *getTHRESHOLD_KOSCDBNode()
10158 {
10159 return _THRESHOLD_KOS;
10160 }
10161 TPLAYER &getPLAYER(uint32 index)
10162 {
10163 nlassert(index < 7);
10164 return _PLAYER[index];
10165 }
10166 TTRIBE &getTRIBE(uint32 index)
10167 {
10168 nlassert(index < 53);
10169 return _TRIBE[index];
10170 }
10171
10172 };
10173
10174 class TSTATIC_DATA
10175 {
10176 public:
10177
10178
10179 private:
10180 ICDBStructNode *_BranchNode;
10181
10182 ICDBStructNode *_BAG_BULK_MAX;
10183
10184
10185 public:
10186 void init(ICDBStructNode *parent);
10187
10188 // accessor to branch node
10189 ICDBStructNode *getCDBNode()
10190 {
10191 return _BranchNode;
10192 }
10193
10194
10195 void setBAG_BULK_MAX(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
10196 {
10197
10198
10199 _setProp(dbGroup, _BAG_BULK_MAX, value, forceSending);
10200 }
10201
10202 uint32 getBAG_BULK_MAX(const CCDBSynchronised &dbGroup)
10203 {
10204 uint32 value;
10205 _getProp(dbGroup, _BAG_BULK_MAX, value);
10206
10207 return value;
10208 }
10209
10210 ICDBStructNode *getBAG_BULK_MAXCDBNode()
10211 {
10212 return _BAG_BULK_MAX;
10213 }
10214
10215 };
10216
10217 class TDYN_CHAT
10218 {
10219 public:
10220
10221 class TCHANNEL
10222 {
10223 public:
10224
10225
10226 private:
10227 ICDBStructNode *_BranchNode;
10228
10229 ICDBStructNode *_NAME;
10230 ICDBStructNode *_ID;
10231 ICDBStructNode *_WRITE_RIGHT;
10232
10233
10234 public:
10235 void init(ICDBStructNode *parent, uint index);
10236
10237 // accessor to branch node
10238 ICDBStructNode *getCDBNode()
10239 {
10240 return _BranchNode;
10241 }
10242
10243
10244 void setNAME(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
10245 {
10246
10247
10248 _setProp(dbGroup, _NAME, value, forceSending);
10249 }
10250
10251 uint32 getNAME(const CCDBSynchronised &dbGroup)
10252 {
10253 uint32 value;
10254 _getProp(dbGroup, _NAME, value);
10255
10256 return value;
10257 }
10258
10259 ICDBStructNode *getNAMECDBNode()
10260 {
10261 return _NAME;
10262 }
10263
10264 void setID(CCDBSynchronised &dbGroup, uint64 value, bool forceSending = false)
10265 {
10266
10267
10268 _setProp(dbGroup, _ID, value, forceSending);
10269 }
10270
10271 uint64 getID(const CCDBSynchronised &dbGroup)
10272 {
10273 uint64 value;
10274 _getProp(dbGroup, _ID, value);
10275
10276 return value;
10277 }
10278
10279 ICDBStructNode *getIDCDBNode()
10280 {
10281 return _ID;
10282 }
10283
10284 void setWRITE_RIGHT(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
10285 {
10286
10287
10288 _setProp(dbGroup, _WRITE_RIGHT, value, forceSending);
10289 }
10290
10291 bool getWRITE_RIGHT(const CCDBSynchronised &dbGroup)
10292 {
10293 bool value;
10294 _getProp(dbGroup, _WRITE_RIGHT, value);
10295
10296 return value;
10297 }
10298
10299 ICDBStructNode *getWRITE_RIGHTCDBNode()
10300 {
10301 return _WRITE_RIGHT;
10302 }
10303
10304 };
10305
10306
10307 private:
10308 ICDBStructNode *_BranchNode;
10309
10310 TCHANNEL _CHANNEL[8];
10311
10312
10313 public:
10314 void init(ICDBStructNode *parent);
10315
10316 // accessor to branch node
10317 ICDBStructNode *getCDBNode()
10318 {
10319 return _BranchNode;
10320 }
10321
10322 TCHANNEL &getCHANNEL(uint32 index)
10323 {
10324 nlassert(index < 8);
10325 return _CHANNEL[index];
10326 }
10327
10328 };
10329
10330 class TPVP_EFFECTS
10331 {
10332 public:
10333
10334 class TPVP_FACTION_POINTS
10335 {
10336 public:
10337
10338
10339 private:
10340 ICDBStructNode *_BranchNode;
10341
10342 ICDBStructNode *_CIV;
10343 ICDBStructNode *_CIV_POINTS;
10344 ICDBStructNode *_CULT;
10345 ICDBStructNode *_CULT_POINTS;
10346
10347
10348 public:
10349 void init(ICDBStructNode *parent);
10350
10351 // accessor to branch node
10352 ICDBStructNode *getCDBNode()
10353 {
10354 return _BranchNode;
10355 }
10356
10357
10358 void setCIV(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
10359 {
10360
10361
10362 _setProp(dbGroup, _CIV, value, forceSending);
10363 }
10364
10365 uint8 getCIV(const CCDBSynchronised &dbGroup)
10366 {
10367 uint8 value;
10368 _getProp(dbGroup, _CIV, value);
10369
10370 return value;
10371 }
10372
10373 ICDBStructNode *getCIVCDBNode()
10374 {
10375 return _CIV;
10376 }
10377
10378 void setCIV_POINTS(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
10379 {
10380
10381
10382 _setProp(dbGroup, _CIV_POINTS, value, forceSending);
10383 }
10384
10385 uint32 getCIV_POINTS(const CCDBSynchronised &dbGroup)
10386 {
10387 uint32 value;
10388 _getProp(dbGroup, _CIV_POINTS, value);
10389
10390 return value;
10391 }
10392
10393 ICDBStructNode *getCIV_POINTSCDBNode()
10394 {
10395 return _CIV_POINTS;
10396 }
10397
10398 void setCULT(CCDBSynchronised &dbGroup, uint8 value, bool forceSending = false)
10399 {
10400
10401
10402 _setProp(dbGroup, _CULT, value, forceSending);
10403 }
10404
10405 uint8 getCULT(const CCDBSynchronised &dbGroup)
10406 {
10407 uint8 value;
10408 _getProp(dbGroup, _CULT, value);
10409
10410 return value;
10411 }
10412
10413 ICDBStructNode *getCULTCDBNode()
10414 {
10415 return _CULT;
10416 }
10417
10418 void setCULT_POINTS(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
10419 {
10420
10421
10422 _setProp(dbGroup, _CULT_POINTS, value, forceSending);
10423 }
10424
10425 uint32 getCULT_POINTS(const CCDBSynchronised &dbGroup)
10426 {
10427 uint32 value;
10428 _getProp(dbGroup, _CULT_POINTS, value);
10429
10430 return value;
10431 }
10432
10433 ICDBStructNode *getCULT_POINTSCDBNode()
10434 {
10435 return _CULT_POINTS;
10436 }
10437
10438 };
10439
10440 class TArray
10441 {
10442 public:
10443
10444
10445 private:
10446 ICDBStructNode *_BranchNode;
10447
10448 ICDBStructNode *_ID;
10449 ICDBStructNode *_ISBONUS;
10450 ICDBStructNode *_PARAM;
10451
10452
10453 public:
10454 void init(ICDBStructNode *parent, uint index);
10455
10456 // accessor to branch node
10457 ICDBStructNode *getCDBNode()
10458 {
10459 return _BranchNode;
10460 }
10461
10462
10463 void setID(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
10464 {
10465
10466
10467 _setProp(dbGroup, _ID, value, forceSending);
10468 }
10469
10470 uint32 getID(const CCDBSynchronised &dbGroup)
10471 {
10472 uint32 value;
10473 _getProp(dbGroup, _ID, value);
10474
10475 return value;
10476 }
10477
10478 ICDBStructNode *getIDCDBNode()
10479 {
10480 return _ID;
10481 }
10482
10483 void setISBONUS(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
10484 {
10485
10486
10487 _setProp(dbGroup, _ISBONUS, value, forceSending);
10488 }
10489
10490 bool getISBONUS(const CCDBSynchronised &dbGroup)
10491 {
10492 bool value;
10493 _getProp(dbGroup, _ISBONUS, value);
10494
10495 return value;
10496 }
10497
10498 ICDBStructNode *getISBONUSCDBNode()
10499 {
10500 return _ISBONUS;
10501 }
10502
10503 void setPARAM(CCDBSynchronised &dbGroup, uint32 value, bool forceSending = false)
10504 {
10505
10506
10507 _setProp(dbGroup, _PARAM, value, forceSending);
10508 }
10509
10510 uint32 getPARAM(const CCDBSynchronised &dbGroup)
10511 {
10512 uint32 value;
10513 _getProp(dbGroup, _PARAM, value);
10514
10515 return value;
10516 }
10517
10518 ICDBStructNode *getPARAMCDBNode()
10519 {
10520 return _PARAM;
10521 }
10522
10523 };
10524
10525
10526 private:
10527 ICDBStructNode *_BranchNode;
10528
10529 TPVP_FACTION_POINTS _PVP_FACTION_POINTS;
10530 TArray _Array[59];
10531
10532
10533 public:
10534 void init(ICDBStructNode *parent);
10535
10536 // accessor to branch node
10537 ICDBStructNode *getCDBNode()
10538 {
10539 return _BranchNode;
10540 }
10541
10542 TPVP_FACTION_POINTS &getPVP_FACTION_POINTS()
10543 {
10544 return _PVP_FACTION_POINTS;
10545 }
10546 TArray &getArray(uint32 index)
10547 {
10548 nlassert(index < 59);
10549 return _Array[index];
10550 }
10551
10552 };
10553
10554 class TWEATHER
10555 {
10556 public:
10557
10558
10559 private:
10560 ICDBStructNode *_BranchNode;
10561
10562 ICDBStructNode *_VALUE;
10563
10564
10565 public:
10566 void init(ICDBStructNode *parent);
10567
10568 // accessor to branch node
10569 ICDBStructNode *getCDBNode()
10570 {
10571 return _BranchNode;
10572 }
10573
10574
10575 void setVALUE(CCDBSynchronised &dbGroup, uint16 value, bool forceSending = false)
10576 {
10577
10578
10579 _setProp(dbGroup, _VALUE, value, forceSending);
10580 }
10581
10582 uint16 getVALUE(const CCDBSynchronised &dbGroup)
10583 {
10584 uint16 value;
10585 _getProp(dbGroup, _VALUE, value);
10586
10587 return value;
10588 }
10589
10590 ICDBStructNode *getVALUECDBNode()
10591 {
10592 return _VALUE;
10593 }
10594
10595 };
10596
10597 static TGameTime _GameTime;
10598
10599 static TINTERFACES _INTERFACES;
10600
10601 static TUSER _USER;
10602
10603 static TDEFENSE _DEFENSE;
10604
10605 static TFLAGS _FLAGS;
10606
10607 static TTARGET _TARGET;
10608
10609 static TGROUP _GROUP;
10610
10611 static TDM_GIFT _DM_GIFT;
10612
10613 static TEXCHANGE _EXCHANGE;
10614
10615 static TINVENTORY _INVENTORY;
10616
10617 static TMODIFIERS _MODIFIERS;
10618
10619 static TDISABLE_CONSUMABLE _DISABLE_CONSUMABLE;
10620
10621 static TBOTCHAT _BOTCHAT;
10622
10623 static TASCENSOR _ASCENSOR;
10624
10625 static TCHOOSE_MISSIONS _CHOOSE_MISSIONS;
10626
10627 static TTRADING _TRADING;
10628
10629 static TBRICK_FAMILY _BRICK_FAMILY;
10630
10631 static TFABER_PLANS _FABER_PLANS;
10632
10633 static TMISSIONS _MISSIONS;
10634
10635 static TEXECUTE_PHRASE _EXECUTE_PHRASE;
10636
10637 static TCHARACTER_INFO _CHARACTER_INFO;
10638
10639 static TPACK_ANIMAL _PACK_ANIMAL;
10640
10641 static TDEBUG_INFO _DEBUG_INFO;
10642
10643 static TMP_EVAL _MP_EVAL;
10644
10645 static TCOMPASS _COMPASS;
10646
10647 static TFAME _FAME;
10648
10649 static TSTATIC_DATA _STATIC_DATA;
10650
10651 static TDYN_CHAT _DYN_CHAT;
10652
10653 static TPVP_EFFECTS _PVP_EFFECTS;
10654
10655 static TWEATHER _WEATHER;
10656
10657
10658 public:
10659
10660 // Constructor
10661 CBankAccessor_PLR()
10662 {
10663 // make sure the static tree is initialised (some kind of lazy initialisation)
10664 init();
10665
10666 // init the base class
10667 CCDBSynchronised::init(BankTag);
10668 }
10669
10670
10671 static void init();
10672
10673 static TGameTime &getGameTime()
10674 {
10675 return _GameTime;
10676 }
10677 static TINTERFACES &getINTERFACES()
10678 {
10679 return _INTERFACES;
10680 }
10681 static TUSER &getUSER()
10682 {
10683 return _USER;
10684 }
10685 static TDEFENSE &getDEFENSE()
10686 {
10687 return _DEFENSE;
10688 }
10689 static TFLAGS &getFLAGS()
10690 {
10691 return _FLAGS;
10692 }
10693 static TTARGET &getTARGET()
10694 {
10695 return _TARGET;
10696 }
10697 static TGROUP &getGROUP()
10698 {
10699 return _GROUP;
10700 }
10701 static TDM_GIFT &getDM_GIFT()
10702 {
10703 return _DM_GIFT;
10704 }
10705 static TEXCHANGE &getEXCHANGE()
10706 {
10707 return _EXCHANGE;
10708 }
10709 static TINVENTORY &getINVENTORY()
10710 {
10711 return _INVENTORY;
10712 }
10713 static TMODIFIERS &getMODIFIERS()
10714 {
10715 return _MODIFIERS;
10716 }
10717 static TDISABLE_CONSUMABLE &getDISABLE_CONSUMABLE()
10718 {
10719 return _DISABLE_CONSUMABLE;
10720 }
10721 static TBOTCHAT &getBOTCHAT()
10722 {
10723 return _BOTCHAT;
10724 }
10725 static TASCENSOR &getASCENSOR()
10726 {
10727 return _ASCENSOR;
10728 }
10729 static TCHOOSE_MISSIONS &getCHOOSE_MISSIONS()
10730 {
10731 return _CHOOSE_MISSIONS;
10732 }
10733 static TTRADING &getTRADING()
10734 {
10735 return _TRADING;
10736 }
10737 static TBRICK_FAMILY &getBRICK_FAMILY()
10738 {
10739 return _BRICK_FAMILY;
10740 }
10741 static TFABER_PLANS &getFABER_PLANS()
10742 {
10743 return _FABER_PLANS;
10744 }
10745 static TMISSIONS &getMISSIONS()
10746 {
10747 return _MISSIONS;
10748 }
10749 static TEXECUTE_PHRASE &getEXECUTE_PHRASE()
10750 {
10751 return _EXECUTE_PHRASE;
10752 }
10753 static TCHARACTER_INFO &getCHARACTER_INFO()
10754 {
10755 return _CHARACTER_INFO;
10756 }
10757 static TPACK_ANIMAL &getPACK_ANIMAL()
10758 {
10759 return _PACK_ANIMAL;
10760 }
10761 static TDEBUG_INFO &getDEBUG_INFO()
10762 {
10763 return _DEBUG_INFO;
10764 }
10765 static TMP_EVAL &getMP_EVAL()
10766 {
10767 return _MP_EVAL;
10768 }
10769 static TCOMPASS &getCOMPASS()
10770 {
10771 return _COMPASS;
10772 }
10773 static TFAME &getFAME()
10774 {
10775 return _FAME;
10776 }
10777 static TSTATIC_DATA &getSTATIC_DATA()
10778 {
10779 return _STATIC_DATA;
10780 }
10781 static TDYN_CHAT &getDYN_CHAT()
10782 {
10783 return _DYN_CHAT;
10784 }
10785 static TPVP_EFFECTS &getPVP_EFFECTS()
10786 {
10787 return _PVP_EFFECTS;
10788 }
10789 static TWEATHER &getWEATHER()
10790 {
10791 return _WEATHER;
10792 }
10793
10794
10795 };
10796
10797
10798 #endif // INCLUDED_DATABASE_database_PLR_H