Cronocide/Descent3
1
0
Fork 0
mirror of https://github.com/kevinbentley/Descent3.git synced 2025-01-22 19:55:23 +00:00
Code Issues Packages Projects Releases Wiki Activity
8e350a6c5d
Descent3/physics/physics.cpp
Kevin Bentley df209742fc Initial import
2024-04-15 21:43:29 -06:00

3511 lines
100 KiB
C++
Raw Blame History

#include <stdlib.h>
#include <memory.h>
#include <limits>
#include "object.h"
#include "PHYSICS.H"
#include "collide.h"
#include "findintersection.h"
#include "vecmat.h"
#include "game.h"
#include "terrain.h"
#include "descent.h"
#include "weapon.h"
#include "polymodel.h"
#include "fireball.h"
#include "damage.h"
#include "gameevent.h"
#include "hlsoundlib.h"
#include "soundload.h"
#include "viseffect.h"
#include "multi.h"
#include "attach.h"
#include "D3ForceFeedback.h"
#include "player.h"
#include "demofile.h"
#include "vibeinterface.h"
//Global variables for physics system
ubyte Default_player_terrain_leveling = 0;
ubyte Default_player_room_leveling = 0;
// Maximum iterations thru the simulation loop NOTE: It is assumed that the player loops >= non-player loops
#define MAX_PLAYER_SIM_LOOPS 9
#define MAX_NON_PLAYER_SIM_LOOPS 5
#define CEILING_POWERUP_DELTA 30.0f
#define WIGGLE_FALLOFF_TIME 2.0
int Physics_normal_counter;
int Physics_normal_looping_counter;
int Physics_walking_counter;
int Physics_walking_looping_counter;
int Physics_vis_counter;
#ifdef _DEBUG
// This will allow us to debug physics in a better way.
typedef struct sim_loop_info
{
vector start_pos;
physics_info phys_info; // At beginnning of loop
fvi_info hit_info; // Hit information returned by FVI
} sim_loop_info;
sim_loop_info sim_loop_record[MAX_PLAYER_SIM_LOOPS];
#endif
#ifdef _DEBUG
int Physics_player_verbose = 0;
#endif
#define PHYSICS_GROUND_TOLERANCE 0.0001f
#define DAMP_ANG 1.0f // chrishack -- this is probably too tight and should be an int not a float
#define MAX_OBJECT_VEL 100000.0f
int Physics_cheat_flag = 0;
extern char BounceCheat;
int PhysicsLinkList[MAX_OBJECTS];
int Physics_NumLinked = 0;
// Current strength of gravity
float Gravity_strength = -32.2f; // Meters/second^2
void DoPhysLinkedFrame(object *obj)
{
object *parent = ObjGet(obj->mtype.obj_link_info.parent_handle);
matrix new_orient;
vector new_pos;
if(parent && parent->type != OBJ_GHOST && parent->type != OBJ_DUMMY)
{
poly_model *pm;
vector pnt;
vector fvec;
vector uvec;
matrix m;
int mn; //submodel number
float normalized_time[MAX_SUBOBJECTS];
pm = &Poly_models[parent->rtype.pobj_info.model_num];
ASSERT (pm->used);
SetNormalizedTimeObj(parent, normalized_time);
SetModelAnglesAndPos (pm,normalized_time);
pnt = obj->mtype.obj_link_info.pos;
fvec = obj->mtype.obj_link_info.fvec;
uvec = obj->mtype.obj_link_info.uvec;
mn = obj->mtype.obj_link_info.sobj_index;
if (mn<0 || mn>=pm->n_models)
{
mprintf ((0,"Caught physics link bug!\n"));
SetObjectDeadFlag (obj);
return;
}
// Instance up the tree for this gun
while (mn != -1)
{
vector tpnt;
vm_AnglesToMatrix(&m, pm->submodel[mn].angs.p,pm->submodel[mn].angs.h, pm->submodel[mn].angs.b);
vm_TransposeMatrix(&m);
tpnt = pnt * m;
fvec = fvec * m;
uvec = uvec * m;
pnt = tpnt + pm->submodel[mn].offset + pm->submodel[mn].mod_pos;
mn = pm->submodel[mn].parent;
}
//now instance for the entire object
m = parent->orient;
vm_TransposeMatrix(&m);
new_pos = pnt * m;
fvec = fvec * m;
uvec = uvec * m;
vm_VectorToMatrix(&new_orient, &fvec, &uvec, NULL);
new_pos += parent->pos;
ObjSetPos(obj, &new_pos, parent->roomnum, &new_orient, false);
}
else
{
SetObjectDeadFlag(obj);
}
}
bool PhysCalcGround(vector *ground_point, vector *ground_normal, object *obj, int ground_num)
{
poly_model *pm;
vector pnt;
vector normal;
matrix m;
int mn; //submodel number
float normalized_time[MAX_SUBOBJECTS];
bool f_good_gp = true;
if (obj->render_type!=RT_POLYOBJ && obj->type!=OBJ_PLAYER)
{
// mprintf ((0,"Object type %d is not a polyobj!\n",obj->type));
if(ground_point)
*ground_point = obj->pos;
if(ground_normal)
*ground_normal = obj->orient.fvec;
return false;
}
pm = &Poly_models[obj->rtype.pobj_info.model_num];
if(pm->n_ground == 0)
{
mprintf((0, "WARNING: Object with no weapons is firing.\n", ground_num));
if(ground_point)
*ground_point = obj->pos;
if(ground_normal)
*ground_normal = obj->orient.fvec;
return false;
}
SetNormalizedTimeObj(obj, normalized_time);
SetModelAnglesAndPos (pm,normalized_time);
if (ground_num < 0 || ground_num >= pm->n_ground)
{
mprintf((0, "WARNING: Bashing ground num %d to 0.\n", ground_num));
ground_num = 0;
f_good_gp = false;
}
pnt = pm->ground_slots[ground_num].pnt;
normal = pm->ground_slots[ground_num].norm;
mn = pm->ground_slots[ground_num].parent;
// Instance up the tree for this ground
while (mn != -1)
{
vector tpnt;
vm_AnglesToMatrix(&m, pm->submodel[mn].angs.p,pm->submodel[mn].angs.h, pm->submodel[mn].angs.b);
vm_TransposeMatrix(&m);
tpnt = pnt * m;
normal = normal * m;
pnt = tpnt + pm->submodel[mn].offset + pm->submodel[mn].mod_pos;
mn = pm->submodel[mn].parent;
}
m = obj->orient;
vm_TransposeMatrix(&m);
if(ground_point)
*ground_point = pnt * m;
if(ground_normal)
*ground_normal = normal * m;
if(ground_point)
*ground_point += obj->pos;
return f_good_gp;
}
// Applies rotational thrust over at delta time
void PhysicsApplyConstRotForce( object& objp, const vector& rotforce, vector& rotvel, float deltaTime )
{
const double drag = objp.mtype.phys_info.rotdrag;
const double mass = objp.mtype.phys_info.mass;
if( mass < std::numeric_limits<double>::epsilon() || drag < std::numeric_limits<double>::epsilon() )
{
// Invalid mass/drag
rotvel += rotforce * deltaTime;
return;
}
// Standard angular motion with a linear air drag (drag is proportional to angular velocity)
const double oneOverDrag = 1.0 / drag;
const double rotForceOverDrag[3] = { double(rotforce.x) * oneOverDrag, double(rotforce.y) * oneOverDrag, double(rotforce.z) * oneOverDrag };
const double dragOverMass = drag / mass;
const double expDoMDt = exp( -dragOverMass * double(deltaTime) );
double newRotVel[3];
newRotVel[0] = ( double(rotvel.x) - rotForceOverDrag[0] ) * expDoMDt + rotForceOverDrag[0];
newRotVel[1] = ( double(rotvel.y) - rotForceOverDrag[1] ) * expDoMDt + rotForceOverDrag[1];
newRotVel[2] = ( double(rotvel.z) - rotForceOverDrag[2] ) * expDoMDt + rotForceOverDrag[2];
// set the new rotational velocity
rotvel.x = static_cast<float>( newRotVel[0] );
rotvel.y = static_cast<float>( newRotVel[1] );
rotvel.z = static_cast<float>( newRotVel[2] );
}
// Applies a linear force over time. --Like gravity or thrust
void PhysicsApplyConstantForce( const object& objp, vector& newPos, vector& newVel, vector& movementVec, const vector& force, float deltaTime )
{
const vector& pos = objp.pos;
const vector& vel = objp.mtype.phys_info.velocity;
const double drag = static_cast<double>( objp.mtype.phys_info.drag );
const double mass = static_cast<double>( objp.mtype.phys_info.mass );
if( mass < std::numeric_limits<double>::epsilon() || drag < std::numeric_limits<double>::epsilon() )
{
// No Mass/Drag
movementVec = (vel * deltaTime) + (force * (0.5f * deltaTime * deltaTime));
newPos = pos + movementVec;
newVel = vel + force * deltaTime;
return;
}
// Standard motion with a linear air drag (drag is proportional to velocity)
const double dt = static_cast<double>( deltaTime );
const double oneOverDrag = 1.0 / drag;
const double massOverDrag = mass / drag;
const double forceOverDrag[3] = { force.x * oneOverDrag, force.y * oneOverDrag, force.z * oneOverDrag };
const double objVel[3] = { static_cast<double>( vel.x ), static_cast<double>( vel.y ), static_cast<double>( vel.z ) };
const double expDoMDt = exp( (-1.0 / massOverDrag) * dt );
newPos.x = static_cast<float>( static_cast<double>(pos.x) + forceOverDrag[0] * dt + massOverDrag * ( objVel[0] - forceOverDrag[0] ) * (1.0 - expDoMDt) );
newPos.y = static_cast<float>( static_cast<double>(pos.y) + forceOverDrag[1] * dt + massOverDrag * ( objVel[1] - forceOverDrag[1] ) * (1.0 - expDoMDt) );
newPos.z = static_cast<float>( static_cast<double>(pos.z) + forceOverDrag[2] * dt + massOverDrag * ( objVel[2] - forceOverDrag[2] ) * (1.0 - expDoMDt) );
movementVec = newPos - pos;
newVel.x = static_cast<float>( (objVel[0] - forceOverDrag[0]) * expDoMDt + forceOverDrag[0] );
newVel.y = static_cast<float>( (objVel[1] - forceOverDrag[1]) * expDoMDt + forceOverDrag[1] );
newVel.z = static_cast<float>( (objVel[2] - forceOverDrag[2]) * expDoMDt + forceOverDrag[2] );
}
// Banks an object as it turns (we counteract this and then reapply it when we
// actually do the turn -- cool)
void set_object_turnroll(object *obj, vector *rotvel, angle *turnroll)
{
float desired_bank;
angle desired_bank_angle;
desired_bank = -(rotvel->y) * obj->mtype.phys_info.turnroll_ratio;
// If desired bank > 32000, we will rotate the ship in weird ways. Should limit turn-roll to 32000 if this
// ever occurs. BTW This is where the limiter should be placed.
if(fabs(desired_bank) > 32000.0)
{
if(desired_bank < 0.0)
desired_bank = -32000.0f;
else
desired_bank = 32000.0f;
}
if(desired_bank > -1.0) // accounts for -.9999 this is rounded to 0 in a float to int conversion
desired_bank_angle = desired_bank;
else
desired_bank_angle = 65535 + desired_bank;
if (*turnroll != desired_bank_angle)
{
int delta_ang;
int max_roll;
max_roll = obj->mtype.phys_info.max_turnroll_rate * Frametime;
if(*turnroll > 32000)
delta_ang = desired_bank - (*turnroll - 65535);
else
delta_ang = desired_bank - *turnroll;
if (labs(delta_ang) > max_roll)
if(delta_ang > 0)
*turnroll += max_roll;
else
*turnroll -= max_roll;
else
*turnroll = desired_bank_angle;
}
else
*turnroll = desired_bank_angle;
}
// Maximum number of objects that we already hit.
#define MAX_IGNORE_OBJS 100
// When leveling non-player objects - how many angles per sec. do they correct with.
#define MAX_LEVEL_ANGLES_PER_SEC 30000.0f
// Base scaler for pitch scaling of autoleveling
#define MAX_AUTOLEVEL_TILT_ANGLE 11000
// Multiplier for newbie autoleveling scaling of tilt angle
#define NEWBIE_AUTOLEVEL_TILT_ANGLE_SCALAR 1.25f
// How long a newbie sits there before the pitch leveling kicks in
#define NEWBIE_PITCH_LEVEL_TIME 1.5f
#define BANK_AUTOLEVEL_SPEED_SCALAR 2.0
// Rotational simulator the updates orient, rotvel, and turnroll
// (using these original values + frametime + rotthrust)
bool PhysicsDoSimRot(object *obj, float frame_time, matrix *orient, vector *rotthrust, vector *rotvel, angle *turnroll)
{
angvec tangles;
matrix rotmat;
physics_info *pi;
bool f_leveling = false;
float max_tilt_angle;
bool f_newbie_leveling = false;
if(frame_time <= 0.0)
return false; // chrishack
pi = &obj->mtype.phys_info;
if(obj == Player_object && obj->control_type != CT_AI)
{
max_tilt_angle = MAX_AUTOLEVEL_TILT_ANGLE;
if(OBJECT_OUTSIDE(obj))
{
if(Default_player_terrain_leveling)
{
f_leveling = true;
if(Default_player_terrain_leveling > 1)
{
max_tilt_angle *= NEWBIE_AUTOLEVEL_TILT_ANGLE_SCALAR;
f_newbie_leveling = true;
}
}
}
else
{
if(Default_player_room_leveling)
{
f_leveling = true;
if(Default_player_room_leveling > 1)
{
max_tilt_angle *= NEWBIE_AUTOLEVEL_TILT_ANGLE_SCALAR;
f_newbie_leveling = true;
}
}
}
}
else
{
if(pi->flags & PF_LEVELING)
f_leveling = true;
}
// Fixed rate rotaters
if(obj->mtype.phys_info.flags & PF_FIXED_ROT_VELOCITY)
{
tangles.p = rotvel->x * frame_time;
tangles.h = rotvel->y * frame_time;
tangles.b = rotvel->z * frame_time;
vm_AnglesToMatrix(&rotmat, tangles.p, tangles.h, tangles.b);
*orient = *orient * rotmat; // ObjSetOrient below
vm_Orthogonalize(orient); // Rest done after call
return true;
}
// if(!(f_leveling) && fabs(rotthrust->x) < .000001 && fabs(rotthrust->y) < .000001 && fabs(rotthrust->z) < .000001)
// {
// if(!(fabs(rotvel->x) > .000001 || fabs(rotvel->y) > .000001 || fabs(rotvel->z) > .000001 || *turnroll != 0))
// {
// return false;
// }
// }
//now rotate object
//unrotate object for bank caused by turn
if (*turnroll != 0)
{
tangles.p = tangles.h = 0;
tangles.b = -(*turnroll);
vm_AnglesToMatrix(&rotmat, tangles.p, tangles.h, tangles.b);
// Apply rotation matrix to the orientation matrix
*orient = *orient * rotmat; // ObjSetOrient is below
}
// Auto-leveling
if((f_leveling) && (obj->type != OBJ_PLAYER))
{
if(fabs(rotthrust->z) < 100.0f)
{
if((fabs(rotvel->z) < 1500.0f) /*&& (pi->turnroll <= 10 || pi->turnroll >= 65535 - 10)*/)
{
angvec ang;
vector fvec;
int bound;
//f_leveling = true;
//pi->turnroll = 0;
//extract angles from a matrix
vm_ExtractAnglesFromMatrix(&ang, orient);
if((pi->flags & PF_TURNROLL) && *turnroll)
{
bound = *turnroll;
if(bound > 32768)
{
bound = 65535 - bound;
}
}
else
{
bound = 10;
}
if(ang.b > bound && ang.b < 65535 - bound) // About 1 degree
{
float scale;
//Scale on pitch
if(ang.p < 32768)
{
scale = abs(16834 - (int)ang.p)/16384.0f;
}
else
{
scale = abs(49152 - (int)ang.p)/16384.0f;
}
// mprintf((0, "scale %f, ", scale));
if(ang.b < 32768)
{
float al_rate = scale * MAX_LEVEL_ANGLES_PER_SEC * (1.0f - (abs(16834 - (int)ang.b)/16384.0f));
if(al_rate < scale * 5000.0f)
{
al_rate = scale * 5000.0f;
}
al_rate *= frame_time;
if(al_rate > ang.b)
al_rate = ang.b;
// mprintf((0, "L al_rate %f\n", al_rate));
ang.b -= al_rate;
}
else
{
float al_rate = scale * MAX_LEVEL_ANGLES_PER_SEC * (1.0f - (abs(16384 - ((int)ang.b - 32768))/16384.0f));
if(al_rate < scale * 5000.0f)
{
al_rate = scale * 5000.0f;
}
al_rate *= frame_time;
if(al_rate > 65535 - ang.b)
al_rate = 65535 - ang.b;
// mprintf((0, "G al_rate %f\n", al_rate));
ang.b += al_rate;
}
fvec = orient->fvec;
vm_AnglesToMatrix(orient, ang.p, ang.h, ang.b);
}
}
}
}
else if((f_leveling) && (obj->type == OBJ_PLAYER))
{
bool f_pitch_leveled = false;
bool f_player_fired_recently = false;
int i;
for(i = 0; i < 21; i++)
{
if(obj->dynamic_wb[i].last_fire_time + NEWBIE_PITCH_LEVEL_TIME > Gametime)
{
f_player_fired_recently = true;
f_newbie_leveling = false;
break;
}
}
if(!f_player_fired_recently && f_newbie_leveling && (Players[obj->id].last_thrust_time + NEWBIE_PITCH_LEVEL_TIME < Gametime))
{
if(1)
{
angvec ang;
int bound;
//f_leveling = true;
//pi->turnroll = 0;
//extract angles from a matrix
vm_ExtractAnglesFromMatrix(&ang, orient);
bound = 750;
// About 1 degree -- front or back
if((ang.p > bound) && (ang.p < 65535 - bound) && // Forward
abs(ang.p - 32768) > bound) // Backward
{
float scale;
f_pitch_leveled = true;
if(obj->orient.uvec.y < 0.0f)
{
ang.p += 16384;
}
scale = 1.05f - fabs(obj->orient.uvec.y);
// scale *= scale;
if(scale > 1.0)
scale = 1.0;
if(ang.p < 16834)
{
// float temp_scale = (1.04f - ((16834 - ang.p)/16834.0f));
// scale = temp_scale * temp_scale;
rotthrust->x -= scale * obj->mtype.phys_info.full_rotthrust;
// mprintf((0, "1 scale %f\n", scale));
}
else if(ang.p < 32768)
{
// float temp_scale = (1.04f - ((ang.p - 16834)/16834.0f));
// scale = temp_scale * temp_scale;
rotthrust->x += scale * obj->mtype.phys_info.full_rotthrust;
// mprintf((0, "2 scale %f\n", scale));
}
else if(ang.p < 49152)
{
// float temp_scale = (1.04f - ((49152 - ang.p)/16834.0f));
// scale = temp_scale * temp_scale;
rotthrust->x -= scale * obj->mtype.phys_info.full_rotthrust;
// mprintf((0, "3 scale %f\n", scale));
}
else
{
// float temp_scale = (1.04f - ((ang.p - 49152)/16834.0f));
// scale = temp_scale * temp_scale;
rotthrust->x += scale * obj->mtype.phys_info.full_rotthrust;
// mprintf((0, "4 scale %f\n", scale));
}
}
}
}
if(!f_pitch_leveled && fabs(rotthrust->z) < 100.0f)
{
if(1) ///*&& (pi->turnroll <= 10 || pi->turnroll >= 65535 - 10)*/)
{
angvec ang;
int bound;
//f_leveling = true;
//pi->turnroll = 0;
//extract angles from a matrix
vm_ExtractAnglesFromMatrix(&ang, orient);
if((ang.p < 32768 && (abs((int)ang.p - (int)16834) > max_tilt_angle)) ||
(ang.p >= 32768 && (abs((int)ang.p - (int)49152) > max_tilt_angle)))
{
if((pi->flags & PF_TURNROLL) && *turnroll)
{
bound = *turnroll;
if(bound > 32768)
{
bound = 65535 - bound;
}
}
else
{
bound = 10;
}
if(ang.b > bound && ang.b < 65535 - bound) // About 1 degree
{
float scale;
// vector level_rotthrust = Zero_vector;
//Scale on pitch
if(ang.p < 32768)
{
scale = (abs(16834 - (int)ang.p) - max_tilt_angle)/(16384.0f - max_tilt_angle);
}
else
{
scale = (abs(49152 - (int)ang.p) - max_tilt_angle)/(16384.0f - max_tilt_angle);
}
// mprintf((0, "scale %f, ", scale));
if(ang.b < 32768)
{
float temp_scale;
// if(temp_scale * temp_scale > .05)
if(ang.b > 28672)
{
temp_scale = (1.04f - ((28672 - 16834)/16384.0f));
}
else
{
temp_scale = (1.04f - (abs(16834 - (int)ang.b)/16384.0f));
}
temp_scale *= temp_scale;
scale *= temp_scale;
if(f_player_fired_recently)
scale *= .25f;
rotthrust->z -= scale * BANK_AUTOLEVEL_SPEED_SCALAR * obj->mtype.phys_info.full_rotthrust;
}
else
{
float temp_scale;
if(ang.b < 36864)
{
temp_scale = (1.04f - ((49152 - 36864)/16384.0f));
}
else
{
temp_scale = (1.04f - (abs(49152 - (int)ang.b)/16384.0f));
}
temp_scale *= temp_scale;
scale *= temp_scale;
if(f_player_fired_recently)
scale *= .25f;
rotthrust->z += scale * BANK_AUTOLEVEL_SPEED_SCALAR * obj->mtype.phys_info.full_rotthrust;
}
// PhysicsApplyConstRotForce(*obj, level_rotthrust, *rotvel, frame_time);
}
}
}
}
}
if (pi->rotdrag > 0.0f)
{
if(!(pi->flags & PF_USES_THRUST))
{
*rotthrust = Zero_vector;
}
PhysicsApplyConstRotForce(*obj, *rotthrust, *rotvel, frame_time);
}
// Apply rotation to the "un-rollbanked" object
tangles.p = rotvel->x * frame_time;
tangles.h = rotvel->y * frame_time;
tangles.b = rotvel->z * frame_time;
vm_AnglesToMatrix(&rotmat, tangles.p, tangles.h, tangles.b);
*orient = *orient * rotmat;// ObjSetOrient is below
// Determine the new turnroll from this amount of turning
if (pi->flags & PF_TURNROLL)
{
set_object_turnroll(obj, rotvel, turnroll);
}
//re-rotate object for bank caused by turn
if (*turnroll != 0)
{
tangles.p = tangles.h = 0;
tangles.b = *turnroll;
vm_AnglesToMatrix(&rotmat, tangles.p, tangles.h, tangles.b);
*orient = *orient * rotmat; // ObjSetOrient is below
}
// mprintf((0, " a %f, %f, %f,\n%f, %f, %f,\n%f %f %f\n\n", XYZ(&obj->orient.fvec), XYZ(&obj->orient.rvec), XYZ(&obj->orient.uvec)));
// Make sure the new orientation is valid
vm_Orthogonalize(orient);
return true;
}
void PhysicsDoSimLinear(const object& obj, const vector& pos, const vector& force, vector& velocity, vector& movementVec, vector& movementPos, float simTime, int count)
{
// Determine velocity
if( obj.mtype.phys_info.flags & PF_FIXED_VELOCITY )
{
movementVec = velocity * simTime;
movementPos = pos + movementVec;
return;
}
// Help so that we do not loss velocity when sliding (still framerate dependent -- fix with force stuff)
// if (!(count == 0 || (count > 0 && (~obj->mtype.phys_info.flags & (PF_BOUNCE | PF_GRAVITY)))))
// return;
vector forceToUse = force;
if( !ROOMNUM_OUTSIDE(obj.roomnum) &&
!(obj.mtype.phys_info.flags & PF_LOCK_MASK) &&
Rooms[obj.roomnum].wind != Zero_vector &&
count == 0 &&
obj.mtype.phys_info.drag > 0.0f &&
!(obj.type == OBJ_POWERUP && Level_powerups_ignore_wind) )
{
// Factor in outside wind
const vector& wind = Rooms[obj.roomnum].wind;
vector deltaForce = wind * obj.mtype.phys_info.drag * 16.0f;
forceToUse += deltaForce;
}
PhysicsApplyConstantForce( obj, movementPos, velocity, movementVec, forceToUse, simTime );
#ifdef _DEBUG
if(Physics_player_verbose && obj.type == OBJ_PLAYER)
{
mprintf((0, "Player Velocity = %f(%f)\n", vm_GetMagnitude(&velocity), vm_GetMagnitude(&movementVec)/simTime));
}
#endif
}
// -----------------------------------------------------------------------------------------------------------
//Simulate a physics object for this frame
void do_physics_sim(object *obj)
{
//Since we might not call FVI, set this here
Fvi_num_recorded_faces = 0;
int n_ignore_objs = 0; // The number of ignored objects
int ignore_obj_list[MAX_IGNORE_OBJS+1]; // List of ignored objects
int fate; // Collision type for response code
vector movement_vec; // Movement in this frame
vector movement_pos; // End point of the movement
int count = 0; // Simulation loop counter
int sim_loop_limit = (obj->type == OBJ_PLAYER) ? MAX_PLAYER_SIM_LOOPS : MAX_NON_PLAYER_SIM_LOOPS;
int objnum = OBJNUM(obj); // Simulated object's index
fvi_info hit_info; // Hit information
fvi_query fq; // Movement query
float sim_time_remaining = Frametime; // Amount of simulation time remaining (current iteration)
float old_sim_time_remaining = Frametime; // Amount of simulation time remaining (previous iteration)
vector init_pos = obj->pos; // Initial position
int init_room = obj->roomnum; // Initial room
vector start_pos; // Values at the start of current simulation loop
vector start_vel;
matrix start_orient;
vector start_rotvel;
angle start_turnroll;
int start_room;
float moved_time; // How long objected moved before hit something
physics_info *pi = &obj->mtype.phys_info; // Simulated object's physics information
int bounced=0; // Did the object bounce?
vector total_force; // Constant force acting on an object
bool f_continue_sim; // Should we run another simulation loop
bool f_start_fvi_record = true; // Records the rooms that are passed thru
bool f_turn_gravity_on = false;
// Assert conditions
ASSERT(obj->type != OBJ_NONE);
ASSERT(obj->movement_type == MT_PHYSICS);
ASSERT(!(obj->mtype.phys_info.flags&PF_USES_THRUST) || obj->mtype.phys_info.drag != 0.0 );
DebugBlockPrint("P ");
ASSERT(_finite(obj->mtype.phys_info.velocity.x) != 0); // Caller wants to go to infinity! -- Not FVI's fault.
ASSERT(_finite(obj->mtype.phys_info.velocity.y) != 0); // Caller wants to go to infinity! -- Not FVI's fault.
ASSERT(_finite(obj->mtype.phys_info.velocity.z) != 0); // Caller wants to go to infinity! -- Not FVI's fault.
#ifdef _DEBUG
if(!Game_do_flying_sim)
{
return;
}
#endif
// Make powerups above the ceiling fall with gravity
if(obj->type == OBJ_POWERUP && ROOMNUM_OUTSIDE(obj->roomnum) && obj->pos.y > (CEILING_HEIGHT - obj->size - CEILING_POWERUP_DELTA) && !(obj->mtype.phys_info.flags & PF_GRAVITY))
{
obj->mtype.phys_info.flags |= PF_GRAVITY;
obj->flags |= OF_TEMP_GRAVITY;
}
else if(obj->flags & OF_TEMP_GRAVITY)
{
obj->mtype.phys_info.flags &= ~PF_GRAVITY;
}
// Instant bail cases
if((obj->flags & (OF_DEAD | OF_ATTACHED)) || (Frametime <= 0.0) || (obj->type == OBJ_DUMMY))
{
return;
}
if(obj->type == OBJ_PLAYER && (obj->mtype.phys_info.thrust != Zero_vector ||
obj->mtype.phys_info.rotthrust != Zero_vector))
{
Players[obj->id].last_thrust_time = Gametime;
}
// mprintf((0, "%d Over terrain = %d\n", obj - Objects, obj->flags & OF_OVER_TERRAIN));
// If the object wiggles
if ( (obj->mtype.phys_info.flags & PF_WIGGLE) && (Demo_flags!=DF_PLAYBACK) )
{
float swiggle;
vector w_pos;
if(vm_GetMagnitude(&obj->mtype.phys_info.thrust) < .1)
{
obj->mtype.phys_info.last_still_time -= Frametime / WIGGLE_FALLOFF_TIME;
}
else
{
obj->mtype.phys_info.last_still_time += Frametime / WIGGLE_FALLOFF_TIME;
}
if(obj->mtype.phys_info.last_still_time < 0.0)
obj->mtype.phys_info.last_still_time = 0.0;
else if(obj->mtype.phys_info.last_still_time > 1.0)
obj->mtype.phys_info.last_still_time = 1.0;
// Ship always keeps 10% of its wiggle
// if(obj->mtype.phys_info.last_still_time < 1.0)
{
float scaler = 1.0f - obj->mtype.phys_info.last_still_time;
if(scaler < .1f)
scaler = .1f;
swiggle = obj->mtype.phys_info.wiggle_amplitude *
(scaler) *
(FixSin((angle)((int)(Gametime * obj->mtype.phys_info.wiggles_per_sec * 65535) % 65535)) -
FixSin((angle)((int)((Gametime - Frametime) * obj->mtype.phys_info.wiggles_per_sec * 65535) % 65535)));
w_pos = obj->pos + obj->orient.uvec * (swiggle);
fq.p0 = &obj->pos;
fq.startroom = obj->roomnum;
fq.p1 = &w_pos;
fq.rad = obj->size;
fq.thisobjnum = objnum;
fq.ignore_obj_list = NULL;
fq.flags = FQ_CHECK_OBJS | FQ_RECORD | FQ_IGNORE_POWERUPS;
fq.flags |= FQ_NEW_RECORD_LIST;
fq.flags |= FQ_CHECK_CEILING;
// Need for weapons to go thru transparent areas of a texture
if (obj->type == OBJ_WEAPON)
fq.flags |= FQ_TRANSPOINT;
if(obj->flags & OF_NO_OBJECT_COLLISIONS)
fq.flags &= ~FQ_CHECK_OBJS;
fate = fvi_FindIntersection(&fq,&hit_info);
// Only wiggle on a non-hit case
if(fate == HIT_NONE)
{
ASSERT(hit_info.hit_room != -1);
f_start_fvi_record = false;
// update object's position and segment number
ObjSetPos(obj,&hit_info.hit_pnt,hit_info.hit_room, NULL, false);
}
}
}
// If the object is effected by gravity (normal, lighter than air, and anti-gravity)
if (obj->mtype.phys_info.flags & PF_GRAVITY)
{
total_force.x = total_force.z = 0.0;
total_force.y = Gravity_strength * obj->mtype.phys_info.mass;
}
else if (obj->mtype.phys_info.flags & PF_REVERSE_GRAVITY)
{
total_force.x = total_force.z = 0.0;
total_force.y = -Gravity_strength * obj->mtype.phys_info.mass;
}
else
{
total_force.x = total_force.y = total_force.z = 0.0;
}
obj->flags &= (~OF_STOPPED_THIS_FRAME);
// Do rotation velocity/accel stuff
bool f_rotated = false;
if (!(fabs(pi->velocity.x) > .000001 || fabs(pi->velocity.y) > .000001 || fabs(pi->velocity.z) > .000001 ||
fabs(pi->thrust.x) > .000001 || fabs(pi->thrust.y) > .000001 || fabs(pi->thrust.z) > .000001 ||
fabs(pi->rotvel.x) > .000001 || fabs(pi->rotvel.y) > .000001 || fabs(pi->rotvel.z) > .000001 ||
fabs(pi->rotthrust.x) > .000001 || fabs(pi->rotthrust.y) > .000001 || fabs(pi->rotthrust.z) > .000001 ||
(obj->mtype.phys_info.flags & PF_GRAVITY) ||
((!ROOMNUM_OUTSIDE(obj->roomnum)) && Rooms[obj->roomnum].wind != Zero_vector) ||
(obj->mtype.phys_info.flags & PF_WIGGLE) ||
((obj->ai_info != NULL) && ((obj->ai_info->flags & AIF_REPORT_NEW_ORIENT) != 0))))
{
if((obj->flags & OF_MOVED_THIS_FRAME))
{
obj->flags &= (~OF_MOVED_THIS_FRAME);
obj->flags |= OF_STOPPED_THIS_FRAME;
}
return;
}
if(obj->ai_info)
obj->ai_info->flags &= ~AIF_REPORT_NEW_ORIENT;
obj->flags |= OF_MOVED_THIS_FRAME;
// This assumes that the thrust does not change within a frame. If it does, account for it
// there... like missiles bouncing off a wall and changing heading. --chrishack
if (obj->mtype.phys_info.drag != 0.0)
{
if (obj->mtype.phys_info.flags & PF_USES_THRUST)
{
total_force += obj->mtype.phys_info.thrust;
}
}
// mprintf((0, "PHYSICS: Current obj: %d, %9.2fx %9.2fy %9.2fz\n", OBJNUM(obj), XYZ(&obj->pos)));
// mprintf((2,1,0,"x %9.2f\ny %9.2f\nz %9.2f", XYZ(&obj->mtype.phys_info.velocity)));
// mprintf((0, "PHYSICS: Current velocity (%f, %f, %f)\n", XYZ(&obj->mtype.phys_info.velocity)));
Physics_normal_counter++;
// Simulate movement until we are done (i.e. Frametime has passed or object is done moving)
do
{
// Values at start of sim loop
start_pos = obj->pos;
start_vel = obj->mtype.phys_info.velocity;
start_orient = obj->orient;
start_rotvel = obj->mtype.phys_info.rotvel;
start_turnroll = obj->mtype.phys_info.turnroll;
start_room = obj->roomnum;
matrix end_orient = start_orient;
vector end_rotvel = start_rotvel;
angle end_turnroll = start_turnroll;
vector end_vel = start_vel;
#ifdef _DEBUG
// This records the sim.
sim_loop_record[count].phys_info = obj->mtype.phys_info;
#endif
// Initailly assume that this is the last sim cycle
f_continue_sim = false;
// Determines forces
if (count > 0)
{
// If the object is effected by gravity (normal, lighter than air, and anti-gravity)
if (obj->mtype.phys_info.flags & PF_GRAVITY)
{
total_force.x = total_force.z = 0.0;
total_force.y = Gravity_strength * obj->mtype.phys_info.mass;
}
else if (obj->mtype.phys_info.flags & PF_REVERSE_GRAVITY)
{
total_force.x = total_force.z = 0.0;
total_force.y = -Gravity_strength * obj->mtype.phys_info.mass;
}
else if (!(obj->mtype.phys_info.flags & PF_BOUNCE))
{
// Player ship
}
else
{
total_force.x = total_force.y = total_force.z = 0.0;
}
}
// Compute rotational information
// Chrishack -- replace OBJ_CLUTTER with a BBOX_HIT_TYPE
bool f_set_orient;
if((f_rotated == false && count == 0) || obj->type == OBJ_CLUTTER)
{
f_rotated = true;
f_set_orient = true;
PhysicsDoSimRot(obj, sim_time_remaining, &end_orient, &obj->mtype.phys_info.rotthrust, &end_rotvel, &end_turnroll);
/* vector init_pos = obj->pos + obj->wall_sphere_offset;*/
ObjSetOrient(obj, &end_orient);
/* vector new_pos = obj->pos + obj->wall_sphere_offset;
if(obj->wall_sphere_offset != Zero_vector && obj->type == OBJ_ROBOT && !(obj->mtype.phys_info.flags & PF_POINT_COLLIDE_WALLS))
{
fq.p0 = &init_pos;
fq.startroom = obj->roomnum;
fq.p1 = &new_pos;
fq.rad = Poly_models[obj->rtype.pobj_info.model_num].wall_size;
fq.thisobjnum = objnum;
fq.ignore_obj_list = NULL;
fq.flags = 0;
fate = fvi_FindIntersection(&fq,&hit_info);
// Only wiggle on a non-hit case
if(fate != HIT_NONE)
{
end_orient = start_orient;
ObjSetOrient(obj, &start_orient);
}
}*/
}
else
{
f_set_orient = false;
}
// Updates the thrust vector to the orientation for homing weapons
if((obj->type == OBJ_WEAPON) &&
(pi->flags & PF_USES_THRUST) &&
(pi->flags & PF_HOMING))
{
pi->thrust = end_orient.fvec * pi->full_thrust;
movement_vec = obj->mtype.phys_info.velocity * Frametime;
movement_pos = obj->pos + movement_vec;
}
PhysicsDoSimLinear( *obj, obj->pos, total_force, end_vel, movement_vec, movement_pos, sim_time_remaining, count);
// Only do velocity until we've reached our destination position
// This is useful for multiplayer
if (obj->mtype.phys_info.flags & PF_DESTINATION_POS)
{
vector sub1=obj->pos-obj->mtype.phys_info.dest_pos;
vector sub2=movement_pos-obj->mtype.phys_info.dest_pos;
if (vm_DotProduct(&sub1,&sub2)<=0)
{
obj->mtype.phys_info.flags &=~PF_DESTINATION_POS;
vm_MakeZero (&obj->mtype.phys_info.velocity);
vm_MakeZero (&movement_vec);
movement_pos=obj->pos;
goto end_of_sim;
}
if ((vm_VectorDistanceQuick (&obj->mtype.phys_info.dest_pos,&obj->pos))<1)
{
vm_MakeZero (&obj->mtype.phys_info.velocity);
obj->mtype.phys_info.flags &=~PF_DESTINATION_POS;
goto end_of_sim;
}
}
// We are done, as there is no collision response with PF_NO_COLLIDE
if(obj->mtype.phys_info.flags & PF_NO_COLLIDE)
{
obj->mtype.phys_info.rotvel = end_rotvel;
obj->mtype.phys_info.turnroll = end_turnroll;
obj->mtype.phys_info.velocity = end_vel;
// ObjSetOrient(obj,&end_orient);
ObjSetPos(obj,&movement_pos,obj->roomnum, NULL, false);
ObjSetAABB(obj);
obj->last_pos = init_pos;
goto end_of_sim;
}
// If we are stationary, we are done :) -- breaks on high framerates (Gravity)
// if(vm_GetMagnitude(&movement_vec) < 0.00001)
// if(vm_GetMagnitude(&start_vel) < 0.00001)
// if(vm_GetMagnitude(&end_vel) < 0.00001)
// if(vm_GetMagnitude(&obj->mtype.phys_info.thrust) < 0.00001)
// if(vm_GetMagnitude(&obj->mtype.phys_info.rotthrust) < .0001)
// if(vm_GetMagnitude(&start_rotvel) < .0001)
// if(vm_GetMagnitude(&end_rotvel) < .0001)
// {
// mprintf((0, "At rest\n"));
// goto end_of_sim;
// }
// mprintf((0, "PHYSICS: Try to move to (%f, %f, %f)\n", movement_pos.x, movement_pos.y, movement_pos.z));
Physics_normal_looping_counter++;
// Cap ignore list -- (Objects we already hit this frame)
ignore_obj_list[n_ignore_objs] = -1;
vector temp_vel = obj->mtype.phys_info.velocity;
obj->mtype.phys_info.velocity = (movement_pos - start_pos)/sim_time_remaining;
fq.p0 = &obj->pos;
fq.startroom = obj->roomnum;
fq.p1 = &movement_pos;
fq.rad = obj->size;
fq.thisobjnum = objnum;
fq.ignore_obj_list = ignore_obj_list;
fq.flags = FQ_CHECK_OBJS | FQ_RECORD;
if(f_start_fvi_record) fq.flags |= FQ_NEW_RECORD_LIST;
fq.o_orient = &start_orient;
fq.o_rotvel = &start_rotvel;
fq.o_rotthrust = &obj->mtype.phys_info.rotthrust;
fq.o_turnroll = &start_turnroll;
fq.o_velocity = &start_vel;
fq.o_thrust = &total_force;
f_start_fvi_record = false;
// Need for weapons to go thru transparent areas of a texture
if (obj->type == OBJ_WEAPON)
fq.flags |= FQ_TRANSPOINT;
// Added a ceiling for players and powerups
if (obj->type == OBJ_POWERUP || (obj->type == OBJ_PLAYER && obj->control_type != CT_AI) || obj->type == OBJ_OBSERVER || (obj == Players[Player_object->id].guided_obj) || (obj->flags & OF_FORCE_CEILING_CHECK))
fq.flags |= FQ_CHECK_CEILING;
if((obj->type == OBJ_WEAPON) && (obj->ctype.laser_info.hit_status != WPC_NOT_USED))
fq.flags |= FQ_IGNORE_WALLS;
if(obj->flags & OF_NO_OBJECT_COLLISIONS)
fq.flags &= ~FQ_CHECK_OBJS;
if(IS_GENERIC(obj->type) && (Object_info[obj->id].flags & OIF_IGNORE_FORCEFIELDS_AND_GLASS))
fq.flags |= FQ_IGNORE_RENDER_THROUGH_PORTALS;
// Initially assume that we fully move
hit_info.hit_turnroll = end_turnroll;
hit_info.hit_orient = end_orient;
hit_info.hit_rotvel = end_rotvel;
hit_info.hit_velocity = end_vel;
hit_info.hit_time = sim_time_remaining;
if(obj->type == OBJ_PLAYER)
{
fq.flags |= FQ_MULTI_POINT;
}
fate = fvi_FindIntersection(&fq,&hit_info);
if(fate != HIT_NONE)
{
if(obj->type == OBJ_PLAYER && hit_info.num_hits > 1)
{
vector n = Zero_vector;
int i;
for(i = 0; i < hit_info.num_hits; i++)
{
n += hit_info.hit_wallnorm[i];
}
hit_info.hit_wallnorm[0] = n;
}
vm_NormalizeVector(&hit_info.hit_wallnorm[0]);
}
/* if(obj == Player_object && fate != HIT_NONE)
{
mprintf((0, "Hit type %d, obj %d\n", fate, hit_info.hit_object[0]));
if(fate == HIT_OBJECT || fate == HIT_SPHERE_2_POLY_OBJECT)
{
mprintf((0, "Hit object type %d, id %d\n", Objects[hit_info.hit_object[0]].type, Objects[hit_info.hit_object[0]].id));
}
}
*/
obj->mtype.phys_info.velocity = temp_vel;
// Accounts for precomputed hit rays
if((obj->type == OBJ_WEAPON) && (obj->ctype.laser_info.hit_status == WPC_HIT_WALL))
{
vector to_hit_pnt,to_fvi_pos;
if (fate == HIT_NONE) {
to_hit_pnt = obj->ctype.laser_info.hit_pnt - obj->pos;
to_fvi_pos = obj->ctype.laser_info.hit_pnt - hit_info.hit_pnt;
}
else {
to_hit_pnt = obj->ctype.laser_info.hit_wall_pnt - obj->pos;
to_fvi_pos = obj->ctype.laser_info.hit_wall_pnt - hit_info.hit_face_pnt[0];
}
if((to_hit_pnt * to_fvi_pos) <= 0.0f)
{
fate = hit_info.hit_type[0] = HIT_WALL;
hit_info.hit_pnt = obj->ctype.laser_info.hit_pnt;
hit_info.hit_face_pnt[0] = obj->ctype.laser_info.hit_wall_pnt;
hit_info.hit_room = obj->ctype.laser_info.hit_room;
hit_info.hit_face_room[0] = obj->ctype.laser_info.hit_pnt_room;
hit_info.hit_wallnorm[0] = obj->ctype.laser_info.hit_wall_normal;
hit_info.hit_face[0] = obj->ctype.laser_info.hit_face;
obj->ctype.laser_info.hit_status = WPC_NOT_USED;
}
}
// chrishack -- move all FVI ASSERT to here!
ASSERT( fate != HIT_WALL || (fate == HIT_WALL && hit_info.hit_face[0] > -1));
ASSERT(hit_info.hit_pnt.x > -100000000.0);
ASSERT(hit_info.hit_pnt.y > -100000000.0);
ASSERT(hit_info.hit_pnt.z > -100000000.0);
ASSERT(hit_info.hit_pnt.x < 100000000.0);
ASSERT(hit_info.hit_pnt.y < 100000000.0);
ASSERT(hit_info.hit_pnt.z < 100000000.0);
ASSERT(!(fate != HIT_OUT_OF_TERRAIN_BOUNDS && hit_info.hit_room == -1));
#ifdef _DEBUG
sim_loop_record[count].start_pos = obj->pos;
sim_loop_record[count].hit_info = hit_info;
if(fate != HIT_NONE)
{
if(Physics_player_verbose)
{
objnum = ObjCreate( OBJ_DEBUG_LINE, 1, hit_info.hit_room, &hit_info.hit_face_pnt[0], NULL);
if(objnum >= 0) { //DAJ -1FIX
Objects[objnum].rtype.line_info.end_pos = hit_info.hit_face_pnt[0] + hit_info.hit_wallnorm[0];
Objects[objnum].size = vm_VectorDistance(&Player_object->pos, &hit_info.hit_pnt);
ObjSetAABB(&Objects[objnum]);
Objects[objnum].flags |= OF_USES_LIFELEFT;
Objects[objnum].lifeleft = 10.0f;
Objects[objnum].lifetime = 10.0f;
}
if(obj == Player_object)
{
mprintf((0, "Fate = %d for player - ", fate));
if(fate == HIT_OBJECT ||
fate == HIT_SPHERE_2_POLY_OBJECT)
{
if(Objects[hit_info.hit_object[0]].flags & OF_BIG_OBJECT)
{
mprintf((0, "Big object\n"));
}
else
{
mprintf((0, "Small object\n"));
}
}
else
{
mprintf((0, "non-object\n"));
}
}
}
}
#endif
if(f_set_orient)
{
obj->mtype.phys_info.turnroll = hit_info.hit_turnroll;
obj->mtype.phys_info.rotvel = hit_info.hit_rotvel;
// ObjSetOrient(obj, &hit_info.hit_orient);
f_set_orient = false;
}
obj->mtype.phys_info.velocity = hit_info.hit_velocity;
// Instant bails for collision response
if(obj->type == OBJ_PLAYER && ((fate == HIT_OUT_OF_TERRAIN_BOUNDS) || (ROOMNUM_OUTSIDE(hit_info.hit_room) && GetTerrainCellFromPos(&hit_info.hit_pnt) == -1)))
{
ObjSetPos(obj,&init_pos, init_room, NULL, false);
obj->last_pos = init_pos;
return;
}
else if (fate == HIT_OUT_OF_TERRAIN_BOUNDS)
{
SetObjectDeadFlag (obj);
obj->last_pos = init_pos;
return;
}
// This is so the collide code knows that last collision position if there are multiple collisions
obj->last_pos = obj->pos;
// update object's position and segment number
ObjSetPos(obj,&hit_info.hit_pnt,hit_info.hit_room, NULL, false);
// Calulate amount of sim time left
if(fate == HIT_NONE)
{
moved_time = old_sim_time_remaining = sim_time_remaining;
sim_time_remaining = 0.0;
f_continue_sim = false;
}
else
{
vm_NormalizeVector(&hit_info.hit_wallnorm[0]);
vector moved_vec_n;
float attempted_dist,actual_dist;
// Save results of this simulation
old_sim_time_remaining = sim_time_remaining;
moved_vec_n = obj->pos - start_pos; //chrishack -- use this copy
if(moved_vec_n != Zero_vector)
{
actual_dist = vm_NormalizeVector(&moved_vec_n);
}
else
{
actual_dist = 0.0f;
}
// chrishack -- potentially bad -- outside to inside stuff
// We where sitting in a wall -- invalid starting point
//moved backwards
if (fate == HIT_WALL && moved_vec_n * movement_vec < -0.000001 && actual_dist != 0.0)
{
// mprintf((0, "Obj %d Flew backwards!\n", OBJNUM(obj)));
// mprintf((0, "PHYSICS NOTE: (%f, %f, %f) to (%f, %f, %f)\n", XYZ(&start_pos), XYZ(&obj->pos)));
//don't change position or sim_time_remaining
ObjSetPos(obj, &start_pos, start_room, NULL, false);
moved_time = 0.0;
}
else
{
// Compute more results of this simulation
attempted_dist = vm_GetMagnitude(&movement_vec);
sim_time_remaining = sim_time_remaining * ((attempted_dist - actual_dist) / attempted_dist);
moved_time = old_sim_time_remaining - sim_time_remaining;
// chrishack -- we have no time left (plus some) This can happen if FVI corrects a near tangental
// movement by adding the radius - thus, we move a little too far.
if (sim_time_remaining < 0.0)
{
sim_time_remaining = 0.0;
moved_time = old_sim_time_remaining;
}
// chrishack -- negative simulation time pasted for this sim frame
if (sim_time_remaining > old_sim_time_remaining)
{
// mprintf((0,"PHYSICS WARNING: Bogus sim_time_remaining = %15.13f, old = %15.13f\nAttempted d = %15.13f, actual = %15.13f\n",sim_time_remaining,old_sim_time_remaining, attempted_dist, actual_dist));
// Int3();
sim_time_remaining = old_sim_time_remaining;
moved_time = 0.0;
f_continue_sim = false;
}
}
// // Get the collision speed as a linear interp.
// if(old_sim_time_remaining > 0.0f)
// {
// Get the collision speed as a linear interp.
if(fate == HIT_OBJECT || fate == HIT_SPHERE_2_POLY_OBJECT || fate == HIT_TERRAIN || fate == HIT_WALL)
{
if(moved_time > 0.0001f)
{
obj->mtype.phys_info.velocity = (hit_info.hit_pnt - start_pos)/moved_time;
}
else
{
//mprintf((0, "Moved time is ZERO\n")); -- Add this back -- chrishack
ASSERT(old_sim_time_remaining > 0.0f);
obj->mtype.phys_info.velocity = start_vel;
}
}
else
{
if(old_sim_time_remaining > 0.0)
{
obj->mtype.phys_info.velocity = obj->mtype.phys_info.velocity * (moved_time / old_sim_time_remaining) + start_vel * (sim_time_remaining / old_sim_time_remaining);
}
}
}
bounced=0;
// Collision response code
switch( fate )
{
case HIT_NONE:
if (obj->type == OBJ_WEAPON && (obj->mtype.phys_info.flags & (PF_GRAVITY | PF_WIND )))
{
if(obj->mtype.phys_info.velocity != Zero_vector)
vm_VectorToMatrix(&obj->orient,&obj->mtype.phys_info.velocity,&obj->orient.uvec,NULL);
}
f_continue_sim = false;
break;
case HIT_WALL: // Finally unified, still needs some work, but it certainly better like this :)
case HIT_TERRAIN:
{
bool f_volatile_lava; //either volatile or lava
bool f_forcefield;
float ff_bounce_factor = 2.0f;
//Check if volatile
int tmap;
if (!ROOMNUM_OUTSIDE(hit_info.hit_face_room[0])) //Make sure we've hit a wall, and not terrain
{
tmap = Rooms[hit_info.hit_face_room[0]].faces[hit_info.hit_face[0]].tmap;
}
else
{
tmap = Terrain_tex_seg[Terrain_seg[CELLNUM(hit_info.hit_face_room[0])].texseg_index].tex_index;
}
f_volatile_lava = (GameTextures[tmap].flags & (TF_VOLATILE+TF_LAVA)) != 0;
f_forcefield = (GameTextures[tmap].flags & TF_FORCEFIELD) != 0;
if(f_forcefield)
{
int i;
for(i = 0; i < MAX_FORCE_FIELD_BOUNCE_TEXTURES; i++)
{
if(tmap == force_field_bounce_texture[i])
{
ff_bounce_factor = force_field_bounce_multiplier[i];
break;
}
}
}
// if(obj->type != OBJ_CLUTTER)
{
vector moved_v;
float hit_speed, wall_part;
float hit_dot = 1.0;
float luke_test;
if(obj->type == OBJ_PLAYER)
{
luke_test = vm_GetMagnitude(&obj->mtype.phys_info.velocity);
}
// Find hit speed
moved_v = obj->pos - start_pos; // chrishack -- We already computed this!!!!!!!
wall_part = moved_v * hit_info.hit_wallnorm[0];
if(obj->mtype.phys_info.hit_die_dot > 0.0)
{
vector m_normal = start_pos - obj->pos;
vm_NormalizeVector(&m_normal);
hit_dot = m_normal * hit_info.hit_wallnorm[0];
}
hit_speed = -(wall_part / moved_time);
//Process wall hit
bool hit_wall = collide_object_with_wall( obj, hit_speed, hit_info.hit_face_room[0], hit_info.hit_face[0], &hit_info.hit_face_pnt[0], &hit_info.hit_wallnorm[0], hit_dot );
if ( !(obj->flags&OF_DEAD) )
{
//Check for not really hitting the wall (because it was glass & broke)
if (!hit_wall) {
f_continue_sim = true;
break;
}
if(obj->type == OBJ_WEAPON && ((obj->mtype.phys_info.flags & PF_BOUNCE) || f_forcefield))
obj->mtype.phys_info.flags &= (~PF_NO_COLLIDE_PARENT);
// Slide object along wall
//We're constrained by wall, so subtract wall part from the velocity vector
wall_part = hit_info.hit_wallnorm[0] * obj->mtype.phys_info.velocity;
if (!f_forcefield && !f_volatile_lava && (obj->mtype.phys_info.num_bounces <= 0) && (obj->mtype.phys_info.flags & PF_STICK))
{
obj->movement_type = MT_NONE;
if(!ROOMNUM_OUTSIDE(hit_info.hit_face_room[0]))
{
if(GameTextures[Rooms[hit_info.hit_face_room[0]].faces[hit_info.hit_face[0]].tmap].flags & (TF_VOLATILE | TF_LAVA))
{
SetObjectDeadFlag (obj);
}
}
else
{
if(GameTextures[Terrain_tex_seg[Terrain_seg[CELLNUM(hit_info.hit_room)].texseg_index].tex_index].flags & (TF_VOLATILE | TF_LAVA))
{
SetObjectDeadFlag (obj);
}
}
if(!ROOMNUM_OUTSIDE(hit_info.hit_face_room[0]) && (Rooms[hit_info.hit_face_room[0]].faces[hit_info.hit_face[0]].portal_num >= 0))
{
obj->flags |= OF_STUCK_ON_PORTAL;
obj->mtype.phys_info.stuck_room = hit_info.hit_face_room[0];
obj->mtype.phys_info.stuck_portal = Rooms[hit_info.hit_face_room[0]].faces[hit_info.hit_face[0]].portal_num;
}
vm_MakeZero(&obj->mtype.phys_info.velocity);
obj->last_pos = init_pos;
goto end_of_sim;
}
else if (f_volatile_lava || f_forcefield || (obj->mtype.phys_info.flags & PF_BOUNCE))
{
wall_part *= 2.0; //Subtract out wall part twice to achieve bounce
bounced = 1; //this object bounced
if (f_forcefield)
{
if (obj->type == OBJ_PLAYER)
wall_part *= ff_bounce_factor; //player bounce twice as much -- chrishack try without this too.
}
// New bounceness code
if (!f_forcefield && (obj->mtype.phys_info.flags & PF_BOUNCE) &&
(obj->mtype.phys_info.num_bounces != PHYSICS_UNLIMITED_BOUNCE))
{
if(obj->mtype.phys_info.num_bounces == 0)
{
if (obj->type!=OBJ_PLAYER && (obj->flags & OF_DYING))
{
ASSERT((obj->control_type == CT_DYING) || (obj->control_type == CT_DYING_AND_AI));
DestroyObject(obj,50.0,obj->ctype.dying_info.death_flags);
}
else
{
if (obj->type!=OBJ_PLAYER)
SetObjectDeadFlag (obj);
else
mprintf ((0,"Got a ship that was set for bounce!!! BAD!!!\n"));
}
}
obj->mtype.phys_info.num_bounces--;
}
{
float v_mag = vm_GetMagnitude(&obj->mtype.phys_info.velocity);
if(obj->type == OBJ_CLUTTER && hit_info.hit_wallnorm[0].y > .4 && (obj->mtype.phys_info.velocity * hit_info.hit_wallnorm[0] > -2.0f))
{
if(obj->mtype.phys_info.flags & PF_GRAVITY)
{
f_turn_gravity_on = true;
obj->mtype.phys_info.flags &= (~(PF_GRAVITY | PF_BOUNCE));
obj->mtype.phys_info.drag *= 300.0f;
}
if(v_mag < 1.8f)
{
obj->mtype.phys_info.velocity = Zero_vector;
obj->mtype.phys_info.rotvel = Zero_vector;
goto skip_sim;
}
else
{
goto slide_sim;
}
}
if(!f_forcefield && !(f_volatile_lava && obj->type == OBJ_PLAYER))
bump_obj_against_fixed(obj, &hit_info.hit_face_pnt[0], &hit_info.hit_wallnorm[0]);
else
obj->mtype.phys_info.velocity += hit_info.hit_wallnorm[0] * (wall_part * -1.0f);
}
// if(!f_forcefield && !(f_volatile && obj->type == OBJ_PLAYER))
// {
// if(obj->mtype.phys_info.coeff_restitution != 1.0f)
// obj->mtype.phys_info.velocity -= (obj->mtype.phys_info.velocity * (1.0f - obj->mtype.phys_info.coeff_restitution));
// }
// if(!f_forcefield && !(f_volatile && obj->type == OBJ_PLAYER))
// bump_obj_against_fixed(obj, &hit_info.hit_face_pnt[0], &hit_info.hit_wallnorm[0]);
//
// if(hit_info.hit_wallnorm[0].y > .4 && (vm_GetMagnitude(&obj->mtype.phys_info.velocity) < .001f || obj->mtype.phys_info.velocity * hit_info.hit_wallnorm[0] <= 0.0f))
// {
// mprintf((0, "At Rest!\n"));
// obj->movement_type = MT_NONE;
// obj->mtype.phys_info.velocity = Zero_vector;
// f_continue_sim = false;
// }
//mprintf((0, "(%f, %f, %f) after bounce\n", XYZ(&obj->mtype.phys_info.velocity)));
//mprintf((0, "p (%f, %f, %f) after bounce\n", XYZ(&obj->pos)));
}
else
{
slide_sim:
float wall_force;
wall_force = total_force * hit_info.hit_wallnorm[0];
if(obj->type != OBJ_CLUTTER)
total_force += hit_info.hit_wallnorm[0] * (wall_force * -1.001); // 1.001 so that we are not quite tangential
else
total_force += hit_info.hit_wallnorm[0] * (wall_force * -1.0001); // 1.001 so that we are not quite tangential
// Update velocity from wall hit.
if(obj->type != OBJ_CLUTTER)
obj->mtype.phys_info.velocity += hit_info.hit_wallnorm[0] * (wall_part * -1.001); // 1.001 so that we are not quite tangential
else
obj->mtype.phys_info.velocity += hit_info.hit_wallnorm[0] * (wall_part * -1.0001); // 1.001 so that we are not quite tangential
if((obj->type == OBJ_ROBOT || obj->type == OBJ_PLAYER || (obj->type == OBJ_BUILDING && obj->ai_info)) && sim_time_remaining == old_sim_time_remaining)
{
obj->mtype.phys_info.velocity += hit_info.hit_wallnorm[0];
}
if(obj->type == OBJ_PLAYER)
{
float real_vel;
real_vel = vm_NormalizeVector(&obj->mtype.phys_info.velocity);
obj->mtype.phys_info.velocity *= ((real_vel + luke_test)/2);
//obj->mtype.phys_info.velocity *= (luke_test);
}
else if(obj->type == OBJ_CLUTTER && !(obj->mtype.phys_info.flags & PF_LOCK_MASK))
{
// Do rolling rotvel hack
obj->mtype.phys_info.rotvel = Zero_vector;
if(obj->mtype.phys_info.velocity != Zero_vector)
{
vector axis;
float speed = vm_GetMagnitude(&obj->mtype.phys_info.velocity);
vm_CrossProduct(&axis, &obj->mtype.phys_info.velocity, &hit_info.hit_wallnorm[0]);
vm_NormalizeVector(&axis);
axis = axis * obj->orient;
float scale = speed * 65535.0f / (2.0f * PI * obj->size);
obj->mtype.phys_info.rotvel = axis * -scale;
}
}
}
skip_sim:
//mprintf((0, "PHYSICS: Wall normal (%f, %f, %f)\n", XYZ(&hit_info.hit_wallnorm[0])));
//mprintf((0, "PHYSICS: Bounded velocity (%f, %f, %f)\n", XYZ(&obj->mtype.phys_info.velocity)));
// This only happens if the new velocity is set from hitting a forcefield.
if(!(fabs(obj->mtype.phys_info.velocity.x) < MAX_OBJECT_VEL &&
fabs(obj->mtype.phys_info.velocity.y) < MAX_OBJECT_VEL &&
fabs(obj->mtype.phys_info.velocity.z) < MAX_OBJECT_VEL))
{
float mag = vm_NormalizeVector(&obj->mtype.phys_info.velocity);
mprintf((0, "PHYSICS: Bashing vel for Obj %d of type %d with %f velocity", objnum, obj->type, mag));
obj->mtype.phys_info.velocity *= MAX_OBJECT_VEL * 0.1f;
}
// Weapons should face their new heading. This is so missiles are pointing in the correct direct.
if (obj->type == OBJ_WEAPON && (bounced || (obj->mtype.phys_info.flags & (PF_GRAVITY | PF_WIND ) )))
if(obj->mtype.phys_info.velocity !=Zero_vector)
vm_VectorToMatrix(&obj->orient,&obj->mtype.phys_info.velocity,&obj->orient.uvec,NULL);
}
}
//else
//{
/* vector r1 = hit_info.hit_face_pnt[0] - obj->pos;
vector w1;
vector n1;
float temp1;
float j;
matrix o_t1 = obj->orient;
vm_TransposeMatrix(&o_t1);
vector cmp1 = obj->mtype.phys_info.rotvel * o_t1;
ConvertEulerToAxisAmount(&cmp1, &n1, &temp1);
n1 *= temp1;
if(temp1 != 0.0f)
{
vm_CrossProduct(&w1, &n1, &r1);
}
else
{
w1 = Zero_vector;
}
vector p1 = obj->mtype.phys_info.velocity + w1; //*((2.0f*(float)PI)/65535.0f);
if(p1.y < 0.0)
{
// if(p1.y == 0.0)
// mprintf((0, "AT REST: p1 (%f, %f, %f)\n", XYZ(&p1)));
// else
// mprintf((0, "SHIT: p1 (%f, %f, %f)\n", XYZ(&p1)));
//
// p1.y = -.0001f;
// }
float v_rel;
float m1 = obj->mtype.phys_info.mass;
v_rel = hit_info.hit_wallnorm[0] * (p1);
float e = .1f;
vector c1;
vector cc1;
float cv1;
float i1 = (m1/12.0)*(2.0f * pow(obj->size*2.0, 2));
vm_CrossProduct(&c1, &r1, &hit_info.hit_wallnorm[0]);
c1 = c1/i1;
vm_CrossProduct(&cc1, &c1, &r1);
cv1 = (hit_info.hit_wallnorm[0])*c1;
j = (-(1.0f + e))*v_rel;
j /= (1/m1 + cv1);
obj->mtype.phys_info.velocity += ((j*(hit_info.hit_wallnorm[0]))/m1);
vector jcn = j * (hit_info.hit_wallnorm[0]);
vm_CrossProduct(&c1, &r1, &jcn);
n1 = (c1)/i1;
temp1 = vm_NormalizeVector(&n1);
vector txx1;
ConvertAxisAmountToEuler(&n1, &temp1, &txx1);
obj->mtype.phys_info.rotvel += (txx1*obj->orient);
}
else
{
obj->mtype.phys_info.velocity.y = .001f;
obj->mtype.phys_info.rotvel = Zero_vector;
}*/
// }
f_continue_sim = true;
}
break;
case HIT_CEILING:
{
vector moved_v;
float wall_part;
float luke_test;
if(obj->type == OBJ_PLAYER)
{
luke_test = vm_GetMagnitude(&obj->mtype.phys_info.velocity);
}
// Find hit speed
moved_v = obj->pos - start_pos; // chrishack -- We already computed this!!!!!!!
wall_part = moved_v * hit_info.hit_wallnorm[0];
//We're constrained by wall, so subtract wall part from the velocity vector
wall_part = hit_info.hit_wallnorm[0] * obj->mtype.phys_info.velocity;
if (obj->mtype.phys_info.flags & PF_BOUNCE)
{
wall_part *= 2.0; //Subtract out wall part twice to achieve bounce
obj->mtype.phys_info.velocity += hit_info.hit_wallnorm[0] * (wall_part * -1.0f);
if(obj->mtype.phys_info.coeff_restitution != 1.0f)
obj->mtype.phys_info.velocity -= (obj->mtype.phys_info.velocity * (1.0f - obj->mtype.phys_info.coeff_restitution));
}
else
{
float wall_force;
wall_force = total_force * hit_info.hit_wallnorm[0];
total_force += hit_info.hit_wallnorm[0] * (wall_force * -1.001); // 1.001 so that we are not quite tangential
// Update velocity from wall hit.
obj->mtype.phys_info.velocity += hit_info.hit_wallnorm[0] * (wall_part * -1.001); // 1.001 so that we are not quite tangential
if(obj->type == OBJ_PLAYER)
{
float real_vel;
real_vel = vm_NormalizeVector(&obj->mtype.phys_info.velocity);
obj->mtype.phys_info.velocity *= ((real_vel + luke_test)/2.0f);
//obj->mtype.phys_info.velocity *= (luke_test);
}
}
// This only happens if the new velocity is set from hitting a forcefield.
ASSERT(fabs(obj->mtype.phys_info.velocity.x) < MAX_OBJECT_VEL &&
fabs(obj->mtype.phys_info.velocity.y) < MAX_OBJECT_VEL &&
fabs(obj->mtype.phys_info.velocity.z) < MAX_OBJECT_VEL);
// Weapons should face their new heading. This is so missiles are pointing in the correct direct.
if (obj->type == OBJ_WEAPON && (bounced || (obj->mtype.phys_info.flags & (PF_GRAVITY | PF_WIND ) )))
vm_VectorToMatrix(&obj->orient,&obj->mtype.phys_info.velocity,&obj->orient.uvec,NULL);
f_continue_sim = true;
}
break;
case HIT_OBJECT:
case HIT_SPHERE_2_POLY_OBJECT:
{
vector old_force; // -- chrishack
// Mark the hit object so that on the following sim frames, in this game frame, ignore this object.
ASSERT(hit_info.hit_object[0] != -1); // chrishack move this ASSERT fvi stuff above
// chrishack -- we should have this point from FVI!!!!!!!!!!!
// Calculcate the hit point between the two objects.
//old_vel = obj->mtype.phys_info.velocity;
old_force = obj->mtype.phys_info.thrust;
obj->mtype.phys_info.thrust = total_force;
// hit_info.hit_wallnorm[0] *= -1.0f;
// mprintf((0, "hit dist %f\n", hit_info.hit_dist));
collide_two_objects( obj, &Objects[hit_info.hit_object[0]], &hit_info.hit_face_pnt[0], &hit_info.hit_wallnorm[0], &hit_info);
if(obj->movement_type == MT_OBJ_LINKED)
goto end_of_sim;
total_force = obj->mtype.phys_info.thrust;
obj->mtype.phys_info.thrust = old_force;
if((obj->type != OBJ_POWERUP && Objects[hit_info.hit_object[0]].type != OBJ_POWERUP) &&
(obj->type == OBJ_CLUTTER ||
obj->type == OBJ_ROBOT ||
obj->type == OBJ_PLAYER ||
(obj->type == OBJ_BUILDING && obj->ai_info)) &&
sim_time_remaining == old_sim_time_remaining &&
(Objects[hit_info.hit_object[0]].movement_type == MT_NONE ||
(Objects[hit_info.hit_object[0]].mtype.phys_info.velocity == Zero_vector &&
(Objects[hit_info.hit_object[0]].mtype.phys_info.flags & PF_LOCK_MASK))))
{
obj->mtype.phys_info.velocity += hit_info.hit_wallnorm[0];
}
//mprintf((0, "OBJ %d t %d hit %d\n", OBJNUM(obj), obj->type, hit_info.hit_object[0]));
// Let object continue its movement if collide_two_objects does not mark it as dead
// if ( !(obj->flags&OF_DEAD) )
// {
//
// // chrishack -- check this later -- what is the old_vel stuff?
// if ((obj->mtype.phys_info.flags & PF_PERSISTENT) ||
// (old_vel == obj->mtype.phys_info.velocity))
// {
// ignore_obj_list[n_ignore_objs++] = hit_info.hit_object[0];
// }
// }
// Let object continue its movement if collide_two_objects does not mark it as dead
if (!(obj->flags & OF_DEAD))
{
if ((obj->mtype.phys_info.flags & PF_PERSISTENT) ||
(Objects[hit_info.hit_object[0]].mtype.phys_info.flags & PF_PERSISTENT))
{
if(n_ignore_objs < MAX_IGNORE_OBJS)
{
ignore_obj_list[n_ignore_objs++] = hit_info.hit_object[0];
count--;
if(count < -1)
count = -1;
}
if(obj->type == OBJ_WEAPON && (obj->mtype.phys_info.flags & PF_PERSISTENT))
obj->ctype.laser_info.last_hit_handle = Objects[hit_info.hit_object[0]].handle;
if(Objects[hit_info.hit_object[0]].type == OBJ_WEAPON && (Objects[hit_info.hit_object[0]].mtype.phys_info.flags & PF_PERSISTENT))
Objects[hit_info.hit_object[0]].ctype.laser_info.last_hit_handle = obj->handle;
}
else if (Objects[hit_info.hit_object[0]].type == OBJ_POWERUP || obj->type == OBJ_POWERUP ||
Objects[hit_info.hit_object[0]].type == OBJ_MARKER || obj->type == OBJ_MARKER)
{
if(n_ignore_objs < MAX_IGNORE_OBJS)
ignore_obj_list[n_ignore_objs++] = hit_info.hit_object[0];
count--;
if(count < -1)
count = -1;
}
f_continue_sim = true;
// if((obj->type == OBJ_CLUTTER)&&(Objects[hit_info.hit_object[0]].type == OBJ_CLUTTER))
// {
// f_continue_sim = false;
// }
}
else
{
f_continue_sim = false;
}
}
break;
case HIT_BAD_P0:
mprintf((0,"PHYSICS ERROR: Bad p0 in physics!!!\n"));
Int3(); // Unexpected collision type: start point not in specified segment.
break;
default:
mprintf((0, "PHYSICS ERROR: Unknown and unhandled hit type returned from FVI\n"));
Int3();
break;
}
// Increment the simulation loop counter
count++;
} while ((f_continue_sim) && (!(obj->flags & OF_DEAD)) &&
(sim_time_remaining > 0.0f) && (count < sim_loop_limit));
// Special stuff should we do if we hit the simulation loop limit
// If retry count is getting large, then we might be trying to do something bad.
// NOTE: These numbers limit the max collisions an object can have in a single frame
if (count >= sim_loop_limit)
{
if (obj->type == OBJ_PLAYER)
{
mprintf((0, "PHYSICS NOTE: Too many collisions for player!\n"));
obj->mtype.phys_info.velocity = Zero_vector;
}
else
{
// mprintf((0, "PHYSICS NOTE: Too many collisions for non-player object %d (%d to %d)!\n", objnum, init_room, obj->roomnum));
// obj->flags |= OF_DEAD;
// obj->mtype.phys_info.velocity /= 2.0f;
// obj->mtype.phys_info.rotvel /= 2.0f;
}
//ObjSetPos(obj,&init_pos, init_room);
//obj->last_pos = init_pos;
}
end_of_sim:
if(f_turn_gravity_on)
{
obj->mtype.phys_info.flags |= (PF_GRAVITY | PF_BOUNCE);
obj->mtype.phys_info.drag /= 300.0f;
}
AttachUpdateSubObjects(obj);
ASSERT(_finite(obj->mtype.phys_info.velocity.x) != 0); // Caller wants to go to infinity! -- Not FVI's fault.
ASSERT(_finite(obj->mtype.phys_info.velocity.y) != 0); // Caller wants to go to infinity! -- Not FVI's fault.
ASSERT(_finite(obj->mtype.phys_info.velocity.z) != 0); // Caller wants to go to infinity! -- Not FVI's fault.
obj->last_pos = init_pos;
return;
}
int PhysCastWalkRay(object *obj, vector *p0, vector *p1, vector *hitpnt, int *start_roomnum = NULL, int *end_roomnum = NULL, vector *hit_normal = NULL)
{
int fate;
fvi_info hit_info;
fvi_query fq;
fq.p0 = p0;
fq.p1 = p1;
if(start_roomnum)
fq.startroom = *start_roomnum;
else
fq.startroom = obj->roomnum;
fq.rad = 0.0f;
fq.flags = FQ_CHECK_OBJS | FQ_IGNORE_POWERUPS | FQ_IGNORE_WEAPONS | FQ_IGNORE_MOVING_OBJECTS | FQ_IGNORE_NON_LIGHTMAP_OBJECTS;
if(!end_roomnum)
fq.flags |= FQ_NO_RELINK;
fq.thisobjnum = OBJNUM(obj);
fq.ignore_obj_list = NULL;
fate = fvi_FindIntersection(&fq, &hit_info);
if(end_roomnum)
*end_roomnum = hit_info.hit_room;
if(hit_normal)
*hit_normal = hit_info.hit_wallnorm[0];
if(fate == HIT_WALL)
{
if(GameTextures[Rooms[hit_info.hit_face_room[0]].faces[hit_info.hit_face[0]].tmap].flags & (TF_VOLATILE | TF_FORCEFIELD | TF_LAVA))
{
return HIT_NONE;
}
}
*hitpnt = hit_info.hit_pnt;
return fate;
}
//void PhysComputeGroundPosOrient(object *obj, vector *pos, matrix *orient)
//{
// vector pnt[3];
// vector tpnt = obj->pos;
// matrix tmatrix = obj->orient;
// poly_model *pm=&Poly_models[obj->rtype.pobj_info.model_num];
// int num_gps = (pm->n_ground == 5)?3:1;
// int i;
//
// obj->pos = *pos;
// obj->orient = *orient;
//
// for(i = 0; i < num_gps; i++)
// {
// PhysCalcGround(&pnt[i], NULL, obj, i);
// }
//
// obj->pos = tpnt;
// obj->orient = tmatrix;
//
// if(num_gps == 3 && ROOMNUM_OUTSIDE(obj->roomnum))
// {
// float diff[3];
// vector gp[3];
//
// for(i = 0; i < 3; i++)
// {
// gp[i] = pnt[i];
// gp[i].y = GetTerrainGroundPoint(&gp[i]);
// }
//
// for(i = 0; i < 3; i++)
// {
// diff[i] = gp[i].y - pnt[i].y;
// }
//
// float biggest_diff = diff[0];
// for(i = 1; i < 3; i++)
// {
// if(fabs(diff[i]) > fabs(biggest_diff))
// {
// biggest_diff = diff[i];
// }
// }
//
// vector uvec;
// vm_GetPerp(&uvec, &gp[0], &gp[1], &gp[2]);
// vm_NormalizeVector(&uvec);
//
// float dot = orient->fvec * uvec;
// vector fvec = orient->fvec;
// fvec -= (uvec * dot);
// vm_NormalizeVector(&fvec);
//
// vm_VectorToMatrix(orient, &fvec, &uvec, NULL);
// pos->y += biggest_diff;
// }
// else
// { // Alignd to Y-axis
// float diff = GetTerrainGroundPoint(&pnt[0]) - pnt[0].y;
//
// pos->y += diff;
//
// angvec a;
// vm_ExtractAnglesFromMatrix(&a, orient);
// vm_AnglesToMatrix(orient, 0.0f, a.h, 0.0f);
// }
//}
void PhysCalPntOnCPntPlane(object *obj, vector *s_pnt, vector *d_pnt, float *dist)
{
vector tpnt = *s_pnt - obj->pos;
*dist = obj->orient.uvec * tpnt;
*d_pnt = *s_pnt + ((-(*dist)) * obj->orient.uvec);
}
bool PhysComputeWalkerPosOrient(object *obj, vector *pos, matrix *orient)
{
vector pnt[3];
vector tpnt = obj->pos;
matrix tmatrix = obj->orient;
poly_model *pm=&Poly_models[obj->rtype.pobj_info.model_num];
int num_gps = (pm->n_ground == 5)?3:1;
int i;
bool f_ok = true;
obj->pos = *pos;
obj->orient = *orient;
for(i = 0; i < num_gps; i++)
{
PhysCalcGround(&pnt[i], NULL, obj, i);
}
obj->pos = tpnt;
obj->orient = tmatrix;
if(num_gps == 3)
{
vector pp[3];
float pdist[3];
int proom[3];
vector hp[3];
for(i = 0; i < 3; i++)
PhysCalPntOnCPntPlane(obj, &pnt[i], &pp[i], &pdist[i]);
// Moves the points to valid locations in the mine and determines the points' room numbers
for(i = 0; i < 3; i++)
{
vector x;
vector norm;
int fate = PhysCastWalkRay(obj, &obj->pos, &pp[i], &x, NULL, &proom[i], &norm);
if(fate != HIT_NONE)
{
if(norm * obj->orient.uvec < 0.4717f)
{
return false;
}
pp[i] = x;
}
}
int num_ave = 0;
vector ave_diff = Zero_vector;
for(i = 0; i < 3; i++)
{
int fate;
vector foot_pnt = pp[i] + obj->orient.uvec * -(obj->size * 1.5f);
vector norm;
fate = PhysCastWalkRay(obj, &pp[i], &foot_pnt, &hp[i], &proom[i], NULL, &norm);
if(fate != HIT_NONE)
{
if(norm * obj->orient.uvec < 0.4717f)
{
return false;
}
ave_diff += hp[i] - pnt[i];
num_ave++;
}
else
{
f_ok = false;
}
}
if(num_ave > 0)
{
ave_diff /= num_ave;
}
else
ave_diff = Zero_vector;
vector uvec;
vm_GetPerp(&uvec, &hp[0], &hp[1], &hp[2]);
vm_NormalizeVector(&uvec);
// if(uvec.y < 0.0)
// uvec *= -1.0f;
float dot = orient->fvec * uvec;
vector fvec = orient->fvec;
fvec -= (uvec * dot);
vm_NormalizeVector(&fvec);
vm_VectorToMatrix(orient, &fvec, &uvec, NULL);
*pos += ave_diff;
}
else
{ // Alignd to Y-axis
int fate;
vector hp;
vector foot_pnt = obj->pos;
foot_pnt.y -= obj->size * 3.0f;
fate = PhysCastWalkRay(obj, &obj->pos, &foot_pnt, &hp);
if(fate == HIT_NONE)
{
mprintf((0, "Walking object %d should be falling\n", OBJNUM(obj)));
// SetObjectDeadFlag(obj);
f_ok = false;
}
else
{
float diff = hp.y - pnt[0].y;
pos->y += diff;
angvec a;
vm_ExtractAnglesFromMatrix(&a, orient);
vm_AnglesToMatrix(orient, 0.0f, a.h, 0.0f);
}
}
return f_ok;
}
bool IsNodeValid(int cell, float min_vert_dot)
{
if(TerrainNormals[MAX_TERRAIN_LOD-1][cell].normal1.y >= min_vert_dot &&
TerrainNormals[MAX_TERRAIN_LOD-1][cell].normal2.y >= min_vert_dot)
return true;
else
return false;
}
bool PhysValidateGroundPath(object *obj, vector *s, int sroom, vector *e, int eroom, float rad, float min_vert_dot)
{
if(ROOMNUM_OUTSIDE(sroom))
{
int x1, x2, y1, y2, x, y, delta_y, delta_x, change_x, change_y, length, cur_node, error_term, i;
int new_x, new_y;
int counter;
int delta_ter_check = rad/TERRAIN_SIZE + 1;
// Determine the start end end nodes
x1 = CELLNUM(sroom)%TERRAIN_WIDTH;
y1 = CELLNUM(sroom)/TERRAIN_WIDTH;
x2 = CELLNUM(eroom)%TERRAIN_WIDTH;
y2 = CELLNUM(eroom)/TERRAIN_WIDTH;
x = x1;
y = y1;
// How many nodes did I move?
delta_x = x2 - x1;
delta_y = y2 - y1;
// Check the current node
if(!IsNodeValid(CELLNUM(sroom), min_vert_dot))
{
return false;
}
if(delta_x == 0 && delta_y == 0)
return true;
// check the end node
cur_node = y1*TERRAIN_DEPTH + x2;
if(!IsNodeValid(cur_node, min_vert_dot))
{
return false;
}
// Do a Breshenham line algorithm
if(delta_x < 0)
{
change_x = -1;
delta_x = -delta_x;
}
else
{
change_x = 1;
}
if(delta_y < 0)
{
change_y = -1;
delta_y = -delta_y;
}
else
{
change_y = 1;
}
error_term = 0;
i = 1;
if(delta_x < delta_y)
{
length = delta_y + 1;
while(i < length)
{
y += change_y;
error_term += delta_x;
if(error_term >= delta_y)
{
x += change_x;
error_term -= delta_y;
}
if(y >= TERRAIN_DEPTH || y < 0 || x < 0 || x >= TERRAIN_WIDTH)
{
return false;
}
for(counter = -delta_ter_check; counter <= delta_ter_check; counter++)
{
new_x = x + counter;
if (new_x < 0)
{
counter = -x;
new_x = 0;
}
if (new_x >= TERRAIN_WIDTH)
break;
// Check the current node for collisions -- chrishack -- This can be made iterative
cur_node = y*TERRAIN_DEPTH + new_x;
if(!IsNodeValid(cur_node, min_vert_dot))
{
return false;
}
}
i++;
}
}
else
{
length = delta_x + 1;
while(i < length)
{
x += change_x;
error_term += delta_y;
if(error_term >= delta_x)
{
y += change_y;
error_term -= delta_x;
}
if(y >= TERRAIN_DEPTH || y < 0 || x < 0 || x >= TERRAIN_WIDTH)
{
return false;
}
for(counter = -delta_ter_check; counter <= delta_ter_check; counter++)
{
new_y = y + counter;
if (new_y < 0)
{
counter = -y;
new_y = 0;
}
if (new_y >= TERRAIN_DEPTH) break;
// Check the current node for collisions -- chrishack -- This can be made iterative
cur_node = new_y*TERRAIN_DEPTH + x;
if(!IsNodeValid(cur_node, min_vert_dot))
{
return false;
}
}
i++;
}
}
return true;
}
else
{
return true;
}
}
// -----------------------------------------------------------------------------------------------------------
//Simulate a physics object for this frame
void do_walking_sim(object *obj)
{
//Since we might not call FVI, set this here
Fvi_num_recorded_faces = 0;
int n_ignore_objs = 0; // The number of ignored objects
int ignore_obj_list[MAX_IGNORE_OBJS+1]; // List of ignored objects
int fate; // Collision type for response code
vector movement_vec; // Movement in this frame
vector movement_pos; // End point of the movement
int count = 0; // Simulation loop counter
int sim_loop_limit = (obj->type == OBJ_PLAYER) ? MAX_PLAYER_SIM_LOOPS : MAX_NON_PLAYER_SIM_LOOPS;
int objnum = OBJNUM(obj); // Simulated object's index
fvi_info hit_info; // Hit information
fvi_query fq; // Movement query
float sim_time_remaining = Frametime; // Amount of simulation time remaining (current iteration)
float old_sim_time_remaining = Frametime; // Amount of simulation time remaining (previous iteration)
vector init_pos = obj->pos; // Initial position
int init_room = obj->roomnum; // Initial room
vector start_pos = obj->pos; // Values at the start of current simulation loop
vector start_vel = obj->mtype.phys_info.velocity;
int start_room = obj->roomnum;
float moved_time; // How long objected moved before hit something
physics_info *pi = &obj->mtype.phys_info; // Simulated object's physics information
int bounced=0; // Did the object bounce?
vector total_force = Zero_vector; // Constant force acting on an object
bool f_continue_sim; // Should we run another simulation loop
bool f_start_fvi_record = true; // Records the rooms that are passed thru
poly_model *pm=&Poly_models[obj->rtype.pobj_info.model_num];
// Assert conditions
ASSERT(obj->type != OBJ_NONE);
ASSERT(obj->movement_type == MT_WALKING);
ASSERT(!(obj->mtype.phys_info.flags&PF_USES_THRUST) || obj->mtype.phys_info.drag != 0.0 );
ASSERT(_finite(obj->mtype.phys_info.velocity.x) != 0); // Caller wants to go to infinity! -- Not FVI's fault.
ASSERT(_finite(obj->mtype.phys_info.velocity.y) != 0); // Caller wants to go to infinity! -- Not FVI's fault.
ASSERT(_finite(obj->mtype.phys_info.velocity.z) != 0); // Caller wants to go to infinity! -- Not FVI's fault.
DebugBlockPrint("PW");
#ifdef _DEBUG
if(!Game_do_walking_sim)
{
return;
}
#endif
// Instant bail cases
if((obj->flags & (OF_DEAD | OF_ATTACHED)) || (Frametime <= 0.0) || (obj->type == OBJ_DUMMY))
{
return;
}
obj->flags &= (~OF_STOPPED_THIS_FRAME);
// Do rotation velocity/accel stuff
bool f_rotated = false;
if (!(fabs(pi->velocity.x) > .000001 || fabs(pi->velocity.y) > .000001 || fabs(pi->velocity.z) > .000001 ||
fabs(pi->thrust.x) > .000001 || fabs(pi->thrust.y) > .000001 || fabs(pi->thrust.z) > .000001 ||
fabs(pi->rotvel.x) > .000001 || fabs(pi->rotvel.y) > .000001 || fabs(pi->rotvel.z) > .000001 ||
fabs(pi->rotthrust.x) > .000001 || fabs(pi->rotthrust.y) > .000001 || fabs(pi->rotthrust.z) > .000001 ||
(obj->mtype.phys_info.flags & PF_GRAVITY) ||
((!ROOMNUM_OUTSIDE(obj->roomnum)) && Rooms[obj->roomnum].wind != Zero_vector) ||
(obj->mtype.phys_info.flags & PF_WIGGLE) ||
((obj->ai_info != NULL) && ((obj->ai_info->flags & AIF_REPORT_NEW_ORIENT) != 0))))
{
if((obj->flags & OF_MOVED_THIS_FRAME))
{
obj->flags &= (~OF_MOVED_THIS_FRAME);
obj->flags |= OF_STOPPED_THIS_FRAME;
}
return;
}
if(obj->ai_info)
{
if(obj->ai_info->flags & AIF_REPORT_NEW_ORIENT)
{
if(pm->n_ground == 5)
{
vector pos = obj->pos;
matrix orient = obj->orient;
if(PhysComputeWalkerPosOrient(obj, &pos, &orient) && ((!obj->ai_info) || (orient.uvec * obj->orient.uvec > .7101 && orient.fvec * obj->orient.fvec > .7101 && orient.rvec * obj->orient.rvec > .7101)))
ObjSetPos(obj, &pos, obj->roomnum, &orient, false);
else
ObjSetOrient(obj, &obj->ai_info->saved_orient);
}
obj->ai_info->flags &= ~AIF_REPORT_NEW_ORIENT;
}
}
obj->flags |= OF_MOVED_THIS_FRAME;
// This assumes that the thrust does not change within a frame. If it does, account for it
// there... like missiles bouncing off a wall and changing heading. --chrishack
if (obj->mtype.phys_info.drag != 0.0)
{
if (obj->mtype.phys_info.flags & PF_USES_THRUST)
{
total_force = obj->mtype.phys_info.thrust;
}
}
// mprintf((0, "PHYSICS: Current obj: %d, %9.2fx %9.2fy %9.2fz\n", OBJNUM(obj), XYZ(&obj->pos)));
// mprintf((2,1,0,"x %9.2f\ny %9.2f\nz %9.2f", XYZ(&obj->mtype.phys_info.velocity)));
// mprintf((0, "PHYSICS: Current velocity (%f, %f, %f)\n", XYZ(&obj->mtype.phys_info.velocity)));
Physics_normal_counter++;
// Simulate movement until we are done (i.e. Frametime has passed or object is done moving)
do
{
obj->mtype.phys_info.rotvel = Zero_vector;
#ifdef _DEBUG
// This records the sim.
sim_loop_record[count].phys_info = obj->mtype.phys_info;
#endif
// Remove transient portions of the velocity
vector t = (obj->mtype.phys_info.velocity * obj->orient.uvec) * obj->orient.uvec;
obj->mtype.phys_info.velocity -= t;
// Initailly assume that this is the last sim cycle
f_continue_sim = false;
// Determines forces
if (count > 0)
{
total_force.x = total_force.y = total_force.z = 0.0;
}
{
movement_vec = pi->velocity * Frametime;
movement_pos = obj->pos + movement_vec;
vector footstep = movement_pos;
int new_room;
if(ROOMNUM_OUTSIDE(obj->roomnum))
{
new_room = GetTerrainRoomFromPos(&footstep);
}
else
{
new_room = obj->roomnum;
}
bool f_step;
if(PhysValidateGroundPath(obj, &obj->pos, obj->roomnum, &footstep, new_room, obj->size, 0.6f))
{
f_step = true;
//Determine endpos
matrix norient;
norient = obj->orient;
if(PhysComputeWalkerPosOrient(obj, &footstep, &norient))
{
if(norient.uvec * obj->orient.uvec > .7101 && norient.fvec * obj->orient.fvec > .7101 && norient.rvec * obj->orient.rvec > .7101)
{
ObjSetOrient(obj, &norient);
movement_vec = footstep - obj->pos;
movement_pos = footstep;
fq.p0 = &obj->pos;
fq.startroom = obj->roomnum;
fq.p1 = &footstep;
fq.rad = obj->size;
fq.thisobjnum = objnum;
fq.ignore_obj_list = NULL;
fq.flags = FQ_CHECK_OBJS | FQ_IGNORE_WEAPONS | FQ_IGNORE_POWERUPS | FQ_IGNORE_TERRAIN;
if(obj->mtype.phys_info.flags & PF_POINT_COLLIDE_WALLS)
{
fq.rad = 0.0f;
}
else if(!ROOMNUM_OUTSIDE(obj->roomnum))
{
poly_model *pm=&Poly_models[obj->rtype.pobj_info.model_num];
int num_gps = (pm->n_ground == 5)?3:1;
if(num_gps == 3)
fq.rad *= 0.2f;
else
fq.rad *= 0.45f;
}
if(obj->flags & OF_NO_OBJECT_COLLISIONS)
fq.flags &= ~FQ_CHECK_OBJS;
fate = fvi_FindIntersection(&fq,&hit_info);
norient = obj->orient;
if(PhysComputeWalkerPosOrient(obj, &hit_info.hit_pnt, &norient))
{
ObjSetPos(obj, &hit_info.hit_pnt, hit_info.hit_room, &norient, false);
}
else
{
f_step = false;
}
}
else
{
f_step = false;
movement_vec = Zero_vector;
}
}
else
{
f_step = false;
movement_vec = Zero_vector;
}
}
else
{
f_step = false;
}
if(!f_step)
{
pi->velocity = Zero_vector;
break;
}
// If we are stationary, we are done :)
if ( fabs(movement_vec.x) < 0.0000001 && fabs(movement_vec.y) < 0.0000001 && fabs(movement_vec.z) < 0.0000001 )
break;
}
Physics_walking_looping_counter++;
// Instant bails for collision response
if(obj->type == OBJ_PLAYER && ((fate == HIT_OUT_OF_TERRAIN_BOUNDS) || (ROOMNUM_OUTSIDE(hit_info.hit_room) && GetTerrainCellFromPos(&hit_info.hit_pnt) == -1)))
{
ObjSetPos(obj,&init_pos, init_room, NULL, false);
obj->last_pos = init_pos;
goto end_of_sim;
}
else if (fate == HIT_OUT_OF_TERRAIN_BOUNDS)
{
mprintf((0, "PHYSICS NOTE: Walker exited terrain\n"));
SetObjectDeadFlag (obj);
obj->last_pos = init_pos;
goto end_of_sim;
}
// Calulate amount of sim time left
if(fate == HIT_NONE)
{
moved_time = old_sim_time_remaining = sim_time_remaining;
sim_time_remaining = 0.0;
f_continue_sim = false;
}
else
{
vector moved_vec_n;
float attempted_dist,actual_dist;
// Save results of this simulation
old_sim_time_remaining = sim_time_remaining;
moved_vec_n = obj->pos - start_pos; //chrishack -- use this copy
if(moved_vec_n != Zero_vector)
{
actual_dist = vm_NormalizeVector(&moved_vec_n);
}
else
{
actual_dist = 0.0f;
}
// chrishack -- potentially bad -- outside to inside stuff
// We where sitting in a wall -- invalid starting point
//moved backwards
if (fate == HIT_WALL && moved_vec_n * movement_vec < -0.000001 && actual_dist != 0.0)
{
mprintf((0, "Obj %d Walked backwards!\n", OBJNUM(obj)));
// mprintf((0, "PHYSICS NOTE: (%f, %f, %f) to (%f, %f, %f)\n", XYZ(&start_pos), XYZ(&obj->pos)));
//don't change position or sim_time_remaining
ObjSetPos(obj, &start_pos, start_room, NULL, false);
moved_time = 0.0;
}
else
{
// Compute more results of this simulation
attempted_dist = vm_GetMagnitude(&movement_vec);
sim_time_remaining = sim_time_remaining * ((attempted_dist - actual_dist) / attempted_dist);
moved_time = old_sim_time_remaining - sim_time_remaining;
// chrishack -- we have no time left (plus some) This can happen if FVI corrects a near tangental
// movement by adding the radius - thus, we move a little too far.
if (sim_time_remaining < 0.0)
{
sim_time_remaining = 0.0;
moved_time = old_sim_time_remaining;
}
// chrishack -- negative simulation time pasted for this sim frame
if (sim_time_remaining > old_sim_time_remaining)
{
mprintf((0,"PHYSICS WARNING: Bogus sim_time_remaining = %15.13f, old = %15.13f\nAttempted d = %15.13f, actual = %15.13f\n",sim_time_remaining,old_sim_time_remaining, attempted_dist, actual_dist));
// Int3();
sim_time_remaining = old_sim_time_remaining;
moved_time = 0.0;
f_continue_sim = false;
}
}
}
// Get the collision speed as a linear interp.
if(old_sim_time_remaining > 0.0)
{
obj->mtype.phys_info.velocity = obj->mtype.phys_info.velocity * (moved_time / old_sim_time_remaining) + start_vel * (sim_time_remaining / old_sim_time_remaining);
}
// Collision response code
switch( fate )
{
case HIT_NONE:
f_continue_sim = false;
break;
case HIT_WALL: // Finally unified, still needs some work, but it certainly better like this :)
case HIT_TERRAIN:
{
// if(obj->type != OBJ_CLUTTER)
{
vector moved_v;
float hit_speed, wall_part;
float hit_dot = 1.0;
float luke_test;
if(obj->type == OBJ_PLAYER || OBJ_CLUTTER)
{
luke_test = vm_GetMagnitude(&obj->mtype.phys_info.velocity);
}
// Find hit speed
moved_v = obj->pos - start_pos; // chrishack -- We already computed this!!!!!!!
wall_part = moved_v * hit_info.hit_wallnorm[0];
if(obj->mtype.phys_info.hit_die_dot > 0.0)
{
vector m_normal = start_pos - obj->pos;
vm_NormalizeVector(&m_normal);
hit_dot = m_normal * hit_info.hit_wallnorm[0];
}
hit_speed = -(wall_part / moved_time);
// We hit a wall (weapons cannot scrap)
if ((wall_part != 0.0 && moved_time > 0.0 && (hit_speed > 0.0)) || obj->type == OBJ_WEAPON)
collide_object_with_wall( obj, hit_speed, hit_info.hit_face_room[0], hit_info.hit_face[0], &hit_info.hit_face_pnt[0], &hit_info.hit_wallnorm[0], hit_dot );
else // We hit a wall and are moving parallel to it
collide_object_with_wall( obj, hit_speed, hit_info.hit_face_room[0], hit_info.hit_face[0], &hit_info.hit_face_pnt[0], &hit_info.hit_wallnorm[0], hit_dot );
// scrape_object_on_wall(obj, hit_info.hit_face_room, hit_info.hit_face, &hit_info.hit_face_pnt[0], &hit_info.hit_wallnorm[0] );
if ( !(obj->flags&OF_DEAD) )
{
bool f_forcefield = false; //bounce off a forcefield
if(obj->type == OBJ_WEAPON && (obj->mtype.phys_info.flags & PF_BOUNCE))
obj->mtype.phys_info.flags &= (~PF_NO_COLLIDE_PARENT);
// Slide object along wall
//We're constrained by wall, so subtract wall part from the velocity vector
wall_part = hit_info.hit_wallnorm[0] * obj->mtype.phys_info.velocity;
if ((obj->mtype.phys_info.num_bounces <= 0) && (obj->mtype.phys_info.flags & PF_STICK))
{
obj->movement_type = MT_NONE;
vm_MakeZero(&obj->mtype.phys_info.velocity);
obj->last_pos = init_pos;
goto end_of_sim;
}
else if (f_forcefield || (obj->mtype.phys_info.flags & PF_BOUNCE))
{
wall_part *= 2.0; //Subtract out wall part twice to achieve bounce
if (f_forcefield)
{
if (obj->type == OBJ_PLAYER)
wall_part *= 2; //player bounce twice as much -- chrishack try without this too.
}
bounced = 1; //this object bounced
// mprintf((0, "(%f, %f, %f) before bounce\n", XYZ(&obj->mtype.phys_info.velocity)));
obj->mtype.phys_info.velocity += hit_info.hit_wallnorm[0] * (wall_part * -1.0f);
if(obj->mtype.phys_info.coeff_restitution != 1.0f)
obj->mtype.phys_info.velocity -= (obj->mtype.phys_info.velocity * (1.0f - obj->mtype.phys_info.coeff_restitution));
//mprintf((0, "(%f, %f, %f) after bounce\n", XYZ(&obj->mtype.phys_info.velocity)));
//mprintf((0, "p (%f, %f, %f) after bounce\n", XYZ(&obj->pos)));
}
else
{
float wall_force;
wall_force = total_force * hit_info.hit_wallnorm[0];
total_force += hit_info.hit_wallnorm[0] * (wall_force * -1.001); // 1.001 so that we are not quite tangential
// Update velocity from wall hit.
obj->mtype.phys_info.velocity += hit_info.hit_wallnorm[0] * (wall_part * -1.001); // 1.001 so that we are not quite tangential
if((obj->type == OBJ_ROBOT || obj->type == OBJ_PLAYER || OBJ_CLUTTER || (obj->type == OBJ_BUILDING && obj->ai_info)) && sim_time_remaining == old_sim_time_remaining)
{
obj->mtype.phys_info.velocity += hit_info.hit_wallnorm[0];
}
if(obj->type == OBJ_PLAYER || OBJ_CLUTTER)
{
float real_vel;
real_vel = vm_NormalizeVector(&obj->mtype.phys_info.velocity);
obj->mtype.phys_info.velocity *= ((real_vel + luke_test)/2);
//obj->mtype.phys_info.velocity *= (luke_test);
}
}
//mprintf((0, "PHYSICS: Wall normal (%f, %f, %f)\n", XYZ(&hit_info.hit_wallnorm[0])));
//mprintf((0, "PHYSICS: Bounded velocity (%f, %f, %f)\n", XYZ(&obj->mtype.phys_info.velocity)));
// This only happens if the new velocity is set from hitting a forcefield.
if(!(fabs(obj->mtype.phys_info.velocity.x) < MAX_OBJECT_VEL &&
fabs(obj->mtype.phys_info.velocity.y) < MAX_OBJECT_VEL &&
fabs(obj->mtype.phys_info.velocity.z) < MAX_OBJECT_VEL))
{
float mag = vm_NormalizeVector(&obj->mtype.phys_info.velocity);
mprintf((0, "PHYSICS: Bashing vel for Obj %d of type %d with %f velocity", objnum, obj->type, mag));
obj->mtype.phys_info.velocity *= MAX_OBJECT_VEL * 0.1f;
}
// Weapons should face their new heading. This is so missiles are pointing in the correct direct.
if (obj->type == OBJ_WEAPON && (bounced || (obj->mtype.phys_info.flags & (PF_GRAVITY | PF_WIND ))))
if(obj->mtype.phys_info.velocity !=Zero_vector)
vm_VectorToMatrix(&obj->orient,&obj->mtype.phys_info.velocity,&obj->orient.uvec,NULL);
}
}
//else
//{
/* vector r1 = hit_info.hit_face_pnt[0] - obj->pos;
vector w1;
vector n1;
float temp1;
float j;
matrix o_t1 = obj->orient;
vm_TransposeMatrix(&o_t1);
vector cmp1 = obj->mtype.phys_info.rotvel * o_t1;
ConvertEulerToAxisAmount(&cmp1, &n1, &temp1);
n1 *= temp1;
if(temp1 != 0.0f)
{
vm_CrossProduct(&w1, &n1, &r1);
}
else
{
w1 = Zero_vector;
}
vector p1 = obj->mtype.phys_info.velocity + w1; //*((2.0f*(float)PI)/65535.0f);
if(p1.y < 0.0)
{
// if(p1.y == 0.0)
// mprintf((0, "AT REST: p1 (%f, %f, %f)\n", XYZ(&p1)));
// else
// mprintf((0, "SHIT: p1 (%f, %f, %f)\n", XYZ(&p1)));
//
// p1.y = -.0001f;
// }
float v_rel;
float m1 = obj->mtype.phys_info.mass;
v_rel = hit_info.hit_wallnorm[0] * (p1);
float e = .1f;
vector c1;
vector cc1;
float cv1;
float i1 = (m1/12.0)*(2.0f * pow(obj->size*2.0, 2));
vm_CrossProduct(&c1, &r1, &hit_info.hit_wallnorm[0]);
c1 = c1/i1;
vm_CrossProduct(&cc1, &c1, &r1);
cv1 = (hit_info.hit_wallnorm[0])*c1;
j = (-(1.0f + e))*v_rel;
j /= (1/m1 + cv1);
obj->mtype.phys_info.velocity += ((j*(hit_info.hit_wallnorm[0]))/m1);
vector jcn = j * (hit_info.hit_wallnorm[0]);
vm_CrossProduct(&c1, &r1, &jcn);
n1 = (c1)/i1;
temp1 = vm_NormalizeVector(&n1);
vector txx1;
ConvertAxisAmountToEuler(&n1, &temp1, &txx1);
obj->mtype.phys_info.rotvel += (txx1*obj->orient);
}
else
{
obj->mtype.phys_info.velocity.y = .001f;
obj->mtype.phys_info.rotvel = Zero_vector;
}*/
// }
f_continue_sim = true;
}
break;
case HIT_OBJECT:
case HIT_SPHERE_2_POLY_OBJECT:
{
vector old_force; // -- chrishack
// Mark the hit object so that on the following sim frames, in this game frame, ignore this object.
ASSERT(hit_info.hit_object[0] != -1); // chrishack move this ASSERT fvi stuff above
// chrishack -- we should have this point from FVI!!!!!!!!!!!
// Calculcate the hit point between the two objects.
//old_vel = obj->mtype.phys_info.velocity;
old_force = obj->mtype.phys_info.thrust;
obj->mtype.phys_info.thrust = total_force;
// hit_info.hit_wallnorm[0] *= -1.0f;
collide_two_objects( obj, &Objects[hit_info.hit_object[0]], &hit_info.hit_face_pnt[0], &hit_info.hit_wallnorm[0], &hit_info);
if(obj->movement_type == MT_OBJ_LINKED)
goto end_of_sim;
total_force = obj->mtype.phys_info.thrust;
obj->mtype.phys_info.thrust = old_force;
if((obj->type == OBJ_ROBOT || obj->type == OBJ_PLAYER || OBJ_CLUTTER || (obj->type == OBJ_BUILDING && obj->ai_info)) && sim_time_remaining == old_sim_time_remaining && Objects[hit_info.hit_object[0]].movement_type == MT_NONE)
{
obj->mtype.phys_info.velocity += hit_info.hit_wallnorm[0];
}
//mprintf((0, "OBJ %d t %d hit %d\n", OBJNUM(obj), obj->type, hit_info.hit_object[0]));
// Let object continue its movement if collide_two_objects does not mark it as dead
// if ( !(obj->flags&OF_DEAD) )
// {
//
// // chrishack -- check this later -- what is the old_vel stuff?
// if ((obj->mtype.phys_info.flags & PF_PERSISTENT) ||
// (old_vel == obj->mtype.phys_info.velocity))
// {
// ignore_obj_list[n_ignore_objs++] = hit_info.hit_object[0];
// }
// }
// Let object continue its movement if collide_two_objects does not mark it as dead
if (!(obj->flags & OF_DEAD))
{
if ((obj->mtype.phys_info.flags & PF_PERSISTENT) ||
(Objects[hit_info.hit_object[0]].mtype.phys_info.flags & PF_PERSISTENT))
{
if(n_ignore_objs < MAX_IGNORE_OBJS)
ignore_obj_list[n_ignore_objs++] = hit_info.hit_object[0];
}
else if (Objects[hit_info.hit_object[0]].type == OBJ_POWERUP || obj->type == OBJ_POWERUP ||
Objects[hit_info.hit_object[0]].type == OBJ_MARKER || obj->type == OBJ_MARKER)
{
if(n_ignore_objs < MAX_IGNORE_OBJS)
ignore_obj_list[n_ignore_objs++] = hit_info.hit_object[0];
count--;
if(count < -1)
count = -1;
}
f_continue_sim = true;
}
else
{
f_continue_sim = false;
}
}
break;
case HIT_BAD_P0:
mprintf((0,"PHYSICS ERROR: Bad p0 in physics!!!\n"));
Int3(); // Unexpected collision type: start point not in specified segment.
break;
default:
mprintf((0, "PHYSICS ERROR: Unknown and unhandled hit type returned from FVI\n"));
Int3();
break;
}
// Increment the simulation loop counter
count++;
} while ((f_continue_sim) && (!(obj->flags & OF_DEAD)) &&
(sim_time_remaining > 0.0f) && (count < sim_loop_limit));
// Special stuff should we do if we hit the simulation loop limit
// If retry count is getting large, then we might be trying to do something bad.
// NOTE: These numbers limit the max collisions an object can have in a single frame
if (count >= sim_loop_limit)
{
if (obj->type == OBJ_PLAYER)
{
mprintf((0, "PHYSICS NOTE: Too many collisions for player!\n"));
}
else
{
// mprintf((0, "PHYSICS NOTE: Too many collisions for non-player object %d (%d to %d)!\n", objnum, init_room, obj->roomnum));
// obj->flags |= OF_DEAD;
// obj->mtype.phys_info.velocity /= 2.0f;
// obj->mtype.phys_info.rotvel /= 2.0f;
}
//ObjSetPos(obj,&init_pos, init_room);
//obj->last_pos = init_pos;
}
end_of_sim:
AttachUpdateSubObjects(obj);
ASSERT(_finite(obj->mtype.phys_info.velocity.x) != 0); // Caller wants to go to infinity! -- Not FVI's fault.
ASSERT(_finite(obj->mtype.phys_info.velocity.y) != 0); // Caller wants to go to infinity! -- Not FVI's fault.
ASSERT(_finite(obj->mtype.phys_info.velocity.z) != 0); // Caller wants to go to infinity! -- Not FVI's fault.
obj->last_pos = init_pos;
return;
}
// -----------------------------------------------------------------------------------------------------------
//Simulate a physics object for this frame
void do_vis_physics_sim(vis_effect *vis)
{
if( Frametime <= 0.0f )
return;
vector total_force;
vector old_pos = vis->pos;
#ifdef _DEBUG
if(!Game_do_vis_sim)
{
return;
}
#endif
DebugBlockPrint("V ");
if(vis->flags & VF_DEAD)
{
DebugBlockPrint("DV");
return;
}
if( fabsf(vis->velocity.x) < 0.000001f &&
fabsf(vis->velocity.y) < 0.000001f &&
fabsf(vis->velocity.z) < 0.000001f &&
!(vis->phys_flags & PF_GRAVITY) )
{
DebugBlockPrint("DV");
return;
}
// Determine velocity
if(vis->phys_flags & PF_FIXED_VELOCITY)
{
vis->pos += vis->velocity * Frametime;
}
else
{
if( vis->mass > 0.0f && vis->drag > 0.0f )
{
// If the object is effected by gravity (normal, lighter than air, and anti-gravity)
if (vis->phys_flags & PF_GRAVITY)
{
total_force.x = total_force.z = 0.0f;
total_force.y = Gravity_strength * vis->mass;
}
else if (vis->phys_flags & PF_REVERSE_GRAVITY)
{
total_force.x = total_force.z = 0.0f;
total_force.y = -Gravity_strength * vis->mass;
}
else
{
total_force.x = total_force.y = total_force.z = 0.0f;
}
// Note: The math here is done in 64bit floats because we will run into precision problems with 32bit
const double forceOverDrag[3] = { total_force.x / vis->drag, total_force.y / vis->drag, total_force.z / vis->drag };
const double frameTime = Frametime;
const double massOverDrag = vis->mass / vis->drag;
const double dragOverMass = vis->drag / vis->mass;
const double expDoMFt = exp( -dragOverMass * frameTime );
double visNewPos[3];
visNewPos[0] = double(vis->pos.x) + forceOverDrag[0]*frameTime + massOverDrag*(double(vis->velocity.x) - forceOverDrag[0]) * (1.0 - expDoMFt);
visNewPos[1] = double(vis->pos.y) + forceOverDrag[1]*frameTime + massOverDrag*(double(vis->velocity.y) - forceOverDrag[1]) * (1.0 - expDoMFt);
visNewPos[2] = double(vis->pos.z) + forceOverDrag[2]*frameTime + massOverDrag*(double(vis->velocity.z) - forceOverDrag[2]) * (1.0 - expDoMFt);
double visNewVel[3];
visNewVel[0] = (double(vis->velocity.x) - forceOverDrag[0]) * expDoMFt + forceOverDrag[0];
visNewVel[1] = (double(vis->velocity.y) - forceOverDrag[1]) * expDoMFt + forceOverDrag[1];
visNewVel[2] = (double(vis->velocity.z) - forceOverDrag[2]) * expDoMFt + forceOverDrag[2];
vis->pos.x = float(visNewPos[0]);
vis->pos.y = float(visNewPos[1]);
vis->pos.z = float(visNewPos[2]);
vis->velocity.x = float(visNewVel[0]);
vis->velocity.y = float(visNewVel[1]);
vis->velocity.z = float(visNewVel[2]);
}
else
{
vector delta_velocity = {0.0f, 0.0f, 0.0f};
if(vis->phys_flags & PF_GRAVITY)
{
delta_velocity.y += Gravity_strength * Frametime;
}
else if (vis->phys_flags & PF_REVERSE_GRAVITY)
{
delta_velocity.y -= Gravity_strength * Frametime;
}
vis->pos += (vis->velocity * Frametime) + (0.5f * delta_velocity * Frametime);
vis->velocity += delta_velocity;
}
}
if(vis->phys_flags & PF_NO_COLLIDE)
{
DebugBlockPrint("DV");
return;
}
Physics_vis_counter++;
//Do FVI call to check for death & update room
fvi_query fq;
fvi_info hit_info;
int fate;
if (ROOMNUM_OUTSIDE(vis->roomnum))
{
ASSERT(CELLNUM(vis->roomnum) <= TERRAIN_WIDTH*TERRAIN_DEPTH);
ASSERT(CELLNUM(vis->roomnum) >= 0);
}
else
{
ASSERT(vis->roomnum >= 0 && vis->roomnum <= Highest_room_index && Rooms[vis->roomnum].used);
}
fq.p0 = &old_pos;
fq.startroom = vis->roomnum;
fq.p1 = &vis->pos;
fq.rad = 0.0f;
fq.thisobjnum = -1;
fq.ignore_obj_list = NULL;
fq.flags = FQ_CHECK_OBJS | FQ_ONLY_DOOR_OBJ | FQ_IGNORE_WALLS;
fate = fvi_FindIntersection(&fq,&hit_info);
if (fate == HIT_NONE && hit_info.hit_room != -1)
{
if (hit_info.hit_room != vis->roomnum)
{
VisEffectRelink(vis-VisEffects,hit_info.hit_room);
}
if (ROOMNUM_OUTSIDE(hit_info.hit_room))
{
ASSERT(CELLNUM(hit_info.hit_room) <= TERRAIN_WIDTH*TERRAIN_DEPTH);
ASSERT(CELLNUM(hit_info.hit_room) >= 0);
}
else
{
ASSERT(hit_info.hit_room >= 0 && hit_info.hit_room <= Highest_room_index && Rooms[hit_info.hit_room].used);
}
}
else
{
VisEffectDelete(vis-VisEffects);
}
DebugBlockPrint("DV");
}
void phys_apply_force(object *obj,vector *force_vec,short weapon_index)
{
if (obj->mtype.phys_info.mass == 0.0)
return;
if (obj->movement_type != MT_PHYSICS && obj->movement_type != MT_WALKING)
return;
if (obj->mtype.phys_info.flags & PF_LOCK_MASK) // Not done!
return;
if((Game_mode & GM_MULTI) &&
((obj->type == OBJ_PLAYER && obj->id != Player_num) ||
((obj->type != OBJ_PLAYER && obj->type!=OBJ_POWERUP) && Netgame.local_role != LR_SERVER)))
return;
// Do Force Feedback for the hit
if(obj->id==Player_num){
//we need to convert collision_normal from world space to local space
vector local_norm;
float scale = 0,magnitude = 0;
//compute how much force to do
magnitude = vm_GetMagnitude (force_vec);
if(magnitude){
scale = magnitude / 2500.0f;
if(scale <0.0f ) scale = 0.0f;
if(scale >1.0f ) scale = 1.0f;
vm_MatrixMulVector (&local_norm,force_vec,&obj->orient);
local_norm *= -1.0f;
ForceEffectsPlay(FORCE_TEST_FORCE,&scale,&local_norm);
}
if(weapon_index!=-1)
{
mprintf((0,"Force from weapon\n"));
}
//mprintf((0,"Force: Magnitude = %f Scale = %1.3f\n",magnitude,scale));
VIBE_DoForce(force_vec);
}
//------------------------------
//Add in acceleration due to force
obj->mtype.phys_info.velocity += (*force_vec / obj->mtype.phys_info.mass);
}
/*
// ----------------------------------------------------------------
// Do *dest = *delta unless:
// *delta is pretty small
// and they are of different signs.
void physics_set_rotvel_and_saturate(float *dest, float delta)
{
if ((delta ^ *dest) < 0) {
if (abs(delta) < F1_0/8) {
// mprintf((0, "D"));
*dest = delta/4;
} else
// mprintf((0, "d"));
*dest = delta;
} else {
// mprintf((0, "!"));
*dest = delta;
}
}
// ------------------------------------------------------------------------------------------------------
// Note: This is the old ai_turn_towards_vector code.
// phys_apply_rot used to call ai_turn_towards_vector until I fixed it, which broke phys_apply_rot.
void physics_turn_towards_vector(vector *goal_vector, object *obj, float rate)
{
vms_angvec dest_angles, cur_angles;
float delta_p, delta_h;
vector *rotvel_ptr = &obj->mtype.phys_info.rotvel;
// Make this object turn towards the goal_vector. Changes orientation, doesn't change direction of movement.
// If no one moves, will be facing goal_vector in 1 second.
// Detect null vector.
if ((goal_vector->x == 0) && (goal_vector->y == 0) && (goal_vector->z == 0))
return;
// Make morph objects turn more slowly.
if (obj->control_type == CT_MORPH)
rate *= 2;
vm_extract_angles_vector(&dest_angles, goal_vector);
vm_extract_angles_vector(&cur_angles, &obj->orient.fvec);
delta_p = (dest_angles.p - cur_angles.p);
delta_h = (dest_angles.h - cur_angles.h);
if (delta_p > F1_0/2) delta_p = dest_angles.p - cur_angles.p - F1_0;
if (delta_p < -F1_0/2) delta_p = dest_angles.p - cur_angles.p + F1_0;
if (delta_h > F1_0/2) delta_h = dest_angles.h - cur_angles.h - F1_0;
if (delta_h < -F1_0/2) delta_h = dest_angles.h - cur_angles.h + F1_0;
delta_p = fixdiv(delta_p, rate);
delta_h = fixdiv(delta_h, rate);
if (abs(delta_p) < F1_0/16) delta_p *= 4;
if (abs(delta_h) < F1_0/16) delta_h *= 4;
physics_set_rotvel_and_saturate(&rotvel_ptr->x, delta_p);
physics_set_rotvel_and_saturate(&rotvel_ptr->y, delta_h);
rotvel_ptr->z = 0;
}
*/
// -----------------------------------------------------------------------------
// Applies an instantaneous whack on an object, resulting in an instantaneous
// change in orientation.
void phys_apply_rot(object *obj,vector *force_vec)
{
/*
float rate, vecmag;
if (obj->movement_type != MT_PHYSICS)
return;
vecmag = vm_VectorMagnitude(force_vec);
if (vecmag < F1_0/256)
rate = 4*F1_0;
else if (vecmag < obj->mtype.phys_info.mass >> 14)
rate = 4*F1_0;
else {
rate = fixdiv(obj->mtype.phys_info.mass, vecmag);
if (obj->type == OBJ_ROBOT) {
if (rate < F1_0/4)
rate = F1_0/4;
// Changed by mk, 10/24/95, claw guys should not slow down when attacking!
if (!Robot_info[obj->id].thief && !Robot_info[obj->id].attack_type) {
if (obj->ctype.ai_info.SKIP_AI_COUNT * Frametime < 3*F1_0/4) {
float tval = fixdiv(F1_0, 8*Frametime);
int addval;
addval = f2i(tval);
if ( (rand() * 2) < (tval & 0xffff))
addval++;
obj->ctype.ai_info.SKIP_AI_COUNT += addval;
// -- mk: too much stuff making hard to see my debug messages...mprintf((0, "Frametime = %7.3f, addval = %i\n", f2fl(Frametime), addval));
}
}
} else {
if (rate < F1_0/2)
rate = F1_0/2;
}
}
// Turn amount inversely proportional to mass. Third parameter is seconds to do 360 turn.
physics_turn_towards_vector(force_vec, obj, rate);
*/
}
/*
//this routine will set the thrust for an object to a value that will
//(hopefully) maintain the object's current velocity
void set_thrust_from_velocity(object *obj)
{
Int3();
// float k;
//
// ASSERT(obj->movement_type == MT_PHYSICS);
//
// k = fixmuldiv(obj->mtype.phys_info.mass,obj->mtype.phys_info.drag,(f1_0-obj->mtype.phys_info.drag));
//
// vm_vec_copy_scale(&obj->mtype.phys_info.thrust,&obj->mtype.phys_info.velocity,k);
//
}
*/
// Checks if an object is on the ground (we might do more in this function at a latter date) --chrishack
int check_obj_on_ground(object *obj, fvi_info *hit_info_ptr) {
vector ground;
fvi_query fq;
ASSERT(obj->size - 2*PHYSICS_GROUND_TOLERANCE > 0.0f);
ground = obj->pos;
// This should account for an object that touches more than one face. (To find the real ground).
ground.y -= (obj->size + 3 * PHYSICS_GROUND_TOLERANCE);
fq.p0 = &obj->pos;
fq.startroom = obj->roomnum;
fq.p1 = &ground;
fq.rad = obj->size - 2*PHYSICS_GROUND_TOLERANCE;
fq.thisobjnum = OBJNUM(obj);
fq.ignore_obj_list = NULL;
fq.flags = FQ_CHECK_OBJS;
if(obj->flags & OF_NO_OBJECT_COLLISIONS)
fq.flags &= ~FQ_CHECK_OBJS;
return fvi_FindIntersection(&fq, hit_info_ptr);
}
Reference in New Issue View Git Blame Copy Permalink