Pol  Revision:cb584c9
pktout.h
Go to the documentation of this file.
1 
20 #ifndef __PKTOUTH
21 #define __PKTOUTH
22 
23 #include "../clib/rawtypes.h"
24 #include "layers.h"
25 #include "pktdef.h"
26 #include "pktoutid.h"
27 #include "uconst.h"
28 namespace Pol
29 {
30 namespace Core
31 {
32 #pragma pack( push, 1 )
33 
34 // struct PKTOUT_0B {
35 // u8 msgtype;
36 // u32 serial;
37 // u16 damage;
38 //};
39 // static_assert( sizeof(PKTOUT_0B) == 7, "size missmatch" );
40 //
41 // struct PKTOUT_11_V1 {
42 // u8 msgtype;
43 // u16 msglen;
44 // u32 serial;
45 // char name[30];
46 // u16 hits;
47 // u16 max_hits;
48 // u8 renameable; // 00, or FF if can rename
49 // u8 moreinfo; // is the data following present?
50 // u8 gender; // GENDER_MALE or GENDER_FEMALE (see uconst.h)
51 // u16 str;
52 // u16 dex;
53 // u16 intel;
54 //
55 // u16 stamina;
56 // u16 max_stamina;
57 //
58 // u16 mana;
59 // u16 max_mana;
60 //
61 // u32 gold;
62 // u16 AR;
63 // u16 weight;
64 // // If moreinfo is 3 or 4
65 // u16 statcap;
66 // u8 followers;
67 // u8 followers_max;
68 // // If moreinfo is 4
69 // u16 fireresist;
70 // u16 coldresist;
71 // u16 poisonresist;
72 // u16 energyresist;
73 // u16 luck;
74 // u16 damage_min;
75 // u16 damage_max;
76 // u32 titching;
77 //};
78 // static_assert( sizeof( PKTOUT_11_V1 ) == 88, "size missmatch" );
79 //
80 // struct PKTOUT_11_V2 {
81 // u8 msgtype;
82 // u16 msglen;
83 // u32 serial;
84 // char name[30];
85 // u16 hits;
86 // u16 max_hits;
87 // u8 renameable; // 00, or FF if can rename
88 // u8 moreinfo; // is the data following present?
89 // u8 gender; // GENDER_MALE or GENDER_FEMALE (see uconst.h)
90 // u16 str;
91 // u16 dex;
92 // u16 intel;
93 //
94 // u16 stamina;
95 // u16 max_stamina;
96 //
97 // u16 mana;
98 // u16 max_mana;
99 //
100 // u32 gold;
101 // u16 AR;
102 // u16 weight;
103 // // If moreinfo is 5 or higher (ML Introduced this mid-packet
104 // u16 max_weight;
105 // u8 race;
106 // // If moreinfo is 3 or higher
107 // u16 statcap;
108 // u8 followers;
109 // u8 followers_max;
110 // // If moreinfo is 4 or higher
111 // u16 fireresist;
112 // u16 coldresist;
113 // u16 poisonresist;
114 // u16 energyresist;
115 // u16 luck;
116 // u16 damage_min;
117 // u16 damage_max;
118 // u32 titching;
119 //};
120 // static_assert( sizeof( PKTOUT_11_V2 ) == 91, "size missmatch" );
121 
122 // Health bar status update (KR)
123 // struct PKTOUT_17 {
124 // u8 msgtype;
125 // u16 msglen;
126 // u32 serial;
127 // u16 unk;
128 // u16 status_type;
129 // u8 flag;
130 //};
131 // static_assert( sizeof(PKTOUT_17) == 12, "size missmatch" );
132 
133 // struct PKTOUT_1A_A {
134 // u8 msgtype;
135 // u16 msglen;
136 // u32 serial; // bit 0x80000000 enables piles
137 // u16 graphic;
138 // u16 amount;
139 // u16 x;
140 // u16 y; // bits 0x80 and 0x40 are Dye and Move (dunno which is which)
141 // u8 z;
142 // u16 color;
143 // u8 flags;
144 //};
145 // static_assert( sizeof(PKTOUT_1A_A) == 19, "size missmatch" );
146 
147 // use message type B if facing of an item is nonzero
148 // struct PKTOUT_1A_B {
149 // u8 msgtype;
150 // u16 msglen;
151 // u32 serial; // bit 0x80000000 enables piles
152 // u16 graphic;
153 // u16 amount;
154 // u16 x; // set bit 0x8000 for this msg type
155 // u16 y; // bits 0x80 and 0x40 are Dye and Move (dunno which is which)
156 // u8 facing;
157 // u8 z;
158 // u16 color;
159 // u8 flags;
160 //};
161 // static_assert( sizeof(PKTOUT_1A_B) == 20, "size missmatch" );
162 
163 // struct PKTOUT_1A_C {
164 // u8 msgtype;
165 // u16 msglen;
166 // u32 serial;
167 // u16 graphic;
168 // u16 x;
169 // u16 y;
170 // u8 z;
171 //};
172 // static_assert( sizeof(PKTOUT_1A_C) == 0x0E, "size missmatch" );
173 
174 // use message type D when?
176 {
179  u32 serial; // bit 0x80000000 enables piles
181  u16 amount; // or is this color?
183  u16 y; // bits 0x80 and 0x40 are Dye and Move (dunno which is which)
184  u8 z;
185 };
186 static_assert( sizeof( PKTOUT_1A_D ) == 0x10, "size missmatch" );
187 
188 // Character Startup - Login actually completed.
189 // struct PKTOUT_1B {
190 // u8 msgtype;
191 // u32 serial;
192 // u8 unk5, unk6, unk7, unk8;
193 // u16 graphic;
194 // u16 x;
195 // u16 y;
196 // u8 unk_15;
197 // u8 z;
198 // u8 dir;
199 // u8 unk18;
200 // u8 unk19;
201 // u8 unk20;
202 // u8 unk21_7F;
203 // u8 unk22;
204 //
205 // u16 map_startx;
206 // u16 map_starty;
207 // u16 map_width;
208 // u16 map_height;
209 // u8 unk31;
210 // u8 unk32;
211 // u8 unk33;
212 // u8 unk34;
213 // u8 unk35;
214 // u8 unk36;
215 //};
216 // static_assert( sizeof(PKTOUT_1B) == 37, "size missmatch" );
217 
218 // Send ASCII Speech
219 // struct PKTOUT_1C {
220 // u8 msgtype;
221 // u16 msglen;
222 // u32 source_serial;
223 // u16 source_graphic;
224 // u8 type;
225 // u16 color;
226 // u16 font;
227 // char speaker_name[ 30 ];
228 // char text[ SPEECH_MAX_LEN + 1 ];
229 //};
230 // static_assert( sizeof(PKTOUT_1C) == 44 + SPEECH_MAX_LEN + 1, "size missmatch" );
231 
232 // struct PKTOUT_1D {
233 // u8 msgtype;
234 // u32 serial;
235 //};
236 // static_assert( sizeof(PKTOUT_1D) == 5, "size missmatch" );
237 
238 struct PKTOUT_1F
239 {
241  u8 unk1_7[7];
242 };
243 static_assert( sizeof( PKTOUT_1F ) == 8, "size missmatch" );
244 
245 // struct PKTOUT_20 {
246 // u8 msgtype;
247 // u32 serial;
248 // u16 graphic;
249 // u8 unk7;
250 // u16 color;
251 // u8 flag1;
252 // u16 x;
253 // u16 y;
254 // u8 unk15;
255 // u8 unk16;
256 // u8 dir; // NOTE: bit 0x80 seems to always be set.
257 // u8 z;
258 // /*
259 // enum {
260 // FLAG_NORMAL = 0x00,
261 // FLAG_WARMODE = 0x40,
262 // FLAG_HIDDEN = 0x80
263 // };
264 // */
265 //};
266 // static_assert( sizeof(PKTOUT_20) == 19, "size missmatch" );
267 
268 // struct PKTOUT_21 {
269 // u8 msgtype;
270 // u8 sequence;
271 // u16 x;
272 // u16 y;
273 // u8 facing;
274 // u8 z;
275 //};
276 // static_assert( sizeof(PKTOUT_21) == 8, "size missmatch" );
277 
278 struct PKTOUT_23
279 {
284  u16 amount; // item amount
293 };
294 static_assert( sizeof( PKTOUT_23 ) == 26, "size missmatch" );
295 
296 // NOTE: Msg Type 24 followed by message type 3C.
297 // (for opening containers)
298 // struct PKTOUT_24 {
299 // u8 msgtype;
300 // u32 serial;
301 // u16 gump; // ugh. 0x0009 is the corpse gump...
302 //};
303 // static_assert( sizeof(PKTOUT_24) == 7, "size missmatch" );
304 
305 // struct PKTOUT_25_V1 {
306 // u8 msgtype;
307 // u32 serial;
308 // u16 graphic;
309 // u8 unk7; // layer?
310 // u16 amount; // ??
311 // u16 x;
312 // u16 y;
313 // u32 container_serial;
314 // u16 color;
315 //};
316 // static_assert( sizeof( PKTOUT_25_V1 ) == 20, "size missmatch" );
317 //
318 // struct PKTOUT_25_V2 {
319 // u8 msgtype;
320 // u32 serial;
321 // u16 graphic;
322 // u8 unk7; // layer?
323 // u16 amount; // ??
324 // u16 x;
325 // u16 y;
326 // u8 slotindex;
327 // u32 container_serial;
328 // u16 color;
329 //};
330 // static_assert( sizeof( PKTOUT_25_V2 ) == 21, "size missmatch" );
331 
332 struct PKTOUT_26
333 {
336 };
337 static_assert( sizeof( PKTOUT_26 ) == 5, "size missmatch" );
338 
339 // struct PKTOUT_27 {
340 // u8 msgtype;
341 // u8 reason;
342 //};
343 // static_assert( sizeof(PKTOUT_27) == 2, "size missmatch" );
344 
345 struct PKTOUT_28
346 {
349 };
350 static_assert( sizeof( PKTOUT_28 ) == 5, "size missmatch" );
351 
352 // struct PKTOUT_29 {
353 // u8 msgtype;
354 //};
355 // static_assert( sizeof(PKTOUT_29) == 1, "size missmatch" );
356 
357 struct PKTOUT_2A
358 {
361 };
362 static_assert( sizeof( PKTOUT_2A ) == 5, "size missmatch" );
363 
364 struct PKTOUT_2B
365 {
367  u8 mode; // on/off. 0/1?
368 };
369 static_assert( sizeof( PKTOUT_2B ) == 2, "size missmatch" );
370 
371 // struct PKTOUT_2D {
372 // u8 msgtype;
373 // u32 serial;
374 // u16 hitsmax;
375 // u16 hitscurrent;
376 // u16 manamax;
377 // u16 manacurrent;
378 // u16 stammax;
379 // u16 stamcurrent;
380 //};
381 // static_assert( sizeof(PKTOUT_2D) == 17, "size missmatch" );
382 
383 // struct PKTOUT_2E {
384 // u8 msgtype;
385 // u32 serial;
386 // u16 graphic;
387 // u8 unk7;
388 // u8 layer;
389 // u32 worn_by;
390 // u16 color;
391 //};
392 // static_assert( sizeof(PKTOUT_2E) == 15, "size missmatch" );
393 
394 // struct PKTOUT_2F {
395 // u8 msgtype;
396 // u8 zero1;
397 // u32 attacker_serial;
398 // u32 defender_serial;
399 //};
400 // static_assert( sizeof(PKTOUT_2F) == 10, "size missmatch" );
401 
402 struct PKTOUT_30
403 {
406 };
407 static_assert( sizeof( PKTOUT_30 ) == 5, "size missmatch" );
408 
409 struct PKTOUT_31
410 {
412 };
413 static_assert( sizeof( PKTOUT_31 ) == 1, "size missmatch" );
414 
415 struct PKTOUT_32
416 {
419 };
420 static_assert( sizeof( PKTOUT_32 ) == 2, "size missmatch" );
421 
422 struct PKTOUT_33
423 {
426 };
427 
428 struct PKTOUT_36
429 {
432  u8 unk1[1];
433 };
434 
435 // msg 3C: be sure to not send the whole structure, just as many 'items' as you insert
436 // struct PKTOUT_3C {
437 // u8 msgtype;
438 // u16 msglen;
439 // u16 count;
440 // struct {
441 // u32 serial;
442 // u16 graphic;
443 // u8 unk6_00;
444 // u16 amount;
445 // u16 x;
446 // u16 y;
447 // u32 container_serial;
448 // u16 color;
449 // } items[ MAX_CONTAINER_ITEMS ];
450 //};
451 // static_assert( sizeof(PKTOUT_3C) == 5 + MAX_CONTAINER_ITEMS * 19, "size missmatch" );
452 //
453 // struct PKTOUT_3C_6017 {
454 // u8 msgtype;
455 // u16 msglen;
456 // u16 count;
457 // struct {
458 // u32 serial;
459 // u16 graphic;
460 // u8 unk6_00;
461 // u16 amount;
462 // u16 x;
463 // u16 y;
464 // u8 slot_index;
465 // u32 container_serial;
466 // u16 color;
467 // } items[ MAX_CONTAINER_ITEMS ];
468 //};
469 // static_assert( sizeof(PKTOUT_3C_6017) == 5 + MAX_CONTAINER_ITEMS * 20, "size missmatch" );
470 
471 struct PKTOUT_3E
472 {
474  u8 unk1_x24[0x24];
475 };
476 static_assert( sizeof( PKTOUT_3E ) == 0x25, "size missmatch" );
477 
478 struct PKTOUT_3F
479 {
482  u8 data[1];
483 };
484 
485 // Server->Client
486 struct PKTOUT_41
487 {
492  u16 unk; // F777
493 };
494 
495 // Server->Client
496 struct PKTOUT_42
497 {
500  u8 data[1];
501 };
502 
503 // Server->Client
504 struct PKTOUT_43
505 {
507  u8 unk1_x28[0x28];
508 };
509 static_assert( sizeof( PKTOUT_43 ) == 0x29, "size missmatch" );
510 
511 // Server->Client
512 struct PKTOUT_44
513 {
515  u8 unk1_xC8[0xC8];
516 };
517 static_assert( sizeof( PKTOUT_44 ) == 0xC9, "size missmatch" );
518 
519 struct PKTOUT_4E
520 {
524 };
525 static_assert( sizeof( PKTOUT_4E ) == 6, "size missmatch" );
526 
527 // struct PKTOUT_4F {
528 // u8 msgtype;
529 // u8 lightlevel;
530 //};
531 // static_assert( sizeof(PKTOUT_4F) == 2, "size missmatch" );
532 
533 // struct PKTOUT_53
534 //{
535 // u8 msgtype;
536 // u8 warning;
537 //
538 // enum {
539 // WARN_NO_CHARACTER = 1,
540 // WARN_CHARACTER_EXISTS = 2,
541 // WARN_CANT_CONNECT_1 = 3,
542 // WARN_CANT_CONNECT_2 = 4,
543 // WARN_CHARACTER_IN_WORLD = 5,
544 // WARN_LOGIN_PROBLEM = 6,
545 // WARN_CHARACTER_IDLE = 7,
546 // WARN_CANT_CONNECT_3 = 8
547 // };
548 //};
549 
550 // struct PKTOUT_54 {
551 // u8 msgtype;
552 // u8 flags; // 0 = repeating, 1 = single play
553 // u16 effect; // SOUND_EFFECT_XX, see sfx.h
554 // u16 volume;
555 // u16 x;
556 // u16 y;
557 // s16 z;
558 // enum { FLAG_REPEAT = 0, FLAG_SINGLEPLAY = 1 };
559 //};
560 // static_assert( sizeof(PKTOUT_54) == 12, "size missmatch" );
561 
562 // struct PKTOUT_55 {
563 // u8 msgtype;
564 //};
565 // static_assert( sizeof(PKTOUT_55) == 1, "size missmatch" );
566 
567 struct PKTOUT_5B
568 {
573 };
574 static_assert( sizeof( PKTOUT_5B ) == 4, "size missmatch" );
575 
576 // struct PKTOUT_65 {
577 // u8 msgtype;
578 // u8 type;
579 // u8 severity;
580 // u8 aux;
581 // enum { TYPE_NONE = 0, TYPE_RAIN = 1, TYPE_SNOW = 2 };
582 // enum { //TODO:FIX//
583 // WTYPE_START_TO_RAIN = 0x00,
584 // WTYPE_FIERCE_STORM = 0x01,
585 // WTYPE_BEGIN_TO_SNOW = 0x02,
586 // WTYPE_STORM_BREWING = 0x03,
587 // WTYPE_STOP_WEATHER = 0xFF
588 // };
589 //};
590 // static_assert( sizeof(PKTOUT_65) == 4, "size missmatch" );
591 
592 // struct PKTOUT_6D
593 //{
594 // u8 msgtype;
595 // u16 midi;
596 //};
597 // static_assert( sizeof(PKTOUT_6D) == 3, "size missmatch" );
598 
599 // struct PKTOUT_6E {
600 // u8 msgtype;
601 // u32 serial;
602 // u16 action;
603 // u16 framecount;
604 // u16 repeatcount;
605 // u8 backward;
606 // u8 repeatflag;
607 // u8 delay;
608 // enum DIRECTION_FLAG { BACKWARD = 1,
609 // FORWARD = 0 };
610 // enum REPEAT_FLAG { REPEAT = 1,
611 // NOREPEAT = 0 };
612 //};
613 // static_assert( sizeof(PKTOUT_6E) == 14, "size missmatch" );
614 
615 /*
616 Okay, this just sucks. If, in a client, you click on someone with
617 the targetting cursor, and at that same moment (or even slightly thereafter!)
618 that person moves, the client seems to regularly get the "move" before
619 registering your selection. The end result is that you target whatever is
620 NOW under your cursor, rather than what WAS under it.
621 On the plus side, it seems you can target an effect from an x/y/z coord
622 to another x/y/z coordinate.
623 */
624 // struct PKTOUT_70 {
625 // u8 msgtype;
626 // u8 effect_type; // EFFECT_TYPE_xx
627 // u32 source_serial;
628 // u32 target_serial;
629 // u16 effect;
630 // u16 srcx;
631 // u16 srcy;
632 // u8 srcz;
633 // u16 dstx;
634 // u16 dsty;
635 // u8 dstz;
636 // u8 speed; /* was: 07 */
637 // u8 loop; /* 1=shortest, 0=very long */
638 // u8 unk24;
639 // u8 unk25;
640 // u8 unk26;
641 // u8 explode;/* not sure what to put here */
642 //};
643 // static_assert( sizeof(PKTOUT_70) == 28, "size missmatch" );
644 
645 // struct PKTOUT_74 {
646 // struct HEADER {
647 // u8 msgtype;
648 // u16 msglen;
649 // u32 container; /* container serial # */
650 // u8 num_items;
651 // };
652 // struct ELEMENT {
653 // u32 price;
654 // u8 desc_len; /* including null terminator */
655 // char description[1]; /* No idea what max len should be null term string len includes null*/
656 // };
657 //};
658 // static_assert( sizeof(PKTOUT_74::HEADER) == 8, "size missmatch" );
659 // static_assert( sizeof(PKTOUT_74::ELEMENT) == 6, "size missmatch" );
660 
661 // struct PKTOUT_76
662 //{
663 // u8 msgtype;
664 // u16 xloc;
665 // u16 yloc;
666 // u16 zloc;
667 // u8 unk0;
668 // u16 x1;
669 // u16 y1;
670 // u16 x2;
671 // u16 y2;
672 //};
673 // static_assert( sizeof( PKTOUT_76 ) == 16, "size missmatch" );
674 
675 // struct PKTOUT_77 {
676 // u8 msgtype;
677 // u32 serial;
678 // u16 graphic;
679 // u16 x;
680 // u16 y;
681 // u8 z;
682 // u8 dir;
683 // u16 skin;
684 // u8 flag1; /* bit 0x80 seems to be invis (and self hidden), bit 0x40 is war mode */
685 // u8 hilite; /* only 1 to 7 seem to be valid. any other value in the entire byte causes white
686 // highlighting */
687 //};
688 // static_assert( sizeof(PKTOUT_77) == 17, "size missmatch" );
689 
690 // struct PKTOUT_78 {
691 // u8 msgtype;
692 // u16 msglen;
693 // u32 serial;
694 // u16 graphic;
695 // u16 x;
696 // u16 y;
697 // u8 z;
698 // u8 facing; /* WALK_DIR_x */
699 // u16 skin; /* skin color? */
700 // u8 flag1;
701 // u8 hilite;
702 // u8 wornitems[ 9 * HIGHEST_LAYER + 4 ];
703 //};
704 //
705 // struct PKTOUT_78_NOCOLOR {
706 // u32 serial;
707 // u16 graphic;
708 // u8 layer;
709 //};
710 // static_assert( sizeof( PKTOUT_78_NOCOLOR ) == 7, "size missmatch" );
711 //
712 // struct PKTOUT_78_COLOR {
713 // u32 serial;
714 // u16 graphic;
715 // u8 layer;
716 // u16 color;
717 //};
718 // static_assert( sizeof( PKTOUT_78_COLOR ) == 9, "size missmatch" );
719 /*
720  FIXME: msg type 78 is incompletely understood. I believe item/clothing data can be sent in it.
721  NOTE on wornitems: each layer is sent. The format seems to be:
722  SERIAL OBJTYPE LAYER {Optional Color}
723  4 2 1 2
724  when there are no more, inject 4 zeros into wornitems.
725  I think the high bit of OBJTYPE indicates whether or not color is present.
726  For our purposes, if the item has a nonzero color, we will send it.
727  I'm not sure if the tiledata has a bit to indicate whether color goes along or not.
728 
729  */
730 
731 // struct PKTOUT_7C {
732 // u8 msgtype;
733 // u16 msglen;
734 // u32 used_item_serial;
735 // u16 menu_id;
736 //};
737 //
738 // struct PKTOUT_7C_TITLE {
739 // u8 titlelen;
740 // char title[ 80 ]; /* don't know what this should be */
741 //};
742 //
743 // struct PKTOUT_7C_COUNT {
744 // u8 item_count;
745 //};
746 //
747 // struct PKTOUT_7C_ELEM {
748 // u16 graphic;
749 // u16 color; // ?? they were all grey.
750 // u8 desclen;
751 // char desc[ 80 ]; // also not sure what the max is
752 //};
753 
754 // struct PKTOUT_82 {
755 // u8 msgtype;
756 // u8 error;
757 //};
758 // static_assert( sizeof(PKTOUT_82) == 2, "size missmatch" );
759 
760 struct PKTOUT_86
761 {
765 };
766 static_assert( sizeof( PKTOUT_86 ) == 4, "size missmatch" );
767 
769 {
770  char name[30];
771  char password[30];
772 };
773 static_assert( sizeof( PKTOUT_86_CHARACTERS ) == 60, "size missmatch" );
774 
775 // struct PKTOUT_88 {
776 // u8 msgtype;
777 // u32 serial;
778 // u8 text[ 60 ];
779 // u8 flag1;
780 //};
781 // static_assert( sizeof(PKTOUT_88) == 66, "size missmatch" );
782 
783 // after all layers inserted, set the 'layer' value
784 // in the next array elem to 0. length should include this byte.
785 // Example, for an empty corpse: 89 00 08 40 75 13 f9 00
786 // struct PKTOUT_89 {
787 // u8 msgtype;
788 // u16 msglen;
789 // u32 serial;
790 // struct {
791 // u8 layer;
792 // u32 serial;
793 // } layers[ NUM_LAYERS +1 ];
794 //};
795 
796 // struct PKTOUT_8C {
797 // u8 msgtype;
798 // u8 ip[4];
799 // u16 port;
800 // u8 unk7_00;
801 // u8 unk8_03;
802 // u16 unk9_10_ClientType;
803 //};
804 // static_assert( sizeof(PKTOUT_8C) == 11, "size missmatch" );
805 
806 // struct PKTOUT_90
807 //{
808 // u8 msgtype;
809 // u32 serial;
810 // u8 unk5_13;
811 // u8 unk6_9d;
812 // u16 x1;
813 // u16 y1;
814 // u16 x2;
815 // u16 y2;
816 // u16 xsize;
817 // u16 ysize;
818 //};
819 // static_assert( sizeof(PKTOUT_90) == 19, "size missmatch" );
820 
821 struct PKTOUT_97
822 {
825 };
826 static_assert( sizeof( PKTOUT_97 ) == 2, "size missmatch" );
827 
828 struct PKTOUT_9C
829 {
831  char response[52]; // Unknown at this time.
832 };
833 
834 // struct PKTOUT_9E {
835 // struct HEADER {
836 // u8 msgtype;
837 // u16 msglen;
838 // u32 vendor_serial;
839 // u16 num_items;
840 // };
841 // struct ELEMENT {
842 // u32 serial;
843 // u16 graphic;
844 // u16 color;
845 // u16 amount;
846 // u16 price;
847 // u16 desc_len;
848 // char description[1];
849 // };
850 //};
851 // static_assert( sizeof(PKTOUT_9E::HEADER) == 9, "size missmatch" );
852 // static_assert( sizeof(PKTOUT_9E::ELEMENT) == 15, "size missmatch" );
853 
854 // struct PKTOUT_A1
855 //{
856 // u8 msgtype;
857 // u32 serial;
858 // u16 max_hits; // str
859 // u16 hits;
860 //};
861 // static_assert( sizeof(PKTOUT_A1) == 9, "size missmatch" );
862 
863 // struct PKTOUT_A2 {
864 // u8 msgtype;
865 // u32 serial;
866 // u16 max_mana; // intel;
867 // u16 mana;
868 //};
869 // static_assert( sizeof(PKTOUT_A2) == 9, "size missmatch" );
870 
871 // struct PKTOUT_A3 {
872 // u8 msgtype;
873 // u32 serial;
874 // u16 max_stamina; // dex;
875 // u16 stamina;
876 //};
877 // static_assert( sizeof(PKTOUT_A3) == 9, "size missmatch" );
878 
879 // struct PKTOUT_A5 {
880 // u8 msgtype;
881 // u16 msglen;
882 // char address[ URL_MAX_LEN + 1 ];
883 // u8 null_term;
884 //};
885 
886 // struct PKTOUT_A6 {
887 // u8 msgtype;
888 // u16 msglen;
889 // u8 type;
890 // u8 unk4;
891 // u8 unk5;
892 // u16 tipnum;
893 // u16 textlen;
894 // char text[10000];
895 // enum { TYPE_TIP = 0,
896 // TYPE_UPDATE = 1 };
897 //};
898 // static_assert( sizeof(PKTOUT_A6) == 10010, "size missmatch" );
899 
900 // struct PKTOUT_A8 {
901 // u8 msgtype;
902 // u16 msglen;
903 // u8 unk3_FF;
904 // u16 servcount;
905 //};
906 // static_assert( sizeof(PKTOUT_A8) == 6, "size missmatch" );
907 //
908 // struct PKTOUT_A8_SERVER {
909 // u16 servernum;
910 // char servername[30]; // think the last two bytes are the sorting amounts.
911 // u16 servernum2;
912 // u8 percentfull;
913 // s8 timezone;
914 // char ip[4];
915 //};
916 // static_assert( sizeof(PKTOUT_A8_SERVER) == 40, "size missmatch" );
917 
918 // struct PKTOUT_A9 {
919 // u8 msgtype;
920 // u16 msglen;
921 // u8 numchars;
922 //};
923 // static_assert( sizeof(PKTOUT_A9) == 4, "size missmatch" );
924 //
928 // struct PKTOUT_A9_CHARACTERS {
929 // char name[60];
930 //};
931 // static_assert( sizeof(PKTOUT_A9_CHARACTERS) == 60, "size missmatch" );
932 //
933 // struct PKTOUT_A9_START_LEN {
934 // u8 startcount;
935 //};
936 // static_assert( sizeof(PKTOUT_A9_START_LEN) == 1, "size missmatch" );
937 //
938 // struct PKTOUT_A9_START_ELEM {
939 // u8 startnum;
940 // char city[31];
941 // char desc[31];
942 //};
943 // static_assert( sizeof(PKTOUT_A9_START_ELEM) == 63, "size missmatch" );
944 //
945 // struct PKTOUT_A9_START_FLAGS {
946 // u32 flags;
947 // enum {
948 // FLAG_UNK_0x0001 = 0x0001, // ?
949 // FLAG_SEND_CONFIG_REQ_LOGOUT = 0x0002, // Sends Configuration to Server
950 // FLAG_SINGLE_CHARACTER_SIEGE = 0x0004, // ?
951 // FLAG_ENABLE_NPC_POPUP_MENUS = 0x0008, // Enable NPC PopUp Menus
952 // FLAG_SINGLE_CHARACTER = 0x0010, // Use 1 Character only
953 // FLAG_AOS_FEATURES = 0x0020, // Age of Shadows
954 // FLAG_UPTO_SIX_CHARACTERS = 0x0040, // Use up to 6 Characters (not only 5)
955 // FLAG_SE_FEATURES = 0x0080, // Samurai Empire
956 // FLAG_ML_FEATURES = 0x0100, // Mondain's Legacy
957 // FLAG_SEND_UO3D_TYPE = 0x0400, // KR and UO:SA will send 0xE1 packet
958 // FLAG_UNK_0x0800 = 0x0800, // ?
959 // FLAG_UPTO_SEVEN_CHARACTERS = 0x1000, // Use up to 7 Characters
960 // FLAG_UNK_0x2000 = 0x2000 // ?
961 // };
962 //};
963 
964 /* AA message - Sets Opponent - the always-highlighted being.
965  Setting to 0 clears.
966  Sent to you when you die (serial=0), or when others target you if you
967  have noone targetted.
968  */
969 // struct PKTOUT_AA {
970 // u8 msgtype;
971 // u32 serial;
972 //};
973 // static_assert( sizeof(PKTOUT_AA) == 5, "size missmatch" );
974 
975 // struct PKTOUT_AB
976 //{
977 // struct HEADER {
978 // u8 msgtype;
979 // u16 msglen;
980 // u32 serial;
981 // u8 type;
982 // u8 index;
983 // };
984 // struct TEXTLINE1 {
985 // u16 numbytes;
986 // char text[256]; // null-terminated
987 // };
988 // struct TEXTLINE2 {
989 // u8 cancel; enum { CANCEL_DISABLE, CANCEL_ENABLE };
990 // u8 style; enum { STYLE_DISABLE, STYLE_NORMAL, STYLE_NUMERICAL };
991 // u32 mask;
992 // u16 numbytes;
993 // char text[256]; // null-terminated
994 // };
995 //
996 //};
997 // static_assert( sizeof(PKTOUT_AB::HEADER) == 9, "size missmatch" );
998 // static_assert( sizeof(PKTOUT_AB::TEXTLINE1) == 258, "size missmatch" );
999 // static_assert( sizeof(PKTOUT_AB::TEXTLINE2) == 264, "size missmatch" );
1000 
1001 // struct PKTOUT_AE
1002 //{
1003 // u8 msgtype;
1004 // u16 msglen;
1005 // u32 source_serial;
1006 // u16 source_graphic;
1007 // u8 type;
1008 // u16 color;
1009 // u16 font;
1010 // char lang[4]; // "enu" - US english
1011 // char speaker_name[ 30 ];
1012 // u16 wtext[(SPEECH_MAX_LEN) + 1]; // wide-character, double-null terminated
1013 //};
1014 // static_assert( sizeof( PKTOUT_AE ) == 450, "size missmatch" );
1015 
1016 // struct PKTOUT_AF {
1017 // u8 msgtype;
1018 // u32 player_id;
1019 // u32 corpse_id;
1020 // u32 unk4_zero; // 0x00000000
1021 //};
1022 // static_assert( sizeof(PKTOUT_AF) == 13, "size missmatch" );
1023 
1024 // struct PKTOUT_B0
1025 //{
1027 // struct HEADER {
1028 // u8 msgtype;
1029 // u16 msglen;
1030 // u32 serial;
1031 // u32 dialogid;
1032 // u32 x;
1033 // u32 y;
1034 // };
1036 // struct LAYOUT {
1037 // u16 len;
1038 // char text[ 1 ]; // null-terminated
1039 // };
1041 // struct DATA_HEADER {
1042 // u16 numlines;
1043 // };
1045 // struct DATA {
1046 // u16 len;
1047 // char text[ 1 ];
1048 // };
1049 //};
1050 // static_assert( sizeof(PKTOUT_B0::HEADER) == 19, "size missmatch" );
1051 // static_assert( sizeof(PKTOUT_B0::LAYOUT) == 3, "size missmatch" );
1052 // static_assert( sizeof(PKTOUT_B0::DATA_HEADER) == 2, "size missmatch" );
1053 // static_assert( sizeof(PKTOUT_B0::DATA) == 3, "size missmatch" );
1054 
1055 // struct PKTOUT_B7 {
1056 // u8 msgtype;
1057 // u16 msglen;
1058 // u32 serial;
1059 // enum { MAX_CHARACTERS=256 };
1060 // char text[MAX_CHARACTERS*2+2]; // null-terminated unicode string
1061 //};
1062 // static_assert( sizeof(PKTOUT_B7) == 521, "size missmatch" );
1063 
1064 // struct PKTOUT_B9 {
1065 // u8 msgtype;
1066 // u16 enable;
1067 // /*
1068 // if (MSB not set)
1069 // Bit 0 T2A upgrade, enables chatbutton,
1070 // Bit 1 enables LBR update. (of course LBR installation is required)
1071 // (plays MP3 instead of midis, 2D LBR client shows new LBR monsters,)
1072 // if (MSB set)
1073 // Bit 2 T2A upgrade, enables chatbutton,
1074 // Bit 3 enables LBR update.
1075 // Bit 4 enables Age of Shadows update (AoS monsters/map (AOS installation required for that),
1076 // AOS skills/necro/paladin/fight book stuff works for ALL clients 4.0 and above)
1077 // Bit 5 enables use of up to 6 Characters (not only 5)
1078 // Bit 6 enables Samurai Empire update (SE map (SE installation required for that))
1079 // Bit 7 enables Mondain's Legacy update (Elves (ML/Gold installation required for that))
1080 // */
1081 //};
1082 // static_assert( sizeof(PKTOUT_B9) == 3, "size missmatch" );
1083 //
1084 // struct PKTOUT_B9_V2 {
1085 // u8 msgtype;
1086 // u32 enable;
1087 //};
1088 // static_assert( sizeof(PKTOUT_B9_V2) == 5, "size missmatch" );
1089 
1090 // struct PKTOUT_BA {
1091 // u8 msgtype;
1092 // u8 active; enum { ARROW_OFF = 0, ARROW_ON = 1 };
1093 // u16 x_tgt;
1094 // u16 y_tgt;
1095 //};
1096 // static_assert( sizeof(PKTOUT_BA) == 6, "size missmatch" );
1097 
1098 // struct PKTOUT_BC {
1099 // u8 msgtype;
1100 // u8 season; enum { SEASON_SPRING = 0, SEASON_SUMMER, SEASON_FALL, SEASON_WINTER,
1101 // SEASON_DESOLATION };
1102 // u8 playsound; enum { PLAYSOUND_NO = 0, PLAYSOUND_YES = 1 };
1103 //};
1104 // static_assert( sizeof(PKTOUT_BC) == 3, "size missmatch" );
1105 
1106 // Big-Endian for u16/32 unless otherwise noted.
1107 // struct PKTOUT_C0
1108 //{
1109 // u8 msgtype;
1110 // u8 type;
1111 // u32 source_serial;
1112 // u32 target_serial;
1113 // u16 itemid;
1114 // u16 x_source;
1115 // u16 y_source;
1116 // u8 z_source;
1117 // u16 x_target;
1118 // u16 y_target;
1119 // u8 z_target;
1120 // u8 speed;
1121 // u8 duration;
1122 // u16 unk; //On OSI, flamestrikes are 0x0100
1123 // u8 fixed_direction;
1124 // u8 explodes;
1125 // u32 hue;
1126 // u32 render_mode;
1127 // enum {
1128 // EFFECT_MOVING = 0x00,
1129 // EFFECT_LIGHTNING = 0x01,
1130 // EFFECT_FIXEDXYZ = 0x02,
1131 // EFFECT_FIXEDFROM = 0x03
1132 // };
1133 //};
1134 
1135 // Argument example:
1136 // take number 1042762:
1137 //"Only ~1_AMOUNT~ gold could be deposited. A check for ~2_CHECK_AMOUNT~ gold was returned to you."
1138 // the arguments string may have "100 thousand\t25 hundred", which in turn would modify the string:
1139 //"Only 100 thousand gold could be deposited. A check for 25 hundred gold was returned to you."
1140 // Big-Endian for u16/32 unless otherwise noted.
1141 // struct PKTOUT_C1 {
1142 // u8 msgtype;
1143 // u16 msglen;
1144 // u32 serial; //0xFFffFFff for system message
1145 // u16 body; //0xFFff for system message
1146 // u8 type; //6 lower left, 7 on player
1147 // u16 hue;
1148 // u16 font;
1149 // u32 msgnumber;
1150 // char name[30];
1151 // u16 arguments[(SPEECH_MAX_LEN) + 1]; // _little-endian_ Unicode string, tabs ('\t') separate the
1152 // arguments
1153 //};
1154 // static_assert( sizeof( PKTOUT_C1 ) == 450, "size missmatch" );
1155 
1156 // not used:
1157 // Big-Endian for u16/32 unless otherwise noted.
1159 {
1163 };
1164 
1165 // Big-Endian for u16/32 unless otherwise noted.
1166 // struct PKTOUT_C7
1167 //{
1168 // PKTOUT_C0 header;
1169 // u16 effect_num; //see particleffect subdir
1170 // u16 explode_effect_num; //0 if no explosion
1171 // u16 explode_sound_num; //for moving effects, 0 otherwise
1172 // u32 itemid; //if target is item (type 2), 0 otherwise
1173 // u8 layer; //(of the character, e.g left hand, right hand, 0-5,7, 0xff: moving effect or target
1174 // is no char)
1175 // u16 unk_effect; //for moving effect, 0 otherwise
1176 //};
1177 
1178 // Big-Endian for u16/32 unless otherwise noted.
1179 // struct PKTOUT_CC
1180 //{
1181 // u8 msgtype;
1182 // u16 msglen;
1183 // u32 serial; //0xFFffFFff for system message
1184 // u16 body; //0xFFff for system message
1185 // u8 type; //6-lowerleft, 7-on player
1186 // u16 hue;
1187 // u16 font;
1188 // u32 msgnumber;
1189 // u8 flags; //0x2 unk, 0x4 message doesn't move,
1190 // //(flags & 0x1) == 0 signals affix is appended to the localization string, (flags & 0x1) == 1
1191 // signals to prepend.
1192 // char name[30]; //u8 name[32];
1193 // char affix[1]; //nullterminated, uh not just 1 byte
1194 // u16 arguments[1]; // _big-endian_ unicode string, tabs ('\t') seperate arguments, see 0xC1 for
1195 // argument example
1196 //};
1197 
1199 {
1200  u32 header; // bitpacked: TTTTZZZZ UUUUUUUU LLLLLLLL UUUULLLL
1201  // T : numeric type value from 0-2, determines how to process 'data'
1202  // Z : encoded Z offset value used in type 1 and 2, actual Z value translated from table in
1203  // customhouses.cpp
1204  // U : uncompressed length of 'data'
1205  // L : compressed length of 'data'
1206  u8 data[1];
1207 };
1208 
1210 {
1213 };
1214 
1216 {
1218  u16 msglen; // flipped
1219  u8 compressiontype; // 0x03 currently supported for zlib compression type
1220  u8 unk; // usually 0
1222  u32 revision; // incremented whenever content changes
1224  u16 planebuffer_len; // length of remaining packet data
1226 };
1227 
1228 // If send clients request with 0xd6 list
1229 // struct PKTOUT_DC {
1230 // u8 msgtype;
1231 // u32 serial;
1232 // u32 revision;
1233 //};
1234 // static_assert( sizeof(PKTOUT_DC) == 9, "size missmatch" );
1235 
1236 // struct PKTOUT_DD {
1237 // struct HEADER {
1238 // u8 msgtype;
1239 // u16 msglen;
1240 // u32 serial;
1241 // u32 dialog_id;
1242 // u32 dialog_x;
1243 // u32 dialog_y;
1244 // };
1245 // struct LAYOUT {
1246 // u32 layout_clen;
1247 // u32 layout_dlen;
1248 // u8 layout_cdata;
1249 // };
1250 // struct TEXT {
1251 // u32 lines;
1252 // u32 text_clen;
1253 // u32 text_dlen;
1254 // u8 text_cdata;
1255 // };
1256 //};
1257 // static_assert( sizeof(PKTOUT_DD::HEADER) == 19, "size missmatch" );
1258 // static_assert( sizeof(PKTOUT_DD::LAYOUT) == 9, "size missmatch" );
1259 // static_assert( sizeof(PKTOUT_DD::TEXT) == 13, "size missmatch" );
1260 
1261 // struct PKTOUT_E3 {
1262 // u8 msgtype;
1263 // u16 msglen;
1264 // u32 unknown_A_length; // 3 Bytes
1265 // u8 unknown_A[3];
1266 // u32 unknown_B_length; // 19 Bytes
1267 // u8 unknown_B[19];
1268 // u32 unknown_C_length; // 16 Bytes
1269 // u8 unknown_C[16];
1270 // u32 unknown_D;
1271 // u32 unknown_E_length; // 16 Bytes
1272 // u8 unknown_E[16];
1273 //};
1274 // static_assert( sizeof(PKTOUT_E3) == 77, "size missmatch" );
1275 
1276 // struct PKTOUT_F3 {
1277 // u8 msgtype;
1278 // u16 unknown; // always 0x1
1279 // u8 datatype; // 0x00 for item and 0x02 for multi
1280 // u32 serial;
1281 // u16 graphic;
1282 // u8 facing; // 0x00 if multi
1283 // u16 amount; // 0x1 if multi
1284 // u16 amount_2; // 0x1 if multi
1285 // u16 x;
1286 // u16 y;
1287 // u8 z;
1288 // u8 layer; // 0x00 if multi
1289 // u16 color; // 0x00 if multi
1290 // u8 flags; // 0x00 if multi
1291 //};
1292 // static_assert( sizeof(PKTOUT_F3) == 24, "size missmatch" );
1293 
1294 #pragma pack( pop )
1295 }
1296 }
1297 
1298 #endif
unsigned char u8
Definition: rawtypes.h:25
TileData * tiledata
Definition: uofile01.cpp:32
unsigned short u16
Definition: rawtypes.h:26
unsigned char buffer[10000]
Definition: UoToolMain.cpp:109
unsigned int u32
Definition: rawtypes.h:27
signed char s8
Definition: rawtypes.h:29
std::unordered_map< u64, ScriptDiffData > data
Definition: osmod.cpp:966
std::string name
Definition: osmod.cpp:943
Definition: berror.cpp:12