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_8cpp_source.html | 1570 +++++++++++++++++++++++++++ 1 file changed, 1570 insertions(+) create mode 100644 Doc/doxygen/html/_net_data_8cpp_source.html (limited to 'Doc/doxygen/html/_net_data_8cpp_source.html') diff --git a/Doc/doxygen/html/_net_data_8cpp_source.html b/Doc/doxygen/html/_net_data_8cpp_source.html new file mode 100644 index 0000000..74d6982 --- /dev/null +++ b/Doc/doxygen/html/_net_data_8cpp_source.html @@ -0,0 +1,1570 @@ + + + + + +Starshatter_Open: D:/SRC/StarshatterSVN/Stars45/NetData.cpp Source File + + + + + + + + + + + + + +
+
+ + + + + + +
+
Starshatter_Open +
+
Open source Starshatter engine
+
+
+ + + + + +
+
+ +
+
+
+ +
+ + + + +
+ +
+ +
+
+
NetData.cpp
+
+
+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.cpp
+
7  AUTHOR: John DiCamillo
+
8 
+
9 
+
10  OVERVIEW
+
11  ========
+
12  Payload structures for multiplayer network packets
+
13 */
+
14 
+
15 #include "MemDebug.h"
+
16 #include "NetData.h"
+
17 #include "NetLink.h"
+
18 #include "NetMsg.h"
+
19 #include "RadioMessage.h"
+
20 #include "Ship.h"
+
21 #include "Shot.h"
+
22 #include "Sim.h"
+
23 #include "Instruction.h"
+
24 #include "Weapon.h"
+
25 #include "Element.h"
+
26 #include "System.h"
+
27 #include "Power.h"
+
28 #include "Shield.h"
+
29 
+
30 #include "Game.h"
+
31 
+
32 // +--------------------------------------------------------------------+
+
33 // DATA SIZE OFFSET
+
34 // -------- ----------------- ---------
+
35 // type: 1 0
+
36 // size: 1 1
+
37 // objid: 2 2
+
38 // loc: 9 (3 x 24 bits) 4
+
39 // vel: 6 (3 x 16 bits) 13
+
40 // euler: 4 (3 x 10 bits) 19
+
41 // status: 1 23
+
42 
+
43 const int LOCATION_OFFSET = 8000000;
+
44 const int VELOCITY_OFFSET = 32000;
+
45 const double EULER_SCALE = 2*PI / (1<<10);
+
46 
+
47 BYTE*
+
48 NetObjLoc::Pack()
+
49 {
+
50  data[ 0] = TYPE;
+
51  data[ 1] = SIZE;
+
52 
+
53  // obj id
+
54  data[ 2] = (BYTE) ((objid & 0xff00) >> 8);
+
55  data[ 3] = (BYTE) ((objid & 0x00ff) );
+
56 
+
57  // location
+
58  DWORD x = (DWORD) (((int) location.x + LOCATION_OFFSET) & 0x00ffffff);
+
59  DWORD y = (DWORD) (((int) location.y + LOCATION_OFFSET) & 0x00ffffff);
+
60  DWORD z = (DWORD) (((int) location.z + LOCATION_OFFSET) & 0x00ffffff);
+
61 
+
62  data[ 4] = (BYTE) ((x & 0x00ff0000) >> 16);
+
63  data[ 5] = (BYTE) ((x & 0x0000ff00) >> 8);
+
64  data[ 6] = (BYTE) ((x & 0x000000ff) );
+
65 
+
66  data[ 7] = (BYTE) ((y & 0x00ff0000) >> 16);
+
67  data[ 8] = (BYTE) ((y & 0x0000ff00) >> 8);
+
68  data[ 9] = (BYTE) ((y & 0x000000ff) );
+
69 
+
70  data[10] = (BYTE) ((z & 0x00ff0000) >> 16);
+
71  data[11] = (BYTE) ((z & 0x0000ff00) >> 8);
+
72  data[12] = (BYTE) ((z & 0x000000ff) );
+
73 
+
74  // velocity
+
75  WORD vx = (WORD) (((int) velocity.x + VELOCITY_OFFSET) & 0x0000ffff);
+
76  WORD vy = (WORD) (((int) velocity.y + VELOCITY_OFFSET) & 0x0000ffff);
+
77  WORD vz = (WORD) (((int) velocity.z + VELOCITY_OFFSET) & 0x0000ffff);
+
78 
+
79  data[13] = (BYTE) ((vx & 0xff00) >> 8);
+
80  data[14] = (BYTE) ((vx & 0x00ff));
+
81 
+
82  data[15] = (BYTE) ((vy & 0xff00) >> 8);
+
83  data[16] = (BYTE) ((vy & 0x00ff));
+
84 
+
85  data[17] = (BYTE) ((vz & 0xff00) >> 8);
+
86  data[18] = (BYTE) ((vz & 0x00ff));
+
87 
+
88  // orientation
+
89  if (_finite(euler.x)) {
+
90  while (euler.x < 0) euler.x += 2*PI;
+
91  while (euler.x > 2*PI) euler.x -= 2*PI;
+
92  }
+
93  else {
+
94  euler.x = 0;
+
95  }
+
96 
+
97  if (_finite(euler.y)) {
+
98  while (euler.y < 0) euler.y += 2*PI;
+
99  while (euler.y > 2*PI) euler.y -= 2*PI;
+
100  }
+
101  else {
+
102  euler.y = 0;
+
103  }
+
104 
+
105  if (_finite(euler.z)) {
+
106  while (euler.z < 0) euler.z += 2*PI;
+
107  while (euler.z > 2*PI) euler.z -= 2*PI;
+
108  }
+
109  else {
+
110  euler.z = 0;
+
111  }
+
112 
+
113  WORD ox = (WORD) (((int) (euler.x / EULER_SCALE)) & 0x000003ff);
+
114  WORD oy = (WORD) (((int) (euler.y / EULER_SCALE)) & 0x000003ff);
+
115  WORD oz = (WORD) (((int) (euler.z / EULER_SCALE)) & 0x000003ff);
+
116 
+
117  DWORD o = (ox << 20) | (oy << 10) | (oz);
+
118 
+
119  data[19] = (BYTE) ((o & 0xff000000) >> 24);
+
120  data[20] = (BYTE) ((o & 0x00ff0000) >> 16);
+
121  data[21] = (BYTE) ((o & 0x0000ff00) >> 8);
+
122  data[22] = (BYTE) ((o & 0x000000ff) );
+
123 
+
124  // status bits
+
125  data[23] = throttle << 7 |
+
126  augmenter << 6 |
+
127  gear << 5 |
+
128  (shield >> 2) & 0x1f;
+
129 
+
130  return data;
+
131 }
+
132 
+
133 bool
+
134 NetObjLoc::Unpack(const BYTE* p)
+
135 {
+
136  if (p && p[0] == TYPE && p[1] == SIZE) {
+
137  CopyMemory(data, p, SIZE);
+
138 
+
139  objid = (data[ 2] << 8) |
+
140  (data[ 3] );
+
141 
+
142  int x = (data[ 4] << 16) |
+
143  (data[ 5] << 8) |
+
144  (data[ 6] );
+
145 
+
146  int y = (data[ 7] << 16) |
+
147  (data[ 8] << 8) |
+
148  (data[ 9] );
+
149 
+
150  int z = (data[10] << 16) |
+
151  (data[11] << 8) |
+
152  (data[12] );
+
153 
+
154  int vx = (data[13] << 8) |
+
155  (data[14] );
+
156 
+
157  int vy = (data[15] << 8) |
+
158  (data[16] );
+
159 
+
160  int vz = (data[17] << 8) |
+
161  (data[18] );
+
162 
+
163  DWORD o = (data[19] << 24) |
+
164  (data[20] << 16) |
+
165  (data[21] << 8) |
+
166  (data[22] );
+
167 
+
168  WORD ox = (WORD) ((o >> 20) & 0x03ff);
+
169  WORD oy = (WORD) ((o >> 10) & 0x03ff);
+
170  WORD oz = (WORD) ((o ) & 0x03ff);
+
171 
+
172  throttle = data[23] & 0x80 ? true : false;
+
173  augmenter = data[23] & 0x40 ? true : false;
+
174  gear = data[23] & 0x20 ? true : false;
+
175  shield = (data[23] & 0x1f) << 2;
+
176 
+
177  location = Point(x -LOCATION_OFFSET, y -LOCATION_OFFSET, z -LOCATION_OFFSET);
+
178  velocity = Point(vx-VELOCITY_OFFSET, vy-VELOCITY_OFFSET, vz-VELOCITY_OFFSET);
+
179  euler = Point(ox*EULER_SCALE, oy*EULER_SCALE, oz*EULER_SCALE);
+
180  return true;
+
181  }
+
182 
+
183  return false;
+
184 }
+
185 
+
186 // +--------------------------------------------------------------------+
+
187 
+
188 BYTE*
+
189 NetJoinRequest::Pack()
+
190 {
+
191  ZeroMemory(data, SIZE);
+
192 
+
193  data[0] = TYPE;
+
194  data[1] = SIZE;
+
195 
+
196  for (int i = 0; i < name.length() && i < 16; i++)
+
197  data[2+i] = name[i];
+
198 
+
199  for (int i = 0; i < pass.length() && i < 16; i++)
+
200  data[18+i] = pass[i];
+
201 
+
202  for (int i = 0; i < elem.length() && i < 31; i++)
+
203  data[34+i] = elem[i];
+
204 
+
205  data[65] = (BYTE) index;
+
206 
+
207  for (int i = 0; i < serno.length() && i < 60; i++)
+
208  data[66+i] = serno[i];
+
209 
+
210  return data;
+
211 }
+
212 
+
213 bool
+
214 NetJoinRequest::Unpack(const BYTE* p)
+
215 {
+
216  if (p && p[0] == TYPE && p[1] == SIZE) {
+
217  CopyMemory(data, p, SIZE);
+
218 
+
219  char buf[64];
+
220 
+
221  CopyMemory(buf, data+2, 16);
+
222  buf[16] = 0;
+
223  name = buf;
+
224 
+
225  CopyMemory(buf, data+18, 16);
+
226  buf[16] = 0;
+
227  pass = buf;
+
228 
+
229  CopyMemory(buf, data+34, 31);
+
230  buf[31] = 0;
+
231  elem = buf;
+
232 
+
233  index = data[65];
+
234 
+
235  CopyMemory(buf, data+66, 60);
+
236  buf[61] = 0;
+
237  serno = buf;
+
238  return true;
+
239  }
+
240 
+
241  return false;
+
242 }
+
243 
+
244 // +--------------------------------------------------------------------+
+
245 
+
246 NetJoinAnnounce::NetJoinAnnounce()
+
247 : index(0), integrity(0), respawns(0), decoys(0), probes(0), fuel(0),
+
248 shield(0), nid(0)
+
249 {
+
250  ZeroMemory(ammo, sizeof(ammo));
+
251 }
+
252 
+
253 void
+
254 NetJoinAnnounce::SetAmmo(const int* a)
+
255 {
+
256  if (a) {
+
257  CopyMemory(ammo, a, sizeof(ammo));
+
258  }
+
259 }
+
260 
+
261 void
+
262 NetJoinAnnounce::SetShip(Ship* s)
+
263 {
+
264  SetName(s->Name());
+
265  SetObjID(s->GetObjID());
+
266 
+
267  if (s->GetElement()) {
+
268  SetElement(s->GetElement()->Name());
+
269  SetIndex(s->GetElementIndex());
+
270  }
+
271 
+
272  if (s->GetRegion())
+
273  SetRegion(s->GetRegion()->Name());
+
274 
+
275  SetLocation(s->Location());
+
276  SetVelocity(s->Velocity());
+
277  SetIntegrity(s->Integrity());
+
278  SetRespawns(s->RespawnCount());
+
279 
+
280  if (s->GetDecoy())
+
281  SetDecoys(s->GetDecoy()->Ammo());
+
282 
+
283  if (s->GetProbeLauncher())
+
284  SetProbes(s->GetProbeLauncher()->Ammo());
+
285 
+
286  if (s->Reactors().size())
+
287  SetFuel(s->Reactors()[0]->Charge());
+
288 
+
289  Shield* shield = s->GetShield();
+
290  if (shield)
+
291  SetShield((int) shield->GetPowerLevel());
+
292 }
+
293 
+
294 BYTE*
+
295 NetJoinAnnounce::Pack()
+
296 {
+
297  ZeroMemory(data, SIZE);
+
298 
+
299  data[ 0] = TYPE;
+
300  data[ 1] = SIZE;
+
301  data[ 2] = (BYTE) ((objid & 0xff00) >> 8);
+
302  data[ 3] = (BYTE) ((objid & 0x00ff) );
+
303 
+
304  float* f = (float*) (data + 4);
+
305  *f++ = (float) loc.x; // bytes 4 - 7
+
306  *f++ = (float) loc.y; // bytes 8 - 11
+
307  *f++ = (float) loc.z; // bytes 12 - 15
+
308  *f++ = (float) integrity; // bytes 16 - 19
+
309 
+
310  for (int i = 0; i < name.length() && i < 16; i++)
+
311  data[20+i] = name[i];
+
312 
+
313  for (int i = 0; i < elem.length() && i < 32; i++)
+
314  data[36+i] = elem[i];
+
315 
+
316  for (int i = 0; i < region.length() && i < 32; i++)
+
317  data[68+i] = region[i];
+
318 
+
319  int* p = (int*) (data + 100);
+
320  *p++ = respawns; // bytes 100 - 103
+
321  *p++ = decoys; // bytes 104 - 107
+
322  *p++ = probes; // bytes 108 - 111
+
323 
+
324  data[112]= (BYTE) fuel; // byte 112
+
325  data[113]= (BYTE) shield; // byte 113
+
326 
+
327  BYTE* a = data + 116;
+
328  for (int i = 0; i < 16; i++) { // bytes 116 - 179
+
329  if (ammo[i] >= 0) {
+
330  *a++ = ammo[i];
+
331  }
+
332  else {
+
333  *a++ = 255;
+
334  }
+
335  }
+
336 
+
337  data[180] = (BYTE) index;
+
338 
+
339  f = (float*) (data + 184);
+
340  *f++ = (float) velocity.x;
+
341  *f++ = (float) velocity.y;
+
342  *f++ = (float) velocity.z;
+
343 
+
344  return data;
+
345 }
+
346 
+
347 bool
+
348 NetJoinAnnounce::Unpack(const BYTE* p)
+
349 {
+
350  if (p && p[0] == TYPE && p[1] == SIZE) {
+
351  CopyMemory(data, p, SIZE);
+
352 
+
353  objid = (data[2] << 8) | data[3];
+
354 
+
355  float* f = (float*) (data + 4);
+
356  loc.x = *f++;
+
357  loc.y = *f++;
+
358  loc.z = *f++;
+
359  integrity = *f++;
+
360 
+
361  char buf[64];
+
362  CopyMemory(buf, data+20, 16);
+
363  buf[16] = 0;
+
364  name = buf;
+
365 
+
366  CopyMemory(buf, data+36, 32);
+
367  buf[16] = 0;
+
368  elem = buf;
+
369 
+
370  CopyMemory(buf, data+68, 32);
+
371  buf[16] = 0;
+
372  region = buf;
+
373 
+
374  int* p = (int*) (data + 100);
+
375  respawns = *p++;
+
376  decoys = *p++;
+
377  probes = *p++;
+
378 
+
379  fuel = data[112];
+
380  shield = data[113];
+
381 
+
382  CopyMemory(ammo, data+116, 16);
+
383 
+
384  index = data[180];
+
385 
+
386  f = (float*) (data + 184);
+
387  velocity.x = *f++;
+
388  velocity.y = *f++;
+
389  velocity.z = *f++;
+
390 
+
391  return true;
+
392  }
+
393 
+
394  return false;
+
395 }
+
396 
+
397 // +--------------------------------------------------------------------+
+
398 
+
399 BYTE*
+
400 NetQuitAnnounce::Pack()
+
401 {
+
402  ZeroMemory(data, SIZE);
+
403 
+
404  data[0] = TYPE;
+
405  data[1] = SIZE;
+
406 
+
407  data[2] = (BYTE) ((objid & 0xff00) >> 8);
+
408  data[3] = (BYTE) ((objid & 0x00ff) );
+
409  data[4] = (BYTE) (disconnected);
+
410 
+
411  return data;
+
412 }
+
413 
+
414 bool
+
415 NetQuitAnnounce::Unpack(const BYTE* p)
+
416 {
+
417  if (p && p[0] == TYPE && p[1] == SIZE) {
+
418  CopyMemory(data, p, SIZE);
+
419 
+
420  objid = (data[2] << 8) | data[3];
+
421  disconnected = data[4] ? true : false;
+
422 
+
423  return true;
+
424  }
+
425 
+
426  return false;
+
427 }
+
428 
+
429 // +--------------------------------------------------------------------+
+
430 
+
431 BYTE*
+
432 NetDisconnect::Pack()
+
433 {
+
434  ZeroMemory(data, SIZE);
+
435 
+
436  data[0] = TYPE;
+
437  data[1] = SIZE;
+
438 
+
439  return data;
+
440 }
+
441 
+
442 bool
+
443 NetDisconnect::Unpack(const BYTE* p)
+
444 {
+
445  if (p && p[0] == TYPE && p[1] == SIZE) {
+
446  CopyMemory(data, p, SIZE);
+
447  return true;
+
448  }
+
449 
+
450  return false;
+
451 }
+
452 
+
453 // +--------------------------------------------------------------------+
+
454 
+
455 BYTE*
+
456 NetObjDamage::Pack()
+
457 {
+
458  ZeroMemory(data, SIZE);
+
459 
+
460  data[0] = TYPE;
+
461  data[1] = SIZE;
+
462 
+
463  data[2] = (BYTE) ((objid & 0xff00) >> 8);
+
464  data[3] = (BYTE) ((objid & 0x00ff) );
+
465  data[4] = (BYTE) ((shotid & 0xff00) >> 8);
+
466  data[5] = (BYTE) ((shotid & 0x00ff) );
+
467 
+
468  float* p = (float*) (data + 6);
+
469  *p = damage;
+
470 
+
471  return data;
+
472 }
+
473 
+
474 bool
+
475 NetObjDamage::Unpack(const BYTE* p)
+
476 {
+
477  if (p && p[0] == TYPE && p[1] == SIZE) {
+
478  CopyMemory(data, p, SIZE);
+
479 
+
480  objid = (data[2] << 8) | data[3];
+
481  shotid = (data[4] << 8) | data[5];
+
482  damage = *(float*) (data + 6);
+
483 
+
484  return true;
+
485  }
+
486 
+
487  return false;
+
488 }
+
489 
+
490 // +--------------------------------------------------------------------+
+
491 
+
492 BYTE*
+
493 NetSysDamage::Pack()
+
494 {
+
495  ZeroMemory(data, SIZE);
+
496 
+
497  data[0] = TYPE;
+
498  data[1] = SIZE;
+
499 
+
500  data[2] = (BYTE) ((objid & 0xff00) >> 8);
+
501  data[3] = (BYTE) ((objid & 0x00ff) );
+
502 
+
503  float* p = (float*) (data + 4);
+
504  *p = (float) damage;
+
505 
+
506  data[8] = (BYTE) (sysix+1);
+
507  data[9] = dmgtype;
+
508 
+
509  return data;
+
510 }
+
511 
+
512 bool
+
513 NetSysDamage::Unpack(const BYTE* p)
+
514 {
+
515  if (p && p[0] == TYPE && p[1] == SIZE) {
+
516  CopyMemory(data, p, SIZE);
+
517 
+
518  objid = (data[2] << 8) | data[3];
+
519  damage = *(float*) (data + 4);
+
520  sysix = data[8];
+
521  dmgtype = data[9];
+
522 
+
523  sysix--;
+
524  return true;
+
525  }
+
526 
+
527  return false;
+
528 }
+
529 
+
530 // +--------------------------------------------------------------------+
+
531 
+
532 BYTE*
+
533 NetSysStatus::Pack()
+
534 {
+
535  ZeroMemory(data, SIZE);
+
536 
+
537  data[0] = TYPE;
+
538  data[1] = SIZE;
+
539 
+
540  data[2] = (BYTE) ((objid & 0xff00) >> 8);
+
541  data[3] = (BYTE) ((objid & 0x00ff) );
+
542  data[4] = (BYTE) (sysix+1);
+
543  data[5] = (BYTE) (status);
+
544  data[6] = (BYTE) (power);
+
545  data[7] = (BYTE) (reactor);
+
546 
+
547  float* f = (float*) (data + 8);
+
548  *f = (float) avail;
+
549 
+
550  return data;
+
551 }
+
552 
+
553 bool
+
554 NetSysStatus::Unpack(const BYTE* p)
+
555 {
+
556  if (p && p[0] == TYPE && p[1] == SIZE) {
+
557  CopyMemory(data, p, SIZE);
+
558 
+
559  objid = (data[2] << 8) | data[3];
+
560  sysix = data[4];
+
561  status = data[5];
+
562  power = data[6];
+
563  reactor = data[7];
+
564 
+
565  float* f = (float*) (data + 8);
+
566  avail = *f;
+
567 
+
568  sysix--;
+
569  return true;
+
570  }
+
571 
+
572  return false;
+
573 }
+
574 
+
575 // +--------------------------------------------------------------------+
+
576 
+
577 BYTE*
+
578 NetObjKill::Pack()
+
579 {
+
580  ZeroMemory(data, SIZE);
+
581 
+
582  data[0] = TYPE;
+
583  data[1] = SIZE;
+
584 
+
585  data[2] = (BYTE) ((objid & 0xff00) >> 8);
+
586  data[3] = (BYTE) ((objid & 0x00ff) );
+
587  data[4] = (BYTE) ((kill_id & 0xff00) >> 8);
+
588  data[5] = (BYTE) ((kill_id & 0x00ff) );
+
589  data[6] = (BYTE) killtype;
+
590  data[7] = (BYTE) respawn;
+
591 
+
592  float* f = (float*) (data + 8);
+
593  *f++ = (float) loc.x;
+
594  *f++ = (float) loc.y;
+
595  *f++ = (float) loc.z;
+
596 
+
597  data[20] = (BYTE) deck;
+
598 
+
599  return data;
+
600 }
+
601 
+
602 bool
+
603 NetObjKill::Unpack(const BYTE* p)
+
604 {
+
605  if (p && p[0] == TYPE && p[1] == SIZE) {
+
606  CopyMemory(data, p, SIZE);
+
607 
+
608  objid = (data[2] << 8) | data[3];
+
609  kill_id = (data[4] << 8) | data[5];
+
610  killtype = data[6];
+
611  respawn = data[7] ? true : false;
+
612 
+
613  float* f = (float*) (data + 8);
+
614  loc.x = *f++;
+
615  loc.y = *f++;
+
616  loc.z = *f++;
+
617 
+
618  deck = data[20];
+
619 
+
620  return true;
+
621  }
+
622 
+
623  return false;
+
624 }
+
625 
+
626 // +--------------------------------------------------------------------+
+
627 
+
628 BYTE*
+
629 NetObjHyper::Pack()
+
630 {
+
631  ZeroMemory(data, SIZE);
+
632 
+
633  data[0] = TYPE;
+
634  data[1] = SIZE;
+
635 
+
636  data[2] = (BYTE) ((objid & 0xff00) >> 8);
+
637  data[3] = (BYTE) ((objid & 0x00ff) );
+
638  data[4] = (BYTE) ((fc_src & 0xff00) >> 8);
+
639  data[5] = (BYTE) ((fc_src & 0x00ff) );
+
640  data[6] = (BYTE) ((fc_dst & 0xff00) >> 8);
+
641  data[7] = (BYTE) ((fc_dst & 0x00ff) );
+
642  data[8] = (BYTE) transtype;
+
643 
+
644  float* f = (float*) (data + 12);
+
645  *f++ = (float) location.x; // bytes 12 - 15
+
646  *f++ = (float) location.y; // bytes 16 - 19
+
647  *f++ = (float) location.z; // bytes 20 - 23
+
648 
+
649  char* p = (char*) (data + 24);
+
650  strncpy(p, region.data(), 31);
+
651 
+
652  return data;
+
653 }
+
654 
+
655 bool
+
656 NetObjHyper::Unpack(const BYTE* p)
+
657 {
+
658  if (p && p[0] == TYPE && p[1] == SIZE) {
+
659  CopyMemory(data, p, SIZE);
+
660 
+
661  objid = (data[2] << 8) | data[3];
+
662  fc_src = (data[4] << 8) | data[5];
+
663  fc_dst = (data[6] << 8) | data[7];
+
664  transtype = data[8];
+
665 
+
666  float* f = (float*) (data + 12);
+
667  location.x = *f++;
+
668  location.y = *f++;
+
669  location.z = *f++;
+
670 
+
671  region = (char*) (data + 24);
+
672 
+
673  return true;
+
674  }
+
675 
+
676  return false;
+
677 }
+
678 
+
679 // +--------------------------------------------------------------------+
+
680 
+
681 BYTE*
+
682 NetObjTarget::Pack()
+
683 {
+
684  ZeroMemory(data, SIZE);
+
685 
+
686  data[0] = TYPE;
+
687  data[1] = SIZE;
+
688 
+
689  data[2] = (BYTE) ((objid & 0xff00) >> 8);
+
690  data[3] = (BYTE) ((objid & 0x00ff) );
+
691  data[4] = (BYTE) ((tgtid & 0xff00) >> 8);
+
692  data[5] = (BYTE) ((tgtid & 0x00ff) );
+
693  data[6] = (BYTE) (sysix+1);
+
694 
+
695  return data;
+
696 }
+
697 
+
698 bool
+
699 NetObjTarget::Unpack(const BYTE* p)
+
700 {
+
701  if (p && p[0] == TYPE && p[1] == SIZE) {
+
702  CopyMemory(data, p, SIZE);
+
703 
+
704  objid = (data[2] << 8) | data[3];
+
705  tgtid = (data[4] << 8) | data[5];
+
706  sysix = data[6];
+
707 
+
708  sysix--;
+
709  return true;
+
710  }
+
711 
+
712  return false;
+
713 }
+
714 
+
715 // +--------------------------------------------------------------------+
+
716 
+
717 BYTE*
+
718 NetObjEmcon::Pack()
+
719 {
+
720  ZeroMemory(data, SIZE);
+
721 
+
722  data[0] = TYPE;
+
723  data[1] = SIZE;
+
724 
+
725  data[2] = (BYTE) ((objid & 0xff00) >> 8);
+
726  data[3] = (BYTE) ((objid & 0x00ff) );
+
727  data[4] = (BYTE) (emcon);
+
728 
+
729  return data;
+
730 }
+
731 
+
732 bool
+
733 NetObjEmcon::Unpack(const BYTE* p)
+
734 {
+
735  if (p && p[0] == TYPE && p[1] == SIZE) {
+
736  CopyMemory(data, p, SIZE);
+
737 
+
738  objid = (data[2] << 8) | data[3];
+
739  emcon = data[4];
+
740 
+
741  return true;
+
742  }
+
743 
+
744  return false;
+
745 }
+
746 
+
747 // +--------------------------------------------------------------------+
+
748 
+
749 BYTE*
+
750 NetWepTrigger::Pack()
+
751 {
+
752  ZeroMemory(data, SIZE);
+
753 
+
754  data[0] = TYPE;
+
755  data[1] = SIZE;
+
756 
+
757  data[2] = (BYTE) ((objid & 0xff00) >> 8);
+
758  data[3] = (BYTE) ((objid & 0x00ff) );
+
759  data[4] = (BYTE) ((tgtid & 0xff00) >> 8);
+
760  data[5] = (BYTE) ((tgtid & 0x00ff) );
+
761  data[6] = (BYTE) (sysix+1);
+
762  data[7] = (BYTE) index;
+
763  data[8] = (BYTE) count;
+
764  data[9] = ((BYTE) decoy << 1) |
+
765  ((BYTE) probe );
+
766 
+
767  return data;
+
768 }
+
769 
+
770 bool
+
771 NetWepTrigger::Unpack(const BYTE* p)
+
772 {
+
773  if (p && p[0] == TYPE && p[1] == SIZE) {
+
774  CopyMemory(data, p, SIZE);
+
775 
+
776  objid = (data[2] << 8) | data[3];
+
777  tgtid = (data[4] << 8) | data[5];
+
778  sysix = data[6];
+
779  index = data[7];
+
780  count = data[8];
+
781  decoy = (data[9] & 0x02) ? true : false;
+
782  probe = (data[9] & 0x01) ? true : false;
+
783 
+
784  sysix--;
+
785  return true;
+
786  }
+
787 
+
788  return false;
+
789 }
+
790 
+
791 // +--------------------------------------------------------------------+
+
792 
+
793 BYTE*
+
794 NetWepRelease::Pack()
+
795 {
+
796  ZeroMemory(data, SIZE);
+
797 
+
798  data[0] = TYPE;
+
799  data[1] = SIZE;
+
800 
+
801  data[2] = (BYTE) ((objid & 0xff00) >> 8);
+
802  data[3] = (BYTE) ((objid & 0x00ff) );
+
803  data[4] = (BYTE) ((tgtid & 0xff00) >> 8);
+
804  data[5] = (BYTE) ((tgtid & 0x00ff) );
+
805  data[6] = (BYTE) ((wepid & 0xff00) >> 8);
+
806  data[7] = (BYTE) ((wepid & 0x00ff) );
+
807  data[8] = (BYTE) (sysix+1);
+
808  data[9] = (BYTE) index;
+
809  data[10] = ((BYTE) decoy << 1) |
+
810  ((BYTE) probe );
+
811 
+
812  return data;
+
813 }
+
814 
+
815 bool
+
816 NetWepRelease::Unpack(const BYTE* p)
+
817 {
+
818  if (p && p[0] == TYPE && p[1] == SIZE) {
+
819  CopyMemory(data, p, SIZE);
+
820 
+
821  objid = (data[2] << 8) | data[3];
+
822  tgtid = (data[4] << 8) | data[5];
+
823  wepid = (data[6] << 8) | data[7];
+
824  sysix = data[8];
+
825  index = data[9];
+
826  decoy = (data[10] & 0x02) ? true : false;
+
827  probe = (data[10] & 0x01) ? true : false;
+
828 
+
829  sysix--;
+
830  return true;
+
831  }
+
832 
+
833  return false;
+
834 }
+
835 
+
836 // +--------------------------------------------------------------------+
+
837 
+
838 BYTE*
+
839 NetWepDestroy::Pack()
+
840 {
+
841  ZeroMemory(data, SIZE);
+
842 
+
843  data[0] = TYPE;
+
844  data[1] = SIZE;
+
845  data[2] = (BYTE) ((objid & 0xff00) >> 8);
+
846  data[3] = (BYTE) ((objid & 0x00ff) );
+
847 
+
848  return data;
+
849 }
+
850 
+
851 bool
+
852 NetWepDestroy::Unpack(const BYTE* p)
+
853 {
+
854  if (p && p[0] == TYPE && p[1] == SIZE) {
+
855  CopyMemory(data, p, SIZE);
+
856  objid = (data[2] << 8) | data[3];
+
857  return true;
+
858  }
+
859 
+
860  return false;
+
861 }
+
862 
+
863 // +--------------------------------------------------------------------+
+
864 
+
865 NetCommMsg::~NetCommMsg()
+
866 {
+
867  delete radio_message;
+
868 }
+
869 
+
870 void
+
871 NetCommMsg::SetRadioMessage(RadioMessage* m)
+
872 {
+
873  radio_message = new(__FILE__,__LINE__) RadioMessage(*m);
+
874 }
+
875 
+
876 BYTE*
+
877 NetCommMsg::Pack()
+
878 {
+
879  ZeroMemory(data, SIZE);
+
880 
+
881  if (radio_message) {
+
882  length = 55 + radio_message->Info().length();
+
883 
+
884  if (length > SIZE)
+
885  length = SIZE;
+
886 
+
887  data[0] = TYPE;
+
888  data[1] = (BYTE) length;
+
889 
+
890  if (radio_message->Sender()) {
+
891  objid = radio_message->Sender()->GetObjID();
+
892  data[2] = (BYTE) ((objid & 0xff00) >> 8);
+
893  data[3] = (BYTE) ((objid & 0x00ff) );
+
894  }
+
895 
+
896  if (radio_message->DestinationShip()) {
+
897  DWORD dstid = radio_message->DestinationShip()->GetObjID();
+
898  data[4] = (BYTE) ((dstid & 0xff00) >> 8);
+
899  data[5] = (BYTE) ((dstid & 0x00ff) );
+
900  }
+
901 
+
902  data[6] = (BYTE) radio_message->Action();
+
903  data[7] = (BYTE) radio_message->Channel();
+
904 
+
905  if (radio_message->TargetList().size() > 0) {
+
906  SimObject* tgt = radio_message->TargetList().at(0);
+
907  DWORD tgtid = tgt->GetObjID();
+
908  data[8] = (BYTE) ((tgtid & 0xff00) >> 8);
+
909  data[9] = (BYTE) ((tgtid & 0x00ff) );
+
910  }
+
911 
+
912  float* f = (float*) (data + 10);
+
913  *f++ = (float) radio_message->Location().x; // bytes 10 - 13
+
914  *f++ = (float) radio_message->Location().y; // bytes 14 - 17
+
915  *f++ = (float) radio_message->Location().z; // bytes 18 - 21
+
916 
+
917  char* p = (char*) (data + 22);
+
918 
+
919  Element* dst_elem = radio_message->DestinationElem();
+
920  if (dst_elem)
+
921  strncpy(p, dst_elem->Name().data(), 31);
+
922 
+
923  p = (char*) (data + 55);
+
924  strncpy(p, radio_message->Info().data(), 128);
+
925 
+
926  data[SIZE-1] = 0;
+
927  }
+
928 
+
929  return data;
+
930 }
+
931 
+
932 bool
+
933 NetCommMsg::Unpack(const BYTE* p)
+
934 {
+
935  if (p && p[0] == TYPE) {
+
936  length = p[1];
+
937  ZeroMemory(data, SIZE);
+
938  CopyMemory(data, p, length);
+
939 
+
940  DWORD dstid = 0;
+
941  DWORD tgtid = 0;
+
942  int action = 0;
+
943  int channel = 0;
+
944  Point loc;
+
945  Text elem_name;
+
946  Text info;
+
947 
+
948  objid = (data[2] << 8) | data[3];
+
949  dstid = (data[4] << 8) | data[5];
+
950  tgtid = (data[8] << 8) | data[9];
+
951  action = data[6];
+
952  channel = data[7];
+
953 
+
954  float* f = (float*) (data + 10);
+
955  loc.x = *f++;
+
956  loc.y = *f++;
+
957  loc.z = *f++;
+
958 
+
959  elem_name = (char*) (data + 22);
+
960 
+
961  if (length > 55)
+
962  info = (char*) (data + 55);
+
963 
+
964  Sim* sim = Sim::GetSim();
+
965  Ship* src = sim->FindShipByObjID(objid);
+
966  Ship* dst = sim->FindShipByObjID(dstid);
+
967  Element* elem = sim->FindElement(elem_name);
+
968 
+
969  delete radio_message;
+
970  if (elem)
+
971  radio_message = new(__FILE__,__LINE__) RadioMessage(elem, src, action);
+
972  else
+
973  radio_message = new(__FILE__,__LINE__) RadioMessage(dst, src, action);
+
974 
+
975  radio_message->SetChannel(channel);
+
976  radio_message->SetLocation(loc);
+
977  radio_message->SetInfo(info);
+
978 
+
979  if (tgtid) {
+
980  SimObject* tgt = sim->FindShipByObjID(tgtid);
+
981 
+
982  if (!tgt)
+
983  tgt = sim->FindShotByObjID(tgtid);
+
984 
+
985  if (tgt)
+
986  radio_message->AddTarget(tgt);
+
987  }
+
988 
+
989  return true;
+
990  }
+
991 
+
992  return false;
+
993 }
+
994 
+
995 // +--------------------------------------------------------------------+
+
996 
+
997 BYTE*
+
998 NetChatMsg::Pack()
+
999 {
+
1000  ZeroMemory(data, SIZE);
+
1001 
+
1002  int chatlen = text.length();
+
1003 
+
1004  if (chatlen > MAX_CHAT)
+
1005  chatlen = MAX_CHAT;
+
1006 
+
1007  length = HDR_LEN + NAME_LEN + chatlen;
+
1008 
+
1009  data[0] = TYPE;
+
1010  data[1] = (BYTE) length;
+
1011  data[2] = (BYTE) ((dstid & 0xff00) >> 8);
+
1012  data[3] = (BYTE) ((dstid & 0x00ff) );
+
1013 
+
1014  char* p = (char*) (data + HDR_LEN);
+
1015  strncpy(p, name.data(), NAME_LEN);
+
1016 
+
1017  p = (char*) (data + HDR_LEN + NAME_LEN);
+
1018  strncpy(p, text.data(), chatlen);
+
1019 
+
1020  return data;
+
1021 }
+
1022 
+
1023 bool
+
1024 NetChatMsg::Unpack(const BYTE* p)
+
1025 {
+
1026  if (p && p[0] == TYPE) {
+
1027  length = p[1];
+
1028  ZeroMemory(data, SIZE);
+
1029  CopyMemory(data, p, length);
+
1030 
+
1031  dstid = (data[2] << 8) | data[3];
+
1032 
+
1033  char buffer[NAME_LEN+1];
+
1034  ZeroMemory(buffer, NAME_LEN+1);
+
1035  CopyMemory(buffer, data + HDR_LEN, NAME_LEN);
+
1036 
+
1037  name = buffer;
+
1038 
+
1039  if (length > HDR_LEN + NAME_LEN)
+
1040  text = (char*) (data + HDR_LEN + NAME_LEN);
+
1041 
+
1042  return true;
+
1043  }
+
1044 
+
1045  return false;
+
1046 }
+
1047 
+
1048 // +--------------------------------------------------------------------+
+
1049 
+
1050 NetElemRequest::NetElemRequest()
+
1051 { }
+
1052 
+
1053 BYTE*
+
1054 NetElemRequest::Pack()
+
1055 {
+
1056  ZeroMemory(data, SIZE);
+
1057 
+
1058  data[0] = TYPE;
+
1059  data[1] = SIZE;
+
1060 
+
1061  strncpy((char*) (data + 8), name.data(), NAME_LEN-1);
+
1062 
+
1063  return data;
+
1064 }
+
1065 
+
1066 bool
+
1067 NetElemRequest::Unpack(const BYTE* p)
+
1068 {
+
1069  if (p && p[0] == TYPE) {
+
1070  ZeroMemory(data, SIZE);
+
1071  CopyMemory(data, p, SIZE);
+
1072 
+
1073  name = (const char*) (data + 8);
+
1074 
+
1075  return true;
+
1076  }
+
1077 
+
1078  return false;
+
1079 }
+
1080 
+
1081 // +--------------------------------------------------------------------+
+
1082 
+
1083 NetElemCreate::NetElemCreate()
+
1084 : iff(0), type(0), intel(0), alert(false), in_flight(false)
+
1085 {
+
1086  for (int i = 0; i < 16; i++)
+
1087  load[i] = -1;
+
1088 }
+
1089 
+
1090 void
+
1091 NetElemCreate::SetLoadout(int* l)
+
1092 {
+
1093  if (l) {
+
1094  CopyMemory(load, l, sizeof(load));
+
1095  }
+
1096  else {
+
1097  for (int i = 0; i < 16; i++)
+
1098  load[i] = -1;
+
1099  }
+
1100 }
+
1101 
+
1102 void
+
1103 NetElemCreate::SetSlots(int* s)
+
1104 {
+
1105  if (s) {
+
1106  CopyMemory(slots, s, sizeof(slots));
+
1107  }
+
1108  else {
+
1109  for (int i = 0; i < 4; i++)
+
1110  slots[i] = -1;
+
1111  }
+
1112 }
+
1113 
+
1114 BYTE*
+
1115 NetElemCreate::Pack()
+
1116 {
+
1117  ZeroMemory(data, SIZE);
+
1118 
+
1119  data[0] = TYPE;
+
1120  data[1] = SIZE;
+
1121 
+
1122  data[2] = (BYTE) iff;
+
1123  data[3] = (BYTE) type;
+
1124  data[4] = (BYTE) intel;
+
1125  data[5] = (BYTE) obj_code;
+
1126 
+
1127  for (int i = 0; i < 16; i++)
+
1128  data[6+i] = (BYTE) load[i];
+
1129 
+
1130  strncpy((char*) (data + 22), name.data(), NAME_LEN-1);
+
1131  strncpy((char*) (data + 54), commander.data(), NAME_LEN-1);
+
1132  strncpy((char*) (data + 86), objective.data(), NAME_LEN-1);
+
1133  strncpy((char*) (data + 118), carrier.data(), NAME_LEN-1);
+
1134 
+
1135  data[150] = (BYTE) squadron;
+
1136  data[151] = (BYTE) slots[0];
+
1137  data[152] = (BYTE) slots[1];
+
1138  data[153] = (BYTE) slots[2];
+
1139  data[154] = (BYTE) slots[3];
+
1140  data[155] = (BYTE) alert;
+
1141  data[156] = (BYTE) in_flight;
+
1142 
+
1143  return data;
+
1144 }
+
1145 
+
1146 bool
+
1147 NetElemCreate::Unpack(const BYTE* p)
+
1148 {
+
1149  if (p && p[0] == TYPE) {
+
1150  ZeroMemory(data, SIZE);
+
1151  CopyMemory(data, p, SIZE);
+
1152 
+
1153  iff = data[2];
+
1154  type = data[3];
+
1155  intel = data[4];
+
1156  obj_code = data[5];
+
1157 
+
1158  for (int i = 0; i < 16; i++) {
+
1159  load[i] = data[6+i] == 255 ? -1 : data[6+i];
+
1160  }
+
1161 
+
1162  name = (const char*) (data + 22);
+
1163  commander = (const char*) (data + 54);
+
1164  objective = (const char*) (data + 86);
+
1165  carrier = (const char*) (data + 118);
+
1166 
+
1167  squadron = data[150];
+
1168 
+
1169  for (int i = 0; i < 4; i++) {
+
1170  slots[i] = data[151+i];
+
1171  if (slots[i] >= 255)
+
1172  slots[i] = -1;
+
1173  }
+
1174 
+
1175  alert = data[155] ? true : false;
+
1176  in_flight = data[156] ? true : false;
+
1177 
+
1178  return true;
+
1179  }
+
1180 
+
1181  return false;
+
1182 }
+
1183 
+
1184 // +--------------------------------------------------------------------+
+
1185 
+
1186 BYTE*
+
1187 NetShipLaunch::Pack()
+
1188 {
+
1189  ZeroMemory(data, SIZE);
+
1190 
+
1191  data[ 0] = TYPE;
+
1192  data[ 1] = SIZE;
+
1193 
+
1194  DWORD* p = (DWORD*) (data + 4);
+
1195  *p++ = (DWORD) objid;
+
1196  *p++ = (DWORD) squadron;
+
1197  *p++ = (DWORD) slot;
+
1198 
+
1199  return data;
+
1200 }
+
1201 
+
1202 bool
+
1203 NetShipLaunch::Unpack(const BYTE* p)
+
1204 {
+
1205  if (p && p[0] == TYPE) {
+
1206  ZeroMemory(data, SIZE);
+
1207  CopyMemory(data, p, SIZE);
+
1208 
+
1209  DWORD* p = (DWORD*) (data + 4);
+
1210  objid = *p++;
+
1211  squadron = (int) *p++;
+
1212  slot = (int) *p++;
+
1213 
+
1214  return true;
+
1215  }
+
1216 
+
1217  return false;
+
1218 }
+
1219 
+
1220 // +--------------------------------------------------------------------+
+
1221 
+
1222 NetNavData::NetNavData()
+
1223 : objid(0), create(true), index(0), navpoint(0)
+
1224 {
+
1225 }
+
1226 
+
1227 NetNavData::~NetNavData()
+
1228 {
+
1229  delete navpoint;
+
1230 }
+
1231 
+
1232 void
+
1233 NetNavData::SetNavPoint(Instruction* n)
+
1234 {
+
1235  if (navpoint) {
+
1236  delete navpoint;
+
1237  navpoint = 0;
+
1238  }
+
1239 
+
1240  if (n)
+
1241  navpoint = new(__FILE__,__LINE__) Instruction(*n);
+
1242 }
+
1243 
+
1244 BYTE*
+
1245 NetNavData::Pack()
+
1246 {
+
1247  ZeroMemory(data, SIZE);
+
1248 
+
1249  data[ 0] = TYPE;
+
1250  data[ 1] = SIZE;
+
1251 
+
1252  data[ 2] = (BYTE) ((objid & 0xff00) >> 8);
+
1253  data[ 3] = (BYTE) ((objid & 0x00ff) );
+
1254  data[ 4] = (BYTE) create;
+
1255  data[ 5] = (BYTE) index;
+
1256 
+
1257  if (!navpoint)
+
1258  return data;
+
1259 
+
1260  data[ 6] = (BYTE) navpoint->Action();
+
1261  data[ 7] = (BYTE) navpoint->Formation();
+
1262  data[ 8] = (BYTE) navpoint->Status();
+
1263  data[ 9] = (BYTE) navpoint->EMCON();
+
1264  data[10] = (BYTE) navpoint->WeaponsFree();
+
1265  data[11] = (BYTE) navpoint->Farcast();
+
1266 
+
1267  Point loc = navpoint->Location();
+
1268 
+
1269  float* f = (float*) (data + 12);
+
1270  *f++ = (float) loc.x; // bytes 12 - 15
+
1271  *f++ = (float) loc.y; // bytes 16 - 19
+
1272  *f++ = (float) loc.z; // bytes 20 - 23
+
1273  *f++ = (float) navpoint->HoldTime(); // bytes 24 - 27
+
1274  *f++ = (float) navpoint->Speed(); // bytes 28 - 31
+
1275 
+
1276  WORD tgtid = 0;
+
1277  if (navpoint->GetTarget())
+
1278  tgtid = (WORD) navpoint->GetTarget()->GetObjID();
+
1279 
+
1280  data[32] = (BYTE) ((tgtid & 0xff00) >> 8);
+
1281  data[33] = (BYTE) ((tgtid & 0x00ff) );
+
1282 
+
1283  strncpy((char*) (data + 34), navpoint->RegionName(), NAME_LEN-1);
+
1284  strncpy((char*) (data + 66), navpoint->TargetName(), NAME_LEN-1);
+
1285  strncpy((char*) (data + 98), elem.data(), NAME_LEN-1);
+
1286 
+
1287  return data;
+
1288 }
+
1289 
+
1290 bool
+
1291 NetNavData::Unpack(const BYTE* p)
+
1292 {
+
1293  if (p && p[0] == TYPE) {
+
1294  ZeroMemory(data, SIZE);
+
1295  CopyMemory(data, p, SIZE);
+
1296 
+
1297  int action;
+
1298  int formation;
+
1299  int status;
+
1300  int emcon;
+
1301  int wep_free;
+
1302  int farcast;
+
1303  int speed;
+
1304  float hold_time;
+
1305  Point loc;
+
1306  WORD tgtid = 0;
+
1307 
+
1308  const char* rgn_name = 0;
+
1309  const char* tgt_name = 0;
+
1310 
+
1311  objid = (data[ 2] << 8) |
+
1312  (data[ 3] );
+
1313 
+
1314  tgtid = (data[32] << 8) |
+
1315  (data[33] );
+
1316 
+
1317  create = data[ 4] ? true : false;
+
1318  index = data[ 5];
+
1319  action = data[ 6];
+
1320  formation = data[ 7];
+
1321  status = data[ 8];
+
1322  emcon = data[ 9];
+
1323  wep_free = data[10];
+
1324  farcast = data[11];
+
1325 
+
1326  float* f = (float*) (data + 12);
+
1327  loc.x = *f++;
+
1328  loc.y = *f++;
+
1329  loc.z = *f++;
+
1330  hold_time = *f++;
+
1331  speed = (int) *f++;
+
1332 
+
1333  rgn_name = (const char*) (data + 34);
+
1334  tgt_name = (const char*) (data + 66);
+
1335  elem = (const char*) (data + 98);
+
1336 
+
1337  if (navpoint) {
+
1338  delete navpoint;
+
1339  navpoint = 0;
+
1340  }
+
1341 
+
1342  Sim* sim = Sim::GetSim();
+
1343  SimRegion* rgn = 0;
+
1344 
+
1345  if (sim)
+
1346  rgn = sim->FindRegion(rgn_name);
+
1347 
+
1348  if (rgn)
+
1349  navpoint = new(__FILE__,__LINE__) Instruction(rgn, loc, action);
+
1350  else
+
1351  navpoint = new(__FILE__,__LINE__) Instruction(rgn_name, loc, action);
+
1352 
+
1353  navpoint->SetFormation(formation);
+
1354  navpoint->SetStatus(status);
+
1355  navpoint->SetEMCON(emcon);
+
1356  navpoint->SetWeaponsFree(wep_free);
+
1357  navpoint->SetFarcast(farcast);
+
1358  navpoint->SetHoldTime(hold_time);
+
1359  navpoint->SetSpeed(speed);
+
1360  navpoint->SetTarget(tgt_name);
+
1361 
+
1362  if (tgtid) {
+
1363  Sim* sim = Sim::GetSim();
+
1364  Ship* tgt = sim->FindShipByObjID(tgtid);
+
1365 
+
1366  if (tgt)
+
1367  navpoint->SetTarget(tgt);
+
1368  }
+
1369 
+
1370  if (index >= 255)
+
1371  index = -1;
+
1372 
+
1373  return true;
+
1374  }
+
1375 
+
1376  return false;
+
1377 }
+
1378 
+
1379 // +--------------------------------------------------------------------+
+
1380 
+
1381 BYTE*
+
1382 NetNavDelete::Pack()
+
1383 {
+
1384  ZeroMemory(data, SIZE);
+
1385 
+
1386  data[ 0] = TYPE;
+
1387  data[ 1] = SIZE;
+
1388 
+
1389  data[ 2] = (BYTE) ((objid & 0xff00) >> 8);
+
1390  data[ 3] = (BYTE) ((objid & 0x00ff) );
+
1391  data[ 4] = (BYTE) index;
+
1392 
+
1393  strncpy((char*) (data + 6), elem.data(), 31);
+
1394 
+
1395  return data;
+
1396 }
+
1397 
+
1398 bool
+
1399 NetNavDelete::Unpack(const BYTE* p)
+
1400 {
+
1401  if (p && p[0] == TYPE) {
+
1402  ZeroMemory(data, SIZE);
+
1403  CopyMemory(data, p, SIZE);
+
1404  int index = 0;
+
1405 
+
1406  objid = (data[ 2] << 8) |
+
1407  (data[ 3] );
+
1408 
+
1409  index = data[4];
+
1410  elem = (const char*) (data + 6);
+
1411 
+
1412  if (index >= 255)
+
1413  index = -1;
+
1414 
+
1415  return true;
+
1416  }
+
1417 
+
1418  return false;
+
1419 }
+
1420 
+
1421 // +--------------------------------------------------------------------+
+
1422 
+
1423 BYTE*
+
1424 NetSelfDestruct::Pack()
+
1425 {
+
1426  ZeroMemory(data, SIZE);
+
1427 
+
1428  data[0] = TYPE;
+
1429  data[1] = SIZE;
+
1430 
+
1431  data[2] = (BYTE) ((objid & 0xff00) >> 8);
+
1432  data[3] = (BYTE) ((objid & 0x00ff) );
+
1433 
+
1434  float* p = (float*) (data + 4);
+
1435  *p = damage;
+
1436 
+
1437  return data;
+
1438 }
+
1439 
+
1440 bool
+
1441 NetSelfDestruct::Unpack(const BYTE* p)
+
1442 {
+
1443  if (p && p[0] == TYPE && p[1] == SIZE) {
+
1444  CopyMemory(data, p, SIZE);
+
1445 
+
1446  objid = (data[2] << 8) | data[3];
+
1447  damage = *(float*) (data + 4);
+
1448 
+
1449  return true;
+
1450  }
+
1451 
+
1452  return false;
+
1453 }
+
+
+ + + + -- cgit v1.1