This commit was generated by cvs2svn to compensate for changes in r2,
[btb/d2x.git] / main / object.c
1 /*
2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
3 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
6 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
8 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.  
11 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
12 */
13
14
15 #ifdef RCS
16 static char rcsid[] = "$Id: object.c,v 1.1.1.1 2001-01-19 03:30:00 bradleyb Exp $";
17 #endif
18
19 #include <conf.h>
20
21 #ifdef WINDOWS
22 #include "desw.h"
23 #endif
24
25 #include <string.h>     // for memset
26 #include <stdio.h>
27
28 #include "inferno.h"
29 #include "game.h"
30 #include "gr.h"
31 #include "stdlib.h"
32 #include "bm.h"
33 //#include "error.h"
34 #include "mono.h"
35 #include "3d.h"
36 #include "segment.h"
37 #include "texmap.h"
38 #include "laser.h"
39 #include "key.h"
40 #include "gameseg.h"
41 #include "textures.h"
42
43 #include "object.h"
44 #include "physics.h"
45 #include "slew.h"               
46 #include "render.h"
47 #include "wall.h"
48 #include "vclip.h"
49 #include "polyobj.h"
50 #include "fireball.h"
51 #include "laser.h"
52 #include "error.h"
53 #include "pa_enabl.h"
54 #include "ai.h"
55 #include "hostage.h"
56 #include "morph.h"
57 #include "cntrlcen.h"
58 #include "powerup.h"
59 #include "fuelcen.h"
60 #include "endlevel.h"
61
62 #include "sounds.h"
63 #include "collide.h"
64
65 #include "lighting.h"
66 #include "newdemo.h"
67 #include "player.h"
68 #include "weapon.h"
69 #include "network.h"
70 #include "newmenu.h"
71 #include "gauges.h"
72 #include "multi.h"
73 #include "menu.h"
74 #include "args.h"
75 #include "text.h"
76 #include "piggy.h"
77 #include "switch.h"
78
79 #ifdef TACTILE
80 #include "tactile.h"
81 #endif
82
83 #ifdef EDITOR
84 #include "editor\editor.h"
85 #endif
86
87 #ifdef _3DFX
88 #include "3dfx_des.h"
89 #endif
90
91 /*
92  *  Global variables
93  */
94
95 extern byte WasRecorded[MAX_OBJECTS];
96
97 ubyte CollisionResult[MAX_OBJECT_TYPES][MAX_OBJECT_TYPES];
98
99 object *ConsoleObject;                                  //the object that is the player
100
101 static short free_obj_list[MAX_OBJECTS];
102
103 //Data for objects
104
105 // -- Object stuff
106
107 //info on the various types of objects
108 #ifndef NDEBUG
109 object  Object_minus_one;
110 #endif
111
112 object Objects[MAX_OBJECTS];
113 int num_objects=0;
114 int Highest_object_index=0;
115 int Highest_ever_object_index=0;
116
117 // grs_bitmap *robot_bms[MAX_ROBOT_BITMAPS];    //all bitmaps for all robots
118
119 // int robot_bm_nums[MAX_ROBOT_TYPES];          //starting bitmap num for each robot
120 // int robot_n_bitmaps[MAX_ROBOT_TYPES];                //how many bitmaps for each robot
121
122 // char *robot_names[MAX_ROBOT_TYPES];          //name of each robot
123
124 //--unused-- int Num_robot_types=0;
125
126 int print_object_info = 0;
127 //@@int Object_viewer = 0;
128
129 //object * Slew_object = NULL;  // Object containing slew object info.
130
131 //--unused-- int Player_controller_type = 0;
132
133 window_rendered_data Window_rendered_data[MAX_RENDERED_WINDOWS];
134
135 #ifndef NDEBUG
136 char    Object_type_names[MAX_OBJECT_TYPES][9] = {
137         "WALL    ",
138         "FIREBALL",
139         "ROBOT   ",
140         "HOSTAGE ",
141         "PLAYER  ",
142         "WEAPON  ",
143         "CAMERA  ",
144         "POWERUP ",
145         "DEBRIS  ",
146         "CNTRLCEN",
147         "FLARE   ",
148         "CLUTTER ",
149         "GHOST   ",
150         "LIGHT   ",
151         "COOP    ",
152         "MARKER  ",
153 };
154 #endif
155
156 #ifndef RELEASE
157 //set viewer object to next object in array
158 void object_goto_next_viewer()
159 {
160         int i, start_obj = 0;
161
162         start_obj = Viewer - Objects;           //get viewer object number
163         
164         for (i=0;i<=Highest_object_index;i++) {
165
166                 start_obj++;
167                 if (start_obj > Highest_object_index ) start_obj = 0;
168
169                 if (Objects[start_obj].type != OBJ_NONE )       {
170                         Viewer = &Objects[start_obj];
171                         return;
172                 }
173         }
174
175         Error( "Couldn't find a viewer object!" );
176
177 }
178
179 //set viewer object to next object in array
180 void object_goto_prev_viewer()
181 {
182         int i, start_obj = 0;
183
184         start_obj = Viewer - Objects;           //get viewer object number
185         
186         for (i=0; i<=Highest_object_index; i++) {
187
188                 start_obj--;
189                 if (start_obj < 0 ) start_obj = Highest_object_index;
190
191                 if (Objects[start_obj].type != OBJ_NONE )       {
192                         Viewer = &Objects[start_obj];
193                         return;
194                 }
195         }
196
197         Error( "Couldn't find a viewer object!" );
198
199 }
200 #endif
201
202 object *obj_find_first_of_type (int type)
203  {
204   int i;
205
206   for (i=0;i<=Highest_object_index;i++)
207         if (Objects[i].type==type)
208          return (&Objects[i]);
209   return ((object *)NULL);
210  }
211
212 int obj_return_num_of_type (int type)
213  {
214   int i,count=0;
215
216   for (i=0;i<=Highest_object_index;i++)
217         if (Objects[i].type==type)
218          count++;
219   return (count);
220  }
221 int obj_return_num_of_typeid (int type,int id)
222  {
223   int i,count=0;
224
225   for (i=0;i<=Highest_object_index;i++)
226         if (Objects[i].type==type && Objects[i].id==id)
227          count++;
228   return (count);
229  }
230
231 int global_orientation = 0;
232
233 //draw an object that has one bitmap & doesn't rotate
234 void draw_object_blob(object *obj,bitmap_index bmi)
235 {
236         int     orientation=0;
237         grs_bitmap * bm = &GameBitmaps[bmi.index];
238
239
240         if (obj->type == OBJ_FIREBALL)
241                 orientation = (obj-Objects) & 7;
242
243         orientation = global_orientation;
244
245 //@@#ifdef WINDOWS
246 //@@    if (obj->type == OBJ_POWERUP) {
247 //@@            if ( GameBitmaps[(bmi).index].bm_flags & BM_FLAG_PAGED_OUT) 
248 //@@                    piggy_bitmap_page_in_w( bmi,1 );
249 //@@    }
250 //@@    if (bm->bm_handle) {
251 //@@            DDGRUNLOCK(dd_grd_curcanv);
252 //@@    }
253 //@@#else
254         PIGGY_PAGE_IN( bmi );
255 //@@#endif      
256
257         if (bm->bm_w > bm->bm_h)
258
259                 g3_draw_bitmap(&obj->pos,obj->size,fixmuldiv(obj->size,bm->bm_h,bm->bm_w),bm, orientation);
260
261         else 
262
263                 g3_draw_bitmap(&obj->pos,fixmuldiv(obj->size,bm->bm_w,bm->bm_h),obj->size,bm, orientation);
264
265 //@@#ifdef WINDOWS
266 //@@    if (bm->bm_handle) {
267 //@@            DDGRLOCK(dd_grd_curcanv);
268 //@@    }
269 //@@#endif
270 }
271
272 //draw an object that is a texture-mapped rod
273 void draw_object_tmap_rod(object *obj,bitmap_index bitmapi,int lighted)
274 {
275         grs_bitmap * bitmap = &GameBitmaps[bitmapi.index];
276         fix light;
277
278         vms_vector delta,top_v,bot_v;
279         g3s_point top_p,bot_p;
280
281         PIGGY_PAGE_IN(bitmapi);
282
283    bitmap->bm_handle = bitmapi.index;
284
285         vm_vec_copy_scale(&delta,&obj->orient.uvec,obj->size);
286
287         vm_vec_add(&top_v,&obj->pos,&delta);
288         vm_vec_sub(&bot_v,&obj->pos,&delta);
289
290         g3_rotate_point(&top_p,&top_v);
291         g3_rotate_point(&bot_p,&bot_v);
292
293         if (lighted)
294                 light = compute_object_light(obj,&top_p.p3_vec);
295         else
296                 light = f1_0;
297
298    #ifdef _3DFX
299    _3dfx_rendering_poly_obj = 1;
300    #endif
301
302         #ifdef PA_3DFX_VOODOO
303         light = f1_0;
304         #endif
305
306         g3_draw_rod_tmap(bitmap,&bot_p,obj->size,&top_p,obj->size,light);
307
308    #ifdef _3DFX
309    _3dfx_rendering_poly_obj = 0;
310    #endif
311
312 }
313
314 int     Linear_tmap_polygon_objects = 1;
315
316 extern fix Max_thrust;
317
318 //used for robot engine glow
319 #define MAX_VELOCITY i2f(50)
320
321 //function that takes the same parms as draw_tmap, but renders as flat poly
322 //we need this to do the cloaked effect
323 extern void draw_tmap_flat();
324
325 //what darkening level to use when cloaked
326 #define CLOAKED_FADE_LEVEL              28
327
328 #define CLOAK_FADEIN_DURATION_PLAYER    F2_0
329 #define CLOAK_FADEOUT_DURATION_PLAYER   F2_0
330
331 #define CLOAK_FADEIN_DURATION_ROBOT     F1_0
332 #define CLOAK_FADEOUT_DURATION_ROBOT    F1_0
333
334 //do special cloaked render
335 void draw_cloaked_object(object *obj,fix light,fix *glow,fix cloak_start_time,fix cloak_end_time)
336 {
337         fix cloak_delta_time,total_cloaked_time;
338         fix light_scale;
339         int cloak_value;
340         int fading=0;           //if true, fading, else cloaking
341         fix     Cloak_fadein_duration;
342         fix     Cloak_fadeout_duration;
343
344
345         total_cloaked_time = cloak_end_time-cloak_start_time;
346
347         switch (obj->type) {
348                 case OBJ_PLAYER:
349                         Cloak_fadein_duration = CLOAK_FADEIN_DURATION_PLAYER;
350                         Cloak_fadeout_duration = CLOAK_FADEOUT_DURATION_PLAYER;
351                         break;
352                 case OBJ_ROBOT:
353                         Cloak_fadein_duration = CLOAK_FADEIN_DURATION_ROBOT;
354                         Cloak_fadeout_duration = CLOAK_FADEOUT_DURATION_ROBOT;
355                         break;
356                 default:
357                         Int3();         //      Contact Mike: Unexpected object type in draw_cloaked_object.
358         }
359
360         cloak_delta_time = GameTime - cloak_start_time;
361
362         if (cloak_delta_time < Cloak_fadein_duration/2) {
363
364                 light_scale = fixdiv(Cloak_fadein_duration/2 - cloak_delta_time,Cloak_fadein_duration/2);
365                 fading = 1;
366
367         }
368         else if (cloak_delta_time < Cloak_fadein_duration) {
369
370                 cloak_value = f2i(fixdiv(cloak_delta_time - Cloak_fadein_duration/2,Cloak_fadein_duration/2) * CLOAKED_FADE_LEVEL);
371
372         } else if (GameTime < cloak_end_time-Cloak_fadeout_duration) {
373                 static int cloak_delta=0,cloak_dir=1;
374                 static fix cloak_timer=0;
375
376                 //note, if more than one cloaked object is visible at once, the
377                 //pulse rate will change!
378
379                 cloak_timer -= FrameTime;
380                 while (cloak_timer < 0) {
381
382                         cloak_timer += Cloak_fadeout_duration/12;
383
384                         cloak_delta += cloak_dir;
385
386                         if (cloak_delta==0 || cloak_delta==4)
387                                 cloak_dir = -cloak_dir;
388                 }
389
390                 cloak_value = CLOAKED_FADE_LEVEL - cloak_delta;
391         
392         } else if (GameTime < cloak_end_time-Cloak_fadeout_duration/2) {
393
394                 cloak_value = f2i(fixdiv(total_cloaked_time - Cloak_fadeout_duration/2 - cloak_delta_time,Cloak_fadeout_duration/2) * CLOAKED_FADE_LEVEL);
395
396         } else {
397
398                 light_scale = fixdiv(Cloak_fadeout_duration/2 - (total_cloaked_time - cloak_delta_time),Cloak_fadeout_duration/2);
399                 fading = 1;
400         }
401
402
403         if (fading) {
404                 fix new_light,save_glow;
405                 bitmap_index * alt_textures = NULL;
406
407 #ifdef NETWORK
408                 if ( obj->rtype.pobj_info.alt_textures > 0 )
409                         alt_textures = multi_player_textures[obj->rtype.pobj_info.alt_textures-1];
410 #endif
411
412                 new_light = fixmul(light,light_scale);
413                 save_glow = glow[0];
414                 glow[0] = fixmul(glow[0],light_scale);
415                 draw_polygon_model(&obj->pos,&obj->orient,&obj->rtype.pobj_info.anim_angles,obj->rtype.pobj_info.model_num,obj->rtype.pobj_info.subobj_flags,new_light,glow, alt_textures );
416                 glow[0] = save_glow;
417         }
418         else {
419                 Gr_scanline_darkening_level = cloak_value;
420                 gr_setcolor(BM_XRGB(0,0,0));    //set to black (matters for s3)
421                 g3_set_special_render(draw_tmap_flat,NULL,NULL);                //use special flat drawer
422                 draw_polygon_model(&obj->pos,&obj->orient,&obj->rtype.pobj_info.anim_angles,obj->rtype.pobj_info.model_num,obj->rtype.pobj_info.subobj_flags,light,glow,NULL );
423                 g3_set_special_render(NULL,NULL,NULL);
424                 Gr_scanline_darkening_level = GR_FADE_LEVELS;
425         }
426
427 }
428
429 //draw an object which renders as a polygon model
430 void draw_polygon_object(object *obj)
431 {
432         fix light;
433         int     imsave;
434         fix engine_glow_value[2];               //element 0 is for engine glow, 1 for headlight
435
436         light = compute_object_light(obj,NULL);
437
438         //      If option set for bright players in netgame, brighten them!
439 #ifdef NETWORK
440         if (Game_mode & GM_MULTI)
441                 if (Netgame.BrightPlayers)
442                         light = F1_0;
443 #endif
444
445         //make robots brighter according to robot glow field
446         if (obj->type == OBJ_ROBOT)
447                 light += (Robot_info[obj->id].glow<<12);                //convert 4:4 to 16:16
448
449         if (obj->type == OBJ_WEAPON)
450                 if (obj->id == FLARE_ID)
451                         light += F1_0*2;
452
453         if (obj->type == OBJ_MARKER)
454                 light += F1_0*2;
455
456
457         imsave = Interpolation_method;
458         if (Linear_tmap_polygon_objects)
459                 Interpolation_method = 1;
460
461         //set engine glow value
462         engine_glow_value[0] = f1_0/5;
463         if (obj->movement_type == MT_PHYSICS) {
464
465                 if (obj->mtype.phys_info.flags & PF_USES_THRUST && obj->type==OBJ_PLAYER && obj->id==Player_num) {
466                         fix thrust_mag = vm_vec_mag_quick(&obj->mtype.phys_info.thrust);
467                         engine_glow_value[0] += (fixdiv(thrust_mag,Player_ship->max_thrust)*4)/5;
468                 }
469                 else {
470                         fix speed = vm_vec_mag_quick(&obj->mtype.phys_info.velocity);
471                         engine_glow_value[0] += (fixdiv(speed,MAX_VELOCITY)*3)/5;
472                 }
473         }
474
475         //set value for player headlight
476         if (obj->type == OBJ_PLAYER) {
477                 if (Players[obj->id].flags & PLAYER_FLAGS_HEADLIGHT && !Endlevel_sequence)
478                         if (Players[obj->id].flags & PLAYER_FLAGS_HEADLIGHT_ON)
479                                 engine_glow_value[1] = -2;              //draw white!
480                         else
481                                 engine_glow_value[1] = -1;              //draw normal color (grey)
482                 else
483                         engine_glow_value[1] = -3;                      //don't draw
484         }
485
486         if (obj->rtype.pobj_info.tmap_override != -1) {
487                 polymodel *pm = &Polygon_models[obj->rtype.pobj_info.model_num];
488                 bitmap_index bm_ptrs[12];
489
490                 int i;
491
492                 Assert(pm->n_textures<=12);
493
494                 for (i=0;i<12;i++)              //fill whole array, in case simple model needs more
495                         bm_ptrs[i] = Textures[obj->rtype.pobj_info.tmap_override];
496
497                 draw_polygon_model(&obj->pos,&obj->orient,&obj->rtype.pobj_info.anim_angles,obj->rtype.pobj_info.model_num,obj->rtype.pobj_info.subobj_flags,light,engine_glow_value,bm_ptrs);
498         }
499         else {
500
501                 if (obj->type==OBJ_PLAYER && (Players[obj->id].flags&PLAYER_FLAGS_CLOAKED))
502                         draw_cloaked_object(obj,light,engine_glow_value,Players[obj->id].cloak_time,Players[obj->id].cloak_time+CLOAK_TIME_MAX);
503                 else if ((obj->type == OBJ_ROBOT) && (obj->ctype.ai_info.CLOAKED)) {
504                         if (Robot_info[obj->id].boss_flag)
505                                 draw_cloaked_object(obj,light,engine_glow_value, Boss_cloak_start_time, Boss_cloak_end_time);
506                         else
507                                 draw_cloaked_object(obj,light,engine_glow_value, GameTime-F1_0*10, GameTime+F1_0*10);
508                 } else {
509                         bitmap_index * alt_textures = NULL;
510         
511                         #ifdef NETWORK
512                         if ( obj->rtype.pobj_info.alt_textures > 0 )
513                                 alt_textures = multi_player_textures[obj->rtype.pobj_info.alt_textures-1];
514                         #endif
515
516                         //      Snipers get bright when they fire.
517                         if (Ai_local_info[obj-Objects].next_fire < F1_0/8) {
518                                 if (obj->ctype.ai_info.behavior == AIB_SNIPE)
519                                         light = 2*light + F1_0;
520                         }
521
522                         draw_polygon_model(&obj->pos,&obj->orient,&obj->rtype.pobj_info.anim_angles,obj->rtype.pobj_info.model_num,obj->rtype.pobj_info.subobj_flags,light,engine_glow_value,alt_textures);
523                         if (obj->type == OBJ_WEAPON && (Weapon_info[obj->id].model_num_inner > -1 )) {
524                                 fix dist_to_eye = vm_vec_dist_quick(&Viewer->pos, &obj->pos);
525                                 if (dist_to_eye < Simple_model_threshhold_scale * F1_0*2)
526                                         draw_polygon_model(&obj->pos,&obj->orient,&obj->rtype.pobj_info.anim_angles,Weapon_info[obj->id].model_num_inner,obj->rtype.pobj_info.subobj_flags,light,engine_glow_value,alt_textures);
527                         }
528                 }
529         }
530
531         Interpolation_method = imsave;
532
533 }
534
535 //------------------------------------------------------------------------------
536 // These variables are used to keep a list of the 3 closest robots to the viewer.
537 // The code works like this: Every time render object is called with a polygon model,
538 // it finds the distance of that robot to the viewer.  If this distance if within 10
539 // segments of the viewer, it does the following: If there aren't already 3 robots in
540 // the closet-robots list, it just sticks that object into the list along with its distance.
541 // If the list already contains 3 robots, then it finds the robot in that list that is
542 // farthest from the viewer. If that object is farther than the object currently being
543 // rendered, then the new object takes over that far object's slot.  *Then* after all 
544 // objects are rendered, object_render_targets is called an it draws a target on top
545 // of all the objects.
546
547 //091494: #define MAX_CLOSE_ROBOTS 3
548 //--unused-- static int Object_draw_lock_boxes = 0;
549 //091494: static int Object_num_close = 0;
550 //091494: static object * Object_close_ones[MAX_CLOSE_ROBOTS];
551 //091494: static fix Object_close_distance[MAX_CLOSE_ROBOTS];
552
553 //091494: set_close_objects(object *obj)
554 //091494: {
555 //091494:       fix dist;
556 //091494: 
557 //091494:       if ( (obj->type != OBJ_ROBOT) || (Object_draw_lock_boxes==0) )  
558 //091494:               return;
559 //091494: 
560 //091494:       // The following code keeps a list of the 10 closest robots to the 
561 //091494:       // viewer.  See comments in front of this function for how this works.
562 //091494:       dist = vm_vec_dist( &obj->pos, &Viewer->pos );
563 //091494:       if ( dist < i2f(20*10) )        {                               
564 //091494:               if ( Object_num_close < MAX_CLOSE_ROBOTS )      {
565 //091494:                       Object_close_ones[Object_num_close] = obj;
566 //091494:                       Object_close_distance[Object_num_close] = dist;
567 //091494:                       Object_num_close++;
568 //091494:               } else {
569 //091494:                       int i, farthest_robot;
570 //091494:                       fix farthest_distance;
571 //091494:                       // Find the farthest robot in the list
572 //091494:                       farthest_robot = 0;
573 //091494:                       farthest_distance = Object_close_distance[0];
574 //091494:                       for (i=1; i<Object_num_close; i++ )     {
575 //091494:                               if ( Object_close_distance[i] > farthest_distance )     {
576 //091494:                                       farthest_distance = Object_close_distance[i];
577 //091494:                                       farthest_robot = i;
578 //091494:                               }
579 //091494:                       }
580 //091494:                       // If this object is closer to the viewer than 
581 //091494:                       // the farthest in the list, replace the farthest with this object.
582 //091494:                       if ( farthest_distance > dist ) {
583 //091494:                               Object_close_ones[farthest_robot] = obj;
584 //091494:                               Object_close_distance[farthest_robot] = dist;
585 //091494:                       }
586 //091494:               }
587 //091494:       }
588 //091494: }
589
590 int     Player_fired_laser_this_frame=-1;
591
592
593
594 // -----------------------------------------------------------------------------
595 //this routine checks to see if an robot rendered near the middle of
596 //the screen, and if so and the player had fired, "warns" the robot
597 void set_robot_location_info(object *objp)
598 {
599         if (Player_fired_laser_this_frame != -1) {
600                 g3s_point temp;
601
602                 g3_rotate_point(&temp,&objp->pos);
603
604                 if (temp.p3_codes & CC_BEHIND)          //robot behind the screen
605                         return;
606
607                 //the code below to check for object near the center of the screen
608                 //completely ignores z, which may not be good
609
610                 if ((abs(temp.p3_x) < F1_0*4) && (abs(temp.p3_y) < F1_0*4)) {
611                         objp->ctype.ai_info.danger_laser_num = Player_fired_laser_this_frame;
612                         objp->ctype.ai_info.danger_laser_signature = Objects[Player_fired_laser_this_frame].signature;
613                 }
614         }
615
616
617 }
618
619 //      ------------------------------------------------------------------------------------------------------------------
620 void create_small_fireball_on_object(object *objp, fix size_scale, int sound_flag)
621 {
622         fix                     size;
623         vms_vector      pos, rand_vec;
624         int                     segnum;
625
626         pos = objp->pos;
627         make_random_vector(&rand_vec);
628
629         vm_vec_scale(&rand_vec, objp->size/2);
630
631         vm_vec_add2(&pos, &rand_vec);
632
633         size = fixmul(size_scale, F1_0/2 + d_rand()*4/2);
634
635         segnum = find_point_seg(&pos, objp->segnum);
636         if (segnum != -1) {
637                 object *expl_obj;
638                 expl_obj = object_create_explosion(segnum, &pos, size, VCLIP_SMALL_EXPLOSION);
639                 if (!expl_obj)
640                         return;
641                 obj_attach(objp,expl_obj);
642                 if (d_rand() < 8192) {
643                         fix     vol = F1_0/2;
644                         if (objp->type == OBJ_ROBOT)
645                                 vol *= 2;
646                         else if (sound_flag)
647                                 digi_link_sound_to_object(SOUND_EXPLODING_WALL, objp-Objects, 0, vol);
648                 }
649         }
650 }
651
652 //      ------------------------------------------------------------------------------------------------------------------
653 void create_vclip_on_object(object *objp, fix size_scale, int vclip_num)
654 {
655         fix                     size;
656         vms_vector      pos, rand_vec;
657         int                     segnum;
658
659         pos = objp->pos;
660         make_random_vector(&rand_vec);
661
662         vm_vec_scale(&rand_vec, objp->size/2);
663
664         vm_vec_add2(&pos, &rand_vec);
665
666         size = fixmul(size_scale, F1_0 + d_rand()*4);
667
668         segnum = find_point_seg(&pos, objp->segnum);
669         if (segnum != -1) {
670                 object *expl_obj;
671                 expl_obj = object_create_explosion(segnum, &pos, size, vclip_num);
672                 if (!expl_obj)
673                         return;
674
675                 expl_obj->movement_type = MT_PHYSICS;
676                 expl_obj->mtype.phys_info.velocity.x = objp->mtype.phys_info.velocity.x/2;
677                 expl_obj->mtype.phys_info.velocity.y = objp->mtype.phys_info.velocity.y/2;
678                 expl_obj->mtype.phys_info.velocity.z = objp->mtype.phys_info.velocity.z/2;
679         }
680 }
681
682 // -- mk, 02/05/95 -- #define   VCLIP_INVULNERABILITY_EFFECT    VCLIP_SMALL_EXPLOSION
683 // -- mk, 02/05/95 -- 
684 // -- mk, 02/05/95 -- // -----------------------------------------------------------------------------
685 // -- mk, 02/05/95 -- void do_player_invulnerability_effect(object *objp)
686 // -- mk, 02/05/95 -- {
687 // -- mk, 02/05/95 --   if (d_rand() < FrameTime*8) {
688 // -- mk, 02/05/95 --           create_vclip_on_object(objp, F1_0, VCLIP_INVULNERABILITY_EFFECT);
689 // -- mk, 02/05/95 --   }
690 // -- mk, 02/05/95 -- }
691
692 // -----------------------------------------------------------------------------
693 //      Render an object.  Calls one of several routines based on type
694 void render_object(object *obj)
695 {
696         int     mld_save;
697
698         if ( obj == Viewer ) return;            
699
700         if ( obj->type==OBJ_NONE )      {
701                 #ifndef NDEBUG
702                 mprintf( (1, "ERROR!!!! Bogus obj %d in seg %d is rendering!\n", obj-Objects, obj->segnum ));
703                 Int3();
704                 #endif
705                 return;
706         }
707
708         mld_save = Max_linear_depth;
709         Max_linear_depth = Max_linear_depth_objects;
710
711         switch (obj->render_type) {
712
713                 case RT_NONE:   break;          //doesn't render, like the player
714
715                 case RT_POLYOBJ:
716
717                         draw_polygon_object(obj); 
718
719                         //"warn" robot if being shot at
720                         if (obj->type == OBJ_ROBOT)
721                                 set_robot_location_info(obj);
722
723 //JOHN SAID TO:                 if ( (obj->type==OBJ_PLAYER) && ((keyd_pressed[KEY_W]) || (keyd_pressed[KEY_I])))
724 //JOHN SAID TO:                         object_render_id(obj);
725
726 // -- mk, 02/05/95 --                   if (obj->type == OBJ_PLAYER)
727 // -- mk, 02/05/95 --                           if (Players[obj->id].flags & PLAYER_FLAGS_INVULNERABLE)
728 // -- mk, 02/05/95 --                                   do_player_invulnerability_effect(obj);
729
730                         break;
731
732                 case RT_MORPH:  draw_morph_object(obj); break;
733
734                 case RT_FIREBALL: draw_fireball(obj); break;
735
736                 case RT_WEAPON_VCLIP: draw_weapon_vclip(obj); break;
737
738                 case RT_HOSTAGE: draw_hostage(obj); break;
739
740                 case RT_POWERUP: draw_powerup(obj); break;
741
742                 case RT_LASER: Laser_render(obj); break;
743
744                 default: Error("Unknown render_type <%d>",obj->render_type);
745         }
746
747         #ifdef NEWDEMO
748         if ( obj->render_type != RT_NONE )
749                 if ( Newdemo_state == ND_STATE_RECORDING ) {
750                         if (!WasRecorded[obj-Objects]) {     
751                                 newdemo_record_render_object(obj);
752                                 WasRecorded[obj-Objects]=1;
753                         }
754                 }
755         #endif
756
757         Max_linear_depth = mld_save;
758
759 }
760
761 //--unused-- void object_toggle_lock_targets()  {
762 //--unused--    Object_draw_lock_boxes ^= 1;
763 //--unused-- }
764
765 //091494: //draw target boxes for nearby robots
766 //091494: void object_render_targets()
767 //091494: {
768 //091494:       g3s_point pt;
769 //091494:       ubyte codes;
770 //091494:       int i;
771 //091494:       int radius,x,y;
772 //091494: 
773 //091494:       if (Object_draw_lock_boxes==0) 
774 //091494:               return;
775 //091494: 
776 //091494:       for (i=0; i<Object_num_close; i++ )     {
777 //091494:                       
778 //091494:               codes = g3_rotate_point(&pt, &Object_close_ones[i]->pos );
779 //091494:               if ( !(codes & CC_BEHIND) )     {
780 //091494:                       g3_project_point(&pt);
781 //091494:                       if (pt.p3_flags & PF_PROJECTED) {
782 //091494:                               x = f2i(pt.p3_sx);
783 //091494:                               y = f2i(pt.p3_sy);
784 //091494:                               radius = f2i(fixdiv((grd_curcanv->cv_bitmap.bm_w*Object_close_ones[i]->size)/8,pt.z));
785 //091494:                               gr_setcolor( BM_XRGB(0,31,0) );
786 //091494:                               gr_box(x-radius,y-radius,x+radius,y+radius);
787 //091494:                       }
788 //091494:               }
789 //091494:       }
790 //091494:       Object_num_close=0;
791 //091494: }
792 //--unused-- //draw target boxes for nearby robots
793 //--unused-- void object_render_id(object * obj)
794 //--unused-- {
795 //--unused--    g3s_point pt;
796 //--unused--    ubyte codes;
797 //--unused--    int x,y;
798 //--unused--    int w, h, aw;
799 //--unused--    char s[20], *s1;
800 //--unused-- 
801 //--unused--    s1 = network_get_player_name( obj-Objects );
802 //--unused-- 
803 //--unused--    if (s1)
804 //--unused--            sprintf( s, "%s", s1 );
805 //--unused--    else
806 //--unused--            sprintf( s, "<%d>", obj->id );
807 //--unused-- 
808 //--unused--    codes = g3_rotate_point(&pt, &obj->pos );
809 //--unused--    if ( !(codes & CC_BEHIND) )     {
810 //--unused--            g3_project_point(&pt);
811 //--unused--            if (pt.p3_flags & PF_PROJECTED) {
812 //--unused--                    gr_get_string_size( s, &w, &h, &aw );
813 //--unused--                    x = f2i(pt.p3_sx) - w/2;
814 //--unused--                    y = f2i(pt.p3_sy) - h/2;
815 //--unused--                    if ( x>= 0 && y>=0 && (x+w)<=grd_curcanv->cv_bitmap.bm_w && (y+h)<grd_curcanv->cv_bitmap.bm_h ) {
816 //--unused--                            gr_set_fontcolor( BM_XRGB(0,31,0), -1 );
817 //--unused--                            gr_string( x, y, s );
818 //--unused--                    }
819 //--unused--            }
820 //--unused--    }
821 //--unused-- }
822
823 void check_and_fix_matrix(vms_matrix *m);
824
825 #define vm_angvec_zero(v) (v)->p=(v)->b=(v)->h=0
826
827 void reset_player_object()
828 {
829         int i;
830
831         //Init physics
832
833         vm_vec_zero(&ConsoleObject->mtype.phys_info.velocity);
834         vm_vec_zero(&ConsoleObject->mtype.phys_info.thrust);
835         vm_vec_zero(&ConsoleObject->mtype.phys_info.rotvel);
836         vm_vec_zero(&ConsoleObject->mtype.phys_info.rotthrust);
837         ConsoleObject->mtype.phys_info.brakes = ConsoleObject->mtype.phys_info.turnroll = 0;
838         ConsoleObject->mtype.phys_info.mass = Player_ship->mass;
839         ConsoleObject->mtype.phys_info.drag = Player_ship->drag;
840         ConsoleObject->mtype.phys_info.flags |= PF_TURNROLL | PF_LEVELLING | PF_WIGGLE | PF_USES_THRUST;
841
842         //Init render info
843
844         ConsoleObject->render_type = RT_POLYOBJ;
845         ConsoleObject->rtype.pobj_info.model_num = Player_ship->model_num;              //what model is this?
846         ConsoleObject->rtype.pobj_info.subobj_flags = 0;                //zero the flags
847         ConsoleObject->rtype.pobj_info.tmap_override = -1;              //no tmap override!
848
849         for (i=0;i<MAX_SUBMODELS;i++)
850                 vm_angvec_zero(&ConsoleObject->rtype.pobj_info.anim_angles[i]);
851
852         // Clear misc
853
854         ConsoleObject->flags = 0;
855
856 }
857
858
859 //make object0 the player, setting all relevant fields
860 void init_player_object()
861 {
862         ConsoleObject->type = OBJ_PLAYER;
863         ConsoleObject->id = 0;                                  //no sub-types for player
864
865         ConsoleObject->signature = 0;                   //player has zero, others start at 1
866
867         ConsoleObject->size = Polygon_models[Player_ship->model_num].rad;
868
869         ConsoleObject->control_type = CT_SLEW;                  //default is player slewing
870         ConsoleObject->movement_type = MT_PHYSICS;              //change this sometime
871
872         ConsoleObject->lifeleft = IMMORTAL_TIME;
873
874         ConsoleObject->attached_obj = -1;
875
876         reset_player_object();
877
878 }
879
880 //sets up the free list & init player & whatever else
881 void init_objects()
882 {
883         int i;
884
885         collide_init();
886
887         for (i=0;i<MAX_OBJECTS;i++) {
888                 free_obj_list[i] = i;
889                 Objects[i].type = OBJ_NONE;
890                 Objects[i].segnum = -1;
891         }
892
893         for (i=0;i<MAX_SEGMENTS;i++)
894                 Segments[i].objects = -1;
895
896         ConsoleObject = Viewer = &Objects[0];
897
898         init_player_object();
899         obj_link(ConsoleObject-Objects,0);      //put in the world in segment 0
900
901         num_objects = 1;                                                //just the player
902         Highest_object_index = 0;
903
904         
905 }
906
907 //after calling init_object(), the network code has grabbed specific
908 //object slots without allocating them.  Go though the objects & build
909 //the free list, then set the apporpriate globals
910 void special_reset_objects(void)
911 {
912         int i;
913
914         num_objects=MAX_OBJECTS;
915
916         Highest_object_index = 0;
917         Assert(Objects[0].type != OBJ_NONE);            //0 should be used
918
919         for (i=MAX_OBJECTS;i--;)
920                 if (Objects[i].type == OBJ_NONE)
921                         free_obj_list[--num_objects] = i;
922                 else
923                         if (i > Highest_object_index)
924                                 Highest_object_index = i;
925 }
926
927 #ifndef NDEBUG
928 int is_object_in_seg( int segnum, int objn )
929 {
930         int objnum, count = 0;
931
932         for (objnum=Segments[segnum].objects;objnum!=-1;objnum=Objects[objnum].next)    {
933                 if ( count > MAX_OBJECTS )      {
934                         Int3();
935                         return count;
936                 }
937                 if ( objnum==objn ) count++;
938         }
939          return count;
940 }
941
942 int search_all_segments_for_object( int objnum )
943 {
944         int i;
945         int count = 0;
946
947         for (i=0; i<=Highest_segment_index; i++) {
948                 count += is_object_in_seg( i, objnum );
949         }
950         return count;
951 }
952
953 void johns_obj_unlink(int segnum, int objnum)
954 {
955         object  *obj = &Objects[objnum];
956         segment *seg = &Segments[segnum];
957
958         Assert(objnum != -1);
959
960         if (obj->prev == -1)
961                 seg->objects = obj->next;
962         else
963                 Objects[obj->prev].next = obj->next;
964
965         if (obj->next != -1) Objects[obj->next].prev = obj->prev;
966 }
967
968 void remove_incorrect_objects()
969 {
970         int segnum, objnum, count;
971
972         for (segnum=0; segnum <= Highest_segment_index; segnum++) {
973                 count = 0;
974                 for (objnum=Segments[segnum].objects;objnum!=-1;objnum=Objects[objnum].next)    {
975                         count++;
976                         #ifndef NDEBUG
977                         if ( count > MAX_OBJECTS )      {
978                                 mprintf((1, "Object list in segment %d is circular.\n", segnum ));
979                                 Int3();
980                         }
981                         #endif
982                         if (Objects[objnum].segnum != segnum )  {
983                                 #ifndef NDEBUG
984                                 mprintf((0, "Removing object %d from segment %d.\n", objnum, segnum ));
985                                 Int3();
986                                 #endif
987                                 johns_obj_unlink(segnum,objnum);
988                         }
989                 }
990         }
991 }
992
993 void remove_all_objects_but( int segnum, int objnum )
994 {
995         int i;
996
997         for (i=0; i<=Highest_segment_index; i++) {
998                 if (segnum != i )       {
999                         if (is_object_in_seg( i, objnum ))      {
1000                                 johns_obj_unlink( i, objnum );
1001                         }
1002                 }
1003         }
1004 }
1005
1006 int check_duplicate_objects()
1007 {
1008         int i, count=0;
1009         
1010         for (i=0;i<=Highest_object_index;i++) {
1011                 if ( Objects[i].type != OBJ_NONE )      {
1012                         count = search_all_segments_for_object( i );
1013                         if ( count > 1 )        {
1014                                 #ifndef NDEBUG
1015                                 mprintf((1, "Object %d is in %d segments!\n", i, count ));
1016                                 Int3();
1017                                 #endif
1018                                 remove_all_objects_but( Objects[i].segnum,  i );
1019                                 return count;
1020                         }
1021                 }
1022         }
1023         return count;
1024 }
1025
1026 void list_seg_objects( int segnum )
1027 {
1028         int objnum, count = 0;
1029
1030         for (objnum=Segments[segnum].objects;objnum!=-1;objnum=Objects[objnum].next)    {
1031                 count++;
1032                 if ( count > MAX_OBJECTS )      {
1033                         Int3();
1034                         return;
1035                 }
1036         }
1037         return;
1038
1039 }
1040 #endif
1041
1042 //link the object into the list for its segment
1043 void obj_link(int objnum,int segnum)
1044 {
1045         object *obj = &Objects[objnum];
1046
1047         Assert(objnum != -1);
1048
1049         Assert(obj->segnum == -1);
1050
1051         Assert(segnum>=0 && segnum<=Highest_segment_index);
1052
1053         obj->segnum = segnum;
1054         
1055         obj->next = Segments[segnum].objects;
1056         obj->prev = -1;
1057
1058         Segments[segnum].objects = objnum;
1059
1060         if (obj->next != -1) Objects[obj->next].prev = objnum;
1061         
1062         //list_seg_objects( segnum );
1063         //check_duplicate_objects();
1064
1065         Assert(Objects[0].next != 0);
1066         if (Objects[0].next == 0)
1067                 Objects[0].next = -1;
1068
1069         Assert(Objects[0].prev != 0);
1070         if (Objects[0].prev == 0)
1071                 Objects[0].prev = -1;
1072 }
1073
1074 void obj_unlink(int objnum)
1075 {
1076         object  *obj = &Objects[objnum];
1077         segment *seg = &Segments[obj->segnum];
1078
1079         Assert(objnum != -1);
1080
1081         if (obj->prev == -1)
1082                 seg->objects = obj->next;
1083         else
1084                 Objects[obj->prev].next = obj->next;
1085
1086         if (obj->next != -1) Objects[obj->next].prev = obj->prev;
1087
1088         obj->segnum = -1;
1089
1090         Assert(Objects[0].next != 0);
1091         Assert(Objects[0].prev != 0);
1092 }
1093
1094 int Object_next_signature = 1;  //player gets 0, others start at 1
1095
1096 int Debris_object_count=0;
1097
1098 int     Unused_object_slots;
1099
1100 //returns the number of a free object, updating Highest_object_index.
1101 //Generally, obj_create() should be called to get an object, since it
1102 //fills in important fields and does the linking.
1103 //returns -1 if no free objects
1104 int obj_allocate(void)
1105 {
1106         int objnum;
1107
1108         if ( num_objects >= MAX_OBJECTS-2 ) {
1109                 int     num_freed;
1110
1111                 num_freed = free_object_slots(MAX_OBJECTS-10);
1112                 mprintf((0, " *** Freed %i objects in frame %i\n", num_freed, FrameCount));
1113         }
1114
1115         if ( num_objects >= MAX_OBJECTS ) {
1116                 #ifndef NDEBUG
1117                 mprintf((1, "Object creation failed - too many objects!\n" ));
1118                 #endif
1119                 return -1;
1120         }
1121
1122         objnum = free_obj_list[num_objects++];
1123
1124         if (objnum > Highest_object_index) {
1125                 Highest_object_index = objnum;
1126                 if (Highest_object_index > Highest_ever_object_index)
1127                         Highest_ever_object_index = Highest_object_index;
1128         }
1129
1130 {
1131 int     i;
1132 Unused_object_slots=0;
1133 for (i=0; i<=Highest_object_index; i++)
1134         if (Objects[i].type == OBJ_NONE)
1135                 Unused_object_slots++;
1136 }
1137         return objnum;
1138 }
1139
1140 //frees up an object.  Generally, obj_delete() should be called to get
1141 //rid of an object.  This function deallocates the object entry after
1142 //the object has been unlinked
1143 void obj_free(int objnum)
1144 {
1145         free_obj_list[--num_objects] = objnum;
1146         Assert(num_objects >= 0);
1147
1148         if (objnum == Highest_object_index)
1149                 while (Objects[--Highest_object_index].type == OBJ_NONE);
1150 }
1151
1152 //-----------------------------------------------------------------------------
1153 //      Scan the object list, freeing down to num_used objects
1154 //      Returns number of slots freed.
1155 int free_object_slots(int num_used)
1156 {
1157         int     i, olind;
1158         int     obj_list[MAX_OBJECTS];
1159         int     num_already_free, num_to_free, original_num_to_free;
1160
1161         olind = 0;
1162         num_already_free = MAX_OBJECTS - Highest_object_index - 1;
1163
1164         if (MAX_OBJECTS - num_already_free < num_used)
1165                 return 0;
1166
1167         for (i=0; i<=Highest_object_index; i++) {
1168                 if (Objects[i].flags & OF_SHOULD_BE_DEAD) {
1169                         num_already_free++;
1170                         if (MAX_OBJECTS - num_already_free < num_used)
1171                                 return num_already_free;
1172                 } else
1173                         switch (Objects[i].type) {
1174                                 case OBJ_NONE:
1175                                         num_already_free++;
1176                                         if (MAX_OBJECTS - num_already_free < num_used)
1177                                                 return 0;
1178                                         break;
1179                                 case OBJ_WALL:
1180                                 case OBJ_FLARE:
1181                                         Int3();         //      This is curious.  What is an object that is a wall?
1182                                         break;
1183                                 case OBJ_FIREBALL:
1184                                 case OBJ_WEAPON:
1185                                 case OBJ_DEBRIS:
1186                                         obj_list[olind++] = i;
1187                                         break;
1188                                 case OBJ_ROBOT:
1189                                 case OBJ_HOSTAGE:
1190                                 case OBJ_PLAYER:
1191                                 case OBJ_CNTRLCEN:
1192                                 case OBJ_CLUTTER:
1193                                 case OBJ_GHOST:
1194                                 case OBJ_LIGHT:
1195                                 case OBJ_CAMERA:
1196                                 case OBJ_POWERUP:
1197                                         break;
1198                         }
1199
1200         }
1201
1202         num_to_free = MAX_OBJECTS - num_used - num_already_free;
1203         original_num_to_free = num_to_free;
1204
1205         if (num_to_free > olind) {
1206                 mprintf((1, "Warning: Asked to free %i objects, but can only free %i.\n", num_to_free, olind));
1207                 num_to_free = olind;
1208         }
1209
1210         for (i=0; i<num_to_free; i++)
1211                 if (Objects[obj_list[i]].type == OBJ_DEBRIS) {
1212                         num_to_free--;
1213                         mprintf((0, "Freeing   DEBRIS object %3i\n", obj_list[i]));
1214                         Objects[obj_list[i]].flags |= OF_SHOULD_BE_DEAD;
1215                 }
1216
1217         if (!num_to_free)
1218                 return original_num_to_free;
1219
1220         for (i=0; i<num_to_free; i++)
1221                 if (Objects[obj_list[i]].type == OBJ_FIREBALL  &&  Objects[obj_list[i]].ctype.expl_info.delete_objnum==-1) {
1222                         num_to_free--;
1223                         mprintf((0, "Freeing FIREBALL object %3i\n", obj_list[i]));
1224                         Objects[obj_list[i]].flags |= OF_SHOULD_BE_DEAD;
1225                 }
1226
1227         if (!num_to_free)
1228                 return original_num_to_free;
1229
1230         for (i=0; i<num_to_free; i++)
1231                 if ((Objects[obj_list[i]].type == OBJ_WEAPON) && (Objects[obj_list[i]].id == FLARE_ID)) {
1232                         num_to_free--;
1233                         Objects[obj_list[i]].flags |= OF_SHOULD_BE_DEAD;
1234                 }
1235
1236         if (!num_to_free)
1237                 return original_num_to_free;
1238
1239         for (i=0; i<num_to_free; i++)
1240                 if ((Objects[obj_list[i]].type == OBJ_WEAPON) && (Objects[obj_list[i]].id != FLARE_ID)) {
1241                         num_to_free--;
1242                         mprintf((0, "Freeing   WEAPON object %3i\n", obj_list[i]));
1243                         Objects[obj_list[i]].flags |= OF_SHOULD_BE_DEAD;
1244                 }
1245
1246         return original_num_to_free - num_to_free;
1247 }
1248
1249 //-----------------------------------------------------------------------------
1250 //initialize a new object.  adds to the list for the given segment
1251 //note that segnum is really just a suggestion, since this routine actually
1252 //searches for the correct segment
1253 //returns the object number
1254 int obj_create(ubyte type,ubyte id,int segnum,vms_vector *pos,
1255                                 vms_matrix *orient,fix size,ubyte ctype,ubyte mtype,ubyte rtype)
1256 {
1257         int objnum;
1258         object *obj;
1259
1260         Assert(segnum <= Highest_segment_index);
1261         Assert (segnum >= 0);
1262         Assert(ctype <= CT_CNTRLCEN);
1263
1264         if (type==OBJ_DEBRIS && Debris_object_count>=Max_debris_objects)
1265                 return -1;
1266
1267         if (get_seg_masks(pos,segnum,0).centermask!=0)
1268                 if ((segnum=find_point_seg(pos,segnum))==-1) {
1269                         #ifndef NDEBUG
1270                         mprintf((0,"Bad segnum in obj_create (type=%d)\n",type));
1271                         #endif
1272                         return -1;              //don't create this object
1273                 }
1274
1275         // Find next free object
1276         objnum = obj_allocate();
1277
1278         if (objnum == -1)               //no free objects
1279                 return -1;
1280
1281         Assert(Objects[objnum].type == OBJ_NONE);               //make sure unused 
1282
1283         obj = &Objects[objnum];
1284
1285         Assert(obj->segnum == -1);
1286
1287         // Zero out object structure to keep weird bugs from happening
1288         // in uninitialized fields.
1289         memset( obj, 0, sizeof(object) );
1290
1291         obj->signature                          = Object_next_signature++;
1292         obj->type                                       = type;
1293         obj->id                                                 = id;
1294         obj->last_pos                           = *pos;
1295         obj->pos                                        = *pos;
1296         obj->size                                       = size;
1297         obj->flags                                      = 0;
1298         //@@if (orient != NULL) 
1299         //@@    obj->orient                     = *orient;
1300
1301         obj->orient                             = orient?*orient:vmd_identity_matrix;
1302
1303         obj->control_type               = ctype;
1304         obj->movement_type              = mtype;
1305         obj->render_type                        = rtype;
1306         obj->contains_type              = -1;
1307
1308         obj->lifeleft                           = IMMORTAL_TIME;                //assume immortal
1309         obj->attached_obj                       = -1;
1310
1311         if (obj->control_type == CT_POWERUP)
1312                 obj->ctype.powerup_info.count = 1;
1313
1314         // Init physics info for this object
1315         if (obj->movement_type == MT_PHYSICS) {
1316
1317                 vm_vec_zero(&obj->mtype.phys_info.velocity);
1318                 vm_vec_zero(&obj->mtype.phys_info.thrust);
1319                 vm_vec_zero(&obj->mtype.phys_info.rotvel);
1320                 vm_vec_zero(&obj->mtype.phys_info.rotthrust);
1321
1322                 obj->mtype.phys_info.mass               = 0;
1323                 obj->mtype.phys_info.drag               = 0;
1324                 obj->mtype.phys_info.brakes     = 0;
1325                 obj->mtype.phys_info.turnroll   = 0;
1326                 obj->mtype.phys_info.flags              = 0;
1327         }
1328
1329         if (obj->render_type == RT_POLYOBJ)
1330                 obj->rtype.pobj_info.tmap_override = -1;
1331
1332         obj->shields                            = 20*F1_0;
1333
1334         segnum = find_point_seg(pos,segnum);            //find correct segment
1335
1336         Assert(segnum!=-1);
1337
1338         obj->segnum = -1;                                       //set to zero by memset, above
1339         obj_link(objnum,segnum);
1340
1341         //      Set (or not) persistent bit in phys_info.
1342         if (obj->type == OBJ_WEAPON) {
1343                 Assert(obj->control_type == CT_WEAPON);
1344                 obj->mtype.phys_info.flags |= (Weapon_info[obj->id].persistent*PF_PERSISTENT);
1345                 obj->ctype.laser_info.creation_time = GameTime;
1346                 obj->ctype.laser_info.last_hitobj = -1;
1347                 obj->ctype.laser_info.multiplier = F1_0;
1348         }
1349
1350         if (obj->control_type == CT_POWERUP)
1351                 obj->ctype.powerup_info.creation_time = GameTime;
1352
1353         if (obj->control_type == CT_EXPLOSION)
1354                 obj->ctype.expl_info.next_attach = obj->ctype.expl_info.prev_attach = obj->ctype.expl_info.attach_parent = -1;
1355
1356         #ifndef NDEBUG
1357         if (print_object_info)  
1358                 mprintf( (0, "Created object %d of type %d\n", objnum, obj->type ));
1359         #endif
1360
1361         if (obj->type == OBJ_DEBRIS)
1362                 Debris_object_count++;
1363
1364         return objnum;
1365 }
1366
1367 #ifdef EDITOR
1368 //create a copy of an object. returns new object number
1369 int obj_create_copy(int objnum, vms_vector *new_pos, int newsegnum)
1370 {
1371         int newobjnum;
1372         object *obj;
1373
1374         // Find next free object
1375         newobjnum = obj_allocate();
1376
1377         if (newobjnum == -1)
1378                 return -1;
1379
1380         obj = &Objects[newobjnum];
1381
1382         *obj = Objects[objnum];
1383
1384         obj->pos = obj->last_pos = *new_pos;
1385
1386         obj->next = obj->prev = obj->segnum = -1;
1387
1388         obj_link(newobjnum,newsegnum);
1389
1390         obj->signature                          = Object_next_signature++;
1391
1392         //we probably should initialize sub-structures here
1393
1394         return newobjnum;
1395
1396 }
1397 #endif
1398
1399 extern void newdemo_record_guided_end();
1400
1401 //remove object from the world
1402 void obj_delete(int objnum)
1403 {
1404         int pnum;
1405         object *obj = &Objects[objnum];
1406
1407         Assert(objnum != -1);
1408         Assert(objnum != 0 );
1409         Assert(obj->type != OBJ_NONE);
1410         Assert(obj != ConsoleObject);
1411
1412         if (obj->type==OBJ_WEAPON && obj->id==GUIDEDMISS_ID) {
1413                 pnum=Objects[obj->ctype.laser_info.parent_num].id;
1414                 mprintf ((0,"Deleting a guided missile! Player %d\n\n",pnum));
1415
1416                 if (pnum!=Player_num) {
1417                         mprintf ((0,"deleting missile that belongs to %d (%s)!\n",pnum,Players[pnum].callsign));
1418                         Guided_missile[pnum]=NULL;
1419                 }
1420                 else if (Newdemo_state==ND_STATE_RECORDING)
1421                         newdemo_record_guided_end();
1422                 
1423         }
1424
1425         if (obj == Viewer)              //deleting the viewer?
1426                 Viewer = ConsoleObject;                                         //..make the player the viewer
1427
1428         if (obj->flags & OF_ATTACHED)           //detach this from object
1429                 obj_detach_one(obj);
1430
1431         if (obj->attached_obj != -1)            //detach all objects from this
1432                 obj_detach_all(obj);
1433
1434         #if !defined(NDEBUG) && !defined(NMONO)
1435         if (print_object_info) mprintf( (0, "Deleting object %d of type %d\n", objnum, Objects[objnum].type ));
1436         #endif
1437
1438         if (obj->type == OBJ_DEBRIS)
1439                 Debris_object_count--;
1440
1441         obj_unlink(objnum);
1442
1443         Assert(Objects[0].next != 0);
1444
1445         obj->type = OBJ_NONE;           //unused!
1446         obj->signature = -1;
1447         obj->segnum=-1;                         // zero it!
1448
1449         obj_free(objnum);
1450 }
1451
1452 #define DEATH_SEQUENCE_LENGTH                   (F1_0*5)
1453 #define DEATH_SEQUENCE_EXPLODE_TIME     (F1_0*2)
1454
1455 int             Player_is_dead = 0;                     //      If !0, then player is dead, but game continues so he can watch.
1456 object  *Dead_player_camera = NULL;     //      Object index of object watching deader.
1457 fix             Player_time_of_death;           //      Time at which player died.
1458 object  *Viewer_save;
1459 int             Player_flags_save;
1460 int             Player_exploded = 0;
1461 int             Death_sequence_aborted=0;
1462 int             Player_eggs_dropped=0;
1463 fix             Camera_to_player_dist_goal=F1_0*4;
1464
1465 ubyte           Control_type_save, Render_type_save;
1466 extern  int Cockpit_mode_save;  //set while in letterbox or rear view, or -1
1467
1468 //      ------------------------------------------------------------------------------------------------------------------
1469 void dead_player_end(void)
1470 {
1471         if (!Player_is_dead)
1472                 return;
1473
1474         if (Newdemo_state == ND_STATE_RECORDING)
1475                 newdemo_record_restore_cockpit();
1476
1477         Player_is_dead = 0;
1478         Player_exploded = 0;
1479         obj_delete(Dead_player_camera-Objects);
1480         Dead_player_camera = NULL;
1481         select_cockpit(Cockpit_mode_save);
1482         Cockpit_mode_save = -1;
1483         Viewer = Viewer_save;
1484         ConsoleObject->type = OBJ_PLAYER;
1485         ConsoleObject->flags = Player_flags_save;
1486
1487         Assert((Control_type_save == CT_FLYING) || (Control_type_save == CT_SLEW));
1488
1489         ConsoleObject->control_type = Control_type_save;
1490         ConsoleObject->render_type = Render_type_save;
1491         Players[Player_num].flags &= ~PLAYER_FLAGS_INVULNERABLE;
1492         Player_eggs_dropped = 0;
1493
1494 }
1495
1496 //      ------------------------------------------------------------------------------------------------------------------
1497 //      Camera is less than size of player away from 
1498 void set_camera_pos(vms_vector *camera_pos, object *objp)
1499 {
1500         int     count = 0;
1501         fix     camera_player_dist;
1502         fix     far_scale;
1503
1504         camera_player_dist = vm_vec_dist_quick(camera_pos, &objp->pos);
1505
1506         if (camera_player_dist < Camera_to_player_dist_goal) { //2*objp->size) {
1507                 //      Camera is too close to player object, so move it away.
1508                 vms_vector      player_camera_vec;
1509                 fvi_query       fq;
1510                 fvi_info                hit_data;
1511                 vms_vector      local_p1;
1512
1513                 vm_vec_sub(&player_camera_vec, camera_pos, &objp->pos);
1514                 if ((player_camera_vec.x == 0) && (player_camera_vec.y == 0) && (player_camera_vec.z == 0))
1515                         player_camera_vec.x += F1_0/16;
1516
1517                 hit_data.hit_type = HIT_WALL;
1518                 far_scale = F1_0;
1519
1520                 while ((hit_data.hit_type != HIT_NONE) && (count++ < 6)) {
1521                         vms_vector      closer_p1;
1522                         vm_vec_normalize_quick(&player_camera_vec);
1523                         vm_vec_scale(&player_camera_vec, Camera_to_player_dist_goal);
1524
1525                         fq.p0 = &objp->pos;
1526                         vm_vec_add(&closer_p1, &objp->pos, &player_camera_vec);         //      This is the actual point we want to put the camera at.
1527                         vm_vec_scale(&player_camera_vec, far_scale);                                            //      ...but find a point 50% further away...
1528                         vm_vec_add(&local_p1, &objp->pos, &player_camera_vec);          //      ...so we won't have to do as many cuts.
1529
1530                         fq.p1 = &local_p1;
1531                         fq.startseg = objp->segnum;
1532                         fq.rad = 0;
1533                         fq.thisobjnum = objp-Objects;
1534                         fq.ignore_obj_list = NULL;
1535                         fq.flags = 0;
1536                         find_vector_intersection( &fq, &hit_data);
1537
1538                         if (hit_data.hit_type == HIT_NONE) {
1539                                 *camera_pos = closer_p1;
1540                         } else {
1541                                 make_random_vector(&player_camera_vec);
1542                                 far_scale = 3*F1_0/2;
1543                         }
1544                 }
1545         }
1546 }
1547
1548 extern void drop_player_eggs(object *objp);
1549 extern int get_explosion_vclip(object *obj,int stage);
1550 extern void multi_cap_objects();
1551 extern int Proximity_dropped,Smartmines_dropped;
1552
1553 //      ------------------------------------------------------------------------------------------------------------------
1554 void dead_player_frame(void)
1555 {
1556         fix     time_dead;
1557         vms_vector      fvec;
1558
1559         if (Player_is_dead) {
1560                 time_dead = GameTime - Player_time_of_death;
1561
1562                 //      If unable to create camera at time of death, create now.
1563                 if (Dead_player_camera == Viewer_save) {
1564                         int             objnum;
1565                         object  *player = &Objects[Players[Player_num].objnum];
1566
1567                         objnum = obj_create(OBJ_CAMERA, 0, player->segnum, &player->pos, &player->orient, 0, CT_NONE, MT_NONE, RT_NONE);
1568
1569                         mprintf((0, "Creating new dead player camera.\n"));
1570                         if (objnum != -1)
1571                                 Viewer = Dead_player_camera = &Objects[objnum];
1572                         else {
1573                                 mprintf((1, "Can't create dead player camera.\n"));
1574                                 Int3();
1575                         }
1576                 }               
1577
1578                 ConsoleObject->mtype.phys_info.rotvel.x = max(0, DEATH_SEQUENCE_EXPLODE_TIME - time_dead)/4;
1579                 ConsoleObject->mtype.phys_info.rotvel.y = max(0, DEATH_SEQUENCE_EXPLODE_TIME - time_dead)/2;
1580                 ConsoleObject->mtype.phys_info.rotvel.z = max(0, DEATH_SEQUENCE_EXPLODE_TIME - time_dead)/3;
1581
1582                 Camera_to_player_dist_goal = min(time_dead*8, F1_0*20) + ConsoleObject->size;
1583
1584                 set_camera_pos(&Dead_player_camera->pos, ConsoleObject);
1585
1586 //              if (time_dead < DEATH_SEQUENCE_EXPLODE_TIME+F1_0*2) {
1587                         vm_vec_sub(&fvec, &ConsoleObject->pos, &Dead_player_camera->pos);
1588                         vm_vector_2_matrix(&Dead_player_camera->orient, &fvec, NULL, NULL);
1589 //              } else {
1590 //                      Dead_player_camera->movement_type = MT_PHYSICS;
1591 //                      Dead_player_camera->mtype.phys_info.rotvel.y = F1_0/8;
1592 //              }
1593
1594                 if (time_dead > DEATH_SEQUENCE_EXPLODE_TIME) {
1595                         if (!Player_exploded) {
1596
1597                         if (Players[Player_num].hostages_on_board > 1)
1598                                 HUD_init_message(TXT_SHIP_DESTROYED_2, Players[Player_num].hostages_on_board);
1599                         else if (Players[Player_num].hostages_on_board == 1)
1600                                 HUD_init_message(TXT_SHIP_DESTROYED_1);
1601                         else
1602                                 HUD_init_message(TXT_SHIP_DESTROYED_0);
1603
1604                                 #ifdef TACTILE 
1605                                         if (TactileStick)
1606                                          {
1607                                           ClearForces();
1608                                          }
1609                                 #endif
1610                                 Player_exploded = 1;
1611 #ifdef NETWORK
1612                                 if (Game_mode & GM_NETWORK)
1613                                  {
1614                                         AdjustMineSpawn ();
1615                                         multi_cap_objects();
1616                                  }
1617 #endif
1618                                   
1619                                 drop_player_eggs(ConsoleObject);
1620                                 Player_eggs_dropped = 1;
1621                                 #ifdef NETWORK
1622                                 if (Game_mode & GM_MULTI)
1623                                 {
1624                                         //multi_send_position(Players[Player_num].objnum);
1625                                         multi_send_player_explode(MULTI_PLAYER_EXPLODE);
1626                                 }
1627                                 #endif
1628
1629                                 explode_badass_player(ConsoleObject);
1630
1631                                 //is this next line needed, given the badass call above?
1632                                 explode_object(ConsoleObject,0);
1633                                 ConsoleObject->flags &= ~OF_SHOULD_BE_DEAD;             //don't really kill player
1634                                 ConsoleObject->render_type = RT_NONE;                           //..just make him disappear
1635                                 ConsoleObject->type = OBJ_GHOST;                                                //..and kill intersections
1636                                 Players[Player_num].flags &= ~PLAYER_FLAGS_HEADLIGHT_ON;
1637                         }
1638                 } else {
1639                         if (d_rand() < FrameTime*4) {
1640                                 #ifdef NETWORK
1641                                 if (Game_mode & GM_MULTI)
1642                                         multi_send_create_explosion(Player_num);
1643                                 #endif
1644                                 create_small_fireball_on_object(ConsoleObject, F1_0, 1);
1645                         }
1646                 }
1647
1648
1649                 if (Death_sequence_aborted) { //time_dead > DEATH_SEQUENCE_LENGTH) {
1650                         if (!Player_eggs_dropped) {
1651                         
1652 #ifdef NETWORK
1653                                 if (Game_mode & GM_NETWORK)
1654                                  {
1655                                         AdjustMineSpawn();
1656                                         multi_cap_objects();
1657                                  }
1658 #endif
1659                                 
1660                                 drop_player_eggs(ConsoleObject);
1661                                 Player_eggs_dropped = 1;
1662                                 #ifdef NETWORK
1663                                 if (Game_mode & GM_MULTI)
1664                                 {
1665                                         //multi_send_position(Players[Player_num].objnum);
1666                                         multi_send_player_explode(MULTI_PLAYER_EXPLODE);
1667                                 }
1668                                 #endif
1669                         }
1670
1671                         DoPlayerDead();         //kill_player();
1672                 }
1673         }
1674 }
1675
1676
1677 void AdjustMineSpawn()
1678  {
1679    if (!(Game_mode & GM_NETWORK))
1680                 return;  // No need for this function in any other mode
1681   
1682    if (!(Game_mode & GM_HOARD))
1683                 Players[Player_num].secondary_ammo[PROXIMITY_INDEX]+=Proximity_dropped;
1684    Players[Player_num].secondary_ammo[SMART_MINE_INDEX]+=Smartmines_dropped;
1685         Proximity_dropped=0;
1686         Smartmines_dropped=0;
1687  }
1688
1689
1690
1691 int Killed_in_frame = -1;
1692 short Killed_objnum = -1;
1693 extern char Multi_killed_yourself;
1694
1695 //      ------------------------------------------------------------------------------------------------------------------
1696 void start_player_death_sequence(object *player)
1697 {
1698         int     objnum;
1699
1700         Assert(player == ConsoleObject);
1701         if ((Player_is_dead != 0) || (Dead_player_camera != NULL))
1702                 return;
1703
1704         //Assert(Player_is_dead == 0);
1705         //Assert(Dead_player_camera == NULL);
1706
1707         reset_rear_view();
1708
1709         if (!(Game_mode & GM_MULTI))
1710                 HUD_clear_messages();
1711
1712         Killed_in_frame = FrameCount;
1713         Killed_objnum = player-Objects;
1714         Death_sequence_aborted = 0;
1715
1716         #ifdef NETWORK
1717         if (Game_mode & GM_MULTI) 
1718         {
1719                 multi_send_kill(Players[Player_num].objnum);
1720
1721 //              If Hoard, increase number of orbs by 1
1722 //    Only if you haven't killed yourself
1723 //              This prevents cheating
1724
1725                 if (Game_mode & GM_HOARD)
1726                  if (Players[Player_num].secondary_ammo[PROXIMITY_INDEX]<12)
1727                         if (!Multi_killed_yourself)
1728                                 Players[Player_num].secondary_ammo[PROXIMITY_INDEX]++;
1729         
1730         }
1731         #endif
1732         
1733         PaletteRedAdd = 40;
1734         Player_is_dead = 1;
1735    #ifdef TACTILE
1736     if (TactileStick)
1737           Buffeting (70);
1738         #endif
1739   
1740         //Players[Player_num].flags &= ~(PLAYER_FLAGS_AFTERBURNER);
1741
1742         vm_vec_zero(&player->mtype.phys_info.rotthrust);
1743         vm_vec_zero(&player->mtype.phys_info.thrust);
1744
1745         Player_time_of_death = GameTime;
1746
1747         objnum = obj_create(OBJ_CAMERA, 0, player->segnum, &player->pos, &player->orient, 0, CT_NONE, MT_NONE, RT_NONE);
1748         Viewer_save = Viewer;
1749         if (objnum != -1)
1750                 Viewer = Dead_player_camera = &Objects[objnum];
1751         else {
1752                 mprintf((1, "Can't create dead player camera.\n"));
1753                 Int3();
1754                 Dead_player_camera = Viewer;
1755         }
1756
1757         if (Cockpit_mode_save == -1)            //if not already saved
1758                 Cockpit_mode_save = Cockpit_mode;
1759         select_cockpit(CM_LETTERBOX);
1760         if (Newdemo_state == ND_STATE_RECORDING)
1761                 newdemo_record_letterbox();
1762
1763         Player_flags_save = player->flags;
1764         Control_type_save = player->control_type;
1765         Render_type_save = player->render_type;
1766
1767         player->flags &= ~OF_SHOULD_BE_DEAD;
1768 //      Players[Player_num].flags |= PLAYER_FLAGS_INVULNERABLE;
1769         player->control_type = CT_NONE;
1770         player->shields = F1_0*1000;
1771
1772         PALETTE_FLASH_SET(0,0,0);
1773 }
1774
1775 //      ------------------------------------------------------------------------------------------------------------------
1776 void obj_delete_all_that_should_be_dead()
1777 {
1778         int i;
1779         object *objp;
1780         int             local_dead_player_object=-1;
1781
1782         // Move all objects
1783         objp = Objects;
1784
1785         for (i=0;i<=Highest_object_index;i++) {
1786                 if ((objp->type!=OBJ_NONE) && (objp->flags&OF_SHOULD_BE_DEAD) ) {
1787                         Assert(!(objp->type==OBJ_FIREBALL && objp->ctype.expl_info.delete_time!=-1));
1788                         if (objp->type==OBJ_PLAYER) {
1789                                 if ( objp->id == Player_num ) {
1790                                         if (local_dead_player_object == -1) {
1791                                                 start_player_death_sequence(objp);
1792                                                 local_dead_player_object = objp-Objects;
1793                                         } else
1794                                                 Int3(); //      Contact Mike: Illegal, killed player twice in this frame!
1795                                                                         // Ok to continue, won't start death sequence again!
1796                                         // kill_player();
1797                                 }
1798                         } else {                                        
1799                                 obj_delete(i);
1800                         }
1801                 }
1802                 objp++;
1803         }
1804 }
1805
1806 //when an object has moved into a new segment, this function unlinks it
1807 //from its old segment, and links it into the new segment
1808 void obj_relink(int objnum,int newsegnum)
1809 {
1810
1811         Assert((objnum >= 0) && (objnum <= Highest_object_index));
1812         Assert((newsegnum <= Highest_segment_index) && (newsegnum >= 0));
1813
1814         obj_unlink(objnum);
1815
1816         obj_link(objnum,newsegnum);
1817         
1818 #ifndef NDEBUG
1819         if (get_seg_masks(&Objects[objnum].pos,Objects[objnum].segnum,0).centermask!=0)
1820                 mprintf((1, "obj_relink violates seg masks.\n"));
1821 #endif
1822 }
1823
1824 //process a continuously-spinning object
1825 spin_object(object *obj)
1826 {
1827         vms_angvec rotangs;
1828         vms_matrix rotmat, new_pm;
1829
1830         Assert(obj->movement_type == MT_SPINNING);
1831
1832         rotangs.p = fixmul(obj->mtype.spin_rate.x,FrameTime);
1833         rotangs.h = fixmul(obj->mtype.spin_rate.y,FrameTime);
1834         rotangs.b = fixmul(obj->mtype.spin_rate.z,FrameTime);
1835
1836         vm_angles_2_matrix(&rotmat,&rotangs);
1837
1838         vm_matrix_x_matrix(&new_pm,&obj->orient,&rotmat);
1839         obj->orient = new_pm;
1840
1841         check_and_fix_matrix(&obj->orient);
1842 }
1843
1844 int Drop_afterburner_blob_flag;         //ugly hack
1845 extern void multi_send_drop_blobs(char);
1846 extern void fuelcen_check_for_goal (segment *);
1847
1848 //see if wall is volatile, and if so, cause damage to player  
1849 //returns true if player is in lava
1850 int check_volatile_wall(object *obj,int segnum,int sidenum,vms_vector *hitpt);
1851
1852 //      Time at which this object last created afterburner blobs.
1853 fix     Last_afterburner_time[MAX_OBJECTS];
1854
1855 //--------------------------------------------------------------------
1856 //move an object for the current frame
1857 void object_move_one( object * obj )
1858 {
1859
1860         #ifndef DEMO_ONLY
1861
1862         int     previous_segment = obj->segnum;
1863
1864         obj->last_pos = obj->pos;                       // Save the current position
1865
1866         if ((obj->type==OBJ_PLAYER) && (Player_num==obj->id))   {
1867                 fix fuel;
1868                 
1869 #ifdef NETWORK
1870       if (Game_mode & GM_CAPTURE)
1871                          fuelcen_check_for_goal (&Segments[obj->segnum]);
1872       if (Game_mode & GM_HOARD)
1873                          fuelcen_check_for_hoard_goal (&Segments[obj->segnum]);
1874 #endif
1875
1876                 fuel=fuelcen_give_fuel( &Segments[obj->segnum], INITIAL_ENERGY-Players[Player_num].energy );
1877                 if (fuel > 0 )  {
1878                         Players[Player_num].energy += fuel;
1879
1880                 }
1881         }
1882
1883         if (obj->lifeleft != IMMORTAL_TIME) {   //if not immortal...
1884                 //      Ok, this is a big hack by MK.
1885                 //      If you want an object to last for exactly one frame, then give it a lifeleft of ONE_FRAME_TIME.
1886                 if (obj->lifeleft != ONE_FRAME_TIME)
1887                         obj->lifeleft -= FrameTime;             //...inevitable countdown towards death
1888         }
1889
1890         Drop_afterburner_blob_flag = 0;
1891
1892         switch (obj->control_type) {
1893
1894                 case CT_NONE: break;
1895
1896                 case CT_FLYING:
1897
1898                         #if !defined(NDEBUG) && !defined(NMONO)
1899                         if (print_object_info>1) mprintf( (0, "Moving player object #%d\n", obj-Objects ));
1900                         #endif
1901
1902                         read_flying_controls( obj );
1903
1904                         break;
1905
1906                 case CT_REPAIRCEN: Int3();      // -- hey! these are no longer supported!! -- do_repair_sequence(obj); break;
1907
1908                 case CT_POWERUP: do_powerup_frame(obj); break;
1909         
1910                 case CT_MORPH:                  //morph implies AI
1911                         do_morph_frame(obj);
1912                         //NOTE: FALLS INTO AI HERE!!!!
1913
1914                 case CT_AI:
1915                         //NOTE LINK TO CT_MORPH ABOVE!!!
1916                         if (Game_suspended & SUSP_ROBOTS) return;
1917                         #if !defined(NDEBUG) && !defined(NMONO)
1918                         if (print_object_info>1) mprintf( (0, "AI: Moving robot object #%d\n",obj-Objects ));
1919                         #endif
1920                         do_ai_frame(obj);
1921                         break;
1922
1923                 case CT_WEAPON:         Laser_do_weapon_sequence(obj); break;
1924                 case CT_EXPLOSION:      do_explosion_sequence(obj); break;
1925
1926                 #ifndef RELEASE
1927                 case CT_SLEW:
1928                         if ( keyd_pressed[KEY_PAD5] ) slew_stop( obj );
1929                         if ( keyd_pressed[KEY_NUMLOCK] )                {
1930                                 slew_reset_orient( obj ); 
1931                                 * (ubyte *) 0x417 &= ~0x20;             //kill numlock
1932                         }
1933                         slew_frame(0 );         // Does velocity addition for us.
1934                         break;
1935                 #endif
1936
1937
1938 //              case CT_FLYTHROUGH:
1939 //                      do_flythrough(obj,0);                   // HACK:do_flythrough should operate on an object!!!!
1940 //                      //check_object_seg(obj);
1941 //                      return; // DON'T DO THE REST OF OBJECT STUFF SINCE THIS IS A SPECIAL CASE!!!
1942 //                      break;
1943
1944                 case CT_DEBRIS: do_debris_frame(obj); break;
1945
1946                 case CT_LIGHT: break;           //doesn't do anything
1947
1948                 case CT_REMOTE: break;          //movement is handled in com_process_input
1949
1950                 case CT_CNTRLCEN: do_controlcen_frame(obj); break;
1951
1952                 default:
1953
1954                         Error("Unknown control type %d in object %i, sig/type/id = %i/%i/%i",obj->control_type, obj-Objects, obj->signature, obj->type, obj->id);
1955
1956                         break;
1957
1958         }
1959
1960         if (obj->lifeleft < 0 ) {               // We died of old age
1961                 obj->flags |= OF_SHOULD_BE_DEAD;
1962                 if ( obj->type==OBJ_WEAPON && Weapon_info[obj->id].damage_radius )
1963                         explode_badass_weapon(obj,&obj->pos);
1964                 else if ( obj->type==OBJ_ROBOT) //make robots explode
1965                         explode_object(obj,0);
1966         }
1967
1968         if (obj->type == OBJ_NONE || obj->flags&OF_SHOULD_BE_DEAD)
1969                 return;                 //object has been deleted
1970
1971         switch (obj->movement_type) {
1972
1973                 case MT_NONE:                   break;                                                          //this doesn't move
1974
1975                 case MT_PHYSICS:                do_physics_sim(obj);    break;  //move by physics
1976
1977                 case MT_SPINNING:               spin_object(obj); break;
1978
1979         }
1980
1981         //      If player and moved to another segment, see if hit any triggers.
1982         // also check in player under a lavafall
1983         if (obj->type == OBJ_PLAYER && obj->movement_type==MT_PHYSICS)  {
1984
1985                 if (previous_segment != obj->segnum) {
1986                         int     connect_side,i;
1987 #ifdef NETWORK
1988                         int     old_level = Current_level_num;
1989 #endif
1990                         for (i=0;i<n_phys_segs-1;i++) {
1991                                 connect_side = find_connect_side(&Segments[phys_seglist[i+1]], &Segments[phys_seglist[i]]);
1992                                 if (connect_side != -1)
1993                                         check_trigger(&Segments[phys_seglist[i]], connect_side, obj-Objects,0);
1994                                 #ifndef NDEBUG
1995                                 else {  // segments are not directly connected, so do binary subdivision until you find connected segments.
1996                                         mprintf((1, "UNCONNECTED SEGMENTS %d,%d\n",phys_seglist[i+1],phys_seglist[i]));
1997                                         // -- Unnecessary, MK, 09/04/95 -- Int3();
1998                                 }
1999                                 #endif
2000
2001                                 //maybe we've gone on to the next level.  if so, bail!
2002 #ifdef NETWORK
2003                                 if (Current_level_num != old_level)
2004                                         return;
2005 #endif
2006                         }
2007                 }
2008
2009                 {
2010                         int sidemask,under_lavafall=0;
2011                         static int lavafall_hiss_playing[MAX_PLAYERS]={0};
2012
2013                         sidemask = get_seg_masks(&obj->pos,obj->segnum,obj->size).sidemask;
2014                         if (sidemask) {
2015                                 int sidenum,bit,wall_num;
2016         
2017                                 for (sidenum=0,bit=1;sidenum<6;bit<<=1,sidenum++)
2018                                         if ((sidemask & bit) && ((wall_num=Segments[obj->segnum].sides[sidenum].wall_num)!=-1) && Walls[wall_num].type==WALL_ILLUSION) {
2019                                                 int type;
2020                                                 if ((type=check_volatile_wall(obj,obj->segnum,sidenum,&obj->pos))!=0) {
2021                                                         int sound = (type==1)?SOUND_LAVAFALL_HISS:SOUND_SHIP_IN_WATERFALL;
2022                                                         under_lavafall = 1;
2023                                                         if (!lavafall_hiss_playing[obj->id]) {
2024                                                                 digi_link_sound_to_object3( sound, obj-Objects, 1, F1_0, i2f(256), -1, -1);
2025                                                                 lavafall_hiss_playing[obj->id] = 1;
2026                                                         }
2027                                                 }
2028                                         }
2029                         }
2030         
2031                         if (!under_lavafall && lavafall_hiss_playing[obj->id]) {
2032                                 digi_kill_sound_linked_to_object( obj-Objects);
2033                                 lavafall_hiss_playing[obj->id] = 0;
2034                         }
2035                 }
2036         }
2037
2038         //see if guided missile has flown through exit trigger
2039         if (obj==Guided_missile[Player_num] && obj->signature==Guided_missile_sig[Player_num]) {
2040                 if (previous_segment != obj->segnum) {
2041                         int     connect_side;
2042                         connect_side = find_connect_side(&Segments[obj->segnum], &Segments[previous_segment]);
2043                         if (connect_side != -1) {
2044                                 int wall_num,trigger_num;
2045                                 wall_num = Segments[previous_segment].sides[connect_side].wall_num;
2046                                 if ( wall_num != -1 ) {
2047                                         trigger_num = Walls[wall_num].trigger;
2048                                         if (trigger_num != -1)
2049                                                 if (Triggers[trigger_num].type == TT_EXIT)
2050                                                         Guided_missile[Player_num]->lifeleft = 0;
2051                                 }
2052                         }
2053                 }
2054         }
2055
2056         if (Drop_afterburner_blob_flag) {
2057                 Assert(obj==ConsoleObject);
2058                 drop_afterburner_blobs(obj, 2, i2f(5)/2, -1);   //      -1 means use default lifetime
2059 #ifdef NETWORK
2060                 if (Game_mode & GM_MULTI)
2061                         multi_send_drop_blobs(Player_num);
2062 #endif
2063                 Drop_afterburner_blob_flag = 0;
2064         }
2065
2066         if ((obj->type == OBJ_WEAPON) && (Weapon_info[obj->id].afterburner_size)) {
2067                 int     objnum = obj-Objects;
2068                 fix     vel = vm_vec_mag_quick(&obj->mtype.phys_info.velocity);
2069                 fix     delay, lifetime;
2070
2071                 if (vel > F1_0*200)
2072                         delay = F1_0/16;
2073                 else if (vel > F1_0*40)
2074                         delay = fixdiv(F1_0*13,vel);
2075                 else
2076                         delay = F1_0/4;
2077
2078                 lifetime = (delay * 3)/2;
2079                 if (!(Game_mode & GM_MULTI)) {
2080                         delay /= 2;
2081                         lifetime *= 2;
2082                 }
2083
2084                 if ((Last_afterburner_time[objnum] + delay < GameTime) || (Last_afterburner_time[objnum] > GameTime)) {
2085                         drop_afterburner_blobs(obj, 1, i2f(Weapon_info[obj->id].afterburner_size)/16, lifetime);
2086                         Last_afterburner_time[objnum] = GameTime;
2087                 }
2088         }
2089
2090         #else
2091                 obj++;          //kill warning
2092         #endif          //DEMO_ONLY
2093 }
2094
2095 int     Max_used_objects = MAX_OBJECTS - 20;
2096
2097 //--------------------------------------------------------------------
2098 //move all objects for the current frame
2099 void object_move_all()
2100 {
2101         int i;
2102         object *objp;
2103
2104 // -- mprintf((0, "Frame %i: %i/%i objects used.\n", FrameCount, num_objects, MAX_OBJECTS));
2105
2106 //      check_duplicate_objects();
2107 //      remove_incorrect_objects();
2108
2109         if (Highest_object_index > Max_used_objects)
2110                 free_object_slots(Max_used_objects);            //      Free all possible object slots.
2111
2112         obj_delete_all_that_should_be_dead();
2113
2114         if (Auto_leveling_on)
2115                 ConsoleObject->mtype.phys_info.flags |= PF_LEVELLING;
2116         else
2117                 ConsoleObject->mtype.phys_info.flags &= ~PF_LEVELLING;
2118
2119         // Move all objects
2120         objp = Objects;
2121
2122         #ifndef DEMO_ONLY
2123         for (i=0;i<=Highest_object_index;i++) {
2124                 if ( (objp->type != OBJ_NONE) && (!(objp->flags&OF_SHOULD_BE_DEAD)) )   {
2125                         object_move_one( objp );
2126                 }
2127                 objp++;
2128         }
2129         #else
2130                 i=0;    //kill warning
2131         #endif
2132
2133 //      check_duplicate_objects();
2134 //      remove_incorrect_objects();
2135
2136 }
2137
2138
2139 //--unused-- // -----------------------------------------------------------
2140 //--unused-- // Moved here from eobject.c on 02/09/94 by MK.
2141 //--unused-- int find_last_obj(int i)
2142 //--unused-- {
2143 //--unused--    for (i=MAX_OBJECTS;--i>=0;)
2144 //--unused--            if (Objects[i].type != OBJ_NONE) break;
2145 //--unused-- 
2146 //--unused--    return i;
2147 //--unused-- 
2148 //--unused-- }
2149
2150
2151 //make object array non-sparse
2152 void compress_objects(void)
2153 {
2154         int start_i;    //,last_i;
2155
2156         //last_i = find_last_obj(MAX_OBJECTS);
2157
2158         //      Note: It's proper to do < (rather than <=) Highest_object_index here because we
2159         //      are just removing gaps, and the last object can't be a gap.
2160         for (start_i=0;start_i<Highest_object_index;start_i++)
2161
2162                 if (Objects[start_i].type == OBJ_NONE) {
2163
2164                         int     segnum_copy;
2165
2166                         segnum_copy = Objects[Highest_object_index].segnum;
2167
2168                         obj_unlink(Highest_object_index);
2169
2170                         Objects[start_i] = Objects[Highest_object_index];
2171
2172                         #ifdef EDITOR
2173                         if (Cur_object_index == Highest_object_index)
2174                                 Cur_object_index = start_i;
2175                         #endif
2176
2177                         Objects[Highest_object_index].type = OBJ_NONE;
2178
2179                         obj_link(start_i,segnum_copy);
2180
2181                         while (Objects[--Highest_object_index].type == OBJ_NONE);
2182
2183                         //last_i = find_last_obj(last_i);
2184                         
2185                 }
2186
2187         reset_objects(num_objects);
2188
2189 }
2190
2191 //called after load.  Takes number of objects,  and objects should be 
2192 //compressed.  resets free list, marks unused objects as unused
2193 void reset_objects(int n_objs)
2194 {
2195         int i;
2196
2197         num_objects = n_objs;
2198
2199         Assert(num_objects>0);
2200
2201         for (i=num_objects;i<MAX_OBJECTS;i++) {
2202                 free_obj_list[i] = i;
2203                 Objects[i].type = OBJ_NONE;
2204                 Objects[i].segnum = -1;
2205         }
2206
2207         Highest_object_index = num_objects-1;
2208
2209         Debris_object_count = 0;
2210 }
2211
2212 //Tries to find a segment for an object, using find_point_seg()
2213 int find_object_seg(object * obj )
2214 {
2215         return find_point_seg(&obj->pos,obj->segnum);
2216 }
2217
2218
2219 //If an object is in a segment, set its segnum field and make sure it's
2220 //properly linked.  If not in any segment, returns 0, else 1.
2221 //callers should generally use find_vector_intersection()  
2222 int update_object_seg(object * obj )
2223 {
2224         int newseg;
2225
2226         newseg = find_object_seg(obj);
2227
2228         if (newseg == -1)
2229                 return 0;
2230
2231         if ( newseg != obj->segnum )
2232                 obj_relink(obj-Objects, newseg );
2233
2234         return 1;
2235 }
2236
2237
2238 //go through all objects and make sure they have the correct segment numbers
2239 fix_object_segs()
2240 {
2241         int i;
2242
2243         for (i=0;i<=Highest_object_index;i++)
2244                 if (Objects[i].type != OBJ_NONE)
2245                         if (update_object_seg(&Objects[i]) == 0) {
2246                                 mprintf((1,"Cannot find segment for object %d in fix_object_segs()\n"));
2247                                 Int3();
2248                                 compute_segment_center(&Objects[i].pos,&Segments[Objects[i].segnum]);
2249                         }
2250 }
2251
2252
2253 //--unused-- void object_use_new_object_list( object * new_list )
2254 //--unused-- {
2255 //--unused--    int i, segnum;
2256 //--unused--    object *obj;
2257 //--unused-- 
2258 //--unused--    // First, unlink all the old objects for the segments array
2259 //--unused--    for (segnum=0; segnum <= Highest_segment_index; segnum++) {
2260 //--unused--            Segments[segnum].objects = -1;
2261 //--unused--    }
2262 //--unused--    // Then, erase all the objects
2263 //--unused--    reset_objects(1);
2264 //--unused-- 
2265 //--unused--    // Fill in the object array
2266 //--unused--    memcpy( Objects, new_list, sizeof(object)*MAX_OBJECTS );
2267 //--unused-- 
2268 //--unused--    Highest_object_index=-1;
2269 //--unused-- 
2270 //--unused--    // Relink 'em
2271 //--unused--    for (i=0; i<MAX_OBJECTS; i++ )  {
2272 //--unused--            obj = &Objects[i];
2273 //--unused--            if ( obj->type != OBJ_NONE )    {
2274 //--unused--                    num_objects++;
2275 //--unused--                    Highest_object_index = i;
2276 //--unused--                    segnum = obj->segnum;
2277 //--unused--                    obj->next = obj->prev = obj->segnum = -1;
2278 //--unused--                    obj_link(i,segnum);
2279 //--unused--            } else {
2280 //--unused--                    obj->next = obj->prev = obj->segnum = -1;
2281 //--unused--            }
2282 //--unused--    }
2283 //--unused--    
2284 //--unused-- }
2285
2286 //delete objects, such as weapons & explosions, that shouldn't stay between levels
2287 //      Changed by MK on 10/15/94, don't remove proximity bombs.
2288 //if clear_all is set, clear even proximity bombs
2289 void clear_transient_objects(int clear_all)
2290 {
2291         int objnum;
2292         object *obj; 
2293
2294         for (objnum=0,obj=&Objects[0];objnum<=Highest_object_index;objnum++,obj++)
2295                 if (((obj->type == OBJ_WEAPON) && !(Weapon_info[obj->id].flags&WIF_PLACABLE) && (clear_all || ((obj->id != PROXIMITY_ID) && (obj->id != SUPERPROX_ID)))) ||
2296                          obj->type == OBJ_FIREBALL ||
2297                          obj->type == OBJ_DEBRIS ||
2298                          obj->type == OBJ_DEBRIS ||
2299                          (obj->type!=OBJ_NONE && obj->flags & OF_EXPLODING)) {
2300
2301                         #ifndef NDEBUG
2302                         if (Objects[objnum].lifeleft > i2f(2))
2303                                 mprintf((0,"Note: Clearing object %d (type=%d, id=%d) with lifeleft=%x\n",objnum,Objects[objnum].type,Objects[objnum].id,Objects[objnum].lifeleft));
2304                         #endif
2305                         obj_delete(objnum);
2306                 }
2307                 #ifndef NDEBUG
2308                  else if (Objects[objnum].type!=OBJ_NONE && Objects[objnum].lifeleft < i2f(2))
2309                         mprintf((0,"Note: NOT clearing object %d (type=%d, id=%d) with lifeleft=%x\n",objnum,Objects[objnum].type,Objects[objnum].id,Objects[objnum].lifeleft));
2310                 #endif
2311 }
2312
2313 //attaches an object, such as a fireball, to another object, such as a robot
2314 void obj_attach(object *parent,object *sub)
2315 {
2316         Assert(sub->type == OBJ_FIREBALL);
2317         Assert(sub->control_type == CT_EXPLOSION);
2318
2319         Assert(sub->ctype.expl_info.next_attach==-1);
2320         Assert(sub->ctype.expl_info.prev_attach==-1);
2321
2322         Assert(parent->attached_obj==-1 || Objects[parent->attached_obj].ctype.expl_info.prev_attach==-1);
2323
2324         sub->ctype.expl_info.next_attach = parent->attached_obj;
2325
2326         if (sub->ctype.expl_info.next_attach != -1)
2327                 Objects[sub->ctype.expl_info.next_attach].ctype.expl_info.prev_attach = sub-Objects;
2328
2329         parent->attached_obj = sub-Objects;
2330
2331         sub->ctype.expl_info.attach_parent = parent-Objects;
2332         sub->flags |= OF_ATTACHED;
2333
2334         Assert(sub->ctype.expl_info.next_attach != sub-Objects);
2335         Assert(sub->ctype.expl_info.prev_attach != sub-Objects);
2336 }
2337
2338 //dettaches one object
2339 void obj_detach_one(object *sub)
2340 {
2341         Assert(sub->flags & OF_ATTACHED);
2342         Assert(sub->ctype.expl_info.attach_parent != -1);
2343
2344         if ((Objects[sub->ctype.expl_info.attach_parent].type == OBJ_NONE) || (Objects[sub->ctype.expl_info.attach_parent].attached_obj == -1))
2345         {
2346                 sub->flags &= ~OF_ATTACHED;
2347                 return;
2348         }
2349
2350         if (sub->ctype.expl_info.next_attach != -1) {
2351                 Assert(Objects[sub->ctype.expl_info.next_attach].ctype.expl_info.prev_attach=sub-Objects);
2352                 Objects[sub->ctype.expl_info.next_attach].ctype.expl_info.prev_attach = sub->ctype.expl_info.prev_attach;
2353         }
2354
2355         if (sub->ctype.expl_info.prev_attach != -1) {
2356                 Assert(Objects[sub->ctype.expl_info.prev_attach].ctype.expl_info.next_attach=sub-Objects);
2357                 Objects[sub->ctype.expl_info.prev_attach].ctype.expl_info.next_attach = sub->ctype.expl_info.next_attach;
2358         }
2359         else {
2360                 Assert(Objects[sub->ctype.expl_info.attach_parent].attached_obj=sub-Objects);
2361                 Objects[sub->ctype.expl_info.attach_parent].attached_obj = sub->ctype.expl_info.next_attach;
2362         }
2363
2364         sub->ctype.expl_info.next_attach = sub->ctype.expl_info.prev_attach = -1;
2365         sub->flags &= ~OF_ATTACHED;
2366
2367 }
2368
2369 //dettaches all objects from this object
2370 void obj_detach_all(object *parent)
2371 {
2372         while (parent->attached_obj != -1)
2373                 obj_detach_one(&Objects[parent->attached_obj]);
2374 }
2375
2376 //creates a marker object in the world.  returns the object number
2377 int drop_marker_object(vms_vector *pos,int segnum,vms_matrix *orient, int marker_num)
2378 {
2379         int objnum;
2380
2381         Assert(Marker_model_num != -1);
2382
2383         objnum = obj_create(OBJ_MARKER, marker_num, segnum, pos, orient, Polygon_models[Marker_model_num].rad, CT_NONE, MT_NONE, RT_POLYOBJ);
2384
2385         if (objnum >= 0) {
2386                 object *obj = &Objects[objnum];
2387
2388                 obj->rtype.pobj_info.model_num = Marker_model_num;
2389
2390                 vm_vec_copy_scale(&obj->mtype.spin_rate,&obj->orient.uvec,F1_0/2);
2391
2392                 //      MK, 10/16/95: Using lifeleft to make it flash, thus able to trim lightlevel from all objects.
2393                 obj->lifeleft = IMMORTAL_TIME - 1;
2394         }
2395
2396         return objnum;  
2397 }
2398
2399 extern int Ai_last_missile_camera;
2400
2401 //      *viewer is a viewer, probably a missile.
2402 //      wake up all robots that were rendered last frame subject to some constraints.
2403 void wake_up_rendered_objects(object *viewer, int window_num)
2404 {
2405         int     i;
2406
2407         //      Make sure that we are processing current data.
2408         if (FrameCount != Window_rendered_data[window_num].frame) {
2409                 mprintf((1, "Warning: Called wake_up_rendered_objects with a bogus window.\n"));
2410                 return;
2411         }
2412
2413         Ai_last_missile_camera = viewer-Objects;
2414
2415         for (i=0; i<Window_rendered_data[window_num].num_objects; i++) {
2416                 int     objnum;
2417                 object *objp;
2418                 int     fcval = FrameCount & 3;
2419
2420                 objnum = Window_rendered_data[window_num].rendered_objects[i];
2421                 if ((objnum & 3) == fcval) {
2422                         objp = &Objects[objnum];
2423         
2424                         if (objp->type == OBJ_ROBOT) {
2425                                 if (vm_vec_dist_quick(&viewer->pos, &objp->pos) < F1_0*100) {
2426                                         ai_local                *ailp = &Ai_local_info[objnum];
2427                                         if (ailp->player_awareness_type == 0) {
2428                                                 objp->ctype.ai_info.SUB_FLAGS |= SUB_FLAGS_CAMERA_AWAKE;
2429                                                 ailp->player_awareness_type = PA_WEAPON_ROBOT_COLLISION;
2430                                                 ailp->player_awareness_time = F1_0*3;
2431                                                 ailp->previous_visibility = 2;
2432                                         }
2433                                 }
2434                         }
2435                 }
2436         }
2437 }
2438
2439
2440
2441
2442
2443