main/netpkt.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-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12 */
  13
  14 /*
  15  * $Source: /cvs/cvsroot/d2x/main/netpkt.c,v $
  16  * $Revision: 1.2 $
  17  * $Author: bradleyb $
  18  * $Date: 2002-02-14 09:24:19 $
  19  *
  20  * Network packet conversions
  21  * Based on macnet.c from MAC version of Descent 1
  22  *
  23  * $Log: not supported by cvs2svn $
  24  * Revision 1.1  2002/02/14 09:05:33  bradleyb
  25  * Lotsa networking stuff from d1x
  26  *
  27  *
  28  */
  29
  30 #ifdef HAVE_CONFIG_H
  31 #include <conf.h>
  32 #endif
  33
  34 #include <string.h>
  35 #include "pstypes.h"
  36 #include "multi.h"
  37 #include "network.h"
  38 #include "object.h"
  39 #include "powerup.h"
  40 #include "error.h"
  41 #include "ipx.h"
  42 #include "netpkt.h"
  43
  44 void receive_netplayer_info(ubyte *data, netplayer_info *info, int d2x)
  45 {
  46         int loc = 0;
  47
  48         memcpy(info->callsign, &(data[loc]), CALLSIGN_LEN);           loc += CALLSIGN_LEN;
  49         info->callsign[CALLSIGN_LEN] = 0;
  50         if (!d2x) loc++;
  51         memcpy(&(info->network.ipx.server), &(data[loc]), 4);                             loc += 4;
  52         memcpy(&(info->network.ipx.node), &(data[loc]), 6);                                       loc += 6;
  53         memcpy(&(info->socket), &(data[loc]), 2);                                 loc += 2;
  54 //MWA  don't think we need to swap this because we need it in high order        info->socket = swapshort(info->socket);
  55         info->connected = data[loc]; loc++;
  56         #ifndef SHAREWARE
  57  //edited 03/04/99 Matt Mueller - sub_protocol was being set wrong in non-d2x games.. I still think its screwed somewhere else too though
  58         if (d2x){
  59                 info->sub_protocol = data[loc]; loc++;
  60 //              printf ("%i "__FUNCTION__ " name=%s sub_protocol=%i\n",Player_num,info->callsign,info->sub_protocol);
  61         }else
  62                 info->sub_protocol = 0;
  63 //end edit -MM
  64         #endif
  65 }
  66
  67 void send_sequence_packet(sequence_packet seq, ubyte *server, ubyte *node, ubyte *net_address)
  68 {
  69         short tmps;
  70         int loc;
  71
  72         loc = 0;
  73         memset(out_buffer, 0, sizeof(out_buffer));
  74         out_buffer[0] = seq.type;                       loc++;
  75         memcpy(&(out_buffer[loc]), seq.player.callsign, CALLSIGN_LEN+1);                loc += CALLSIGN_LEN+1;
  76         memcpy(&(out_buffer[loc]), seq.player.network.ipx.server, 4);     loc += 4;
  77         memcpy(&(out_buffer[loc]), seq.player.network.ipx.node, 6);       loc += 6;
  78         tmps = swapshort(seq.player.socket);
  79         memcpy(&(out_buffer[loc]), &tmps, 2);           loc += 2;
  80         out_buffer[loc] = seq.player.connected; loc++;
  81         out_buffer[loc] = MULTI_PROTO_D2X_MINOR; loc++;
  82
  83         if (net_address != NULL)
  84                 ipx_send_packet_data( out_buffer, loc, server, node, net_address);
  85         else if ((server == NULL) && (node == NULL))
  86                 ipx_send_broadcast_packet_data( out_buffer, loc );
  87         else
  88                 ipx_send_internetwork_packet_data( out_buffer, loc, server, node);
  89 }
  90
  91 void receive_sequence_packet(ubyte *data, sequence_packet *seq)
  92 {
  93         int loc = 0;
  94
  95         seq->type = data[0];                            loc++;
  96         receive_netplayer_info(&(data[loc]), &(seq->player), 0);
  97 }
  98
  99
 100 void send_netgame_packet(ubyte *server, ubyte *node)
 101 {
 102         uint tmpi;
 103         ushort tmps;
 104         int i, j;
 105         int loc = 0;
 106
 107 #ifndef SHAREWARE
 108         if (Netgame.protocol_version == MULTI_PROTO_D2X_VER) {
 109                 send_d2x_netgame_packet(server, node);
 110                 return;
 111         }
 112 #endif
 113         memset(out_buffer, 0, IPX_MAX_DATA_SIZE);
 114         out_buffer[loc] = Netgame.type; loc++;
 115         memcpy(&(out_buffer[loc]), Netgame.game_name, NETGAME_NAME_LEN+1); loc += (NETGAME_NAME_LEN+1);
 116         memcpy(&(out_buffer[loc]), Netgame.team_name, 2*(CALLSIGN_LEN+1)); loc += 2*(CALLSIGN_LEN+1);
 117         out_buffer[loc] = Netgame.gamemode; loc++;
 118         out_buffer[loc] = Netgame.difficulty; loc++;
 119         out_buffer[loc] = Netgame.game_status; loc++;
 120         out_buffer[loc] = Netgame.numplayers; loc++;
 121         out_buffer[loc] = Netgame.max_numplayers; loc++;
 122         out_buffer[loc] = Netgame.game_flags; loc++;
 123         for (i = 0; i < MAX_PLAYERS; i++) {
 124                 memcpy(&(out_buffer[loc]), NetPlayers.players[i].callsign, CALLSIGN_LEN+1);     loc += CALLSIGN_LEN+1;
 125                 memcpy(&(out_buffer[loc]), NetPlayers.players[i].network.ipx.server, 4);                                  loc += 4;
 126                 memcpy(&(out_buffer[loc]), NetPlayers.players[i].network.ipx.node, 6);                                    loc += 6;
 127                 memcpy(&(out_buffer[loc]), &(NetPlayers.players[i].socket), 2);                           loc += 2;
 128                 memcpy(&(out_buffer[loc]), &(NetPlayers.players[i].connected), 1);                              loc++;
 129         }
 130         if (Netgame.protocol_version == MULTI_PROTO_D2X_VER) {
 131                 for (i = 0; i < MAX_PLAYERS; i++) {
 132                         out_buffer[loc] = Netgame.locations[i]; loc++;
 133                 }
 134         } else {
 135                 for (i = 0; i < MAX_PLAYERS; i++) {
 136                         tmpi = swapint(Netgame.locations[i]);
 137                         memcpy(&(out_buffer[loc]), &tmpi, 4); loc += 4;                 // SWAP HERE!!!
 138                 }
 139         }
 140
 141         for (i = 0; i < MAX_PLAYERS; i++) {
 142                 for (j = 0; j < MAX_PLAYERS; j++) {
 143                         tmps = swapshort(Netgame.kills[i][j]);
 144                         memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2;                 // SWAP HERE!!!
 145                 }
 146         }
 147
 148         tmpi = swapint(Netgame.levelnum);
 149         memcpy(&(out_buffer[loc]), &tmpi, 4); loc += 4;                         // SWAP_HERE
 150         out_buffer[loc] = Netgame.protocol_version; loc++;
 151         out_buffer[loc] = Netgame.team_vector; loc++;
 152         tmps = swapshort(Netgame.segments_checksum);
 153         memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2;                         // SWAP_HERE
 154         tmps = swapshort(Netgame.team_kills[0]);
 155         memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2;                         // SWAP_HERE
 156         tmps = swapshort(Netgame.team_kills[1]);
 157         memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2;                         // SWAP_HERE
 158         for (i = 0; i < MAX_PLAYERS; i++) {
 159                 tmps = swapshort(Netgame.killed[i]);
 160                 memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2;                 // SWAP HERE!!!
 161         }
 162         for (i = 0; i < MAX_PLAYERS; i++) {
 163                 tmps = swapshort(Netgame.player_kills[i]);
 164                 memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2;                 // SWAP HERE!!!
 165         }
 166
 167 #ifndef SHAREWARE
 168         tmpi = swapint(Netgame.level_time);
 169         memcpy(&(out_buffer[loc]), &tmpi, 4); loc += 4;                         // SWAP_HERE
 170         tmpi = swapint(Netgame.control_invul_time);
 171         memcpy(&(out_buffer[loc]), &tmpi, 4); loc += 4;                         // SWAP_HERE
 172         tmpi = swapint(Netgame.monitor_vector);
 173         memcpy(&(out_buffer[loc]), &tmpi, 4); loc += 4;                         // SWAP_HERE
 174         for (i = 0; i < 8; i++) {
 175                 tmpi = swapint(Netgame.player_score[i]);
 176                 memcpy(&(out_buffer[loc]), &tmpi, 4); loc += 4;                         // SWAP_HERE
 177         }
 178         for (i = 0; i < 8; i++) {
 179                 memcpy(&(out_buffer[loc]), &(Netgame.player_flags[i]), 1); loc++;
 180         }
 181         memcpy(&(out_buffer[loc]), Netgame.mission_name, 9); loc += 9;
 182         memcpy(&(out_buffer[loc]), Netgame.mission_title, MISSION_NAME_LEN+1); loc += (MISSION_NAME_LEN+1);
 183         if (Netgame.protocol_version == MULTI_PROTO_D2X_VER) {
 184             out_buffer[loc] = Netgame.PacketsPerSec; loc++;
 185             tmpi = swapint(Netgame.flags);
 186             memcpy(&out_buffer[loc], &tmpi, 4); loc += 4;
 187         }
 188 #endif
 189
 190         if (server == NULL)
 191                 ipx_send_broadcast_packet_data(out_buffer, loc);
 192         else
 193                 ipx_send_internetwork_packet_data( out_buffer, loc, server, node );
 194 }
 195
 196 void receive_netgame_packet(ubyte *data, netgame_info *netgame, AllNetPlayers_info *netplayers, int d2x)
 197 {
 198         int i, j;
 199         int loc = 0;
 200 #ifndef SHAREWARE
 201         if (d2x) {
 202                 receive_d2x_netgame_packet(data, netgame, netplayers);
 203                 return;
 204         }
 205 #endif
 206
 207         netgame->type = data[loc];      loc++;
 208         memcpy(netgame->game_name, &(data[loc]), NETGAME_NAME_LEN+1); loc += (NETGAME_NAME_LEN+1);
 209         memcpy(netgame->team_name, &(data[loc]), 2*(CALLSIGN_LEN+1)); loc += 2*(CALLSIGN_LEN+1);
 210         netgame->gamemode = data[loc]; loc++;
 211         netgame->difficulty = data[loc]; loc++;
 212         netgame->game_status = data[loc]; loc++;
 213         netgame->numplayers = data[loc]; loc++;
 214         netgame->max_numplayers = data[loc]; loc++;
 215         netgame->game_flags = data[loc]; loc++;
 216         for (i = 0; i < MAX_PLAYERS; i++) {
 217                 receive_netplayer_info(&(data[loc]), &(netplayers->players[i]), 0);
 218                 loc += sizeof(netplayer_info);//NETPLAYER_ORIG_SIZE;
 219         }
 220 #if 0
 221         if (d2x) {
 222                 for (i = 0; i < MAX_PLAYERS; i++) {
 223                         netgame->locations[i] = data[loc]; loc++;
 224                 }
 225         } else
 226 #endif
 227         {
 228                 for (i = 0; i < MAX_PLAYERS; i++) {
 229                         memcpy(&(netgame->locations[i]), &(data[loc]), 4); loc += 4;                    // SWAP HERE!!!
 230                         netgame->locations[i] = swapint(netgame->locations[i]);
 231                 }
 232         }
 233
 234         for (i = 0; i < MAX_PLAYERS; i++) {
 235                 for (j = 0; j < MAX_PLAYERS; j++) {
 236                         memcpy(&(netgame->kills[i][j]), &(data[loc]), 2); loc += 2;                     // SWAP HERE!!!
 237                         netgame->kills[i][j] = swapshort(netgame->kills[i][j]);
 238                 }
 239         }
 240
 241         memcpy(&(netgame->levelnum), &(data[loc]), 4); loc += 4;                                // SWAP_HERE
 242         netgame->levelnum = swapint(netgame->levelnum);
 243         netgame->protocol_version = data[loc]; loc++;
 244         netgame->team_vector = data[loc]; loc++;
 245         memcpy(&(netgame->segments_checksum), &(data[loc]), 2); loc += 2;                               // SWAP_HERE
 246         netgame->segments_checksum = swapshort(netgame->segments_checksum);
 247         memcpy(&(netgame->team_kills[0]), &(data[loc]), 2); loc += 2;                           // SWAP_HERE
 248         netgame->team_kills[0] = swapshort(netgame->team_kills[0]);
 249         memcpy(&(netgame->team_kills[1]), &(data[loc]), 2); loc += 2;                           // SWAP_HERE
 250         netgame->team_kills[1] = swapshort(netgame->team_kills[1]);
 251         for (i = 0; i < MAX_PLAYERS; i++) {
 252                 memcpy(&(netgame->killed[i]), &(data[loc]), 2); loc += 2;                       // SWAP HERE!!!
 253                 netgame->killed[i] = swapshort(netgame->killed[i]);
 254         }
 255         for (i = 0; i < MAX_PLAYERS; i++) {
 256                 memcpy(&(netgame->player_kills[i]), &(data[loc]), 2); loc += 2;                 // SWAP HERE!!!
 257                 netgame->player_kills[i] = swapshort(netgame->player_kills[i]);
 258         }
 259
 260 #ifndef SHAREWARE
 261         memcpy(&(netgame->level_time), &(data[loc]), 4); loc += 4;                              // SWAP_HERE
 262         netgame->level_time = swapint(netgame->level_time);
 263         memcpy(&(netgame->control_invul_time), &(data[loc]), 4); loc += 4;                              // SWAP_HERE
 264         netgame->control_invul_time = swapint(netgame->control_invul_time);
 265         memcpy(&(netgame->monitor_vector), &(data[loc]), 4); loc += 4;                          // SWAP_HERE
 266         netgame->monitor_vector = swapint(netgame->monitor_vector);
 267         for (i = 0; i < 8; i++) {
 268                 memcpy(&(netgame->player_score[i]), &(data[loc]), 4); loc += 4;                         // SWAP_HERE
 269                 netgame->player_score[i] = swapint(netgame->player_score[i]);
 270         }
 271         memcpy(netgame->player_flags, &(data[loc]), 8); loc += 8;
 272 #if 0
 273         for (i = 0; i < 8; i++) {
 274                 memcpy(&(netgame->player_flags[i]), &(data[loc]), 1); loc++;
 275         }
 276 #endif
 277
 278         memcpy(netgame->mission_name, &(data[loc]), 9); loc += 9;
 279         memcpy(netgame->mission_title, &(data[loc]), MISSION_NAME_LEN+1); loc += (MISSION_NAME_LEN+1);
 280 #if 0
 281         if (d2x && netgame->protocol_version == MULTI_PROTO_D2X_VER) {
 282             netgame->packets_per_sec = data[loc]; loc++;
 283             memcpy(&netgame->flags, &data[loc], 4); loc += 4;
 284             netgame->flags = swapint(netgame->flags);
 285         }
 286 #endif
 287 #endif
 288 }
 289
 290 #ifndef SHAREWARE
 291 void store_netplayer_info(ubyte *data, netplayer_info *player, int d2x)
 292 {
 293         memcpy(data, player->callsign, CALLSIGN_LEN);      data += CALLSIGN_LEN;
 294         if (!d2x) *(data++) = 0;
 295         memcpy(data, player->network.ipx.server, 4);               data += 4;
 296         memcpy(data, player->network.ipx.node, 6);                         data += 6;
 297         memcpy(data, &player->socket, 2);                data += 2;
 298         *data = player->connected;     data++;
 299         if (d2x) {
 300                 *data = player->sub_protocol;  data++;
 301 //          printf ("%i "__FUNCTION__ " name=%s sub_protocol=%i\n",Player_num,player->callsign,player->sub_protocol);
 302         }
 303 }
 304
 305 void send_d2x_netgame_packet(ubyte *server, ubyte *node)
 306 {
 307         uint tmpi;
 308         ushort tmps;
 309         int i, j;
 310         int loc = 0;
 311
 312         memset(out_buffer, 0, IPX_MAX_DATA_SIZE);
 313         out_buffer[loc] = Netgame.type; loc++;
 314         out_buffer[loc] = MULTI_PROTO_D2X_VER; loc++;
 315         out_buffer[loc] = Netgame.subprotocol; loc++;
 316         out_buffer[loc] = Netgame.required_subprotocol; loc++;
 317         memcpy(&(out_buffer[loc]), Netgame.game_name, NETGAME_NAME_LEN); loc += NETGAME_NAME_LEN;
 318         memcpy(&(out_buffer[loc]), Netgame.mission_name, 8); loc += 8;
 319         memcpy(&(out_buffer[loc]), Netgame.mission_title, MISSION_NAME_LEN); loc += MISSION_NAME_LEN;
 320         out_buffer[loc] = Netgame.levelnum; loc++;
 321         out_buffer[loc] = Netgame.gamemode; loc++;
 322         out_buffer[loc] = Netgame.difficulty; loc++;
 323         out_buffer[loc] = Netgame.game_status; loc++;
 324         out_buffer[loc] = Netgame.game_flags; loc++;
 325         out_buffer[loc] = Netgame.max_numplayers; loc++;
 326         out_buffer[loc] = Netgame.team_vector; loc++;
 327         if (Netgame.type == PID_D2X_GAME_LITE) {
 328                 int master = -1;
 329                 j = 0;
 330                 for (i = 0; i < Netgame.numplayers; i++)
 331                         if (Players[i].connected) {
 332                                 if (master == -1)
 333                                         master = i;
 334                                 j++;
 335                         }
 336                 out_buffer[loc] = j; loc++; /* numconnected */
 337                 if (master == -1)   /* should not happen, but... */
 338                         master = Player_num;
 339                 store_netplayer_info(&(out_buffer[loc]), &NetPlayers.players[master], 1); loc += sizeof(netplayer_info); //NETPLAYER_D2X_SIZE;
 340                 //added 4/18/99 Matt Mueller - send .flags as well, so 'I' can show them
 341                 tmpi = swapint(Netgame.flags);
 342                 memcpy(&out_buffer[loc], &tmpi, 4); loc += 4;
 343                 //end addition -MM
 344         } else {
 345                 out_buffer[loc] = Netgame.numplayers; loc++;
 346                 out_buffer[loc] = sizeof(netplayer_info); //NETPLAYER_D2X_SIZE; // sizeof netplayer struct
 347                 loc++;
 348                 for (i = 0; i < MAX_PLAYERS; i++) {
 349                         store_netplayer_info(&(out_buffer[loc]), &NetPlayers.players[i], 1);
 350                         loc += sizeof(netplayer_info); //NETPLAYER_D2X_SIZE;
 351                 }
 352                 memcpy(&(out_buffer[loc]), Netgame.team_name[0], CALLSIGN_LEN); loc += CALLSIGN_LEN;
 353                 memcpy(&(out_buffer[loc]), Netgame.team_name[1], CALLSIGN_LEN); loc += CALLSIGN_LEN;
 354                 for (i = 0; i < MAX_PLAYERS; i++) {
 355                         out_buffer[loc] = Netgame.locations[i]; loc++;
 356                 }
 357                 for (i = 0; i < MAX_PLAYERS; i++) {
 358                         for (j = 0; j < MAX_PLAYERS; j++) {
 359                                 tmps = swapshort(Netgame.kills[i][j]);
 360                                 memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2;         // SWAP HERE!!!
 361                         }
 362                 }
 363                 tmps = swapshort(Netgame.segments_checksum);
 364                 memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2;                         // SWAP_HERE
 365                 tmps = swapshort(Netgame.team_kills[0]);
 366                 memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2;                         // SWAP_HERE
 367                 tmps = swapshort(Netgame.team_kills[1]);
 368                 memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2;                         // SWAP_HERE
 369                 for (i = 0; i < MAX_PLAYERS; i++) {
 370                         tmps = swapshort(Netgame.killed[i]);
 371                         memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2;                 // SWAP HERE!!!
 372                 }
 373                 for (i = 0; i < MAX_PLAYERS; i++) {
 374                         tmps = swapshort(Netgame.player_kills[i]);
 375                         memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2;                 // SWAP HERE!!!
 376                 }
 377                 tmpi = swapint(Netgame.level_time);
 378                 memcpy(&(out_buffer[loc]), &tmpi, 4); loc += 4;                         // SWAP_HERE
 379                 tmpi = swapint(Netgame.control_invul_time);
 380                 memcpy(&(out_buffer[loc]), &tmpi, 4); loc += 4;                         // SWAP_HERE
 381                 tmpi = swapint(Netgame.monitor_vector);
 382                 memcpy(&(out_buffer[loc]), &tmpi, 4); loc += 4;                         // SWAP_HERE
 383                 for (i = 0; i < 8; i++) {
 384                         tmpi = swapint(Netgame.player_score[i]);
 385                         memcpy(&(out_buffer[loc]), &tmpi, 4); loc += 4;                         // SWAP_HERE
 386                 }
 387                 memcpy(&(out_buffer[loc]), Netgame.player_flags, MAX_PLAYERS); loc += MAX_PLAYERS;
 388                 out_buffer[loc] = Netgame.PacketsPerSec; loc++;
 389                 tmpi = swapint(Netgame.flags);
 390                 memcpy(&out_buffer[loc], &tmpi, 4); loc += 4;
 391         }
 392
 393         if (server == NULL)
 394                 ipx_send_broadcast_packet_data(out_buffer, loc);
 395         else
 396                 ipx_send_internetwork_packet_data(out_buffer, loc, server, node);
 397 }
 398
 399 void receive_d2x_netgame_packet(ubyte *data, netgame_info *netgame, AllNetPlayers_info *netplayers) {
 400         int i, j;
 401         int loc = 0;
 402
 403         netgame->type = data[loc];      loc++;
 404         if (netgame->type == PID_D2X_GAME_LITE) {
 405                 memset(netgame, 0, sizeof(netgame_info));
 406                 netgame->type = PID_D2X_GAME_LITE;
 407         }
 408         netgame->protocol_version = data[loc]; loc++;
 409         netgame->subprotocol = data[loc]; loc++;
 410         netgame->required_subprotocol = data[loc]; loc++;
 411         memcpy(netgame->game_name, &(data[loc]), NETGAME_NAME_LEN); loc += NETGAME_NAME_LEN;
 412         netgame->game_name[NETGAME_NAME_LEN] = 0;
 413         memcpy(netgame->mission_name, &(data[loc]), 8); loc += 8;
 414         netgame->mission_name[8] = 0;
 415         memcpy(netgame->mission_title, &(data[loc]), MISSION_NAME_LEN); loc += MISSION_NAME_LEN;
 416         netgame->mission_title[MISSION_NAME_LEN] = 0;
 417         netgame->levelnum = ((signed char *)data)[loc]; loc++;
 418         netgame->gamemode = data[loc]; loc++;
 419         netgame->difficulty = data[loc]; loc++;
 420         netgame->game_status = data[loc]; loc++;
 421         netgame->game_flags = data[loc]; loc++;
 422         netgame->max_numplayers = data[loc]; loc++;
 423         netgame->team_vector = data[loc]; loc++;
 424         if (netgame->type == PID_D2X_GAME_LITE) {
 425                 j = netgame->numplayers = data[loc]; loc++;
 426                 for (i = 0; i < j; i++)
 427                         netplayers->players[i].connected = 1;
 428                 receive_netplayer_info(&(data[loc]), &(netplayers->players[0]), 1);loc += sizeof(netplayer_info); //NETPLAYER_D2X_SIZE;
 429                 //added 4/18/99 Matt Mueller - send .flags as well, so 'I' can show them
 430                 if (netgame->subprotocol>=1){
 431                         memcpy(&netgame->flags, &data[loc], 4); loc += 4;
 432                         netgame->flags = swapint(netgame->flags);
 433                 }
 434                 //end addition -MM
 435         } else {
 436                 netgame->numplayers = data[loc]; loc++;
 437                 j = data[loc]; loc++; // sizeof netplayer struct
 438                 if (j > 29) { /* sanity: 304+29*8=536, just below IPX_MAX=542 */
 439                     netgame->protocol_version = 0; return;
 440                 }
 441                 for (i = 0; i < MAX_PLAYERS; i++) {
 442                         receive_netplayer_info(&(data[loc]), &(netplayers->players[i]), 1);
 443                         loc += j;
 444                 }
 445                 memcpy(netgame->team_name[0], &(data[loc]), CALLSIGN_LEN); loc += CALLSIGN_LEN;
 446                 netgame->team_name[0][CALLSIGN_LEN] = 0;
 447                 memcpy(netgame->team_name[1], &(data[loc]), CALLSIGN_LEN); loc += CALLSIGN_LEN;
 448                 netgame->team_name[1][CALLSIGN_LEN] = 0;
 449                 for (i = 0; i < MAX_PLAYERS; i++) {
 450                         netgame->locations[i] = data[loc]; loc++;
 451                 }
 452                 for (i = 0; i < MAX_PLAYERS; i++) {
 453                         for (j = 0; j < MAX_PLAYERS; j++) {
 454                                 memcpy(&(netgame->kills[i][j]), &(data[loc]), 2); loc += 2;                     // SWAP HERE!!!
 455                                 netgame->kills[i][j] = swapshort(netgame->kills[i][j]);
 456                         }
 457                 }
 458                 memcpy(&(netgame->segments_checksum), &(data[loc]), 2); loc += 2;                               // SWAP_HERE
 459                 netgame->segments_checksum = swapshort(netgame->segments_checksum);
 460                 memcpy(&(netgame->team_kills[0]), &(data[loc]), 2); loc += 2;                           // SWAP_HERE
 461                 netgame->team_kills[0] = swapshort(netgame->team_kills[0]);
 462                 memcpy(&(netgame->team_kills[1]), &(data[loc]), 2); loc += 2;                           // SWAP_HERE
 463                 netgame->team_kills[1] = swapshort(netgame->team_kills[1]);
 464                 for (i = 0; i < MAX_PLAYERS; i++) {
 465                         memcpy(&(netgame->killed[i]), &(data[loc]), 2); loc += 2;                       // SWAP HERE!!!
 466                         netgame->killed[i] = swapshort(netgame->killed[i]);
 467                 }
 468                 for (i = 0; i < MAX_PLAYERS; i++) {
 469                         memcpy(&(netgame->player_kills[i]), &(data[loc]), 2); loc += 2;                 // SWAP HERE!!!
 470                         netgame->player_kills[i] = swapshort(netgame->player_kills[i]);
 471                 }
 472                 memcpy(&(netgame->level_time), &(data[loc]), 4); loc += 4;                              // SWAP_HERE
 473                 netgame->level_time = swapint(netgame->level_time);
 474                 memcpy(&(netgame->control_invul_time), &(data[loc]), 4); loc += 4;                              // SWAP_HERE
 475                 netgame->control_invul_time = swapint(netgame->control_invul_time);
 476                 memcpy(&(netgame->monitor_vector), &(data[loc]), 4); loc += 4;                          // SWAP_HERE
 477                 netgame->monitor_vector = swapint(netgame->monitor_vector);
 478                 for (i = 0; i < 8; i++) {
 479                         memcpy(&(netgame->player_score[i]), &(data[loc]), 4); loc += 4;                         // SWAP_HERE
 480                         netgame->player_score[i] = swapint(netgame->player_score[i]);
 481                 }
 482                 memcpy(netgame->player_flags, &(data[loc]), 8); loc += 8;
 483                 netgame->PacketsPerSec = data[loc]; loc++;
 484                 memcpy(&netgame->flags, &data[loc], 4); loc += 4;
 485                 netgame->flags = swapint(netgame->flags);
 486         }
 487 }
 488 #endif
 489
 490 void send_frameinfo_packet(ubyte *server, ubyte *node, ubyte *address, int short_packet)
 491 {
 492         int loc, tmpi;
 493         short tmps;
 494 #ifndef SHAREWARE
 495         ushort tmpus;
 496 #endif
 497         object *pl_obj = &Objects[Players[Player_num].objnum];
 498
 499         loc = 0;
 500         memset(out_buffer, 0, IPX_MAX_DATA_SIZE);
 501 #ifdef SHAREWARE
 502         out_buffer[0] = PID_PDATA;              loc++;
 503         tmpi = swapint(MySyncPack.numpackets);
 504         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 505         tmps = swapshort(Players[Player_num].objnum);
 506         memcpy(&(out_buffer[loc]), &tmps, 2);   loc += 2;
 507         out_buffer[loc] = Player_num; loc++;
 508         tmps = swapshort(pl_obj->segnum);
 509         memcpy(&(out_buffer[loc]), &tmps, 2);   loc += 2;
 510
 511         tmpi = swapint((int)pl_obj->pos.x);
 512         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 513         tmpi = swapint((int)pl_obj->pos.y);
 514         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 515         tmpi = swapint((int)pl_obj->pos.z);
 516         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 517
 518         tmpi = swapint((int)pl_obj->orient.rvec.x);
 519         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 520         tmpi = swapint((int)pl_obj->orient.rvec.y);
 521         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 522         tmpi = swapint((int)pl_obj->orient.rvec.z);
 523         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 524         tmpi = swapint((int)pl_obj->orient.uvec.x);
 525         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 526         tmpi = swapint((int)pl_obj->orient.uvec.y);
 527         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 528         tmpi = swapint((int)pl_obj->orient.uvec.z);
 529         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 530         tmpi = swapint((int)pl_obj->orient.fvec.x);
 531         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 532         tmpi = swapint((int)pl_obj->orient.fvec.y);
 533         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 534         tmpi = swapint((int)pl_obj->orient.fvec.z);
 535         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 536
 537         tmpi = swapint((int)pl_obj->mtype.phys_info.velocity.x);
 538         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 539         tmpi = swapint((int)pl_obj->mtype.phys_info.velocity.y);
 540         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 541         tmpi = swapint((int)pl_obj->mtype.phys_info.velocity.z);
 542         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 543         tmpi = swapint((int)pl_obj->mtype.phys_info.thrust.x);
 544         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 545         tmpi = swapint((int)pl_obj->mtype.phys_info.thrust.y);
 546         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 547         tmpi = swapint((int)pl_obj->mtype.phys_info.thrust.z);
 548         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 549         tmpi = swapint((int)pl_obj->mtype.phys_info.mass);
 550         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 551         tmpi = swapint((int)pl_obj->mtype.phys_info.drag);
 552         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 553         tmpi = swapint((int)pl_obj->mtype.phys_info.brakes);
 554         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 555         tmpi = swapint((int)pl_obj->mtype.phys_info.rotvel.x);
 556         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 557         tmpi = swapint((int)pl_obj->mtype.phys_info.rotvel.y);
 558         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 559         tmpi = swapint((int)pl_obj->mtype.phys_info.rotvel.z);
 560         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 561         tmpi = swapint((int)pl_obj->mtype.phys_info.rotthrust.x);
 562         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 563         tmpi = swapint((int)pl_obj->mtype.phys_info.rotthrust.y);
 564         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 565         tmpi = swapint((int)pl_obj->mtype.phys_info.rotthrust.z);
 566         memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 567         tmps = swapshort((short)pl_obj->mtype.phys_info.turnroll);
 568         memcpy(&(out_buffer[loc]), &tmps, 2);   loc += 2;
 569         tmps = swapshort(pl_obj->mtype.phys_info.flags);
 570         memcpy(&(out_buffer[loc]), &tmps, 2);   loc += 2;
 571
 572         out_buffer[loc] = pl_obj->render_type; loc++;
 573         out_buffer[loc] = Current_level_num; loc++;
 574         tmps = swapshort(MySyncPack.data_size);
 575         memcpy(&(out_buffer[loc]), &tmps, 2);   loc += 2;
 576         memcpy(&(out_buffer[loc]), MySyncPack.data, MySyncPack.data_size);
 577         loc += MySyncPack.data_size;
 578 #else
 579         if (short_packet == 1) {
 580                 loc = 0;
 581                 out_buffer[loc] = PID_SHORTPDATA; loc++;
 582                 out_buffer[loc] = Player_num; loc++;
 583                 out_buffer[loc] = pl_obj->render_type; loc++;
 584                 out_buffer[loc] = Current_level_num; loc++;
 585                 create_shortpos((shortpos *)(out_buffer + loc), pl_obj, 0);
 586                 loc += 9+2*3+2+2*3; // go past shortpos structure
 587                 *(ushort *)(out_buffer + loc) = MySyncPack.data_size; loc += 2;
 588                 memcpy(out_buffer + loc, MySyncPack.data, MySyncPack.data_size);
 589                 loc += MySyncPack.data_size;
 590         } else if (short_packet == 2) {
 591                 loc = 0;
 592                 out_buffer[loc] = PID_PDATA_SHORT2; loc++;
 593                 out_buffer[loc] = MySyncPack.numpackets & 255; loc++;
 594                 create_shortpos((shortpos *)(out_buffer + loc), pl_obj, 0);
 595                 loc += 9+2*3+2+2*3; // go past shortpos structure
 596                 tmpus = MySyncPack.data_size | (Player_num << 12) | (pl_obj->render_type << 15);
 597                 *(ushort *)(out_buffer + loc) = tmpus; loc += 2;
 598                 out_buffer[loc] = Current_level_num; loc++;
 599                 memcpy(out_buffer + loc, MySyncPack.data, MySyncPack.data_size);
 600                 loc += MySyncPack.data_size;
 601         } else {
 602                 out_buffer[0] = PID_PDATA;              loc++;  loc += 3;               // skip three for pad byte
 603                 tmpi = swapint(MySyncPack.numpackets);
 604                 memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 605
 606                 tmpi = swapint((int)pl_obj->pos.x);
 607                 memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 608                 tmpi = swapint((int)pl_obj->pos.y);
 609                 memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 610                 tmpi = swapint((int)pl_obj->pos.z);
 611                 memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 612
 613                 tmpi = swapint((int)pl_obj->orient.rvec.x);
 614                 memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 615                 tmpi = swapint((int)pl_obj->orient.rvec.y);
 616                 memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 617                 tmpi = swapint((int)pl_obj->orient.rvec.z);
 618                 memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 619                 tmpi = swapint((int)pl_obj->orient.uvec.x);
 620                 memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 621                 tmpi = swapint((int)pl_obj->orient.uvec.y);
 622                 memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 623                 tmpi = swapint((int)pl_obj->orient.uvec.z);
 624                 memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 625                 tmpi = swapint((int)pl_obj->orient.fvec.x);
 626                 memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 627                 tmpi = swapint((int)pl_obj->orient.fvec.y);
 628                 memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 629                 tmpi = swapint((int)pl_obj->orient.fvec.z);
 630                 memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 631
 632                 tmpi = swapint((int)pl_obj->mtype.phys_info.velocity.x);
 633                 memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 634                 tmpi = swapint((int)pl_obj->mtype.phys_info.velocity.y);
 635                 memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 636                 tmpi = swapint((int)pl_obj->mtype.phys_info.velocity.z);
 637                 memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 638
 639                 tmpi = swapint((int)pl_obj->mtype.phys_info.rotvel.x);
 640                 memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 641                 tmpi = swapint((int)pl_obj->mtype.phys_info.rotvel.y);
 642                 memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 643                 tmpi = swapint((int)pl_obj->mtype.phys_info.rotvel.z);
 644                 memcpy(&(out_buffer[loc]), &tmpi, 4);   loc += 4;
 645
 646                 tmps = swapshort(pl_obj->segnum);
 647                 memcpy(&(out_buffer[loc]), &tmps, 2);   loc += 2;
 648                 tmps = swapshort(MySyncPack.data_size);
 649                 memcpy(&(out_buffer[loc]), &tmps, 2);   loc += 2;
 650
 651                 out_buffer[loc] = Player_num; loc++;
 652                 out_buffer[loc] = pl_obj->render_type; loc++;
 653                 out_buffer[loc] = Current_level_num; loc++;
 654                 memcpy(&(out_buffer[loc]), MySyncPack.data, MySyncPack.data_size);
 655                 loc += MySyncPack.data_size;
 656         }
 657 #endif
 658 #if 0 // adb: not possible (always array passed)
 659         if (address == NULL)
 660                 ipx_send_internetwork_packet_data( out_buffer, loc, server, node );
 661         else
 662 #endif
 663                 ipx_send_packet_data( out_buffer, loc, server, node, address);
 664 }
 665
 666 void receive_frameinfo_packet(ubyte *data, frame_info *info, int short_packet)
 667 {
 668         int loc;
 669
 670 #ifdef SHAREWARE
 671         loc = 0;
 672
 673         info->type = data[0];                                                   loc++;
 674         memcpy(&(info->numpackets), &(data[loc]), 4);   loc += 4;
 675         info->numpackets = swapint(info->numpackets);
 676         memcpy(&(info->objnum), &(data[loc]), 2);               loc += 2;
 677         info->objnum = swapshort(info->objnum);
 678         info->playernum = data[loc];                                    loc++;
 679
 680         memcpy(&(info->obj_segnum), &(data[loc]), 2);   loc += 2;
 681         info->obj_segnum = swapshort(info->obj_segnum);
 682
 683         memcpy(&(info->obj_pos.x), &(data[loc]), 4);    loc += 4;
 684         info->obj_pos.x = (fix)swapint((int)info->obj_pos.x);
 685         memcpy(&(info->obj_pos.y), &(data[loc]), 4);    loc += 4;
 686         info->obj_pos.y = (fix)swapint((int)info->obj_pos.y);
 687         memcpy(&(info->obj_pos.z), &(data[loc]), 4);    loc += 4;
 688         info->obj_pos.z = (fix)swapint((int)info->obj_pos.z);
 689
 690         memcpy(&(info->obj_orient.rvec.x), &(data[loc]), 4);    loc += 4;
 691         info->obj_orient.rvec.x = (fix)swapint((int)info->obj_orient.rvec.x);
 692         memcpy(&(info->obj_orient.rvec.y), &(data[loc]), 4);    loc += 4;
 693         info->obj_orient.rvec.y = (fix)swapint((int)info->obj_orient.rvec.y);
 694         memcpy(&(info->obj_orient.rvec.z), &(data[loc]), 4);    loc += 4;
 695         info->obj_orient.rvec.z = (fix)swapint((int)info->obj_orient.rvec.z);
 696         memcpy(&(info->obj_orient.uvec.x), &(data[loc]), 4);    loc += 4;
 697         info->obj_orient.uvec.x = (fix)swapint((int)info->obj_orient.uvec.x);
 698         memcpy(&(info->obj_orient.uvec.y), &(data[loc]), 4);    loc += 4;
 699         info->obj_orient.uvec.y = (fix)swapint((int)info->obj_orient.uvec.y);
 700         memcpy(&(info->obj_orient.uvec.z), &(data[loc]), 4);    loc += 4;
 701         info->obj_orient.uvec.z = (fix)swapint((int)info->obj_orient.uvec.z);
 702         memcpy(&(info->obj_orient.fvec.x), &(data[loc]), 4);    loc += 4;
 703         info->obj_orient.fvec.x = (fix)swapint((int)info->obj_orient.fvec.x);
 704         memcpy(&(info->obj_orient.fvec.y), &(data[loc]), 4);    loc += 4;
 705         info->obj_orient.fvec.y = (fix)swapint((int)info->obj_orient.fvec.y);
 706         memcpy(&(info->obj_orient.fvec.z), &(data[loc]), 4);    loc += 4;
 707         info->obj_orient.fvec.z = (fix)swapint((int)info->obj_orient.fvec.z);
 708
 709         memcpy(&(info->obj_phys_info.velocity.x), &(data[loc]), 4);     loc += 4;
 710         info->obj_phys_info.velocity.x = (fix)swapint((int)info->obj_phys_info.velocity.x);
 711         memcpy(&(info->obj_phys_info.velocity.y), &(data[loc]), 4);     loc += 4;
 712         info->obj_phys_info.velocity.y = (fix)swapint((int)info->obj_phys_info.velocity.y);
 713         memcpy(&(info->obj_phys_info.velocity.z), &(data[loc]), 4);     loc += 4;
 714         info->obj_phys_info.velocity.z = (fix)swapint((int)info->obj_phys_info.velocity.z);
 715
 716         memcpy(&(info->obj_phys_info.thrust.x), &(data[loc]), 4);       loc += 4;
 717         info->obj_phys_info.thrust.x = (fix)swapint((int)info->obj_phys_info.thrust.x);
 718         memcpy(&(info->obj_phys_info.thrust.y), &(data[loc]), 4);       loc += 4;
 719         info->obj_phys_info.thrust.y = (fix)swapint((int)info->obj_phys_info.thrust.y);
 720         memcpy(&(info->obj_phys_info.thrust.z), &(data[loc]), 4);       loc += 4;
 721         info->obj_phys_info.thrust.z = (fix)swapint((int)info->obj_phys_info.thrust.z);
 722
 723         memcpy(&(info->obj_phys_info.mass), &(data[loc]), 4);   loc += 4;
 724         info->obj_phys_info.mass = (fix)swapint((int)info->obj_phys_info.mass);
 725         memcpy(&(info->obj_phys_info.drag), &(data[loc]), 4);   loc += 4;
 726         info->obj_phys_info.drag = (fix)swapint((int)info->obj_phys_info.drag);
 727         memcpy(&(info->obj_phys_info.brakes), &(data[loc]), 4); loc += 4;
 728         info->obj_phys_info.brakes = (fix)swapint((int)info->obj_phys_info.brakes);
 729
 730         memcpy(&(info->obj_phys_info.rotvel.x), &(data[loc]), 4);       loc += 4;
 731         info->obj_phys_info.rotvel.x = (fix)swapint((int)info->obj_phys_info.rotvel.x);
 732         memcpy(&(info->obj_phys_info.rotvel.y), &(data[loc]), 4);       loc += 4;
 733         info->obj_phys_info.rotvel.y = (fix)swapint((int)info->obj_phys_info.rotvel.y);
 734         memcpy(&(info->obj_phys_info.rotvel.z), &(data[loc]), 4);       loc += 4;
 735         info->obj_phys_info.rotvel.z = (fix)swapint((int)info->obj_phys_info.rotvel.z);
 736
 737         memcpy(&(info->obj_phys_info.rotthrust.x), &(data[loc]), 4);    loc += 4;
 738         info->obj_phys_info.rotthrust.x = (fix)swapint((int)info->obj_phys_info.rotthrust.x);
 739         memcpy(&(info->obj_phys_info.rotthrust.y), &(data[loc]), 4);    loc += 4;
 740         info->obj_phys_info.rotthrust.y = (fix)swapint((int)info->obj_phys_info.rotthrust.y);
 741         memcpy(&(info->obj_phys_info.rotthrust.z), &(data[loc]), 4);    loc += 4;
 742         info->obj_phys_info.rotthrust.z = (fix)swapint((int)info->obj_phys_info.rotthrust.z);
 743
 744         memcpy(&(info->obj_phys_info.turnroll), &(data[loc]), 2);       loc += 2;
 745         info->obj_phys_info.turnroll = (fixang)swapshort((short)info->obj_phys_info.turnroll);
 746
 747         memcpy(&(info->obj_phys_info.flags), &(data[loc]), 2);  loc += 2;
 748         info->obj_phys_info.flags = (ushort)swapshort(info->obj_phys_info.flags);
 749
 750         info->obj_render_type = data[loc];              loc++;
 751         info->level_num = data[loc];                    loc++;
 752         memcpy( &(info->data_size), &(data[loc]), 2);   loc += 2;
 753         info->data_size = swapshort(info->data_size);
 754         memcpy(info->data, &(data[loc]), info->data_size);
 755 #else
 756         if (short_packet == 1) {
 757                 loc = 0;
 758                 info->type = data[loc]; loc++;
 759                 info->playernum = data[loc]; loc++;
 760                 info->obj_render_type = data[loc]; loc++;
 761                 info->level_num = data[loc]; loc++;
 762                 loc += 9+2*3+2+2*3; // skip shortpos structure
 763                 info->data_size = *(ushort *)(data + loc); loc+=2;
 764                 memcpy(info->data, &(data[loc]), info->data_size);
 765         } else if (short_packet == 2) {
 766                 ushort tmpus;
 767
 768                 loc = 0;
 769                 info->type = data[loc];         loc++;
 770                 info->numpackets = data[loc];   loc++;
 771                 loc += 9+2*3+2+2*3; // skip shortpos structure
 772                 tmpus = *(ushort *)(data + loc); loc+=2;
 773                 info->data_size = tmpus & 0xfff;
 774                 info->playernum = (tmpus >> 12) & 7;
 775                 info->obj_render_type = tmpus >> 15;
 776                 info->numpackets |= Players[info->playernum].n_packets_got & (~255);
 777                 if (info->numpackets - Players[info->playernum].n_packets_got > 224)
 778                         info->numpackets -= 256;
 779                 else if (Players[info->playernum].n_packets_got - info->numpackets > 128)
 780                         info->numpackets += 256;
 781                 info->level_num = data[loc];    loc++;
 782                 memcpy(info->data, &(data[loc]), info->data_size);
 783         } else {
 784                 loc = 0;
 785                 info->type = data[loc];                 loc++;  loc += 3;               // skip three for pad byte
 786                 memcpy(&(info->numpackets), &(data[loc]), 4);   loc += 4;
 787                 info->numpackets = swapint(info->numpackets);
 788
 789                 memcpy(&(info->obj_pos.x), &(data[loc]), 4);    loc += 4;
 790                 info->obj_pos.x = swapint((int)info->obj_pos.x);
 791                 memcpy(&(info->obj_pos.y), &(data[loc]), 4);    loc += 4;
 792                 info->obj_pos.y = swapint((int)info->obj_pos.y);
 793                 memcpy(&(info->obj_pos.z), &(data[loc]), 4);    loc += 4;
 794                 info->obj_pos.z = swapint((int)info->obj_pos.z);
 795
 796                 memcpy(&(info->obj_orient.rvec.x), &(data[loc]), 4);    loc += 4;
 797                 info->obj_orient.rvec.x = swapint((int)info->obj_orient.rvec.x);
 798                 memcpy(&(info->obj_orient.rvec.y), &(data[loc]), 4);    loc += 4;
 799                 info->obj_orient.rvec.y = swapint((int)info->obj_orient.rvec.y);
 800                 memcpy(&(info->obj_orient.rvec.z), &(data[loc]), 4);    loc += 4;
 801                 info->obj_orient.rvec.z = swapint((int)info->obj_orient.rvec.z);
 802                 memcpy(&(info->obj_orient.uvec.x), &(data[loc]), 4);    loc += 4;
 803                 info->obj_orient.uvec.x = swapint((int)info->obj_orient.uvec.x);
 804                 memcpy(&(info->obj_orient.uvec.y), &(data[loc]), 4);    loc += 4;
 805                 info->obj_orient.uvec.y = swapint((int)info->obj_orient.uvec.y);
 806                 memcpy(&(info->obj_orient.uvec.z), &(data[loc]), 4);    loc += 4;
 807                 info->obj_orient.uvec.z = swapint((int)info->obj_orient.uvec.z);
 808                 memcpy(&(info->obj_orient.fvec.x), &(data[loc]), 4);    loc += 4;
 809                 info->obj_orient.fvec.x = swapint((int)info->obj_orient.fvec.x);
 810                 memcpy(&(info->obj_orient.fvec.y), &(data[loc]), 4);    loc += 4;
 811                 info->obj_orient.fvec.y = swapint((int)info->obj_orient.fvec.y);
 812                 memcpy(&(info->obj_orient.fvec.z), &(data[loc]), 4);    loc += 4;
 813                 info->obj_orient.fvec.z = swapint((int)info->obj_orient.fvec.z);
 814
 815                 memcpy(&(info->phys_velocity.x), &(data[loc]), 4);      loc += 4;
 816                 info->phys_velocity.x = swapint((int)info->phys_velocity.x);
 817                 memcpy(&(info->phys_velocity.y), &(data[loc]), 4);      loc += 4;
 818                 info->phys_velocity.y = swapint((int)info->phys_velocity.y);
 819                 memcpy(&(info->phys_velocity.z), &(data[loc]), 4);      loc += 4;
 820                 info->phys_velocity.z = swapint((int)info->phys_velocity.z);
 821
 822                 memcpy(&(info->phys_rotvel.x), &(data[loc]), 4);        loc += 4;
 823                 info->phys_rotvel.x = swapint((int)info->phys_rotvel.x);
 824                 memcpy(&(info->phys_rotvel.y), &(data[loc]), 4);        loc += 4;
 825                 info->phys_rotvel.y = swapint((int)info->phys_rotvel.y);
 826                 memcpy(&(info->phys_rotvel.z), &(data[loc]), 4);        loc += 4;
 827                 info->phys_rotvel.z = swapint((int)info->phys_rotvel.z);
 828
 829                 memcpy(&(info->obj_segnum), &(data[loc]), 2);   loc += 2;
 830                 info->obj_segnum = swapshort(info->obj_segnum);
 831                 memcpy(&(info->data_size), &(data[loc]), 2);    loc += 2;
 832                 info->data_size = swapshort(info->data_size);
 833
 834                 info->playernum = data[loc];            loc++;
 835                 info->obj_render_type = data[loc];      loc++;
 836                 info->level_num = data[loc];            loc++;
 837                 memcpy(info->data, &(data[loc]), info->data_size);
 838         }
 839 #endif
 840 }
 841
 842 void send_endlevel_packet(endlevel_info *info, ubyte *server, ubyte *node, ubyte *address)
 843 {
 844         int i, j;
 845         int loc = 0;
 846         ushort tmps;
 847
 848         memset(out_buffer, 0, IPX_MAX_DATA_SIZE);
 849         out_buffer[loc] = info->type;                   loc++;
 850         out_buffer[loc] = info->player_num;             loc++;
 851         out_buffer[loc] = info->connected;              loc++;
 852         for (i = 0; i < MAX_PLAYERS; i++) {
 853                 for (j = 0; j < MAX_PLAYERS; j++) {
 854                         tmps = swapshort(info->kill_matrix[i][j]);
 855                         memcpy(&(out_buffer[loc]), &tmps, 2);
 856                         loc += 2;
 857                 }
 858         }
 859         tmps = swapshort(info->kills);
 860         memcpy(&(out_buffer[loc]), &tmps, 2);  loc += 2;
 861         tmps = swapshort(info->killed);
 862         memcpy(&(out_buffer[loc]), &tmps, 2);  loc += 2;
 863         out_buffer[loc] = info->seconds_left; loc++;
 864
 865         ipx_send_packet_data( out_buffer, loc, server, node, address);
 866 }
 867
 868 void receive_endlevel_packet(ubyte *data, endlevel_info *info)
 869 {
 870         int i, j;
 871         int loc = 0;
 872
 873         info->type = data[loc];                                         loc++;
 874         info->player_num = data[loc];                           loc++;
 875         info->connected = data[loc];                            loc++;
 876
 877         for (i = 0; i < MAX_PLAYERS; i++) {
 878                 for (j = 0; j < MAX_PLAYERS; j++) {
 879                         memcpy(&(info->kill_matrix[i][j]), &(data[loc]), 2);    loc += 2;
 880                         info->kill_matrix[i][j] = swapshort(info->kill_matrix[i][j]);
 881                 }
 882         }
 883         memcpy(&(info->kills), &(data[loc]), 2);  loc += 2;
 884         info->kills = swapshort(info->kills);
 885         memcpy(&(info->killed), &(data[loc]), 2);  loc += 2;
 886         info->killed = swapshort(info->killed);
 887         info->seconds_left = data[loc];
 888 }
 889
 890 void swap_object(object *obj)
 891 {
 892 // swap the short and int entries for this object
 893         obj->signature                  = swapint(obj->signature);
 894         obj->next                               = swapshort(obj->next);
 895         obj->prev                               = swapshort(obj->prev);
 896         obj->segnum                             = swapshort(obj->segnum);
 897         obj->attached_obj               = swapshort(obj->attached_obj);
 898         obj->pos.x                              = swapint(obj->pos.x);
 899         obj->pos.y                              = swapint(obj->pos.y);
 900         obj->pos.z                              = swapint(obj->pos.z);
 901
 902         obj->orient.rvec.x              = swapint(obj->orient.rvec.x);
 903         obj->orient.rvec.y              = swapint(obj->orient.rvec.y);
 904         obj->orient.rvec.z              = swapint(obj->orient.rvec.z);
 905         obj->orient.fvec.x              = swapint(obj->orient.fvec.x);
 906         obj->orient.fvec.y              = swapint(obj->orient.fvec.y);
 907         obj->orient.fvec.z              = swapint(obj->orient.fvec.z);
 908         obj->orient.uvec.x              = swapint(obj->orient.uvec.x);
 909         obj->orient.uvec.y              = swapint(obj->orient.uvec.y);
 910         obj->orient.uvec.z              = swapint(obj->orient.uvec.z);
 911
 912         obj->size                               = swapint(obj->size);
 913         obj->shields                    = swapint(obj->shields);
 914
 915         obj->last_pos.x                 = swapint(obj->last_pos.x);
 916         obj->last_pos.y                 = swapint(obj->last_pos.y);
 917         obj->last_pos.z                 = swapint(obj->last_pos.z);
 918
 919         obj->lifeleft                   = swapint(obj->lifeleft);
 920
 921         switch (obj->movement_type) {
 922
 923         case MT_PHYSICS:
 924
 925                 obj->mtype.phys_info.velocity.x = swapint(obj->mtype.phys_info.velocity.x);
 926                 obj->mtype.phys_info.velocity.y = swapint(obj->mtype.phys_info.velocity.y);
 927                 obj->mtype.phys_info.velocity.z = swapint(obj->mtype.phys_info.velocity.z);
 928
 929                 obj->mtype.phys_info.thrust.x   = swapint(obj->mtype.phys_info.thrust.x);
 930                 obj->mtype.phys_info.thrust.y   = swapint(obj->mtype.phys_info.thrust.y);
 931                 obj->mtype.phys_info.thrust.z   = swapint(obj->mtype.phys_info.thrust.z);
 932
 933                 obj->mtype.phys_info.mass               = swapint(obj->mtype.phys_info.mass);
 934                 obj->mtype.phys_info.drag               = swapint(obj->mtype.phys_info.drag);
 935                 obj->mtype.phys_info.brakes             = swapint(obj->mtype.phys_info.brakes);
 936
 937                 obj->mtype.phys_info.rotvel.x   = swapint(obj->mtype.phys_info.rotvel.x);
 938                 obj->mtype.phys_info.rotvel.y   = swapint(obj->mtype.phys_info.rotvel.y);
 939                 obj->mtype.phys_info.rotvel.z   = swapint(obj->mtype.phys_info.rotvel.z);
 940
 941                 obj->mtype.phys_info.rotthrust.x = swapint(obj->mtype.phys_info.rotthrust.x);
 942                 obj->mtype.phys_info.rotthrust.y = swapint(obj->mtype.phys_info.rotthrust.y);
 943                 obj->mtype.phys_info.rotthrust.z = swapint(obj->mtype.phys_info.rotthrust.z);
 944
 945                 obj->mtype.phys_info.turnroll   = swapint(obj->mtype.phys_info.turnroll);
 946                 obj->mtype.phys_info.flags              = swapshort(obj->mtype.phys_info.flags);
 947
 948                 break;
 949
 950         case MT_SPINNING:
 951
 952                 obj->mtype.spin_rate.x = swapint(obj->mtype.spin_rate.x);
 953                 obj->mtype.spin_rate.y = swapint(obj->mtype.spin_rate.y);
 954                 obj->mtype.spin_rate.z = swapint(obj->mtype.spin_rate.z);
 955                 break;
 956         }
 957
 958         switch (obj->control_type) {
 959
 960         case CT_WEAPON:
 961                 obj->ctype.laser_info.parent_type               = swapshort(obj->ctype.laser_info.parent_type);
 962                 obj->ctype.laser_info.parent_num                = swapshort(obj->ctype.laser_info.parent_num);
 963                 obj->ctype.laser_info.parent_signature  = swapshort(obj->ctype.laser_info.parent_signature);
 964                 obj->ctype.laser_info.creation_time             = swapint(obj->ctype.laser_info.creation_time);
 965                 obj->ctype.laser_info.last_hitobj               = swapint(obj->ctype.laser_info.last_hitobj);
 966                 obj->ctype.laser_info.multiplier                = swapint(obj->ctype.laser_info.multiplier);
 967                 break;
 968
 969         case CT_EXPLOSION:
 970                 obj->ctype.expl_info.spawn_time         = swapint(obj->ctype.expl_info.spawn_time);
 971                 obj->ctype.expl_info.delete_time        = swapint(obj->ctype.expl_info.delete_time);
 972                 obj->ctype.expl_info.delete_objnum      = swapshort(obj->ctype.expl_info.delete_objnum);
 973                 obj->ctype.expl_info.attach_parent      = swapshort(obj->ctype.expl_info.attach_parent);
 974                 obj->ctype.expl_info.prev_attach        = swapshort(obj->ctype.expl_info.prev_attach);
 975                 obj->ctype.expl_info.next_attach        = swapshort(obj->ctype.expl_info.next_attach);
 976                 break;
 977
 978         case CT_AI:
 979                 obj->ctype.ai_info.hide_segment                 = swapshort(obj->ctype.ai_info.hide_segment);
 980                 obj->ctype.ai_info.hide_index                   = swapshort(obj->ctype.ai_info.hide_index);
 981                 obj->ctype.ai_info.path_length                  = swapshort(obj->ctype.ai_info.path_length);
 982                 obj->ctype.ai_info.cur_path_index               = swapshort(obj->ctype.ai_info.cur_path_index);
 983 //              obj->ctype.ai_info.follow_path_start_seg        = swapshort(obj->ctype.ai_info.follow_path_start_seg);
 984 //              obj->ctype.ai_info.follow_path_end_seg          = swapshort(obj->ctype.ai_info.follow_path_end_seg);
 985                 obj->ctype.ai_info.danger_laser_signature = swapint(obj->ctype.ai_info.danger_laser_signature);
 986                 obj->ctype.ai_info.danger_laser_num             = swapshort(obj->ctype.ai_info.danger_laser_num);
 987                 break;
 988
 989         case CT_LIGHT:
 990                 obj->ctype.light_info.intensity = swapint(obj->ctype.light_info.intensity);
 991                 break;
 992
 993         case CT_POWERUP:
 994                 obj->ctype.powerup_info.count = swapint(obj->ctype.powerup_info.count);
 995                 if (obj->id == POW_VULCAN_WEAPON)
 996                         obj->ctype.powerup_info.count = VULCAN_WEAPON_AMMO_AMOUNT;
 997                 break;
 998
 999         }
1000
1001         switch (obj->render_type) {
1002
1003         case RT_MORPH:
1004         case RT_POLYOBJ: {
1005                 int i;
1006
1007                 obj->rtype.pobj_info.model_num          = swapint(obj->rtype.pobj_info.model_num);
1008
1009                 for (i=0;i<MAX_SUBMODELS;i++) {
1010                         obj->rtype.pobj_info.anim_angles[i].p = swapint(obj->rtype.pobj_info.anim_angles[i].p);
1011                         obj->rtype.pobj_info.anim_angles[i].b = swapint(obj->rtype.pobj_info.anim_angles[i].b);
1012                         obj->rtype.pobj_info.anim_angles[i].h = swapint(obj->rtype.pobj_info.anim_angles[i].h);
1013                 }
1014
1015                 obj->rtype.pobj_info.subobj_flags       = swapint(obj->rtype.pobj_info.subobj_flags);
1016                 obj->rtype.pobj_info.tmap_override      = swapint(obj->rtype.pobj_info.tmap_override);
1017                 obj->rtype.pobj_info.alt_textures       = swapint(obj->rtype.pobj_info.alt_textures);
1018                 break;
1019         }
1020
1021         case RT_WEAPON_VCLIP:
1022         case RT_HOSTAGE:
1023         case RT_POWERUP:
1024         case RT_FIREBALL:
1025                 obj->rtype.vclip_info.vclip_num = swapint(obj->rtype.vclip_info.vclip_num);
1026                 obj->rtype.vclip_info.frametime = swapint(obj->rtype.vclip_info.frametime);
1027                 break;
1028
1029         case RT_LASER:
1030                 break;
1031
1032         }
1033 //  END OF SWAPPING OBJECT STRUCTURE
1034
1035 }