From 8898ad9b25fca6afe2374d293a981db02a83d7e9 Mon Sep 17 00:00:00 2001 From: "FWoltermann@gmail.com" Date: Thu, 31 May 2012 14:46:27 +0000 Subject: Committing the documentation to svn to have it accessible online --- Doc/doxygen/html/_net_data_8h_source.html | 1083 +++++++++++++++++++++++++++++ 1 file changed, 1083 insertions(+) create mode 100644 Doc/doxygen/html/_net_data_8h_source.html (limited to 'Doc/doxygen/html/_net_data_8h_source.html') diff --git a/Doc/doxygen/html/_net_data_8h_source.html b/Doc/doxygen/html/_net_data_8h_source.html new file mode 100644 index 0000000..331c6c7 --- /dev/null +++ b/Doc/doxygen/html/_net_data_8h_source.html @@ -0,0 +1,1083 @@ + + + + + +Starshatter_Open: D:/SRC/StarshatterSVN/Stars45/NetData.h Source File + + + + + + + + + + + + + +
+
+ + + + + + +
+
Starshatter_Open +
+
Open source Starshatter engine
+
+
+ + + + + +
+
+ +
+
+
+ +
+ + + + +
+ +
+ +
+
+
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 
+
+
+ + + + -- cgit v1.1