// -----------------------------------------------------------------------------
// Look at control center guns, find best one to fire at *objp.
// Return best gun number (one whose direction dotted with vector to player is largest).
// If best gun has negative dot, return -1, meaning no gun is good.
int calc_best_gun(int num_guns, vms_vector *gun_pos, vms_vector *gun_dir, vms_vector *objpos)
{
int i;
fix best_dot;
int best_gun;
best_dot = -F1_0*2;
best_gun = -1;
for (i=0; i<num_guns; i++) {
fix dot;
vms_vector gun_vec;
vm_vec_sub(&gun_vec, objpos, &gun_pos[i]);
vm_vec_normalize_quick(&gun_vec);
dot = vm_vec_dot(&gun_dir[i], &gun_vec);
if (dot > best_dot) {
best_dot = dot;
best_gun = i;
}
}
Assert(best_gun != -1); // Contact Mike. This is impossible. Or maybe you're getting an unnormalized vector somewhere.
if (best_dot < 0)
return -1;
else
return best_gun;
}
object *object_create_debris(object *parent, int subobj_num)
{
int objnum;
object *obj;
polymodel *po;
Assert((parent->type == OBJ_ROBOT) || (parent->type == OBJ_PLAYER) );
objnum = obj_create(OBJ_DEBRIS,0,parent->segnum,&parent->pos,
&parent->orient,Polygon_models[parent->rtype.pobj_info.model_num].submodel_rads[subobj_num],
CT_DEBRIS,MT_PHYSICS,RT_POLYOBJ);
if ((objnum < 0 ) && (Highest_object_index >= MAX_OBJECTS-1)) {
mprintf((1, "Can't create object in object_create_debris.\n"));
Int3();
return NULL;
}
if ( objnum < 0 )
return NULL; // Not enough debris slots!
obj = &Objects[objnum];
Assert(subobj_num < 32);
//Set polygon-object-specific data
obj->rtype.pobj_info.model_num = parent->rtype.pobj_info.model_num;
obj->rtype.pobj_info.subobj_flags = 1<<subobj_num;
obj->rtype.pobj_info.tmap_override = parent->rtype.pobj_info.tmap_override;
//Set physics data for this object
po = &Polygon_models[obj->rtype.pobj_info.model_num];
obj->mtype.phys_info.velocity.x = RAND_MAX/2 - rand();
obj->mtype.phys_info.velocity.y = RAND_MAX/2 - rand();
obj->mtype.phys_info.velocity.z = RAND_MAX/2 - rand();
vm_vec_normalize_quick(&obj->mtype.phys_info.velocity);
vm_vec_scale(&obj->mtype.phys_info.velocity,i2f(10 + (30 * rand() / RAND_MAX)));
vm_vec_add2(&obj->mtype.phys_info.velocity,&parent->mtype.phys_info.velocity);
vm_vec_make(&obj->mtype.phys_info.rotvel,10*0x2000/3,10*0x4000/3,10*0x7000/3);
vm_vec_zero(&obj->mtype.phys_info.rotthrust);
obj->lifeleft = DEBRIS_LIFE;
obj->mtype.phys_info.mass = fixmuldiv(parent->mtype.phys_info.mass,obj->size,parent->size);
obj->mtype.phys_info.drag = 0; //fl2f(0.2); //parent->mtype.phys_info.drag;
return obj;
}
// -----------------------------------------------------------------------------
//do whatever this thing does in a frame
void do_controlcen_frame(object *obj)
{
int best_gun_num;
// If a boss level, then Control_center_present will be 0.
if (!Control_center_present)
return;
#ifndef NDEBUG
if (!Robot_firing_enabled || (Game_suspended & SUSP_ROBOTS))
return;
#else
if (!Robot_firing_enabled)
return;
#endif
if (!(Control_center_been_hit || Control_center_player_been_seen)) {
if (!(FrameCount % 8)) { // Do every so often...
vms_vector vec_to_player;
fix dist_to_player;
int i;
segment *segp = &Segments[obj->segnum];
// This is a hack. Since the control center is not processed by
// ai_do_frame, it doesn't know to deal with cloaked dudes. It
// seems to work in single-player mode because it is actually using
// the value of Believed_player_position that was set by the last
// person to go through ai_do_frame. But since a no-robots game
// never goes through ai_do_frame, I'm making it so the control
// center can spot cloaked dudes.
if (Game_mode & GM_MULTI)
Believed_player_pos = Objects[Players[Player_num].objnum].pos;
// Hack for special control centers which are isolated and not reachable because the
// real control center is inside the boss.
for (i=0; i<MAX_SIDES_PER_SEGMENT; i++)
if (segp->children[i] != -1)
break;
if (i == MAX_SIDES_PER_SEGMENT)
return;
vm_vec_sub(&vec_to_player, &ConsoleObject->pos, &obj->pos);
dist_to_player = vm_vec_normalize_quick(&vec_to_player);
if (dist_to_player < F1_0*200) {
Control_center_player_been_seen = player_is_visible_from_object(obj, &obj->pos, 0, &vec_to_player, 0);
Control_center_next_fire_time = 0;
}
}
return;
}
if ((Control_center_next_fire_time < 0) && !(Player_is_dead && (GameTime > Player_time_of_death+F1_0*2))) {
if (Players[Player_num].flags & PLAYER_FLAGS_CLOAKED)
best_gun_num = calc_best_gun(N_controlcen_guns, Gun_pos, Gun_dir, &Believed_player_pos);
else
best_gun_num = calc_best_gun(N_controlcen_guns, Gun_pos, Gun_dir, &ConsoleObject->pos);
if (best_gun_num != -1) {
vms_vector vec_to_goal;
fix dist_to_player;
fix delta_fire_time;
if (Players[Player_num].flags & PLAYER_FLAGS_CLOAKED) {
vm_vec_sub(&vec_to_goal, &Believed_player_pos, &Gun_pos[best_gun_num]);
dist_to_player = vm_vec_normalize_quick(&vec_to_goal);
} else {
vm_vec_sub(&vec_to_goal, &ConsoleObject->pos, &Gun_pos[best_gun_num]);
dist_to_player = vm_vec_normalize_quick(&vec_to_goal);
}
if (dist_to_player > F1_0*300)
{
Control_center_been_hit = 0;
Control_center_player_been_seen = 0;
return;
}
#ifdef NETWORK
if (Game_mode & GM_MULTI)
multi_send_controlcen_fire(&vec_to_goal, best_gun_num, obj-Objects);
#endif
Laser_create_new_easy( &vec_to_goal, &Gun_pos[best_gun_num], obj-Objects, CONTROLCEN_WEAPON_NUM, 1);
// 1/4 of time, fire another thing, not directly at player, so it might hit him if he's constantly moving.
if (rand() < 32767/4) {
vms_vector randvec;
make_random_vector(&randvec);
vm_vec_scale_add2(&vec_to_goal, &randvec, F1_0/4);
vm_vec_normalize_quick(&vec_to_goal);
#ifdef NETWORK
if (Game_mode & GM_MULTI)
multi_send_controlcen_fire(&vec_to_goal, best_gun_num, obj-Objects);
#endif
Laser_create_new_easy( &vec_to_goal, &Gun_pos[best_gun_num], obj-Objects, CONTROLCEN_WEAPON_NUM, 1);
}
delta_fire_time = (NDL - Difficulty_level) * F1_0/4;
if (Game_mode & GM_MULTI) // slow down rate of fire in multi player
delta_fire_time *= 2;
Control_center_next_fire_time = delta_fire_time;
}
} else
Control_center_next_fire_time -= FrameTime;
}
do_endlevel_flythrough(int n)
{
object *obj;
segment *pseg;
int old_player_seg;
flydata = &fly_objects[n];
obj = flydata->obj;
old_player_seg = obj->segnum;
//move the player for this frame
if (!flydata->first_time) {
vm_vec_scale_add2(&obj->pos,&flydata->step,FrameTime);
angvec_add2_scale(&flydata->angles,&flydata->angstep,FrameTime);
vm_angles_2_matrix(&obj->orient,&flydata->angles);
}
//check new player seg
update_object_seg(obj);
pseg = &Segments[obj->segnum];
if (flydata->first_time || obj->segnum != old_player_seg) { //moved into new seg
vms_vector curcenter,nextcenter;
fix step_size,seg_time;
short entry_side,exit_side; //what sides we entry and leave through
vms_vector dest_point; //where we are heading (center of exit_side)
vms_angvec dest_angles; //where we want to be pointing
vms_matrix dest_orient;
int up_side;
//find new exit side
if (!flydata->first_time) {
entry_side = matt_find_connect_side(obj->segnum,old_player_seg);
exit_side = Side_opposite[entry_side];
}
if (flydata->first_time || entry_side==-1 || pseg->children[exit_side]==-1)
exit_side = find_exit_side(obj);
{ //find closest side to align to
fix d,largest_d=-f1_0;
int i;
for (i=0;i<6;i++) {
#ifdef COMPACT_SEGS
vms_vector v1;
get_side_normal(pseg, i, 0, &v1 );
d = vm_vec_dot(&v1,&flydata->obj->orient.uvec);
#else
d = vm_vec_dot(&pseg->sides[i].normals[0],&flydata->obj->orient.uvec);
#endif
if (d > largest_d) {largest_d = d; up_side=i;}
}
}
//update target point & angles
compute_center_point_on_side(&dest_point,pseg,exit_side);
//update target point and movement points
//offset object sideways
if (flydata->offset_frac) {
int s0=-1,s1,i;
vms_vector s0p,s1p;
fix dist;
for (i=0;i<6;i++)
if (i!=entry_side && i!=exit_side && i!=up_side && i!=Side_opposite[up_side])
if (s0==-1)
s0 = i;
else
s1 = i;
compute_center_point_on_side(&s0p,pseg,s0);
compute_center_point_on_side(&s1p,pseg,s1);
dist = fixmul(vm_vec_dist(&s0p,&s1p),flydata->offset_frac);
if (dist-flydata->offset_dist > MAX_SLIDE_PER_SEGMENT)
dist = flydata->offset_dist + MAX_SLIDE_PER_SEGMENT;
flydata->offset_dist = dist;
vm_vec_scale_add2(&dest_point,&obj->orient.rvec,dist);
}
vm_vec_sub(&flydata->step,&dest_point,&obj->pos);
step_size = vm_vec_normalize_quick(&flydata->step);
vm_vec_scale(&flydata->step,flydata->speed);
compute_segment_center(&curcenter,pseg);
compute_segment_center(&nextcenter,&Segments[pseg->children[exit_side]]);
vm_vec_sub(&flydata->headvec,&nextcenter,&curcenter);
#ifdef COMPACT_SEGS
{
vms_vector _v1;
get_side_normal(pseg, up_side, 0, &_v1 );
vm_vector_2_matrix(&dest_orient,&flydata->headvec,&_v1,NULL);
}
#else
vm_vector_2_matrix(&dest_orient,&flydata->headvec,&pseg->sides[up_side].normals[0],NULL);
#endif
vm_extract_angles_matrix(&dest_angles,&dest_orient);
if (flydata->first_time)
vm_extract_angles_matrix(&flydata->angles,&obj->orient);
seg_time = fixdiv(step_size,flydata->speed); //how long through seg
if (seg_time) {
flydata->angstep.x = max(-MAX_ANGSTEP,min(MAX_ANGSTEP,fixdiv(delta_ang(flydata->angles.p,dest_angles.p),seg_time)));
flydata->angstep.z = max(-MAX_ANGSTEP,min(MAX_ANGSTEP,fixdiv(delta_ang(flydata->angles.b,dest_angles.b),seg_time)));
flydata->angstep.y = max(-MAX_ANGSTEP,min(MAX_ANGSTEP,fixdiv(delta_ang(flydata->angles.h,dest_angles.h),seg_time)));
}
else {
flydata->angles = dest_angles;
flydata->angstep.x = flydata->angstep.y = flydata->angstep.z = 0;
}
}
flydata->first_time=0;
}
object *object_create_explosion_sub(object *objp, short segnum, vms_vector * position, fix size, int vclip_type, fix maxdamage, fix maxdistance, fix maxforce, int parent )
{
int objnum;
object *obj;
objnum = obj_create( OBJ_FIREBALL,vclip_type,segnum,position,&vmd_identity_matrix,size,
CT_EXPLOSION,MT_NONE,RT_FIREBALL);
if (objnum < 0 ) {
mprintf((1, "Can't create object in object_create_explosion_sub.\n"));
return NULL;
}
obj = &Objects[objnum];
//mprintf( 0, "Fireball created at %d, %d, %d\n", obj->pos.x, obj->pos.y, obj->pos.z );
//now set explosion-specific data
obj->lifeleft = Vclip[vclip_type ].play_time;
obj->ctype.expl_info.spawn_time = -1;
obj->ctype.expl_info.delete_objnum = -1;
obj->ctype.expl_info.delete_time = -1;
if (maxdamage > 0) {
fix dist, force;
vms_vector pos_hit, vforce;
fix damage;
int i;
object * obj0p = &Objects[0];
// -- now legal for badass explosions on a wall. Assert(objp != NULL);
for (i=0; i<=Highest_object_index; i++ ) {
// Weapons used to be affected by badass explosions, but this introduces serious problems.
// When a smart bomb blows up, if one of its children goes right towards a nearby wall, it will
// blow up, blowing up all the children. So I remove it. MK, 09/11/94
if ( (obj0p->type == OBJ_CNTRLCEN) || (obj0p->type==OBJ_PLAYER) || ((obj0p->type==OBJ_ROBOT) && ((Objects[parent].type != OBJ_ROBOT) || (Objects[parent].id != obj0p->id)))) {
dist = vm_vec_dist_quick( &obj0p->pos, &obj->pos );
// Make damage be from 'maxdamage' to 0.0, where 0.0 is 'maxdistance' away;
if ( dist < maxdistance ) {
if (object_to_object_visibility(obj, obj0p, FQ_TRANSWALL)) {
damage = maxdamage - fixmuldiv( dist, maxdamage, maxdistance );
force = maxforce - fixmuldiv( dist, maxforce, maxdistance );
// Find the force vector on the object
vm_vec_sub( &vforce, &obj0p->pos, &obj->pos );
vm_vec_normalize_quick(&vforce);
vm_vec_scale(&vforce, force );
// Find where the point of impact is... ( pos_hit )
vm_vec_scale(vm_vec_sub(&pos_hit, &obj->pos, &obj0p->pos), fixdiv(obj0p->size, obj0p->size + dist));
switch ( obj0p->type ) {
case OBJ_ROBOT:
phys_apply_force(obj0p,&vforce);
// When a robot gets whacked by a badass force, he looks towards it because robots tend to get blasted from behind.
{
vms_vector neg_vforce;
neg_vforce.x = vforce.x * -2 * (7 - Difficulty_level)/8;
neg_vforce.y = vforce.y * -2 * (7 - Difficulty_level)/8;
neg_vforce.z = vforce.z * -2 * (7 - Difficulty_level)/8;
phys_apply_rot(obj0p,&neg_vforce);
}
if ( obj0p->shields >= 0 ) {
if (apply_damage_to_robot(obj0p, damage, parent))
if ((objp != NULL) && (parent == Players[Player_num].objnum))
add_points_to_score(Robot_info[obj0p->id].score_value);
}
break;
case OBJ_CNTRLCEN:
if ( obj0p->shields >= 0 ) {
apply_damage_to_controlcen(obj0p, damage, parent );
}
break;
case OBJ_PLAYER: {
object * killer=NULL;
vms_vector vforce2;
if ((objp != NULL) && (Game_mode & GM_MULTI) && (objp->type == OBJ_PLAYER)) {
// mprintf((0, "Damaged by player %d's explosion.\n", objp->id));
killer = objp;
}
vforce2 = vforce;
if (parent > -1 ) {
killer = &Objects[parent];
if (killer != ConsoleObject) // if someone else whacks you, cut force by 2x
vforce2.x /= 2; vforce2.y /= 2; vforce2.z /= 2;
}
vforce2.x /= 2; vforce2.y /= 2; vforce2.z /= 2;
phys_apply_force(obj0p,&vforce);
phys_apply_rot(obj0p,&vforce2);
if ( obj0p->shields >= 0 )
apply_damage_to_player(obj0p, killer, damage );
}
break;
default:
Int3(); // Illegal object type
} // end switch
} else {
; // mprintf((0, "No badass: robot=%2i, dist=%7.3f, maxdistance=%7.3f .\n", i, f2fl(dist), f2fl(maxdistance)));
} // end if (object_to_object_visibility...
} // end if (dist < maxdistance)
}
obj0p++;
} // end for
} // end if (maxdamage...
// mprintf(0, "\n");
return obj;
}
void particle_render_all()
{
ubyte flags;
float pct_complete;
float alpha;
vertex pos;
vec3d ts, te, temp;
int rotate = 1;
int framenum, cur_frame;
bool render_batch = false;
int tmap_flags = TMAP_FLAG_TEXTURED | TMAP_HTL_3D_UNLIT | TMAP_FLAG_SOFT_QUAD;
if ( !Particles_enabled )
return;
MONITOR_INC( NumParticlesRend, Num_particles );
if ( Particles.empty() )
return;
for (SCP_vector<particle*>::iterator p = Particles.begin(); p != Particles.end(); ++p) {
particle* part = *p;
// skip back-facing particles (ripped from fullneb code)
// Wanderer - add support for attached particles
vec3d p_pos;
if (part->attached_objnum >= 0) {
vm_vec_unrotate(&p_pos, &part->pos, &Objects[part->attached_objnum].orient);
vm_vec_add2(&p_pos, &Objects[part->attached_objnum].pos);
} else {
p_pos = part->pos;
}
if ( vm_vec_dot_to_point(&Eye_matrix.vec.fvec, &Eye_position, &p_pos) <= 0.0f ) {
continue;
}
// calculate the alpha to draw at
alpha = get_current_alpha(&p_pos);
// if it's transparent then just skip it
if (alpha <= 0.0f) {
continue;
}
// make sure "rotate" is enabled for this particle
rotate = 1;
// if this is a tracer style particle, calculate tracer vectors
if (part->tracer_length > 0.0f) {
ts = p_pos;
temp = part->velocity;
vm_vec_normalize_quick(&temp);
vm_vec_scale_add(&te, &ts, &temp, part->tracer_length);
// don't bother rotating
rotate = 0;
}
// rotate the vertex
if (rotate) {
flags = g3_rotate_vertex( &pos, &p_pos );
if ( flags ) {
continue;
}
if (!Cmdline_nohtl)
g3_transfer_vertex(&pos, &p_pos);
}
// pct complete for the particle
pct_complete = part->age / part->max_life;
// figure out which frame we should be using
if (part->nframes > 1) {
framenum = fl2i(pct_complete * part->nframes + 0.5);
CLAMP(framenum, 0, part->nframes-1);
cur_frame = part->reverse ? (part->nframes - framenum - 1) : framenum;
} else {
cur_frame = 0;
}
if (part->type == PARTICLE_DEBUG) {
gr_set_color( 255, 0, 0 );
g3_draw_sphere_ez( &p_pos, part->radius );
} else {
framenum = part->optional_data;
Assert( cur_frame < part->nframes );
// if this is a tracer style particle
if (part->tracer_length > 0.0f) {
batch_add_laser( framenum + cur_frame, &ts, part->radius, &te, part->radius );
}
// draw as a regular bitmap
else {
batch_add_bitmap( framenum + cur_frame, tmap_flags, &pos, part->particle_index % 8, part->radius, alpha );
}
render_batch = true;
}
}
profile_begin("Batch Render");
if (render_batch) {
batch_render_all(Particle_buffer_object);
}
profile_end("Batch Render");
}
