// -----------------------------------------------------------------------------------------------------------
// Simulate a physics object for this frame. Used by the editor. The difference between
// this function and physics_sim() is that this one uses a heading change to rotate around
// the universal Y axis, rather than the local orientation's Y axis. Banking is also ignored.
void physics_sim_editor(vec3d *position, matrix * orient, physics_info * pi, float sim_time )
{
physics_sim_vel(position, pi, sim_time, orient);
physics_sim_rot_editor(orient, pi, sim_time);
pi->speed = vm_vec_mag_quick(&pi->vel);
pi->fspeed = vm_vec_dot(&orient->vec.fvec, &pi->vel); // instead of vector magnitude -- use only forward vector since we are only interested in forward velocity
}
void radar_plot_object( object * objp, int hue )
{
ubyte flags;
g3s_point pos;
int color;
fix dist, rscale, zdist, distance;
int xpos, ypos;
flags = g3_rotate_point(&pos,&objp->pos);
dist = vm_vec_mag_quick(&pos.p3_vec);
// Make distance be 1.0 to 0.0, where 0.0 is maximum segments away;
if ( dist >= Radar_farthest_dist ) return;
distance = F1_0 - fixdiv( dist, Radar_farthest_dist );
color = f2i( distance*31 );
zdist = fix_sqrt( fixmul(pos.p3_x,pos.p3_x)+fixmul(pos.p3_y,pos.p3_y) );
if (zdist < 100 ) return; // Watch for divide overflow
rscale = fix_acos( fixdiv(pos.p3_z,dist) )/2;
xpos = f2i(fixmul( rox+fixmul(fixdiv(pos.p3_x,zdist),rscale), radx));
ypos = f2i(fixmul( roy-fixmul(fixdiv(pos.p3_y,zdist),rscale), rady));
if ( xpos < Hostage_monitor_x ) xpos = Hostage_monitor_x;
if ( ypos < Hostage_monitor_y ) ypos = Hostage_monitor_y;
if ( xpos > Hostage_monitor_x+Hostage_monitor_size-1 ) xpos = Hostage_monitor_x+Hostage_monitor_size-1;
if ( ypos > Hostage_monitor_y+Hostage_monitor_size-1 ) ypos = Hostage_monitor_y+Hostage_monitor_size-1;
Blips[N_blips].c = gr_fade_table[hue+color*256];
Blips[N_blips].x = xpos; Blips[N_blips].y = ypos;
N_blips++;
}
//Compute the lighting from the headlight for a given vertex on a face.
//Takes:
// point - the 3d coords of the point
// face_light - a scale factor derived from the surface normal of the face
//If no surface normal effect is wanted, pass F1_0 for face_light
fix compute_headlight_light(vms_vector *point,fix face_light)
{
fix light;
light = Beam_brightness;
if (light) { //if no beam, don't bother with the rest of this
fix point_dist;
if (face_light < 0)
face_light = 0;
point_dist = vm_vec_mag_quick(point);
//note: beam scale not used if !use_beam
if (point_dist >= MAX_DIST)
light = 0;
else {
fix dist_scale,temp_lightval;
dist_scale = (MAX_DIST - point_dist) >> MAX_DIST_LOG;
temp_lightval = f1_0/4 + face_light/2;
light = Beam_brightness;
if (use_beam) {
fix beam_scale;
beam_scale = fixdiv(point->z,point_dist);
beam_scale = fixmul(beam_scale,beam_scale); //square it
light = fixmul(light,beam_scale);
}
light = fixmul(light,fixmul(dist_scale,temp_lightval));
}
}
return light;
}
void Tactile_apply_force (vms_vector *force_vec,vms_matrix *orient)
{
int feedforce;
fix feedmag,tempfix=0;
vms_angvec feedang;
vms_vector feedvec;
unsigned short tempangle;
int realangle;
if (TactileStick==TACTILE_IMMERSION)
{
vm_vec_rotate (&feedvec,force_vec,orient);
vm_extract_angles_vector(&feedang,&feedvec);
feedmag=vm_vec_mag_quick (force_vec);
feedforce=f2i(fixmuldiv (feedmag,i2f(100),MAX_FORCE));
mprintf ((0,"feedforce=%d\n",feedforce));
if (feedforce<0)
feedforce=0;
if (feedforce>100)
feedforce=100;
tempangle=(unsigned short)feedang.h;
tempfix=tempangle;
realangle=f2i(fixmul(tempfix,i2f(360)));
realangle-=180;
if (realangle<0)
realangle+=360;
Jolt (feedforce,realangle,feedforce*7);
}
}
// get the total AWACS level for target to viewer
// < 0.0f : untargetable
// 0.0 - 1.0f : marginally targetable
// >= 1.0f : fully targetable as normal
float awacs_get_level(object *target, ship *viewer, int use_awacs)
{
Assert(target); // Goober5000
Assert(viewer); // Goober5000
vec3d dist_vec, subsys_pos;
float closest = 0.0f;
float test;
int closest_index = -1;
int idx, stealth_ship = 0, check_huge_ship = 0, friendly_stealth_invisible = 0;
ship *shipp = NULL;
ship_info *sip = NULL;
int viewer_has_primitive_sensors = (viewer->flags[Ship::Ship_Flags::Primitive_sensors]);
// calc distance from viewer to target
vm_vec_sub(&dist_vec, &target->pos, &Objects[viewer->objnum].pos);
int distance = (int) vm_vec_mag_quick(&dist_vec);
// redone by Goober5000
#define ALWAYS_TARGETABLE 1.5f
#define MARGINALLY_TARGETABLE 0.5f
#define UNTARGETABLE -1.0f
#define FULLY_TARGETABLE (viewer_has_primitive_sensors ? ((distance < viewer->primitive_sensor_range) ? MARGINALLY_TARGETABLE : UNTARGETABLE) : ALWAYS_TARGETABLE)
// if the viewer is me, and I'm a multiplayer observer, its always viewable
if ((viewer == Player_ship) && (Game_mode & GM_MULTIPLAYER) && (Net_player != NULL) && MULTI_OBSERVER(Net_players[MY_NET_PLAYER_NUM]))
return ALWAYS_TARGETABLE;
// check the targeting threshold
if ((Hud_max_targeting_range > 0) && (distance > Hud_max_targeting_range)) {
return UNTARGETABLE;
}
if (target->type == OBJ_SHIP) {
// if no valid target then bail as never viewable
if (target->instance < 0)
return UNTARGETABLE;
// Goober5000
shipp = &Ships[target->instance];
sip = &Ship_info[shipp->ship_info_index];
stealth_ship = (shipp->flags[Ship::Ship_Flags::Stealth]);
friendly_stealth_invisible = (shipp->flags[Ship::Ship_Flags::Friendly_stealth_invis]);
check_huge_ship = (sip->is_huge_ship());
}
int nebula_enabled = (The_mission.flags[Mission::Mission_Flags::Fullneb]);
// ships on the same team are always viewable
if ((target->type == OBJ_SHIP) && (shipp->team == viewer->team))
{
// not necessarily now! -- Goober5000
if ( !(stealth_ship && friendly_stealth_invisible) )
return FULLY_TARGETABLE;
}
// check for a tagged ship. TAG'd ships are _always_ visible
if (target->type == OBJ_SHIP)
{
Assert( shipp != NULL );
if (shipp->tag_left > 0.0f || shipp->level2_tag_left > 0.0f)
return FULLY_TARGETABLE;
}
// only check for Awacs if stealth ship or Nebula mission
// determine the closest awacs on our team
if ((stealth_ship || nebula_enabled) && use_awacs)
{
for (idx=0; idx<Awacs_count; idx++)
{
// if not on the same team as the viewer
if (Awacs[idx].team != viewer->team)
continue;
// if this awacs source has somehow become invalid
if (Awacs[idx].objp->type != OBJ_SHIP)
continue;
// get the subsystem position
if (!get_subsystem_pos(&subsys_pos, Awacs[idx].objp, Awacs[idx].subsys))
continue;
// determine if its the closest
// special case for HUGE_SHIPS
if (check_huge_ship)
{
// check if inside bbox expanded by awacs_radius
if (check_world_pt_in_expanded_ship_bbox(&subsys_pos, target, Awacs[idx].subsys->awacs_radius))
{
closest_index = idx;
break;
}
}
// not a huge ship
else
{
// get distance from Subsys to target
vm_vec_sub(&dist_vec, &subsys_pos, &target->pos);
test = vm_vec_mag_quick(&dist_vec);
if (test > Awacs[idx].subsys->awacs_radius)
continue;
if ((closest_index == -1) || (test < closest))
{
closest = test;
closest_index = idx;
break;
}
}
}
}
// if this is a stealth ship
if (stealth_ship)
{
// if the ship is within range of an awacs
if (closest_index >= 0)
{
// if the nebula effect is active, stealth ships are only partially targetable
if (nebula_enabled)
return MARGINALLY_TARGETABLE;
// otherwise it's targetable
return FULLY_TARGETABLE;
}
// otherwise its completely hidden
else
{
return UNTARGETABLE;
}
}
// all other ships
else
{
// if this is not a nebula mission, its always targetable
if (!nebula_enabled)
return FULLY_TARGETABLE;
// if the ship is within range of an awacs, its fully targetable
if (closest_index >= 0)
return FULLY_TARGETABLE;
// fully targetable at half the nebula value
// modify distance by species
float scan_nebula_range = Neb2_awacs * Species_info[Ship_info[viewer->ship_info_index].species].awacs_multiplier;
// special case for huge ship - check inside expanded bounding boxes
if (check_huge_ship)
{
if (check_world_pt_in_expanded_ship_bbox(&Objects[viewer->objnum].pos, target, scan_nebula_range))
{
if (check_world_pt_in_expanded_ship_bbox(&Objects[viewer->objnum].pos, target, 0.5f * scan_nebula_range))
return FULLY_TARGETABLE;
return MARGINALLY_TARGETABLE;
}
}
// otherwise check straight up nebula numbers
else
{
vm_vec_sub(&dist_vec, &target->pos, &Objects[viewer->objnum].pos);
test = vm_vec_mag_quick(&dist_vec);
if (test < (0.5f * scan_nebula_range))
return FULLY_TARGETABLE;
else if (test < scan_nebula_range)
return MARGINALLY_TARGETABLE;
}
// untargetable at longer range
return UNTARGETABLE;
}
}
// ------------------------------------------------------------------
// swarm_update_direction()
//
// Check if we want to update the direction of a swarm missile.
//
void swarm_update_direction(object *objp, float frametime)
{
weapon_info *wip;
weapon *wp;
object *hobjp;
swarm_info *swarmp;
vec3d obj_to_target;
float vel, target_dist, radius, missile_speed, missile_dist;
physics_info *pi;
Assert(objp->instance >= 0 && objp->instance < MAX_WEAPONS);
wp = &Weapons[objp->instance];
if (wp->swarm_index == -1) {
return;
}
wip = &Weapon_info[wp->weapon_info_index];
hobjp = wp->homing_object;
pi = &Objects[wp->objnum].phys_info;
swarmp = &Swarm_missiles[wp->swarm_index];
// check if homing is lost.. if it is then get a new path to move swarm missile along
if ( swarmp->homing_objnum != -1 && hobjp == &obj_used_list ) {
swarmp->change_timestamp = 1;
swarmp->path_num = -1;
swarmp->homing_objnum = -1;
}
if ( hobjp != &obj_used_list ) {
swarmp->homing_objnum = OBJ_INDEX(hobjp);
}
if ( timestamp_elapsed(swarmp->change_timestamp) ) {
if ( swarmp->path_num == -1 ) {
if ( Objects[objp->parent].type != OBJ_SHIP ) {
//AL: parent ship died... so just pick some random paths
swarmp->path_num = myrand()%4;
} else {
ship *parent_shipp;
parent_shipp = &Ships[Objects[objp->parent].instance];
swarmp->path_num = (parent_shipp->next_swarm_path++)%4;
if ( parent_shipp->next_swarm_path%4 == 0 ) {
swarmp->flags ^= SWARM_POSITIVE_PATH;
}
}
vm_vec_scale_add(&swarmp->original_target, &objp->pos, &objp->orient.vec.fvec, SWARM_CONE_LENGTH);
swarmp->circle_rvec = objp->orient.vec.rvec;
swarmp->circle_uvec = objp->orient.vec.uvec;
swarmp->change_count = 1;
swarmp->change_time = fl2i(SWARM_CHANGE_DIR_TIME + SWARM_TIME_VARIANCE*(frand() - 0.5f) * 2);
vm_vec_zero(&swarmp->last_offset);
missile_speed = pi->speed;
missile_dist = missile_speed * swarmp->change_time/1000.0f;
if ( missile_dist < SWARM_DIST_OFFSET ) {
missile_dist=i2fl(SWARM_DIST_OFFSET);
}
swarmp->angle_offset = (float)(asin(SWARM_DIST_OFFSET / missile_dist));
Assert(!_isnan(swarmp->angle_offset) );
}
swarmp->change_timestamp = timestamp(swarmp->change_time);
// check if swarm missile is homing, if so need to calculate a new target pos to turn towards
if ( hobjp != &obj_used_list && f2fl(Missiontime - wp->creation_time) > 0.5f && ( f2fl(Missiontime - wp->creation_time) > wip->free_flight_time ) ) {
swarmp->original_target = wp->homing_pos;
// Calculate a rvec and uvec that will determine the displacement from the
// intended target. Use crossprod to generate a right vector, from the missile
// up vector and the vector connecting missile to the homing object.
swarmp->circle_uvec = objp->orient.vec.uvec;
swarmp->circle_rvec = objp->orient.vec.rvec;
missile_speed = pi->speed;
missile_dist = missile_speed * swarmp->change_time/1000.0f;
if ( missile_dist < SWARM_DIST_OFFSET ) {
missile_dist = i2fl(SWARM_DIST_OFFSET);
}
swarmp->angle_offset = (float)(asin(SWARM_DIST_OFFSET / missile_dist));
Assert(!_isnan(swarmp->angle_offset) );
}
vm_vec_sub(&obj_to_target, &swarmp->original_target, &objp->pos);
target_dist = vm_vec_mag_quick(&obj_to_target);
swarmp->last_dist = target_dist;
// If homing swarm missile is close to target, let missile home in on original target
if ( target_dist < SWARM_DIST_STOP_SWARMING ) {
swarmp->new_target = swarmp->original_target;
goto swarm_new_target_calced;
}
radius = (float)tan(swarmp->angle_offset) * target_dist;
vec3d rvec_component, uvec_component;
swarmp->change_count++;
if ( swarmp->change_count > 2 ) {
swarmp->flags ^= SWARM_POSITIVE_PATH;
swarmp->change_count = 0;
}
// pick a new path number to follow once at center
if ( swarmp->change_count == 1 ) {
swarmp->path_num = swarmp->path_num + myrand()%3;
if ( swarmp->path_num > 3 ) {
swarmp->path_num = 0;
}
}
vm_vec_zero(&rvec_component);
vm_vec_zero(&uvec_component);
switch ( swarmp->path_num ) {
case 0: // straight up and down
if ( swarmp->flags & SWARM_POSITIVE_PATH )
vm_vec_copy_scale( &uvec_component, &swarmp->circle_uvec, radius);
else
vm_vec_copy_scale( &uvec_component, &swarmp->circle_uvec, -radius);
break;
case 1: // left/right
if ( swarmp->flags & SWARM_POSITIVE_PATH )
vm_vec_copy_scale( &rvec_component, &swarmp->circle_rvec, radius);
else
vm_vec_copy_scale( &rvec_component, &swarmp->circle_rvec, -radius);
break;
case 2: // top/right - bottom/left
if ( swarmp->flags & SWARM_POSITIVE_PATH ) {
vm_vec_copy_scale( &rvec_component, &swarmp->circle_rvec, radius);
vm_vec_copy_scale( &uvec_component, &swarmp->circle_uvec, radius);
}
else {
vm_vec_copy_scale( &rvec_component, &swarmp->circle_rvec, -radius);
vm_vec_copy_scale( &uvec_component, &swarmp->circle_uvec, -radius);
}
break;
case 3: // top-left - bottom/right
if ( swarmp->flags & SWARM_POSITIVE_PATH ) {
vm_vec_copy_scale( &rvec_component, &swarmp->circle_rvec, -radius);
vm_vec_copy_scale( &uvec_component, &swarmp->circle_uvec, radius);
}
else {
vm_vec_copy_scale( &rvec_component, &swarmp->circle_rvec, radius);
vm_vec_copy_scale( &uvec_component, &swarmp->circle_uvec, -radius);
}
break;
default:
Int3();
break;
}
swarmp->new_target = swarmp->original_target;
vm_vec_zero(&swarmp->last_offset);
vm_vec_add(&swarmp->last_offset, &uvec_component, &rvec_component);
vm_vec_add2(&swarmp->new_target, &swarmp->last_offset);
}
else {
if ( hobjp != &obj_used_list && f2fl(Missiontime - wp->creation_time) > 0.5f ) {
swarmp->new_target = swarmp->original_target;
if ( swarmp->last_dist < SWARM_DIST_STOP_SWARMING ) {
swarmp->new_target = wp->homing_pos;
goto swarm_new_target_calced;
}
vm_vec_add2(&swarmp->new_target, &swarmp->last_offset);
}
}
swarm_new_target_calced:
ai_turn_towards_vector(&swarmp->new_target, objp, frametime, wip->turn_time, NULL, NULL, 0.0f, 0);
vel = vm_vec_mag(&objp->phys_info.desired_vel);
vm_vec_copy_scale(&objp->phys_info.desired_vel, &objp->orient.vec.fvec, vel);
}
/**
* Checks asteroid-ship collisions.
* @param pair obj_pair pointer to the two objects. pair->a is asteroid and pair->b is ship.
* @return 1 if all future collisions between these can be ignored
*/
int collide_asteroid_ship( obj_pair * pair )
{
if (!Asteroids_enabled)
return 0;
float dist;
object *pasteroid = pair->a;
object *pship = pair->b;
// Don't check collisions for warping out player
if ( Player->control_mode != PCM_NORMAL ) {
if ( pship == Player_obj ) return 0;
}
if (pasteroid->hull_strength < 0.0f)
return 0;
Assert( pasteroid->type == OBJ_ASTEROID );
Assert( pship->type == OBJ_SHIP );
dist = vm_vec_dist( &pasteroid->pos, &pship->pos );
if ( dist < pasteroid->radius + pship->radius ) {
int hit;
vec3d hitpos;
// create and initialize ship_ship_hit_info struct
collision_info_struct asteroid_hit_info;
init_collision_info_struct(&asteroid_hit_info);
if ( pasteroid->phys_info.mass > pship->phys_info.mass ) {
asteroid_hit_info.heavy = pasteroid;
asteroid_hit_info.light = pship;
} else {
asteroid_hit_info.heavy = pship;
asteroid_hit_info.light = pasteroid;
}
hit = asteroid_check_collision(pasteroid, pship, &hitpos, &asteroid_hit_info );
if ( hit )
{
//Scripting support (WMC)
Script_system.SetHookObjects(4, "Ship", pship, "Asteroid", pasteroid, "Self",pship, "Object", pasteroid);
bool ship_override = Script_system.IsConditionOverride(CHA_COLLIDEASTEROID, pship);
Script_system.SetHookObjects(2, "Self",pasteroid, "Object", pship);
bool asteroid_override = Script_system.IsConditionOverride(CHA_COLLIDESHIP, pasteroid);
if(!ship_override && !asteroid_override)
{
float ship_damage;
float asteroid_damage;
vec3d asteroid_vel = pasteroid->phys_info.vel;
// do collision physics
calculate_ship_ship_collision_physics( &asteroid_hit_info );
if ( asteroid_hit_info.impulse < 0.5f )
return 0;
// limit damage from impulse by making max impulse (for damage) 2*m*v_max_relative
float max_ship_impulse = (2.0f*pship->phys_info.max_vel.xyz.z+vm_vec_mag_quick(&asteroid_vel)) *
(pship->phys_info.mass*pasteroid->phys_info.mass) / (pship->phys_info.mass + pasteroid->phys_info.mass);
if (asteroid_hit_info.impulse > max_ship_impulse) {
ship_damage = 0.001f * max_ship_impulse;
} else {
ship_damage = 0.001f * asteroid_hit_info.impulse; // Cut collision-based damage in half.
}
// Decrease heavy damage by 2x.
if (ship_damage > 5.0f)
ship_damage = 5.0f + (ship_damage - 5.0f)/2.0f;
if ((ship_damage > 500.0f) && (ship_damage > Ships[pship->instance].ship_max_hull_strength/8.0f)) {
ship_damage = Ships[pship->instance].ship_max_hull_strength/8.0f;
nprintf(("AI", "Pinning damage to %s from asteroid at %7.3f (%7.3f percent)\n", Ships[pship->instance].ship_name, ship_damage, 100.0f * ship_damage/Ships[pship->instance].ship_max_hull_strength));
}
// Decrease damage during warp out because it's annoying when your escoree dies during warp out.
if (Ai_info[Ships[pship->instance].ai_index].mode == AIM_WARP_OUT)
ship_damage /= 3.0f;
// calculate asteroid damage and set asteroid damage to greater or asteroid and ship
// asteroid damage is needed since we can really whack some small asteroid with afterburner and not do
// significant damage to ship but the asteroid goes off faster than afterburner speed.
asteroid_damage = asteroid_hit_info.impulse/pasteroid->phys_info.mass; // ie, delta velocity of asteroid
asteroid_damage = (asteroid_damage > ship_damage) ? asteroid_damage : ship_damage;
// apply damage to asteroid
asteroid_hit( pasteroid, pship, &hitpos, asteroid_damage); // speed => damage
//extern fix Missiontime;
int quadrant_num;
if ( asteroid_hit_info.heavy == pship ) {
quadrant_num = get_ship_quadrant_from_global(&hitpos, pship);
if ((pship->flags[Object::Object_Flags::No_shields]) || !ship_is_shield_up(pship, quadrant_num) ) {
quadrant_num = -1;
}
ship_apply_local_damage(asteroid_hit_info.heavy, asteroid_hit_info.light, &hitpos, ship_damage, quadrant_num, CREATE_SPARKS, asteroid_hit_info.submodel_num);
} else {
// don't draw sparks (using sphere hitpos)
ship_apply_local_damage(asteroid_hit_info.light, asteroid_hit_info.heavy, &hitpos, ship_damage, MISS_SHIELDS, NO_SPARKS);
}
// maybe print Collision on HUD
if ( pship == Player_obj ) {
hud_start_text_flash(XSTR("Collision", 1431), 2000);
}
collide_ship_ship_do_sound(&hitpos, pship, pasteroid, pship==Player_obj);
}
Script_system.SetHookObjects(2, "Self",pship, "Object", pasteroid);
if(!(asteroid_override && !ship_override))
Script_system.RunCondition(CHA_COLLIDEASTEROID, '\0', NULL, pship);
Script_system.SetHookObjects(2, "Self",pasteroid, "Object", pship);
if((asteroid_override && !ship_override) || (!asteroid_override && !ship_override))
Script_system.RunCondition(CHA_COLLIDESHIP, '\0', NULL, pasteroid);
Script_system.RemHookVars(4, "Ship", "Asteroid", "Self", "Object");
return 0;
}
return 0;
} else {
// estimate earliest time at which pair can hit
float asteroid_max_speed, ship_max_speed, time;
ship *shipp = &Ships[pship->instance];
asteroid_max_speed = vm_vec_mag(&pasteroid->phys_info.vel); // Asteroid... vel gets reset, not max vel.z
asteroid_max_speed = MAX(asteroid_max_speed, 10.0f);
if (ship_is_beginning_warpout_speedup(pship)) {
ship_max_speed = MAX(ship_get_max_speed(shipp), ship_get_warpout_speed(pship));
} else {
ship_max_speed = ship_get_max_speed(shipp);
}
ship_max_speed = MAX(ship_max_speed, 10.0f);
ship_max_speed = MAX(ship_max_speed, pship->phys_info.vel.xyz.z);
time = 1000.0f * (dist - pship->radius - pasteroid->radius - 10.0f) / (asteroid_max_speed + ship_max_speed); // 10.0f is a safety factor
time -= 200.0f; // allow one frame slow frame at ~5 fps
if (time > 100) {
pair->next_check_time = timestamp( fl2i(time) );
} else {
pair->next_check_time = timestamp(0); // check next time
}
return 0;
}
}
/**
* When inside radius of big ship, check if we can cull collision pair determine the time when pair should next be checked
* @return 1 if pair can be culled
* @return 0 if pair can not be culled
*/
int check_inside_radius_for_big_ships( object *ship, object *weapon_obj, obj_pair *pair )
{
vec3d error_vel; // vel perpendicular to laser
float error_vel_mag; // magnitude of error_vel
float time_to_max_error, time_to_exit_sphere;
float ship_speed_at_exit_sphere, error_at_exit_sphere;
float max_error = (float) ERROR_STD / 150.0f * ship->radius;
if (max_error < 2)
max_error = 2.0f;
time_to_exit_sphere = (ship->radius + vm_vec_dist(&ship->pos, &weapon_obj->pos)) / (weapon_obj->phys_info.max_vel.xyz.z - ship->phys_info.max_vel.xyz.z);
ship_speed_at_exit_sphere = estimate_ship_speed_upper_limit( ship, time_to_exit_sphere );
// update estimated time to exit sphere
time_to_exit_sphere = (ship->radius + vm_vec_dist(&ship->pos, &weapon_obj->pos)) / (weapon_obj->phys_info.max_vel.xyz.z - ship_speed_at_exit_sphere);
vm_vec_scale_add( &error_vel, &ship->phys_info.vel, &weapon_obj->orient.vec.fvec, -vm_vec_dot(&ship->phys_info.vel, &weapon_obj->orient.vec.fvec) );
error_vel_mag = vm_vec_mag_quick( &error_vel );
error_vel_mag += 0.5f * (ship->phys_info.max_vel.xyz.z - error_vel_mag)*(time_to_exit_sphere/ship->phys_info.forward_accel_time_const);
// error_vel_mag is now average velocity over period
error_at_exit_sphere = error_vel_mag * time_to_exit_sphere;
time_to_max_error = max_error / error_at_exit_sphere * time_to_exit_sphere;
// find the minimum time we can safely check into the future.
// limited by (1) time to exit sphere (2) time to weapon expires
// if ship_weapon_check_collision comes back with a hit_time > error limit, ok
// if ship_weapon_check_collision comes finds no collision, next check time based on error time
float limit_time; // furthest time to check (either lifetime or exit sphere)
if ( time_to_exit_sphere < Weapons[weapon_obj->instance].lifeleft ) {
limit_time = time_to_exit_sphere;
} else {
limit_time = Weapons[weapon_obj->instance].lifeleft;
}
// Note: when estimated hit time is less than 200 ms, look at every frame
int hit_time; // estimated time of hit in ms
// modify ship_weapon_check_collision to do damage if hit_time is negative (ie, hit occurs in this frame)
if ( ship_weapon_check_collision( ship, weapon_obj, limit_time, &hit_time ) ) {
// hit occured in while in sphere
if (hit_time < 0) {
// hit occured in the frame
return 1;
} else if (hit_time > 200) {
pair->next_check_time = timestamp(hit_time - 200);
return 0;
// set next check time to time - 200
} else {
// set next check time to next frame
pair->next_check_time = 1;
return 0;
}
} else {
if (limit_time > time_to_max_error) {
// no hit, but beyond error tolerance
if (1000*time_to_max_error > 200) {
pair->next_check_time = timestamp( (int)(1000*time_to_max_error) - 200 );
} else {
pair->next_check_time = 1;
}
return 0;
} else {
// no hit and within error tolerance
return 1;
}
}
}
// -----------------------------------------------------------------------------------------------------------
//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;
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,old_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;
int bounced=0;
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) || (objp->id == SUPERPROX_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;
old_sim_time = sim_time;
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 {
//if (obj == debug_obj)
// printf(" moved_vec = %x %x %x\n",XYZ(&moved_vec));
attempted_dist = vm_vec_mag(&frame_vec);
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) ) {
int forcefield_bounce; //bounce off a forcefield
Assert(BounceCheat || !(obj->mtype.phys_info.flags & PF_STICK && obj->mtype.phys_info.flags & PF_BOUNCE)); //can't be bounce and stick
forcefield_bounce = (TmapInfo[Segments[WallHitSeg].sides[WallHitSide].tmap_num].flags & TMI_FORCE_FIELD);
if (!forcefield_bounce && (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
int check_vel=0;
//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);
// mprintf((0, "%d", f2i(vm_vec_mag(&hit_info.hit_wallnorm)) ));
if (forcefield_bounce || (obj->mtype.phys_info.flags & PF_BOUNCE)) { //bounce off wall
wall_part *= 2; //Subtract out wall part twice to achieve bounce
if (forcefield_bounce) {
check_vel = 1; //check for max velocity
if (obj->type == OBJ_PLAYER)
wall_part *= 2; //player bounce twice as much
}
if ( obj->mtype.phys_info.flags & PF_BOUNCES_TWICE) {
Assert(obj->mtype.phys_info.flags & PF_BOUNCE);
if (obj->mtype.phys_info.flags & PF_BOUNCED_ONCE)
obj->mtype.phys_info.flags &= ~(PF_BOUNCE+PF_BOUNCED_ONCE+PF_BOUNCES_TWICE);
else
obj->mtype.phys_info.flags |= PF_BOUNCED_ONCE;
}
bounced = 1; //this object bounced
}
vm_vec_scale_add2(&obj->mtype.phys_info.velocity,&hit_info.hit_wallnorm,-wall_part);
// mprintf((0, "Velocity at bounce time = %d\n", f2i(vm_vec_mag(&obj->mtype.phys_info.velocity))));
//if (obj==ConsoleObject)
// mprintf((0,"player vel = %x\n",vm_vec_mag_quick(&obj->mtype.phys_info.velocity)));
if (check_vel) {
fix vel = vm_vec_mag_quick(&obj->mtype.phys_info.velocity);
if (vel > MAX_OBJECT_VEL)
vm_vec_scale(&obj->mtype.phys_info.velocity,fixdiv(MAX_OBJECT_VEL,vel));
}
if (bounced && obj->type == OBJ_WEAPON)
vm_vector_2_matrix(&obj->orient,&obj->mtype.phys_info.velocity,&obj->orient.uvec,NULL);
#ifdef EXTRA_DEBUG
if (obj == debug_obj) {
printf(" sliding - wall_norm %x %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:
#ifdef TACTILE
if (TactileStick && obj==ConsoleObject && !(FrameCount & 15))
Tactile_Xvibrate_clear ();
#endif
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;
#ifndef NDEBUG
Total_retries += count-1;
Total_sims++;
#endif
}
}
//I'm not sure why we do this. I wish there were a comment that
//explained it. I think maybe it only needs to be done if the object
//is sliding, but I don't know
if (!obj_stopped && !bounced) { //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);
//don't bump player toward center of reactor segment
if (Segment2s[obj->segnum].special == SEGMENT_IS_CONTROLCEN)
vm_vec_negate(&bump_vec);
vm_vec_scale_add2(&obj->pos,&bump_vec,obj->size/5);
//if moving away from seg, might move out of seg, so update
if (Segment2s[obj->segnum].special == SEGMENT_IS_CONTROLCEN)
update_object_seg(obj);
}
#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];
if (orig_segnum==-1)
Error("orig_segnum == -1 in physics");
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
}
// -----------------------------------------------------------------------------------------------------------
//Simulate a physics object for this frame
void do_physics_sim(dxxobject *obj)
{
objnum_t ignore_obj_list[MAX_IGNORE_OBJS];
unsigned n_ignore_objs;
segnum_t 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;
objnum_t objnum;
segnum_t WallHitSeg;
int WallHitSide;
fvi_info hit_info;
fvi_query fq;
vms_vector save_pos;
segnum_t save_seg;
fix drag;
fix sim_time,old_sim_time;
vms_vector start_pos;
int obj_stopped=0;
fix moved_time; //how long objected moved before hit something
physics_info *pi;
segnum_t orig_segnum = obj->segnum;
int bounced=0;
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)
{
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] = object_none;
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) {
dxxobject *objp = &Objects[hit_info.hit_object];
if (((objp->type == OBJ_WEAPON) && ((objp->id == PROXIMITY_ID) || (objp->id == SUPERPROX_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==segment_none) { //some sort of horrible error
if (obj->type == OBJ_WEAPON)
obj->flags |= OF_SHOULD_BE_DEAD;
break;
}
Assert(!((fate==HIT_WALL) && ((WallHitSeg == segment_none) || (WallHitSeg > Highest_segment_index))));
//if(!get_seg_masks(&hit_info.hit_pnt, hit_info.hit_seg, 0, __FILE__, __LINE__).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 )
{
segnum_t n;
if ((n=find_object_seg(obj))==segment_none) {
//Int3();
if (obj->type==OBJ_PLAYER && (n=find_point_seg(&obj->last_pos,obj->segnum))!=segment_none) {
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;
old_sim_time = sim_time;
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 {
attempted_dist = vm_vec_mag(&frame_vec);
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 total_d,moved_d;
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 != segment_none && WallHitSeg <= Highest_segment_index );
Assert( WallHitSide > -1 );
if ( !(obj->flags&OF_SHOULD_BE_DEAD) ) {
int forcefield_bounce; //bounce off a forcefield
Assert(cheats.bouncyfire || !(obj->mtype.phys_info.flags & PF_STICK && obj->mtype.phys_info.flags & PF_BOUNCE)); //can't be bounce and stick
forcefield_bounce = (TmapInfo[Segments[WallHitSeg].sides[WallHitSide].tmap_num].flags & TMI_FORCE_FIELD);
if (!forcefield_bounce && (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
int check_vel=0;
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 (forcefield_bounce || (obj->mtype.phys_info.flags & PF_BOUNCE)) { //bounce off wall
wall_part *= 2; //Subtract out wall part twice to achieve bounce
if (forcefield_bounce) {
check_vel = 1; //check for max velocity
if (obj->type == OBJ_PLAYER)
wall_part *= 2; //player bounce twice as much
}
if ( obj->mtype.phys_info.flags & PF_BOUNCES_TWICE) {
Assert(obj->mtype.phys_info.flags & PF_BOUNCE);
if (obj->mtype.phys_info.flags & PF_BOUNCED_ONCE)
obj->mtype.phys_info.flags &= ~(PF_BOUNCE+PF_BOUNCED_ONCE+PF_BOUNCES_TWICE);
else
obj->mtype.phys_info.flags |= PF_BOUNCED_ONCE;
}
bounced = 1; //this object bounced
}
vm_vec_scale_add2(&obj->mtype.phys_info.velocity,&hit_info.hit_wallnorm,-wall_part);
if (check_vel) {
fix vel = vm_vec_mag_quick(&obj->mtype.phys_info.velocity);
if (vel > MAX_OBJECT_VEL)
vm_vec_scale(&obj->mtype.phys_info.velocity,fixdiv(MAX_OBJECT_VEL,vel));
}
if (bounced && obj->type == OBJ_WEAPON)
vm_vector_2_matrix(&obj->orient,&obj->mtype.phys_info.velocity,&obj->orient.uvec,NULL);
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 != object_none);
// 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;
#ifndef NDEBUG
Total_retries += count-1;
Total_sims++;
#endif
}
}
// 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 && !bounced
&& ((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_t *s;
int vertnum,num_faces,i;
fix dist;
int vertex_list[6];
//bump object back
s = &Segments[orig_segnum].sides[sidenum];
if (orig_segnum==segment_none)
Error("orig_segnum == -1 in physics");
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)==segment_none) {
segnum_t n;
//Int3();
if (obj->type==OBJ_PLAYER && (n=find_point_seg(&obj->last_pos,obj->segnum))!=segment_none) {
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
}
