// Determine if locking point is in the locking cone
void hud_lock_check_if_target_in_lock_cone()
{
float dot;
vec3d vec_to_target;
vm_vec_normalized_dir(&vec_to_target, &lock_world_pos, &Player_obj->pos);
dot = vm_vec_dot(&Player_obj->orient.vec.fvec, &vec_to_target);
if ( dot > 0.85) {
Player->target_in_lock_cone = 1;
} else {
Player->target_in_lock_cone = 0;
}
}
// Return true if objp will collide with some large object.
// Don't check for an object this ship is docked to.
int collide_predict_large_ship(object *objp, float distance)
{
object *objp2;
vec3d cur_pos, goal_pos;
ship_info *sip;
sip = &Ship_info[Ships[objp->instance].ship_info_index];
cur_pos = objp->pos;
vm_vec_scale_add(&goal_pos, &cur_pos, &objp->orient.vec.fvec, distance);
for ( objp2 = GET_FIRST(&obj_used_list); objp2 != END_OF_LIST(&obj_used_list); objp2 = GET_NEXT(objp2) ) {
if ((objp != objp2) && (objp2->type == OBJ_SHIP)) {
if (Ship_info[Ships[objp2->instance].ship_info_index].flags & (SIF_BIG_SHIP | SIF_HUGE_SHIP)) {
if (dock_check_find_docked_object(objp, objp2))
continue;
if (cpls_aux(&goal_pos, objp2, objp))
return 1;
}
} else if (!(sip->flags & (SIF_BIG_SHIP | SIF_HUGE_SHIP)) && (objp2->type == OBJ_ASTEROID)) {
if (vm_vec_dist_quick(&objp2->pos, &objp->pos) < (distance + objp2->radius)*2.5f) {
vec3d pos, delvec;
int count;
float d1;
d1 = 2.5f * distance + objp2->radius;
count = (int) (d1/(objp2->radius + objp->radius)); // Scale up distance, else looks like there would be a collision.
pos = cur_pos;
vm_vec_normalized_dir(&delvec, &goal_pos, &cur_pos);
vm_vec_scale(&delvec, d1/count);
for (; count>0; count--) {
if (vm_vec_dist_quick(&pos, &objp2->pos) < objp->radius + objp2->radius)
return 1;
vm_vec_add2(&pos, &delvec);
}
}
}
}
return 0;
}
void camera::set_rotation_facing(vec3d *in_target, float in_rotation_time, float in_rotation_acceleration_time, float in_rotation_deceleration_time)
{
matrix temp_matrix = IDENTITY_MATRIX;
if(in_target != NULL)
{
vec3d position = vmd_zero_vector;
this->get_info(&position, NULL);
if(in_target->xyz.x == position.xyz.x && in_target->xyz.y == position.xyz.y && in_target->xyz.z == position.xyz.z)
{
Warning(LOCATION, "Camera tried to point to self");
return;
}
vec3d targetvec;
vm_vec_normalized_dir(&targetvec, in_target, &position);
vm_vector_2_matrix(&temp_matrix, &targetvec, NULL, NULL);
}
set_rotation(&temp_matrix, in_rotation_time, in_rotation_acceleration_time, in_rotation_deceleration_time);
}
// -----------------------------------------------------------------------------------------------------------
//Simulate a physics object for this frame
void do_physics_sim(object *obj)
{
int ignore_obj_list[MAX_IGNORE_OBJS],n_ignore_objs;
int iseg;
int try_again;
int fate=0;
vms_vector frame_vec; //movement in this frame
vms_vector new_pos,ipos; //position after this frame
int count=0;
int objnum;
int WallHitSeg, WallHitSide;
fvi_info hit_info;
fvi_query fq;
vms_vector save_pos;
int save_seg;
fix drag;
fix sim_time;
vms_vector start_pos;
int obj_stopped=0;
fix moved_time; //how long objected moved before hit something
physics_info *pi;
int orig_segnum = obj->segnum;
fix PhysTime = (FrameTime<F1_0/30?F1_0/30:FrameTime);
Assert(obj->movement_type == MT_PHYSICS);
#ifndef NDEBUG
if (Dont_move_ai_objects)
if (obj->control_type == CT_AI)
return;
#endif
pi = &obj->mtype.phys_info;
do_physics_sim_rot(obj);
if (!(pi->velocity.x || pi->velocity.y || pi->velocity.z || pi->thrust.x || pi->thrust.y || pi->thrust.z))
return;
objnum = obj-Objects;
n_phys_segs = 0;
/* As this engine was not designed for that high FPS as we intend, we use F1_0/30 max. for sim_time to ensure
scaling and dot products stay accurate and reliable. The object position intended for this frame will be scaled down later,
after the main collision-loop is done.
This won't make collision results be equal in all FPS settings, but hopefully more accurate, the higher our FPS are.
*/
sim_time = PhysTime; //FrameTime;
//debug_obj = obj;
#ifdef EXTRA_DEBUG
//check for correct object segment
if(!get_seg_masks(&obj->pos,obj->segnum,0,__FILE__,__LINE__).centermask==0) {
//Int3(); Removed by Rob 10/5/94
if (!update_object_seg(obj)) {
if (!(Game_mode & GM_MULTI))
Int3();
compute_segment_center(&obj->pos,&Segments[obj->segnum]);
obj->pos.x += objnum;
}
}
#endif
start_pos = obj->pos;
n_ignore_objs = 0;
Assert(obj->mtype.phys_info.brakes==0); //brakes not used anymore?
//if uses thrust, cannot have zero drag
Assert(!(obj->mtype.phys_info.flags&PF_USES_THRUST) || obj->mtype.phys_info.drag!=0);
//do thrust & drag
// NOTE: this always must be dependent on FrameTime, if sim_time differs!
if ((drag = obj->mtype.phys_info.drag) != 0) {
int count;
vms_vector accel;
fix r,k,have_accel;
count = FrameTime / FT;
r = FrameTime % FT;
k = fixdiv(r,FT);
if (obj->mtype.phys_info.flags & PF_USES_THRUST) {
vm_vec_copy_scale(&accel,&obj->mtype.phys_info.thrust,fixdiv(f1_0,obj->mtype.phys_info.mass));
have_accel = (accel.x || accel.y || accel.z);
while (count--) {
if (have_accel)
vm_vec_add2(&obj->mtype.phys_info.velocity,&accel);
vm_vec_scale(&obj->mtype.phys_info.velocity,f1_0-drag);
}
//do linear scale on remaining bit of time
vm_vec_scale_add2(&obj->mtype.phys_info.velocity,&accel,k);
if (drag)
vm_vec_scale(&obj->mtype.phys_info.velocity,f1_0-fixmul(k,drag));
}
else if (drag)
{
fix total_drag=f1_0;
while (count--)
total_drag = fixmul(total_drag,f1_0-drag);
//do linear scale on remaining bit of time
total_drag = fixmul(total_drag,f1_0-fixmul(k,drag));
vm_vec_scale(&obj->mtype.phys_info.velocity,total_drag);
}
}
do {
try_again = 0;
//Move the object
vm_vec_copy_scale(&frame_vec, &obj->mtype.phys_info.velocity, sim_time);
if ( (frame_vec.x==0) && (frame_vec.y==0) && (frame_vec.z==0) )
break;
count++;
// If retry count is getting large, then we are trying to do something stupid.
if (count > 8) break; // in original code this was 3 for all non-player objects. still leave us some limit in case fvi goes apeshit.
vm_vec_add(&new_pos,&obj->pos,&frame_vec);
ignore_obj_list[n_ignore_objs] = -1;
fq.p0 = &obj->pos;
fq.startseg = obj->segnum;
fq.p1 = &new_pos;
fq.rad = obj->size;
fq.thisobjnum = objnum;
fq.ignore_obj_list = ignore_obj_list;
fq.flags = FQ_CHECK_OBJS;
if (obj->type == OBJ_WEAPON)
fq.flags |= FQ_TRANSPOINT;
if (obj->type == OBJ_PLAYER)
fq.flags |= FQ_GET_SEGLIST;
fate = find_vector_intersection(&fq,&hit_info);
// Matt: Mike's hack.
if (fate == HIT_OBJECT) {
object *objp = &Objects[hit_info.hit_object];
if (((objp->type == OBJ_WEAPON) && (objp->id == PROXIMITY_ID)) || objp->type == OBJ_POWERUP) // do not increase count for powerups since they *should* not change our movement
count--;
}
#ifndef NDEBUG
if (fate == HIT_BAD_P0) {
Int3();
}
#endif
if (obj->type == OBJ_PLAYER) {
int i;
if (n_phys_segs && phys_seglist[n_phys_segs-1]==hit_info.seglist[0])
n_phys_segs--;
for (i=0;(i<hit_info.n_segs) && (n_phys_segs<MAX_FVI_SEGS-1); )
phys_seglist[n_phys_segs++] = hit_info.seglist[i++];
}
ipos = hit_info.hit_pnt;
iseg = hit_info.hit_seg;
WallHitSide = hit_info.hit_side;
WallHitSeg = hit_info.hit_side_seg;
if (iseg==-1) { //some sort of horrible error
if (obj->type == OBJ_WEAPON)
obj->flags |= OF_SHOULD_BE_DEAD;
break;
}
Assert(!((fate==HIT_WALL) && ((WallHitSeg == -1) || (WallHitSeg > Highest_segment_index))));
//if(!get_seg_masks(&hit_info.hit_pnt,hit_info.hit_seg,0).centermask==0)
// Int3();
save_pos = obj->pos; //save the object's position
save_seg = obj->segnum;
// update object's position and segment number
obj->pos = ipos;
if ( iseg != obj->segnum )
obj_relink(objnum, iseg );
//if start point not in segment, move object to center of segment
if (get_seg_masks(&obj->pos,obj->segnum,0,__FILE__,__LINE__).centermask!=0) {
int n;
if ((n=find_object_seg(obj))==-1) {
//Int3();
if (obj->type==OBJ_PLAYER && (n=find_point_seg(&obj->last_pos,obj->segnum))!=-1) {
obj->pos = obj->last_pos;
obj_relink(objnum, n );
}
else {
compute_segment_center(&obj->pos,&Segments[obj->segnum]);
obj->pos.x += objnum;
}
if (obj->type == OBJ_WEAPON)
obj->flags |= OF_SHOULD_BE_DEAD;
}
return;
}
//calulate new sim time
{
//vms_vector moved_vec;
vms_vector moved_vec_n;
fix attempted_dist,actual_dist;
actual_dist = vm_vec_normalized_dir(&moved_vec_n,&obj->pos,&save_pos);
if (fate==HIT_WALL && vm_vec_dot(&moved_vec_n,&frame_vec) < 0) { //moved backwards
//don't change position or sim_time
obj->pos = save_pos;
//iseg = obj->segnum; //don't change segment
obj_relink(objnum, save_seg );
moved_time = 0;
}
else {
fix old_sim_time;
attempted_dist = vm_vec_mag(&frame_vec);
old_sim_time = sim_time;
sim_time = fixmuldiv(sim_time,attempted_dist-actual_dist,attempted_dist);
moved_time = old_sim_time - sim_time;
if (sim_time < 0 || sim_time>old_sim_time) {
sim_time = old_sim_time;
//WHY DOES THIS HAPPEN??
moved_time = 0;
}
}
}
switch( fate ) {
case HIT_WALL: {
vms_vector moved_v;
fix hit_speed=0, wall_part=0;
// Find hit speed
vm_vec_sub(&moved_v,&obj->pos,&save_pos);
wall_part = vm_vec_dot(&moved_v,&hit_info.hit_wallnorm);
if ((wall_part != 0 && moved_time>0 && (hit_speed=-fixdiv(wall_part,moved_time))>0) || obj->type == OBJ_WEAPON || obj->type == OBJ_DEBRIS)
collide_object_with_wall( obj, hit_speed, WallHitSeg, WallHitSide, &hit_info.hit_pnt );
if (obj->type == OBJ_PLAYER)
scrape_player_on_wall(obj, WallHitSeg, WallHitSide, &hit_info.hit_pnt );
Assert( WallHitSeg > -1 );
Assert( WallHitSide > -1 );
if ( !(obj->flags&OF_SHOULD_BE_DEAD) ) {
Assert(! (obj->mtype.phys_info.flags & PF_STICK && obj->mtype.phys_info.flags & PF_BOUNCE)); //can't be bounce and stick
if (obj->mtype.phys_info.flags & PF_STICK) { //stop moving
add_stuck_object(obj, WallHitSeg, WallHitSide);
vm_vec_zero(&obj->mtype.phys_info.velocity);
obj_stopped = 1;
try_again = 0;
}
else { // Slide object along wall
//We're constrained by wall, so subtract wall part from
//velocity vector
wall_part = vm_vec_dot(&hit_info.hit_wallnorm,&obj->mtype.phys_info.velocity);
// if wall_part, make sure the value is sane enough to get usable velocity computed
if (wall_part < 0 && wall_part > -f1_0) wall_part = -f1_0;
if (wall_part > 0 && wall_part < f1_0) wall_part = f1_0;
if (obj->mtype.phys_info.flags & PF_BOUNCE) //bounce off wall
wall_part *= 2; //Subtract out wall part twice to achieve bounce
vm_vec_scale_add2(&obj->mtype.phys_info.velocity,&hit_info.hit_wallnorm,-wall_part);
try_again = 1;
}
}
break;
}
case HIT_OBJECT: {
vms_vector old_vel;
// Mark the hit object so that on a retry the fvi code
// ignores this object.
Assert(hit_info.hit_object != -1);
// Calculcate the hit point between the two objects.
{ vms_vector *ppos0, *ppos1, pos_hit;
fix size0, size1;
ppos0 = &Objects[hit_info.hit_object].pos;
ppos1 = &obj->pos;
size0 = Objects[hit_info.hit_object].size;
size1 = obj->size;
Assert(size0+size1 != 0); // Error, both sizes are 0, so how did they collide, anyway?!?
//vm_vec_scale(vm_vec_sub(&pos_hit, ppos1, ppos0), fixdiv(size0, size0 + size1));
//vm_vec_add2(&pos_hit, ppos0);
vm_vec_sub(&pos_hit, ppos1, ppos0);
vm_vec_scale_add(&pos_hit,ppos0,&pos_hit,fixdiv(size0, size0 + size1));
old_vel = obj->mtype.phys_info.velocity;
collide_two_objects( obj, &Objects[hit_info.hit_object], &pos_hit);
}
// Let object continue its movement
if ( !(obj->flags&OF_SHOULD_BE_DEAD) ) {
//obj->pos = save_pos;
if (obj->mtype.phys_info.flags&PF_PERSISTENT || (old_vel.x == obj->mtype.phys_info.velocity.x && old_vel.y == obj->mtype.phys_info.velocity.y && old_vel.z == obj->mtype.phys_info.velocity.z)) {
//if (Objects[hit_info.hit_object].type == OBJ_POWERUP)
ignore_obj_list[n_ignore_objs++] = hit_info.hit_object;
try_again = 1;
}
}
break;
}
case HIT_NONE:
break;
#ifndef NDEBUG
case HIT_BAD_P0:
Int3(); // Unexpected collision type: start point not in specified segment.
break;
default:
// Unknown collision type returned from find_vector_intersection!!
Int3();
break;
#endif
}
} while ( try_again );
// Pass retry count info to AI.
if (obj->control_type == CT_AI) {
if (count > 0) {
Ai_local_info[objnum].retry_count = count-1;
Total_retries += count-1;
Total_sims++;
}
}
// As sim_time may not base on FrameTime, scale actual object position to get accurate movement
if (PhysTime/FrameTime > 0)
{
vms_vector md;
vm_vec_sub(&md, &obj->pos, &start_pos);
vm_vec_scale(&md, F1_0/((float)PhysTime/FrameTime));
vm_vec_add(&obj->pos,&start_pos, &md);
//check for and update correct object segment
if(!get_seg_masks(&obj->pos, obj->segnum, 0, __FILE__, __LINE__).centermask == 0)
{
if (!update_object_seg(obj)) {
if (!(Game_mode & GM_MULTI))
Int3();
compute_segment_center(&obj->pos,&Segments[obj->segnum]);
obj->pos.x += objnum;
}
}
}
// After collision with objects and walls, set velocity from actual movement
if (!obj_stopped
&& ((obj->type == OBJ_PLAYER) || (obj->type == OBJ_ROBOT) || (obj->type == OBJ_DEBRIS))
&& ((fate == HIT_WALL) || (fate == HIT_OBJECT) || (fate == HIT_BAD_P0))
)
{
vms_vector moved_vec;
vm_vec_sub(&moved_vec,&obj->pos,&start_pos);
vm_vec_copy_scale(&obj->mtype.phys_info.velocity,&moved_vec,fixdiv(f1_0,FrameTime));
}
fix_illegal_wall_intersection(obj, &start_pos);
//Assert(check_point_in_seg(&obj->pos,obj->segnum,0).centermask==0);
//if (obj->control_type == CT_FLYING)
if (obj->mtype.phys_info.flags & PF_LEVELLING)
do_physics_align_object( obj );
//hack to keep player from going through closed doors
if (obj->type==OBJ_PLAYER && obj->segnum!=orig_segnum && (!cheats.ghostphysics) ) {
int sidenum;
sidenum = find_connect_side(&Segments[obj->segnum],&Segments[orig_segnum]);
if (sidenum != -1) {
if (! (WALL_IS_DOORWAY(&Segments[orig_segnum],sidenum) & WID_FLY_FLAG)) {
side *s;
int vertnum,num_faces,i;
fix dist;
int vertex_list[6];
//bump object back
s = &Segments[orig_segnum].sides[sidenum];
create_abs_vertex_lists( &num_faces, vertex_list, orig_segnum, sidenum, __FILE__,__LINE__);
//let's pretend this wall is not triangulated
vertnum = vertex_list[0];
for (i=1;i<4;i++)
if (vertex_list[i] < vertnum)
vertnum = vertex_list[i];
#ifdef COMPACT_SEGS
{
vms_vector _vn;
get_side_normal(&Segments[orig_segnum], sidenum, 0, &_vn );
dist = vm_dist_to_plane(&start_pos, &_vn, &Vertices[vertnum]);
vm_vec_scale_add(&obj->pos,&start_pos,&_vn,obj->size-dist);
}
#else
dist = vm_dist_to_plane(&start_pos, &s->normals[0], &Vertices[vertnum]);
vm_vec_scale_add(&obj->pos,&start_pos,&s->normals[0],obj->size-dist);
#endif
update_object_seg(obj);
}
}
}
//--WE ALWYS WANT THIS IN, MATT AND MIKE DECISION ON 12/10/94, TWO MONTHS AFTER FINAL #ifndef NDEBUG
//if end point not in segment, move object to last pos, or segment center
if (get_seg_masks(&obj->pos,obj->segnum,0,__FILE__,__LINE__).centermask!=0) {
if (find_object_seg(obj)==-1) {
int n;
//Int3();
if (obj->type==OBJ_PLAYER && (n=find_point_seg(&obj->last_pos,obj->segnum))!=-1) {
obj->pos = obj->last_pos;
obj_relink(objnum, n );
}
else {
compute_segment_center(&obj->pos,&Segments[obj->segnum]);
obj->pos.x += objnum;
}
if (obj->type == OBJ_WEAPON)
obj->flags |= OF_SHOULD_BE_DEAD;
}
}
//--WE ALWYS WANT THIS IN, MATT AND MIKE DECISION ON 12/10/94, TWO MONTHS AFTER FINAL #endif
}
// -----------------------------------------------------------------------------------------------------------
//Simulate a physics object for this frame
do_physics_sim(object *obj)
{
int ignore_obj_list[MAX_IGNORE_OBJS],n_ignore_objs;
int iseg;
int try_again;
int fate;
vms_vector frame_vec; //movement in this frame
vms_vector new_pos,ipos; //position after this frame
int count=0;
int objnum;
int WallHitSeg, WallHitSide;
fvi_info hit_info;
fvi_query fq;
vms_vector save_pos;
int save_seg;
fix drag;
fix sim_time;
vms_vector start_pos;
int obj_stopped=0;
fix moved_time; //how long objected moved before hit something
vms_vector save_p0,save_p1;
physics_info *pi;
int orig_segnum = obj->segnum;
Assert(obj->type != OBJ_NONE);
Assert(obj->movement_type == MT_PHYSICS);
#ifndef NDEBUG
if (Dont_move_ai_objects)
if (obj->control_type == CT_AI)
return;
#endif
pi = &obj->mtype.phys_info;
do_physics_sim_rot(obj);
if (!(pi->velocity.x || pi->velocity.y || pi->velocity.z || pi->thrust.x || pi->thrust.y || pi->thrust.z))
return;
objnum = obj-Objects;
n_phys_segs = 0;
disable_new_fvi_stuff = (obj->type != OBJ_PLAYER);
sim_time = FrameTime;
//debug_obj = obj;
#ifdef EXTRA_DEBUG
if (obj == debug_obj) {
printf("object %d:\n start pos = %x %x %x\n",objnum,XYZ(&obj->pos));
printf(" thrust = %x %x %x\n",XYZ(&obj->mtype.phys_info.thrust));
printf(" sim_time = %x\n",sim_time);
}
//check for correct object segment
if(!get_seg_masks(&obj->pos,obj->segnum,0).centermask==0) {
#ifndef NDEBUG
mprintf((0,"Warning: object %d not in given seg!\n",objnum));
#endif
//Int3(); Removed by Rob 10/5/94
if (!update_object_seg(obj)) {
#ifndef NDEBUG
mprintf((0,"Warning: can't find seg for object %d - moving\n",objnum));
#endif
if (!(Game_mode & GM_MULTI))
Int3();
compute_segment_center(&obj->pos,&Segments[obj->segnum]);
obj->pos.x += objnum;
}
}
#endif
start_pos = obj->pos;
n_ignore_objs = 0;
Assert(obj->mtype.phys_info.brakes==0); //brakes not used anymore?
//if uses thrust, cannot have zero drag
Assert(!(obj->mtype.phys_info.flags&PF_USES_THRUST) || obj->mtype.phys_info.drag!=0);
//mprintf((0,"thrust=%x speed=%x\n",vm_vec_mag(&obj->mtype.phys_info.thrust),vm_vec_mag(&obj->mtype.phys_info.velocity)));
//do thrust & drag
if ((drag = obj->mtype.phys_info.drag) != 0) {
int count;
vms_vector accel;
fix r,k;
count = sim_time / FT;
r = sim_time % FT;
k = fixdiv(r,FT);
if (obj->mtype.phys_info.flags & PF_USES_THRUST) {
vm_vec_copy_scale(&accel,&obj->mtype.phys_info.thrust,fixdiv(f1_0,obj->mtype.phys_info.mass));
while (count--) {
vm_vec_add2(&obj->mtype.phys_info.velocity,&accel);
vm_vec_scale(&obj->mtype.phys_info.velocity,f1_0-drag);
}
//do linear scale on remaining bit of time
vm_vec_scale_add2(&obj->mtype.phys_info.velocity,&accel,k);
vm_vec_scale(&obj->mtype.phys_info.velocity,f1_0-fixmul(k,drag));
}
else {
fix total_drag=f1_0;
while (count--)
total_drag = fixmul(total_drag,f1_0-drag);
//do linear scale on remaining bit of time
total_drag = fixmul(total_drag,f1_0-fixmul(k,drag));
vm_vec_scale(&obj->mtype.phys_info.velocity,total_drag);
}
}
#ifdef EXTRA_DEBUG
if (obj == debug_obj)
printf(" velocity = %x %x %x\n",XYZ(&obj->mtype.phys_info.velocity));
#endif
do {
try_again = 0;
//Move the object
vm_vec_copy_scale(&frame_vec, &obj->mtype.phys_info.velocity, sim_time);
#ifdef EXTRA_DEBUG
if (obj == debug_obj)
printf(" pass %d, frame_vec = %x %x %x\n",count,XYZ(&frame_vec));
#endif
if ( (frame_vec.x==0) && (frame_vec.y==0) && (frame_vec.z==0) )
break;
count++;
// If retry count is getting large, then we are trying to do something stupid.
if ( count > 3) {
if (obj->type == OBJ_PLAYER) {
if (count > 8)
break;
} else
break;
}
vm_vec_add(&new_pos,&obj->pos,&frame_vec);
#ifdef EXTRA_DEBUG
if (obj == debug_obj)
printf(" desired_pos = %x %x %x\n",XYZ(&new_pos));
#endif
ignore_obj_list[n_ignore_objs] = -1;
#ifdef EXTRA_DEBUG
if (obj == debug_obj) {
printf(" FVI parms: p0 = %8x %8x %8x, segnum=%x, size=%x\n",XYZ(&obj->pos),obj->segnum,obj->size);
printf(" p1 = %8x %8x %8x\n",XYZ(&new_pos));
}
#endif
fq.p0 = &obj->pos;
fq.startseg = obj->segnum;
fq.p1 = &new_pos;
fq.rad = obj->size;
fq.thisobjnum = objnum;
fq.ignore_obj_list = ignore_obj_list;
fq.flags = FQ_CHECK_OBJS;
if (obj->type == OBJ_WEAPON)
fq.flags |= FQ_TRANSPOINT;
if (obj->type == OBJ_PLAYER)
fq.flags |= FQ_GET_SEGLIST;
//@@ if (get_seg_masks(&obj->pos,obj->segnum,0).centermask!=0)
//@@ Int3();
save_p0 = *fq.p0;
save_p1 = *fq.p1;
fate = find_vector_intersection(&fq,&hit_info);
// Matt: Mike's hack.
if (fate == HIT_OBJECT) {
object *objp = &Objects[hit_info.hit_object];
if ((objp->type == OBJ_WEAPON) && (objp->id == PROXIMITY_ID))
count--;
}
#ifndef NDEBUG
if (fate == HIT_BAD_P0) {
mprintf((0,"Warning: Bad p0 in physics! Object = %i, type = %i [%s]\n", obj-Objects, obj->type, Object_type_names[obj->type]));
Int3();
}
#endif
if (obj->type == OBJ_PLAYER) {
int i;
if (n_phys_segs && phys_seglist[n_phys_segs-1]==hit_info.seglist[0])
n_phys_segs--;
for (i=0;(i<hit_info.n_segs) && (n_phys_segs<MAX_FVI_SEGS-1); )
phys_seglist[n_phys_segs++] = hit_info.seglist[i++];
}
#ifdef EXTRA_DEBUG
if (obj == debug_obj)
printf(" fate = %d, hit_pnt = %8x %8x %8x\n",fate,XYZ(&hit_info.hit_pnt));;
#endif
ipos = hit_info.hit_pnt;
iseg = hit_info.hit_seg;
WallHitSide = hit_info.hit_side;
WallHitSeg = hit_info.hit_side_seg;
if (iseg==-1) { //some sort of horrible error
#ifndef NDEBUG
mprintf((1,"iseg==-1 in physics! Object = %i, type = %i (%s)\n", obj-Objects, obj->type, Object_type_names[obj->type]));
#endif
//Int3();
//compute_segment_center(&ipos,&Segments[obj->segnum]);
//ipos.x += objnum;
//iseg = obj->segnum;
//fate = HIT_NONE;
if (obj->type == OBJ_WEAPON)
obj->flags |= OF_SHOULD_BE_DEAD;
break;
}
Assert(!((fate==HIT_WALL) && ((WallHitSeg == -1) || (WallHitSeg > Highest_segment_index))));
//if(!get_seg_masks(&hit_info.hit_pnt,hit_info.hit_seg,0).centermask==0)
// Int3();
save_pos = obj->pos; //save the object's position
save_seg = obj->segnum;
// update object's position and segment number
obj->pos = ipos;
#ifdef EXTRA_DEBUG
if (obj == debug_obj)
printf(" new pos = %x %x %x\n",XYZ(&obj->pos));
#endif
if ( iseg != obj->segnum )
obj_relink(objnum, iseg );
//if start point not in segment, move object to center of segment
if (get_seg_masks(&obj->pos,obj->segnum,0).centermask!=0) {
int n;
if ((n=find_object_seg(obj))==-1) {
//Int3();
if (obj->type==OBJ_PLAYER && (n=find_point_seg(&obj->last_pos,obj->segnum))!=-1) {
obj->pos = obj->last_pos;
obj_relink(objnum, n );
}
else {
compute_segment_center(&obj->pos,&Segments[obj->segnum]);
obj->pos.x += objnum;
}
if (obj->type == OBJ_WEAPON)
obj->flags |= OF_SHOULD_BE_DEAD;
}
return;
}
//calulate new sim time
{
//vms_vector moved_vec;
vms_vector moved_vec_n;
fix attempted_dist,actual_dist;
actual_dist = vm_vec_normalized_dir(&moved_vec_n,&obj->pos,&save_pos);
if (fate==HIT_WALL && vm_vec_dot(&moved_vec_n,&frame_vec) < 0) { //moved backwards
//don't change position or sim_time
//******* mprintf((0,"Obj %d moved backwards\n",obj-Objects));
#ifdef EXTRA_DEBUG
if (obj == debug_obj)
printf(" Warning: moved backwards!\n");
#endif
obj->pos = save_pos;
//iseg = obj->segnum; //don't change segment
obj_relink(objnum, save_seg );
moved_time = 0;
}
else {
fix old_sim_time;
//if (obj == debug_obj)
// printf(" moved_vec = %x %x %x\n",XYZ(&moved_vec));
attempted_dist = vm_vec_mag(&frame_vec);
old_sim_time = sim_time;
sim_time = fixmuldiv(sim_time,attempted_dist-actual_dist,attempted_dist);
moved_time = old_sim_time - sim_time;
if (sim_time < 0 || sim_time>old_sim_time) {
#ifndef NDEBUG
mprintf((0,"Bogus sim_time = %x, old = %x\n",sim_time,old_sim_time));
if (obj == debug_obj)
printf(" Bogus sim_time = %x, old = %x, attempted_dist = %x, actual_dist = %x\n",sim_time,old_sim_time,attempted_dist,actual_dist);
//Int3(); Removed by Rob
#endif
sim_time = old_sim_time;
//WHY DOES THIS HAPPEN??
moved_time = 0;
}
}
#ifdef EXTRA_DEBUG
if (obj == debug_obj)
printf(" new sim_time = %x\n",sim_time);
#endif
}
switch( fate ) {
case HIT_WALL: {
vms_vector moved_v;
//@@fix total_d,moved_d;
fix hit_speed,wall_part;
// Find hit speed
vm_vec_sub(&moved_v,&obj->pos,&save_pos);
wall_part = vm_vec_dot(&moved_v,&hit_info.hit_wallnorm);
if (wall_part != 0 && moved_time>0 && (hit_speed=-fixdiv(wall_part,moved_time))>0)
collide_object_with_wall( obj, hit_speed, WallHitSeg, WallHitSide, &hit_info.hit_pnt );
else
scrape_object_on_wall(obj, WallHitSeg, WallHitSide, &hit_info.hit_pnt );
Assert( WallHitSeg > -1 );
Assert( WallHitSide > -1 );
if ( !(obj->flags&OF_SHOULD_BE_DEAD) ) {
Assert(! (obj->mtype.phys_info.flags & PF_STICK && obj->mtype.phys_info.flags & PF_BOUNCE)); //can't be bounce and stick
if (obj->mtype.phys_info.flags & PF_STICK) { //stop moving
// mprintf((0, "Object %i stuck at %i:%i\n", obj-Objects, WallHitSeg, WallHitSide));
add_stuck_object(obj, WallHitSeg, WallHitSide);
vm_vec_zero(&obj->mtype.phys_info.velocity);
obj_stopped = 1;
try_again = 0;
}
else { // Slide object along wall
//We're constrained by wall, so subtract wall part from
//velocity vector
wall_part = vm_vec_dot(&hit_info.hit_wallnorm,&obj->mtype.phys_info.velocity);
if (obj->mtype.phys_info.flags & PF_BOUNCE) //bounce off wall
wall_part *= 2; //Subtract out wall part twice to achieve bounce
vm_vec_scale_add2(&obj->mtype.phys_info.velocity,&hit_info.hit_wallnorm,-wall_part);
#ifdef EXTRA_DEBUG
if (obj == debug_obj) {
printf(" sliding - wall_norm %x %x %x\n",wall_part,XYZ(&hit_info.hit_wallnorm));
printf(" wall_part %x, new velocity = %x %x %x\n",wall_part,XYZ(&obj->mtype.phys_info.velocity));
}
#endif
try_again = 1;
}
}
break;
}
case HIT_OBJECT: {
vms_vector old_vel;
// Mark the hit object so that on a retry the fvi code
// ignores this object.
Assert(hit_info.hit_object != -1);
// Calculcate the hit point between the two objects.
{ vms_vector *ppos0, *ppos1, pos_hit;
fix size0, size1;
ppos0 = &Objects[hit_info.hit_object].pos;
ppos1 = &obj->pos;
size0 = Objects[hit_info.hit_object].size;
size1 = obj->size;
Assert(size0+size1 != 0); // Error, both sizes are 0, so how did they collide, anyway?!?
//vm_vec_scale(vm_vec_sub(&pos_hit, ppos1, ppos0), fixdiv(size0, size0 + size1));
//vm_vec_add2(&pos_hit, ppos0);
vm_vec_sub(&pos_hit, ppos1, ppos0);
vm_vec_scale_add(&pos_hit,ppos0,&pos_hit,fixdiv(size0, size0 + size1));
old_vel = obj->mtype.phys_info.velocity;
collide_two_objects( obj, &Objects[hit_info.hit_object], &pos_hit);
}
// Let object continue its movement
if ( !(obj->flags&OF_SHOULD_BE_DEAD) ) {
//obj->pos = save_pos;
if (obj->mtype.phys_info.flags&PF_PERSISTENT || (old_vel.x == obj->mtype.phys_info.velocity.x && old_vel.y == obj->mtype.phys_info.velocity.y && old_vel.z == obj->mtype.phys_info.velocity.z)) {
//if (Objects[hit_info.hit_object].type == OBJ_POWERUP)
ignore_obj_list[n_ignore_objs++] = hit_info.hit_object;
try_again = 1;
}
}
break;
}
case HIT_NONE:
break;
#ifndef NDEBUG
case HIT_BAD_P0:
Int3(); // Unexpected collision type: start point not in specified segment.
mprintf((0,"Warning: Bad p0 in physics!!!\n"));
break;
default:
// Unknown collision type returned from find_vector_intersection!!
Int3();
break;
#endif
}
} while ( try_again );
// Pass retry count info to AI.
if (obj->control_type == CT_AI) {
if (count > 0) {
Ai_local_info[objnum].retry_count = count-1;
Total_retries += count-1;
Total_sims++;
}
}
if (! obj_stopped) { //Set velocity from actual movement
vms_vector moved_vec;
vm_vec_sub(&moved_vec,&obj->pos,&start_pos);
vm_vec_copy_scale(&obj->mtype.phys_info.velocity,&moved_vec,fixdiv(f1_0,FrameTime));
#ifdef BUMP_HACK
if (obj==ConsoleObject && (obj->mtype.phys_info.velocity.x==0 && obj->mtype.phys_info.velocity.y==0 && obj->mtype.phys_info.velocity.z==0) &&
!(obj->mtype.phys_info.thrust.x==0 && obj->mtype.phys_info.thrust.y==0 && obj->mtype.phys_info.thrust.z==0)) {
vms_vector center,bump_vec;
//bump player a little towards center of segment to unstick
compute_segment_center(¢er,&Segments[obj->segnum]);
vm_vec_normalized_dir_quick(&bump_vec,¢er,&obj->pos);
vm_vec_scale_add2(&obj->pos,&bump_vec,obj->size/5);
}
#endif
}
//Assert(check_point_in_seg(&obj->pos,obj->segnum,0).centermask==0);
//if (obj->control_type == CT_FLYING)
if (obj->mtype.phys_info.flags & PF_LEVELLING)
do_physics_align_object( obj );
//hack to keep player from going through closed doors
if (obj->type==OBJ_PLAYER && obj->segnum!=orig_segnum && (Physics_cheat_flag!=0xBADA55) ) {
int sidenum;
sidenum = find_connect_side(&Segments[obj->segnum],&Segments[orig_segnum]);
if (sidenum != -1) {
if (! (WALL_IS_DOORWAY(&Segments[orig_segnum],sidenum) & WID_FLY_FLAG)) {
side *s;
int vertnum,num_faces,i;
fix dist;
int vertex_list[6];
//bump object back
s = &Segments[orig_segnum].sides[sidenum];
create_abs_vertex_lists( &num_faces, vertex_list, orig_segnum, sidenum);
//let's pretend this wall is not triangulated
vertnum = vertex_list[0];
for (i=1;i<4;i++)
if (vertex_list[i] < vertnum)
vertnum = vertex_list[i];
#ifdef COMPACT_SEGS
{
vms_vector _vn;
get_side_normal(&Segments[orig_segnum], sidenum, 0, &_vn );
dist = vm_dist_to_plane(&start_pos, &_vn, &Vertices[vertnum]);
vm_vec_scale_add(&obj->pos,&start_pos,&_vn,obj->size-dist);
}
#else
dist = vm_dist_to_plane(&start_pos, &s->normals[0], &Vertices[vertnum]);
vm_vec_scale_add(&obj->pos,&start_pos,&s->normals[0],obj->size-dist);
#endif
update_object_seg(obj);
}
}
}
//--WE ALWYS WANT THIS IN, MATT AND MIKE DECISION ON 12/10/94, TWO MONTHS AFTER FINAL #ifndef NDEBUG
//if end point not in segment, move object to last pos, or segment center
if (get_seg_masks(&obj->pos,obj->segnum,0).centermask!=0) {
if (find_object_seg(obj)==-1) {
int n;
//Int3();
if (obj->type==OBJ_PLAYER && (n=find_point_seg(&obj->last_pos,obj->segnum))!=-1) {
obj->pos = obj->last_pos;
obj_relink(objnum, n );
}
else {
compute_segment_center(&obj->pos,&Segments[obj->segnum]);
obj->pos.x += objnum;
}
if (obj->type == OBJ_WEAPON)
obj->flags |= OF_SHOULD_BE_DEAD;
}
}
//--WE ALWYS WANT THIS IN, MATT AND MIKE DECISION ON 12/10/94, TWO MONTHS AFTER FINAL #endif
}
// hud_do_lock_indicator() manages missle locking, both the non-rendering calculations and the 2D HUD rendering
void hud_do_lock_indicator(float frametime)
{
ship_weapon *swp;
weapon_info *wip;
// if i'm a multiplayer observer, bail here
if((Game_mode & GM_MULTIPLAYER) && ((Net_player->flags & NETINFO_FLAG_OBSERVER) || (Player_obj->type == OBJ_OBSERVER)) ){
return;
}
Assert(Player_ai->target_objnum >= 0);
// be sure to unset this flag, then possibly set later in this function so that
// threat indicators work properly.
Player_ai->ai_flags.remove(AI::AI_Flags::Seek_lock);
if ( hud_abort_lock() ) {
hud_lock_reset();
return;
}
// if there is an EMP effect active, never update lock
if(emp_active_local()){
hud_lock_reset();
return;
}
swp = &Player_ship->weapons;
wip = &Weapon_info[swp->secondary_bank_weapons[swp->current_secondary_bank]];
Lock_start_dist = wip->min_lock_time * wip->lock_pixels_per_sec;
// if secondary weapons change, reset the lock
if ( hud_lock_secondary_weapon_changed(swp) ) {
hud_lock_reset();
}
Player_ai->last_secondary_index = swp->current_secondary_bank;
object *tobjp = &Objects[Player_ai->target_objnum];
vec3d dir_to_target;
vm_vec_normalized_dir(&dir_to_target, &tobjp->pos, &Player_obj->pos);
if ( !(wip->is_locked_homing()) ) {
hud_lock_reset();
return;
}
// Allow locking on ships and bombs (only targeted weapon allowed is a bomb, so don't bother checking flags)
if ( (Objects[Player_ai->target_objnum].type != OBJ_SHIP) && (Objects[Player_ai->target_objnum].type != OBJ_WEAPON) ) {
hud_lock_reset();
return;
}
// Javelins must lock on engines if locking on a ship and those must be in sight
if (wip->wi_flags[Weapon::Info_Flags::Homing_javelin] &&
tobjp->type == OBJ_SHIP &&
Player->locking_subsys != NULL) {
vec3d subobj_pos;
vm_vec_unrotate(&subobj_pos, &Player->locking_subsys->system_info->pnt, &tobjp->orient);
vm_vec_add2(&subobj_pos, &tobjp->pos);
int target_subsys_in_sight = ship_subsystem_in_sight(tobjp, Player->locking_subsys, &Player_obj->pos, &subobj_pos);
if (!target_subsys_in_sight || Player->locking_subsys->system_info->type != SUBSYSTEM_ENGINE) {
Player->locking_subsys =
ship_get_closest_subsys_in_sight(&Ships[tobjp->instance], SUBSYSTEM_ENGINE, &Player_obj->pos);
}
}
if (wip->wi_flags[Weapon::Info_Flags::Homing_javelin] &&
tobjp->type == OBJ_SHIP &&
Player->locking_subsys == NULL) {
Player->locking_subsys =
ship_get_closest_subsys_in_sight(&Ships[tobjp->instance], SUBSYSTEM_ENGINE, &Player_obj->pos);
if (Player->locking_subsys == NULL) {
hud_lock_reset();
return;
}
}
hud_lock_determine_lock_point(&lock_world_pos);
if ( !hud_lock_has_homing_point() ) {
Player->target_in_lock_cone=0;
}
hud_lock_check_if_target_in_lock_cone();
// check if the target is within range of the current secondary weapon. If it is not,
// a lock will not be detected
if ( !hud_lock_target_in_range() ) {
Player->target_in_lock_cone = 0;
}
// If locking on a subsystem, and not in sight... can't lock
// Changed by MK on 4/3/98. It was confusing me that my hornets would not lock on my target.
// It will now be confusing that they lock, but don't home on your subsystem, but I think that's preferable.
// Often you really care about destroying the target, not just the subsystem.
/*if ( Player_ai->targeted_subsys ) {
if ( !hud_lock_on_subsys_ok() ) {
Player->target_in_lock_cone=0;
}
}*/
if ( !Player->target_in_lock_cone ) {
Player->locking_on_center=0;
Player->locking_subsys_parent=-1;
Player->locking_subsys=NULL;
}
hud_calculate_lock_position(frametime);
if (!Players[Player_num].lock_indicator_visible)
return;
if (Player_ai->current_target_is_locked) {
if ( Missile_track_loop > -1 ) {
snd_stop(Missile_track_loop);
Missile_track_loop = -1;
if (wip->hud_locked_snd >= 0)
{
Missile_lock_loop = snd_play(&Snds[wip->hud_locked_snd]);
}
else
{
Missile_lock_loop = snd_play(&Snds[ship_get_sound(Player_obj, SND_MISSILE_LOCK)]);
}
}
}
else {
Player_ai->ai_flags.set(AI::AI_Flags::Seek_lock); // set this flag so multiplayer's properly track lock on other ships
if ( Missile_lock_loop != -1 && snd_is_playing(Missile_lock_loop) ) {
snd_stop(Missile_lock_loop);
Missile_lock_loop = -1;
}
}
}
void camera::get_info(vec3d *position, matrix *orientation)
{
if(position == NULL && orientation == NULL)
return;
eye* eyep = NULL;
vec3d host_normal;
//POSITION
if(!(flags & CAM_STATIONARY_POS) || object_host.IsValid())
{
c_pos = vmd_zero_vector;
vec3d pt;
pos_x.get(&pt.xyz.x, NULL);
pos_y.get(&pt.xyz.y, NULL);
pos_z.get(&pt.xyz.z, NULL);
if(object_host.IsValid())
{
object *objp = object_host.objp;
int model_num = object_get_model(objp);
polymodel *pm = NULL;
if(model_num > -1)
{
pm = model_get(model_num);
}
if(object_host_submodel < 0 || pm == NULL)
{
vm_vec_unrotate(&c_pos, &pt, &object_host.objp->orient);
vm_vec_add2(&c_pos, &object_host.objp->pos);
}
else
{
eyep = get_submodel_eye(pm, object_host_submodel);
if(eyep)
{
vec3d c_pos_in;
find_submodel_instance_point_normal( &c_pos_in, &host_normal, objp, eyep->parent, &eyep->pnt, &eyep->norm);
vm_vec_unrotate(&c_pos, &c_pos_in, &objp->orient);
vm_vec_add2(&c_pos, &objp->pos);
}
else
{
model_find_world_point( &c_pos, &pt, pm->id, object_host_submodel, &objp->orient, &objp->pos );
}
}
}
else
{
c_pos = pt;
}
//Do custom position stuff, if needed
if(func_custom_position != NULL && !eyep)
{
func_custom_position(this, &c_pos);
}
}
if(position != NULL)
*position = c_pos;
//ORIENTATION
if(orientation != NULL)
{
bool target_set = false;
if(!(flags & CAM_STATIONARY_ORI) || object_target.IsValid() || object_host.IsValid())
{
if(object_target.IsValid())
{
object *objp = object_target.objp;
int model_num = object_get_model(objp);
polymodel *pm = NULL;
vec3d target_pos = vmd_zero_vector;
//See if we can get the model
if(model_num > -1)
{
pm = model_get(model_num);
}
//If we don't have a submodel or don't have the model use object pos
//Otherwise, find the submodel pos as it is rotated
if(object_target_submodel < 0 || pm == NULL)
{
target_pos = objp->pos;
}
else
{
model_find_world_point( &target_pos, &vmd_zero_vector, pm->id, object_target_submodel, &objp->orient, &objp->pos );
}
vec3d targetvec;
vm_vec_normalized_dir(&targetvec, &target_pos, &c_pos);
vm_vector_2_matrix(&c_ori, &targetvec, NULL, NULL);
target_set = true;
}
else if(object_host.IsValid())
{
if(eyep)
{
vm_vector_2_matrix(&c_ori, &host_normal, vm_vec_same(&host_normal, &object_host.objp->orient.vec.uvec)?NULL:&object_host.objp->orient.vec.uvec, NULL);
target_set = true;
}
else
{
c_ori = object_host.objp->orient;
}
}
else
{
c_ori = vmd_identity_matrix;
}
matrix mtxA = c_ori;
matrix mtxB = IDENTITY_MATRIX;
float pos = 0.0f;
for(int i = 0; i < 9; i++)
{
ori[i].get(&pos, NULL);
mtxB.a1d[i] = pos;
}
vm_matrix_x_matrix(&c_ori, &mtxA, &mtxB);
vm_orthogonalize_matrix(&c_ori);
}
//Do custom orientation stuff, if needed
if(func_custom_orientation != NULL && !target_set)
{
func_custom_orientation(this, &c_ori);
}
*orientation = c_ori;
}
}
int ship_weapon_check_collision(object *ship_objp, object *weapon_objp, float time_limit = 0.0f, int *next_hit = NULL)
{
mc_info mc, mc_shield, mc_hull;
ship *shipp;
ship_info *sip;
weapon *wp;
weapon_info *wip;
Assert( ship_objp != NULL );
Assert( ship_objp->type == OBJ_SHIP );
Assert( ship_objp->instance >= 0 );
shipp = &Ships[ship_objp->instance];
sip = &Ship_info[shipp->ship_info_index];
Assert( weapon_objp != NULL );
Assert( weapon_objp->type == OBJ_WEAPON );
Assert( weapon_objp->instance >= 0 );
wp = &Weapons[weapon_objp->instance];
wip = &Weapon_info[wp->weapon_info_index];
Assert( shipp->objnum == OBJ_INDEX(ship_objp));
// Make ships that are warping in not get collision detection done
if ( shipp->is_arriving() ) return 0;
// Return information for AI to detect incoming fire.
// Could perhaps be done elsewhere at lower cost --MK, 11/7/97
float dist = vm_vec_dist_quick(&ship_objp->pos, &weapon_objp->pos);
if (dist < weapon_objp->phys_info.speed) {
update_danger_weapon(ship_objp, weapon_objp);
}
int valid_hit_occurred = 0; // If this is set, then hitpos is set
int quadrant_num = -1;
polymodel *pm = model_get(sip->model_num);
// total time is flFrametime + time_limit (time_limit used to predict collisions into the future)
vec3d weapon_end_pos;
vm_vec_scale_add( &weapon_end_pos, &weapon_objp->pos, &weapon_objp->phys_info.vel, time_limit );
// Goober5000 - I tried to make collision code here much saner... here begin the (major) changes
mc_info_init(&mc);
// set up collision structs
mc.model_instance_num = shipp->model_instance_num;
mc.model_num = sip->model_num;
mc.submodel_num = -1;
mc.orient = &ship_objp->orient;
mc.pos = &ship_objp->pos;
mc.p0 = &weapon_objp->last_pos;
mc.p1 = &weapon_end_pos;
mc.lod = sip->collision_lod;
memcpy(&mc_shield, &mc, sizeof(mc_info));
memcpy(&mc_hull, &mc, sizeof(mc_info));
// (btw, these are leftover comments from below...)
//
// Note: This code is obviously stupid. We want to add the shield point if there is shield to hit, but:
// 1. We want the size/color of the hit effect to indicate shield damage done. (i.e., for already-weak shield, smaller effect)
// 2. Currently (8/9/97), apply_damage_to_shield() passes lefer damage to hull, which might not make sense. If
// wouldn't have collided with hull, shouldn't do damage. Once this is fixed, the code below needs to cast the
// vector through to the hull if there is leftover damage.
//
// WIF2_PIERCE_SHIELDS pierces shields
// AL 1-14-97: "Puncture" doesn't mean penetrate shield anymore, it means that it punctures
// hull to inflict maximum subsystem damage
//
// _argv[-1], 16 Jan 2005: Surface shields.
// Surface shields allow for shields on a ship without a shield mesh. Good for putting real shields
// on the Lucifer. This also fixes the strange bug where shots will occasionally go through the
// shield mesh when they shouldn't. I don't know what causes this, but this fixes that -- shields
// will absorb it when it hits the hull instead. This has no fancy graphical effect, though.
// Someone should make one.
// check both kinds of collisions
int shield_collision = 0;
int hull_collision = 0;
// check shields for impact
if (!(ship_objp->flags[Object::Object_Flags::No_shields])) {
if (sip->flags[Ship::Info_Flags::Auto_spread_shields]) {
// The weapon is not allowed to impact the shield before it reaches this point
vec3d shield_ignored_until = weapon_objp->last_pos;
float weapon_flown_for = vm_vec_dist(&wp->start_pos, &weapon_objp->last_pos);
float min_weapon_span;
if (sip->auto_shield_spread_min_span >= 0.0f) {
min_weapon_span = sip->auto_shield_spread_min_span;
} else {
min_weapon_span = sip->auto_shield_spread;
}
// If weapon hasn't yet flown a distance greater than the maximum ignore
// range, then some part of the currently checked range needs to be
// ignored
if (weapon_flown_for < min_weapon_span) {
vm_vec_sub(&shield_ignored_until, &weapon_end_pos, &wp->start_pos);
vm_vec_normalize(&shield_ignored_until);
vm_vec_scale(&shield_ignored_until, min_weapon_span);
vm_vec_add2(&shield_ignored_until, &wp->start_pos);
}
float this_range = vm_vec_dist(&weapon_objp->last_pos, &weapon_end_pos);
// The range during which the weapon is not allowed to collide with the
// shield, except if it actually hits the hull
float ignored_range;
// If the weapon has not yet surpassed the ignore range, calculate the
// remaining ignore range
if (vm_vec_dist(&wp->start_pos, &shield_ignored_until) > weapon_flown_for)
ignored_range = vm_vec_dist(&weapon_objp->last_pos, &shield_ignored_until);
else
ignored_range = 0.0f;
// The range during which the weapon may impact the shield
float active_range = this_range - ignored_range;
// During the ignored range, we only check for a ray collision with
// the model
if (ignored_range > 0.0f) {
mc_shield.flags = MC_CHECK_MODEL;
mc_shield.p1 = &shield_ignored_until;
shield_collision = model_collide(&mc_shield);
mc_shield.p1 = &weapon_end_pos;
mc_shield.hit_dist = mc_shield.hit_dist * (ignored_range / this_range);
}
// If no collision with the model found in the ignore range, only
// then do we check for sphereline collisions with the model during the
// non-ignored range
if (!shield_collision && weapon_flown_for + this_range > min_weapon_span) {
mc_shield.p0 = &shield_ignored_until;
mc_shield.p1 = &weapon_end_pos;
mc_shield.radius = sip->auto_shield_spread;
if (sip->auto_shield_spread_from_lod > -1) {
mc_shield.lod = sip->auto_shield_spread_from_lod;
}
mc_shield.flags = MC_CHECK_MODEL | MC_CHECK_SPHERELINE;
shield_collision = model_collide(&mc_shield);
mc_shield.lod = sip->collision_lod;
mc_shield.submodel_num = -1;
// Because we manipulated p0 and p1 above, hit_dist will be
// relative to the values we used, not the values the rest of
// the code expects; this fixes that
mc_shield.p0 = &weapon_objp->last_pos;
mc_shield.p1 = &weapon_end_pos;
mc_shield.hit_dist = (ignored_range + (active_range * mc_shield.hit_dist)) / this_range;
}
if (shield_collision) {
// If we used a sphereline check, then the collision point will lie
// somewhere on the ship's hull; this re-positions it to lie on the
// correct point along the weapon's path
if (mc_shield.flags & MC_CHECK_SPHERELINE) {
vec3d tempv;
vm_vec_sub(&tempv, mc_shield.p1, mc_shield.p0);
vm_vec_scale(&tempv, mc_shield.hit_dist);
vm_vec_add2(&tempv, mc_shield.p0);
mc_shield.hit_point_world = tempv;
}
// Re-calculate hit_point because it's likely pointing to the wrong
// place
vec3d tempv;
vm_vec_sub(&tempv, &mc_shield.hit_point_world, &ship_objp->pos);
vm_vec_rotate(&mc_shield.hit_point, &tempv, &ship_objp->orient);
}
} else if (sip->flags[Ship::Info_Flags::Surface_shields]) {
if (pm->shield.ntris > 0) {
// If there is a shield mesh, we need to check that first
mc_shield.flags = MC_CHECK_SHIELD;
shield_collision = model_collide(&mc_shield);
}
if (!shield_collision) {
// But if no shield mesh or it was missed, check for a hull collision
mc_shield.flags = MC_CHECK_MODEL;
shield_collision = model_collide(&mc_shield);
// Because we used MC_CHECK_MODEL, the returned hit position might be
// in a submodel's frame of reference, so we need to ensure we end up
// in the ship's frame of reference
vec3d local_pos;
vm_vec_sub(&local_pos, &mc_shield.hit_point_world, &ship_objp->pos);
vm_vec_rotate(&mc_shield.hit_point, &local_pos, &ship_objp->orient);
}
} else {
// Normal collision check against a shield mesh
mc_shield.flags = MC_CHECK_SHIELD;
shield_collision = (pm->shield.ntris > 0) ? model_collide(&mc_shield) : 0;
}
}
// If we found a shield collision but were only checking for a simple model
// collision, we can re-use the same collision info for the hull as well
if (shield_collision && mc_shield.flags == MC_CHECK_MODEL) {
memcpy(&mc_hull, &mc_shield, sizeof(mc_info));
hull_collision = shield_collision;
// The weapon has impacted on the hull, so if it should therefore bypass
// the shields altogether, we do it here
if (sip->auto_shield_spread_bypass) {
shield_collision = 0;
}
} else {
mc_hull.flags = MC_CHECK_MODEL;
hull_collision = model_collide(&mc_hull);
}
if (shield_collision) {
// pick out the shield quadrant
quadrant_num = get_quadrant(&mc_shield.hit_point, ship_objp);
// make sure that the shield is active in that quadrant
if (shipp->flags[Ship::Ship_Flags::Dying] || !ship_is_shield_up(ship_objp, quadrant_num))
quadrant_num = -1;
// see if we hit the shield
if (quadrant_num >= 0) {
// do the hit effect
if ( mc_shield.shield_hit_tri != -1 && (mc_shield.hit_dist*(flFrametime + time_limit) - flFrametime) < 0.0f ) {
add_shield_point(OBJ_INDEX(ship_objp), mc_shield.shield_hit_tri, &mc_shield.hit_point);
}
// if this weapon pierces the shield, then do the hit effect, but act like a shield collision never occurred;
// otherwise, we have a valid hit on this shield
if (wip->wi_flags[Weapon::Info_Flags::Pierce_shields])
quadrant_num = -1;
else
valid_hit_occurred = 1;
}
}
// see which impact we use
if (shield_collision && valid_hit_occurred)
{
memcpy(&mc, &mc_shield, sizeof(mc_info));
Assert(quadrant_num >= 0);
}
else if (hull_collision)
{
memcpy(&mc, &mc_hull, sizeof(mc_info));
valid_hit_occurred = 1;
}
// check if the hit point is beyond the clip plane when warping out.
if ((shipp->flags[Ship::Ship_Flags::Depart_warp]) &&
(shipp->warpout_effect) &&
(valid_hit_occurred))
{
vec3d warp_pnt, hit_direction;
matrix warp_orient;
shipp->warpout_effect->getWarpPosition(&warp_pnt);
shipp->warpout_effect->getWarpOrientation(&warp_orient);
vm_vec_sub(&hit_direction, &mc.hit_point_world, &warp_pnt);
if (vm_vec_dot(&hit_direction, &warp_orient.vec.fvec) < 0.0f)
{
valid_hit_occurred = 0;
}
}
// deal with predictive collisions. Find their actual hit time and see if they occured in current frame
if (next_hit && valid_hit_occurred) {
// find hit time
*next_hit = (int) (1000.0f * (mc.hit_dist*(flFrametime + time_limit) - flFrametime) );
if (*next_hit > 0)
// if hit occurs outside of this frame, do not do damage
return 1;
}
if ( valid_hit_occurred )
{
wp->collisionInfo = new mc_info; // The weapon will free this memory later
memcpy(wp->collisionInfo, &mc, sizeof(mc_info));
Script_system.SetHookObjects(4, "Ship", ship_objp, "Weapon", weapon_objp, "Self",ship_objp, "Object", weapon_objp);
bool ship_override = Script_system.IsConditionOverride(CHA_COLLIDEWEAPON, ship_objp);
Script_system.SetHookObjects(2, "Self",weapon_objp, "Object", ship_objp);
bool weapon_override = Script_system.IsConditionOverride(CHA_COLLIDESHIP, weapon_objp);
if(!ship_override && !weapon_override) {
if (shield_collision && quadrant_num >= 0) {
if ((sip->shield_impact_explosion_anim > -1) && (wip->shield_impact_explosion_radius > 0)) {
shield_impact_explosion(&mc.hit_point, ship_objp, wip->shield_impact_explosion_radius, sip->shield_impact_explosion_anim);
}
}
ship_weapon_do_hit_stuff(ship_objp, weapon_objp, &mc.hit_point_world, &mc.hit_point, quadrant_num, mc.hit_submodel, mc.hit_normal);
}
Script_system.SetHookObjects(2, "Self",ship_objp, "Object", weapon_objp);
if(!(weapon_override && !ship_override))
Script_system.RunCondition(CHA_COLLIDEWEAPON, '\0', NULL, ship_objp, wp->weapon_info_index);
Script_system.SetHookObjects(2, "Self",weapon_objp, "Object", ship_objp);
if((weapon_override && !ship_override) || (!weapon_override && !ship_override))
Script_system.RunCondition(CHA_COLLIDESHIP, '\0', NULL, weapon_objp);
Script_system.RemHookVars(4, "Ship", "Weapon", "Self","Object");
}
else if ((Missiontime - wp->creation_time > F1_0/2) && (wip->is_homing()) && (wp->homing_object == ship_objp)) {
if (dist < wip->shockwave.inner_rad) {
vec3d vec_to_ship;
vm_vec_normalized_dir(&vec_to_ship, &ship_objp->pos, &weapon_objp->pos);
if (vm_vec_dot(&vec_to_ship, &weapon_objp->orient.vec.fvec) < 0.0f) {
// check if we're colliding against "invisible" ship
if (!(shipp->flags[Ship::Ship_Flags::Dont_collide_invis])) {
wp->lifeleft = 0.001f;
if (ship_objp == Player_obj)
nprintf(("Jim", "Frame %i: Weapon %d set to detonate, dist = %7.3f.\n", Framecount, OBJ_INDEX(weapon_objp), dist));
valid_hit_occurred = 1;
}
}
}
}
return valid_hit_occurred;
}
void generate_banked_curve(fix maxscale, vms_equation coeffs) {
vms_vector vec_dir, tvec, b4r4t;
vms_vector coord,prev_point;
fix enddist, nextdist;
int firstsegflag;
fixang rangle, uangle, angle, scaled_ang=0;
fix t;
if (CurveNumSegs) {
const vcsegptr_t cursegp = Cursegp;
extract_up_vector_from_segment(cursegp, b4r4t);
uangle = vm_vec_delta_ang( b4r4t, r4t, r4 );
if (uangle >= F1_0 * 1/8) uangle -= F1_0 * 1/4;
if (uangle >= F1_0 * 1/8) uangle -= F1_0 * 1/4;
if (uangle <= -F1_0 * 1/8) uangle += F1_0 * 1/4;
if (uangle <= -F1_0 * 1/8) uangle += F1_0 * 1/4;
extract_right_vector_from_segment(cursegp, b4r4t);
rangle = vm_vec_delta_ang( b4r4t, r4t, r4 );
if (rangle >= F1_0/8) rangle -= F1_0/4;
if (rangle >= F1_0/8) rangle -= F1_0/4;
if (rangle <= -F1_0/8) rangle += F1_0/4;
if (rangle <= -F1_0/8) rangle += F1_0/4;
angle = uangle;
if (abs(rangle) < abs(uangle)) angle = rangle;
delete_curve();
coord = prev_point = p1;
#define MAGIC_NUM 0.707*F1_0
if (maxscale)
scaled_ang = fixdiv(angle,fixmul(maxscale,MAGIC_NUM));
t=0;
tvec = r1save;
firstsegflag = 1;
enddist = F1_0; nextdist = 0;
while ( enddist > fixmul( nextdist, 1.5*F1_0 )) {
vms_matrix rotmat;
if (firstsegflag==1)
firstsegflag=0;
else
extract_forward_vector_from_segment(cursegp, tvec);
nextdist = vm_vec_mag(tvec); // nextdist := distance to next point
t = curve_dist(&coeffs, 3, t, prev_point, nextdist); // t = argument at which function is forward vector magnitude units away from prev_point (in 3-space, not along curve)
coord = evaluate_curve(&coeffs, 3, t); // coord := point about forward vector magnitude units away from prev_point
enddist = vm_vec_dist(coord, p4); // enddist := distance from current to end point, vec_dir used as a temporary variable
//vm_vec_normalize(vm_vec_sub(&vec_dir, &coord, &prev_point));
vm_vec_normalized_dir(vec_dir, coord, prev_point);
if (!med_attach_segment(Cursegp, vmsegptr(&New_segment), Curside, AttachSide))
{
med_extract_matrix_from_segment(cursegp, &rotmat); // rotmat := matrix describing orientation of Cursegp
const auto tdest = vm_vec_rotate(vec_dir,rotmat); // tdest := vec_dir in reference frame of Cursegp
vec_dir = tdest;
const auto rotmat2 = vm_vec_ang_2_matrix(vec_dir,scaled_ang);
med_rotate_segment( Cursegp, rotmat2 );
prev_point = coord;
Curside = Side_opposite[AttachSide];
CurveSegs[CurveNumSegs]=Cursegp;
CurveNumSegs++;
}
}
}
}
int generate_curve( fix r1scale, fix r4scale ) {
vms_vector vec_dir, tvec;
vms_vector coord,prev_point;
vms_equation coeffs;
fix enddist, nextdist;
int firstsegflag;
fix t, maxscale;
fixang rangle, uangle;
const vcsegptr_t cursegp = Cursegp;
compute_center_point_on_side(p1, cursegp, Curside);
switch( Curside ) {
case WLEFT:
extract_right_vector_from_segment(cursegp, r1);
vm_vec_scale(r1, -F1_0 );
break;
case WTOP:
extract_up_vector_from_segment(cursegp, r1);
break;
case WRIGHT:
extract_right_vector_from_segment(cursegp, r1);
break;
case WBOTTOM:
extract_up_vector_from_segment(cursegp, r1);
vm_vec_scale(r1, -F1_0 );
break;
case WBACK:
extract_forward_vector_from_segment(cursegp, r1);
break;
case WFRONT:
extract_forward_vector_from_segment(cursegp, r1);
vm_vec_scale(r1, -F1_0 );
break;
}
const vcsegptr_t markedsegp = Markedsegp;
compute_center_point_on_side(p4, markedsegp, Markedside);
switch( Markedside ) {
case WLEFT:
extract_right_vector_from_segment(markedsegp, r4);
extract_up_vector_from_segment(markedsegp, r4t);
break;
case WTOP:
extract_up_vector_from_segment(markedsegp, r4);
vm_vec_scale(r4, -F1_0 );
extract_forward_vector_from_segment(markedsegp, r4t);
vm_vec_scale(r4t, -F1_0 );
break;
case WRIGHT:
extract_right_vector_from_segment(markedsegp, r4);
vm_vec_scale(r4, -F1_0 );
extract_up_vector_from_segment(markedsegp, r4t);
break;
case WBOTTOM:
extract_up_vector_from_segment(markedsegp, r4);
extract_forward_vector_from_segment(markedsegp, r4t);
break;
case WBACK:
extract_forward_vector_from_segment(markedsegp, r4);
vm_vec_scale(r4, -F1_0 );
extract_up_vector_from_segment(markedsegp, r4t);
break;
case WFRONT:
extract_forward_vector_from_segment(markedsegp, r4);
extract_up_vector_from_segment(markedsegp, r4t);
break;
}
r1save = r1;
tvec = r1;
vm_vec_scale(r1,r1scale);
vm_vec_scale(r4,r4scale);
create_curve( p1, p4, r1, r4, coeffs );
OriginalSeg = Cursegp;
OriginalMarkedSeg = Markedsegp;
OriginalSide = Curside;
OriginalMarkedSide = Markedside;
CurveNumSegs = 0;
coord = prev_point = p1;
t=0;
firstsegflag = 1;
enddist = F1_0; nextdist = 0;
while ( enddist > fixmul( nextdist, 1.5*F1_0 )) {
vms_matrix rotmat;
if (firstsegflag==1)
firstsegflag=0;
else
extract_forward_vector_from_segment(cursegp, tvec);
nextdist = vm_vec_mag(tvec); // nextdist := distance to next point
t = curve_dist(&coeffs, 3, t, prev_point, nextdist); // t = argument at which function is forward vector magnitude units away from prev_point (in 3-space, not along curve)
coord = evaluate_curve(&coeffs, 3, t); // coord := point about forward vector magnitude units away from prev_point
enddist = vm_vec_dist(coord, p4); // enddist := distance from current to end point, vec_dir used as a temporary variable
//vm_vec_normalize(vm_vec_sub(&vec_dir, &coord, &prev_point));
vm_vec_normalized_dir(vec_dir, coord, prev_point);
if (!med_attach_segment(Cursegp, vmsegptr(&New_segment), Curside, AttachSide))
{
med_extract_matrix_from_segment(cursegp, &rotmat); // rotmat := matrix describing orientation of Cursegp
const auto tdest = vm_vec_rotate(vec_dir,rotmat); // tdest := vec_dir in reference frame of Cursegp
vec_dir = tdest;
const auto rotmat2 = vm_vector_2_matrix(vec_dir,nullptr,nullptr);
med_rotate_segment( Cursegp, rotmat2 );
prev_point = coord;
Curside = Side_opposite[AttachSide];
CurveSegs[CurveNumSegs]=Cursegp;
CurveNumSegs++;
} else return 0;
}
extract_up_vector_from_segment(cursegp, tvec);
uangle = vm_vec_delta_ang( tvec, r4t, r4 );
if (uangle >= F1_0 * 1/8) uangle -= F1_0 * 1/4;
if (uangle >= F1_0 * 1/8) uangle -= F1_0 * 1/4;
if (uangle <= -F1_0 * 1/8) uangle += F1_0 * 1/4;
if (uangle <= -F1_0 * 1/8) uangle += F1_0 * 1/4;
extract_right_vector_from_segment(cursegp, tvec);
rangle = vm_vec_delta_ang( tvec, r4t, r4 );
if (rangle >= F1_0/8) rangle -= F1_0/4;
if (rangle >= F1_0/8) rangle -= F1_0/4;
if (rangle <= -F1_0/8) rangle += F1_0/4;
if (rangle <= -F1_0/8) rangle += F1_0/4;
if ((uangle != 0) && (rangle != 0)) {
maxscale = CurveNumSegs*F1_0;
generate_banked_curve(maxscale, coeffs);
}
if (CurveNumSegs) {
med_form_bridge_segment( Cursegp, Side_opposite[AttachSide], Markedsegp, Markedside );
CurveSegs[CurveNumSegs] = vmsegptr(Markedsegp->children[Markedside]);
CurveNumSegs++;
}
Cursegp = OriginalSeg;
Curside = OriginalSide;
med_create_new_segment_from_cursegp();
//warn_if_concave_segments();
if (CurveNumSegs) return 1;
else return 0;
}
// returns true if powerup consumed
int do_powerup(dxxobject *obj)
{
int used=0;
int special_used=0; //for when hitting vulcan cannon gets vulcan ammo
int id=obj->id;
if ((Player_is_dead) || (ConsoleObject->type == OBJ_GHOST) || (Players[Player_num].shields < 0))
return 0;
if ((obj->ctype.powerup_info.flags & PF_SPAT_BY_PLAYER) && obj->ctype.powerup_info.creation_time>0 && GameTime64<obj->ctype.powerup_info.creation_time+i2f(2))
return 0; //not enough time elapsed
if (Game_mode & GM_MULTI)
{
/*
* The fact: Collecting a powerup is decided Client-side and due to PING it takes time for other players to know if one collected a powerup actually. This may lead to the case two players collect the same powerup!
* The solution: Let us check if someone else is closer to a powerup and if so, do not collect it.
* NOTE: Player positions computed by 'shortpos' and PING can still cause a small margin of error.
*/
int i = 0;
vms_vector tvec;
fix mydist = vm_vec_normalized_dir(&tvec, &obj->pos, &ConsoleObject->pos);
for (i = 0; i < MAX_PLAYERS; i++)
{
if (i == Player_num || Players[i].connected != CONNECT_PLAYING)
continue;
if (Objects[Players[i].objnum].type == OBJ_GHOST || Players[i].shields < 0)
continue;
if (mydist > vm_vec_normalized_dir(&tvec, &obj->pos, &Objects[Players[i].objnum].pos))
return 0;
}
}
switch (obj->id) {
case POW_EXTRA_LIFE:
Players[Player_num].lives++;
powerup_basic(15, 15, 15, 0, TXT_EXTRA_LIFE);
used=1;
break;
case POW_ENERGY:
used = pick_up_energy();
break;
case POW_SHIELD_BOOST:
if (Players[Player_num].shields < MAX_SHIELDS) {
fix boost = 3*F1_0 + 3*F1_0*(NDL - Difficulty_level);
if (Difficulty_level == 0)
boost += boost/2;
Players[Player_num].shields += boost;
if (Players[Player_num].shields > MAX_SHIELDS)
Players[Player_num].shields = MAX_SHIELDS;
powerup_basic(0, 0, 15, SHIELD_SCORE, "%s %s %d",TXT_SHIELD,TXT_BOOSTED_TO,f2ir(Players[Player_num].shields));
used=1;
} else
HUD_init_message(HM_DEFAULT|HM_REDUNDANT|HM_MAYDUPL, TXT_MAXED_OUT,TXT_SHIELD);
break;
case POW_LASER:
if (Players[Player_num].laser_level >= MAX_LASER_LEVEL) {
//Players[Player_num].laser_level = MAX_LASER_LEVEL;
HUD_init_message(HM_DEFAULT|HM_REDUNDANT|HM_MAYDUPL, TXT_MAXED_OUT,TXT_LASER);
} else {
if (Newdemo_state == ND_STATE_RECORDING)
newdemo_record_laser_level(Players[Player_num].laser_level, Players[Player_num].laser_level + 1);
Players[Player_num].laser_level++;
powerup_basic(10, 0, 10, LASER_SCORE, "%s %s %d",TXT_LASER,TXT_BOOSTED_TO, Players[Player_num].laser_level+1);
update_laser_weapon_info();
pick_up_primary (LASER_INDEX);
used=1;
}
if (!used && !(Game_mode & GM_MULTI) )
used = pick_up_energy();
break;
case POW_MISSILE_1:
used=pick_up_secondary(CONCUSSION_INDEX,1);
break;
case POW_MISSILE_4:
used=pick_up_secondary(CONCUSSION_INDEX,4);
break;
case POW_KEY_BLUE:
if (Players[Player_num].flags & PLAYER_FLAGS_BLUE_KEY)
break;
#ifdef NETWORK
multi_send_play_sound(Powerup_info[obj->id].hit_sound, F1_0);
#endif
digi_play_sample( Powerup_info[obj->id].hit_sound, F1_0 );
Players[Player_num].flags |= PLAYER_FLAGS_BLUE_KEY;
powerup_basic(0, 0, 15, KEY_SCORE, "%s %s",TXT_BLUE,TXT_ACCESS_GRANTED);
if (Game_mode & GM_MULTI)
used=0;
else
used=1;
invalidate_escort_goal();
break;
case POW_KEY_RED:
if (Players[Player_num].flags & PLAYER_FLAGS_RED_KEY)
break;
#ifdef NETWORK
multi_send_play_sound(Powerup_info[obj->id].hit_sound, F1_0);
#endif
digi_play_sample( Powerup_info[obj->id].hit_sound, F1_0 );
Players[Player_num].flags |= PLAYER_FLAGS_RED_KEY;
powerup_basic(15, 0, 0, KEY_SCORE, "%s %s",TXT_RED,TXT_ACCESS_GRANTED);
if (Game_mode & GM_MULTI)
used=0;
else
used=1;
invalidate_escort_goal();
break;
case POW_KEY_GOLD:
if (Players[Player_num].flags & PLAYER_FLAGS_GOLD_KEY)
break;
#ifdef NETWORK
multi_send_play_sound(Powerup_info[obj->id].hit_sound, F1_0);
#endif
digi_play_sample( Powerup_info[obj->id].hit_sound, F1_0 );
Players[Player_num].flags |= PLAYER_FLAGS_GOLD_KEY;
powerup_basic(15, 15, 7, KEY_SCORE, "%s %s",TXT_YELLOW,TXT_ACCESS_GRANTED);
if (Game_mode & GM_MULTI)
used=0;
else
used=1;
invalidate_escort_goal();
break;
case POW_QUAD_FIRE:
if (!(Players[Player_num].flags & PLAYER_FLAGS_QUAD_LASERS)) {
Players[Player_num].flags |= PLAYER_FLAGS_QUAD_LASERS;
powerup_basic(15, 15, 7, QUAD_FIRE_SCORE, "%s!",TXT_QUAD_LASERS);
update_laser_weapon_info();
used=1;
} else
HUD_init_message(HM_DEFAULT|HM_REDUNDANT|HM_MAYDUPL, "%s %s!",TXT_ALREADY_HAVE,TXT_QUAD_LASERS);
if (!used && !(Game_mode & GM_MULTI) )
used = pick_up_energy();
break;
case POW_VULCAN_WEAPON:
case POW_GAUSS_WEAPON: {
int ammo = obj->ctype.powerup_info.count;
used = pick_up_primary((obj->id==POW_VULCAN_WEAPON)?VULCAN_INDEX:GAUSS_INDEX);
//didn't get the weapon (because we already have it), but
//maybe snag some of the ammo. if single-player, grab all the ammo
//and remove the powerup. If multi-player take ammo in excess of
//the amount in a powerup, and leave the rest.
if (! used)
if ((Game_mode & GM_MULTI) )
ammo -= VULCAN_AMMO_AMOUNT; //don't let take all ammo
if (ammo > 0) {
int ammo_used;
ammo_used = pick_up_ammo(CLASS_PRIMARY, VULCAN_INDEX, ammo);
obj->ctype.powerup_info.count -= ammo_used;
if (!used && ammo_used) {
powerup_basic(7, 14, 21, VULCAN_AMMO_SCORE, "%s (now ammo=%i/%i)!", TXT_VULCAN_AMMO, PRINTABLE_VULCAN_AMMO(Players[Player_num].primary_ammo[1]), PRINTABLE_VULCAN_AMMO(CURRENT_VULCAN_AMMO_CAPACITY(Player_num)));
special_used = 1;
id = POW_VULCAN_AMMO; //set new id for making sound at end of this function
if (obj->ctype.powerup_info.count == 0)
used = 1; //say used if all ammo taken
}
}
break;
}
case POW_SPREADFIRE_WEAPON:
used = pick_up_primary(SPREADFIRE_INDEX);
if (!used && !(Game_mode & GM_MULTI) )
used = pick_up_energy();
break;
case POW_PLASMA_WEAPON:
used = pick_up_primary(PLASMA_INDEX);
if (!used && !(Game_mode & GM_MULTI) )
used = pick_up_energy();
break;
case POW_FUSION_WEAPON:
used = pick_up_primary(FUSION_INDEX);
if (!used && !(Game_mode & GM_MULTI) )
used = pick_up_energy();
break;
case POW_HELIX_WEAPON:
used = pick_up_primary(HELIX_INDEX);
if (!used && !(Game_mode & GM_MULTI) )
used = pick_up_energy();
break;
case POW_PHOENIX_WEAPON:
used = pick_up_primary(PHOENIX_INDEX);
if (!used && !(Game_mode & GM_MULTI) )
used = pick_up_energy();
break;
case POW_OMEGA_WEAPON:
used = pick_up_primary(OMEGA_INDEX);
if (used)
Omega_charge = obj->ctype.powerup_info.count;
if (!used && !(Game_mode & GM_MULTI) )
used = pick_up_energy();
break;
case POW_PROXIMITY_WEAPON:
used=pick_up_secondary(PROXIMITY_INDEX,4);
break;
case POW_SMARTBOMB_WEAPON:
used=pick_up_secondary(SMART_INDEX,1);
break;
case POW_MEGA_WEAPON:
used=pick_up_secondary(MEGA_INDEX,1);
break;
case POW_SMISSILE1_1:
used=pick_up_secondary(SMISSILE1_INDEX,1);
break;
case POW_SMISSILE1_4:
used=pick_up_secondary(SMISSILE1_INDEX,4);
break;
case POW_GUIDED_MISSILE_1:
used=pick_up_secondary(GUIDED_INDEX,1);
break;
case POW_GUIDED_MISSILE_4:
used=pick_up_secondary(GUIDED_INDEX,4);
break;
case POW_SMART_MINE:
used=pick_up_secondary(SMART_MINE_INDEX,4);
break;
case POW_MERCURY_MISSILE_1:
used=pick_up_secondary(SMISSILE4_INDEX,1);
break;
case POW_MERCURY_MISSILE_4:
used=pick_up_secondary(SMISSILE4_INDEX,4);
break;
case POW_EARTHSHAKER_MISSILE:
used=pick_up_secondary(SMISSILE5_INDEX,1);
break;
case POW_VULCAN_AMMO:
used = pick_up_vulcan_ammo();
break;
case POW_HOMING_AMMO_1:
used=pick_up_secondary(HOMING_INDEX,1);
break;
case POW_HOMING_AMMO_4:
used=pick_up_secondary(HOMING_INDEX,4);
break;
case POW_CLOAK:
if (Players[Player_num].flags & PLAYER_FLAGS_CLOAKED) {
HUD_init_message(HM_DEFAULT|HM_REDUNDANT|HM_MAYDUPL, "%s %s!",TXT_ALREADY_ARE,TXT_CLOAKED);
break;
} else {
Players[Player_num].cloak_time = GameTime64; // Not! changed by awareness events (like player fires laser).
Players[Player_num].flags |= PLAYER_FLAGS_CLOAKED;
ai_do_cloak_stuff();
#ifdef NETWORK
if (Game_mode & GM_MULTI)
multi_send_cloak();
#endif
powerup_basic(-10,-10,-10, CLOAK_SCORE, "%s!",TXT_CLOAKING_DEVICE);
used = 1;
break;
}
case POW_INVULNERABILITY:
if (Players[Player_num].flags & PLAYER_FLAGS_INVULNERABLE) {
HUD_init_message(HM_DEFAULT|HM_REDUNDANT|HM_MAYDUPL, "%s %s!",TXT_ALREADY_ARE,TXT_INVULNERABLE);
break;
} else {
Players[Player_num].invulnerable_time = GameTime64;
Players[Player_num].flags |= PLAYER_FLAGS_INVULNERABLE;
powerup_basic(7, 14, 21, INVULNERABILITY_SCORE, "%s!",TXT_INVULNERABILITY);
used = 1;
break;
}
#ifndef RELEASE
case POW_MEGAWOW:
do_megawow_powerup(50);
used = 1;
break;
#endif
case POW_FULL_MAP:
if (Players[Player_num].flags & PLAYER_FLAGS_MAP_ALL) {
HUD_init_message(HM_DEFAULT|HM_REDUNDANT|HM_MAYDUPL, "%s %s!",TXT_ALREADY_HAVE,"the FULL MAP");
if (!(Game_mode & GM_MULTI) )
used = pick_up_energy();
} else {
Players[Player_num].flags |= PLAYER_FLAGS_MAP_ALL;
powerup_basic(15, 0, 15, 0, "FULL MAP!");
used=1;
}
break;
case POW_CONVERTER:
if (Players[Player_num].flags & PLAYER_FLAGS_CONVERTER) {
HUD_init_message(HM_DEFAULT|HM_REDUNDANT|HM_MAYDUPL, "%s %s!",TXT_ALREADY_HAVE,"the Converter");
if (!(Game_mode & GM_MULTI) )
used = pick_up_energy();
} else {
Players[Player_num].flags |= PLAYER_FLAGS_CONVERTER;
powerup_basic(15, 0, 15, 0, "Energy -> shield converter!");
used=1;
}
break;
case POW_SUPER_LASER:
if (Players[Player_num].laser_level >= MAX_SUPER_LASER_LEVEL) {
Players[Player_num].laser_level = MAX_SUPER_LASER_LEVEL;
HUD_init_message(HM_DEFAULT|HM_REDUNDANT|HM_MAYDUPL, "SUPER LASER MAXED OUT!");
} else {
int old_level=Players[Player_num].laser_level;
if (Players[Player_num].laser_level <= MAX_LASER_LEVEL)
Players[Player_num].laser_level = MAX_LASER_LEVEL;
Players[Player_num].laser_level++;
if (Newdemo_state == ND_STATE_RECORDING)
newdemo_record_laser_level(old_level, Players[Player_num].laser_level);
powerup_basic(10, 0, 10, LASER_SCORE, "Super Boost to Laser level %d",Players[Player_num].laser_level+1);
update_laser_weapon_info();
if (Primary_weapon!=LASER_INDEX)
check_to_use_primary (SUPER_LASER_INDEX);
used=1;
}
if (!used && !(Game_mode & GM_MULTI) )
used = pick_up_energy();
break;
case POW_AMMO_RACK:
if (Players[Player_num].flags & PLAYER_FLAGS_AMMO_RACK) {
HUD_init_message(HM_DEFAULT|HM_REDUNDANT|HM_MAYDUPL, "%s %s!",TXT_ALREADY_HAVE,"the Ammo rack");
if (!(Game_mode & GM_MULTI) )
used = pick_up_energy();
}
else {
Players[Player_num].flags |= PLAYER_FLAGS_AMMO_RACK;
#ifdef NETWORK
multi_send_play_sound(Powerup_info[obj->id].hit_sound, F1_0);
#endif
digi_play_sample( Powerup_info[obj->id].hit_sound, F1_0 );
powerup_basic(15, 0, 15, 0, "AMMO RACK!");
used=1;
}
break;
case POW_AFTERBURNER:
if (Players[Player_num].flags & PLAYER_FLAGS_AFTERBURNER) {
HUD_init_message(HM_DEFAULT|HM_REDUNDANT|HM_MAYDUPL, "%s %s!",TXT_ALREADY_HAVE,"the Afterburner");
if (!(Game_mode & GM_MULTI) )
used = pick_up_energy();
}
else {
Players[Player_num].flags |= PLAYER_FLAGS_AFTERBURNER;
#ifdef NETWORK
multi_send_play_sound(Powerup_info[obj->id].hit_sound, F1_0);
#endif
digi_play_sample( Powerup_info[obj->id].hit_sound, F1_0 );
powerup_basic(15, 15, 15, 0, "AFTERBURNER!");
Afterburner_charge = f1_0;
used=1;
}
break;
case POW_HEADLIGHT:
if (Players[Player_num].flags & PLAYER_FLAGS_HEADLIGHT) {
HUD_init_message(HM_DEFAULT|HM_REDUNDANT|HM_MAYDUPL, "%s %s!",TXT_ALREADY_HAVE,"the Headlight boost");
if (!(Game_mode & GM_MULTI) )
used = pick_up_energy();
}
else {
Players[Player_num].flags |= PLAYER_FLAGS_HEADLIGHT;
#ifdef NETWORK
multi_send_play_sound(Powerup_info[obj->id].hit_sound, F1_0);
#endif
digi_play_sample( Powerup_info[obj->id].hit_sound, F1_0 );
powerup_basic(15, 0, 15, 0, "HEADLIGHT BOOST! (Headlight is %s)",PlayerCfg.HeadlightActiveDefault?"ON":"OFF");
if (PlayerCfg.HeadlightActiveDefault)
Players[Player_num].flags |= PLAYER_FLAGS_HEADLIGHT_ON;
used=1;
#ifdef NETWORK
if (Game_mode & GM_MULTI)
multi_send_flags (Player_num);
#endif
}
break;
#ifdef NETWORK
case POW_FLAG_BLUE:
if (Game_mode & GM_CAPTURE)
if (get_team(Player_num) == TEAM_RED) {
powerup_basic(15, 0, 15, 0, "BLUE FLAG!");
Players[Player_num].flags |= PLAYER_FLAGS_FLAG;
used=1;
multi_send_got_flag (Player_num);
}
break;
case POW_HOARD_ORB:
if (Game_mode & GM_HOARD)
if (Players[Player_num].secondary_ammo[PROXIMITY_INDEX]<12) {
powerup_basic(15, 0, 15, 0, "Orb!!!");
Players[Player_num].secondary_ammo[PROXIMITY_INDEX]++;
Players[Player_num].flags |= PLAYER_FLAGS_FLAG;
used=1;
multi_send_got_orb (Player_num);
}
break;
case POW_FLAG_RED:
if (Game_mode & GM_CAPTURE)
if (get_team(Player_num) == TEAM_BLUE) {
powerup_basic(15, 0, 15, 0, "RED FLAG!");
Players[Player_num].flags |= PLAYER_FLAGS_FLAG;
used=1;
multi_send_got_flag (Player_num);
}
break;
#endif
// case POW_HOARD_ORB:
default:
break;
}
//always say used, until physics problem (getting stuck on unused powerup)
//is solved. Note also the break statements above that are commented out
//!! used=1;
if ((used || special_used) && Powerup_info[id].hit_sound > -1 ) {
#ifdef NETWORK
if (Game_mode & GM_MULTI) // Added by Rob, take this out if it turns out to be not good for net games!
multi_send_play_sound(Powerup_info[id].hit_sound, F1_0);
#endif
digi_play_sample( Powerup_info[id].hit_sound, F1_0 );
detect_escort_goal_accomplished(obj-Objects);
}
return used;
}
int ship_weapon_check_collision(object *ship_objp, object *weapon_objp, float time_limit = 0.0f, int *next_hit = NULL)
{
mc_info mc, mc_shield, mc_hull;
ship *shipp;
ship_info *sip;
weapon *wp;
weapon_info *wip;
Assert( ship_objp != NULL );
Assert( ship_objp->type == OBJ_SHIP );
Assert( ship_objp->instance >= 0 );
shipp = &Ships[ship_objp->instance];
sip = &Ship_info[shipp->ship_info_index];
Assert( weapon_objp != NULL );
Assert( weapon_objp->type == OBJ_WEAPON );
Assert( weapon_objp->instance >= 0 );
wp = &Weapons[weapon_objp->instance];
wip = &Weapon_info[wp->weapon_info_index];
Assert( shipp->objnum == OBJ_INDEX(ship_objp));
// Make ships that are warping in not get collision detection done
if ( shipp->flags & SF_ARRIVING ) return 0;
// if one object is a capital, only check player and player weapons with
// the capital -- too slow for now otherwise.
// if ( Polygon_models[Ships[num].modelnum].use_grid && !( (other_objp == Player_obj) || (&Objects[other_objp->parent] == Player_obj)) )
// return 0;
// If either of these objects doesn't get collision checks, abort.
if (Ship_info[shipp->ship_info_index].flags & SIF_NO_COLLIDE)
return 0;
// Return information for AI to detect incoming fire.
// Could perhaps be done elsewhere at lower cost --MK, 11/7/97
float dist = vm_vec_dist_quick(&ship_objp->pos, &weapon_objp->pos);
if (dist < weapon_objp->phys_info.speed) {
update_danger_weapon(ship_objp, weapon_objp);
}
ship_model_start(ship_objp);
int valid_hit_occurred = 0; // If this is set, then hitpos is set
int quadrant_num = -1;
polymodel *pm = model_get(sip->model_num);
// total time is flFrametime + time_limit (time_limit used to predict collisions into the future)
vec3d weapon_end_pos;
vm_vec_scale_add( &weapon_end_pos, &weapon_objp->pos, &weapon_objp->phys_info.vel, time_limit );
// Goober5000 - I tried to make collision code here much saner... here begin the (major) changes
// set up collision structs
mc.model_num = sip->model_num;
mc.submodel_num = -1;
mc.orient = &ship_objp->orient;
mc.pos = &ship_objp->pos;
mc.p0 = &weapon_objp->last_pos;
mc.p1 = &weapon_end_pos;
memcpy(&mc_shield, &mc, sizeof(mc_info));
memcpy(&mc_hull, &mc, sizeof(mc_info));
// (btw, these are leftover comments from below...)
//
// Note: This code is obviously stupid. We want to add the shield point if there is shield to hit, but:
// 1. We want the size/color of the hit effect to indicate shield damage done. (i.e., for already-weak shield, smaller effect)
// 2. Currently (8/9/97), apply_damage_to_shield() passes lefer damage to hull, which might not make sense. If
// wouldn't have collided with hull, shouldn't do damage. Once this is fixed, the code below needs to cast the
// vector through to the hull if there is leftover damage.
//
// WIF2_PIERCE_SHIELDS pierces shields
// AL 1-14-97: "Puncture" doesn't mean penetrate shield anymore, it means that it punctures
// hull to inflict maximum subsystem damage
//
// _argv[-1], 16 Jan 2005: Surface shields.
// Surface shields allow for shields on a ship without a shield mesh. Good for putting real shields
// on the Lucifer. This also fixes the strange bug where shots will occasionally go through the
// shield mesh when they shouldn't. I don't know what causes this, but this fixes that -- shields
// will absorb it when it hits the hull instead. This has no fancy graphical effect, though.
// Someone should make one.
// set flags
mc_shield.flags = MC_CHECK_SHIELD;
mc_hull.flags = MC_CHECK_MODEL;
// check both kinds of collisions
int shield_collision = (pm->shield.ntris > 0) ? model_collide(&mc_shield) : 0;
int hull_collision = model_collide(&mc_hull);
// check shields for impact
if (!(ship_objp->flags & OF_NO_SHIELDS))
{
// pick out the shield quadrant
if (shield_collision)
quadrant_num = get_quadrant(&mc_shield.hit_point);
else if (hull_collision && (sip->flags2 & SIF2_SURFACE_SHIELDS))
quadrant_num = get_quadrant(&mc_hull.hit_point);
// make sure that the shield is active in that quadrant
if ((quadrant_num >= 0) && ((shipp->flags & SF_DYING) || !ship_is_shield_up(ship_objp, quadrant_num)))
quadrant_num = -1;
// see if we hit the shield
if (quadrant_num >= 0)
{
// do the hit effect
if (shield_collision)
add_shield_point(OBJ_INDEX(ship_objp), mc_shield.shield_hit_tri, &mc_shield.hit_point);
else
/* TODO */;
// if this weapon pierces the shield, then do the hit effect, but act like a shield collision never occurred;
// otherwise, we have a valid hit on this shield
if (wip->wi_flags2 & WIF2_PIERCE_SHIELDS)
quadrant_num = -1;
else
valid_hit_occurred = 1;
}
}
// see which impact we use
if (shield_collision && valid_hit_occurred)
{
memcpy(&mc, &mc_shield, sizeof(mc_info));
Assert(quadrant_num >= 0);
}
else if (hull_collision)
{
memcpy(&mc, &mc_hull, sizeof(mc_info));
valid_hit_occurred = 1;
}
//nprintf(("AI", "Frame %i, Hit tri = %i\n", Framecount, mc.shield_hit_tri));
ship_model_stop(ship_objp);
// deal with predictive collisions. Find their actual hit time and see if they occured in current frame
if (next_hit && valid_hit_occurred) {
// find hit time
*next_hit = (int) (1000.0f * (mc.hit_dist*(flFrametime + time_limit) - flFrametime) );
if (*next_hit > 0)
// if hit occurs outside of this frame, do not do damage
return 1;
}
if ( valid_hit_occurred )
{
Script_system.SetHookObjects(4, "Ship", ship_objp, "Weapon", weapon_objp, "Self",ship_objp, "Object", weapon_objp);
bool ship_override = Script_system.IsConditionOverride(CHA_COLLIDEWEAPON, ship_objp);
Script_system.SetHookObjects(2, "Self",weapon_objp, "Object", ship_objp);
bool weapon_override = Script_system.IsConditionOverride(CHA_COLLIDESHIP, weapon_objp);
if(!ship_override && !weapon_override) {
ship_weapon_do_hit_stuff(ship_objp, weapon_objp, &mc.hit_point_world, &mc.hit_point, quadrant_num, mc.hit_submodel, mc.hit_normal);
}
Script_system.SetHookObjects(2, "Self",ship_objp, "Object", weapon_objp);
if(!(weapon_override && !ship_override))
Script_system.RunCondition(CHA_COLLIDEWEAPON, '\0', NULL, ship_objp);
Script_system.SetHookObjects(2, "Self",weapon_objp, "Object", ship_objp);
if((weapon_override && !ship_override) || (!weapon_override && !ship_override))
Script_system.RunCondition(CHA_COLLIDESHIP, '\0', NULL, weapon_objp);
Script_system.RemHookVars(4, "Ship", "Weapon", "Self","Object");
/*
if(!Script_system.IsOverride(wip->sc_collide_ship)) {
ship_weapon_do_hit_stuff(ship_objp, weapon_objp, &mc.hit_point_world, &mc.hit_point, quadrant_num, mc.hit_submodel, mc.hit_normal);
}
if(wip->sc_collide_ship.IsValid()) {
ade_odata lua_self_obj = l_Weapon.Set(object_h(weapon_objp));
ade_odata lua_ship_obj = l_Ship.Set(object_h(ship_objp));
Script_system.SetHookVar("Self", 'o', &lua_self_obj);
Script_system.SetHookVar("Ship", 'o', &lua_ship_obj);
Script_system.RunBytecode(wip->sc_collide_ship);
Script_system.RemHookVar("Self");
Script_system.RemHookVar("Ship");
}*/
}
else if ((Missiontime - wp->creation_time > F1_0/2) && (wip->wi_flags & WIF_HOMING) && (wp->homing_object == ship_objp)) {
if (dist < wip->shockwave.inner_rad) {
vec3d vec_to_ship;
vm_vec_normalized_dir(&vec_to_ship, &ship_objp->pos, &weapon_objp->pos);
if (vm_vec_dot(&vec_to_ship, &weapon_objp->orient.vec.fvec) < 0.0f) {
// check if we're colliding against "invisible" ship
if (!(shipp->flags2 & SF2_DONT_COLLIDE_INVIS)) {
wp->lifeleft = 0.001f;
if (ship_objp == Player_obj)
nprintf(("Jim", "Frame %i: Weapon %i set to detonate, dist = %7.3f.\n", Framecount, OBJ_INDEX(weapon_objp), dist));
valid_hit_occurred = 1;
}
}
}
}
return valid_hit_occurred;
}
do_flythrough(object *obj,int first_time) //set true if init
{
segment *pseg;
int old_player_seg = obj->segnum;
if (first_time) {
//vms_vector zero_vector = {0,0,0};
obj->control_type = CT_FLYTHROUGH;
//obj->fly_info.angle_step.p = 0;
//obj->fly_info.angle_step.b = 0;
//obj->fly_info.angle_step.h = 0;
//obj->fly_info.heading = zero_vector;
}
//move the player for this frame
if (!first_time) {
//vms_vector tempv;
//fix rot_step;
vm_vec_scale_add2(&obj->pos,&player_step,FrameTime);
angvec_add2_scale(&player_angles,&player_angstep,FrameTime);
vm_angles_2_matrix(&obj->orient,&player_angles);
}
//check new player seg
update_object_seg(obj);
pseg = &Segments[obj->segnum];
if (first_time || obj->segnum != old_player_seg) { //moved into new seg
vms_vector curcenter,nextcenter;
fix step_size,seg_time;
short entry_side,exit_side; //what sides we entry and leave through
vms_vector dest_point; //where we are heading (center of exit_side)
vms_angvec dest_angles; //where we want to be pointing
//find new exit side
if (!first_time) {
entry_side = matt_find_connect_side(obj->segnum,old_player_seg);
exit_side = Side_opposite[entry_side];
}
if (first_time) ft_preference = FP_FORWARD;
if (first_time || entry_side==-1 || pseg->children[exit_side]==-1 || ft_preference!=FP_FORWARD) {
int i;
vms_vector prefvec,segcenter,sidevec;
fix best_val=-f2_0;
int best_side;
//find exit side
if (ft_preference == FP_FORWARD) {
if (first_time) prefvec = obj->orient.fvec;
else prefvec = headvec;
vm_vec_normalize(&prefvec);
}
else
prefvec = obj->orient.vecs[ft_preference%3];
if (ft_preference >= 3) {prefvec.x = -prefvec.x; prefvec.y = -prefvec.y; prefvec.z = -prefvec.z;}
compute_segment_center(&segcenter,pseg);
best_side=-1;
for (i=MAX_SIDES_PER_SEGMENT;--i >= 0;) {
fix d;
if (pseg->children[i]!=-1) {
compute_center_point_on_side(&sidevec,pseg,i);
//vm_vec_sub2(&sidevec,&segcenter);
//vm_vec_normalize(&sidevec);
vm_vec_normalized_dir(&sidevec,&sidevec,&segcenter);
d = vm_vec_dotprod(&sidevec,&prefvec);
if (labs(d) < MIN_D) d=0;
if (d > best_val || (d==best_val && i==exit_side)) {best_val=d; best_side=i;}
}
}
if (best_val > 0) ft_preference = FP_FORWARD;
Assert(best_side!=-1);
exit_side = best_side;
}
//update target point & angles
compute_center_point_on_side(&dest_point,pseg,exit_side);
//update target point and movement points
vm_vec_sub(&player_step,&dest_point,&obj->pos);
step_size = vm_vec_normalize(&player_step);
vm_vec_scale(&player_step,player_speed);
compute_segment_center(&curcenter,pseg);
compute_segment_center(&nextcenter,&Segments[pseg->children[exit_side]]);
vm_vec_sub(&headvec,&nextcenter,&curcenter);
//angles_from_vector(&dest_angles,&headvec); //extract angles
vm_extract_angles_vector(&dest_angles,&headvec); //extract angles
if (first_time)
//angles_from_vector(&player_angles,&obj->orient.fvec);
vm_extract_angles_vector(&player_angles,&obj->orient.fvec);
seg_time = fixdiv(step_size,player_speed); //how long through seg
if (seg_time) {
player_angstep.p = fixdiv(delta_ang(player_angles.p,dest_angles.p),seg_time);
player_angstep.b = fixdiv(delta_ang(player_angles.b,dest_angles.b),seg_time);
player_angstep.h = fixdiv(delta_ang(player_angles.h,dest_angles.h),seg_time);
}
else {
player_angles = dest_angles;
player_angstep.p = player_angstep.b = player_angstep.h = 0;
}
}
}
