This commit was manufactured by cvs2svn to create tag 'd2x-0_1_2'.
[btb/d2x.git] / main / netmisc.c
1 /*
2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
3 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
6 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
8 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.  
11 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
12 */
13
14 #ifdef HAVE_CONFIG_H
15 #include <conf.h>
16 #endif
17
18 #ifdef RCS
19 static char rcsid[] = "$Id: netmisc.c,v 1.3 2001-10-25 02:15:57 bradleyb Exp $";
20 #endif
21
22 #include <stdio.h>
23 #include <string.h>
24
25 #include "inferno.h"
26 #include "pstypes.h"
27 #include "mono.h"
28
29 #ifdef MACINTOSH
30
31 #include "byteswap.h"
32 #include "segment.h"
33 #include "gameseg.h"
34
35 // routine to calculate the checksum of the segments.  We add these specialized routines
36 // since the current way is byte order dependent.
37
38 void mac_do_checksum_calc(ubyte *b, int len, unsigned int *s1, unsigned int *s2)
39 {
40
41         while(len--)    {
42                 *s1 += *b++;
43                 if (*s1 >= 255 ) *s1 -= 255;
44                 *s2 += *s1;
45         }
46 }
47
48 ushort mac_calc_segment_checksum()
49 {
50         int i, j, k;
51         unsigned int sum1,sum2;
52         short s;
53         int t;
54
55         sum1 = sum2 = 0;
56         for (i = 0; i < Highest_segment_index + 1; i++) {
57                 for (j = 0; j < MAX_SIDES_PER_SEGMENT; j++) {
58                         mac_do_checksum_calc(&(Segments[i].sides[j].type), 1, &sum1, &sum2);
59                         mac_do_checksum_calc(&(Segments[i].sides[j].pad), 1, &sum1, &sum2);
60                         s = INTEL_SHORT(Segments[i].sides[j].wall_num);
61                         mac_do_checksum_calc((ubyte *)&s, 2, &sum1, &sum2);
62                         s = INTEL_SHORT(Segments[i].sides[j].tmap_num);
63                         mac_do_checksum_calc((ubyte *)&s, 2, &sum1, &sum2);
64                         s = INTEL_SHORT(Segments[i].sides[j].tmap_num2);
65                         mac_do_checksum_calc((ubyte *)&s, 2, &sum1, &sum2);
66                         for (k = 0; k < 4; k++) {
67                                 t = INTEL_INT(((int)Segments[i].sides[j].uvls[k].u));
68                                 mac_do_checksum_calc((ubyte *)&t, 4, &sum1, &sum2);
69                                 t = INTEL_INT(((int)Segments[i].sides[j].uvls[k].v));
70                                 mac_do_checksum_calc((ubyte *)&t, 4, &sum1, &sum2);
71                                 t = INTEL_INT(((int)Segments[i].sides[j].uvls[k].l));
72                                 mac_do_checksum_calc((ubyte *)&t, 4, &sum1, &sum2);
73                         }
74                         for (k = 0; k < 2; k++) {
75                                 t = INTEL_INT(((int)Segments[i].sides[j].normals[k].x));
76                                 mac_do_checksum_calc((ubyte *)&t, 4, &sum1, &sum2);
77                                 t = INTEL_INT(((int)Segments[i].sides[j].normals[k].y));
78                                 mac_do_checksum_calc((ubyte *)&t, 4, &sum1, &sum2);
79                                 t = INTEL_INT(((int)Segments[i].sides[j].normals[k].z));
80                                 mac_do_checksum_calc((ubyte *)&t, 4, &sum1, &sum2);
81                         }
82                 }
83                 for (j = 0; j < MAX_SIDES_PER_SEGMENT; j++) {
84                         s = INTEL_SHORT(Segments[i].children[j]);
85                         mac_do_checksum_calc((ubyte *)&s, 2, &sum1, &sum2);
86                 }
87                 for (j = 0; j < MAX_VERTICES_PER_SEGMENT; j++) {
88                         s = INTEL_SHORT(Segments[i].verts[j]);
89                         mac_do_checksum_calc((ubyte *)&s, 2, &sum1, &sum2);
90                 }
91                 t = INTEL_INT(Segments[i].objects);
92                 mac_do_checksum_calc((ubyte *)&t, 4, &sum1, &sum2);
93         }
94         sum2 %= 255;
95         return ((sum1<<8)+ sum2);
96 }
97
98 // this routine totally and completely relies on the fact that the network
99 //  checksum must be calculated on the segments!!!!!
100
101 ushort netmisc_calc_checksum( void * vptr, int len )
102 {
103         vptr = vptr;
104         len = len;
105         return mac_calc_segment_checksum();
106 }
107
108 // Calculates the checksum of a block of memory.
109 ushort netmisc_calc_checksum_pc( void * vptr, int len )
110 {
111         ubyte * ptr = (ubyte *)vptr;
112         unsigned int sum1,sum2;
113
114         sum1 = sum2 = 0;
115
116         while(len--)    {
117                 sum1 += *ptr++;
118                 if (sum1 >= 255 ) sum1 -= 255;
119                 sum2 += sum1;
120         }
121         sum2 %= 255;
122         
123         return ((sum1<<8)+ sum2);
124 }
125
126 // following are routine for macintosh only that will swap the elements of
127 // structures send through the networking code.  The structures and
128 // this code must be kept in total sync
129
130 #include "ipx.h"
131 #include "byteswap.h"
132 #include "multi.h"
133 #ifdef NETWORK
134 #include "network.h"
135 #endif
136 #include "object.h"
137 #include "powerup.h"
138 #include "error.h"
139
140 byte out_buffer[IPX_MAX_DATA_SIZE];             // used for tmp netgame packets as well as sending object data
141
142 void receive_netplayer_info(ubyte *data, netplayer_info *info)
143 {
144         int loc = 0;
145         
146         memcpy(info->callsign, &(data[loc]), CALLSIGN_LEN+1);           loc += CALLSIGN_LEN+1;
147         memcpy(&(info->network.ipx.server), &(data[loc]), 4);                                   loc += 4;
148         memcpy(&(info->network.ipx.node), &(data[loc]), 6);                                             loc += 6;
149         info->version_major = data[loc];                                                        loc++;
150         info->version_minor = data[loc];                                                        loc++;
151         memcpy(&(info->computer_type), &(data[loc]), 1);                        loc++;          // memcpy to avoid compile time warning about enum
152         info->connected = data[loc];                                                            loc++;
153         memcpy(&(info->socket), &(data[loc]), 2);                                       loc += 2; 
154    memcpy (&(info->rank),&(data[loc]),1);                                          loc++;
155 //MWA  don't think we need to swap this because we need it in high order        info->socket = swapshort(info->socket);
156 }
157
158 void send_netplayers_packet(ubyte *server, ubyte *node)
159 {
160         int i, tmpi;
161         int loc = 0;
162         short tmps;
163         
164         memset(out_buffer, 0, sizeof(out_buffer));
165         out_buffer[0] = NetPlayers.type;                                                loc++;
166         tmpi = INTEL_INT(NetPlayers.Security);
167         memcpy(&(out_buffer[loc]), &tmpi, 4);                                   loc += 4;
168         for (i = 0; i < MAX_PLAYERS+4; i++) {
169                 memcpy(&(out_buffer[loc]), NetPlayers.players[i].callsign, CALLSIGN_LEN+1);     loc += CALLSIGN_LEN+1;
170                 memcpy(&(out_buffer[loc]), NetPlayers.players[i].network.ipx.server, 4);                                loc += 4;
171                 memcpy(&(out_buffer[loc]), NetPlayers.players[i].network.ipx.node, 6);                                  loc += 6;
172                 memcpy(&(out_buffer[loc]), &(NetPlayers.players[i].version_major), 1);          loc++;
173                 memcpy(&(out_buffer[loc]), &(NetPlayers.players[i].version_minor), 1);          loc++;
174                 memcpy(&(out_buffer[loc]), &(NetPlayers.players[i].computer_type), 1);          loc++;
175                 memcpy(&(out_buffer[loc]), &(NetPlayers.players[i].connected), 1);                      loc++;
176                 tmps = INTEL_SHORT(NetPlayers.players[i].socket);
177                 memcpy(&(out_buffer[loc]), &tmps, 2);                                                                           loc += 2;               
178                 memcpy(&(out_buffer[loc]), &(NetPlayers.players[i].rank), 1);                   loc++;
179         }
180         
181         if ((server == NULL) && (node == NULL))
182                 ipx_send_broadcast_packet_data( out_buffer, loc );
183         else
184                 ipx_send_internetwork_packet_data( out_buffer, loc, server, node);
185
186 }
187
188 void receive_netplayers_packet(ubyte *data, AllNetPlayers_info *pinfo)
189 {
190         int i, loc = 0;
191
192         pinfo->type = data[loc];                                                        loc++;
193         memcpy(&(pinfo->Security), &(data[loc]), 4);            loc += 4;
194         pinfo->Security = INTEL_INT(pinfo->Security);
195         for (i = 0; i < MAX_PLAYERS+4; i++) {
196                 receive_netplayer_info(&(data[loc]), &(pinfo->players[i]));
197                 loc += 26;                      // sizeof(netplayer_info) on the PC
198         }
199 }
200
201 void send_sequence_packet(sequence_packet seq, ubyte *server, ubyte *node, ubyte *net_address)
202 {
203         short tmps;
204         int loc, tmpi;
205
206         loc = 0;
207         memset(out_buffer, 0, sizeof(out_buffer));
208         out_buffer[0] = seq.type;                                                                               loc++;
209         tmpi = INTEL_INT(seq.Security);
210         memcpy(&(out_buffer[loc]), &tmpi, 4);                                                   loc += 4;               loc += 3;
211         memcpy(&(out_buffer[loc]), seq.player.callsign, CALLSIGN_LEN+1);loc += CALLSIGN_LEN+1;
212         memcpy(&(out_buffer[loc]), seq.player.network.ipx.server, 4);                           loc += 4;
213         memcpy(&(out_buffer[loc]), seq.player.network.ipx.node, 6);                                     loc += 6;
214         out_buffer[loc] = seq.player.version_major;                                             loc++;
215         out_buffer[loc] = seq.player.version_minor;                                             loc++;
216         out_buffer[loc] = seq.player.computer_type;                                             loc++;
217         out_buffer[loc] = seq.player.connected;                                                 loc++;
218         tmps = swapshort(seq.player.socket);
219         memcpy(&(out_buffer[loc]), &tmps, 2);                                                   loc += 2;
220    out_buffer[loc]=seq.player.rank;                                                                     loc++;          // for pad byte
221         if (net_address != NULL)        
222                 ipx_send_packet_data( out_buffer, loc, server, node, net_address);
223         else if ((server == NULL) && (node == NULL))
224                 ipx_send_broadcast_packet_data( out_buffer, loc );
225         else
226                 ipx_send_internetwork_packet_data( out_buffer, loc, server, node);
227 }
228
229 void receive_sequence_packet(ubyte *data, sequence_packet *seq)
230 {
231         int loc = 0;
232         
233         seq->type = data[0];                                            loc++;
234         memcpy(&(seq->Security), &(data[loc]), 4);      loc += 4;       loc += 3;               // +3 for pad byte
235         seq->Security = INTEL_INT(seq->Security);
236         receive_netplayer_info(&(data[loc]), &(seq->player));
237 }
238
239 void send_netgame_packet(ubyte *server, ubyte *node, ubyte *net_address, int lite_flag)         // lite says shorter netgame packets
240 {
241         uint tmpi;
242         ushort tmps, p;
243         int i, j;
244         int loc = 0;
245         
246         memset(out_buffer, 0, IPX_MAX_DATA_SIZE);
247         memcpy(&(out_buffer[loc]), &(Netgame.type), 1); loc++;
248         tmpi = INTEL_INT(Netgame.Security);
249         memcpy(&(out_buffer[loc]), &tmpi, 4);           loc += 4;
250         memcpy(&(out_buffer[loc]), Netgame.game_name, NETGAME_NAME_LEN+1); loc += (NETGAME_NAME_LEN+1);
251         memcpy(&(out_buffer[loc]), Netgame.mission_title, MISSION_NAME_LEN+1);  loc += (MISSION_NAME_LEN+1);
252         memcpy(&(out_buffer[loc]), Netgame.mission_name, 9);                    loc += 9;
253         tmpi = INTEL_INT(Netgame.levelnum);
254         memcpy(&(out_buffer[loc]), &tmpi, 4);                                                   loc += 4;
255         memcpy(&(out_buffer[loc]), &(Netgame.gamemode), 1);                             loc++;
256         memcpy(&(out_buffer[loc]), &(Netgame.RefusePlayers), 1);                loc++;
257         memcpy(&(out_buffer[loc]), &(Netgame.difficulty), 1);                   loc++;
258         memcpy(&(out_buffer[loc]), &(Netgame.game_status), 1);                  loc++;
259         memcpy(&(out_buffer[loc]), &(Netgame.numplayers), 1);                   loc++;
260         memcpy(&(out_buffer[loc]), &(Netgame.max_numplayers), 1);               loc++;
261         memcpy(&(out_buffer[loc]), &(Netgame.numconnected), 1);                 loc++;
262         memcpy(&(out_buffer[loc]), &(Netgame.game_flags), 1);                   loc++;
263         memcpy(&(out_buffer[loc]), &(Netgame.protocol_version), 1);             loc++;
264         memcpy(&(out_buffer[loc]), &(Netgame.version_major), 1);                loc++;
265         memcpy(&(out_buffer[loc]), &(Netgame.version_minor), 1);                loc++;
266         memcpy(&(out_buffer[loc]), &(Netgame.team_vector), 1);                  loc++;
267         
268         if (lite_flag)
269                 goto do_send;
270
271 // will this work -- damn bitfields -- totally bogus when trying to do this type of stuff
272 // Watcom makes bitfields from left to right.  CW7 on the mac goes from right to left.
273 // then they are endian swapped
274
275         tmps = *(ushort *)((ubyte *)(&Netgame.team_vector) + 1);                        // get the values for the first short bitfield
276         tmps = INTEL_SHORT(tmps);
277         memcpy(&(out_buffer[loc]), &tmps, 2);           loc += 2;
278
279         tmps = *(ushort *)((ubyte *)(&Netgame.team_vector) + 3);                        // get the values for the second short bitfield
280         tmps = INTEL_SHORT(tmps);
281         memcpy(&(out_buffer[loc]), &tmps, 2);           loc += 2;
282
283 #if 0           // removed since I reordered bitfields on mac
284         p = *(ushort *)((ubyte *)(&Netgame.team_vector) + 1);                   // get the values for the first short bitfield
285         tmps = 0;
286         for (i = 15; i >= 0; i--) {
287                 if ( p & (1 << i) )
288                         tmps |= (1 << (15 - i));
289         }
290         tmps = INTEL_SHORT(tmps);
291         memcpy(&(out_buffer[loc]), &tmps, 2);                                                   loc += 2;
292         p = *(ushort *)((ubyte *)(&Netgame.team_vector) + 3);                   // get the values for the second short bitfield
293         tmps = 0;
294         for (i = 15; i >= 0; i--) {
295                 if ( p & (1 << i) )
296                         tmps |= (1 << (15 - i));
297         }
298         tmps = INTEL_SHORT(tmps);
299         memcpy(&(out_buffer[loc]), &tmps, 2);                                                   loc += 2;
300 #endif
301         
302         memcpy(&(out_buffer[loc]), Netgame.team_name, 2*(CALLSIGN_LEN+1)); loc += 2*(CALLSIGN_LEN+1);
303         for (i = 0; i < MAX_PLAYERS; i++) {
304                 tmpi = INTEL_INT(Netgame.locations[i]);
305                 memcpy(&(out_buffer[loc]), &tmpi, 4); loc += 4;                 // SWAP HERE!!!
306         }
307
308         for (i = 0; i < MAX_PLAYERS; i++) {
309                 for (j = 0; j < MAX_PLAYERS; j++) {
310                         tmps = INTEL_SHORT(Netgame.kills[i][j]);
311                         memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2;                 // SWAP HERE!!!
312                 }
313         }
314
315         tmps = INTEL_SHORT(Netgame.segments_checksum);
316         memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2;                         // SWAP_HERE
317         tmps = INTEL_SHORT(Netgame.team_kills[0]);
318         memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2;                         // SWAP_HERE
319         tmps = INTEL_SHORT(Netgame.team_kills[1]);
320         memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2;                         // SWAP_HERE
321         for (i = 0; i < MAX_PLAYERS; i++) {
322                 tmps = INTEL_SHORT(Netgame.killed[i]);
323                 memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2;                 // SWAP HERE!!!
324         }
325         for (i = 0; i < MAX_PLAYERS; i++) {
326                 tmps = INTEL_SHORT(Netgame.player_kills[i]);
327                 memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2;                 // SWAP HERE!!!
328         }
329
330         tmpi = INTEL_INT(Netgame.KillGoal);
331         memcpy(&(out_buffer[loc]), &tmpi, 4); loc += 4;                         // SWAP_HERE
332         tmpi = INTEL_INT(Netgame.PlayTimeAllowed);
333         memcpy(&(out_buffer[loc]), &tmpi, 4); loc += 4;                         // SWAP_HERE
334         tmpi = INTEL_INT(Netgame.level_time);
335         memcpy(&(out_buffer[loc]), &tmpi, 4); loc += 4;                         // SWAP_HERE
336         tmpi = INTEL_INT(Netgame.control_invul_time);
337         memcpy(&(out_buffer[loc]), &tmpi, 4); loc += 4;                         // SWAP_HERE
338         tmpi = INTEL_INT(Netgame.monitor_vector);
339         memcpy(&(out_buffer[loc]), &tmpi, 4); loc += 4;                         // SWAP_HERE
340         for (i = 0; i < MAX_PLAYERS; i++) {
341                 tmpi = INTEL_INT(Netgame.player_score[i]);
342                 memcpy(&(out_buffer[loc]), &tmpi, 4); loc += 4;                         // SWAP_HERE
343         }
344         for (i = 0; i < MAX_PLAYERS; i++) {
345                 memcpy(&(out_buffer[loc]), &(Netgame.player_flags[i]), 1); loc++;
346         }
347         tmps = INTEL_SHORT(Netgame.PacketsPerSec);
348         memcpy(&(out_buffer[loc]), &tmps, 2);                                   loc += 2;
349         memcpy(&(out_buffer[loc]), &(Netgame.ShortPackets), 1); loc ++;
350
351 do_send:
352         if (net_address != NULL)        
353                 ipx_send_packet_data( out_buffer, loc, server, node, net_address);
354         else if ((server == NULL) && (node == NULL))
355                 ipx_send_broadcast_packet_data( out_buffer, loc );
356         else
357                 ipx_send_internetwork_packet_data( out_buffer, loc, server, node);
358 }
359
360 void receive_netgame_packet(ubyte *data, netgame_info *netgame, int lite_flag)
361 {
362         int i, j;
363         int loc = 0;
364         short bitfield, new_field;
365         
366         memcpy(&(netgame->type), &(data[loc]), 1);                                              loc++;
367         memcpy(&(netgame->Security), &(data[loc]), 4);                                  loc += 4;
368         netgame->Security = INTEL_INT(netgame->Security);
369         memcpy(netgame->game_name, &(data[loc]), NETGAME_NAME_LEN+1);   loc += (NETGAME_NAME_LEN+1);
370         memcpy(netgame->mission_title, &(data[loc]), MISSION_NAME_LEN+1); loc += (MISSION_NAME_LEN+1);
371         memcpy(netgame->mission_name, &(data[loc]), 9);                                 loc += 9;
372         memcpy(&(netgame->levelnum), &(data[loc]), 4);                                          loc += 4;
373         netgame->levelnum = INTEL_INT(netgame->levelnum);
374         memcpy(&(netgame->gamemode), &(data[loc]), 1);                                  loc++;
375         memcpy(&(netgame->RefusePlayers), &(data[loc]), 1);                             loc++;
376         memcpy(&(netgame->difficulty), &(data[loc]), 1);                                loc++;
377         memcpy(&(netgame->game_status), &(data[loc]), 1);                               loc++;
378         memcpy(&(netgame->numplayers), &(data[loc]), 1);                                loc++;
379         memcpy(&(netgame->max_numplayers), &(data[loc]), 1);                    loc++;
380         memcpy(&(netgame->numconnected), &(data[loc]), 1);                              loc++;
381         memcpy(&(netgame->game_flags), &(data[loc]), 1);                                loc++;
382         memcpy(&(netgame->protocol_version), &(data[loc]), 1);                  loc++;
383         memcpy(&(netgame->version_major), &(data[loc]), 1);                             loc++;
384         memcpy(&(netgame->version_minor), &(data[loc]), 1);                             loc++;
385         memcpy(&(netgame->team_vector), &(data[loc]), 1);                               loc++;
386
387         if (lite_flag)
388                 return;
389
390         memcpy(&bitfield, &(data[loc]), 2);     loc += 2;
391         bitfield = INTEL_SHORT(bitfield);
392         memcpy(((ubyte *)(&netgame->team_vector) + 1), &bitfield, 2);
393
394         memcpy(&bitfield, &(data[loc]), 2);     loc += 2;
395         bitfield = INTEL_SHORT(bitfield);
396         memcpy(((ubyte *)(&netgame->team_vector) + 3), &bitfield, 2);
397
398 #if 0           // not used since reordering mac bitfields
399         memcpy(&bitfield, &(data[loc]), 2);                                                             loc += 2;
400         new_field = 0;
401         for (i = 15; i >= 0; i--) {
402                 if ( bitfield & (1 << i) )
403                         new_field |= (1 << (15 - i));
404         }
405         new_field = INTEL_SHORT(new_field);
406         memcpy(((ubyte *)(&netgame->team_vector) + 1), &new_field, 2);
407
408         memcpy(&bitfield, &(data[loc]), 2);                                                             loc += 2;
409         new_field = 0;
410         for (i = 15; i >= 0; i--) {
411                 if ( bitfield & (1 << i) )
412                         new_field |= (1 << (15 - i));
413         }
414         new_field = INTEL_SHORT(new_field);
415         memcpy(((ubyte *)(&netgame->team_vector) + 3), &new_field, 2);
416 #endif
417
418         memcpy(netgame->team_name, &(data[loc]), 2*(CALLSIGN_LEN+1));           loc += 2*(CALLSIGN_LEN+1);
419         for (i = 0; i < MAX_PLAYERS; i++) {
420                 memcpy(&(netgame->locations[i]), &(data[loc]), 4);                              loc += 4;
421                 netgame->locations[i] = INTEL_INT(netgame->locations[i]);
422         }
423
424         for (i = 0; i < MAX_PLAYERS; i++) {
425                 for (j = 0; j < MAX_PLAYERS; j++) {
426                         memcpy(&(netgame->kills[i][j]), &(data[loc]), 2);                       loc += 2;
427                         netgame->kills[i][j] = INTEL_SHORT(netgame->kills[i][j]);
428                 }
429         }
430
431         memcpy(&(netgame->segments_checksum), &(data[loc]), 2);                         loc += 2;
432         netgame->segments_checksum = INTEL_SHORT(netgame->segments_checksum);
433         memcpy(&(netgame->team_kills[0]), &(data[loc]), 2);                             loc += 2;
434         netgame->team_kills[0] = INTEL_SHORT(netgame->team_kills[0]);
435         memcpy(&(netgame->team_kills[1]), &(data[loc]), 2);                                     loc += 2;
436         netgame->team_kills[1] = INTEL_SHORT(netgame->team_kills[1]);
437         for (i = 0; i < MAX_PLAYERS; i++) {
438                 memcpy(&(netgame->killed[i]), &(data[loc]), 2);                                 loc += 2;
439                 netgame->killed[i] = INTEL_SHORT(netgame->killed[i]);
440         }
441         for (i = 0; i < MAX_PLAYERS; i++) {
442                 memcpy(&(netgame->player_kills[i]), &(data[loc]), 2);                   loc += 2;
443                 netgame->player_kills[i] = INTEL_SHORT(netgame->player_kills[i]);
444         }
445         memcpy(&(netgame->KillGoal), &(data[loc]), 4);                                          loc += 4;
446         netgame->KillGoal = INTEL_INT(netgame->KillGoal);
447         memcpy(&(netgame->PlayTimeAllowed), &(data[loc]), 4);                           loc += 4;
448         netgame->PlayTimeAllowed = INTEL_INT(netgame->PlayTimeAllowed);
449
450         memcpy(&(netgame->level_time), &(data[loc]), 4);                                        loc += 4;
451         netgame->level_time = INTEL_INT(netgame->level_time);
452         memcpy(&(netgame->control_invul_time), &(data[loc]), 4);                        loc += 4;
453         netgame->control_invul_time = swapint(netgame->control_invul_time);
454         memcpy(&(netgame->monitor_vector), &(data[loc]), 4);                            loc += 4;
455         netgame->monitor_vector = swapint(netgame->monitor_vector);
456         for (i = 0; i < MAX_PLAYERS; i++) {
457                 memcpy(&(netgame->player_score[i]), &(data[loc]), 4);                   loc += 4;
458                 netgame->player_score[i] = swapint(netgame->player_score[i]);
459         }
460         for (i = 0; i < MAX_PLAYERS; i++) {
461                 memcpy(&(netgame->player_flags[i]), &(data[loc]), 1); loc++;
462         }
463         memcpy(&(netgame->PacketsPerSec), &(data[loc]), 2);                                     loc += 2;
464         netgame->PacketsPerSec = INTEL_SHORT(netgame->PacketsPerSec);
465         memcpy(&(netgame->ShortPackets), &(data[loc]), 1);                                      loc ++;
466
467 }
468
469 void swap_object(object *obj)
470 {
471 // swap the short and int entries for this object
472         obj->signature                  = INTEL_INT(obj->signature);
473         obj->next                               = INTEL_SHORT(obj->next);
474         obj->prev                               = INTEL_SHORT(obj->prev);
475         obj->segnum                             = INTEL_SHORT(obj->segnum);
476         obj->pos.x                              = INTEL_INT(obj->pos.x);
477         obj->pos.y                              = INTEL_INT(obj->pos.y);
478         obj->pos.z                              = INTEL_INT(obj->pos.z);
479
480         obj->orient.rvec.x              = INTEL_INT(obj->orient.rvec.x);
481         obj->orient.rvec.y              = INTEL_INT(obj->orient.rvec.y);
482         obj->orient.rvec.z              = INTEL_INT(obj->orient.rvec.z);
483         obj->orient.fvec.x              = INTEL_INT(obj->orient.fvec.x);
484         obj->orient.fvec.y              = INTEL_INT(obj->orient.fvec.y);
485         obj->orient.fvec.z              = INTEL_INT(obj->orient.fvec.z);
486         obj->orient.uvec.x              = INTEL_INT(obj->orient.uvec.x);
487         obj->orient.uvec.y              = INTEL_INT(obj->orient.uvec.y);
488         obj->orient.uvec.z              = INTEL_INT(obj->orient.uvec.z);
489         
490         obj->size                               = INTEL_INT(obj->size);
491         obj->shields                    = INTEL_INT(obj->shields);
492         
493         obj->last_pos.x                 = INTEL_INT(obj->last_pos.x);
494         obj->last_pos.y                 = INTEL_INT(obj->last_pos.y);
495         obj->last_pos.z                 = INTEL_INT(obj->last_pos.z);
496         
497         obj->lifeleft                   = INTEL_INT(obj->lifeleft);
498         
499         switch (obj->movement_type) {
500         
501         case MT_PHYSICS:
502         
503                 obj->mtype.phys_info.velocity.x = INTEL_INT(obj->mtype.phys_info.velocity.x);
504                 obj->mtype.phys_info.velocity.y = INTEL_INT(obj->mtype.phys_info.velocity.y);
505                 obj->mtype.phys_info.velocity.z = INTEL_INT(obj->mtype.phys_info.velocity.z);
506         
507                 obj->mtype.phys_info.thrust.x   = INTEL_INT(obj->mtype.phys_info.thrust.x);
508                 obj->mtype.phys_info.thrust.y   = INTEL_INT(obj->mtype.phys_info.thrust.y);
509                 obj->mtype.phys_info.thrust.z   = INTEL_INT(obj->mtype.phys_info.thrust.z);
510         
511                 obj->mtype.phys_info.mass               = INTEL_INT(obj->mtype.phys_info.mass);
512                 obj->mtype.phys_info.drag               = INTEL_INT(obj->mtype.phys_info.drag);
513                 obj->mtype.phys_info.brakes             = INTEL_INT(obj->mtype.phys_info.brakes);
514         
515                 obj->mtype.phys_info.rotvel.x   = INTEL_INT(obj->mtype.phys_info.rotvel.x);
516                 obj->mtype.phys_info.rotvel.y   = INTEL_INT(obj->mtype.phys_info.rotvel.y);
517                 obj->mtype.phys_info.rotvel.z   = INTEL_INT(obj->mtype.phys_info.rotvel.z);
518         
519                 obj->mtype.phys_info.rotthrust.x = INTEL_INT(obj->mtype.phys_info.rotthrust.x);
520                 obj->mtype.phys_info.rotthrust.y = INTEL_INT(obj->mtype.phys_info.rotthrust.y);
521                 obj->mtype.phys_info.rotthrust.z = INTEL_INT(obj->mtype.phys_info.rotthrust.z);
522         
523                 obj->mtype.phys_info.turnroll   = INTEL_INT(obj->mtype.phys_info.turnroll);
524                 obj->mtype.phys_info.flags              = INTEL_SHORT(obj->mtype.phys_info.flags);
525         
526                 break;
527         
528         case MT_SPINNING:
529                 
530                 obj->mtype.spin_rate.x = INTEL_INT(obj->mtype.spin_rate.x);
531                 obj->mtype.spin_rate.y = INTEL_INT(obj->mtype.spin_rate.y);
532                 obj->mtype.spin_rate.z = INTEL_INT(obj->mtype.spin_rate.z);
533                 break;
534         }
535         
536         switch (obj->control_type) {
537         
538         case CT_WEAPON:
539                 obj->ctype.laser_info.parent_type               = INTEL_SHORT(obj->ctype.laser_info.parent_type);
540                 obj->ctype.laser_info.parent_num                = INTEL_SHORT(obj->ctype.laser_info.parent_num);
541                 obj->ctype.laser_info.parent_signature  = INTEL_INT(obj->ctype.laser_info.parent_signature);
542                 obj->ctype.laser_info.creation_time             = INTEL_INT(obj->ctype.laser_info.creation_time);
543                 obj->ctype.laser_info.last_hitobj               = INTEL_SHORT(obj->ctype.laser_info.last_hitobj);
544                 obj->ctype.laser_info.track_goal                = INTEL_SHORT(obj->ctype.laser_info.track_goal);
545                 obj->ctype.laser_info.multiplier                = INTEL_INT(obj->ctype.laser_info.multiplier);
546                 break;
547         
548         case CT_EXPLOSION:
549                 obj->ctype.expl_info.spawn_time         = INTEL_INT(obj->ctype.expl_info.spawn_time);
550                 obj->ctype.expl_info.delete_time        = INTEL_INT(obj->ctype.expl_info.delete_time);
551                 obj->ctype.expl_info.delete_objnum      = INTEL_SHORT(obj->ctype.expl_info.delete_objnum);
552                 obj->ctype.expl_info.attach_parent      = INTEL_SHORT(obj->ctype.expl_info.attach_parent);
553                 obj->ctype.expl_info.prev_attach        = INTEL_SHORT(obj->ctype.expl_info.prev_attach);
554                 obj->ctype.expl_info.next_attach        = INTEL_SHORT(obj->ctype.expl_info.next_attach);
555                 break;
556         
557         case CT_AI:
558                 obj->ctype.ai_info.hide_segment                 = INTEL_SHORT(obj->ctype.ai_info.hide_segment);
559                 obj->ctype.ai_info.hide_index                   = INTEL_SHORT(obj->ctype.ai_info.hide_index);
560                 obj->ctype.ai_info.path_length                  = INTEL_SHORT(obj->ctype.ai_info.path_length);
561                 obj->ctype.ai_info.danger_laser_num             = INTEL_SHORT(obj->ctype.ai_info.danger_laser_num);
562                 obj->ctype.ai_info.danger_laser_signature = INTEL_INT(obj->ctype.ai_info.danger_laser_signature);
563                 obj->ctype.ai_info.dying_start_time     = INTEL_INT(obj->ctype.ai_info.dying_start_time);
564                 break;
565         
566         case CT_LIGHT:
567                 obj->ctype.light_info.intensity = INTEL_INT(obj->ctype.light_info.intensity);
568                 break;
569         
570         case CT_POWERUP:
571                 obj->ctype.powerup_info.count = INTEL_INT(obj->ctype.powerup_info.count);
572                 obj->ctype.powerup_info.creation_time = INTEL_INT(obj->ctype.powerup_info.creation_time);
573                 //Below commented out 5/2/96 by Matt.  I asked Allender why it was
574                 //here, and he didn't know, and it looks like it doesn't belong.
575                 //if (obj->id == POW_VULCAN_WEAPON)
576                 //      obj->ctype.powerup_info.count = VULCAN_WEAPON_AMMO_AMOUNT;
577                 break;
578         
579         }
580         
581         switch (obj->render_type) {
582         
583         case RT_MORPH:
584         case RT_POLYOBJ: {
585                 int i;
586         
587                 obj->rtype.pobj_info.model_num          = INTEL_INT(obj->rtype.pobj_info.model_num);
588         
589                 for (i=0;i<MAX_SUBMODELS;i++) {
590                         obj->rtype.pobj_info.anim_angles[i].p = INTEL_INT(obj->rtype.pobj_info.anim_angles[i].p);
591                         obj->rtype.pobj_info.anim_angles[i].b = INTEL_INT(obj->rtype.pobj_info.anim_angles[i].b);
592                         obj->rtype.pobj_info.anim_angles[i].h = INTEL_INT(obj->rtype.pobj_info.anim_angles[i].h);
593                 }
594         
595                 obj->rtype.pobj_info.subobj_flags       = INTEL_INT(obj->rtype.pobj_info.subobj_flags);
596                 obj->rtype.pobj_info.tmap_override      = INTEL_INT(obj->rtype.pobj_info.tmap_override);
597                 obj->rtype.pobj_info.alt_textures       = INTEL_INT(obj->rtype.pobj_info.alt_textures);
598                 break;
599         }
600         
601         case RT_WEAPON_VCLIP:
602         case RT_HOSTAGE:
603         case RT_POWERUP:
604         case RT_FIREBALL:
605                 obj->rtype.vclip_info.vclip_num = INTEL_INT(obj->rtype.vclip_info.vclip_num);
606                 obj->rtype.vclip_info.frametime = INTEL_INT(obj->rtype.vclip_info.frametime);
607                 break;
608         
609         case RT_LASER:
610                 break;
611         
612         }
613 //  END OF SWAPPING OBJECT STRUCTURE
614
615 }
616
617 #else
618
619
620 // Calculates the checksum of a block of memory.
621 ushort netmisc_calc_checksum( void * vptr, int len )
622 {
623         ubyte * ptr = (ubyte *)vptr;
624         unsigned int sum1,sum2;
625
626         sum1 = sum2 = 0;
627
628         while(len--)    {
629                 sum1 += *ptr++;
630                 if (sum1 >= 255 ) sum1 -= 255;
631                 sum2 += sum1;
632         }
633         sum2 %= 255;
634         
635         return ((sum1<<8)+ sum2);
636 }
637
638 #endif
639 //--unused-- //Finds the difference between block1 and block2.  Fills in diff_buffer and 
640 //--unused-- //returns the size of diff_buffer.
641 //--unused-- int netmisc_find_diff( void *block1, void *block2, int block_size, void *diff_buffer )
642 //--unused-- {
643 //--unused--    int mode;
644 //--unused--    ushort *c1, *c2, *diff_start, *c3;
645 //--unused--    int i, j, size, diff, n , same;
646 //--unused-- 
647 //--unused--    size=(block_size+1)/sizeof(ushort);
648 //--unused--    c1 = (ushort *)block1;
649 //--unused--    c2 = (ushort *)block2;
650 //--unused--    c3 = (ushort *)diff_buffer;
651 //--unused-- 
652 //--unused--    mode = same = diff = n = 0;
653 //--unused-- 
654 //--unused--    //mprintf( 0, "=================================\n" );
655 //--unused-- 
656 //--unused--    for (i=0; i<size; i++, c1++, c2++ )     {
657 //--unused--            if (*c1 != *c2 ) {
658 //--unused--                    if (mode==0)    {
659 //--unused--                            mode = 1;
660 //--unused--                            //mprintf( 0, "%ds ", same );
661 //--unused--                            c3[n++] = same;
662 //--unused--                            same=0; diff=0;
663 //--unused--                            diff_start = c2;
664 //--unused--                    }
665 //--unused--                    *c1 = *c2;
666 //--unused--                    diff++;
667 //--unused--                    if (diff==65535) {
668 //--unused--                            mode = 0;
669 //--unused--                            // send how many diff ones.
670 //--unused--                            //mprintf( 0, "%dd ", diff );
671 //--unused--                            c3[n++]=diff;
672 //--unused--                            // send all the diff ones.
673 //--unused--                            for (j=0; j<diff; j++ )
674 //--unused--                                    c3[n++] = diff_start[j];
675 //--unused--                            same=0; diff=0;
676 //--unused--                            diff_start = c2;
677 //--unused--                    }
678 //--unused--            } else {
679 //--unused--                    if (mode==1)    {
680 //--unused--                            mode=0;
681 //--unused--                            // send how many diff ones.
682 //--unused--                            //mprintf( 0, "%dd ", diff );
683 //--unused--                            c3[n++]=diff;
684 //--unused--                            // send all the diff ones.
685 //--unused--                            for (j=0; j<diff; j++ )
686 //--unused--                                    c3[n++] = diff_start[j];
687 //--unused--                            same=0; diff=0;
688 //--unused--                            diff_start = c2;
689 //--unused--                    }
690 //--unused--                    same++;
691 //--unused--                    if (same==65535)        {
692 //--unused--                            mode=1;
693 //--unused--                            // send how many the same
694 //--unused--                            //mprintf( 0, "%ds ", same );
695 //--unused--                            c3[n++] = same;
696 //--unused--                            same=0; diff=0;
697 //--unused--                            diff_start = c2;
698 //--unused--                    }
699 //--unused--            }
700 //--unused--    
701 //--unused--    }
702 //--unused--    if (mode==0)    {
703 //--unused--            // send how many the same
704 //--unused--            //mprintf( 0, "%ds ", same );
705 //--unused--            c3[n++] = same;
706 //--unused--    } else {
707 //--unused--            // send how many diff ones.
708 //--unused--            //mprintf( 0, "%dd ", diff );
709 //--unused--            c3[n++]=diff;
710 //--unused--            // send all the diff ones.
711 //--unused--            for (j=0; j<diff; j++ )
712 //--unused--                    c3[n++] = diff_start[j];
713 //--unused--    }
714 //--unused-- 
715 //--unused--    //mprintf( 0, "=================================\n" );
716 //--unused--    
717 //--unused--    return n*2;
718 //--unused-- }
719
720 //--unused-- //Applies diff_buffer to block1 to create a new block1.  Returns the final
721 //--unused-- //size of block1.
722 //--unused-- int netmisc_apply_diff(void *block1, void *diff_buffer, int diff_size )    
723 //--unused-- {
724 //--unused--    unsigned int i, j, n, size;
725 //--unused--    ushort *c1, *c2;
726 //--unused-- 
727 //--unused--    //mprintf( 0, "=================================\n" );
728 //--unused--    c1 = (ushort *)diff_buffer;
729 //--unused--    c2 = (ushort *)block1;
730 //--unused-- 
731 //--unused--    size = diff_size/2;
732 //--unused-- 
733 //--unused--    i=j=0;
734 //--unused--    while (1)       {
735 //--unused--            j += c1[i];                     // Same
736 //--unused--            //mprintf( 0, "%ds ", c1[i] );
737 //--unused--            i++;
738 //--unused--            if ( i>=size) break;
739 //--unused--            n = c1[i];                      // ndiff
740 //--unused--            //mprintf( 0, "%dd ", c1[i] );
741 //--unused--            i++;
742 //--unused--            if (n>0)        {
743 //--unused--                    //Assert( n* < 256 );
744 //--unused--                    memcpy( &c2[j], &c1[i], n*2 );
745 //--unused--                    i += n;
746 //--unused--                    j += n;
747 //--unused--            }
748 //--unused--            if ( i>=size) break;
749 //--unused--    }
750 //--unused--    //mprintf( 0, "=================================\n" );
751 //--unused-- 
752 //--unused--    return j*2;
753 //--unused-- }
754