int wall_remove_door_flag(sbyte flag)
{
int Connectside;
segment *csegp;
if (Cursegp->sides[Curside].wall_num == -1)
{
editor_status("Cannot change flag. No wall at Curside.");
return 0;
}
if (Walls[Cursegp->sides[Curside].wall_num].type != WALL_DOOR)
{
editor_status("Cannot change flag. No door at Curside.");
return 0;
}
csegp = &Segments[Cursegp->children[Curside]];
Connectside = find_connect_side(Cursegp, csegp);
Walls[Cursegp->sides[Curside].wall_num].flags &= ~flag;
Walls[csegp->sides[Connectside].wall_num].flags &= ~flag;
Update_flags |= UF_ED_STATE_CHANGED;
return 1;
}
// --------------------------------------------------------------------------------------
// Select next segment.
// If there is a connection on the current side, then choose that segment.
// If there is no connecting segment on the current side, try any segment.
__attribute_warn_unused_result
static std::pair<vsegptridx_t, uint_fast32_t> get_next_segment_side(const vsegptridx_t curseg_num, uint_fast32_t curside)
{
const auto side_child = curseg_num->children[curside];
if (IS_CHILD(side_child))
{
const auto &&newseg_num = curseg_num.absolute_sibling(side_child);
// Find out what side we came in through and favor side opposite that
const auto newside = Side_opposite[find_connect_side(curseg_num, newseg_num)];
// If there is nothing attached on the side opposite to what we came in (*newside), pick any other side
if (!IS_CHILD(newseg_num->children[newside]))
for (uint_fast32_t s = 0; s != MAX_SIDES_PER_SEGMENT; ++s)
{
const auto cseg = newseg_num->children[s];
if (cseg != curseg_num && IS_CHILD(cseg))
return {newseg_num, s};
}
return {newseg_num, newside};
}
else
{
return {curseg_num, curside};
}
}
// -------------------------------------------------------------------------------
//when the wall has used all its hitpoints, this will destroy it
void blast_blastable_wall(segment *seg, int side)
{
int Connectside;
segment *csegp;
int a, n;
Assert(seg->sides[side].wall_num != -1);
csegp = &Segments[seg->children[side]];
Connectside = find_connect_side(seg, csegp);
Assert(Connectside != -1);
kill_stuck_objects(seg->sides[side].wall_num);
kill_stuck_objects(csegp->sides[Connectside].wall_num);
a = Walls[seg->sides[side].wall_num].clip_num;
n = WallAnims[a].num_frames;
if (!(WallAnims[Walls[seg->sides[side].wall_num].clip_num].flags & WCF_EXPLODES))
wall_set_tmap_num(seg,side,csegp,Connectside,a,n-1);
Walls[seg->sides[side].wall_num].flags |= WALL_BLASTED;
Walls[csegp->sides[Connectside].wall_num].flags |= WALL_BLASTED;
//if this is an exploding wall, explode it
if (WallAnims[Walls[seg->sides[side].wall_num].clip_num].flags & WCF_EXPLODES)
explode_wall(seg-Segments,side);
}
// -------------------------------------------------------------------------------
//when the wall has used all its hitpoints, this will destroy it
void blast_blastable_wall(segment *seg, int side)
{
int Connectside;
segment *csegp;
int a, n;
Assert(seg->sides[side].wall_num != -1);
Walls[seg->sides[side].wall_num].hps = -1; //say it's blasted
csegp = &Segments[seg->children[side]];
Connectside = find_connect_side(seg, csegp);
Assert(Connectside != -1);
kill_stuck_objects(seg->sides[side].wall_num);
kill_stuck_objects(csegp->sides[Connectside].wall_num);
//if this is an exploding wall, explode it
if (WallAnims[Walls[seg->sides[side].wall_num].clip_num].flags & WCF_EXPLODES)
explode_wall(seg-Segments,side);
else {
//if not exploding, set final frame, and make door passable
a = Walls[seg->sides[side].wall_num].clip_num;
n = WallAnims[a].num_frames;
wall_set_tmap_num(seg,side,csegp,Connectside,a,n-1);
Walls[seg->sides[side].wall_num].flags |= WALL_BLASTED;
Walls[csegp->sides[Connectside].wall_num].flags |= WALL_BLASTED;
}
}
//---------------------------------------------------------------------
// Add a wall (removable 2 sided)
int add_wall(segment *seg, short side)
{
int Connectside;
segment *csegp;
if (Num_walls < MAX_WALLS-2)
if (IS_CHILD(seg->children[side])) {
if (seg->sides[side].wall_num == -1) {
seg->sides[side].wall_num = Num_walls;
Num_walls++;
}
csegp = &Segments[seg->children[side]];
Connectside = find_connect_side(seg, csegp);
if (csegp->sides[Connectside].wall_num == -1) {
csegp->sides[Connectside].wall_num = Num_walls;
Num_walls++;
}
create_removable_wall( seg, side, CurrentTexture );
create_removable_wall( csegp, Connectside, CurrentTexture );
return 1;
}
return 0;
}
// ---------------------------------------------------------------------------------------
// Select previous segment.
// If there is a connection on the side opposite to the current side, then choose that segment.
// If there is no connecting segment on the opposite face, try any segment.
__attribute_warn_unused_result
static std::pair<vsegptridx_t, uint_fast32_t> get_previous_segment_side(const vsegptridx_t curseg_num, const uint_fast32_t curside)
{
const auto &newseg_num = get_previous_segment(curseg_num, curside);
// Now make Curside point at the segment we just left (unless we couldn't leave it).
return {newseg_num, newseg_num == curseg_num ? curside : find_connect_side(curseg_num, newseg_num)};
}
//---------------------------------------------------------------------
// Add a wall to markedside
int wall_add_to_markedside(sbyte type)
{
int Connectside;
segment *csegp;
if (add_wall(Markedsegp, Markedside)) {
int wall_num, cwall_num;
csegp = &Segments[Markedsegp->children[Markedside]];
Connectside = find_connect_side(Markedsegp, csegp);
wall_num = Markedsegp->sides[Markedside].wall_num;
cwall_num = csegp->sides[Connectside].wall_num;
Walls[wall_num].segnum = Markedsegp-Segments;
Walls[cwall_num].segnum = csegp-Segments;
Walls[wall_num].sidenum = Markedside;
Walls[cwall_num].sidenum = Connectside;
Walls[wall_num].flags = 0;
Walls[cwall_num].flags = 0;
Walls[wall_num].type = type;
Walls[cwall_num].type = type;
Walls[wall_num].trigger = -1;
Walls[cwall_num].trigger = -1;
Walls[wall_num].clip_num = -1;
Walls[cwall_num].clip_num = -1;
Walls[wall_num].keys = KEY_NONE;
Walls[cwall_num].keys = KEY_NONE;
if (type == WALL_BLASTABLE) {
Walls[wall_num].hps = WALL_HPS;
Walls[cwall_num].hps = WALL_HPS;
Walls[wall_num].clip_num = 0;
Walls[cwall_num].clip_num = 0;
}
if (type != WALL_DOOR) {
Markedsegp->sides[Markedside].tmap_num2 = 0;
csegp->sides[Connectside].tmap_num2 = 0;
}
Update_flags |= UF_WORLD_CHANGED;
return 1;
} else {
editor_status( "Cannot add wall here, no children" );
return 0;
}
}
//-----------------------------------------------------------------
// Checks for a trigger whenever an object hits a trigger side.
void check_trigger(segment *seg, short side, short objnum)
{
int wall_num, trigger_num, ctrigger_num;
segment *csegp;
short cside;
// mprintf(0,"T");
if (objnum == Players[Player_num].objnum) {
// if ( Newdemo_state == ND_STATE_RECORDING )
// newdemo_record_trigger( seg-Segments, side, objnum );
if ( Newdemo_state == ND_STATE_PLAYBACK )
return;
wall_num = seg->sides[side].wall_num;
if ( wall_num == -1 ) return;
trigger_num = Walls[wall_num].trigger;
if (trigger_num == -1)
return;
if (check_trigger_sub(trigger_num, Player_num))
return;
if (Triggers[trigger_num].flags & TRIGGER_ONE_SHOT) {
Triggers[trigger_num].flags &= ~TRIGGER_ON;
csegp = &Segments[seg->children[side]];
cside = find_connect_side(seg, csegp);
Assert(cside != -1);
wall_num = csegp->sides[cside].wall_num;
if ( wall_num == -1 ) return;
ctrigger_num = Walls[wall_num].trigger;
Triggers[ctrigger_num].flags &= ~TRIGGER_ON;
}
#ifndef SHAREWARE
#ifdef NETWORK
if (Game_mode & GM_MULTI)
multi_send_trigger(trigger_num);
#endif
#endif
}
}
//-----------------------------------------------------------------
// Turns on an illusionary wall (This will be used primarily for
// wall switches or triggers that can turn on/off illusionary walls.)
void wall_illusion_on(segment *seg, int side)
{
segment *csegp;
int cside;
csegp = &Segments[seg->children[side]];
cside = find_connect_side(seg, csegp);
Assert(cside != -1);
if (seg->sides[side].wall_num == -1) {
return;
}
Walls[seg->sides[side].wall_num].flags &= ~WALL_ILLUSION_OFF;
Walls[csegp->sides[cside].wall_num].flags &= ~WALL_ILLUSION_OFF;
}
// ---------------------------------------------------------------------------------------
// Select previous segment.
// If there is a connection on the side opposite to the current side, then choose that segment.
// If there is no connecting segment on the opposite face, try any segment.
void get_previous_segment(int curseg_num, int curside,int *newseg_num, int *newside)
{
int s;
*newseg_num = curseg_num;
if (IS_CHILD(Segments[curseg_num].children[(int)Side_opposite[curside]]))
*newseg_num = Segments[curseg_num].children[(int)Side_opposite[curside]];
else // no segment on opposite face, connect to anything
for (s=0; s<MAX_SIDES_PER_SEGMENT; s++)
if ((s != curside) && IS_CHILD(Segments[curseg_num].children[s]))
*newseg_num = Segments[curseg_num].children[s];
// Now make Curside point at the segment we just left (unless we couldn't leave it).
if (*newseg_num != curseg_num)
*newside = find_connect_side(&Segments[curseg_num],&Segments[*newseg_num]);
else
*newside = curside;
}
//-----------------------------------------------------------------
// Turns off an illusionary wall (This will be used primarily for
// wall switches or triggers that can turn on/off illusionary walls.)
void wall_illusion_off(segment *seg, int side)
{
segment *csegp;
int cside;
csegp = &Segments[seg->children[side]];
cside = find_connect_side(seg, csegp);
Assert(cside != -1);
if (seg->sides[side].wall_num == -1) {
mprintf((0, "Trying to shut off illusion illegal wall\n"));
return;
}
Walls[seg->sides[side].wall_num].flags |= WALL_ILLUSION_OFF;
Walls[csegp->sides[cside].wall_num].flags |= WALL_ILLUSION_OFF;
kill_stuck_objects(seg->sides[side].wall_num);
kill_stuck_objects(csegp->sides[cside].wall_num);
}
//-----------------------------------------------------------------
// Deteriorate appearance of wall. (Changes bitmap (paste-ons))
void wall_damage(segment *seg, int side, fix damage)
{
int a, i, n;
if (seg->sides[side].wall_num == -1) {
mprintf((0, "Damaging illegal wall\n"));
return;
}
if (Walls[seg->sides[side].wall_num].type != WALL_BLASTABLE)
return;
if (!(Walls[seg->sides[side].wall_num].flags & WALL_BLASTED) && Walls[seg->sides[side].wall_num].hps >= 0)
{
int Connectside;
segment *csegp;
csegp = &Segments[seg->children[side]];
Connectside = find_connect_side(seg, csegp);
Assert(Connectside != -1);
Walls[seg->sides[side].wall_num].hps -= damage;
Walls[csegp->sides[Connectside].wall_num].hps -= damage;
a = Walls[seg->sides[side].wall_num].clip_num;
n = WallAnims[a].num_frames;
if (Walls[seg->sides[side].wall_num].hps < WALL_HPS*1/n) {
blast_blastable_wall( seg, side );
#ifdef NETWORK
if (Game_mode & GM_MULTI)
multi_send_door_open(seg-Segments, side,Walls[seg->sides[side].wall_num].flags);
#endif
}
else
for (i=0;i<n;i++)
if (Walls[seg->sides[side].wall_num].hps < WALL_HPS*(n-i)/n) {
wall_set_tmap_num(seg,side,csegp,Connectside,a,i);
}
}
}
// --------------------------------------------------------------------------------------
// Select next segment.
// If there is a connection on the current side, then choose that segment.
// If there is no connecting segment on the current side, try any segment.
void get_next_segment(int curseg_num, int curside, int *newseg_num, int *newside)
{
int s;
if (IS_CHILD(Segments[curseg_num].children[curside])) {
*newseg_num = Segments[curseg_num].children[Curside];
// Find out what side we came in through and favor side opposite that
*newside = Side_opposite[find_connect_side(&Segments[curseg_num],&Segments[*newseg_num])];
// If there is nothing attached on the side opposite to what we came in (*newside), pick any other side
if (!IS_CHILD(Segments[*newseg_num].children[*newside]))
for (s=0; s<MAX_SIDES_PER_SEGMENT; s++)
if ((Segments[*newseg_num].children[s] != curseg_num) && IS_CHILD(Segments[*newseg_num].children[s]))
*newside = s;
} else {
*newseg_num = curseg_num;
*newside = curside;
}
}
//-----------------------------------------------------------------
// This function closes the specified door and restores the closed
// door texture. This is called when the animation is done
void wall_close_door_num(int door_num)
{
int p;
active_door *d;
int i, cwall_num;
d = &ActiveDoors[door_num];
for (p=0;p<d->n_parts;p++) {
wall *w;
int Connectside, side;
segment *csegp, *seg;
w = &Walls[d->front_wallnum[p]];
seg = &Segments[w->segnum];
side = w->sidenum;
Assert(seg->sides[side].wall_num != -1); //Closing door on illegal wall
csegp = &Segments[seg->children[side]];
Connectside = find_connect_side(seg, csegp);
Assert(Connectside != -1);
cwall_num = csegp->sides[Connectside].wall_num;
Walls[seg->sides[side].wall_num].state = WALL_DOOR_CLOSED;
if (cwall_num > -1)
Walls[cwall_num].state = WALL_DOOR_CLOSED;
wall_set_tmap_num(seg,side,csegp,Connectside,w->clip_num,0);
}
for (i=door_num;i<Num_open_doors;i++)
ActiveDoors[i] = ActiveDoors[i+1];
Num_open_doors--;
}
//returns true of door in unobjstructed (& thus can close)
int is_door_free(segment *seg,int side)
{
int Connectside;
segment *csegp;
int objnum;
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 (Objects[objnum].type!=OBJ_WEAPON && Objects[objnum].type!=OBJ_FIREBALL && check_poke(objnum,seg-Segments,side))
return 0; //not free
for (objnum=csegp->objects;objnum!=-1;objnum=Objects[objnum].next)
if (Objects[objnum].type!=OBJ_WEAPON && Objects[objnum].type!=OBJ_FIREBALL && check_poke(objnum,csegp-Segments,Connectside))
return 0; //not free
return 1; //doorway is free!
}
int wall_assign_door(int door_type)
{
int Connectside;
segment *csegp;
if (Cursegp->sides[Curside].wall_num == -1) {
editor_status("Cannot assign door. No wall at Curside.");
return 0;
}
if (Walls[Cursegp->sides[Curside].wall_num].type != WALL_DOOR && Walls[Cursegp->sides[Curside].wall_num].type != WALL_BLASTABLE) {
editor_status("Cannot assign door. No door at Curside.");
return 0;
}
Current_door_type = door_type;
csegp = &Segments[Cursegp->children[Curside]];
Connectside = find_connect_side(Cursegp, csegp);
Walls[Cursegp->sides[Curside].wall_num].clip_num = door_type;
Walls[csegp->sides[Connectside].wall_num].clip_num = door_type;
if (WallAnims[door_type].flags & WCF_TMAP1) {
Cursegp->sides[Curside].tmap_num = WallAnims[door_type].frames[0];
csegp->sides[Connectside].tmap_num = WallAnims[door_type].frames[0];
Cursegp->sides[Curside].tmap_num2 = 0;
csegp->sides[Connectside].tmap_num2 = 0;
}
else {
Cursegp->sides[Curside].tmap_num2 = WallAnims[door_type].frames[0];
csegp->sides[Connectside].tmap_num2 = WallAnims[door_type].frames[0];
}
Update_flags |= UF_WORLD_CHANGED;
return 1;
}
//-----------------------------------------------------------------
// 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);
}
}
//-----------------------------------------------------------------
// 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);
}
}
//-----------------------------------------------------------------
// Animates opening of a door.
// Called in the game loop.
void do_door_open(int door_num)
{
int p;
active_door *d;
Assert(door_num != -1); //Trying to do_door_open on illegal door
d = &ActiveDoors[door_num];
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]];
kill_stuck_objects(d->front_wallnum[p]);
kill_stuck_objects(d->back_wallnum[p]);
seg = &Segments[w->segnum];
side = w->sidenum;
Assert(seg->sides[side].wall_num != -1); //Trying to do_door_open on illegal wall
csegp = &Segments[seg->children[side]];
Connectside = find_connect_side(seg, csegp);
Assert(Connectside != -1);
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 = time_elapsed/one_frame;
if (i < n)
wall_set_tmap_num(seg,side,csegp,Connectside,w->clip_num,i);
if (i> n/2) {
Walls[seg->sides[side].wall_num].flags |= WALL_DOOR_OPENED;
Walls[csegp->sides[Connectside].wall_num].flags |= WALL_DOOR_OPENED;
}
if (i >= n-1) {
wall_set_tmap_num(seg,side,csegp,Connectside,w->clip_num,n-1);
// If our door is not automatic just remove it from the list.
if (!(Walls[seg->sides[side].wall_num].flags & WALL_DOOR_AUTO)) {
for (i=door_num;i<Num_open_doors;i++)
ActiveDoors[i] = ActiveDoors[i+1];
Num_open_doors--;
Walls[seg->sides[side].wall_num].state = WALL_DOOR_OPEN;
Walls[csegp->sides[Connectside].wall_num].state = WALL_DOOR_OPEN;
}
else {
Walls[seg->sides[side].wall_num].state = WALL_DOOR_WAITING;
Walls[csegp->sides[Connectside].wall_num].state = WALL_DOOR_WAITING;
ActiveDoors[Num_open_doors].time = 0; //counts up
}
}
}
}
//-----------------------------------------------------------------
// 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 );
}
}
//-----------------------------------------------------------------
// 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 );
}
}
//---------------------------------------------------------------------
// Add a wall to curside
int wall_add_to_side(segment *segp, int side, sbyte type)
{
int connectside;
segment *csegp;
if (add_wall(segp, side)) {
csegp = &Segments[segp->children[side]];
connectside = find_connect_side(segp, csegp);
Walls[segp->sides[side].wall_num].segnum = segp-Segments;
Walls[csegp->sides[connectside].wall_num].segnum = csegp-Segments;
Walls[segp->sides[side].wall_num].sidenum = side;
Walls[csegp->sides[connectside].wall_num].sidenum = connectside;
Walls[segp->sides[side].wall_num].flags = 0;
Walls[csegp->sides[connectside].wall_num].flags = 0;
Walls[segp->sides[side].wall_num].type = type;
Walls[csegp->sides[connectside].wall_num].type = type;
// Walls[segp->sides[side].wall_num].trigger = -1;
// Walls[csegp->sides[connectside].wall_num].trigger = -1;
Walls[segp->sides[side].wall_num].clip_num = -1;
Walls[csegp->sides[connectside].wall_num].clip_num = -1;
Walls[segp->sides[side].wall_num].keys = KEY_NONE;
Walls[csegp->sides[connectside].wall_num].keys = KEY_NONE;
if (type == WALL_BLASTABLE) {
Walls[segp->sides[side].wall_num].hps = WALL_HPS;
Walls[csegp->sides[connectside].wall_num].hps = WALL_HPS;
//Walls[segp->sides[side].wall_num].clip_num = 0;
//Walls[csegp->sides[connectside].wall_num].clip_num = 0;
}
if (type != WALL_DOOR) {
segp->sides[side].tmap_num2 = 0;
csegp->sides[connectside].tmap_num2 = 0;
}
if (type == WALL_DOOR) {
Walls[segp->sides[side].wall_num].flags |= WALL_DOOR_AUTO;
Walls[csegp->sides[connectside].wall_num].flags |= WALL_DOOR_AUTO;
Walls[segp->sides[side].wall_num].clip_num = Current_door_type;
Walls[csegp->sides[connectside].wall_num].clip_num = Current_door_type;
}
//Update_flags |= UF_WORLD_CHANGED;
//return 1;
// return NextWall(); //assign a clip num
return wall_assign_door(Current_door_type);
} else {
editor_status( "Cannot add wall here, no children" );
return 0;
}
}
// -----------------------------------------------------------------------------------------------------------
//Simulate a physics object for this frame
do_physics_sim(object *obj)
{
int ignore_obj_list[MAX_IGNORE_OBJS],n_ignore_objs;
int iseg;
int try_again;
int fate;
vms_vector frame_vec; //movement in this frame
vms_vector new_pos,ipos; //position after this frame
int count=0;
int objnum;
int WallHitSeg, WallHitSide;
fvi_info hit_info;
fvi_query fq;
vms_vector save_pos;
int save_seg;
fix drag;
fix sim_time;
vms_vector start_pos;
int obj_stopped=0;
fix moved_time; //how long objected moved before hit something
vms_vector save_p0,save_p1;
physics_info *pi;
int orig_segnum = obj->segnum;
Assert(obj->type != OBJ_NONE);
Assert(obj->movement_type == MT_PHYSICS);
#ifndef NDEBUG
if (Dont_move_ai_objects)
if (obj->control_type == CT_AI)
return;
#endif
pi = &obj->mtype.phys_info;
do_physics_sim_rot(obj);
if (!(pi->velocity.x || pi->velocity.y || pi->velocity.z || pi->thrust.x || pi->thrust.y || pi->thrust.z))
return;
objnum = obj-Objects;
n_phys_segs = 0;
disable_new_fvi_stuff = (obj->type != OBJ_PLAYER);
sim_time = FrameTime;
//debug_obj = obj;
#ifdef EXTRA_DEBUG
if (obj == debug_obj) {
printf("object %d:\n start pos = %x %x %x\n",objnum,XYZ(&obj->pos));
printf(" thrust = %x %x %x\n",XYZ(&obj->mtype.phys_info.thrust));
printf(" sim_time = %x\n",sim_time);
}
//check for correct object segment
if(!get_seg_masks(&obj->pos,obj->segnum,0).centermask==0) {
#ifndef NDEBUG
mprintf((0,"Warning: object %d not in given seg!\n",objnum));
#endif
//Int3(); Removed by Rob 10/5/94
if (!update_object_seg(obj)) {
#ifndef NDEBUG
mprintf((0,"Warning: can't find seg for object %d - moving\n",objnum));
#endif
if (!(Game_mode & GM_MULTI))
Int3();
compute_segment_center(&obj->pos,&Segments[obj->segnum]);
obj->pos.x += objnum;
}
}
#endif
start_pos = obj->pos;
n_ignore_objs = 0;
Assert(obj->mtype.phys_info.brakes==0); //brakes not used anymore?
//if uses thrust, cannot have zero drag
Assert(!(obj->mtype.phys_info.flags&PF_USES_THRUST) || obj->mtype.phys_info.drag!=0);
//mprintf((0,"thrust=%x speed=%x\n",vm_vec_mag(&obj->mtype.phys_info.thrust),vm_vec_mag(&obj->mtype.phys_info.velocity)));
//do thrust & drag
if ((drag = obj->mtype.phys_info.drag) != 0) {
int count;
vms_vector accel;
fix r,k;
count = sim_time / FT;
r = sim_time % FT;
k = fixdiv(r,FT);
if (obj->mtype.phys_info.flags & PF_USES_THRUST) {
vm_vec_copy_scale(&accel,&obj->mtype.phys_info.thrust,fixdiv(f1_0,obj->mtype.phys_info.mass));
while (count--) {
vm_vec_add2(&obj->mtype.phys_info.velocity,&accel);
vm_vec_scale(&obj->mtype.phys_info.velocity,f1_0-drag);
}
//do linear scale on remaining bit of time
vm_vec_scale_add2(&obj->mtype.phys_info.velocity,&accel,k);
vm_vec_scale(&obj->mtype.phys_info.velocity,f1_0-fixmul(k,drag));
}
else {
fix total_drag=f1_0;
while (count--)
total_drag = fixmul(total_drag,f1_0-drag);
//do linear scale on remaining bit of time
total_drag = fixmul(total_drag,f1_0-fixmul(k,drag));
vm_vec_scale(&obj->mtype.phys_info.velocity,total_drag);
}
}
#ifdef EXTRA_DEBUG
if (obj == debug_obj)
printf(" velocity = %x %x %x\n",XYZ(&obj->mtype.phys_info.velocity));
#endif
do {
try_again = 0;
//Move the object
vm_vec_copy_scale(&frame_vec, &obj->mtype.phys_info.velocity, sim_time);
#ifdef EXTRA_DEBUG
if (obj == debug_obj)
printf(" pass %d, frame_vec = %x %x %x\n",count,XYZ(&frame_vec));
#endif
if ( (frame_vec.x==0) && (frame_vec.y==0) && (frame_vec.z==0) )
break;
count++;
// If retry count is getting large, then we are trying to do something stupid.
if ( count > 3) {
if (obj->type == OBJ_PLAYER) {
if (count > 8)
break;
} else
break;
}
vm_vec_add(&new_pos,&obj->pos,&frame_vec);
#ifdef EXTRA_DEBUG
if (obj == debug_obj)
printf(" desired_pos = %x %x %x\n",XYZ(&new_pos));
#endif
ignore_obj_list[n_ignore_objs] = -1;
#ifdef EXTRA_DEBUG
if (obj == debug_obj) {
printf(" FVI parms: p0 = %8x %8x %8x, segnum=%x, size=%x\n",XYZ(&obj->pos),obj->segnum,obj->size);
printf(" p1 = %8x %8x %8x\n",XYZ(&new_pos));
}
#endif
fq.p0 = &obj->pos;
fq.startseg = obj->segnum;
fq.p1 = &new_pos;
fq.rad = obj->size;
fq.thisobjnum = objnum;
fq.ignore_obj_list = ignore_obj_list;
fq.flags = FQ_CHECK_OBJS;
if (obj->type == OBJ_WEAPON)
fq.flags |= FQ_TRANSPOINT;
if (obj->type == OBJ_PLAYER)
fq.flags |= FQ_GET_SEGLIST;
//@@ if (get_seg_masks(&obj->pos,obj->segnum,0).centermask!=0)
//@@ Int3();
save_p0 = *fq.p0;
save_p1 = *fq.p1;
fate = find_vector_intersection(&fq,&hit_info);
// Matt: Mike's hack.
if (fate == HIT_OBJECT) {
object *objp = &Objects[hit_info.hit_object];
if ((objp->type == OBJ_WEAPON) && (objp->id == PROXIMITY_ID))
count--;
}
#ifndef NDEBUG
if (fate == HIT_BAD_P0) {
mprintf((0,"Warning: Bad p0 in physics! Object = %i, type = %i [%s]\n", obj-Objects, obj->type, Object_type_names[obj->type]));
Int3();
}
#endif
if (obj->type == OBJ_PLAYER) {
int i;
if (n_phys_segs && phys_seglist[n_phys_segs-1]==hit_info.seglist[0])
n_phys_segs--;
for (i=0;(i<hit_info.n_segs) && (n_phys_segs<MAX_FVI_SEGS-1); )
phys_seglist[n_phys_segs++] = hit_info.seglist[i++];
}
#ifdef EXTRA_DEBUG
if (obj == debug_obj)
printf(" fate = %d, hit_pnt = %8x %8x %8x\n",fate,XYZ(&hit_info.hit_pnt));;
#endif
ipos = hit_info.hit_pnt;
iseg = hit_info.hit_seg;
WallHitSide = hit_info.hit_side;
WallHitSeg = hit_info.hit_side_seg;
if (iseg==-1) { //some sort of horrible error
#ifndef NDEBUG
mprintf((1,"iseg==-1 in physics! Object = %i, type = %i (%s)\n", obj-Objects, obj->type, Object_type_names[obj->type]));
#endif
//Int3();
//compute_segment_center(&ipos,&Segments[obj->segnum]);
//ipos.x += objnum;
//iseg = obj->segnum;
//fate = HIT_NONE;
if (obj->type == OBJ_WEAPON)
obj->flags |= OF_SHOULD_BE_DEAD;
break;
}
Assert(!((fate==HIT_WALL) && ((WallHitSeg == -1) || (WallHitSeg > Highest_segment_index))));
//if(!get_seg_masks(&hit_info.hit_pnt,hit_info.hit_seg,0).centermask==0)
// Int3();
save_pos = obj->pos; //save the object's position
save_seg = obj->segnum;
// update object's position and segment number
obj->pos = ipos;
#ifdef EXTRA_DEBUG
if (obj == debug_obj)
printf(" new pos = %x %x %x\n",XYZ(&obj->pos));
#endif
if ( iseg != obj->segnum )
obj_relink(objnum, iseg );
//if start point not in segment, move object to center of segment
if (get_seg_masks(&obj->pos,obj->segnum,0).centermask!=0) {
int n;
if ((n=find_object_seg(obj))==-1) {
//Int3();
if (obj->type==OBJ_PLAYER && (n=find_point_seg(&obj->last_pos,obj->segnum))!=-1) {
obj->pos = obj->last_pos;
obj_relink(objnum, n );
}
else {
compute_segment_center(&obj->pos,&Segments[obj->segnum]);
obj->pos.x += objnum;
}
if (obj->type == OBJ_WEAPON)
obj->flags |= OF_SHOULD_BE_DEAD;
}
return;
}
//calulate new sim time
{
//vms_vector moved_vec;
vms_vector moved_vec_n;
fix attempted_dist,actual_dist;
actual_dist = vm_vec_normalized_dir(&moved_vec_n,&obj->pos,&save_pos);
if (fate==HIT_WALL && vm_vec_dot(&moved_vec_n,&frame_vec) < 0) { //moved backwards
//don't change position or sim_time
//******* mprintf((0,"Obj %d moved backwards\n",obj-Objects));
#ifdef EXTRA_DEBUG
if (obj == debug_obj)
printf(" Warning: moved backwards!\n");
#endif
obj->pos = save_pos;
//iseg = obj->segnum; //don't change segment
obj_relink(objnum, save_seg );
moved_time = 0;
}
else {
fix old_sim_time;
//if (obj == debug_obj)
// printf(" moved_vec = %x %x %x\n",XYZ(&moved_vec));
attempted_dist = vm_vec_mag(&frame_vec);
old_sim_time = sim_time;
sim_time = fixmuldiv(sim_time,attempted_dist-actual_dist,attempted_dist);
moved_time = old_sim_time - sim_time;
if (sim_time < 0 || sim_time>old_sim_time) {
#ifndef NDEBUG
mprintf((0,"Bogus sim_time = %x, old = %x\n",sim_time,old_sim_time));
if (obj == debug_obj)
printf(" Bogus sim_time = %x, old = %x, attempted_dist = %x, actual_dist = %x\n",sim_time,old_sim_time,attempted_dist,actual_dist);
//Int3(); Removed by Rob
#endif
sim_time = old_sim_time;
//WHY DOES THIS HAPPEN??
moved_time = 0;
}
}
#ifdef EXTRA_DEBUG
if (obj == debug_obj)
printf(" new sim_time = %x\n",sim_time);
#endif
}
switch( fate ) {
case HIT_WALL: {
vms_vector moved_v;
//@@fix total_d,moved_d;
fix hit_speed,wall_part;
// Find hit speed
vm_vec_sub(&moved_v,&obj->pos,&save_pos);
wall_part = vm_vec_dot(&moved_v,&hit_info.hit_wallnorm);
if (wall_part != 0 && moved_time>0 && (hit_speed=-fixdiv(wall_part,moved_time))>0)
collide_object_with_wall( obj, hit_speed, WallHitSeg, WallHitSide, &hit_info.hit_pnt );
else
scrape_object_on_wall(obj, WallHitSeg, WallHitSide, &hit_info.hit_pnt );
Assert( WallHitSeg > -1 );
Assert( WallHitSide > -1 );
if ( !(obj->flags&OF_SHOULD_BE_DEAD) ) {
Assert(! (obj->mtype.phys_info.flags & PF_STICK && obj->mtype.phys_info.flags & PF_BOUNCE)); //can't be bounce and stick
if (obj->mtype.phys_info.flags & PF_STICK) { //stop moving
// mprintf((0, "Object %i stuck at %i:%i\n", obj-Objects, WallHitSeg, WallHitSide));
add_stuck_object(obj, WallHitSeg, WallHitSide);
vm_vec_zero(&obj->mtype.phys_info.velocity);
obj_stopped = 1;
try_again = 0;
}
else { // Slide object along wall
//We're constrained by wall, so subtract wall part from
//velocity vector
wall_part = vm_vec_dot(&hit_info.hit_wallnorm,&obj->mtype.phys_info.velocity);
if (obj->mtype.phys_info.flags & PF_BOUNCE) //bounce off wall
wall_part *= 2; //Subtract out wall part twice to achieve bounce
vm_vec_scale_add2(&obj->mtype.phys_info.velocity,&hit_info.hit_wallnorm,-wall_part);
#ifdef EXTRA_DEBUG
if (obj == debug_obj) {
printf(" sliding - wall_norm %x %x %x\n",wall_part,XYZ(&hit_info.hit_wallnorm));
printf(" wall_part %x, new velocity = %x %x %x\n",wall_part,XYZ(&obj->mtype.phys_info.velocity));
}
#endif
try_again = 1;
}
}
break;
}
case HIT_OBJECT: {
vms_vector old_vel;
// Mark the hit object so that on a retry the fvi code
// ignores this object.
Assert(hit_info.hit_object != -1);
// Calculcate the hit point between the two objects.
{ vms_vector *ppos0, *ppos1, pos_hit;
fix size0, size1;
ppos0 = &Objects[hit_info.hit_object].pos;
ppos1 = &obj->pos;
size0 = Objects[hit_info.hit_object].size;
size1 = obj->size;
Assert(size0+size1 != 0); // Error, both sizes are 0, so how did they collide, anyway?!?
//vm_vec_scale(vm_vec_sub(&pos_hit, ppos1, ppos0), fixdiv(size0, size0 + size1));
//vm_vec_add2(&pos_hit, ppos0);
vm_vec_sub(&pos_hit, ppos1, ppos0);
vm_vec_scale_add(&pos_hit,ppos0,&pos_hit,fixdiv(size0, size0 + size1));
old_vel = obj->mtype.phys_info.velocity;
collide_two_objects( obj, &Objects[hit_info.hit_object], &pos_hit);
}
// Let object continue its movement
if ( !(obj->flags&OF_SHOULD_BE_DEAD) ) {
//obj->pos = save_pos;
if (obj->mtype.phys_info.flags&PF_PERSISTENT || (old_vel.x == obj->mtype.phys_info.velocity.x && old_vel.y == obj->mtype.phys_info.velocity.y && old_vel.z == obj->mtype.phys_info.velocity.z)) {
//if (Objects[hit_info.hit_object].type == OBJ_POWERUP)
ignore_obj_list[n_ignore_objs++] = hit_info.hit_object;
try_again = 1;
}
}
break;
}
case HIT_NONE:
break;
#ifndef NDEBUG
case HIT_BAD_P0:
Int3(); // Unexpected collision type: start point not in specified segment.
mprintf((0,"Warning: Bad p0 in physics!!!\n"));
break;
default:
// Unknown collision type returned from find_vector_intersection!!
Int3();
break;
#endif
}
} while ( try_again );
// Pass retry count info to AI.
if (obj->control_type == CT_AI) {
if (count > 0) {
Ai_local_info[objnum].retry_count = count-1;
Total_retries += count-1;
Total_sims++;
}
}
if (! obj_stopped) { //Set velocity from actual movement
vms_vector moved_vec;
vm_vec_sub(&moved_vec,&obj->pos,&start_pos);
vm_vec_copy_scale(&obj->mtype.phys_info.velocity,&moved_vec,fixdiv(f1_0,FrameTime));
#ifdef BUMP_HACK
if (obj==ConsoleObject && (obj->mtype.phys_info.velocity.x==0 && obj->mtype.phys_info.velocity.y==0 && obj->mtype.phys_info.velocity.z==0) &&
!(obj->mtype.phys_info.thrust.x==0 && obj->mtype.phys_info.thrust.y==0 && obj->mtype.phys_info.thrust.z==0)) {
vms_vector center,bump_vec;
//bump player a little towards center of segment to unstick
compute_segment_center(¢er,&Segments[obj->segnum]);
vm_vec_normalized_dir_quick(&bump_vec,¢er,&obj->pos);
vm_vec_scale_add2(&obj->pos,&bump_vec,obj->size/5);
}
#endif
}
//Assert(check_point_in_seg(&obj->pos,obj->segnum,0).centermask==0);
//if (obj->control_type == CT_FLYING)
if (obj->mtype.phys_info.flags & PF_LEVELLING)
do_physics_align_object( obj );
//hack to keep player from going through closed doors
if (obj->type==OBJ_PLAYER && obj->segnum!=orig_segnum && (Physics_cheat_flag!=0xBADA55) ) {
int sidenum;
sidenum = find_connect_side(&Segments[obj->segnum],&Segments[orig_segnum]);
if (sidenum != -1) {
if (! (WALL_IS_DOORWAY(&Segments[orig_segnum],sidenum) & WID_FLY_FLAG)) {
side *s;
int vertnum,num_faces,i;
fix dist;
int vertex_list[6];
//bump object back
s = &Segments[orig_segnum].sides[sidenum];
create_abs_vertex_lists( &num_faces, vertex_list, orig_segnum, sidenum);
//let's pretend this wall is not triangulated
vertnum = vertex_list[0];
for (i=1;i<4;i++)
if (vertex_list[i] < vertnum)
vertnum = vertex_list[i];
#ifdef COMPACT_SEGS
{
vms_vector _vn;
get_side_normal(&Segments[orig_segnum], sidenum, 0, &_vn );
dist = vm_dist_to_plane(&start_pos, &_vn, &Vertices[vertnum]);
vm_vec_scale_add(&obj->pos,&start_pos,&_vn,obj->size-dist);
}
#else
dist = vm_dist_to_plane(&start_pos, &s->normals[0], &Vertices[vertnum]);
vm_vec_scale_add(&obj->pos,&start_pos,&s->normals[0],obj->size-dist);
#endif
update_object_seg(obj);
}
}
}
//--WE ALWYS WANT THIS IN, MATT AND MIKE DECISION ON 12/10/94, TWO MONTHS AFTER FINAL #ifndef NDEBUG
//if end point not in segment, move object to last pos, or segment center
if (get_seg_masks(&obj->pos,obj->segnum,0).centermask!=0) {
if (find_object_seg(obj)==-1) {
int n;
//Int3();
if (obj->type==OBJ_PLAYER && (n=find_point_seg(&obj->last_pos,obj->segnum))!=-1) {
obj->pos = obj->last_pos;
obj_relink(objnum, n );
}
else {
compute_segment_center(&obj->pos,&Segments[obj->segnum]);
obj->pos.x += objnum;
}
if (obj->type == OBJ_WEAPON)
obj->flags |= OF_SHOULD_BE_DEAD;
}
}
//--WE ALWYS WANT THIS IN, MATT AND MIKE DECISION ON 12/10/94, TWO MONTHS AFTER FINAL #endif
}
void add_segment_edges(automap *am, segment *seg)
{
int is_grate, no_fade;
ubyte color;
int sn;
int segnum = seg-Segments;
int hidden_flag;
int ttype,trigger_num;
for (sn=0;sn<MAX_SIDES_PER_SEGMENT;sn++) {
int vertex_list[4];
hidden_flag = 0;
is_grate = 0;
no_fade = 0;
color = 255;
if (seg->children[sn] == -1) {
color = am->wall_normal_color;
}
switch( Segment2s[segnum].special ) {
case SEGMENT_IS_FUELCEN:
color = BM_XRGB( 29, 27, 13 );
break;
case SEGMENT_IS_CONTROLCEN:
if (Control_center_present)
color = BM_XRGB( 29, 0, 0 );
break;
case SEGMENT_IS_ROBOTMAKER:
color = BM_XRGB( 29, 0, 31 );
break;
}
if (seg->sides[sn].wall_num > -1) {
trigger_num = Walls[seg->sides[sn].wall_num].trigger;
ttype = Triggers[trigger_num].type;
if (ttype==TT_SECRET_EXIT)
{
color = BM_XRGB( 29, 0, 31 );
no_fade=1;
goto Here;
}
switch( Walls[seg->sides[sn].wall_num].type ) {
case WALL_DOOR:
if (Walls[seg->sides[sn].wall_num].keys == KEY_BLUE) {
no_fade = 1;
color = am->wall_door_blue;
} else if (Walls[seg->sides[sn].wall_num].keys == KEY_GOLD) {
no_fade = 1;
color = am->wall_door_gold;
} else if (Walls[seg->sides[sn].wall_num].keys == KEY_RED) {
no_fade = 1;
color = am->wall_door_red;
} else if (!(WallAnims[Walls[seg->sides[sn].wall_num].clip_num].flags & WCF_HIDDEN)) {
int connected_seg = seg->children[sn];
if (connected_seg != -1) {
int connected_side = find_connect_side(seg, &Segments[connected_seg]);
int keytype = Walls[Segments[connected_seg].sides[connected_side].wall_num].keys;
if ((keytype != KEY_BLUE) && (keytype != KEY_GOLD) && (keytype != KEY_RED))
color = am->wall_door_color;
else {
switch (Walls[Segments[connected_seg].sides[connected_side].wall_num].keys) {
case KEY_BLUE: color = am->wall_door_blue; no_fade = 1; break;
case KEY_GOLD: color = am->wall_door_gold; no_fade = 1; break;
case KEY_RED: color = am->wall_door_red; no_fade = 1; break;
default: Error("Inconsistent data. Supposed to be a colored wall, but not blue, gold or red.\n");
}
}
}
} else {
color = am->wall_normal_color;
hidden_flag = 1;
}
break;
case WALL_CLOSED:
// Make grates draw properly
if (WALL_IS_DOORWAY(seg,sn) & WID_RENDPAST_FLAG)
is_grate = 1;
else
hidden_flag = 1;
color = am->wall_normal_color;
break;
case WALL_BLASTABLE:
// Hostage doors
color = am->wall_door_color;
break;
}
}
if (segnum==Player_init[Player_num].segnum)
color = BM_XRGB(31,0,31);
if ( color != 255 ) {
// If they have a map powerup, draw unvisited areas in dark blue.
if (Players[Player_num].flags & PLAYER_FLAGS_MAP_ALL && (!Automap_visited[segnum]))
color = am->wall_revealed_color;
Here:
get_side_verts(vertex_list,segnum,sn);
add_one_edge( am, vertex_list[0], vertex_list[1], color, sn, segnum, hidden_flag, 0, no_fade );
add_one_edge( am, vertex_list[1], vertex_list[2], color, sn, segnum, hidden_flag, 0, no_fade );
add_one_edge( am, vertex_list[2], vertex_list[3], color, sn, segnum, hidden_flag, 0, no_fade );
add_one_edge( am, vertex_list[3], vertex_list[0], color, sn, segnum, hidden_flag, 0, no_fade );
if ( is_grate ) {
add_one_edge( am, vertex_list[0], vertex_list[2], color, sn, segnum, hidden_flag, 1, no_fade );
add_one_edge( am, vertex_list[1], vertex_list[3], color, sn, segnum, hidden_flag, 1, no_fade );
}
}
}
}
//-----------------------------------------------------------------
// 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 );
}
}
void add_segment_edges(segment *seg)
{
int is_grate, no_fade;
ubyte color;
int sn;
int segnum = seg-Segments;
int hidden_flag;
for (sn=0;sn<MAX_SIDES_PER_SEGMENT;sn++) {
short vertex_list[4];
hidden_flag = 0;
is_grate = 0;
no_fade = 0;
color = 255;
if (seg->children[sn] == -1) {
color = WALL_NORMAL_COLOR;
}
switch( seg->special ) {
case SEGMENT_IS_FUELCEN:
color = BM_XRGB( 29, 27, 13 );
break;
case SEGMENT_IS_CONTROLCEN:
color = BM_XRGB( 29, 0, 0 );
break;
case SEGMENT_IS_ROBOTMAKER:
color = BM_XRGB( 29, 0, 31 );
break;
}
if (seg->sides[sn].wall_num > -1) {
switch( Walls[seg->sides[sn].wall_num].type ) {
case WALL_DOOR:
if (Walls[seg->sides[sn].wall_num].keys == KEY_BLUE) {
no_fade = 1;
color = WALL_DOOR_BLUE;
//mprintf((0, "Seg %i, side %i has BLUE wall\n", segnum, sn));
} else if (Walls[seg->sides[sn].wall_num].keys == KEY_GOLD) {
no_fade = 1;
color = WALL_DOOR_GOLD;
//mprintf((0, "Seg %i, side %i has GOLD wall\n", segnum, sn));
} else if (Walls[seg->sides[sn].wall_num].keys == KEY_RED) {
no_fade = 1;
color = WALL_DOOR_RED;
//mprintf((0, "Seg %i, side %i has RED wall\n", segnum, sn));
} else if (!(WallAnims[Walls[seg->sides[sn].wall_num].clip_num].flags & WCF_HIDDEN)) {
int connected_seg = seg->children[sn];
if (connected_seg != -1) {
int connected_side = find_connect_side(seg, &Segments[connected_seg]);
int keytype = Walls[Segments[connected_seg].sides[connected_side].wall_num].keys;
if ((keytype != KEY_BLUE) && (keytype != KEY_GOLD) && (keytype != KEY_RED))
color = WALL_DOOR_COLOR;
else {
switch (Walls[Segments[connected_seg].sides[connected_side].wall_num].keys) {
case KEY_BLUE: color = WALL_DOOR_BLUE; no_fade = 1; break;
case KEY_GOLD: color = WALL_DOOR_GOLD; no_fade = 1; break;
case KEY_RED: color = WALL_DOOR_RED; no_fade = 1; break;
default: Error("Inconsistent data. Supposed to be a colored wall, but not blue, gold or red.\n");
}
//mprintf((0, "Seg %i, side %i has a colored door on the other side.\n", segnum, sn));
}
}
} else {
color = WALL_NORMAL_COLOR;
hidden_flag = 1;
//mprintf((0, "Wall at seg:side %i:%i is hidden.\n", seg-Segments, sn));
}
break;
case WALL_CLOSED:
// Make grates draw properly
color = WALL_NORMAL_COLOR;
is_grate = 1;
break;
case WALL_BLASTABLE:
// Hostage doors
color = WALL_DOOR_COLOR;
break;
}
}
if (segnum==Player_init[Player_num].segnum)
color = BM_XRGB(31,0,31);
if ( color != 255 ) {
// If they have a map powerup, draw unvisited areas in dark blue.
if (Players[Player_num].flags & PLAYER_FLAGS_MAP_ALL && (!Automap_visited[segnum]))
color = BM_XRGB( 0, 0, 25 );
get_side_verts(vertex_list,segnum,sn);
add_one_edge( vertex_list[0], vertex_list[1], color, (ubyte) sn, (short) segnum, (int) hidden_flag, 0, (int) no_fade );
add_one_edge( vertex_list[1], vertex_list[2], color, (ubyte) sn, (short) segnum, hidden_flag, 0, no_fade );
add_one_edge( vertex_list[2], vertex_list[3], color, (ubyte) sn, (short) segnum, hidden_flag, 0, no_fade );
add_one_edge( vertex_list[3], vertex_list[0], color, (ubyte) sn, (short) segnum, hidden_flag, 0, no_fade );
if ( is_grate ) {
add_one_edge( vertex_list[0], vertex_list[2], color, (ubyte) sn, (short) segnum, hidden_flag, 1, no_fade );
add_one_edge( vertex_list[1], vertex_list[3], color, (ubyte) sn, (short) segnum, hidden_flag, 1, no_fade );
}
}
}
}
//---------------------------------------------------------------------
// Remove a specific side.
int wall_remove_side(segment *seg, short side)
{
int Connectside;
segment *csegp;
int lower_wallnum;
int w, s, t, l, t1;
if (IS_CHILD(seg->children[side]) && IS_CHILD(seg->sides[side].wall_num)) {
csegp = &Segments[seg->children[side]];
Connectside = find_connect_side(seg, csegp);
remove_trigger(seg, side);
remove_trigger(csegp, Connectside);
// Remove walls 'wall_num' and connecting side 'wall_num'
// from Walls array.
lower_wallnum = seg->sides[side].wall_num;
if (csegp->sides[Connectside].wall_num < lower_wallnum)
lower_wallnum = csegp->sides[Connectside].wall_num;
if (Walls[lower_wallnum].linked_wall != -1)
Walls[Walls[lower_wallnum].linked_wall].linked_wall = -1;
if (Walls[lower_wallnum+1].linked_wall != -1)
Walls[Walls[lower_wallnum+1].linked_wall].linked_wall = -1;
for (w=lower_wallnum;w<Num_walls-2;w++)
Walls[w] = Walls[w+2];
Num_walls -= 2;
for (s=0;s<=Highest_segment_index;s++)
if (Segments[s].segnum != -1)
for (w=0;w<MAX_SIDES_PER_SEGMENT;w++)
if (Segments[s].sides[w].wall_num > lower_wallnum+1)
Segments[s].sides[w].wall_num -= 2;
// Destroy any links to the deleted wall.
for (t=0;t<Num_triggers;t++)
for (l=0;l<Triggers[t].num_links;l++)
if ((Triggers[t].seg[l] == seg-Segments) && (Triggers[t].side[l] == side)) {
for (t1=0;t1<Triggers[t].num_links-1;t1++) {
Triggers[t].seg[t1] = Triggers[t].seg[t1+1];
Triggers[t].side[t1] = Triggers[t].side[t1+1];
}
Triggers[t].num_links--;
}
// Destroy control center links as well.
for (l=0;l<ControlCenterTriggers.num_links;l++)
if ((ControlCenterTriggers.seg[l] == seg-Segments) && (ControlCenterTriggers.side[l] == side)) {
for (t1=0;t1<ControlCenterTriggers.num_links-1;t1++) {
ControlCenterTriggers.seg[t1] = ControlCenterTriggers.seg[t1+1];
ControlCenterTriggers.side[t1] = ControlCenterTriggers.side[t1+1];
}
ControlCenterTriggers.num_links--;
}
seg->sides[side].wall_num = -1;
csegp->sides[Connectside].wall_num = -1;
Update_flags |= UF_WORLD_CHANGED;
return 1;
}
editor_status( "Can't remove wall. No wall present.");
return 0;
}
// -----------------------------------------------------------------------------------------------------------
//Simulate a physics object for this frame
void do_physics_sim(object *obj)
{
int ignore_obj_list[MAX_IGNORE_OBJS],n_ignore_objs;
int iseg;
int try_again;
int fate=0;
vms_vector frame_vec; //movement in this frame
vms_vector new_pos,ipos; //position after this frame
int count=0;
int objnum;
int WallHitSeg, WallHitSide;
fvi_info hit_info;
fvi_query fq;
vms_vector save_pos;
int save_seg;
fix drag;
fix sim_time;
vms_vector start_pos;
int obj_stopped=0;
fix moved_time; //how long objected moved before hit something
physics_info *pi;
int orig_segnum = obj->segnum;
fix PhysTime = (FrameTime<F1_0/30?F1_0/30:FrameTime);
Assert(obj->movement_type == MT_PHYSICS);
#ifndef NDEBUG
if (Dont_move_ai_objects)
if (obj->control_type == CT_AI)
return;
#endif
pi = &obj->mtype.phys_info;
do_physics_sim_rot(obj);
if (!(pi->velocity.x || pi->velocity.y || pi->velocity.z || pi->thrust.x || pi->thrust.y || pi->thrust.z))
return;
objnum = obj-Objects;
n_phys_segs = 0;
/* As this engine was not designed for that high FPS as we intend, we use F1_0/30 max. for sim_time to ensure
scaling and dot products stay accurate and reliable. The object position intended for this frame will be scaled down later,
after the main collision-loop is done.
This won't make collision results be equal in all FPS settings, but hopefully more accurate, the higher our FPS are.
*/
sim_time = PhysTime; //FrameTime;
//debug_obj = obj;
#ifdef EXTRA_DEBUG
//check for correct object segment
if(!get_seg_masks(&obj->pos,obj->segnum,0,__FILE__,__LINE__).centermask==0) {
//Int3(); Removed by Rob 10/5/94
if (!update_object_seg(obj)) {
if (!(Game_mode & GM_MULTI))
Int3();
compute_segment_center(&obj->pos,&Segments[obj->segnum]);
obj->pos.x += objnum;
}
}
#endif
start_pos = obj->pos;
n_ignore_objs = 0;
Assert(obj->mtype.phys_info.brakes==0); //brakes not used anymore?
//if uses thrust, cannot have zero drag
Assert(!(obj->mtype.phys_info.flags&PF_USES_THRUST) || obj->mtype.phys_info.drag!=0);
//do thrust & drag
// NOTE: this always must be dependent on FrameTime, if sim_time differs!
if ((drag = obj->mtype.phys_info.drag) != 0) {
int count;
vms_vector accel;
fix r,k,have_accel;
count = FrameTime / FT;
r = FrameTime % FT;
k = fixdiv(r,FT);
if (obj->mtype.phys_info.flags & PF_USES_THRUST) {
vm_vec_copy_scale(&accel,&obj->mtype.phys_info.thrust,fixdiv(f1_0,obj->mtype.phys_info.mass));
have_accel = (accel.x || accel.y || accel.z);
while (count--) {
if (have_accel)
vm_vec_add2(&obj->mtype.phys_info.velocity,&accel);
vm_vec_scale(&obj->mtype.phys_info.velocity,f1_0-drag);
}
//do linear scale on remaining bit of time
vm_vec_scale_add2(&obj->mtype.phys_info.velocity,&accel,k);
if (drag)
vm_vec_scale(&obj->mtype.phys_info.velocity,f1_0-fixmul(k,drag));
}
else if (drag)
{
fix total_drag=f1_0;
while (count--)
total_drag = fixmul(total_drag,f1_0-drag);
//do linear scale on remaining bit of time
total_drag = fixmul(total_drag,f1_0-fixmul(k,drag));
vm_vec_scale(&obj->mtype.phys_info.velocity,total_drag);
}
}
do {
try_again = 0;
//Move the object
vm_vec_copy_scale(&frame_vec, &obj->mtype.phys_info.velocity, sim_time);
if ( (frame_vec.x==0) && (frame_vec.y==0) && (frame_vec.z==0) )
break;
count++;
// If retry count is getting large, then we are trying to do something stupid.
if (count > 8) break; // in original code this was 3 for all non-player objects. still leave us some limit in case fvi goes apeshit.
vm_vec_add(&new_pos,&obj->pos,&frame_vec);
ignore_obj_list[n_ignore_objs] = -1;
fq.p0 = &obj->pos;
fq.startseg = obj->segnum;
fq.p1 = &new_pos;
fq.rad = obj->size;
fq.thisobjnum = objnum;
fq.ignore_obj_list = ignore_obj_list;
fq.flags = FQ_CHECK_OBJS;
if (obj->type == OBJ_WEAPON)
fq.flags |= FQ_TRANSPOINT;
if (obj->type == OBJ_PLAYER)
fq.flags |= FQ_GET_SEGLIST;
fate = find_vector_intersection(&fq,&hit_info);
// Matt: Mike's hack.
if (fate == HIT_OBJECT) {
object *objp = &Objects[hit_info.hit_object];
if (((objp->type == OBJ_WEAPON) && (objp->id == PROXIMITY_ID)) || objp->type == OBJ_POWERUP) // do not increase count for powerups since they *should* not change our movement
count--;
}
#ifndef NDEBUG
if (fate == HIT_BAD_P0) {
Int3();
}
#endif
if (obj->type == OBJ_PLAYER) {
int i;
if (n_phys_segs && phys_seglist[n_phys_segs-1]==hit_info.seglist[0])
n_phys_segs--;
for (i=0;(i<hit_info.n_segs) && (n_phys_segs<MAX_FVI_SEGS-1); )
phys_seglist[n_phys_segs++] = hit_info.seglist[i++];
}
ipos = hit_info.hit_pnt;
iseg = hit_info.hit_seg;
WallHitSide = hit_info.hit_side;
WallHitSeg = hit_info.hit_side_seg;
if (iseg==-1) { //some sort of horrible error
if (obj->type == OBJ_WEAPON)
obj->flags |= OF_SHOULD_BE_DEAD;
break;
}
Assert(!((fate==HIT_WALL) && ((WallHitSeg == -1) || (WallHitSeg > Highest_segment_index))));
//if(!get_seg_masks(&hit_info.hit_pnt,hit_info.hit_seg,0).centermask==0)
// Int3();
save_pos = obj->pos; //save the object's position
save_seg = obj->segnum;
// update object's position and segment number
obj->pos = ipos;
if ( iseg != obj->segnum )
obj_relink(objnum, iseg );
//if start point not in segment, move object to center of segment
if (get_seg_masks(&obj->pos,obj->segnum,0,__FILE__,__LINE__).centermask!=0) {
int n;
if ((n=find_object_seg(obj))==-1) {
//Int3();
if (obj->type==OBJ_PLAYER && (n=find_point_seg(&obj->last_pos,obj->segnum))!=-1) {
obj->pos = obj->last_pos;
obj_relink(objnum, n );
}
else {
compute_segment_center(&obj->pos,&Segments[obj->segnum]);
obj->pos.x += objnum;
}
if (obj->type == OBJ_WEAPON)
obj->flags |= OF_SHOULD_BE_DEAD;
}
return;
}
//calulate new sim time
{
//vms_vector moved_vec;
vms_vector moved_vec_n;
fix attempted_dist,actual_dist;
actual_dist = vm_vec_normalized_dir(&moved_vec_n,&obj->pos,&save_pos);
if (fate==HIT_WALL && vm_vec_dot(&moved_vec_n,&frame_vec) < 0) { //moved backwards
//don't change position or sim_time
obj->pos = save_pos;
//iseg = obj->segnum; //don't change segment
obj_relink(objnum, save_seg );
moved_time = 0;
}
else {
fix old_sim_time;
attempted_dist = vm_vec_mag(&frame_vec);
old_sim_time = sim_time;
sim_time = fixmuldiv(sim_time,attempted_dist-actual_dist,attempted_dist);
moved_time = old_sim_time - sim_time;
if (sim_time < 0 || sim_time>old_sim_time) {
sim_time = old_sim_time;
//WHY DOES THIS HAPPEN??
moved_time = 0;
}
}
}
switch( fate ) {
case HIT_WALL: {
vms_vector moved_v;
fix hit_speed=0, wall_part=0;
// Find hit speed
vm_vec_sub(&moved_v,&obj->pos,&save_pos);
wall_part = vm_vec_dot(&moved_v,&hit_info.hit_wallnorm);
if ((wall_part != 0 && moved_time>0 && (hit_speed=-fixdiv(wall_part,moved_time))>0) || obj->type == OBJ_WEAPON || obj->type == OBJ_DEBRIS)
collide_object_with_wall( obj, hit_speed, WallHitSeg, WallHitSide, &hit_info.hit_pnt );
if (obj->type == OBJ_PLAYER)
scrape_player_on_wall(obj, WallHitSeg, WallHitSide, &hit_info.hit_pnt );
Assert( WallHitSeg > -1 );
Assert( WallHitSide > -1 );
if ( !(obj->flags&OF_SHOULD_BE_DEAD) ) {
Assert(! (obj->mtype.phys_info.flags & PF_STICK && obj->mtype.phys_info.flags & PF_BOUNCE)); //can't be bounce and stick
if (obj->mtype.phys_info.flags & PF_STICK) { //stop moving
add_stuck_object(obj, WallHitSeg, WallHitSide);
vm_vec_zero(&obj->mtype.phys_info.velocity);
obj_stopped = 1;
try_again = 0;
}
else { // Slide object along wall
//We're constrained by wall, so subtract wall part from
//velocity vector
wall_part = vm_vec_dot(&hit_info.hit_wallnorm,&obj->mtype.phys_info.velocity);
// if wall_part, make sure the value is sane enough to get usable velocity computed
if (wall_part < 0 && wall_part > -f1_0) wall_part = -f1_0;
if (wall_part > 0 && wall_part < f1_0) wall_part = f1_0;
if (obj->mtype.phys_info.flags & PF_BOUNCE) //bounce off wall
wall_part *= 2; //Subtract out wall part twice to achieve bounce
vm_vec_scale_add2(&obj->mtype.phys_info.velocity,&hit_info.hit_wallnorm,-wall_part);
try_again = 1;
}
}
break;
}
case HIT_OBJECT: {
vms_vector old_vel;
// Mark the hit object so that on a retry the fvi code
// ignores this object.
Assert(hit_info.hit_object != -1);
// Calculcate the hit point between the two objects.
{ vms_vector *ppos0, *ppos1, pos_hit;
fix size0, size1;
ppos0 = &Objects[hit_info.hit_object].pos;
ppos1 = &obj->pos;
size0 = Objects[hit_info.hit_object].size;
size1 = obj->size;
Assert(size0+size1 != 0); // Error, both sizes are 0, so how did they collide, anyway?!?
//vm_vec_scale(vm_vec_sub(&pos_hit, ppos1, ppos0), fixdiv(size0, size0 + size1));
//vm_vec_add2(&pos_hit, ppos0);
vm_vec_sub(&pos_hit, ppos1, ppos0);
vm_vec_scale_add(&pos_hit,ppos0,&pos_hit,fixdiv(size0, size0 + size1));
old_vel = obj->mtype.phys_info.velocity;
collide_two_objects( obj, &Objects[hit_info.hit_object], &pos_hit);
}
// Let object continue its movement
if ( !(obj->flags&OF_SHOULD_BE_DEAD) ) {
//obj->pos = save_pos;
if (obj->mtype.phys_info.flags&PF_PERSISTENT || (old_vel.x == obj->mtype.phys_info.velocity.x && old_vel.y == obj->mtype.phys_info.velocity.y && old_vel.z == obj->mtype.phys_info.velocity.z)) {
//if (Objects[hit_info.hit_object].type == OBJ_POWERUP)
ignore_obj_list[n_ignore_objs++] = hit_info.hit_object;
try_again = 1;
}
}
break;
}
case HIT_NONE:
break;
#ifndef NDEBUG
case HIT_BAD_P0:
Int3(); // Unexpected collision type: start point not in specified segment.
break;
default:
// Unknown collision type returned from find_vector_intersection!!
Int3();
break;
#endif
}
} while ( try_again );
// Pass retry count info to AI.
if (obj->control_type == CT_AI) {
if (count > 0) {
Ai_local_info[objnum].retry_count = count-1;
Total_retries += count-1;
Total_sims++;
}
}
// As sim_time may not base on FrameTime, scale actual object position to get accurate movement
if (PhysTime/FrameTime > 0)
{
vms_vector md;
vm_vec_sub(&md, &obj->pos, &start_pos);
vm_vec_scale(&md, F1_0/((float)PhysTime/FrameTime));
vm_vec_add(&obj->pos,&start_pos, &md);
//check for and update correct object segment
if(!get_seg_masks(&obj->pos, obj->segnum, 0, __FILE__, __LINE__).centermask == 0)
{
if (!update_object_seg(obj)) {
if (!(Game_mode & GM_MULTI))
Int3();
compute_segment_center(&obj->pos,&Segments[obj->segnum]);
obj->pos.x += objnum;
}
}
}
// After collision with objects and walls, set velocity from actual movement
if (!obj_stopped
&& ((obj->type == OBJ_PLAYER) || (obj->type == OBJ_ROBOT) || (obj->type == OBJ_DEBRIS))
&& ((fate == HIT_WALL) || (fate == HIT_OBJECT) || (fate == HIT_BAD_P0))
)
{
vms_vector moved_vec;
vm_vec_sub(&moved_vec,&obj->pos,&start_pos);
vm_vec_copy_scale(&obj->mtype.phys_info.velocity,&moved_vec,fixdiv(f1_0,FrameTime));
}
fix_illegal_wall_intersection(obj, &start_pos);
//Assert(check_point_in_seg(&obj->pos,obj->segnum,0).centermask==0);
//if (obj->control_type == CT_FLYING)
if (obj->mtype.phys_info.flags & PF_LEVELLING)
do_physics_align_object( obj );
//hack to keep player from going through closed doors
if (obj->type==OBJ_PLAYER && obj->segnum!=orig_segnum && (!cheats.ghostphysics) ) {
int sidenum;
sidenum = find_connect_side(&Segments[obj->segnum],&Segments[orig_segnum]);
if (sidenum != -1) {
if (! (WALL_IS_DOORWAY(&Segments[orig_segnum],sidenum) & WID_FLY_FLAG)) {
side *s;
int vertnum,num_faces,i;
fix dist;
int vertex_list[6];
//bump object back
s = &Segments[orig_segnum].sides[sidenum];
create_abs_vertex_lists( &num_faces, vertex_list, orig_segnum, sidenum, __FILE__,__LINE__);
//let's pretend this wall is not triangulated
vertnum = vertex_list[0];
for (i=1;i<4;i++)
if (vertex_list[i] < vertnum)
vertnum = vertex_list[i];
#ifdef COMPACT_SEGS
{
vms_vector _vn;
get_side_normal(&Segments[orig_segnum], sidenum, 0, &_vn );
dist = vm_dist_to_plane(&start_pos, &_vn, &Vertices[vertnum]);
vm_vec_scale_add(&obj->pos,&start_pos,&_vn,obj->size-dist);
}
#else
dist = vm_dist_to_plane(&start_pos, &s->normals[0], &Vertices[vertnum]);
vm_vec_scale_add(&obj->pos,&start_pos,&s->normals[0],obj->size-dist);
#endif
update_object_seg(obj);
}
}
}
//--WE ALWYS WANT THIS IN, MATT AND MIKE DECISION ON 12/10/94, TWO MONTHS AFTER FINAL #ifndef NDEBUG
//if end point not in segment, move object to last pos, or segment center
if (get_seg_masks(&obj->pos,obj->segnum,0,__FILE__,__LINE__).centermask!=0) {
if (find_object_seg(obj)==-1) {
int n;
//Int3();
if (obj->type==OBJ_PLAYER && (n=find_point_seg(&obj->last_pos,obj->segnum))!=-1) {
obj->pos = obj->last_pos;
obj_relink(objnum, n );
}
else {
compute_segment_center(&obj->pos,&Segments[obj->segnum]);
obj->pos.x += objnum;
}
if (obj->type == OBJ_WEAPON)
obj->flags |= OF_SHOULD_BE_DEAD;
}
}
//--WE ALWYS WANT THIS IN, MATT AND MIKE DECISION ON 12/10/94, TWO MONTHS AFTER FINAL #endif
}
// --------------------------------------------------------------------
// Load game
// Loads all the relevant data for a level.
// If level != -1, it loads the filename with extension changed to .min
// Otherwise it loads the appropriate level mine.
// returns 0=everything ok, 1=old version, -1=error
int load_game_data(PHYSFS_file *LoadFile)
{
int i,j;
short game_top_fileinfo_version;
int object_offset;
int gs_num_objects;
int trig_size;
//===================== READ FILE INFO ========================
#if 0
PHYSFS_read(LoadFile, &game_top_fileinfo, sizeof(game_top_fileinfo), 1);
#endif
// Check signature
if (PHYSFSX_readShort(LoadFile) != 0x6705)
return -1;
// Read and check version number
game_top_fileinfo_version = PHYSFSX_readShort(LoadFile);
if (game_top_fileinfo_version < GAME_COMPATIBLE_VERSION )
return -1;
// We skip some parts of the former game_top_fileinfo
PHYSFSX_fseek(LoadFile, 31, SEEK_CUR);
object_offset = PHYSFSX_readInt(LoadFile);
gs_num_objects = PHYSFSX_readInt(LoadFile);
PHYSFSX_fseek(LoadFile, 8, SEEK_CUR);
Num_walls = PHYSFSX_readInt(LoadFile);
PHYSFSX_fseek(LoadFile, 20, SEEK_CUR);
Num_triggers = PHYSFSX_readInt(LoadFile);
PHYSFSX_fseek(LoadFile, 24, SEEK_CUR);
trig_size = PHYSFSX_readInt(LoadFile);
Assert(trig_size == sizeof(ControlCenterTriggers));
(void)trig_size;
PHYSFSX_fseek(LoadFile, 4, SEEK_CUR);
Num_robot_centers = PHYSFSX_readInt(LoadFile);
PHYSFSX_fseek(LoadFile, 4, SEEK_CUR);
if (game_top_fileinfo_version >= 31) //load mine filename
// read newline-terminated string, not sure what version this changed.
PHYSFSX_fgets(Current_level_name,sizeof(Current_level_name),LoadFile);
else if (game_top_fileinfo_version >= 14) { //load mine filename
// read null-terminated string
char *p=Current_level_name;
//must do read one char at a time, since no PHYSFSX_fgets()
do *p = PHYSFSX_fgetc(LoadFile); while (*p++!=0);
}
else
Current_level_name[0]=0;
if (game_top_fileinfo_version >= 19) { //load pof names
N_save_pof_names = PHYSFSX_readShort(LoadFile);
if (N_save_pof_names != 0x614d && N_save_pof_names != 0x5547) { // "Ma"de w/DMB beta/"GU"ILE
Assert(N_save_pof_names < MAX_POLYGON_MODELS);
PHYSFS_read(LoadFile,Save_pof_names,N_save_pof_names,FILENAME_LEN);
}
}
//===================== READ PLAYER INFO ==========================
//===================== READ OBJECT INFO ==========================
Gamesave_num_org_robots = 0;
Gamesave_num_players = 0;
if (object_offset > -1) {
if (PHYSFSX_fseek( LoadFile, object_offset, SEEK_SET ))
Error( "Error seeking to object_offset in gamesave.c" );
for (i = 0; i < gs_num_objects; i++) {
read_object(&Objects[i], LoadFile, game_top_fileinfo_version);
Objects[i].signature = obj_get_signature();
verify_object( &Objects[i] );
}
}
//===================== READ WALL INFO ============================
for (i = 0; i < Num_walls; i++) {
if (game_top_fileinfo_version >= 20)
wall_read(&Walls[i], LoadFile); // v20 walls and up.
else if (game_top_fileinfo_version >= 17) {
v19_wall w;
v19_wall_read(&w, LoadFile);
Walls[i].segnum = w.segnum;
Walls[i].sidenum = w.sidenum;
Walls[i].linked_wall = w.linked_wall;
Walls[i].type = w.type;
Walls[i].flags = w.flags;
Walls[i].hps = w.hps;
Walls[i].trigger = w.trigger;
Walls[i].clip_num = convert_wclip(w.clip_num);
Walls[i].keys = w.keys;
Walls[i].state = WALL_DOOR_CLOSED;
} else {
v16_wall w;
v16_wall_read(&w, LoadFile);
Walls[i].segnum = Walls[i].sidenum = Walls[i].linked_wall = -1;
Walls[i].type = w.type;
Walls[i].flags = w.flags;
Walls[i].hps = w.hps;
Walls[i].trigger = w.trigger;
Walls[i].clip_num = convert_wclip(w.clip_num);
Walls[i].keys = w.keys;
}
}
#if 0
//===================== READ DOOR INFO ============================
if (game_fileinfo.doors_offset > -1)
{
if (!PHYSFSX_fseek( LoadFile, game_fileinfo.doors_offset,SEEK_SET )) {
for (i=0;i<game_fileinfo.doors_howmany;i++) {
if (game_top_fileinfo_version >= 20)
active_door_read(&ActiveDoors[i], LoadFile); // version 20 and up
else {
v19_door d;
int p;
v19_door_read(&d, LoadFile);
ActiveDoors[i].n_parts = d.n_parts;
for (p=0;p<d.n_parts;p++) {
int cseg,cside;
cseg = Segments[d.seg[p]].children[d.side[p]];
cside = find_connect_side(&Segments[d.seg[p]],&Segments[cseg]);
ActiveDoors[i].front_wallnum[p] = Segments[d.seg[p]].sides[d.side[p]].wall_num;
ActiveDoors[i].back_wallnum[p] = Segments[cseg].sides[cside].wall_num;
}
}
}
}
}
#endif // 0
//==================== READ TRIGGER INFO ==========================
for (i = 0; i < Num_triggers; i++)
{
if (game_top_fileinfo_version <= 25)
trigger_read(&Triggers[i], LoadFile);
else {
int type;
switch ((type = PHYSFSX_readByte(LoadFile)))
{
case 0: // door
Triggers[i].type = 0;
Triggers[i].flags = TRIGGER_CONTROL_DOORS;
break;
case 2: // matcen
Triggers[i].type = 0;
Triggers[i].flags = TRIGGER_MATCEN;
break;
case 3: // exit
Triggers[i].type = 0;
Triggers[i].flags = TRIGGER_EXIT;
break;
case 4: // secret exit
Triggers[i].type = 0;
Triggers[i].flags = TRIGGER_SECRET_EXIT;
break;
case 5: // illusion off
Triggers[i].type = 0;
Triggers[i].flags = TRIGGER_ILLUSION_OFF;
break;
case 6: // illusion on
Triggers[i].type = 0;
Triggers[i].flags = TRIGGER_ILLUSION_ON;
break;
default:
con_printf(CON_URGENT,"Warning: unsupported trigger type %d (%d)\n", type, i);
}
if (PHYSFSX_readByte(LoadFile) & 2) // one shot
Triggers[i].flags |= TRIGGER_ONE_SHOT;
Triggers[i].num_links = PHYSFSX_readShort(LoadFile);
Triggers[i].value = PHYSFSX_readInt(LoadFile);
Triggers[i].time = PHYSFSX_readInt(LoadFile);
for (j=0; j<MAX_WALLS_PER_LINK; j++ )
Triggers[i].seg[j] = PHYSFSX_readShort(LoadFile);
for (j=0; j<MAX_WALLS_PER_LINK; j++ )
Triggers[i].side[j] = PHYSFSX_readShort(LoadFile);
}
}
//================ READ CONTROL CENTER TRIGGER INFO ===============
control_center_triggers_read_n(&ControlCenterTriggers, 1, LoadFile);
//================ READ MATERIALOGRIFIZATIONATORS INFO ===============
for (i = 0; i < Num_robot_centers; i++) {
matcen_info_read(&RobotCenters[i], LoadFile, game_top_fileinfo_version);
// Set links in RobotCenters to Station array
for (j = 0; j <= Highest_segment_index; j++)
if (Segments[j].special == SEGMENT_IS_ROBOTMAKER)
if (Segments[j].matcen_num == i)
RobotCenters[i].fuelcen_num = Segments[j].value;
}
//========================= UPDATE VARIABLES ======================
reset_objects(gs_num_objects);
for (i=0; i<MAX_OBJECTS; i++) {
Objects[i].next = Objects[i].prev = -1;
if (Objects[i].type != OBJ_NONE) {
int objsegnum = Objects[i].segnum;
if (objsegnum > Highest_segment_index) //bogus object
Objects[i].type = OBJ_NONE;
else {
Objects[i].segnum = -1; //avoid Assert()
obj_link(i,objsegnum);
}
}
}
clear_transient_objects(1); //1 means clear proximity bombs
// Make sure non-transparent doors are set correctly.
for (i=0; i< Num_segments; i++)
for (j=0;j<MAX_SIDES_PER_SEGMENT;j++) {
side *sidep = &Segments[i].sides[j];
if ((sidep->wall_num != -1) && (Walls[sidep->wall_num].clip_num != -1)) {
if (WallAnims[Walls[sidep->wall_num].clip_num].flags & WCF_TMAP1) {
sidep->tmap_num = WallAnims[Walls[sidep->wall_num].clip_num].frames[0];
sidep->tmap_num2 = 0;
}
}
}
reset_walls();
#if 0
Num_open_doors = game_fileinfo.doors_howmany;
#endif // 0
Num_open_doors = 0;
//go through all walls, killing references to invalid triggers
for (i=0;i<Num_walls;i++)
if (Walls[i].trigger >= Num_triggers) {
Walls[i].trigger = -1; //kill trigger
}
//go through all triggers, killing unused ones
for (i=0;i<Num_triggers;) {
int w;
// Find which wall this trigger is connected to.
for (w=0; w<Num_walls; w++)
if (Walls[w].trigger == i)
break;
#ifdef EDITOR
if (w == Num_walls) {
remove_trigger_num(i);
}
else
#endif
i++;
}
// MK, 10/17/95: Make walls point back at the triggers that control them.
// Go through all triggers, stuffing controlling_trigger field in Walls.
{
int t;
for (t=0; t<Num_triggers; t++) {
int l;
for (l=0; l<Triggers[t].num_links; l++) {
int seg_num;
seg_num = Triggers[t].seg[l];
//check to see that if a trigger requires a wall that it has one,
//and if it requires a matcen that it has one
if (Triggers[t].type == TRIGGER_MATCEN) {
if (Segments[seg_num].special != SEGMENT_IS_ROBOTMAKER)
Int3(); //matcen trigger doesn't point to matcen
}
}
}
}
//fix old wall structs
if (game_top_fileinfo_version < 17) {
int segnum,sidenum,wallnum;
for (segnum=0; segnum<=Highest_segment_index; segnum++)
for (sidenum=0;sidenum<6;sidenum++)
if ((wallnum=Segments[segnum].sides[sidenum].wall_num) != -1) {
Walls[wallnum].segnum = segnum;
Walls[wallnum].sidenum = sidenum;
}
}
#ifndef NDEBUG
{
int sidenum;
for (sidenum=0; sidenum<6; sidenum++) {
int wallnum = Segments[Highest_segment_index].sides[sidenum].wall_num;
if (wallnum != -1)
if ((Walls[wallnum].segnum != Highest_segment_index) || (Walls[wallnum].sidenum != sidenum))
Int3(); // Error. Bogus walls in this segment.
// Consult Yuan or Mike.
}
}
#endif
//create_local_segment_data();
fix_object_segs();
#ifndef NDEBUG
dump_mine_info();
#endif
if (game_top_fileinfo_version < GAME_VERSION)
return 1; //means old version
else
return 0;
}