main/multibot.c

   1 /* $Id: multibot.c,v 1.7 2004-08-01 16:28:33 schaffner Exp $ */
   2 /*
   3 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   4 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   5 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   6 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   7 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   8 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   9 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
  10 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  11 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  12 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  13 */
  14
  15 /*
  16  *
  17  * Multiplayer robot code
  18  *
  19  */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include <conf.h>
  23 #endif
  24
  25 #include <string.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28
  29 #include "vecmat.h"
  30 #include "object.h"
  31 #include "multibot.h"
  32 #include "game.h"
  33 #include "modem.h"
  34 #include "network.h"
  35 #include "multi.h"
  36 #include "laser.h"
  37 #include "error.h"
  38 #include "mono.h"
  39 #include "timer.h"
  40 #include "text.h"
  41 #include "ai.h"
  42 #include "fireball.h"
  43 #include "aistruct.h"
  44 #include "robot.h"
  45 #include "powerup.h"
  46 #include "scores.h"
  47 #include "gauges.h"
  48 #include "fuelcen.h"
  49 #include "morph.h"
  50 #include "digi.h"
  51 #include "sounds.h"
  52 #include "effects.h"
  53 #include "physics.h"
  54 #include "byteswap.h"
  55
  56
  57
  58 int multi_add_controlled_robot(int objnum, int agitation);
  59 void multi_send_release_robot(int objnum);
  60 void multi_delete_controlled_robot(int objnum);
  61 void multi_send_robot_position_sub(int objnum);
  62
  63 //
  64 // Code for controlling robots in multiplayer games
  65 //
  66
  67
  68 #define STANDARD_EXPL_DELAY (F1_0/4)
  69 #define MIN_CONTROL_TIME        F1_0*1
  70 #define ROBOT_TIMEOUT           F1_0*2
  71
  72 #define MIN_TO_ADD      60
  73 #define MAX_TO_DELETE   61
  74
  75 int robot_controlled[MAX_ROBOTS_CONTROLLED];
  76 int robot_agitation[MAX_ROBOTS_CONTROLLED];
  77 fix robot_controlled_time[MAX_ROBOTS_CONTROLLED];
  78 fix robot_last_send_time[MAX_ROBOTS_CONTROLLED];
  79 fix robot_last_message_time[MAX_ROBOTS_CONTROLLED];
  80 int robot_send_pending[MAX_ROBOTS_CONTROLLED];
  81 int robot_fired[MAX_ROBOTS_CONTROLLED];
  82 sbyte robot_fire_buf[MAX_ROBOTS_CONTROLLED][18+3];
  83
  84 #define MULTI_ROBOT_PRIORITY(objnum, pnum) (((objnum % 4) + pnum) % N_players)
  85
  86 extern void multi_send_stolen_items();
  87 extern int multi_powerup_is_allowed (int);
  88
  89 //#define MULTI_ROBOT_PRIORITY(objnum, pnum) multi_robot_priority(objnum, pnum)
  90 //int multi_robot_priority(int objnum, int pnum)
  91 //{
  92 //      return( ((objnum % 4) + pnum) % N_players);
  93 //}
  94
  95 int
  96 multi_can_move_robot(int objnum, int agitation)
  97 {
  98         // Determine whether or not I am allowed to move this robot.
  99         int rval;
 100
 101         // Claim robot if necessary.
 102
 103         if (Player_exploded)
 104                 return 0;
 105
 106 #ifndef NDEBUG
 107         if ((objnum < 0) || (objnum > Highest_object_index))
 108         {
 109                 Int3();
 110                 rval = 0;
 111         }
 112
 113         else if (Objects[objnum].type != OBJ_ROBOT)
 114         {
 115                 Int3();
 116                 rval = 0;
 117         }
 118 #endif
 119
 120         else if ((Robot_info[Objects[objnum].id].boss_flag) && (Boss_dying == 1))
 121                 return 0;
 122
 123         else if (Objects[objnum].ctype.ai_info.REMOTE_OWNER == Player_num) // Already my robot!
 124         {
 125                 int slot_num = Objects[objnum].ctype.ai_info.REMOTE_SLOT_NUM;
 126
 127       if ((slot_num < 0) || (slot_num >= MAX_ROBOTS_CONTROLLED))
 128                  {
 129                   mprintf ((0,"Not asserting in multi_can_move_robot!"));
 130                   return 0;
 131                  }
 132
 133                 if (robot_fired[slot_num]) {
 134 //                      mprintf((0, "Preventing robot from firing again until firing complete!\n"));
 135                         rval = 0;
 136                 }
 137                 else {
 138                         robot_agitation[slot_num] = agitation;
 139                         robot_last_message_time[slot_num] = GameTime;
 140                         rval = 1;
 141                 }
 142         }
 143
 144         else if ((Objects[objnum].ctype.ai_info.REMOTE_OWNER != -1) || (agitation < MIN_TO_ADD))
 145         {
 146                 if (agitation == ROBOT_FIRE_AGITATION) // Special case for firing at non-player
 147                 {
 148                         mprintf((0, "Shooting anyway.\n"));
 149                         rval = 1; // Try to fire at player even tho we're not in control!
 150                 }
 151                 else
 152                         rval = 0;
 153         }
 154         else
 155                 rval = multi_add_controlled_robot(objnum, agitation);
 156
 157         return(rval);
 158 }
 159
 160 void
 161 multi_check_robot_timeout(void)
 162 {
 163         static fix lastcheck = 0;
 164         int i;
 165
 166         if (GameTime > lastcheck + F1_0)
 167         {
 168                 lastcheck = GameTime;
 169                 for (i = 0; i < MAX_ROBOTS_CONTROLLED; i++)
 170                 {
 171                         if ((robot_controlled[i] != -1) && (robot_last_send_time[i] + ROBOT_TIMEOUT < GameTime))
 172                         {
 173                                 if (Objects[robot_controlled[i]].ctype.ai_info.REMOTE_OWNER != Player_num)
 174                                 {
 175                                         robot_controlled[i] = -1;
 176                                         Int3(); // Non-terminal but Rob is interesting, step over please...
 177                                         return;
 178                                 }
 179                                 if (Objects[robot_controlled[i]].ctype.ai_info.REMOTE_OWNER !=Player_num)
 180                                  {
 181                                         mprintf ((0,"What? This ain't my bot and I'm trying to time it out!\n"));
 182                                         return;
 183                                  }
 184                                 mprintf((0, "Robot %d (slot %d) removed, timed out, frame %d.\n", robot_controlled[i], i, GameTime));
 185                                 if (robot_send_pending[i])
 186                                         multi_send_robot_position(robot_controlled[i], 1);
 187                                 multi_send_release_robot(robot_controlled[i]);
 188 //                              multi_delete_controlled_robot(robot_controlled[i]);
 189 //                              robot_controlled[i] = -1;
 190                         }
 191                 }
 192         }
 193 }
 194
 195 void
 196 multi_strip_robots(int playernum)
 197 {
 198         // Grab all robots away from a player
 199         // (player died or exited the game)
 200
 201         int i;
 202
 203         if (Game_mode & GM_MULTI_ROBOTS) {
 204
 205                 if (playernum == Player_num)
 206                         for (i = 0; i < MAX_ROBOTS_CONTROLLED; i++)
 207                                 multi_delete_controlled_robot(robot_controlled[i]);
 208
 209                 for (i = 1; i <= Highest_object_index; i++)
 210                         if ((Objects[i].type == OBJ_ROBOT) && (Objects[i].ctype.ai_info.REMOTE_OWNER == playernum)) {
 211                                 Assert((Objects[i].control_type == CT_AI) || (Objects[i].control_type == CT_NONE) || (Objects[i].control_type == CT_MORPH));
 212                                 Objects[i].ctype.ai_info.REMOTE_OWNER = -1;
 213                                 if (playernum == Player_num)
 214                                         Objects[i].ctype.ai_info.REMOTE_SLOT_NUM = 4;
 215                                 else
 216                                         Objects[i].ctype.ai_info.REMOTE_SLOT_NUM = 0;
 217                         }
 218         }
 219         // Note -- only call this with playernum == Player_num if all other players
 220         // already know that we are clearing house.  This does not send a release
 221         // message for each controlled robot!!
 222
 223 }
 224
 225 void
 226 multi_dump_robots(void)
 227
 228 {
 229         // Dump robot control info for debug purposes
 230
 231         int i;
 232
 233         if (!(Game_mode & GM_MULTI_ROBOTS))
 234                 return;
 235
 236         mprintf((0, "\n"));
 237         for (i = 0; i < MAX_ROBOTS_CONTROLLED; i++)
 238         {
 239                 mprintf((0, "Robot %d) objnum=%d, anger=%d, last_message=%d, last move=%d, gametime=%d\n", i, robot_controlled[i], robot_agitation[i], robot_last_message_time[i], robot_last_send_time[i], GameTime));
 240         }
 241 }
 242
 243 int
 244 multi_add_controlled_robot(int objnum, int agitation)
 245 {
 246         int i;
 247         int lowest_agitation = 0x7fffffff; // MAX POSITIVE INT
 248         int lowest_agitated_bot = -1;
 249         int first_free_robot = -1;
 250
 251         // Try to add a new robot to the controlled list, return 1 if added, 0 if not.
 252
 253    if (Robot_info[Objects[objnum].id].boss_flag) // this is a boss, so make sure he gets a slot
 254                 agitation=(agitation*3)+Player_num;
 255
 256         if (Objects[objnum].ctype.ai_info.REMOTE_SLOT_NUM > 0)
 257         {
 258                 mprintf((0, "Robot %d hands-off = %d.\n", objnum, Objects[objnum].ctype.ai_info.REMOTE_SLOT_NUM));
 259                 Objects[objnum].ctype.ai_info.REMOTE_SLOT_NUM -= 1;
 260                 return 0;
 261         }
 262
 263         for (i = 0; i < MAX_ROBOTS_CONTROLLED; i++)
 264         {
 265                 if ((robot_controlled[i] == -1) || (Objects[robot_controlled[i]].type != OBJ_ROBOT)) {
 266                         first_free_robot = i;
 267                         break;
 268                 }
 269
 270                 if (robot_last_message_time[i] + ROBOT_TIMEOUT < GameTime) {
 271                         mprintf((0, "Robot %d replaced (timeout).\n", robot_controlled[i]));
 272                         if (robot_send_pending[i])
 273                                 multi_send_robot_position(robot_controlled[i], 1);
 274                         multi_send_release_robot(robot_controlled[i]);
 275                         first_free_robot = i;
 276                         break;
 277                 }
 278
 279                 if ((robot_controlled[i] != -1) && (robot_agitation[i] < lowest_agitation) && (robot_controlled_time[i] + MIN_CONTROL_TIME < GameTime))
 280                 {
 281                         lowest_agitation = robot_agitation[i];
 282                         lowest_agitated_bot = i;
 283                 }
 284         }
 285
 286 //   mprintf ((0,"first_free_robot=%d lowest_agitated_bot=%d\n",first_free_robot,lowest_agitated_bot));
 287
 288         if (first_free_robot != -1)  // Room left for new robots
 289                 i = first_free_robot;
 290
 291         else if ((agitation > lowest_agitation))// && (lowest_agitation <= MAX_TO_DELETE)) // Replace some old robot with a more agitated one
 292         {
 293                 if (robot_send_pending[lowest_agitated_bot])
 294                         multi_send_robot_position(robot_controlled[lowest_agitated_bot], 1);
 295                 multi_send_release_robot(robot_controlled[lowest_agitated_bot]);
 296
 297                 mprintf((0, "Replaced robot %d (agitation %d) with robot %d (agitation %d).\n", robot_controlled[lowest_agitated_bot], lowest_agitation, objnum, agitation));
 298
 299                 i = lowest_agitated_bot;
 300         }
 301         else {
 302 //              mprintf((0, "Cannot add robot %d agitation %d (min agitation %d)\n", objnum, agitation, lowest_agitation));
 303                 return(0); // Sorry, can't squeeze him in!
 304         }
 305
 306         mprintf((0, "Taking control of robot %d, agitation %d.\n", objnum, agitation));
 307
 308         multi_send_claim_robot(objnum);
 309         robot_controlled[i] = objnum;
 310         robot_agitation[i] = agitation;
 311         Objects[objnum].ctype.ai_info.REMOTE_OWNER = Player_num;
 312         Objects[objnum].ctype.ai_info.REMOTE_SLOT_NUM = i;
 313         robot_controlled_time[i] = GameTime;
 314         robot_last_send_time[i] = robot_last_message_time[i] = GameTime;
 315         return(1);
 316 }
 317
 318 void
 319 multi_delete_controlled_robot(int objnum)
 320 {
 321         int i;
 322
 323         // Delete robot object number objnum from list of controlled robots because it is dead
 324
 325         if ( (objnum<0) || (objnum>Highest_object_index))       {
 326                 mprintf((0, "Trying to releasing control of bogus robot %d\n", objnum));
 327                 return;
 328         }
 329
 330         for (i = 0; i < MAX_ROBOTS_CONTROLLED; i++)
 331                 if (robot_controlled[i] == objnum)
 332                         break;
 333
 334         if (i == MAX_ROBOTS_CONTROLLED)
 335                 return;
 336
 337         mprintf((0, "Releasing control of robot %d\n", objnum));
 338
 339         if (Objects[objnum].ctype.ai_info.REMOTE_SLOT_NUM != i)
 340          {
 341           mprintf ((0,"Saved from asserting in multi_delete_controlled_bot!"));
 342           Int3();  // can't release this bot!
 343           return;
 344          }
 345
 346         Objects[objnum].ctype.ai_info.REMOTE_OWNER = -1;
 347         Objects[objnum].ctype.ai_info.REMOTE_SLOT_NUM = 0;
 348         robot_controlled[i] = -1;
 349         robot_send_pending[i] = 0;
 350         robot_fired[i] = 0;
 351 }
 352
 353 void
 354 multi_send_claim_robot(int objnum)
 355 {
 356         short s;
 357
 358         if ((objnum < 0) || (objnum > Highest_object_index))
 359         {
 360                 Int3(); // See rob
 361                 return;
 362         }
 363
 364         if (Objects[objnum].type != OBJ_ROBOT)
 365         {
 366                 Int3(); // See rob
 367                 return;
 368         }
 369
 370         // The AI tells us we should take control of this robot.
 371
 372         multibuf[0] = (char)MULTI_ROBOT_CLAIM;
 373         multibuf[1] = Player_num;
 374         s = objnum_local_to_remote(objnum, (sbyte *)&multibuf[4]);
 375         PUT_INTEL_SHORT(multibuf+2, s);
 376
 377         multi_send_data(multibuf, 5, 2);
 378         multi_send_data(multibuf, 5, 2);
 379         multi_send_data(multibuf, 5, 2);
 380
 381 }
 382
 383 void
 384 multi_send_release_robot(int objnum)
 385 {
 386         short s;
 387
 388         if ((objnum < 0) || (objnum > Highest_object_index))
 389         {
 390                 Int3(); // See rob
 391                 return;
 392         }
 393
 394         if (Objects[objnum].type != OBJ_ROBOT)
 395         {
 396                 Int3(); // See rob
 397                 return;
 398         }
 399
 400         multi_delete_controlled_robot(objnum);
 401
 402         multibuf[0] = (char)MULTI_ROBOT_RELEASE;
 403         multibuf[1] = Player_num;
 404         s = objnum_local_to_remote(objnum, (sbyte *)&multibuf[4]);
 405         PUT_INTEL_SHORT(multibuf+2, s);
 406
 407         multi_send_data(multibuf, 5, 2);
 408         multi_send_data(multibuf, 5, 2);
 409         multi_send_data(multibuf, 5, 2);
 410 }
 411
 412 #define MIN_ROBOT_COM_GAP F1_0/12
 413
 414 int
 415 multi_send_robot_frame(int sent)
 416 {
 417         static int last_sent = 0;
 418
 419         int i;
 420         int rval = 0;
 421
 422         for (i = 0; i < MAX_ROBOTS_CONTROLLED; i++)
 423         {
 424                 int sending = (last_sent+1+i)%MAX_ROBOTS_CONTROLLED;
 425                 if ( (robot_controlled[sending] != -1) && ((robot_send_pending[sending] > sent) || (robot_fired[sending] > sent)) )
 426                 {
 427                         if (robot_send_pending[sending])
 428                         {
 429                                 robot_send_pending[sending] = 0;
 430                                 multi_send_robot_position_sub(robot_controlled[sending]);
 431                         }
 432
 433                         if (robot_fired[sending])
 434                         {
 435                                 robot_fired[sending] = 0;
 436                                 multi_send_data((char *)robot_fire_buf[sending], 18, 1);
 437                         }
 438
 439                         if (!(Game_mode & GM_NETWORK))
 440                                 sent += 1;
 441
 442                         last_sent = sending;
 443                         rval++;
 444                 }
 445         }
 446         Assert((last_sent >= 0) && (last_sent <= MAX_ROBOTS_CONTROLLED));
 447         return(rval);
 448 }
 449
 450 void
 451 multi_send_robot_position_sub(int objnum)
 452 {
 453         int loc = 0;
 454         short s;
 455 #ifdef WORDS_BIGENDIAN
 456         shortpos sp;
 457 #endif
 458
 459 //      mprintf((0, "SENDPOS object %d, Gametime %d.\n", objnum, GameTime));
 460
 461         multibuf[loc] = MULTI_ROBOT_POSITION;                                                           loc += 1;
 462         multibuf[loc] = Player_num;                                                                                     loc += 1;
 463         s = objnum_local_to_remote(objnum, (sbyte *)&multibuf[loc+2]);
 464         PUT_INTEL_SHORT(multibuf+loc, s);
 465
 466                                                                                                                                                 loc += 3;
 467 #ifndef WORDS_BIGENDIAN
 468         create_shortpos((shortpos *)(multibuf+loc), Objects+objnum,0);          loc += sizeof(shortpos);
 469 #else
 470         create_shortpos(&sp, Objects+objnum, 1);
 471         memcpy(&(multibuf[loc]), (ubyte *)(sp.bytemat), 9);
 472         loc += 9;
 473         memcpy(&(multibuf[loc]), (ubyte *)&(sp.xo), 14);
 474         loc += 14;
 475 #endif
 476         multi_send_data(multibuf, loc, 1);
 477 }
 478
 479 void
 480 multi_send_robot_position(int objnum, int force)
 481 {
 482         // Send robot position to other player(s).  Includes a byte
 483         // value describing whether or not they fired a weapon
 484
 485         if (!(Game_mode & GM_MULTI))
 486                 return;
 487
 488         if ((objnum < 0) || (objnum > Highest_object_index))
 489         {
 490                 Int3(); // See rob
 491                 return;
 492         }
 493         if (Objects[objnum].type != OBJ_ROBOT)
 494         {
 495                 Int3(); // See rob
 496                 return;
 497         }
 498
 499         if (Objects[objnum].ctype.ai_info.REMOTE_OWNER != Player_num)
 500                 return;
 501
 502 //      Objects[objnum].phys_info.drag = Robot_info[Objects[objnum].id].drag; // Set drag to normal
 503
 504         robot_last_send_time[Objects[objnum].ctype.ai_info.REMOTE_SLOT_NUM] = GameTime;
 505
 506         robot_send_pending[Objects[objnum].ctype.ai_info.REMOTE_SLOT_NUM] = 1+force;
 507
 508         if (force & (Game_mode & GM_NETWORK))
 509                 PacketUrgent = 1;
 510
 511         return;
 512 }
 513
 514 void
 515 multi_send_robot_fire(int objnum, int gun_num, vms_vector *fire)
 516 {
 517         // Send robot fire event
 518         int loc = 0;
 519         short s;
 520 #ifdef WORDS_BIGENDIAN
 521         vms_vector swapped_vec;
 522 #endif
 523
 524         multibuf[loc] = MULTI_ROBOT_FIRE;                                               loc += 1;
 525         multibuf[loc] = Player_num;                                                             loc += 1;
 526         s = objnum_local_to_remote(objnum, (sbyte *)&multibuf[loc+2]);
 527         PUT_INTEL_SHORT(multibuf+loc, s);
 528                                                                                                                                                 loc += 3;
 529         multibuf[loc] = gun_num;                                                                        loc += 1;
 530 #ifndef WORDS_BIGENDIAN
 531         memcpy(multibuf+loc, fire, sizeof(vms_vector));         loc += sizeof(vms_vector); // 12
 532         // --------------------------
 533         //      Total = 18
 534 #else
 535         swapped_vec.x = (fix)INTEL_INT((int)fire->x);
 536         swapped_vec.y = (fix)INTEL_INT((int)fire->y);
 537         swapped_vec.z = (fix)INTEL_INT((int)fire->z);
 538         memcpy(multibuf+loc, &swapped_vec, sizeof(vms_vector)); loc += sizeof(vms_vector);
 539 #endif
 540
 541         if (Objects[objnum].ctype.ai_info.REMOTE_OWNER == Player_num)
 542         {
 543                 int slot = Objects[objnum].ctype.ai_info.REMOTE_SLOT_NUM;
 544                 if (slot<0 || slot>=MAX_ROBOTS_CONTROLLED)
 545                  {
 546                         mprintf ((0,"Saved from asserting in robofire\n"));
 547                         return;
 548                  }
 549                 if (robot_fired[slot] != 0)
 550                  {
 551                         mprintf ((0,"Couldn't find an open slot for robo firing!\n"));
 552                   //    Int3(); // ROB!
 553                         return;
 554             }
 555                 memcpy(robot_fire_buf[slot], multibuf, loc);
 556                 robot_fired[slot] = 1;
 557                 if (Game_mode & GM_NETWORK)
 558                         PacketUrgent = 1;
 559         }
 560         else
 561                 multi_send_data(multibuf, loc, 2); // Not our robot, send ASAP
 562 }
 563
 564 void
 565 multi_send_robot_explode(int objnum, int killer,char isthief)
 566 {
 567         // Send robot explosion event to the other players
 568
 569         int loc = 0;
 570         short s;
 571
 572         multibuf[loc] = MULTI_ROBOT_EXPLODE;                                    loc += 1;
 573         multibuf[loc] = Player_num;                                                             loc += 1;
 574         s = (short)objnum_local_to_remote(killer, (sbyte *)&multibuf[loc+2]);
 575         PUT_INTEL_SHORT(multibuf+loc, s);                       loc += 3;
 576
 577         s = (short)objnum_local_to_remote(objnum, (sbyte *)&multibuf[loc+2]);
 578         PUT_INTEL_SHORT(multibuf+loc, s);                       loc += 3;
 579
 580         multibuf[loc]=isthief;   loc++;
 581
 582         multi_send_data(multibuf, loc, 1);
 583
 584         multi_delete_controlled_robot(objnum);
 585 }
 586
 587 void
 588 multi_send_create_robot(int station, int objnum, int type)
 589 {
 590         // Send create robot information
 591
 592         int loc = 0;
 593
 594         multibuf[loc] = MULTI_CREATE_ROBOT;                                             loc += 1;
 595         multibuf[loc] = Player_num;                                                             loc += 1;
 596         multibuf[loc] = (sbyte)station;                         loc += 1;
 597         PUT_INTEL_SHORT(multibuf+loc, objnum);                  loc += 2;
 598         multibuf[loc] = type;                                                                   loc += 1;
 599
 600         map_objnum_local_to_local((short)objnum);
 601
 602         multi_send_data(multibuf, loc, 2);
 603 }
 604
 605 void
 606 multi_send_boss_actions(int bossobjnum, int action, int secondary, int objnum)
 607 {
 608         // Send special boss behavior information
 609
 610         int loc = 0;
 611
 612         multibuf[loc] = MULTI_BOSS_ACTIONS;                                             loc += 1;
 613         multibuf[loc] = Player_num;                                                             loc += 1; // Which player is controlling the boss
 614         PUT_INTEL_SHORT(multibuf+loc, bossobjnum);              loc += 2; // We won't network map this objnum since it's the boss
 615         multibuf[loc] = (sbyte)action;                          loc += 1; // What is the boss doing?
 616         multibuf[loc] = (sbyte)secondary;                       loc += 1; // More info for what he is doing
 617         PUT_INTEL_SHORT(multibuf+loc, objnum);                  loc += 2; // Objnum of object created by gate-in action
 618         if (action == 3) {
 619                 PUT_INTEL_SHORT(multibuf+loc, Objects[objnum].segnum); loc += 2; // Segment number object created in (for gate only)
 620         }
 621         else
 622                                                                                                                                                 loc += 2; // Dummy
 623
 624         if (action == 1) { // Teleport releases robot
 625                 // Boss is up for grabs after teleporting
 626                 mprintf((0, "Boss teleporting, removed from my list.\n"));
 627                 Assert((Objects[bossobjnum].ctype.ai_info.REMOTE_SLOT_NUM >= 0) && (Objects[bossobjnum].ctype.ai_info.REMOTE_SLOT_NUM < MAX_ROBOTS_CONTROLLED));
 628                 multi_delete_controlled_robot(bossobjnum);
 629 //              robot_controlled[Objects[bossobjnum].ctype.ai_info.REMOTE_SLOT_NUM] = -1;
 630 //              Objects[bossobjnum].ctype.ai_info.REMOTE_OWNER = -1;
 631 //              Objects[bossobjnum].ctype.ai_info.REMOTE_SLOT_NUM = 5; // Hands-off period!
 632         }
 633         if (action == 3) {
 634                 mprintf((0, "LOCAL:Boss gating in robot id %d, objnum %d (%d).\n", secondary, objnum, objnum));
 635         }
 636         multi_send_data(multibuf, loc, 1);
 637 }
 638
 639 #define MAX_ROBOT_POWERUPS 4
 640
 641 void
 642 multi_send_create_robot_powerups(object *del_obj)
 643 {
 644         // Send create robot information
 645
 646         int loc = 0;
 647         int i;
 648 #ifdef WORDS_BIGENDIAN
 649         vms_vector swapped_vec;
 650 #endif
 651
 652         multibuf[loc] = MULTI_CREATE_ROBOT_POWERUPS;                            loc += 1;
 653         multibuf[loc] = Player_num;                                                                     loc += 1;
 654         multibuf[loc] = del_obj->contains_count;                                        loc += 1;
 655         multibuf[loc] = del_obj->contains_type;                                         loc += 1;
 656         multibuf[loc] = del_obj->contains_id;                                           loc += 1;
 657         PUT_INTEL_SHORT(multibuf+loc, del_obj->segnum);                 loc += 2;
 658 #ifndef WORDS_BIGENDIAN
 659         memcpy(multibuf+loc, &del_obj->pos, sizeof(vms_vector));        loc += 12;
 660 #else
 661         swapped_vec.x = (fix)INTEL_INT((int)del_obj->pos.x);
 662         swapped_vec.y = (fix)INTEL_INT((int)del_obj->pos.y);
 663         swapped_vec.z = (fix)INTEL_INT((int)del_obj->pos.z);
 664         memcpy(multibuf+loc, &swapped_vec, sizeof(vms_vector));     loc += 12;
 665 #endif
 666
 667         memset(multibuf+loc, -1, MAX_ROBOT_POWERUPS*sizeof(short));
 668
 669    if (del_obj->contains_count!=Net_create_loc)
 670           Int3();  //Get Jason, a bad thing happened
 671
 672         if ((Net_create_loc > MAX_ROBOT_POWERUPS) || (Net_create_loc < 1))
 673         {
 674                 Int3(); // See Rob
 675         }
 676         for (i = 0; i < Net_create_loc; i++)
 677         {
 678                 PUT_INTEL_SHORT(multibuf+loc, Net_create_objnums[i]);
 679                 loc += 2;
 680                 map_objnum_local_to_local(Net_create_objnums[i]);
 681         }
 682
 683         Net_create_loc = 0;
 684
 685         multi_send_data(multibuf, 27, 2);
 686 }
 687
 688 void
 689 multi_do_claim_robot(char *buf)
 690 {
 691         short botnum, remote_botnum;
 692         char pnum;
 693
 694         pnum = buf[1];
 695
 696         remote_botnum = GET_INTEL_SHORT(buf + 2);
 697         botnum = objnum_remote_to_local(remote_botnum, (sbyte)buf[4]);
 698
 699         if ((botnum > Highest_object_index) || (botnum < 0)) {
 700                 mprintf((1, "Ignoring claim message for object I don't have.\n"));
 701 //              Int3(); // See rob
 702                 return;
 703         }
 704
 705         if (Objects[botnum].type != OBJ_ROBOT) {
 706                 mprintf((1, "Got MYBOT message for non-Robot!\n"));
 707                 return;
 708         }
 709
 710         if (Objects[botnum].ctype.ai_info.REMOTE_OWNER != -1)
 711         {
 712                 mprintf((0, "Got a MYBOT message bot %d (%d) currently controlled by player %d.\n", botnum, remote_botnum, Objects[botnum].ctype.ai_info.REMOTE_OWNER));
 713                 if (MULTI_ROBOT_PRIORITY(remote_botnum, pnum) <= MULTI_ROBOT_PRIORITY(remote_botnum, Objects[botnum].ctype.ai_info.REMOTE_OWNER))
 714                         return;
 715         }
 716
 717         // Perform the requested change
 718
 719         mprintf((0, "Player %d taking control of robot %d (%d).\n", pnum, botnum, remote_botnum));
 720
 721         if (Objects[botnum].ctype.ai_info.REMOTE_OWNER == Player_num)
 722         {
 723                 multi_delete_controlled_robot(botnum);
 724         }
 725
 726         Objects[botnum].ctype.ai_info.REMOTE_OWNER = pnum;
 727         Objects[botnum].ctype.ai_info.REMOTE_SLOT_NUM = 0;
 728 }
 729
 730 void
 731 multi_do_release_robot(char *buf)
 732 {
 733         short botnum, remote_botnum;
 734         char pnum;
 735
 736         pnum = buf[1];
 737
 738         remote_botnum = GET_INTEL_SHORT(buf + 2);
 739         botnum = objnum_remote_to_local(remote_botnum, (sbyte)buf[4]);
 740
 741         if ((botnum < 0) || (botnum > Highest_object_index)) {
 742                 mprintf((1, "Ignoring release message for object I don't have.\n"));
 743 //              Int3(); // See rob
 744                 return;
 745         }
 746
 747         if (Objects[botnum].type != OBJ_ROBOT) {
 748                 mprintf((1, "Got RELEASE message for non-Robot!\n"));
 749                 return;
 750         }
 751
 752         if (Objects[botnum].ctype.ai_info.REMOTE_OWNER != pnum)
 753         {
 754                 mprintf((0, "Got a RELEASE message for bot %d not controlled by player %d.\n", botnum, pnum));
 755                 return;
 756         }
 757
 758         // Perform the requested change
 759
 760         mprintf((0, "Player %d releasing control of robot %d (%d).\n", pnum, botnum, remote_botnum));
 761
 762         Objects[botnum].ctype.ai_info.REMOTE_OWNER = -1;
 763         Objects[botnum].ctype.ai_info.REMOTE_SLOT_NUM = 0;
 764 }
 765
 766 void
 767 multi_do_robot_position(char *buf)
 768 {
 769         // Process robot movement sent by another player
 770
 771         short botnum, remote_botnum;
 772         char pnum;
 773         int loc = 1;
 774 #ifdef WORDS_BIGENDIAN
 775         shortpos sp;
 776 #endif
 777
 778         pnum = buf[loc];                                                                                loc += 1;
 779
 780         remote_botnum = GET_INTEL_SHORT(buf + loc);
 781         botnum = objnum_remote_to_local(remote_botnum, (sbyte)buf[loc+2]); loc += 3;
 782
 783         if ((botnum < 0) || (botnum > Highest_object_index)) {
 784                 mprintf((1, "Got robot position for object I don't have.\n"));
 785 //              Int3(); // See rob
 786                 return;
 787         }
 788
 789         if ((Objects[botnum].type != OBJ_ROBOT) || (Objects[botnum].flags & OF_EXPLODING)) {
 790 //              mprintf((0, "Ignoring position packet for non-robot or exploding robot.\n"));
 791                 return;
 792         }
 793
 794         if (Objects[botnum].ctype.ai_info.REMOTE_OWNER != pnum)
 795         {
 796                 if (Objects[botnum].ctype.ai_info.REMOTE_OWNER == -1)
 797                 {
 798                         // Robot claim packet must have gotten lost, let this player claim it.
 799                         if (Objects[botnum].ctype.ai_info.REMOTE_SLOT_NUM > 3) {
 800                                 mprintf((0, "Player %d taking control of robot %d WITHOUT claim message.\n", pnum, botnum));
 801                                 Objects[botnum].ctype.ai_info.REMOTE_OWNER = pnum;
 802                                 Objects[botnum].ctype.ai_info.REMOTE_SLOT_NUM = 0;
 803                         }
 804                         else
 805                                 Objects[botnum].ctype.ai_info.REMOTE_SLOT_NUM++;
 806                 }
 807                 else
 808                 {
 809                         mprintf((0, "Ignoring position for robot %d not controlled by player %d.\n", botnum, pnum));
 810                         return;
 811                 }
 812         }
 813
 814         set_thrust_from_velocity(&Objects[botnum]); // Try to smooth out movement
 815 //      Objects[botnum].phys_info.drag = Robot_info[Objects[botnum].id].drag >> 4; // Set drag to low
 816
 817 #ifndef WORDS_BIGENDIAN
 818         extract_shortpos(&Objects[botnum], (shortpos *)(buf+loc), 0);
 819 #else
 820         memcpy((ubyte *)(sp.bytemat), (ubyte *)(buf + loc), 9);         loc += 9;
 821         memcpy((ubyte *)&(sp.xo), (ubyte *)(buf + loc), 14);
 822         extract_shortpos(&Objects[botnum], &sp, 1);
 823 #endif
 824 }
 825
 826 void
 827 multi_do_robot_fire(char *buf)
 828 {
 829         // Send robot fire event
 830         int loc = 1;
 831         int botnum;
 832         short remote_botnum;
 833         int pnum, gun_num;
 834         vms_vector fire, gun_point;
 835         robot_info *robptr;
 836
 837         pnum = buf[loc];                                                                                                loc += 1;
 838         remote_botnum = GET_INTEL_SHORT(buf + loc);
 839         botnum = objnum_remote_to_local(remote_botnum, (sbyte)buf[loc+2]); loc += 3;
 840         gun_num = (sbyte)buf[loc];                                      loc += 1;
 841         memcpy(&fire, buf+loc, sizeof(vms_vector));
 842         fire.x = (fix)INTEL_INT((int)fire.x);
 843         fire.y = (fix)INTEL_INT((int)fire.y);
 844         fire.z = (fix)INTEL_INT((int)fire.z);
 845
 846         if ((botnum < 0) || (botnum > Highest_object_index) || (Objects[botnum].type != OBJ_ROBOT) || (Objects[botnum].flags & OF_EXPLODING))
 847         {
 848 //              mprintf((1, "Ignored robot fire from deleted robot.\n"));
 849 //              Int3(); // See Rob, probably not serious tho
 850                 return;
 851         }
 852
 853         // Do the firing
 854
 855         if (gun_num == -1 || gun_num==-2)
 856         {
 857                 // Drop proximity bombs
 858                 vm_vec_add(&gun_point, &Objects[botnum].pos, &fire);
 859         }
 860         else
 861         {
 862                 calc_gun_point(&gun_point, &Objects[botnum], gun_num);
 863         }
 864         robptr = &Robot_info[Objects[botnum].id];
 865
 866         if (gun_num == -1)
 867                 Laser_create_new_easy( &fire, &gun_point, botnum, PROXIMITY_ID, 1);
 868         else if (gun_num == -2)
 869                 Laser_create_new_easy( &fire, &gun_point, botnum, SUPERPROX_ID, 1);
 870         else
 871                 Laser_create_new_easy( &fire, &gun_point, botnum, robptr->weapon_type, 1);
 872 }
 873
 874 extern void drop_stolen_items (object *);
 875
 876 int
 877 multi_explode_robot_sub(int botnum, int killer,char isthief)
 878 {
 879         object *robot;
 880
 881         killer = killer;
 882
 883         if ((botnum < 0) || (botnum > Highest_object_index)) { // Objnum in range?
 884                 Int3(); // See rob
 885                 return 0;
 886         }
 887
 888         if (Objects[botnum].type != OBJ_ROBOT) { // Object is robot?
 889                 mprintf((1, "Non-robot explosion ignored.\n"));
 890 //              Int3(); // See rob
 891                 return 0;
 892         }
 893
 894         if (Objects[botnum].flags & OF_EXPLODING) { // Object not already exploding
 895                 return 0;
 896         }
 897
 898         // Data seems valid, explode the sucker
 899
 900         if (Network_send_objects && network_objnum_is_past(botnum))
 901         {
 902                 mprintf((0, "Resetting object sync due to object removal.\n"));
 903                 Network_send_objnum = -1;
 904         }
 905
 906         robot = &Objects[botnum];
 907
 908         mprintf((0, "Robot %d controlled by player %d exploded.\n", botnum, robot->ctype.ai_info.REMOTE_OWNER));
 909
 910         // Drop non-random KEY powerups locally only!
 911         if ((robot->contains_count > 0) && (robot->contains_type == OBJ_POWERUP) && (Game_mode & GM_MULTI_COOP) && (robot->contains_id >= POW_KEY_BLUE) && (robot->contains_id <= POW_KEY_GOLD))
 912         {
 913                 object_create_egg(robot);
 914         }
 915         else if (robot->ctype.ai_info.REMOTE_OWNER == Player_num)
 916         {
 917                 multi_drop_robot_powerups(robot-Objects);
 918                 multi_delete_controlled_robot(robot-Objects);
 919         }
 920         else if (robot->ctype.ai_info.REMOTE_OWNER == -1 && network_i_am_master())
 921         {
 922                 multi_drop_robot_powerups(robot-Objects);
 923                 //multi_delete_controlled_robot(robot-Objects);
 924         }
 925
 926    if (isthief || Robot_info[robot->id].thief)
 927          drop_stolen_items(robot);
 928
 929         if (Robot_info[robot->id].boss_flag) {
 930                 if (!Boss_dying)
 931                         start_boss_death_sequence(robot);
 932                 else
 933                         return (0);
 934         } else if (Robot_info[robot->id].death_roll) {
 935                 start_robot_death_sequence(robot);
 936         } else {
 937                 if (robot->id == SPECIAL_REACTOR_ROBOT)
 938                         special_reactor_stuff();
 939                 if (Robot_info[robot->id].kamikaze)
 940                         explode_object(robot,1);        //      Kamikaze, explode right away, IN YOUR FACE!
 941                 else
 942                         explode_object(robot,STANDARD_EXPL_DELAY);
 943    }
 944
 945         return 1;
 946 }
 947
 948 void
 949 multi_do_robot_explode(char *buf)
 950 {
 951         // Explode robot controlled by other player
 952
 953         int botnum;
 954         short remote_botnum;
 955         int loc = 1;
 956         short killer, remote_killer;
 957         int pnum;
 958         int rval;
 959         char thief;
 960
 961         pnum = buf[loc];                                        loc += 1;
 962         remote_killer = GET_INTEL_SHORT(buf + loc);
 963         killer = objnum_remote_to_local(remote_killer, (sbyte)buf[loc+2]); loc += 3;
 964         remote_botnum = GET_INTEL_SHORT(buf + loc);
 965         botnum = objnum_remote_to_local(remote_botnum, (sbyte)buf[loc+2]); loc += 3;
 966    thief=buf[loc];
 967
 968         if ((botnum < 0) || (botnum > Highest_object_index)) {
 969 //              Int3();
 970                 mprintf((0, "Ignored explode message for robot I don't have.\n"));
 971                 return;
 972         }
 973
 974         rval = multi_explode_robot_sub(botnum, killer,thief);
 975
 976         if (rval && (killer == Players[Player_num].objnum))
 977                 add_points_to_score(Robot_info[Objects[botnum].id].score_value);
 978 }
 979
 980 extern fix EnergyToCreateOneRobot; // From fuelcen.c
 981 extern object *create_morph_robot(segment *segp, vms_vector *object_pos, int object_id); // from fuelcen.c
 982
 983 void
 984 multi_do_create_robot(char *buf)
 985 {
 986
 987         int fuelcen_num = buf[2];
 988         int pnum = buf[1];
 989         short objnum;
 990         int type = buf[5];
 991
 992         FuelCenter *robotcen;
 993         vms_vector cur_object_loc, direction;
 994         object *obj;
 995
 996         objnum = GET_INTEL_SHORT(buf + 3);
 997
 998         if ((pnum < 0) || (objnum < 0) || (fuelcen_num < 0) || (fuelcen_num >= Num_fuelcenters) || (pnum >= N_players))
 999         {
1000                 Int3(); // Bogus data
1001                 return;
1002         }
1003
1004         robotcen = &Station[fuelcen_num];
1005
1006         mprintf((1, "NETWORK: Creating morph robot from matcen %d.\n", fuelcen_num)); // DEBUG
1007
1008         // Play effect and sound
1009
1010         compute_segment_center(&cur_object_loc, &Segments[robotcen->segnum]);
1011         obj = object_create_explosion(robotcen->segnum, &cur_object_loc, i2f(10), VCLIP_MORPHING_ROBOT);
1012         if (obj)
1013                 extract_orient_from_segment(&obj->orient, &Segments[robotcen->segnum]);
1014         if (Vclip[VCLIP_MORPHING_ROBOT].sound_num > -1)
1015                 digi_link_sound_to_pos( Vclip[VCLIP_MORPHING_ROBOT].sound_num, robotcen->segnum, 0, &cur_object_loc, 0, F1_0 );
1016
1017         // Set robot center flags, in case we become the master for the next one
1018
1019         robotcen->Flag = 0;
1020         robotcen->Capacity -= EnergyToCreateOneRobot;
1021         robotcen->Timer = 0;
1022
1023         obj = create_morph_robot(&Segments[robotcen->segnum], &cur_object_loc, type);
1024         if (obj == NULL)
1025                 return; // Cannot create object!
1026
1027         obj->matcen_creator = (robotcen-Station) | 0x80;
1028 //      extract_orient_from_segment(&obj->orient, &Segments[robotcen->segnum]);
1029         vm_vec_sub( &direction, &ConsoleObject->pos, &obj->pos );
1030         vm_vector_2_matrix( &obj->orient, &direction, &obj->orient.uvec, NULL);
1031         morph_start( obj );
1032
1033         mprintf((1, "matcen created robot %d (remote %d)\n", obj-Objects, objnum));
1034         map_objnum_local_to_remote(obj-Objects, objnum, pnum);
1035
1036         Assert(obj->ctype.ai_info.REMOTE_OWNER == -1);
1037 }
1038
1039 void
1040 multi_do_boss_actions(char *buf)
1041 {
1042         // Code to handle remote-controlled boss actions
1043
1044         object *boss_obj;
1045         int boss_objnum;
1046         int pnum;
1047         int action, secondary;
1048         int loc = 1;
1049         short remote_objnum, segnum;
1050
1051         pnum = buf[loc];                                                                        loc += 1;
1052         boss_objnum = GET_INTEL_SHORT(buf + loc);           loc += 2;
1053         action = buf[loc];                                                                      loc += 1;
1054         secondary = buf[loc];                                                           loc += 1;
1055         remote_objnum = GET_INTEL_SHORT(buf + loc);         loc += 2;
1056         segnum = GET_INTEL_SHORT(buf + loc);                loc += 2;
1057
1058         if ((boss_objnum < 0) || (boss_objnum > Highest_object_index))
1059         {
1060                 Int3();  // See Rob
1061                 return;
1062         }
1063
1064         boss_obj = &Objects[boss_objnum];
1065
1066         if ((boss_obj->type != OBJ_ROBOT) || !(Robot_info[boss_obj->id].boss_flag))
1067         {
1068                 Int3(); // Got boss actions for a robot who's not a boss?
1069                 return;
1070         }
1071
1072         mprintf((0, "REMOTE: performing boss action %d.\n", action));
1073
1074         switch(action)
1075         {
1076                 case 1: // Teleport
1077                         {
1078                                 int teleport_segnum;
1079                                 vms_vector boss_dir;
1080
1081                                 if ((secondary < 0) || (secondary > Num_boss_teleport_segs))
1082                                 {
1083                                         Int3(); // Bad segnum for boss teleport, ROB!!
1084                                         return;
1085                                 }
1086                                 teleport_segnum = Boss_teleport_segs[secondary];
1087                                 mprintf((0, "Boss is teleporting, remove from other's list.\n"));
1088                                 if ((teleport_segnum < 0) || (teleport_segnum > Highest_segment_index))
1089                                 {
1090                                         Int3();  // See Rob
1091                                         return;
1092                                 }
1093                                 compute_segment_center(&boss_obj->pos, &Segments[teleport_segnum]);
1094                                 obj_relink(boss_obj-Objects, teleport_segnum);
1095                                 Last_teleport_time = GameTime;
1096
1097                                 vm_vec_sub(&boss_dir, &Objects[Players[pnum].objnum].pos, &boss_obj->pos);
1098                                 vm_vector_2_matrix(&boss_obj->orient, &boss_dir, NULL, NULL);
1099
1100                                 digi_link_sound_to_pos( Vclip[VCLIP_MORPHING_ROBOT].sound_num, teleport_segnum, 0, &boss_obj->pos, 0 , F1_0);
1101                                 digi_kill_sound_linked_to_object( boss_obj-Objects);
1102                                 digi_link_sound_to_object2( SOUND_BOSS_SHARE_SEE, boss_obj-Objects, 1, F1_0, F1_0*512 );        //      F1_0*512 means play twice as loud
1103                                 Ai_local_info[boss_obj-Objects].next_fire = 0;
1104
1105                                 if (boss_obj->ctype.ai_info.REMOTE_OWNER == Player_num)
1106                                 {
1107                                         mprintf((1, "WARNING: Accepted teleport message for boss when I controlled him!\n"));
1108                                         multi_delete_controlled_robot(boss_objnum);
1109 //                                      robot_controlled[boss_obj->ctype.ai_info.REMOTE_SLOT_NUM] = -1;
1110                                 }
1111
1112                                 boss_obj->ctype.ai_info.REMOTE_OWNER = -1; // Boss is up for grabs again!
1113                                 boss_obj->ctype.ai_info.REMOTE_SLOT_NUM = 0; // Available immediately!
1114                         }
1115                         break;
1116                 case 2: // Cloak
1117                         Boss_hit_time = -F1_0*10;
1118                         Boss_cloak_start_time = GameTime;
1119                         Boss_cloak_end_time = GameTime + Boss_cloak_duration;
1120                         boss_obj->ctype.ai_info.CLOAKED = 1;
1121                         break;
1122                 case 3: // Gate in robots!
1123                         {
1124                                 // Do some validity checking
1125                                 if ( (remote_objnum >= MAX_OBJECTS) || (remote_objnum < 0) || (segnum < 0) || (segnum > Highest_segment_index) )
1126                                 {
1127                                         Int3(); // See Rob, bad data in boss gate action message
1128                                         return;
1129                                 }
1130
1131                                 // Gate one in!
1132                                 if (gate_in_robot(secondary, segnum))
1133                                         map_objnum_local_to_remote(Net_create_objnums[0], remote_objnum, pnum);
1134                                 mprintf((0, "REMOTE: Boss gating in robot id %d, objnum %d (%d).\n", secondary, Net_create_objnums[0], remote_objnum));
1135                         }
1136                         break;
1137                 case 4: // Start effect
1138                         restart_effect(BOSS_ECLIP_NUM);
1139                         break;
1140                 case 5: // Stop effect
1141                         stop_effect(BOSS_ECLIP_NUM);
1142                         break;
1143                 default:
1144                         Int3(); // Illegal type to boss actions
1145         }
1146 }
1147
1148 void
1149 multi_do_create_robot_powerups(char *buf)
1150 {
1151         // Code to drop remote-controlled robot powerups
1152
1153         int loc = 1;
1154         object del_obj;
1155         int pnum, egg_objnum, i;
1156
1157         pnum = buf[loc];                                                                                loc += 1;
1158         del_obj.contains_count = buf[loc];                                              loc += 1;
1159         del_obj.contains_type = buf[loc];                                               loc += 1;
1160         del_obj.contains_id = buf[loc];                                                 loc += 1;
1161         del_obj.segnum = GET_INTEL_SHORT(buf + loc);            loc += 2;
1162         memcpy(&del_obj.pos, buf+loc, sizeof(vms_vector));      loc += 12;
1163
1164         vm_vec_zero(&del_obj.mtype.phys_info.velocity);
1165
1166         del_obj.pos.x = (fix)INTEL_INT((int)del_obj.pos.x);
1167         del_obj.pos.y = (fix)INTEL_INT((int)del_obj.pos.y);
1168         del_obj.pos.z = (fix)INTEL_INT((int)del_obj.pos.z);
1169
1170         Assert((pnum >= 0) && (pnum < N_players));
1171         Assert (pnum!=Player_num); // What? How'd we send ourselves this?
1172
1173         Net_create_loc = 0;
1174         d_srand(1245L);
1175
1176         egg_objnum = object_create_egg(&del_obj);
1177
1178         if (egg_objnum == -1)
1179                 return; // Object buffer full
1180
1181 //      Assert(egg_objnum > -1);
1182         Assert((Net_create_loc > 0) && (Net_create_loc <= MAX_ROBOT_POWERUPS));
1183
1184         for (i = 0; i < Net_create_loc; i++)
1185         {
1186                 short s;
1187
1188                 s = GET_INTEL_SHORT(buf + loc);
1189                 if ( s != -1)
1190                         map_objnum_local_to_remote((short)Net_create_objnums[i], s, pnum);
1191                 else
1192                         Objects[Net_create_objnums[i]].flags |= OF_SHOULD_BE_DEAD; // Delete objects other guy didn't create one of
1193                 loc += 2;
1194         }
1195 }
1196
1197 void
1198 multi_drop_robot_powerups(int objnum)
1199 {
1200         // Code to handle dropped robot powerups in network mode ONLY!
1201
1202         object *del_obj;
1203         int egg_objnum = -1;
1204         robot_info      *robptr;
1205
1206         if ((objnum < 0) || (objnum > Highest_object_index))
1207         {
1208                 Int3();  // See rob
1209                 return;
1210         }
1211
1212         del_obj = &Objects[objnum];
1213
1214         if (del_obj->type != OBJ_ROBOT)
1215         {
1216                 Int3(); // dropping powerups for non-robot, Rob's fault
1217                 return;
1218         }
1219
1220         robptr = &Robot_info[del_obj->id];
1221
1222         Net_create_loc = 0;
1223
1224         if (del_obj->contains_count > 0) {
1225                 //      If dropping a weapon that the player has, drop energy instead, unless it's vulcan, in which case drop vulcan ammo.
1226                 if (del_obj->contains_type == OBJ_POWERUP) {
1227                         maybe_replace_powerup_with_energy(del_obj);
1228                         if (!multi_powerup_is_allowed(del_obj->contains_id))
1229                                 del_obj->contains_id=POW_SHIELD_BOOST;
1230
1231                         // No key drops in non-coop games!
1232                         if (!(Game_mode & GM_MULTI_COOP)) {
1233                                 if ((del_obj->contains_id >= POW_KEY_BLUE) && (del_obj->contains_id <= POW_KEY_GOLD))
1234                                         del_obj->contains_count = 0;
1235                         }
1236                 }
1237                 d_srand(1245L);
1238                 if (del_obj->contains_count > 0)
1239                         egg_objnum = object_create_egg(del_obj);
1240         }
1241
1242         else if (del_obj->ctype.ai_info.REMOTE_OWNER == -1) // No random goodies for robots we weren't in control of
1243                 return;
1244
1245         else if (robptr->contains_count) {
1246                 d_srand(timer_get_approx_seconds());
1247                 if (((d_rand() * 16) >> 15) < robptr->contains_prob) {
1248                         del_obj->contains_count = ((d_rand() * robptr->contains_count) >> 15) + 1;
1249                         del_obj->contains_type = robptr->contains_type;
1250                         del_obj->contains_id = robptr->contains_id;
1251                         if (del_obj->contains_type == OBJ_POWERUP)
1252                          {
1253                                 maybe_replace_powerup_with_energy(del_obj);
1254                                 if (!multi_powerup_is_allowed(del_obj->contains_id))
1255                                         del_obj->contains_id=POW_SHIELD_BOOST;
1256                          }
1257
1258                         d_srand(1245L);
1259                         if (del_obj->contains_count > 0)
1260                                 egg_objnum = object_create_egg(del_obj);
1261                 }
1262         }
1263
1264         if (egg_objnum >= 0) {
1265                 // Transmit the object creation to the other players
1266                 mprintf((0, "Dropped %d powerups for robot %d.\n", Net_create_loc, del_obj-Objects));
1267                 multi_send_create_robot_powerups(del_obj);
1268         }
1269 }
1270
1271 //      -----------------------------------------------------------------------------
1272 //      Robot *robot got whacked by player player_num and requests permission to do something about it.
1273 //      Note: This function will be called regardless of whether Game_mode is a multiplayer mode, so it
1274 //      should quick-out if not in a multiplayer mode.  On the other hand, it only gets called when a
1275 //      player or player weapon whacks a robot, so it happens rarely.
1276 void multi_robot_request_change(object *robot, int player_num)
1277 {
1278         int slot, remote_objnum;
1279         sbyte dummy;
1280
1281         if (!(Game_mode & GM_MULTI_ROBOTS))
1282                 return;
1283
1284 //      if (robot->ctype.ai_info.REMOTE_OWNER == Player_num)
1285 //              return;
1286
1287         slot = robot->ctype.ai_info.REMOTE_SLOT_NUM;
1288
1289         if ((slot < 0) || (slot >= MAX_ROBOTS_CONTROLLED)) {
1290                 Int3();
1291                 return;
1292         }
1293
1294         remote_objnum = objnum_local_to_remote(robot-Objects, &dummy);
1295         if (remote_objnum < 0)
1296                 return;
1297
1298         mprintf((0, "request_change(): my pri %d, player %d's pri %d.\n", MULTI_ROBOT_PRIORITY(remote_objnum, Player_num),
1299                           player_num, MULTI_ROBOT_PRIORITY(remote_objnum, player_num)));
1300
1301         if ( (robot_agitation[slot] < 70) || (MULTI_ROBOT_PRIORITY(remote_objnum, player_num) > MULTI_ROBOT_PRIORITY(remote_objnum, Player_num)) || (d_rand() > 0x4400))
1302         {
1303                 mprintf((0, "Robot %d (%d) released because it got hit by Player %d.\n", robot-Objects, remote_objnum, player_num));
1304                 if (robot_send_pending[slot])
1305                         multi_send_robot_position(robot_controlled[slot], -1);
1306                 multi_send_release_robot(robot_controlled[slot]);
1307                 robot->ctype.ai_info.REMOTE_SLOT_NUM = 5;  // Hands-off period
1308         }
1309 }