// --------------------------------------------------------------------------
// Detonate reactor.
// Award player all powerups in mine.
// Place player just outside exit.
// Kill all bots in mine.
// Yippee!!
void kill_and_so_forth(void)
{
int i, j;
HUD_init_message_literal(HM_DEFAULT, "Killing, awarding, etc.!");
for (i=0; i<=Highest_object_index; i++) {
switch (Objects[i].type) {
case OBJ_ROBOT:
Objects[i].flags |= OF_EXPLODING|OF_SHOULD_BE_DEAD;
break;
case OBJ_POWERUP:
do_powerup(&Objects[i]);
break;
}
}
do_controlcen_destroyed_stuff(NULL);
for (i=0; i<Num_triggers; i++) {
if (Triggers[i].flags == TRIGGER_EXIT) {
for (j=0; j<Num_walls; j++) {
if (Walls[j].trigger == i) {
compute_segment_center(&ConsoleObject->pos, &Segments[Walls[j].segnum]);
obj_relink(ConsoleObject-Objects,Walls[j].segnum);
goto kasf_done;
}
}
}
}
kasf_done: ;
}
static int PlaceHostage() {
int ctype,i;
//update_due_to_new_segment();
const auto cur_object_loc = compute_segment_center(Cursegp);
ctype = -1;
for (i=0; i<Num_total_object_types; i++ ) {
if (ObjType[i] == OL_HOSTAGE ) {
ctype = i;
break;
}
}
Assert( ctype != -1 );
if (place_object(Cursegp, cur_object_loc, ctype, 0 )==0) {
Int3(); // Debug below
i=place_object(Cursegp, cur_object_loc, ctype, 0 );
return 1;
}
const auto &&objp = vobjptridx(Cur_object_index);
if (hostage_object_is_valid(objp))
{
CurrentHostageIndex = get_hostage_id(objp);
} else {
Int3(); // Get John! (Object should be valid)
hostage_object_is_valid(objp); // For debugging only
}
return 0;
}
//find which side to fly out of
find_exit_side(object *obj)
{
int i;
vms_vector prefvec,segcenter,sidevec;
fix best_val=-f2_0;
int best_side;
segment *pseg = &Segments[obj->segnum];
//find exit side
vm_vec_normalized_dir_quick(&prefvec,&obj->pos,&obj->last_pos);
compute_segment_center(&segcenter,pseg);
best_side=-1;
for (i=MAX_SIDES_PER_SEGMENT;--i >= 0;) {
fix d;
if (pseg->children[i]!=-1) {
compute_center_point_on_side(&sidevec,pseg,i);
vm_vec_normalized_dir_quick(&sidevec,&sidevec,&segcenter);
d = vm_vec_dotprod(&sidevec,&prefvec);
if (labs(d) < MIN_D) d=0;
if (d > best_val) {best_val=d; best_side=i;}
}
}
Assert(best_side!=-1);
return best_side;
}
int PlaceHostage() {
int ctype,i;
vms_vector cur_object_loc;
//update_due_to_new_segment();
compute_segment_center(&cur_object_loc, Cursegp);
ctype = -1;
for (i=0; i<Num_total_object_types; i++ ) {
if (ObjType[i] == OL_HOSTAGE ) {
ctype = i;
break;
}
}
Assert( ctype != -1 );
if (place_object(Cursegp, &cur_object_loc, ctype )==0) {
Int3(); // Debug below
i=place_object(Cursegp, &cur_object_loc, ctype );
return 1;
}
if (hostage_object_is_valid( Cur_object_index ) ) {
CurrentHostageIndex = Objects[Cur_object_index].id;
} else {
Int3(); // Get John! (Object should be valid)
i=hostage_object_is_valid( Cur_object_index ); // For debugging only
}
return 0;
}
// ------------------------------------------------------------------------------------------------------
// Place current object at center of current segment.
int ObjectPlaceObject(void)
{
int old_cur_object_index;
int rval;
if (Cur_object_type == OBJ_PLAYER)
{
int num_players = compute_num_players();
Assert(num_players <= MAX_MULTI_PLAYERS);
if (num_players > MAX_PLAYERS)
editor_status("You just placed a cooperative player object");
if (num_players == MAX_MULTI_PLAYERS) {
editor_status_fmt("Can't place player object. Already %i players.", MAX_MULTI_PLAYERS);
return -1;
}
}
//update_due_to_new_segment();
const auto cur_object_loc = compute_segment_center(Cursegp);
old_cur_object_index = Cur_object_index;
rval = place_object(Cursegp, cur_object_loc, Cur_object_type, Cur_object_id);
if (old_cur_object_index != Cur_object_index)
vobjptr(Cur_object_index)->rtype.pobj_info.tmap_override = -1;
return rval;
}
//find the distance between a segment and a point
static fix compute_dist(const vcsegptr_t seg,const vms_vector &pos)
{
auto delta = compute_segment_center(seg);
vm_vec_sub2(delta,pos);
return vm_vec_mag(delta);
}
// -----------------------------------------------------------------------------------
// Set the player's position from the globals Secret_return_segment and Secret_return_orient.
void set_pos_from_return_segment(void)
{
int plobjnum = Players[Player_num].objnum;
compute_segment_center(&Objects[plobjnum].pos, &Segments[Secret_return_segment]);
obj_relink(plobjnum, Secret_return_segment);
reset_player_object();
Objects[plobjnum].orient = Secret_return_orient;
}
//find the distance between a segment and a point
fix compute_dist(segment *seg,vms_vector *pos)
{
vms_vector delta;
compute_segment_center(&delta,seg);
vm_vec_sub2(&delta,pos);
return vm_vec_mag(&delta);
}
// Save game
// returns 1 if successful
// returns 0 if unsuccessful
int SaveGameData()
{
char Message[200];
if (gamestate_not_restored) {
sprintf( Message, "Game State has not been restored...\nContinue?\n");
if (MessageBox( -2, -2, 2, Message, "NO", "Yes" )==1)
return 0;
}
if (ui_get_filename( game_filename, "*.LVL", "SAVE GAME" )) {
int saved_flag;
vms_vector save_pos = ConsoleObject->pos;
vms_matrix save_orient = ConsoleObject->orient;
int save_segnum = ConsoleObject->segnum;
checkforgamext(game_filename);
if (Perm_player_segnum > Highest_segment_index)
Perm_player_segnum = -1;
if (Perm_player_segnum!=-1) {
if (get_seg_masks(&Perm_player_position,Perm_player_segnum,0).centermask==0) {
ConsoleObject->pos = Perm_player_position;
obj_relink(ConsoleObject-Objects,Perm_player_segnum);
ConsoleObject->orient = Perm_player_orient;
}
else
Perm_player_segnum=-1; //position was bogus
}
saved_flag=save_level(game_filename);
if (Perm_player_segnum!=-1) {
int found_save_segnum;
if (save_segnum > Highest_segment_index)
save_segnum = 0;
ConsoleObject->pos = save_pos;
found_save_segnum = find_point_seg(&save_pos,save_segnum);
if (found_save_segnum == -1) {
compute_segment_center(&save_pos, &(Segments[save_segnum]));
found_save_segnum = save_segnum;
}
obj_relink(ConsoleObject-Objects,found_save_segnum);
ConsoleObject->orient = save_orient;
}
if (saved_flag)
return 0;
mine_changed = 0;
}
return 1;
}
// ------------------------------------------------------------------------------------------------------
int ObjectSetDefault(void)
{
//update_due_to_new_segment();
if (Cur_object_index == -1) {
editor_status("No current object, cannot move.");
return 1;
}
compute_segment_center(&Objects[Cur_object_index].pos, &Segments[Objects[Cur_object_index].segnum]);
Update_flags |= UF_WORLD_CHANGED;
return 1;
}
// ------------------------------------------------------------------------------------------------------
int ObjectSetDefault(void)
{
//update_due_to_new_segment();
if (Cur_object_index == object_none) {
editor_status("No current object, cannot move.");
return 1;
}
const auto &&objp = vobjptr(Cur_object_index);
compute_segment_center(objp->pos, vcsegptr(objp->segnum));
Update_flags |= UF_WORLD_CHANGED;
return 1;
}
// ------------------------------------------------------------------------------------------------------
// Place current object at center of current segment.
int ObjectPlaceObjectTmap(void)
{
int rval, old_cur_object_index;
//update_due_to_new_segment();
const auto cur_object_loc = compute_segment_center(Cursegp);
old_cur_object_index = Cur_object_index;
rval = place_object(Cursegp, cur_object_loc, Cur_object_type, Cur_object_id);
if ((Cur_object_index != old_cur_object_index) && (Objects[Cur_object_index].render_type == RT_POLYOBJ))
Objects[Cur_object_index].rtype.pobj_info.tmap_override = CurrentTexture;
else
editor_status("Unable to apply current texture map to this object.");
return rval;
}
//------------------------------------------------------------
// Turns a segment into a fully charged up fuel center...
void fuelcen_create( segment *segp)
{
segment2 *seg2p = &Segment2s[segp-Segments];
int station_type;
station_type = seg2p->special;
switch( station_type ) {
case SEGMENT_IS_NOTHING:
case SEGMENT_IS_GOAL_BLUE:
case SEGMENT_IS_GOAL_RED:
return;
case SEGMENT_IS_FUELCEN:
case SEGMENT_IS_REPAIRCEN:
case SEGMENT_IS_CONTROLCEN:
case SEGMENT_IS_ROBOTMAKER:
break;
default:
Error( "Invalid station type %d in fuelcen.c\n", station_type );
}
Assert( (seg2p != NULL) );
if ( seg2p == NULL ) return;
Assert( Num_fuelcenters < MAX_NUM_FUELCENS );
Assert( Num_fuelcenters > -1 );
seg2p->value = Num_fuelcenters;
Station[Num_fuelcenters].Type = station_type;
Station[Num_fuelcenters].MaxCapacity = Fuelcen_max_amount;
Station[Num_fuelcenters].Capacity = Station[Num_fuelcenters].MaxCapacity;
Station[Num_fuelcenters].segnum = seg2p-Segment2s;
Station[Num_fuelcenters].Timer = -1;
Station[Num_fuelcenters].Flag = 0;
// Station[Num_fuelcenters].NextRobotType = -1;
// Station[Num_fuelcenters].last_created_obj=NULL;
// Station[Num_fuelcenters].last_created_sig = -1;
compute_segment_center(&Station[Num_fuelcenters].Center, segp);
// if (station_type == SEGMENT_IS_ROBOTMAKER)
// Station[Num_fuelcenters].Capacity = i2f(Difficulty_level + 3);
//mprintf( (0, "Segment %d is assigned to be fuel center %d.\n", Station[Num_fuelcenters].segnum, Num_fuelcenters ));
Num_fuelcenters++;
}
void move_player_2_segment_and_rotate(segment *seg,int side)
{
vms_vector vp;
vms_vector upvec;
static int edgenum=0;
compute_segment_center(&ConsoleObject->pos,seg);
compute_center_point_on_side(&vp,seg,side);
vm_vec_sub2(&vp,&ConsoleObject->pos);
vm_vec_sub(&upvec, &Vertices[Cursegp->verts[Side_to_verts[Curside][edgenum%4]]], &Vertices[Cursegp->verts[Side_to_verts[Curside][(edgenum+3)%4]]]);
edgenum++;
vm_vector_2_matrix(&ConsoleObject->orient,&vp,&upvec,NULL);
// vm_vector_2_matrix(&ConsoleObject->orient,&vp,NULL,NULL);
obj_relink( ConsoleObject-Objects, SEG_PTR_2_NUM(seg) );
}
// ------------------------------------------------------------------------------------------------------
// Place current object at center of current segment.
int ObjectPlaceObject(void)
{
int old_cur_object_index;
int rval;
vms_vector cur_object_loc;
#ifdef SHAREWARE
if (ObjType[Cur_robot_type] == OL_PLAYER) {
int num_players = compute_num_players();
Assert(num_players <= MAX_PLAYERS);
if (num_players == MAX_PLAYERS) {
editor_status("Can't place player object. Already %i players.", MAX_PLAYERS);
return -1;
}
}
#endif
#ifndef SHAREWARE
if (ObjType[Cur_robot_type] == OL_PLAYER) {
int num_players = compute_num_players();
Assert(num_players <= MAX_MULTI_PLAYERS);
if (num_players > MAX_PLAYERS)
editor_status("You just placed a cooperative player object");
if (num_players == MAX_MULTI_PLAYERS) {
editor_status("Can't place player object. Already %i players.", MAX_MULTI_PLAYERS);
return -1;
}
}
#endif
//update_due_to_new_segment();
compute_segment_center(&cur_object_loc, Cursegp);
old_cur_object_index = Cur_object_index;
rval = place_object(Cursegp, &cur_object_loc, Cur_robot_type);
if (old_cur_object_index != Cur_object_index)
Objects[Cur_object_index].rtype.pobj_info.tmap_override = -1;
return rval;
}
//------------------------------------------------------------
// Trigger (enable) the materialization center in segment segnum
void trigger_matcen(const vsegptridx_t segnum)
{
const auto &segp = segnum;
FuelCenter *robotcen;
Assert(segp->special == SEGMENT_IS_ROBOTMAKER);
Assert(segp->matcen_num < Num_fuelcenters);
Assert((segp->matcen_num >= 0) && (segp->matcen_num <= Highest_segment_index));
robotcen = &Station[RobotCenters[segp->matcen_num].fuelcen_num];
if (robotcen->Enabled == 1)
return;
if (!robotcen->Lives)
return;
#if defined(DXX_BUILD_DESCENT_II)
// MK: 11/18/95, At insane, matcens work forever!
if (Difficulty_level+1 < NDL)
#endif
robotcen->Lives--;
robotcen->Timer = F1_0*1000; // Make sure the first robot gets emitted right away.
robotcen->Enabled = 1; // Say this center is enabled, it can create robots.
robotcen->Capacity = i2f(Difficulty_level + 3);
robotcen->Disable_time = MATCEN_LIFE;
// Create a bright object in the segment.
auto pos = compute_segment_center(segp);
const auto delta = vm_vec_sub(Vertices[segnum->verts[0]], pos);
vm_vec_scale_add2(pos, delta, F1_0/2);
auto objnum = obj_create( OBJ_LIGHT, 0, segnum, pos, NULL, 0, CT_LIGHT, MT_NONE, RT_NONE );
if (objnum != object_none) {
objnum->lifeleft = MATCEN_LIFE;
objnum->ctype.light_info.intensity = i2f(8); // Light cast by a fuelcen.
} else {
Int3();
}
}
//------------------------------------------------------------
// Adds a matcen that already is a special type into the Station array.
// This function is separate from other fuelcens because we don't want values reset.
void matcen_create( segment *segp)
{
segment2 *seg2p = &Segment2s[segp-Segments];
int station_type = seg2p->special;
Assert( (seg2p != NULL) );
Assert(station_type == SEGMENT_IS_ROBOTMAKER);
if ( seg2p == NULL ) return;
Assert( Num_fuelcenters < MAX_NUM_FUELCENS );
Assert( Num_fuelcenters > -1 );
seg2p->value = Num_fuelcenters;
Station[Num_fuelcenters].Type = station_type;
Station[Num_fuelcenters].Capacity = i2f(Difficulty_level + 3);
Station[Num_fuelcenters].MaxCapacity = Station[Num_fuelcenters].Capacity;
Station[Num_fuelcenters].segnum = seg2p-Segment2s;
Station[Num_fuelcenters].Timer = -1;
Station[Num_fuelcenters].Flag = 0;
// Station[Num_fuelcenters].NextRobotType = -1;
// Station[Num_fuelcenters].last_created_obj=NULL;
// Station[Num_fuelcenters].last_created_sig = -1;
compute_segment_center(&Station[Num_fuelcenters].Center, &Segments[seg2p-Segment2s] );
seg2p->matcen_num = Num_robot_centers;
Num_robot_centers++;
RobotCenters[seg2p->matcen_num].hit_points = MATCEN_HP_DEFAULT;
RobotCenters[seg2p->matcen_num].interval = MATCEN_INTERVAL_DEFAULT;
RobotCenters[seg2p->matcen_num].segnum = seg2p-Segment2s;
RobotCenters[seg2p->matcen_num].fuelcen_num = Num_fuelcenters;
//mprintf( (0, "Segment %d is assigned to be fuel center %d.\n", Station[Num_fuelcenters].segnum, Num_fuelcenters ));
Num_fuelcenters++;
}
static int PlaceHostage() {
int ctype,i;
//update_due_to_new_segment();
auto &Vertices = LevelSharedVertexState.get_vertices();
auto &vcvertptr = Vertices.vcptr;
const auto cur_object_loc = compute_segment_center(vcvertptr, Cursegp);
ctype = -1;
for (i=0; i<Num_total_object_types; i++ ) {
if (ObjType[i] == OL_HOSTAGE ) {
ctype = i;
break;
}
}
Assert( ctype != -1 );
if (place_object(Cursegp, cur_object_loc, ctype, 0 )==0) {
Int3(); // Debug below
i=place_object(Cursegp, cur_object_loc, ctype, 0 );
return 1;
}
return 0;
}
//called for each level to load & setup the exit sequence
load_endlevel_data(int level_num)
{
char filename[13];
char line[LINE_LEN],*p;
CFILE *ifile;
int var,segnum,sidenum;
int exit_side, i;
int have_binary = 0;
endlevel_data_loaded = 0; //not loaded yet
try_again:
;
if (level_num<0) //secret level
strcpy(filename,Secret_level_names[-level_num-1]);
else //normal level
strcpy(filename,Level_names[level_num-1]);
if (!convert_ext(filename,"END"))
return;
ifile = cfopen(filename,"rb");
if (!ifile) {
convert_ext(filename,"TXB");
ifile = cfopen(filename,"rb");
if (!ifile)
if (level_num==1) {
return; //abort
//Error("Cannot load file text of binary version of <%s>",filename);
}
else {
level_num = 1;
goto try_again;
}
have_binary = 1;
}
//ok...this parser is pretty simple. It ignores comments, but
//everything else must be in the right place
var = 0;
while (cfgets(line,LINE_LEN,ifile)) {
if (have_binary) {
for (i = 0; i < strlen(line) - 1; i++) {
encode_rotate_left(&(line[i]));
line[i] = line[i] ^ BITMAP_TBL_XOR;
encode_rotate_left(&(line[i]));
}
p = line;
}
if ((p=strchr(line,';'))!=NULL)
*p = 0; //cut off comment
for (p=line+strlen(line)-1;p>line && isspace(*p);*p--=0);
for (p=line;isspace(*p);p++);
if (!*p) //empty line
continue;
switch (var) {
case 0: { //ground terrain
int iff_error;
ubyte pal[768];
if (terrain_bm_instance.bm_data)
free(terrain_bm_instance.bm_data);
iff_error = iff_read_bitmap(p,&terrain_bm_instance,BM_LINEAR,pal);
if (iff_error != IFF_NO_ERROR) {
mprintf((1, "File %s - IFF error: %s",p,iff_errormsg(iff_error)));
Error("File %s - IFF error: %s",p,iff_errormsg(iff_error));
}
terrain_bitmap = &terrain_bm_instance;
gr_remap_bitmap_good( terrain_bitmap, pal, iff_transparent_color, -1);
break;
}
case 1: //height map
load_terrain(p);
break;
case 2:
sscanf(p,"%d,%d",&exit_point_bmx,&exit_point_bmy);
break;
case 3: //exit heading
exit_angles.h = i2f(atoi(p))/360;
break;
case 4: { //planet bitmap
int iff_error;
ubyte pal[768];
if (satellite_bm_instance.bm_data)
free(satellite_bm_instance.bm_data);
iff_error = iff_read_bitmap(p,&satellite_bm_instance,BM_LINEAR,pal);
if (iff_error != IFF_NO_ERROR) {
mprintf((1, "File %s - IFF error: %s",p,iff_errormsg(iff_error)));
Error("File %s - IFF error: %s",p,iff_errormsg(iff_error));
}
satellite_bitmap = &satellite_bm_instance;
gr_remap_bitmap_good( satellite_bitmap, pal, iff_transparent_color, -1);
break;
}
case 5: //earth pos
case 7: { //station pos
vms_matrix tm;
vms_angvec ta;
int pitch,head;
sscanf(p,"%d,%d",&head,&pitch);
ta.h = i2f(head)/360;
ta.p = -i2f(pitch)/360;
ta.b = 0;
vm_angles_2_matrix(&tm,&ta);
if (var==5)
satellite_pos = tm.fvec;
//vm_vec_copy_scale(&satellite_pos,&tm.fvec,SATELLITE_DIST);
else
station_pos = tm.fvec;
break;
}
case 6: //planet size
satellite_size = i2f(atoi(p));
break;
}
var++;
}
Assert(var == NUM_VARS);
// OK, now the data is loaded. Initialize everything
//find the exit sequence by searching all segments for a side with
//children == -2
for (segnum=0,exit_segnum=-1;exit_segnum==-1 && segnum<=Highest_segment_index;segnum++)
for (sidenum=0;sidenum<6;sidenum++)
if (Segments[segnum].children[sidenum] == -2) {
exit_segnum = segnum;
exit_side = sidenum;
break;
}
Assert(exit_segnum!=-1);
compute_segment_center(&mine_exit_point,&Segments[exit_segnum]);
extract_orient_from_segment(&mine_exit_orient,&Segments[exit_segnum]);
compute_center_point_on_side(&mine_side_exit_point,&Segments[exit_segnum],exit_side);
vm_vec_scale_add(&mine_ground_exit_point,&mine_exit_point,&mine_exit_orient.uvec,-i2f(20));
//compute orientation of surface
{
vms_vector tv;
vms_matrix exit_orient,tm;
vm_angles_2_matrix(&exit_orient,&exit_angles);
vm_transpose_matrix(&exit_orient);
vm_matrix_x_matrix(&surface_orient,&mine_exit_orient,&exit_orient);
vm_copy_transpose_matrix(&tm,&surface_orient);
vm_vec_rotate(&tv,&station_pos,&tm);
vm_vec_scale_add(&station_pos,&mine_exit_point,&tv,STATION_DIST);
vm_vec_rotate(&tv,&satellite_pos,&tm);
vm_vec_scale_add(&satellite_pos,&mine_exit_point,&tv,SATELLITE_DIST);
vm_vector_2_matrix(&tm,&tv,&surface_orient.uvec,NULL);
vm_vec_copy_scale(&satellite_upvec,&tm.uvec,SATELLITE_HEIGHT);
}
cfclose(ifile);
endlevel_data_loaded = 1;
}
do_endlevel_flythrough(int n)
{
object *obj;
segment *pseg;
int old_player_seg;
flydata = &fly_objects[n];
obj = flydata->obj;
old_player_seg = obj->segnum;
//move the player for this frame
if (!flydata->first_time) {
vm_vec_scale_add2(&obj->pos,&flydata->step,FrameTime);
angvec_add2_scale(&flydata->angles,&flydata->angstep,FrameTime);
vm_angles_2_matrix(&obj->orient,&flydata->angles);
}
//check new player seg
update_object_seg(obj);
pseg = &Segments[obj->segnum];
if (flydata->first_time || obj->segnum != old_player_seg) { //moved into new seg
vms_vector curcenter,nextcenter;
fix step_size,seg_time;
short entry_side,exit_side; //what sides we entry and leave through
vms_vector dest_point; //where we are heading (center of exit_side)
vms_angvec dest_angles; //where we want to be pointing
vms_matrix dest_orient;
int up_side;
//find new exit side
if (!flydata->first_time) {
entry_side = matt_find_connect_side(obj->segnum,old_player_seg);
exit_side = Side_opposite[entry_side];
}
if (flydata->first_time || entry_side==-1 || pseg->children[exit_side]==-1)
exit_side = find_exit_side(obj);
{ //find closest side to align to
fix d,largest_d=-f1_0;
int i;
for (i=0;i<6;i++) {
#ifdef COMPACT_SEGS
vms_vector v1;
get_side_normal(pseg, i, 0, &v1 );
d = vm_vec_dot(&v1,&flydata->obj->orient.uvec);
#else
d = vm_vec_dot(&pseg->sides[i].normals[0],&flydata->obj->orient.uvec);
#endif
if (d > largest_d) {largest_d = d; up_side=i;}
}
}
//update target point & angles
compute_center_point_on_side(&dest_point,pseg,exit_side);
//update target point and movement points
//offset object sideways
if (flydata->offset_frac) {
int s0=-1,s1,i;
vms_vector s0p,s1p;
fix dist;
for (i=0;i<6;i++)
if (i!=entry_side && i!=exit_side && i!=up_side && i!=Side_opposite[up_side])
if (s0==-1)
s0 = i;
else
s1 = i;
compute_center_point_on_side(&s0p,pseg,s0);
compute_center_point_on_side(&s1p,pseg,s1);
dist = fixmul(vm_vec_dist(&s0p,&s1p),flydata->offset_frac);
if (dist-flydata->offset_dist > MAX_SLIDE_PER_SEGMENT)
dist = flydata->offset_dist + MAX_SLIDE_PER_SEGMENT;
flydata->offset_dist = dist;
vm_vec_scale_add2(&dest_point,&obj->orient.rvec,dist);
}
vm_vec_sub(&flydata->step,&dest_point,&obj->pos);
step_size = vm_vec_normalize_quick(&flydata->step);
vm_vec_scale(&flydata->step,flydata->speed);
compute_segment_center(&curcenter,pseg);
compute_segment_center(&nextcenter,&Segments[pseg->children[exit_side]]);
vm_vec_sub(&flydata->headvec,&nextcenter,&curcenter);
#ifdef COMPACT_SEGS
{
vms_vector _v1;
get_side_normal(pseg, up_side, 0, &_v1 );
vm_vector_2_matrix(&dest_orient,&flydata->headvec,&_v1,NULL);
}
#else
vm_vector_2_matrix(&dest_orient,&flydata->headvec,&pseg->sides[up_side].normals[0],NULL);
#endif
vm_extract_angles_matrix(&dest_angles,&dest_orient);
if (flydata->first_time)
vm_extract_angles_matrix(&flydata->angles,&obj->orient);
seg_time = fixdiv(step_size,flydata->speed); //how long through seg
if (seg_time) {
flydata->angstep.x = max(-MAX_ANGSTEP,min(MAX_ANGSTEP,fixdiv(delta_ang(flydata->angles.p,dest_angles.p),seg_time)));
flydata->angstep.z = max(-MAX_ANGSTEP,min(MAX_ANGSTEP,fixdiv(delta_ang(flydata->angles.b,dest_angles.b),seg_time)));
flydata->angstep.y = max(-MAX_ANGSTEP,min(MAX_ANGSTEP,fixdiv(delta_ang(flydata->angles.h,dest_angles.h),seg_time)));
}
else {
flydata->angles = dest_angles;
flydata->angstep.x = flydata->angstep.y = flydata->angstep.z = 0;
}
}
flydata->first_time=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
}
// -----------------------------------------------------------------------------------------------------------
//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 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;
}
}
}
void objfly_move_to_new_segment( object * obj, short newseg, int first_time )
{
segment *pseg;
int old_object_seg = obj->segnum;
if ( newseg != obj->segnum )
obj_relink(obj-Objects, newseg );
pseg = &Segments[obj->segnum];
if ( first_time || obj->segnum != old_object_seg) { //moved into new seg
vms_vector curcenter,nextcenter;
fix step_size,seg_time;
short entry_side,exit_side; //what sides we entry and leave through
vms_vector dest_point; //where we are heading (center of exit_side)
vms_angvec dest_angles; //where we want to be pointing
//find new exit side
if ( !first_time ) {
entry_side = matt_find_connect_side(obj->segnum,old_object_seg);
exit_side = Side_opposite[entry_side];
}
//if (first_time) obj->fly_info.ft_mode = FP_FORWARD;
if (first_time || entry_side==-1 || (pseg->children[exit_side]==-1) || (obj->fly_info.ft_mode!=FP_FORWARD) ) {
int i;
vms_vector prefvec,segcenter,sidevec;
fix best_val=-f2_0;
int best_side;
//find exit side
if (obj->fly_info.ft_mode == FP_FORWARD) {
if (first_time)
prefvec = obj->orient.fvec;
else
prefvec = obj->fly_info.heading;
vm_vec_normalize(&prefvec);
}
else
prefvec = obj->orient.vecs[obj->fly_info.ft_mode%3];
if (obj->fly_info.ft_mode >= 3) {prefvec.x = -prefvec.x; prefvec.y = -prefvec.y; prefvec.z = -prefvec.z;}
compute_segment_center(&segcenter,pseg);
best_side=-1;
for (i=MAX_SIDES_PER_SEGMENT;--i >= 0;) {
fix d;
if (pseg->children[i]!=-1) {
compute_center_point_on_side(&sidevec,pseg,i);
vm_vec_sub2(&sidevec,&segcenter);
vm_vec_normalize(&sidevec);
d = vm_vec_dotprod(&sidevec,&prefvec);
if (labs(d) < MIN_D) d=0;
if (d > best_val || (d==best_val && i==exit_side)) {best_val=d; best_side=i;}
}
}
if (best_val > 0) obj->fly_info.ft_mode = FP_FORWARD;
Assert(best_side!=-1);
exit_side = best_side;
}
//update target point & angles
compute_center_point_on_side(&dest_point,pseg,exit_side);
//update target point and movement points
vm_vec_sub(&obj->phys_info.velocity,&dest_point,&obj->pos);
step_size = vm_vec_normalize(&obj->phys_info.velocity);
vm_vec_scale(&obj->phys_info.velocity, obj->phys_info.speed);
compute_segment_center(&curcenter,pseg);
compute_segment_center(&nextcenter,&Segments[pseg->children[exit_side]]);
vm_vec_sub(&obj->fly_info.heading,&nextcenter,&curcenter);
angles_from_vector(&dest_angles,&obj->fly_info.heading); //extract angles
if (first_time)
angles_from_vector(&obj->phys_info.rotvel,&obj->orient.fvec);
seg_time = fixdiv(step_size,obj->phys_info.speed); //how long through seg
if (seg_time) {
obj->fly_info.angle_step.p = fixdiv(delta_ang(obj->phys_info.rotvel.p,dest_angles.p),seg_time);
obj->fly_info.angle_step.b = fixdiv(delta_ang(obj->phys_info.rotvel.b,dest_angles.b),seg_time);
obj->fly_info.angle_step.h = fixdiv(delta_ang(obj->phys_info.rotvel.h,dest_angles.h),seg_time);
}
else {
obj->phys_info.rotvel = dest_angles;
obj->fly_info.angle_step.p = obj->fly_info.angle_step.b = obj->fly_info.angle_step.h = 0;
}
}
}
// -----------------------------------------------------------------------------
// Save game
int save_level_sub(char * filename, int compiled_version)
{
PHYSFS_file * SaveFile;
char temp_filename[PATH_MAX];
int minedata_offset=0,gamedata_offset=0,hostagetext_offset=0;
// if ( !compiled_version )
{
write_game_text_file(filename);
if (Errors_in_mine) {
if (is_real_level(filename)) {
char ErrorMessage[200];
sprintf( ErrorMessage, "Warning: %i errors in this mine!\n", Errors_in_mine );
gr_palette_load(gr_palette);
if (nm_messagebox( NULL, 2, "Cancel Save", "Save", ErrorMessage )!=1) {
return 1;
}
}
}
// change_filename_extension(temp_filename,filename,".LVL");
}
// else
{
change_filename_extension(temp_filename, filename, ".RDL");
}
SaveFile = PHYSFSX_openWriteBuffered(temp_filename);
if (!SaveFile)
{
char ErrorMessage[256];
snprintf( ErrorMessage, sizeof(ErrorMessage), "ERROR: Cannot write to '%s'.", temp_filename);
gr_palette_load(gr_palette);
nm_messagebox( NULL, 1, "Ok", ErrorMessage );
return 1;
}
if (Current_level_name[0] == 0)
strcpy(Current_level_name,"Untitled");
clear_transient_objects(1); //1 means clear proximity bombs
compress_objects(); //after this, Highest_object_index == num objects
//make sure player is in a segment
if (update_object_seg(&Objects[Players[0].objnum]) == 0) {
if (ConsoleObject->segnum > Highest_segment_index)
ConsoleObject->segnum = 0;
compute_segment_center(&ConsoleObject->pos,&(Segments[ConsoleObject->segnum]));
}
fix_object_segs();
//Write the header
PHYSFS_writeSLE32(SaveFile, MAKE_SIG('P','L','V','L'));
PHYSFS_writeSLE32(SaveFile, Gamesave_current_version);
//save placeholders
PHYSFS_writeSLE32(SaveFile, minedata_offset);
PHYSFS_writeSLE32(SaveFile, gamedata_offset);
PHYSFS_writeSLE32(SaveFile, hostagetext_offset);
//Now write the damn data
minedata_offset = PHYSFS_tell(SaveFile);
#if 0 // only save compiled mine data
if ( !compiled_version )
save_mine_data(SaveFile);
else
#endif
save_mine_data_compiled(SaveFile);
gamedata_offset = PHYSFS_tell(SaveFile);
save_game_data(SaveFile);
hostagetext_offset = PHYSFS_tell(SaveFile);
PHYSFS_seek(SaveFile, sizeof(int) + sizeof(Gamesave_current_version));
PHYSFS_writeSLE32(SaveFile, minedata_offset);
PHYSFS_writeSLE32(SaveFile, gamedata_offset);
PHYSFS_writeSLE32(SaveFile, hostagetext_offset);
//==================== CLOSE THE FILE =============================
PHYSFS_close(SaveFile);
// if ( !compiled_version )
{
if (EditorWindow)
editor_status_fmt("Saved mine %s, \"%s\"",filename,Current_level_name);
}
return 0;
}
do_flythrough(object *obj,int first_time) //set true if init
{
segment *pseg;
int old_player_seg = obj->segnum;
if (first_time) {
//vms_vector zero_vector = {0,0,0};
obj->control_type = CT_FLYTHROUGH;
//obj->fly_info.angle_step.p = 0;
//obj->fly_info.angle_step.b = 0;
//obj->fly_info.angle_step.h = 0;
//obj->fly_info.heading = zero_vector;
}
//move the player for this frame
if (!first_time) {
//vms_vector tempv;
//fix rot_step;
vm_vec_scale_add2(&obj->pos,&player_step,FrameTime);
angvec_add2_scale(&player_angles,&player_angstep,FrameTime);
vm_angles_2_matrix(&obj->orient,&player_angles);
}
//check new player seg
update_object_seg(obj);
pseg = &Segments[obj->segnum];
if (first_time || obj->segnum != old_player_seg) { //moved into new seg
vms_vector curcenter,nextcenter;
fix step_size,seg_time;
short entry_side,exit_side; //what sides we entry and leave through
vms_vector dest_point; //where we are heading (center of exit_side)
vms_angvec dest_angles; //where we want to be pointing
//find new exit side
if (!first_time) {
entry_side = matt_find_connect_side(obj->segnum,old_player_seg);
exit_side = Side_opposite[entry_side];
}
if (first_time) ft_preference = FP_FORWARD;
if (first_time || entry_side==-1 || pseg->children[exit_side]==-1 || ft_preference!=FP_FORWARD) {
int i;
vms_vector prefvec,segcenter,sidevec;
fix best_val=-f2_0;
int best_side;
//find exit side
if (ft_preference == FP_FORWARD) {
if (first_time) prefvec = obj->orient.fvec;
else prefvec = headvec;
vm_vec_normalize(&prefvec);
}
else
prefvec = obj->orient.vecs[ft_preference%3];
if (ft_preference >= 3) {prefvec.x = -prefvec.x; prefvec.y = -prefvec.y; prefvec.z = -prefvec.z;}
compute_segment_center(&segcenter,pseg);
best_side=-1;
for (i=MAX_SIDES_PER_SEGMENT;--i >= 0;) {
fix d;
if (pseg->children[i]!=-1) {
compute_center_point_on_side(&sidevec,pseg,i);
//vm_vec_sub2(&sidevec,&segcenter);
//vm_vec_normalize(&sidevec);
vm_vec_normalized_dir(&sidevec,&sidevec,&segcenter);
d = vm_vec_dotprod(&sidevec,&prefvec);
if (labs(d) < MIN_D) d=0;
if (d > best_val || (d==best_val && i==exit_side)) {best_val=d; best_side=i;}
}
}
if (best_val > 0) ft_preference = FP_FORWARD;
Assert(best_side!=-1);
exit_side = best_side;
}
//update target point & angles
compute_center_point_on_side(&dest_point,pseg,exit_side);
//update target point and movement points
vm_vec_sub(&player_step,&dest_point,&obj->pos);
step_size = vm_vec_normalize(&player_step);
vm_vec_scale(&player_step,player_speed);
compute_segment_center(&curcenter,pseg);
compute_segment_center(&nextcenter,&Segments[pseg->children[exit_side]]);
vm_vec_sub(&headvec,&nextcenter,&curcenter);
//angles_from_vector(&dest_angles,&headvec); //extract angles
vm_extract_angles_vector(&dest_angles,&headvec); //extract angles
if (first_time)
//angles_from_vector(&player_angles,&obj->orient.fvec);
vm_extract_angles_vector(&player_angles,&obj->orient.fvec);
seg_time = fixdiv(step_size,player_speed); //how long through seg
if (seg_time) {
player_angstep.p = fixdiv(delta_ang(player_angles.p,dest_angles.p),seg_time);
player_angstep.b = fixdiv(delta_ang(player_angles.b,dest_angles.b),seg_time);
player_angstep.h = fixdiv(delta_ang(player_angles.h,dest_angles.h),seg_time);
}
else {
player_angles = dest_angles;
player_angstep.p = player_angstep.b = player_angstep.h = 0;
}
}
}