Starshatter_Open
Open source Starshatter engine
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
NetData.h
Go to the documentation of this file.
1 /* Project Starshatter 4.5
2  Destroyer Studios LLC
3  Copyright © 1997-2004. All Rights Reserved.
4 
5  SUBSYSTEM: Stars.exe
6  FILE: NetData.h
7  AUTHOR: John DiCamillo
8 
9 
10  OVERVIEW
11  ========
12  Payload structures for multiplayer network packets
13 */
14 
15 #ifndef NetData_h
16 #define NetData_h
17 
18 #include "Types.h"
19 #include "Geometry.h"
20 #include "Text.h"
21 
22 // +--------------------------------------------------------------------+
23 
24 // UNRELIABLE: 0x01 - 0x0F
25 
26 const BYTE NET_PING = 0x01;
27 const BYTE NET_PONG = 0x02;
28 const BYTE NET_OBJ_LOC = 0x03;
29 
30 // RELIABLE: 0x10 - 0x7F
31 
32 const BYTE NET_JOIN_REQUEST = 0x10;
33 const BYTE NET_JOIN_ANNOUNCE = 0x11;
34 const BYTE NET_QUIT_REQUEST = 0x12;
35 const BYTE NET_QUIT_ANNOUNCE = 0x13;
36 const BYTE NET_KICK_REQUEST = 0x14;
37 const BYTE NET_KICK_ANNOUNCE = 0x15;
38 const BYTE NET_GAME_OVER = 0x16;
39 const BYTE NET_COMM_MESSAGE = 0x17;
40 const BYTE NET_CHAT_MESSAGE = 0x18;
41 const BYTE NET_DISCONNECT = 0x19;
42 
43 const BYTE NET_OBJ_DAMAGE = 0x20;
44 const BYTE NET_OBJ_KILL = 0x21;
45 const BYTE NET_OBJ_SPAWN = 0x22;
46 const BYTE NET_OBJ_HYPER = 0x23;
47 const BYTE NET_OBJ_TARGET = 0x24;
48 const BYTE NET_OBJ_EMCON = 0x25;
49 const BYTE NET_SYS_DAMAGE = 0x26;
50 const BYTE NET_SYS_STATUS = 0x27;
51 
52 const BYTE NET_ELEM_CREATE = 0x28;
53 const BYTE NET_SHIP_LAUNCH = 0x29;
54 const BYTE NET_NAV_DATA = 0x2A;
55 const BYTE NET_NAV_DELETE = 0x2B;
56 const BYTE NET_ELEM_REQUEST = 0x2C;
57 
58 const BYTE NET_WEP_TRIGGER = 0x30;
59 const BYTE NET_WEP_RELEASE = 0x31;
60 const BYTE NET_WEP_DESTROY = 0x32;
61 
62 const BYTE NET_SELF_DESTRUCT = 0x3F;
63 
64 // +--------------------------------------------------------------------+
65 
66 class Ship;
67 
68 // +--------------------------------------------------------------------+
69 
70 class NetData
71 {
72 public:
73  static const char* TYPENAME() { return "NetData"; }
74 
75  NetData() { }
76  virtual ~NetData() { }
77 
78  virtual int Type() const { return 0; }
79  virtual int Length() const { return 0; }
80  virtual BYTE* Pack() { return 0; }
81  virtual bool Unpack(const BYTE* data) { return 0; }
82 
83  virtual DWORD GetObjID() const { return 0; }
84  virtual void SetObjID(DWORD o) { }
85 };
86 
87 // +--------------------------------------------------------------------+
88 
89 class NetObjLoc : public NetData
90 {
91 public:
92  static const char* TYPENAME() { return "NetObjLoc"; }
93 
94  NetObjLoc() : objid(0), throttle(false), augmenter(false), shield(0) { }
95  NetObjLoc(DWORD oid, const Point& pos, const Point& orient, const Point& vel) :
96  objid(oid), location(pos), euler(orient), velocity(vel),
97  throttle(false), augmenter(false), gear(false), shield(0) { }
98 
99  enum { TYPE=NET_OBJ_LOC, SIZE=24 };
100 
101  virtual BYTE* Pack();
102  virtual bool Unpack(const BYTE* data);
103  virtual int Type() const { return TYPE; }
104  virtual int Length() const { return SIZE; }
105 
106  virtual DWORD GetObjID() const { return objid; }
107  virtual void SetObjID(DWORD id) { objid = id; }
108 
109  Point GetLocation() const { return location; }
110  Point GetVelocity() const { return velocity; }
111  Point GetOrientation() const { return euler; }
112  bool GetThrottle() const { return throttle; }
113  bool GetAugmenter() const { return augmenter; }
114  bool GetGearDown() const { return gear; }
115  int GetShield() const { return shield; }
116 
117  void SetLocation(const Point& loc) { location = loc; }
118  void SetVelocity(const Point& v) { velocity = v; }
119  void SetOrientation(const Point& o) { euler = o; }
120  void SetThrottle(bool t) { throttle = t; }
121  void SetAugmenter(bool a) { augmenter = a; }
122  void SetGearDown(bool g) { gear = g; }
123  void SetShield(int s) { shield = s; }
124 
125 private:
126  DWORD objid;
127  Point location;
128  Point velocity;
129  Point euler;
130  bool throttle;
131  bool augmenter;
132  bool gear;
133  int shield;
134 
135  BYTE data[SIZE];
136 };
137 
138 // +--------------------------------------------------------------------+
139 
140 class NetJoinRequest : public NetData
141 {
142 public:
143  static const char* TYPENAME() { return "NetJoinRequest"; }
144 
145  NetJoinRequest() : index(0) { }
146 
147  enum { TYPE=NET_JOIN_REQUEST, SIZE=128 };
148 
149  virtual BYTE* Pack();
150  virtual bool Unpack(const BYTE* data);
151  virtual int Type() const { return TYPE; }
152  virtual int Length() const { return SIZE; }
153 
154  const char* GetName() const { return name; }
155  const char* GetPassword() const { return pass; }
156  const char* GetSerialNumber() const { return serno; }
157  const char* GetElement() const { return elem; }
158  int GetIndex() const { return index; }
159 
160  void SetName(const char* n) { name = n; }
161  void SetPassword(const char* p) { pass = p; }
162  void SetSerialNumber(const char* s){ serno = s; }
163  void SetElement(const char* n) { elem = n; }
164  void SetIndex(int n) { index = n; }
165 
166 private:
167  Text name; // callsign
168  Text pass; // password
169  Text serno; // box cdkey
170  Text elem; // element to join
171  int index; // one-based index
172 
173  BYTE data[SIZE];
174 };
175 
176 // +--------------------------------------------------------------------+
177 
178 class NetJoinAnnounce : public NetData
179 {
180 public:
181  static const char* TYPENAME() { return "NetJoinAnnounce"; }
182 
183  NetJoinAnnounce();
184 
185  enum { TYPE=NET_JOIN_ANNOUNCE, SIZE=200 };
186 
187  virtual BYTE* Pack();
188  virtual bool Unpack(const BYTE* data);
189  virtual int Type() const { return TYPE; }
190  virtual int Length() const { return SIZE; }
191 
192  virtual DWORD GetObjID() const { return objid; }
193  virtual void SetObjID(DWORD o) { objid = o; }
194 
195  const char* GetName() const { return name; }
196  const char* GetElement() const { return elem; }
197  const char* GetRegion() const { return region; }
198  const Point& GetLocation() const { return loc; }
199  const Point& GetVelocity() const { return velocity; }
200  int GetIndex() const { return index; }
201  double GetIntegrity() const { return integrity; }
202  int GetRespawns() const { return respawns; }
203  int GetDecoys() const { return decoys; }
204  int GetProbes() const { return probes; }
205  int GetFuel() const { return fuel; }
206  int GetShield() const { return shield; }
207  const int* GetAmmo() const { return ammo; }
208 
209  void SetShip(Ship* s);
210 
211  void SetName(const char* n) { name = n; }
212  void SetElement(const char* n) { elem = n; }
213  void SetRegion(const char* r) { region = r; }
214  void SetLocation(const Point& l) { loc = l; }
215  void SetVelocity(const Point& v) { velocity = v; }
216  void SetIndex(int n) { index = n; }
217  void SetIntegrity(double n) { integrity = (float) n; }
218  void SetRespawns(int n) { respawns = n; }
219  void SetDecoys(int n) { decoys = n; }
220  void SetProbes(int n) { probes = n; }
221  void SetFuel(int n) { fuel = n; }
222  void SetShield(int n) { shield = n; }
223  void SetAmmo(const int* a);
224 
225  virtual DWORD GetNetID() const { return nid; }
226  virtual void SetNetID(DWORD n) { nid = n; }
227 
228 private:
229  Text name; // callsign
230  Text elem; // element to join
231  Text region; // region ship is in
232  Point loc; // location of ship
233  Point velocity; // velocity of ship
234  int index; // one-based index
235  float integrity; // hull integrity
236  int respawns;
237  int decoys;
238  int probes;
239  int fuel;
240  int shield;
241  int ammo[16];
242  DWORD objid;
243  DWORD nid; // not sent over network
244 
245  BYTE data[SIZE];
246 };
247 
248 // +--------------------------------------------------------------------+
249 
250 class NetQuitAnnounce : public NetData
251 {
252 public:
253  static const char* TYPENAME() { return "NetQuitAnnounce"; }
254 
255  NetQuitAnnounce() : objid(0), disconnected(false) { }
256 
257  enum { TYPE=NET_QUIT_ANNOUNCE, SIZE=5 };
258 
259  virtual BYTE* Pack();
260  virtual bool Unpack(const BYTE* data);
261  virtual int Type() const { return TYPE; }
262  virtual int Length() const { return SIZE; }
263 
264  virtual DWORD GetObjID() const { return objid; }
265  virtual void SetObjID(DWORD o) { objid = o; }
266  virtual bool GetDisconnected() const { return disconnected; }
267  virtual void SetDisconnected(bool d) { disconnected = d; }
268 
269 private:
270  DWORD objid;
271  bool disconnected;
272 
273  BYTE data[SIZE];
274 };
275 
276 // +--------------------------------------------------------------------+
277 
278 class NetDisconnect : public NetData
279 {
280 public:
281  static const char* TYPENAME() { return "NetDisconnect"; }
282 
283  NetDisconnect() { }
284 
285  enum { TYPE=NET_DISCONNECT, SIZE=2 };
286 
287  virtual BYTE* Pack();
288  virtual bool Unpack(const BYTE* data);
289  virtual int Type() const { return TYPE; }
290  virtual int Length() const { return SIZE; }
291 
292 private:
293  BYTE data[SIZE];
294 };
295 
296 // +--------------------------------------------------------------------+
297 
298 class NetObjDamage : public NetData
299 {
300 public:
301  static const char* TYPENAME() { return "NetObjDamage"; }
302 
303  NetObjDamage() : objid(0), damage(0), shotid(0) { }
304 
305  enum { TYPE=NET_OBJ_DAMAGE, SIZE=12 };
306 
307  virtual BYTE* Pack();
308  virtual bool Unpack(const BYTE* data);
309  virtual int Type() const { return TYPE; }
310  virtual int Length() const { return SIZE; }
311 
312  virtual DWORD GetObjID() const { return objid; }
313  virtual void SetObjID(DWORD o) { objid = o; }
314 
315  virtual DWORD GetShotID() const { return shotid; }
316  virtual void SetShotID(DWORD o) { shotid = o; }
317 
318  float GetDamage() const { return damage; }
319  void SetDamage(float d) { damage = d; }
320 
321 private:
322  DWORD objid;
323  float damage;
324  DWORD shotid;
325 
326  BYTE data[SIZE];
327 };
328 
329 // +--------------------------------------------------------------------+
330 
331 class NetObjKill : public NetData
332 {
333 public:
334  static const char* TYPENAME() { return "NetObjKill"; }
335 
336  NetObjKill() : objid(0), kill_id(0), killtype(0), respawn(false), deck(0) { }
337 
338  enum { TYPE=NET_OBJ_KILL, SIZE=24,
339  KILL_MISC = 0,
340  KILL_PRIMARY,
341  KILL_SECONDARY,
342  KILL_COLLISION,
343  KILL_CRASH,
344  KILL_DOCK
345  };
346 
347  virtual BYTE* Pack();
348  virtual bool Unpack(const BYTE* data);
349  virtual int Type() const { return TYPE; }
350  virtual int Length() const { return SIZE; }
351 
352  virtual DWORD GetObjID() const { return objid; }
353  virtual void SetObjID(DWORD o) { objid = o; }
354  virtual DWORD GetKillerID() const { return kill_id; }
355  virtual void SetKillerID(DWORD o) { kill_id = o; }
356  virtual int GetKillType() const { return killtype;}
357  virtual void SetKillType(int t) { killtype = t; }
358  virtual bool GetRespawn() const { return respawn; }
359  virtual void SetRespawn(bool r) { respawn = r; }
360  virtual Point GetRespawnLoc() const { return loc; }
361  virtual void SetRespawnLoc(const Point& p) { loc = p; }
362  virtual int GetFlightDeck() const { return deck; }
363  virtual void SetFlightDeck(int n) { deck = n; }
364 
365 private:
366  DWORD objid;
367  DWORD kill_id;
368  int killtype;
369  bool respawn;
370  Point loc;
371  int deck;
372 
373  BYTE data[SIZE];
374 };
375 
376 // +--------------------------------------------------------------------+
377 
378 class NetObjHyper : public NetData
379 {
380 public:
381  static const char* TYPENAME() { return "NetObjHyper"; }
382 
383  NetObjHyper() : objid(0), fc_src(0), fc_dst(0), transtype(0) { }
384 
385  enum { TYPE=NET_OBJ_HYPER, SIZE=56 };
386 
387  virtual BYTE* Pack();
388  virtual bool Unpack(const BYTE* data);
389  virtual int Type() const { return TYPE; }
390  virtual int Length() const { return SIZE; }
391 
392  virtual DWORD GetObjID() const { return objid; }
393  virtual void SetObjID(DWORD id) { objid = id; }
394 
395  const Point& GetLocation() const { return location; }
396  const Text& GetRegion() const { return region; }
397  DWORD GetFarcaster1() const { return fc_src; }
398  DWORD GetFarcaster2() const { return fc_dst; }
399  int GetTransitionType() const { return transtype; }
400 
401  void SetLocation(const Point& loc) { location = loc; }
402  void SetRegion(const char* rgn) { region = rgn; }
403  void SetFarcaster1(DWORD f) { fc_src = f; }
404  void SetFarcaster2(DWORD f) { fc_dst = f; }
405  void SetTransitionType(int t) { transtype = t; }
406 
407 private:
408  DWORD objid;
409  Point location;
410  Text region;
411  DWORD fc_src;
412  DWORD fc_dst;
413  int transtype;
414 
415  BYTE data[SIZE];
416 };
417 
418 // +--------------------------------------------------------------------+
419 
420 class NetObjTarget : public NetData
421 {
422 public:
423  static const char* TYPENAME() { return "NetObjTarget"; }
424 
425  NetObjTarget() : objid(0), tgtid(0), sysix(0) { }
426 
427  enum { TYPE=NET_OBJ_TARGET, SIZE=7 };
428 
429  virtual BYTE* Pack();
430  virtual bool Unpack(const BYTE* data);
431  virtual int Type() const { return TYPE; }
432  virtual int Length() const { return SIZE; }
433 
434  virtual DWORD GetObjID() const { return objid; }
435  virtual void SetObjID(DWORD o) { objid = o; }
436 
437  DWORD GetTgtID() const { return tgtid; }
438  void SetTgtID(DWORD o) { tgtid = o; }
439  int GetSubtarget() const { return sysix; }
440  void SetSubtarget(int n) { sysix = n; }
441 
442 private:
443  DWORD objid;
444  DWORD tgtid;
445  int sysix;
446 
447  BYTE data[SIZE];
448 };
449 
450 // +--------------------------------------------------------------------+
451 
452 class NetObjEmcon : public NetData
453 {
454 public:
455  static const char* TYPENAME() { return "NetObjEmcon"; }
456 
457  NetObjEmcon() : objid(0), emcon(0) { }
458 
459  enum { TYPE=NET_OBJ_EMCON, SIZE=5 };
460 
461  virtual BYTE* Pack();
462  virtual bool Unpack(const BYTE* data);
463  virtual int Type() const { return TYPE; }
464  virtual int Length() const { return SIZE; }
465 
466  virtual DWORD GetObjID() const { return objid; }
467  virtual void SetObjID(DWORD o) { objid = o; }
468 
469  int GetEMCON() const { return emcon; }
470  void SetEMCON(int n) { emcon = n; }
471 
472 private:
473  DWORD objid;
474  int emcon;
475 
476  BYTE data[SIZE];
477 };
478 
479 // +--------------------------------------------------------------------+
480 
481 class NetSysDamage : public NetData
482 {
483 public:
484  static const char* TYPENAME() { return "NetSysDamage"; }
485 
486  NetSysDamage() : objid(0), sysix(-1), dmgtype(0), damage(0) { }
487 
488  enum { TYPE=NET_SYS_DAMAGE, SIZE=12 };
489 
490  virtual BYTE* Pack();
491  virtual bool Unpack(const BYTE* data);
492  virtual int Type() const { return TYPE; }
493  virtual int Length() const { return SIZE; }
494 
495  virtual DWORD GetObjID() const { return objid; }
496  virtual void SetObjID(DWORD o) { objid = o; }
497 
498  int GetSystem() const { return sysix; }
499  void SetSystem(int n) { sysix = n; }
500  BYTE GetDamageType() const { return dmgtype; }
501  void SetDamageType(BYTE t) { dmgtype = t; }
502  double GetDamage() const { return damage; }
503  void SetDamage(double d) { damage = d; }
504 
505 private:
506  DWORD objid;
507  int sysix;
508  BYTE dmgtype;
509  double damage;
510 
511  BYTE data[SIZE];
512 };
513 
514 // +--------------------------------------------------------------------+
515 
516 class NetSysStatus : public NetData
517 {
518 public:
519  static const char* TYPENAME() { return "NetSysStatus"; }
520 
521  NetSysStatus() : objid(0), sysix(-1), status(0), power(0), reactor(0),
522  avail(1) { }
523 
524  enum { TYPE=NET_SYS_STATUS, SIZE=12 };
525 
526  virtual BYTE* Pack();
527  virtual bool Unpack(const BYTE* data);
528  virtual int Type() const { return TYPE; }
529  virtual int Length() const { return SIZE; }
530 
531  virtual DWORD GetObjID() const { return objid; }
532  virtual void SetObjID(DWORD o) { objid = o; }
533 
534  int GetSystem() const { return sysix; }
535  void SetSystem(int n) { sysix = n; }
536  BYTE GetStatus() const { return status; }
537  void SetStatus(BYTE s) { status = s; }
538  int GetPower() const { return power; }
539  void SetPower(int n) { power = n; }
540  int GetReactor() const { return reactor; }
541  void SetReactor(int n) { reactor = n; }
542  double GetAvailability() const { return avail; }
543  void SetAvailablility(double a) { avail = a; }
544 
545 private:
546  DWORD objid;
547  int sysix;
548  int status;
549  int power;
550  int reactor;
551  double avail;
552 
553  BYTE data[SIZE];
554 };
555 
556 // +--------------------------------------------------------------------+
557 
558 class NetWepTrigger : public NetData
559 {
560 public:
561  static const char* TYPENAME() { return "NetWepTrigger"; }
562 
563  NetWepTrigger() : objid(0), tgtid(0), sysix(-1), index(0), count(0),
564  decoy(false), probe(false) { }
565 
566  enum { TYPE=NET_WEP_TRIGGER, SIZE=10 };
567 
568  virtual BYTE* Pack();
569  virtual bool Unpack(const BYTE* data);
570  virtual int Type() const { return TYPE; }
571  virtual int Length() const { return SIZE; }
572 
573  virtual DWORD GetObjID() const { return objid; }
574  virtual void SetObjID(DWORD o) { objid = o; }
575 
576  DWORD GetTgtID() const { return tgtid; }
577  void SetTgtID(DWORD o) { tgtid = o; }
578  int GetSubtarget() const { return sysix; }
579  void SetSubtarget(int n) { sysix = n; }
580  int GetIndex() const { return index; }
581  void SetIndex(int n) { index = n; }
582  int GetCount() const { return count; }
583  void SetCount(int n) { count = n; }
584  bool GetDecoy() const { return decoy; }
585  void SetDecoy(bool d) { decoy = d; }
586  bool GetProbe() const { return probe; }
587  void SetProbe(bool p) { probe = p; }
588 
589 private:
590  DWORD objid;
591  DWORD tgtid;
592  int sysix;
593  int index;
594  int count;
595  bool decoy;
596  bool probe;
597 
598  BYTE data[SIZE];
599 };
600 
601 // +--------------------------------------------------------------------+
602 
603 class NetWepRelease : public NetData
604 {
605 public:
606  static const char* TYPENAME() { return "NetWepRelease"; }
607 
608  NetWepRelease() : objid(0), tgtid(0), wepid(0), sysix(-1), index(0),
609  decoy(false), probe(false) { }
610 
611  enum { TYPE=NET_WEP_RELEASE, SIZE=11 };
612 
613  virtual BYTE* Pack();
614  virtual bool Unpack(const BYTE* data);
615  virtual int Type() const { return TYPE; }
616  virtual int Length() const { return SIZE; }
617 
618  virtual DWORD GetObjID() const { return objid; }
619  virtual void SetObjID(DWORD o) { objid = o; }
620 
621  DWORD GetTgtID() const { return tgtid; }
622  void SetTgtID(DWORD o) { tgtid = o; }
623  int GetSubtarget() const { return sysix; }
624  void SetSubtarget(int n) { sysix = n; }
625  DWORD GetWepID() const { return wepid; }
626  void SetWepID(DWORD o) { wepid = o; }
627  int GetIndex() const { return index; }
628  void SetIndex(int n) { index = n; }
629  bool GetDecoy() const { return decoy; }
630  void SetDecoy(bool d) { decoy = d; }
631  bool GetProbe() const { return probe; }
632  void SetProbe(bool p) { probe = p; }
633 
634 private:
635  DWORD objid;
636  DWORD tgtid;
637  DWORD wepid;
638  int sysix;
639  int index;
640  bool decoy;
641  bool probe;
642 
643  BYTE data[SIZE];
644 };
645 
646 // +--------------------------------------------------------------------+
647 
648 class NetWepDestroy : public NetData
649 {
650 public:
651  static const char* TYPENAME() { return "NetWepDestroy"; }
652 
653  NetWepDestroy() : objid(0) { }
654 
655  enum { TYPE=NET_WEP_DESTROY, SIZE=4 };
656 
657  virtual BYTE* Pack();
658  virtual bool Unpack(const BYTE* data);
659  virtual int Type() const { return TYPE; }
660  virtual int Length() const { return SIZE; }
661 
662  virtual DWORD GetObjID() const { return objid; }
663  virtual void SetObjID(DWORD o) { objid = o; }
664 
665 private:
666  DWORD objid;
667 
668  BYTE data[SIZE];
669 };
670 
671 // +--------------------------------------------------------------------+
672 
673 class RadioMessage;
674 class NetCommMsg : public NetData
675 {
676 public:
677  static const char* TYPENAME() { return "NetCommMsg"; }
678 
679  NetCommMsg() : objid(0), radio_message(0), length(0) { }
680  virtual ~NetCommMsg();
681 
682  enum { TYPE=NET_COMM_MESSAGE, SIZE=200 };
683 
684  virtual BYTE* Pack();
685  virtual bool Unpack(const BYTE* data);
686  virtual int Type() const { return TYPE; }
687  virtual int Length() const { return length; }
688 
689  virtual DWORD GetObjID() const { return objid; }
690  virtual void SetObjID(DWORD o) { objid = o; }
691 
692  RadioMessage* GetRadioMessage() { return radio_message; }
693  void SetRadioMessage(RadioMessage* m);
694 
695 private:
696  DWORD objid;
697  RadioMessage* radio_message;
698 
699  int length;
700  BYTE data[SIZE];
701 };
702 
703 // +--------------------------------------------------------------------+
704 
705 class NetChatMsg : public NetData
706 {
707 public:
708  static const char* TYPENAME() { return "NetChatMsg"; }
709 
710  NetChatMsg() : dstid(0), length(0) { }
711 
712  enum { TYPE=NET_CHAT_MESSAGE, SIZE=210, MAX_CHAT=160, HDR_LEN=4, NAME_LEN=32 };
713 
714  virtual BYTE* Pack();
715  virtual bool Unpack(const BYTE* data);
716  virtual int Type() const { return TYPE; }
717  virtual int Length() const { return length; }
718 
719  virtual DWORD GetDstID() const { return dstid; }
720  virtual void SetDstID(DWORD d) { dstid = d; }
721  const Text& GetName() const { return name; }
722  void SetName(const char* m) { name = m; }
723  const Text& GetText() const { return text; }
724  void SetText(const char* m) { text = m; }
725 
726 private:
727  DWORD dstid;
728  Text name;
729  Text text;
730 
731  int length;
732  BYTE data[SIZE];
733 };
734 
735 // +--------------------------------------------------------------------+
736 
737 class NetElemRequest : public NetData
738 {
739 public:
740  static const char* TYPENAME() { return "NetElemRequest"; }
741 
742  NetElemRequest();
743 
744  enum { TYPE=NET_ELEM_REQUEST, SIZE=64, NAME_LEN=32 };
745 
746  virtual BYTE* Pack();
747  virtual bool Unpack(const BYTE* data);
748  virtual int Type() const { return TYPE; }
749  virtual int Length() const { return SIZE; }
750 
751  const Text& GetName() const { return name; }
752  void SetName(const char* m) { name = m; }
753 
754 private:
755  Text name;
756 
757  BYTE data[SIZE];
758 };
759 
760 // +--------------------------------------------------------------------+
761 
762 class NetElemCreate : public NetData
763 {
764 public:
765  static const char* TYPENAME() { return "NetElemCreate"; }
766 
767  NetElemCreate();
768 
769  enum { TYPE=NET_ELEM_CREATE, SIZE=192, NAME_LEN=32 };
770 
771  virtual BYTE* Pack();
772  virtual bool Unpack(const BYTE* data);
773  virtual int Type() const { return TYPE; }
774  virtual int Length() const { return SIZE; }
775 
776  const Text& GetName() const { return name; }
777  void SetName(const char* m) { name = m; }
778  const Text& GetCommander() const { return commander; }
779  void SetCommander(const char* m) { commander = m; }
780  const Text& GetObjective() const { return objective; }
781  void SetObjective(const char* m) { objective = m; }
782  const Text& GetCarrier() const { return carrier; }
783  void SetCarrier(const char* m) { carrier = m; }
784 
785  int GetIFF() const { return iff; }
786  void SetIFF(int n) { iff = n; }
787  int GetType() const { return type; }
788  void SetType(int n) { type = n; }
789  int GetIntel() const { return intel; }
790  void SetIntel(int n) { intel = n; }
791  int GetObjCode() const { return obj_code; }
792  void SetObjCode(int n) { obj_code = n; }
793  int GetSquadron() const { return squadron; }
794  void SetSquadron(int n) { squadron = n; }
795 
796  int* GetLoadout() { return load; }
797  void SetLoadout(int* n);
798  int* GetSlots() { return slots; }
799  void SetSlots(int* n);
800 
801  bool GetAlert() const { return alert; }
802  void SetAlert(bool a) { alert = a; }
803 
804  bool GetInFlight() const { return in_flight; }
805  void SetInFlight(bool f) { in_flight = f; }
806 
807 private:
808  Text name;
809  int iff;
810  int type;
811  int intel;
812  int obj_code;
813  int squadron;
814 
815  Text commander;
816  Text objective;
817  Text carrier;
818 
819  int load[16];
820  int slots[4];
821  bool alert;
822  bool in_flight;
823 
824  BYTE data[SIZE];
825 };
826 
827 // +--------------------------------------------------------------------+
828 
829 class NetShipLaunch : public NetData
830 {
831 public:
832  static const char* TYPENAME() { return "NetShipLaunch"; }
833 
834  NetShipLaunch() : objid(0), squadron(0), slot(0) { }
835 
836  enum { TYPE=NET_SHIP_LAUNCH, SIZE=16 };
837 
838  virtual BYTE* Pack();
839  virtual bool Unpack(const BYTE* data);
840  virtual int Type() const { return TYPE; }
841  virtual int Length() const { return SIZE; }
842 
843  virtual DWORD GetObjID() const { return objid; }
844  virtual int GetSquadron() const { return squadron; }
845  virtual int GetSlot() const { return slot; }
846 
847  virtual void SetObjID(DWORD o) { objid = o; }
848  virtual void SetSquadron(int s) { squadron = s; }
849  virtual void SetSlot(int s) { slot = s; }
850 
851 private:
852  DWORD objid;
853  int squadron;
854  int slot;
855 
856  BYTE data[SIZE];
857 };
858 
859 // +--------------------------------------------------------------------+
860 
861 class Instruction;
862 
863 class NetNavData : public NetData
864 {
865 public:
866  static const char* TYPENAME() { return "NetNavData"; }
867 
868  NetNavData();
869  virtual ~NetNavData();
870 
871  enum { TYPE=NET_NAV_DATA, SIZE=144, NAME_LEN=32 };
872 
873  virtual BYTE* Pack();
874  virtual bool Unpack(const BYTE* data);
875  virtual int Type() const { return TYPE; }
876  virtual int Length() const { return SIZE; }
877 
878  virtual DWORD GetObjID() const { return objid; }
879  bool IsAdd() const { return create; }
880  bool IsEdit() const { return !create; }
881  const Text& GetElem() const { return elem; }
882  int GetIndex() const { return index; }
883  Instruction* GetNavPoint() const { return navpoint; }
884 
885  virtual void SetObjID(DWORD o) { objid = o; }
886  void SetAdd(bool b) { create = b; }
887  void SetElem(const char* e) { elem = e; }
888  void SetIndex(int n) { index = n; }
889  void SetNavPoint(Instruction* n);
890 
891 private:
892  DWORD objid;
893  bool create;
894  Text elem;
895  int index;
896  Instruction* navpoint;
897 
898  BYTE data[SIZE];
899 };
900 
901 // +--------------------------------------------------------------------+
902 
903 class NetNavDelete : public NetData
904 {
905 public:
906  static const char* TYPENAME() { return "NetNavDelete"; }
907 
908  NetNavDelete() : objid(0), index(0) { }
909 
910  enum { TYPE=NET_NAV_DELETE, SIZE=40 };
911 
912  virtual BYTE* Pack();
913  virtual bool Unpack(const BYTE* data);
914  virtual int Type() const { return TYPE; }
915  virtual int Length() const { return SIZE; }
916 
917  virtual DWORD GetObjID() const { return objid; }
918  const Text& GetElem() const { return elem; }
919  int GetIndex() const { return index; }
920 
921  virtual void SetObjID(DWORD o) { objid = o; }
922  void SetElem(const char* e) { elem = e; }
923  void SetIndex(int n) { index = n; }
924 
925 private:
926  DWORD objid;
927  Text elem;
928  int index;
929 
930  BYTE data[SIZE];
931 };
932 
933 // +--------------------------------------------------------------------+
934 
935 class NetSelfDestruct : public NetData
936 {
937 public:
938  static const char* TYPENAME() { return "NetSelfDestruct"; }
939 
940  NetSelfDestruct() : objid(0), damage(0) { }
941 
942  enum { TYPE=NET_SELF_DESTRUCT, SIZE=8 };
943 
944  virtual BYTE* Pack();
945  virtual bool Unpack(const BYTE* data);
946  virtual int Type() const { return TYPE; }
947  virtual int Length() const { return SIZE; }
948 
949  virtual DWORD GetObjID() const { return objid; }
950  virtual void SetObjID(DWORD o) { objid = o; }
951 
952  float GetDamage() const { return damage; }
953  void SetDamage(float d) { damage = d; }
954 
955 private:
956  DWORD objid;
957  float damage;
958 
959  BYTE data[SIZE];
960 };
961 
962 
963 // +--------------------------------------------------------------------+
964 
965 #endif NetData_h
966