//go through this level and start any eclip sounds
void set_sound_sources()
{
int segnum,sidenum;
segment *seg;
digi_init_sounds(); //clear old sounds
for (seg=&Segments[0],segnum=0;segnum<=Highest_segment_index;seg++,segnum++)
for (sidenum=0;sidenum<MAX_SIDES_PER_SEGMENT;sidenum++) {
int tm,ec,sn;
if ((tm=seg->sides[sidenum].tmap_num2) != 0)
if ((ec=TmapInfo[tm&0x3fff].eclip_num)!=-1)
if ((sn=Effects[ec].sound_num)!=-1) {
vms_vector pnt;
compute_center_point_on_side(&pnt,seg,sidenum);
digi_link_sound_to_pos(sn,segnum,sidenum,&pnt,1, F1_0/2);
}
}
}
do_endlevel_frame()
{
static fix timer;
vms_vector save_last_pos;
static fix explosion_wait1=0;
static fix explosion_wait2=0;
static fix bank_rate;
static fix ext_expl_halflife;
save_last_pos = ConsoleObject->last_pos; //don't let move code change this
object_move_all();
ConsoleObject->last_pos = save_last_pos;
if (ext_expl_playing) {
external_explosion.lifeleft -= FrameTime;
do_explosion_sequence(&external_explosion);
if (external_explosion.lifeleft < ext_expl_halflife)
mine_destroyed = 1;
if (external_explosion.flags & OF_SHOULD_BE_DEAD)
ext_expl_playing = 0;
}
if (cur_fly_speed != desired_fly_speed) {
fix delta = desired_fly_speed - cur_fly_speed;
fix frame_accel = fixmul(FrameTime,FLY_ACCEL);
if (abs(delta) < frame_accel)
cur_fly_speed = desired_fly_speed;
else
if (delta > 0)
cur_fly_speed += frame_accel;
else
cur_fly_speed -= frame_accel;
}
//do big explosions
if (!outside_mine) {
if (Endlevel_sequence==EL_OUTSIDE) {
vms_vector tvec;
vm_vec_sub(&tvec,&ConsoleObject->pos,&mine_side_exit_point);
if (vm_vec_dot(&tvec,&mine_exit_orient.fvec) > 0) {
object *tobj;
outside_mine = 1;
tobj = object_create_explosion(exit_segnum,&mine_side_exit_point,i2f(50),VCLIP_BIG_PLAYER_EXPLOSION);
if (tobj) {
external_explosion = *tobj;
tobj->flags |= OF_SHOULD_BE_DEAD;
flash_scale = 0; //kill lights in mine
ext_expl_halflife = tobj->lifeleft;
ext_expl_playing = 1;
}
digi_link_sound_to_pos( SOUND_BIG_ENDLEVEL_EXPLOSION, exit_segnum, 0, &mine_side_exit_point, 0, i2f(3)/4 );
}
}
//do explosions chasing player
if ((explosion_wait1-=FrameTime) < 0) {
vms_vector tpnt;
int segnum;
object *expl;
static int sound_count;
vm_vec_scale_add(&tpnt,&ConsoleObject->pos,&ConsoleObject->orient.fvec,-ConsoleObject->size*5);
vm_vec_scale_add2(&tpnt,&ConsoleObject->orient.rvec,(rand()-RAND_MAX/2)*15);
vm_vec_scale_add2(&tpnt,&ConsoleObject->orient.uvec,(rand()-RAND_MAX/2)*15);
segnum = find_point_seg(&tpnt,ConsoleObject->segnum);
if (segnum != -1) {
expl = object_create_explosion(segnum,&tpnt,i2f(20),VCLIP_BIG_PLAYER_EXPLOSION);
if (rand()<10000 || ++sound_count==7) { //pseudo-random
digi_link_sound_to_pos( SOUND_TUNNEL_EXPLOSION, segnum, 0, &tpnt, 0, F1_0 );
sound_count=0;
}
}
explosion_wait1 = 0x2000 + rand()/4;
}
}
//do little explosions on walls
if (Endlevel_sequence >= EL_FLYTHROUGH && Endlevel_sequence < EL_OUTSIDE)
if ((explosion_wait2-=FrameTime) < 0) {
vms_vector tpnt;
fvi_query fq;
fvi_info hit_data;
//create little explosion on wall
vm_vec_copy_scale(&tpnt,&ConsoleObject->orient.rvec,(rand()-RAND_MAX/2)*100);
vm_vec_scale_add2(&tpnt,&ConsoleObject->orient.uvec,(rand()-RAND_MAX/2)*100);
vm_vec_add2(&tpnt,&ConsoleObject->pos);
if (Endlevel_sequence == EL_FLYTHROUGH)
vm_vec_scale_add2(&tpnt,&ConsoleObject->orient.fvec,rand()*200);
else
vm_vec_scale_add2(&tpnt,&ConsoleObject->orient.fvec,rand()*60);
//find hit point on wall
fq.p0 = &ConsoleObject->pos;
fq.p1 = &tpnt;
fq.startseg = ConsoleObject->segnum;
fq.rad = 0;
fq.thisobjnum = 0;
fq.ignore_obj_list = NULL;
fq.flags = 0;
find_vector_intersection(&fq,&hit_data);
if (hit_data.hit_type==HIT_WALL && hit_data.hit_seg!=-1)
object_create_explosion(hit_data.hit_seg,&hit_data.hit_pnt,i2f(3)+rand()*6,VCLIP_SMALL_EXPLOSION);
explosion_wait2 = (0xa00 + rand()/8)/2;
}
switch (Endlevel_sequence) {
case EL_OFF: return;
case EL_FLYTHROUGH: {
do_endlevel_flythrough(0);
if (ConsoleObject->segnum == transition_segnum) {
int objnum;
Endlevel_sequence = EL_LOOKBACK;
objnum = obj_create(OBJ_CAMERA, 0,
ConsoleObject->segnum,&ConsoleObject->pos,&ConsoleObject->orient,0,
CT_NONE,MT_NONE,RT_NONE);
if (objnum == -1) { //can't get object, so abort
mprintf((1, "Can't get object for endlevel sequence. Aborting endlevel sequence.\n"));
stop_endlevel_sequence();
return;
}
Viewer = endlevel_camera = &Objects[objnum];
select_cockpit(CM_LETTERBOX);
fly_objects[1] = fly_objects[0];
fly_objects[1].obj = endlevel_camera;
fly_objects[1].speed = (5*cur_fly_speed)/4;
fly_objects[1].offset_frac = 0x4000;
vm_vec_scale_add2(&endlevel_camera->pos,&endlevel_camera->orient.fvec,i2f(7));
timer=0x20000;
}
break;
}
case EL_LOOKBACK: {
do_endlevel_flythrough(0);
do_endlevel_flythrough(1);
if (timer>0) {
timer -= FrameTime;
if (timer < 0) //reduce speed
fly_objects[1].speed = fly_objects[0].speed;
}
if (endlevel_camera->segnum == exit_segnum) {
vms_angvec cam_angles,exit_seg_angles;
Endlevel_sequence = EL_OUTSIDE;
timer = i2f(2);
vm_vec_negate(&endlevel_camera->orient.fvec);
vm_vec_negate(&endlevel_camera->orient.rvec);
vm_extract_angles_matrix(&cam_angles,&endlevel_camera->orient);
vm_extract_angles_matrix(&exit_seg_angles,&mine_exit_orient);
bank_rate = (-exit_seg_angles.b - cam_angles.b)/2;
ConsoleObject->control_type = endlevel_camera->control_type = CT_NONE;
//_MARK_("Starting outside");//Commented out by KRB
#ifdef SLEW_ON
slew_obj = endlevel_camera;
#endif
}
break;
}
case EL_OUTSIDE: {
#ifndef SLEW_ON
vms_angvec cam_angles;
#endif
vm_vec_scale_add2(&ConsoleObject->pos,&ConsoleObject->orient.fvec,fixmul(FrameTime,cur_fly_speed));
#ifndef SLEW_ON
vm_vec_scale_add2(&endlevel_camera->pos,&endlevel_camera->orient.fvec,fixmul(FrameTime,-2*cur_fly_speed));
vm_vec_scale_add2(&endlevel_camera->pos,&endlevel_camera->orient.uvec,fixmul(FrameTime,-cur_fly_speed/10));
vm_extract_angles_matrix(&cam_angles,&endlevel_camera->orient);
cam_angles.b += fixmul(bank_rate,FrameTime);
vm_angles_2_matrix(&endlevel_camera->orient,&cam_angles);
#endif
timer -= FrameTime;
if (timer < 0) {
Endlevel_sequence = EL_STOPPED;
vm_extract_angles_matrix(&player_angles,&ConsoleObject->orient);
timer = i2f(3);
}
break;
}
case EL_STOPPED: {
get_angs_to_object(&player_dest_angles,&station_pos,&ConsoleObject->pos);
chase_angles(&player_angles,&player_dest_angles);
vm_angles_2_matrix(&ConsoleObject->orient,&player_angles);
vm_vec_scale_add2(&ConsoleObject->pos,&ConsoleObject->orient.fvec,fixmul(FrameTime,cur_fly_speed));
timer -= FrameTime;
if (timer < 0) {
#ifdef SLEW_ON
slew_obj = endlevel_camera;
_do_slew_movement(endlevel_camera,1,1);
timer += FrameTime; //make time stop
break;
#else
#ifdef SHORT_SEQUENCE
stop_endlevel_sequence();
#else
Endlevel_sequence = EL_PANNING;
vm_extract_angles_matrix(&camera_cur_angles,&endlevel_camera->orient);
timer = i2f(3);
if (Game_mode & GM_MULTI) { // try to skip part of the seq if multiplayer
stop_endlevel_sequence();
return;
}
//mprintf((0,"Switching to pan...\n"));
#endif //SHORT_SEQUENCE
#endif //SLEW_ON
}
break;
}
#ifndef SHORT_SEQUENCE
case EL_PANNING: {
#ifndef SLEW_ON
int mask;
#endif
get_angs_to_object(&player_dest_angles,&station_pos,&ConsoleObject->pos);
chase_angles(&player_angles,&player_dest_angles);
vm_angles_2_matrix(&ConsoleObject->orient,&player_angles);
vm_vec_scale_add2(&ConsoleObject->pos,&ConsoleObject->orient.fvec,fixmul(FrameTime,cur_fly_speed));
#ifdef SLEW_ON
_do_slew_movement(endlevel_camera,1,1);
#else
get_angs_to_object(&camera_desired_angles,&ConsoleObject->pos,&endlevel_camera->pos);
mask = chase_angles(&camera_cur_angles,&camera_desired_angles);
vm_angles_2_matrix(&endlevel_camera->orient,&camera_cur_angles);
if ((mask&5) == 5) {
vms_vector tvec;
Endlevel_sequence = EL_CHASING;
//_MARK_("Done outside");//Commented out -KRB
vm_vec_normalized_dir_quick(&tvec,&station_pos,&ConsoleObject->pos);
vm_vector_2_matrix(&ConsoleObject->orient,&tvec,&surface_orient.uvec,NULL);
desired_fly_speed *= 2;
//mprintf((0,"Switching to chase...\n"));
}
#endif
break;
}
case EL_CHASING: {
fix d,speed_scale;
#ifdef SLEW_ON
_do_slew_movement(endlevel_camera,1,1);
#endif
get_angs_to_object(&camera_desired_angles,&ConsoleObject->pos,&endlevel_camera->pos);
chase_angles(&camera_cur_angles,&camera_desired_angles);
#ifndef SLEW_ON
vm_angles_2_matrix(&endlevel_camera->orient,&camera_cur_angles);
#endif
d = vm_vec_dist_quick(&ConsoleObject->pos,&endlevel_camera->pos);
speed_scale = fixdiv(d,i2f(0x20));
if (d<f1_0) d=f1_0;
get_angs_to_object(&player_dest_angles,&station_pos,&ConsoleObject->pos);
chase_angles(&player_angles,&player_dest_angles);
vm_angles_2_matrix(&ConsoleObject->orient,&player_angles);
vm_vec_scale_add2(&ConsoleObject->pos,&ConsoleObject->orient.fvec,fixmul(FrameTime,cur_fly_speed));
#ifndef SLEW_ON
vm_vec_scale_add2(&endlevel_camera->pos,&endlevel_camera->orient.fvec,fixmul(FrameTime,fixmul(speed_scale,cur_fly_speed)));
if (vm_vec_dist(&ConsoleObject->pos,&station_pos) < i2f(10))
stop_endlevel_sequence();
#endif
break;
}
#endif //ifdef SHORT_SEQUENCE
}
}
//-----------------------------------------------------------------
// Closes a door
void wall_close_door(segment *seg, int side)
{
wall *w;
active_door *d;
int Connectside;
segment *csegp;
Assert(seg->sides[side].wall_num != -1); //Opening door on illegal wall
w = &Walls[seg->sides[side].wall_num];
if ((w->state == WALL_DOOR_CLOSING) || //already closing
(w->state == WALL_DOOR_WAITING) || //open, waiting to close
(w->state == WALL_DOOR_CLOSED)) //closed
return;
if (!is_door_free(seg,side))
return;
if (w->state == WALL_DOOR_OPENING) { //reuse door
int i;
d = NULL;
for (i=0;i<Num_open_doors;i++) { //find door
d = &ActiveDoors[i];
if (d->front_wallnum[0]==w-Walls || d->back_wallnum[0]==w-Walls || (d->n_parts==2 && (d->front_wallnum[1]==w-Walls || d->back_wallnum[1]==w-Walls)))
break;
}
Assert(i<Num_open_doors); //didn't find door!
Assert( d!=NULL ); // Get John!
d->time = WallAnims[w->clip_num].play_time - d->time;
if (d->time < 0)
d->time = 0;
}
else { //create new door
Assert(w->state == WALL_DOOR_OPEN);
d = &ActiveDoors[Num_open_doors];
d->time = 0;
Num_open_doors++;
Assert( Num_open_doors < MAX_DOORS );
}
w->state = WALL_DOOR_CLOSING;
// So that door can't be shot while opening
csegp = &Segments[seg->children[side]];
Connectside = find_connect_side(seg, csegp);
Assert(Connectside != -1);
Walls[csegp->sides[Connectside].wall_num].state = WALL_DOOR_CLOSING;
d->front_wallnum[0] = seg->sides[side].wall_num;
d->back_wallnum[0] = csegp->sides[Connectside].wall_num;
Assert( seg-Segments != -1);
if (Newdemo_state == ND_STATE_RECORDING) {
newdemo_record_door_opening(seg-Segments, side);
}
if (w->linked_wall != -1) {
Int3(); //don't think we ever used linked walls
}
else
d->n_parts = 1;
if ( Newdemo_state != ND_STATE_PLAYBACK )
{
// NOTE THE LINK TO ABOVE!!!!
vms_vector cp;
compute_center_point_on_side(&cp, seg, side );
if (WallAnims[w->clip_num].open_sound > -1 )
digi_link_sound_to_pos( WallAnims[w->clip_num].open_sound, seg-Segments, side, &cp, 0, F1_0 );
}
}
//-----------------------------------------------------------------
// Animates and processes the closing of a door.
// Called from the game loop.
void do_door_close(int door_num)
{
int p;
active_door *d;
wall *w;
Assert(door_num != -1); //Trying to do_door_open on illegal door
d = &ActiveDoors[door_num];
w = &Walls[d->front_wallnum[0]];
//check for objects in doorway before closing
if (w->flags & WALL_DOOR_AUTO)
if (!is_door_free(&Segments[w->segnum],w->sidenum)) {
digi_kill_sound_linked_to_segment(w->segnum,w->sidenum,-1);
wall_open_door(&Segments[w->segnum],w->sidenum); //re-open door
return;
}
for (p=0;p<d->n_parts;p++) {
wall *w;
int Connectside, side;
segment *csegp, *seg;
fix time_elapsed, time_total, one_frame;
int i, n;
w = &Walls[d->front_wallnum[p]];
seg = &Segments[w->segnum];
side = w->sidenum;
if (seg->sides[side].wall_num == -1) {
mprintf((0, "Trying to do_door_close on Illegal wall\n"));
return;
}
//if here, must be auto door
// Assert(Walls[seg->sides[side].wall_num].flags & WALL_DOOR_AUTO);
//don't assert here, because now we have triggers to close non-auto doors
// Otherwise, close it.
csegp = &Segments[seg->children[side]];
Connectside = find_connect_side(seg, csegp);
Assert(Connectside != -1);
if ( Newdemo_state != ND_STATE_PLAYBACK )
// NOTE THE LINK TO ABOVE!!
if (p==0) //only play one sound for linked doors
if ( d->time==0 ) { //first time
vms_vector cp;
compute_center_point_on_side(&cp, seg, side );
if (WallAnims[w->clip_num].close_sound > -1 )
digi_link_sound_to_pos( WallAnims[Walls[seg->sides[side].wall_num].clip_num].close_sound, seg-Segments, side, &cp, 0, F1_0 );
}
d->time += FrameTime;
time_elapsed = d->time;
n = WallAnims[w->clip_num].num_frames;
time_total = WallAnims[w->clip_num].play_time;
one_frame = time_total/n;
i = n-time_elapsed/one_frame-1;
if (i < n/2) {
Walls[seg->sides[side].wall_num].flags &= ~WALL_DOOR_OPENED;
Walls[csegp->sides[Connectside].wall_num].flags &= ~WALL_DOOR_OPENED;
}
// Animate door.
if (i > 0) {
wall_set_tmap_num(seg,side,csegp,Connectside,w->clip_num,i);
Walls[seg->sides[side].wall_num].state = WALL_DOOR_CLOSING;
Walls[csegp->sides[Connectside].wall_num].state = WALL_DOOR_CLOSING;
ActiveDoors[Num_open_doors].time = 0; //counts up
} else
wall_close_door_num(door_num);
}
}
//-----------------------------------------------------------------
// start the transition from open -> closed wall
void start_wall_decloak(segment *seg, int side)
{
wall *w;
cloaking_wall *d;
int Connectside;
segment *csegp;
int i;
if ( Newdemo_state==ND_STATE_PLAYBACK ) return;
Assert(seg->sides[side].wall_num != -1); //Opening door on illegal wall
w = &Walls[seg->sides[side].wall_num];
if (w->type == WALL_CLOSED || w->state == WALL_DOOR_DECLOAKING) //already closed or decloaking
return;
if (w->state == WALL_DOOR_CLOAKING) { //cloaking, so reuse door
int i;
d = NULL;
for (i=0;i<Num_cloaking_walls;i++) { //find door
d = &CloakingWalls[i];
if (d->front_wallnum==w-Walls || d->back_wallnum==w-Walls )
break;
}
Assert(i<Num_cloaking_walls); //didn't find door!
Assert( d!=NULL ); // Get John!
d->time = CLOAKING_WALL_TIME - d->time;
}
else if (w->state == WALL_DOOR_CLOSED) { //create new door
d = &CloakingWalls[Num_cloaking_walls];
d->time = 0;
if (Num_cloaking_walls >= MAX_CLOAKING_WALLS) { //no more!
Int3(); //ran out of cloaking wall slots
/* what is this _doing_ here?
w->type = WALL_CLOSED;
Walls[csegp->sides[Connectside].wall_num].type = WALL_CLOSED;
*/
return;
}
Num_cloaking_walls++;
}
else {
Int3(); //unexpected wall state
return;
}
w->state = WALL_DOOR_DECLOAKING;
// So that door can't be shot while opening
csegp = &Segments[seg->children[side]];
Connectside = find_connect_side(seg, csegp);
Assert(Connectside != -1);
Walls[csegp->sides[Connectside].wall_num].state = WALL_DOOR_DECLOAKING;
d->front_wallnum = seg->sides[side].wall_num;
d->back_wallnum = csegp->sides[Connectside].wall_num;
Assert( seg-Segments != -1);
Assert(w->linked_wall == -1);
if ( Newdemo_state != ND_STATE_PLAYBACK ) {
vms_vector cp;
compute_center_point_on_side(&cp, seg, side );
digi_link_sound_to_pos( SOUND_WALL_CLOAK_OFF, seg-Segments, side, &cp, 0, F1_0 );
}
for (i=0;i<4;i++) {
d->front_ls[i] = seg->sides[side].uvls[i].l;
d->back_ls[i] = csegp->sides[Connectside].uvls[i].l;
}
}
//-----------------------------------------------------------------
// Opens a door
void wall_open_door(segment *seg, int side)
{
wall *w;
active_door *d;
int Connectside;
segment *csegp;
Assert(seg->sides[side].wall_num != -1); //Opening door on illegal wall
w = &Walls[seg->sides[side].wall_num];
//kill_stuck_objects(seg->sides[side].wall_num);
if ((w->state == WALL_DOOR_OPENING) || //already opening
(w->state == WALL_DOOR_WAITING) || //open, waiting to close
(w->state == WALL_DOOR_OPEN)) //open, & staying open
return;
if (w->state == WALL_DOOR_CLOSING) { //closing, so reuse door
int i;
d = NULL;
for (i=0;i<Num_open_doors;i++) { //find door
d = &ActiveDoors[i];
if (d->front_wallnum[0]==w-Walls || d->back_wallnum[0]==w-Walls || (d->n_parts==2 && (d->front_wallnum[1]==w-Walls || d->back_wallnum[1]==w-Walls)))
break;
}
if (i>=Num_open_doors && (Game_mode & GM_MULTI))
goto FastFix;
Assert(i<Num_open_doors); //didn't find door!
Assert( d!=NULL ); // Get John!
d->time = WallAnims[w->clip_num].play_time - d->time;
if (d->time < 0)
d->time = 0;
}
else { //create new door
Assert(w->state == WALL_DOOR_CLOSED);
FastFix:
d = &ActiveDoors[Num_open_doors];
d->time = 0;
Num_open_doors++;
Assert( Num_open_doors < MAX_DOORS );
}
w->state = WALL_DOOR_OPENING;
// So that door can't be shot while opening
csegp = &Segments[seg->children[side]];
Connectside = find_connect_side(seg, csegp);
Assert(Connectside != -1);
Walls[csegp->sides[Connectside].wall_num].state = WALL_DOOR_OPENING;
//kill_stuck_objects(csegp->sides[Connectside].wall_num);
d->front_wallnum[0] = seg->sides[side].wall_num;
d->back_wallnum[0] = csegp->sides[Connectside].wall_num;
Assert( seg-Segments != -1);
if (Newdemo_state == ND_STATE_RECORDING) {
newdemo_record_door_opening(seg-Segments, side);
}
if (w->linked_wall != -1) {
wall *w2;
segment *seg2;
w2 = &Walls[w->linked_wall];
seg2 = &Segments[w2->segnum];
Assert(w2->linked_wall == seg->sides[side].wall_num);
//Assert(!(w2->flags & WALL_DOOR_OPENING || w2->flags & WALL_DOOR_OPENED));
w2->state = WALL_DOOR_OPENING;
csegp = &Segments[seg2->children[w2->sidenum]];
Connectside = find_connect_side(seg2, csegp);
Assert(Connectside != -1);
Walls[csegp->sides[Connectside].wall_num].state = WALL_DOOR_OPENING;
d->n_parts = 2;
d->front_wallnum[1] = w->linked_wall;
d->back_wallnum[1] = csegp->sides[Connectside].wall_num;
}
else
d->n_parts = 1;
if ( Newdemo_state != ND_STATE_PLAYBACK )
{
// NOTE THE LINK TO ABOVE!!!!
vms_vector cp;
compute_center_point_on_side(&cp, seg, side );
if (WallAnims[w->clip_num].open_sound > -1 )
digi_link_sound_to_pos( WallAnims[w->clip_num].open_sound, seg-Segments, side, &cp, 0, F1_0 );
}
}
// ----------------------------------------------------------------------------------------------------------
void robotmaker_proc( FuelCenter * robotcen )
{
fix dist_to_player;
vms_vector cur_object_loc; //, direction;
int matcen_num, segnum, objnum;
object *obj;
fix top_time;
vms_vector direction;
if (robotcen->Enabled == 0)
return;
if (robotcen->Disable_time > 0) {
robotcen->Disable_time -= FrameTime;
if (robotcen->Disable_time <= 0) {
robotcen->Enabled = 0;
}
}
// No robot making in multiplayer mode.
#ifdef NETWORK
#ifndef SHAREWARE
if ((Game_mode & GM_MULTI) && (!(Game_mode & GM_MULTI_ROBOTS) || !multi_i_am_master()))
return;
#else
if (Game_mode & GM_MULTI)
return;
#endif
#endif
// Wait until transmorgafier has capacity to make a robot...
if ( robotcen->Capacity <= 0 ) {
return;
}
matcen_num = Segment2s[robotcen->segnum].matcen_num;
if ( matcen_num == -1 ) {
return;
}
if (RobotCenters[matcen_num].robot_flags[0]==0 && RobotCenters[matcen_num].robot_flags[1]==0) {
return;
}
// Wait until we have a free slot for this puppy...
// <<<<<<<<<<<<<<<< Num robots in mine >>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<< Max robots in mine >>>>>>>>>>>>>>>
if ( (Players[Player_num].num_robots_level - Players[Player_num].num_kills_level) >= (Gamesave_num_org_robots + Num_extry_robots ) ) {
return;
}
robotcen->Timer += FrameTime;
switch( robotcen->Flag ) {
case 0: // Wait until next robot can generate
if (Game_mode & GM_MULTI)
{
top_time = ROBOT_GEN_TIME;
}
else
{
dist_to_player = vm_vec_dist_quick( &ConsoleObject->pos, &robotcen->Center );
top_time = dist_to_player/64 + d_rand() * 2 + F1_0*2;
if ( top_time > ROBOT_GEN_TIME )
top_time = ROBOT_GEN_TIME + d_rand();
if ( top_time < F1_0*2 )
top_time = F1_0*3/2 + d_rand()*2;
}
if (robotcen->Timer > top_time ) {
int count=0;
int i, my_station_num = robotcen-Station;
object *obj;
// Make sure this robotmaker hasn't put out its max without having any of them killed.
for (i=0; i<=Highest_object_index; i++)
if (Objects[i].type == OBJ_ROBOT)
if ((Objects[i].matcen_creator^0x80) == my_station_num)
count++;
if (count > Difficulty_level + 3) {
robotcen->Timer /= 2;
return;
}
// Whack on any robot or player in the matcen segment.
count=0;
segnum = robotcen->segnum;
for (objnum=Segments[segnum].objects;objnum!=-1;objnum=Objects[objnum].next) {
count++;
if ( count > MAX_OBJECTS ) {
Int3();
return;
}
if (Objects[objnum].type==OBJ_ROBOT) {
collide_robot_and_materialization_center(&Objects[objnum]);
robotcen->Timer = top_time/2;
return;
} else if (Objects[objnum].type==OBJ_PLAYER ) {
collide_player_and_materialization_center(&Objects[objnum]);
robotcen->Timer = top_time/2;
return;
}
}
compute_segment_center(&cur_object_loc, &Segments[robotcen->segnum]);
// HACK!!! The 10 under here should be something equal to the 1/2 the size of the segment.
obj = object_create_explosion(robotcen->segnum, &cur_object_loc, i2f(10), VCLIP_MORPHING_ROBOT );
if (obj)
extract_orient_from_segment(&obj->orient,&Segments[robotcen->segnum]);
if ( Vclip[VCLIP_MORPHING_ROBOT].sound_num > -1 ) {
digi_link_sound_to_pos( Vclip[VCLIP_MORPHING_ROBOT].sound_num, robotcen->segnum, 0, &cur_object_loc, 0, F1_0 );
}
robotcen->Flag = 1;
robotcen->Timer = 0;
}
break;
case 1: // Wait until 1/2 second after VCLIP started.
if (robotcen->Timer > (Vclip[VCLIP_MORPHING_ROBOT].play_time/2) ) {
robotcen->Capacity -= EnergyToCreateOneRobot;
robotcen->Flag = 0;
robotcen->Timer = 0;
compute_segment_center(&cur_object_loc, &Segments[robotcen->segnum]);
// If this is the first materialization, set to valid robot.
if (RobotCenters[matcen_num].robot_flags[0] != 0 || RobotCenters[matcen_num].robot_flags[1] != 0) {
int type;
uint flags;
sbyte legal_types[64]; // 64 bits, the width of robot_flags[].
int num_types, robot_index, i;
num_types = 0;
for (i=0;i<2;i++) {
robot_index = i*32;
flags = RobotCenters[matcen_num].robot_flags[i];
while (flags) {
if (flags & 1)
legal_types[num_types++] = robot_index;
flags >>= 1;
robot_index++;
}
}
if (num_types == 1)
type = legal_types[0];
else
type = legal_types[(d_rand() * num_types) / 32768];
obj = create_morph_robot(&Segments[robotcen->segnum], &cur_object_loc, type );
if (obj != NULL) {
#ifndef SHAREWARE
#ifdef NETWORK
if (Game_mode & GM_MULTI)
multi_send_create_robot(robotcen-Station, obj-Objects, type);
#endif
#endif
obj->matcen_creator = (robotcen-Station) | 0x80;
// Make object faces player...
vm_vec_sub( &direction, &ConsoleObject->pos,&obj->pos );
vm_vector_2_matrix( &obj->orient, &direction, &obj->orient.uvec, NULL);
morph_start( obj );
//robotcen->last_created_obj = obj;
//robotcen->last_created_sig = robotcen->last_created_obj->signature;
}
}
}
//-----------------------------------------------------------------
// Opens a door
void wall_open_door(segment *seg, int side)
{
wall *w;
active_door *d;
int Connectside, wall_num, cwall_num = -1;
segment *csegp;
Assert(seg->sides[side].wall_num != -1); //Opening door on illegal wall
w = &Walls[seg->sides[side].wall_num];
wall_num = w - Walls;
//kill_stuck_objects(seg->sides[side].wall_num);
if ((w->state == WALL_DOOR_OPENING) || //already opening
(w->state == WALL_DOOR_WAITING) || //open, waiting to close
(w->state == WALL_DOOR_OPEN)) //open, & staying open
return;
if (w->state == WALL_DOOR_CLOSING) { //closing, so reuse door
int i;
d = NULL;
for (i=0;i<Num_open_doors;i++) { //find door
d = &ActiveDoors[i];
if (d->front_wallnum[0]==w-Walls || d->back_wallnum[0]==wall_num ||
(d->n_parts==2 && (d->front_wallnum[1]==wall_num || d->back_wallnum[1]==wall_num)))
break;
}
if (i>=Num_open_doors) // likely in demo playback or multiplayer
{
d = &ActiveDoors[Num_open_doors];
d->time = 0;
Num_open_doors++;
Assert( Num_open_doors < MAX_DOORS );
}
else
{
Assert( d!=NULL ); // Get John!
d->time = WallAnims[w->clip_num].play_time - d->time;
if (d->time < 0)
d->time = 0;
}
}
else { //create new door
Assert(w->state == WALL_DOOR_CLOSED);
d = &ActiveDoors[Num_open_doors];
d->time = 0;
Num_open_doors++;
Assert( Num_open_doors < MAX_DOORS );
}
w->state = WALL_DOOR_OPENING;
// So that door can't be shot while opening
csegp = &Segments[seg->children[side]];
Connectside = find_connect_side(seg, csegp);
if (Connectside >= 0)
{
cwall_num = csegp->sides[Connectside].wall_num;
if (cwall_num > -1)
{
Walls[cwall_num].state = WALL_DOOR_OPENING;
d->back_wallnum[0] = cwall_num;
}
d->front_wallnum[0] = seg->sides[side].wall_num;
}
else
con_printf(CON_URGENT, "Illegal Connectside %i in wall_open_door. Trying to hop over. Please check your level!\n", side);
Assert( seg-Segments != -1);
if (Newdemo_state == ND_STATE_RECORDING) {
newdemo_record_door_opening(seg-Segments, side);
}
if (w->linked_wall != -1) {
wall *w2;
segment *seg2;
w2 = &Walls[w->linked_wall];
seg2 = &Segments[w2->segnum];
Assert(w2->linked_wall == seg->sides[side].wall_num);
//Assert(!(w2->flags & WALL_DOOR_OPENING || w2->flags & WALL_DOOR_OPENED));
w2->state = WALL_DOOR_OPENING;
csegp = &Segments[seg2->children[w2->sidenum]];
Connectside = find_connect_side(seg2, csegp);
Assert(Connectside != -1);
if (cwall_num > -1)
Walls[cwall_num].state = WALL_DOOR_OPENING;
d->n_parts = 2;
d->front_wallnum[1] = w->linked_wall;
d->back_wallnum[1] = cwall_num;
}
else
d->n_parts = 1;
if ( Newdemo_state != ND_STATE_PLAYBACK )
{
// NOTE THE LINK TO ABOVE!!!!
vms_vector cp;
compute_center_point_on_side(&cp, seg, side );
if (WallAnims[w->clip_num].open_sound > -1 )
digi_link_sound_to_pos( WallAnims[w->clip_num].open_sound, seg-Segments, side, &cp, 0, F1_0 );
}
}
//-----------------------------------------------------------------
// Animates and processes the closing of a door.
// Called from the game loop.
void do_door_close(int door_num)
{
int p;
active_door *d;
wall *w;
Assert(door_num != -1); //Trying to do_door_open on illegal door
d = &ActiveDoors[door_num];
w = &Walls[d->front_wallnum[0]];
//check for objects in doorway before closing
if (w->flags & WALL_DOOR_AUTO)
for (p=0;p<d->n_parts;p++) {
int Connectside, side;
segment *csegp, *seg;
int objnum;
seg = &Segments[w->segnum];
side = w->sidenum;
csegp = &Segments[seg->children[side]];
Connectside = find_connect_side(seg, csegp);
Assert(Connectside != -1);
//go through each object in each of two segments, and see if
//it pokes into the connecting seg
for (objnum=seg->objects;objnum!=-1;objnum=Objects[objnum].next)
if (check_poke(objnum,seg-Segments,side))
return; //abort!
for (objnum=csegp->objects;objnum!=-1;objnum=Objects[objnum].next)
if (check_poke(objnum,csegp-Segments,Connectside))
return; //abort!
}
for (p=0;p<d->n_parts;p++) {
wall *w;
int Connectside, side;
segment *csegp, *seg;
fix time_elapsed, time_total, one_frame;
int i, n;
w = &Walls[d->front_wallnum[p]];
seg = &Segments[w->segnum];
side = w->sidenum;
if (seg->sides[side].wall_num == -1) {
return;
}
//if here, must be auto door
Assert(Walls[seg->sides[side].wall_num].flags & WALL_DOOR_AUTO);
// Otherwise, close it.
csegp = &Segments[seg->children[side]];
Connectside = find_connect_side(seg, csegp);
Assert(Connectside != -1);
if ( Newdemo_state != ND_STATE_PLAYBACK )
// NOTE THE LINK TO ABOVE!!
if (p==0) //only play one sound for linked doors
if ( d->time==0 ) { //first time
vms_vector cp;
compute_center_point_on_side(&cp, seg, side );
if (WallAnims[w->clip_num].close_sound > -1 )
digi_link_sound_to_pos( WallAnims[Walls[seg->sides[side].wall_num].clip_num].close_sound, seg-Segments, side, &cp, 0, F1_0 );
}
d->time += FrameTime;
time_elapsed = d->time;
n = WallAnims[w->clip_num].num_frames;
time_total = WallAnims[w->clip_num].play_time;
one_frame = time_total/n;
i = n-time_elapsed/one_frame-1;
if (i < n/2) {
Walls[seg->sides[side].wall_num].flags &= ~WALL_DOOR_OPENED;
Walls[csegp->sides[Connectside].wall_num].flags &= ~WALL_DOOR_OPENED;
}
// Animate door.
if (i > 0) {
wall_set_tmap_num(seg,side,csegp,Connectside,w->clip_num,i);
Walls[seg->sides[side].wall_num].state = WALL_DOOR_CLOSING;
Walls[csegp->sides[Connectside].wall_num].state = WALL_DOOR_CLOSING;
ActiveDoors[Num_open_doors].time = 0; //counts up
} else
wall_close_door(door_num);
}
}
