change bank to target vel from target position (#4417)

Author: Baezon

code/ai/aicode.cpp

@@ -1195,7 +1195,7 @@ void ai_turn_towards_vector(vec3d* dest, object* objp, vec3d* slide_vec, vec3d*
 	vec3d	vel_in, vel_out, desired_fvec, src;
 	float		delta_time;
 	physics_info	*pip;
-	float		delta_bank;
+	float		bank;
 
 	Assertion(objp->type == OBJ_SHIP || objp->type == OBJ_WEAPON, "ai_turn_towards_vector called on a non-ship non-weapon object!");
 
@@ -1289,17 +1289,18 @@ void ai_turn_towards_vector(vec3d* dest, object* objp, vec3d* slide_vec, vec3d*
 	//	Should be more general case here.  Currently, anything that is not a weapon will bank when it turns.
 	// Goober5000 - don't bank if sexp or ship says not to
 	if ( (objp->type == OBJ_WEAPON) || (flags & AITTV_IGNORE_BANK ) )
-		delta_bank = 0.0f;
+		bank = 0.0f;
 	else if (objp->type == OBJ_SHIP && Ship_info[Ships[objp->instance].ship_info_index].flags[Ship::Info_Flags::Dont_bank_when_turning])
-		delta_bank = 0.0f;
+		bank = 0.0f;
 	else if ((bank_override) && (iff_x_attacks_y(Ships[objp->instance].team, Player_ship->team))) {	//	Theoretically, this will only happen for Shivans.
-		delta_bank = bank_override;
+		bank = bank_override;
 	} else {
-		delta_bank = vm_vec_dot(&curr_orient.vec.rvec, &objp->last_orient.vec.rvec);
-		delta_bank = 200.0f * (1.0f - delta_bank) * pip->delta_bank_const;
+		bank = vm_vec_dot(&curr_orient.vec.rvec, &objp->last_orient.vec.rvec);
+		bank = 200.0f * (1.0f - bank) * pip->delta_bank_const;
 		if (vm_vec_dot(&objp->last_orient.vec.fvec, &objp->orient.vec.rvec) < 0.0f)
-			delta_bank = -delta_bank;
+			bank = -bank;
 	}
+	bank *= vel_limit.xyz.z;
 
 
 	matrix out_orient;
@@ -1311,7 +1312,7 @@ void ai_turn_towards_vector(vec3d* dest, object* objp, vec3d* slide_vec, vec3d*
 		vm_angular_move_matrix(&goal_orient, &curr_orient, &vel_in, delta_time,
 			&out_orient, &vel_out, &vel_limit, &acc_limit, The_mission.ai_profile->flags[AI::Profile_Flags::No_turning_directional_bias]);
 	} else {
-		vm_angular_move_forward_vec(&desired_fvec, &curr_orient, &vel_in, delta_time, delta_bank,
+		vm_angular_move_forward_vec(&desired_fvec, &curr_orient, &vel_in, delta_time, bank,
 			&out_orient, &vel_out, &vel_limit, &acc_limit, The_mission.ai_profile->flags[AI::Profile_Flags::No_turning_directional_bias]);
 	}
 
@@ -4871,12 +4872,12 @@ void avoid_ship()
 	//	If in front of enemy, turn away from it.
 	//	If behind enemy, try to get fully behind it.
 	if (away_dot < 0.0f) {
-		turn_away_from_point(Pl_objp, &enemy_pos, Pl_objp->phys_info.speed);
+		turn_away_from_point(Pl_objp, &enemy_pos, 1.0f);
 	} else {
 		vec3d	goal_pos;
 
 		vm_vec_scale_add(&goal_pos, &En_objp->pos, &En_objp->orient.vec.fvec, -100.0f);
-		turn_towards_point(Pl_objp, &goal_pos, NULL, Pl_objp->phys_info.speed);
+		turn_towards_point(Pl_objp, &goal_pos, NULL, 1.0f);
 	}
 
 	//	Set speed.
@@ -5313,9 +5314,9 @@ void evade_ship()
 			//	caused flying in an odd spiral.
 			vm_vec_scale_add(&goal_point, &enemy_pos, &Pl_objp->orient.vec.rvec, 1000.0f);
 			if (dist < 100.0f)
-				bank_override = Pl_objp->phys_info.speed; 
+				bank_override = 1.0f; 
 		} else {
-			bank_override = Pl_objp->phys_info.speed;			//	In enemy's sights, not pointing at him, twirl away.
+			bank_override = 1.0f;			//	In enemy's sights, not pointing at him, twirl away.
 			goto evade_ship_l1;
 		}
 	} else {
@@ -7662,7 +7663,7 @@ void ai_chase_attack(ai_info *aip, ship_info *sip, vec3d *predicted_enemy_pos, f
 
 	//SUSHI: Don't change bank while circle strafing or glide attacking
 	if (dist_to_enemy < 250.0f && dot_from_enemy > 0.7f && aip->submode != AIS_CHASE_CIRCLESTRAFE && aip->submode != AIS_CHASE_GLIDEATTACK) {
-		bank_override = Pl_objp->phys_info.speed;
+		bank_override = 1.0f;
 	}
 
 	//	If enemy more than 500 meters away, all ships flying there will tend to match bank.
@@ -7709,9 +7710,7 @@ void ai_chase_es(ai_info *aip)
 		tvec.xyz.y += frand();
 	}
 
-	float bank_override = Pl_objp->phys_info.speed;
-
-	ai_turn_towards_vector(&tvec, Pl_objp, nullptr, nullptr, bank_override, 0);
+	ai_turn_towards_vector(&tvec, Pl_objp, nullptr, nullptr, 1.0f, 0);
 	accelerate_ship(aip, 1.0f);
 }
 
@@ -7722,7 +7721,6 @@ void ai_chase_ga(ai_info *aip, ship_info *sip)
 {
 	//	If not near end of this submode, evade squiggly.  If near end, just fly straight for a bit
 	vec3d	tvec;
-	float		bank_override;
 	vec3d	vec_from_enemy;
 
 	if (En_objp != NULL) {
@@ -7735,9 +7733,7 @@ void ai_chase_ga(ai_info *aip, ship_info *sip)
 	vm_vec_scale_add2(&tvec, &vec_from_enemy, 300.0f);
 	vm_vec_add2(&tvec, &Pl_objp->pos);
 
-	bank_override = Pl_objp->phys_info.speed;
-
-	ai_turn_towards_vector(&tvec, Pl_objp, nullptr, nullptr, bank_override, 0);
+	ai_turn_towards_vector(&tvec, Pl_objp, nullptr, nullptr, 1.0f, 0);
 
 	accelerate_ship(aip, 2.0f);
 

code/math/vecmat.cpp

@@ -1901,7 +1901,7 @@ float time_to_arrival(float goal, float vel, float vel_limit, float acc_limit) {
 // and also scales their speed to make a nice straight line
 // note that this is now treated as a movement in linear space, despite the name
 vec3d vm_angular_move(const vec3d* goal, float delta_t,
-	vec3d* vel, const vec3d* vel_limit, const vec3d* acc_limit, bool aggressive_bank, bool force_no_overshoot, bool no_directional_bias)
+	vec3d* vel, const vec3d* vel_limit, const vec3d* acc_limit, bool no_bank, bool force_no_overshoot, bool no_directional_bias)
 {
 	vec3d ret, slow;
 	vm_vec_make(&slow, 1.f, 1.f, 1.f);
@@ -1915,12 +1915,12 @@ vec3d vm_angular_move(const vec3d* goal, float delta_t,
 		// so they arrive at approximately the same time as the slowest component, so the path there is nice and straight
 		float max = fmax(slow.xyz.x, fmax(slow.xyz.y, slow.xyz.z));
 		if (max != 0) vm_vec_scale(&slow, 1 / max);
-		if (aggressive_bank) slow.xyz.z = 1.f;
 	}
 
 	ret.xyz.x = vm_angular_move_1dimension(goal->xyz.x, delta_t, &vel->xyz.x, vel_limit->xyz.x, acc_limit->xyz.x, slow.xyz.x, force_no_overshoot);
 	ret.xyz.y = vm_angular_move_1dimension(goal->xyz.y, delta_t, &vel->xyz.y, vel_limit->xyz.y, acc_limit->xyz.y, slow.xyz.y, force_no_overshoot);
-	ret.xyz.z = vm_angular_move_1dimension(goal->xyz.z, delta_t, &vel->xyz.z, vel_limit->xyz.z, acc_limit->xyz.z, slow.xyz.z, force_no_overshoot);
+	if (!no_bank)
+		ret.xyz.z = vm_angular_move_1dimension(goal->xyz.z, delta_t, &vel->xyz.z, vel_limit->xyz.z, acc_limit->xyz.z, slow.xyz.z, force_no_overshoot);
 	return ret;
 }
 
@@ -2012,7 +2012,7 @@ void vm_angular_move_matrix(const matrix* goal_orient, const matrix* curr_orient
 //					orient		=>		current orientation matrix (with current forward vector)
 //					w_in		=>		current input angular velocity
 //					delta_t		=>		this frametime
-//					delta_bank	=>		desired change in bank in degrees
+//					bank_vel	=>		desired bank velocity
 //					next_orient	=>		the orientation matrix at time delta_t (with current forward vector)
 //					w_out		=>		the angular velocity of the ship at delta_t
 //					vel_limit	=>		maximum rotational speed
@@ -2027,15 +2027,14 @@ void vm_angular_move_matrix(const matrix* goal_orient, const matrix* curr_orient
 //		function attempts to rotate the forward vector toward the goal forward vector taking account of anglular
 //		momentum (velocity)  Attempt to try to move bank by goal delta_bank. 
 //		called "vm_forward_interpolate" in retail 
-void vm_angular_move_forward_vec(const vec3d* goal_f, const matrix* orient, const vec3d* w_in, float delta_t, float delta_bank,
+void vm_angular_move_forward_vec(const vec3d* goal_f, const matrix* orient, const vec3d* w_in, float delta_t, float bank_vel,
 	matrix* next_orient, vec3d* w_out, const vec3d* vel_limit, const vec3d* acc_limit, bool no_directional_bias)
 {
 	vec3d rot_axis;
 	vm_vec_cross(&rot_axis, &orient->vec.fvec, goal_f); // Get the direction to rotate to the goal
 	float cos_theta = vm_vec_dot(&orient->vec.fvec, goal_f);  // Get cos(theta) where theta is the amount to rotate
 	float sin_theta = fmin(vm_vec_mag(&rot_axis), 1.0f);      // Get sin(theta) (cap at 1 for floating point errors)
-	vec3d theta_goal;
-	vm_vec_make(&theta_goal, 0, 0, delta_bank);         // theta_goal will contain the radians to rotate (in the same direction as rot_axis but in local coords)
+	vec3d theta_goal = vmd_zero_vector;    // theta_goal will contain the radians to rotate (in the same direction as rot_axis but in local coords)
 
 	if (sin_theta <= SMALL_NUM) { // sin(theta) is small so we are either very close or very far
 		if (cos_theta < 0) { // cos(theta) < 0, sin(theta) ~ 0 means we are pointed exactly the opposite way
@@ -2063,15 +2062,24 @@ void vm_angular_move_forward_vec(const vec3d* goal_f, const matrix* orient, cons
 
 		// derive theta from sin(theta) for better accuracy
 		vm_vec_copy_scale(&theta_goal, &local_rot_axis, (cos_theta > 0 ? asinf_safe(sin_theta) : PI - asinf_safe(sin_theta)) / sin_theta);
-		
-		// reset z to delta_bank, because it just got cleared
-		theta_goal.xyz.z = delta_bank;
 	}
 
 	// calculate best approach in linear space (returns velocity in w_out and position difference in rot_axis)
 	*w_out = *w_in;
 	rot_axis = vm_angular_move(&theta_goal, delta_t, w_out, vel_limit, acc_limit, true, false, no_directional_bias);
 
+	// handle bank separately, simpler, since its just a target velocity
+	{
+		float delta_bank_vel = bank_vel - w_in->xyz.z;
+		float delta_bank_accel = fl_abs(delta_bank_vel) / delta_t; // the accel required to reach the target vel this frame
+		float accel = (delta_bank_accel > acc_limit->xyz.z) ? acc_limit->xyz.z : delta_bank_accel;
+		if (delta_bank_vel < 0)
+			accel = -accel;
+
+		rot_axis.xyz.z = w_in->xyz.z * delta_t + accel * delta_t * delta_t * 0.5f; // vt + 1/2at^2
+		w_out->xyz.z = w_in->xyz.z + accel * delta_t;
+	}
+
 	//	normalize rotation axis and determine total rotation angle
 	float theta = vm_vec_mag(&rot_axis);
 	if (theta > SMALL_NUM)