Lab firing upgrades (scp-fs2open#6703)

* Fix some issues preventing various secondary types from firing in the lab

* Add ability to fire turrets from the lab

* const char*, mjn please

* more cleanup

* range-based for loop

* Update comment

Author: MjnMixael

code/ai/ai.h

@@ -318,7 +318,7 @@ typedef struct ai_info {
 	//Unlike the predicted position stuff, also takes into account velocity
 	//Only used against small ships
 	fix		next_aim_pos_time;
-	vec3d	last_aim_enemy_pos;
+	vec3d	last_aim_enemy_pos;		// Normally this is the position of the enemy a turret is targeting but in the F3 Lab, this is used to pass raw target coordinates to the turret firing methods. 
 	vec3d	last_aim_enemy_vel;
 
 	ai_goal	goals[MAX_AI_GOALS];

code/ai/aicode.cpp

@@ -12089,6 +12089,8 @@ void ai_process_subobjects(int objnum)
 	ai_info	*aip = &Ai_info[shipp->ai_index];
 	ship_info	*sip = &Ship_info[shipp->ship_info_index];
 
+	bool in_lab = gameseq_get_state() == GS_STATE_LAB;
+
 	// non-player ships that are playing dead do not process subsystems or turrets
 	if ((!(objp->flags[Object::Object_Flags::Player_ship]) || Player_use_ai) && aip->mode == AIM_PLAY_DEAD)
 		return;
@@ -12163,7 +12165,9 @@ void ai_process_subobjects(int objnum)
 
 				if ( psub->turret_num_firing_points > 0 )
 				{
-					ai_turret_execute_behavior(shipp, pss);
+					if (!in_lab) {
+						ai_turret_execute_behavior(shipp, pss);
+					}
 				} else {
 					Warning( LOCATION, "Turret %s on ship %s has no firing points assigned to it.\nThis needs to be fixed in the model.\n", psub->name, shipp->ship_name );
 				}
@@ -12208,6 +12212,11 @@ void ai_process_subobjects(int objnum)
 		// NOTE: Subsystem submodels are no longer rotated here.  See ship_move_subsystems().
 	}
 
+	// Lab doesn't need to do anything else here
+	if (in_lab) {
+		return;
+	}
+
 	// Clients must not make actual AI changes! So bail here.
 	if (MULTIPLAYER_CLIENT) {
 		return;

code/ai/aiturret.cpp

@@ -791,6 +791,120 @@ void LabUi::build_weapon_options(ship* shipp) const {
 			}
 		}
 	}
+
+	with_TreeNode("Turrets")
+	{
+		auto subsys_idx = 0; // unique IDs
+
+		for (auto* subsys = GET_FIRST(&shipp->subsys_list); subsys != END_OF_LIST(&shipp->subsys_list);
+			 subsys = GET_NEXT(subsys)) {
+			if (subsys->system_info->type != SUBSYSTEM_TURRET)
+				continue;
+
+			SCP_string label;
+			sprintf(label, "Turret %i - %s", subsys_idx, subsys->system_info->subobj_name);
+
+			if (TreeNodeEx(label.c_str(), ImGuiTreeNodeFlags_DefaultOpen)) {
+
+				Spacing();
+
+				// Find the turret in FireTurrets
+				auto it = std::find_if(getLabManager()->FireTurrets.begin(),
+					getLabManager()->FireTurrets.end(),
+					[subsys](const auto& tuple) { return std::get<0>(tuple) == subsys; });
+
+				int mode = 0; // Default to UVEC aligned
+				bool fire_now = false;
+
+				bool multipart = false;
+				if (subsys->system_info->turret_gun_sobj >= 0 && subsys->system_info->subobj_num != subsys->system_info->turret_gun_sobj) {
+					multipart = true;
+				}
+
+				const char* aiming_options[] = {"Random", "UVEC Aligned", "Initial"};
+
+				// In the lab we need to force fire on target because we're faking having an actual target
+				subsys->system_info->flags.set(Model::Subsystem_Flags::Fire_on_target);
+
+				// If already added, load current mode + fire state
+				if (it != getLabManager()->FireTurrets.end()) {
+					mode = static_cast<int>(std::get<1>(*it));
+					fire_now = std::get<2>(*it);
+				}
+
+				// Fire checkbox
+				SCP_string cb_label;
+				sprintf(cb_label, "Fire Turret##turret%i", subsys_idx);
+				Checkbox(cb_label.c_str(), &fire_now);
+
+				// Mode dropdown
+				ImGui::TextUnformatted("Turret Aiming:");
+				ImGui::SameLine(150.0f); // Start combo box at 150px
+				ImGui::SetNextItemWidth(200.0f);
+				ImGui::Combo("##AimingMode", &mode, aiming_options, multipart ? 3 : 2);
+
+				auto modeToAimType = [multipart](int this_mode) -> LabTurretAimType {
+					switch (this_mode) {
+					case 0:
+						return LabTurretAimType::RANDOM;
+					case 1:
+						return LabTurretAimType::UVEC;
+					case 2:
+						if (multipart) {
+							return LabTurretAimType::INITIAL;
+						} else {
+							return LabTurretAimType::UVEC;
+						}
+					default:
+						return LabTurretAimType::RANDOM; // fallback
+					}
+				};
+
+				// Update or add to FireTurrets
+				if (it == getLabManager()->FireTurrets.end()) {
+					getLabManager()->FireTurrets.emplace_back(subsys, modeToAimType(mode), fire_now);
+
+					// Set timestamps to allow turret to fire immediately
+					subsys->turret_next_fire_stamp = timestamp(0);
+					auto& weps = subsys->weapons;
+					for (auto& stamp : weps.next_primary_fire_stamp) {
+						stamp = timestamp(0);
+					}
+
+					for (auto& stamp : weps.next_secondary_fire_stamp) {
+						stamp = timestamp(0);
+					}
+				} else {
+					std::get<1>(*it) = modeToAimType(mode);
+					std::get<2>(*it) = fire_now;
+				}
+
+				auto& weps = subsys->weapons;
+
+				// PRIMARY BANKS
+				for (int bank = 0; bank < weps.num_primary_banks; ++bank) {
+					SCP_string text;
+					sprintf(text, "##TurretPrimaryBank%i_%i", subsys_idx, bank);
+
+					auto* wip = &Weapon_info[weps.primary_bank_weapons[bank]];
+					build_primary_weapon_combobox(text, wip, weps.primary_bank_weapons[bank]);
+				}
+
+				// SECONDARY BANKS
+				for (int bank = 0; bank < weps.num_secondary_banks; ++bank) {
+					SCP_string text;
+					sprintf(text, "##TurretSecondaryBank%i_%i", subsys_idx, bank);
+
+					auto* wip = &Weapon_info[weps.secondary_bank_weapons[bank]];
+					build_secondary_weapon_combobox(text, wip, weps.secondary_bank_weapons[bank]);
+				}
+
+				TreePop(); // Close this turret node
+			}
+
+			subsys_idx++;
+		}
+	}
 }
 
 void LabUi::build_primary_weapon_combobox(SCP_string& text,

code/lab/dialogs/lab_ui.cpp

@@ -4,6 +4,12 @@
 #include "model/animation/modelanimation.h"
 #include "species_defs/species_defs.h"
 
+enum class LabTurretAimType {
+	RANDOM,
+	UVEC,
+	INITIAL,
+};
+
 class LabUi {
   public:
 	void create_ui();

code/lab/dialogs/lab_ui.h

@@ -3,8 +3,10 @@
 #include "lab/renderer/lab_renderer.h"
 #include "io/key.h"
 #include "asteroid/asteroid.h"
+#include "math/staticrand.h"
 #include "missionui/missionscreencommon.h"
 #include "debris/debris.h"
+#include "ship/ship.h"
 #include "ship/shipfx.h"
 #include "particle/particle.h"
 #include "weapon/muzzleflash.h"
@@ -16,6 +18,9 @@
 #include "io/mouse.h"
 #include "weapon/weapon.h"
 
+//Turret firing forward declarations
+void ai_turret_execute_behavior(const ship* shipp, ship_subsys* ss);
+
 
 void lab_exit() {
 	getLabManager()->notify_close();
@@ -247,6 +252,78 @@ void LabManager::onFrame(float frametime) {
 				ship_fire_secondary(obj);
 			}
 		}
+
+		ship_process_post(obj, frametime);
+		ai_process_subobjects(CurrentObject); // So that animations get reset
+
+		if (!getLabManager()->FireTurrets.empty()) {
+			for (auto& [subsys, mode, fire] : getLabManager()->FireTurrets) {
+				if (!fire || subsys == nullptr)
+					continue;
+
+				vec3d new_pos, new_vec;
+				ship_get_global_turret_info(&Objects[subsys->parent_objnum], subsys->system_info, &new_pos, &new_vec);
+
+				bool multipart = false;
+				// Turret is multipart
+				if (subsys->system_info->turret_gun_sobj >= 0 && subsys->system_info->subobj_num != subsys->system_info->turret_gun_sobj) {
+					multipart = true;
+				}
+
+				switch (mode) {
+					case LabTurretAimType::UVEC: {
+						subsys->last_aim_enemy_pos = new_pos + new_vec * 500.0f;
+						break;
+					}
+					case LabTurretAimType::INITIAL: {
+						subsys->last_aim_enemy_pos = vmd_zero_vector;
+						break;
+					}
+					case LabTurretAimType::RANDOM: {
+						bool gen_new_vec = !multipart || subsys->points_to_target <= 0.010f;
+						if (gen_new_vec && timestamp_elapsed(subsys->turret_next_fire_stamp)) {
+							vec3d rand_vec;
+							const int MAX_ATTEMPTS = 100;
+							bool valid_vec_found = false;
+
+							// You get 100 tries to find a set of random coords to fire at
+							for (int attempt = 0; attempt < MAX_ATTEMPTS; ++attempt) {
+								float full_fov_degrees = 2.0f * acosf(subsys->system_info->turret_fov) * (180.0f / PI);
+								vm_vec_random_cone(&rand_vec, &new_vec, full_fov_degrees);
+
+								vec3d target_point;
+								vm_vec_scale_add(&target_point, &new_pos, &rand_vec, 1000.0f);
+
+								//  Create a vector from the turret to the random point.
+								vec3d turret_to_target;
+								vm_vec_sub(&turret_to_target, &target_point, &new_pos);
+								vm_vec_normalize(&turret_to_target);
+
+								// Test if the generated vector is within the FOV
+								if (turret_fov_test(subsys, &new_vec, &turret_to_target, 0.0f)) {
+									valid_vec_found = true;
+									rand_vec = target_point;
+									break;
+								}
+							}
+
+							if (valid_vec_found) {
+								subsys->last_aim_enemy_pos = rand_vec;
+							} else {
+								subsys->last_aim_enemy_pos = new_pos + new_vec * 500.0f;
+							}
+						}
+						break;
+					}
+					default:
+						Assertion(false, "Invalid Lab Turret Aim Type!");
+						break;
+				}
+
+				ai_turret_execute_behavior(&Ships[obj->instance], subsys);
+			}
+		}
+
 	}
 
 	// get correct revolution rate
@@ -290,6 +367,9 @@ void LabManager::changeDisplayedObject(LabMode mode, int info_index) {
 	CurrentClass = info_index;
 
 	if (CurrentObject != -1) {
+		// Stop any firing turrets
+		FireTurrets.clear();
+
 		obj_delete_all();
 		CurrentObject = -1;
 	}

code/lab/manager/lab_manager.cpp

@@ -78,6 +78,8 @@ class LabManager {
 
 	int FirePrimaries = 0;
 	int FireSecondaries = 0;
+	
+	SCP_vector<std::tuple<ship_subsys*, LabTurretAimType, bool>> FireTurrets;
 
 	LabRotationMode RotationMode = LabRotationMode::Both;
 	float RotationSpeedDivisor = 100.0f;

code/lab/manager/lab_manager.h

@@ -13734,6 +13734,8 @@ int ship_fire_secondary( object *obj, int allow_swarm, bool rollback_shot )
 	if(Ships[n].objnum != OBJ_INDEX(obj)){
 		return 0;
 	}
+
+	bool in_lab = (gameseq_get_state() == GS_STATE_LAB);
 
 	shipp = &Ships[n];
 	swp = &shipp->weapons;
@@ -13826,7 +13828,7 @@ int ship_fire_secondary( object *obj, int allow_swarm, bool rollback_shot )
 	}
 
 	// Ensure if this is a "require-lock" missile, that a lock actually exists
-	if ( wip->wi_flags[Weapon::Info_Flags::No_dumbfire] ) {
+	if (wip->wi_flags[Weapon::Info_Flags::No_dumbfire] && !in_lab) {
 		if (!aip->current_target_is_locked && !ship_lock_present(shipp) && shipp->missile_locks_firing.empty() && aip->ai_missile_locks_firing.empty()) {
 			if (obj == Player_obj) {
 				if (!Weapon_energy_cheat) {
@@ -13858,7 +13860,7 @@ int ship_fire_secondary( object *obj, int allow_swarm, bool rollback_shot )
 		}
 	}
 
-	if (wip->wi_flags[Weapon::Info_Flags::Tagged_only])
+	if (wip->wi_flags[Weapon::Info_Flags::Tagged_only] && !in_lab)
 	{
 		if (!ship_is_tagged(&Objects[aip->target_objnum]))
 		{
@@ -13890,10 +13892,14 @@ int ship_fire_secondary( object *obj, int allow_swarm, bool rollback_shot )
 	if ( (wip->wi_flags[Weapon::Info_Flags::Swarm]) && !allow_swarm ) {
 		Assert(wip->swarm_count > 0);
 		if (wip->multi_lock) {
-			if(obj == Player_obj || (MULTIPLAYER_MASTER && obj->flags[Object::Object_Flags::Player_ship]))
-				shipp->num_swarm_missiles_to_fire = (int)shipp->missile_locks_firing.size();
-			else // AI ships
-				shipp->num_swarm_missiles_to_fire = (int)aip->ai_missile_locks_firing.size();
+			if (in_lab) {
+				shipp->num_swarm_missiles_to_fire = wip->max_seeking;
+			} else {
+				if (obj == Player_obj || (MULTIPLAYER_MASTER && obj->flags[Object::Object_Flags::Player_ship]))
+					shipp->num_swarm_missiles_to_fire = static_cast<int>(shipp->missile_locks_firing.size());
+				else // AI ships
+					shipp->num_swarm_missiles_to_fire = static_cast<int>(aip->ai_missile_locks_firing.size());
+			}
 		} else if(wip->swarm_count <= 0){
 			shipp->num_swarm_missiles_to_fire = SWARM_DEFAULT_NUM_MISSILES_FIRED;
 		} else {
@@ -13909,10 +13915,14 @@ int ship_fire_secondary( object *obj, int allow_swarm, bool rollback_shot )
 		//phreak 11-9-02 
 		//changed this from 4 to custom number defined in tables
 		if (wip->multi_lock) {
-			if (obj == Player_obj || (MULTIPLAYER_MASTER && obj->flags[Object::Object_Flags::Player_ship]))
-				shipp->num_corkscrew_to_fire = (ubyte)shipp->missile_locks_firing.size();
-			else // AI ships
-				shipp->num_corkscrew_to_fire = (ubyte)aip->ai_missile_locks_firing.size();
+			if (in_lab) {
+				shipp->num_corkscrew_to_fire = static_cast<ubyte>(wip->max_seeking);
+			} else {
+				if (obj == Player_obj || (MULTIPLAYER_MASTER && obj->flags[Object::Object_Flags::Player_ship]))
+					shipp->num_corkscrew_to_fire = static_cast<ubyte>(shipp->missile_locks_firing.size());
+				else // AI ships
+					shipp->num_corkscrew_to_fire = static_cast<ubyte>(aip->ai_missile_locks_firing.size());
+			}
 		} else {
 			shipp->num_corkscrew_to_fire = (ubyte)(shipp->num_corkscrew_to_fire + (ubyte)wip->cs_num_fired);
 		}
@@ -14014,7 +14024,7 @@ int ship_fire_secondary( object *obj, int allow_swarm, bool rollback_shot )
 		// and if I am a client in multiplayer
 		check_ammo = 1;
 
-		if ( MULTIPLAYER_CLIENT && (obj != Player_obj) ){
+		if (in_lab || (MULTIPLAYER_CLIENT && (obj != Player_obj))) {
 			check_ammo = 0;
 		}
 
@@ -14229,7 +14239,7 @@ int ship_fire_secondary( object *obj, int allow_swarm, bool rollback_shot )
 
 	// if we are out of ammo in this bank then don't carry over firing swarm/corkscrew
 	// missiles to a new bank
-	if (!ship_secondary_has_ammo(swp, bank) || shipp->weapon_energy < wip->energy_consumed) {
+	if (!in_lab && (!ship_secondary_has_ammo(swp, bank) || shipp->weapon_energy < wip->energy_consumed)) {
 		// NOTE: these are set to 1 since they will get reduced by 1 in the
 		//       swarm/corkscrew code once this function returns
 

code/ship/ship.cpp

@@ -309,7 +309,7 @@ void turret_swarm_delete(int i)
 }
 
 // Set up turret swarm info struct
-void turret_swarm_set_up_info(int parent_objnum, ship_subsys *turret, const weapon_info *wip, int weapon_num)
+void turret_swarm_set_up_info(int parent_objnum, ship_subsys *turret, const weapon_info *wip, int weapon_num, bool no_tracking_object)
 {
 	turret_swarm_info	*tsi;
 	object *parent_obj, *target_obj;
@@ -334,7 +334,7 @@ void turret_swarm_set_up_info(int parent_objnum, ship_subsys *turret, const weap
 	Assert(parent_obj->type == OBJ_SHIP);
 	shipp = &Ships[parent_obj->instance];
 	Assert(turret->turret_enemy_objnum < MAX_OBJECTS);
-	if((turret->turret_enemy_objnum < 0) || (turret->turret_enemy_objnum >= MAX_OBJECTS)){
+	if(!no_tracking_object && ((turret->turret_enemy_objnum < 0) || (turret->turret_enemy_objnum >= MAX_OBJECTS))){
 		return;
 	}
 	target_obj = &Objects[turret->turret_enemy_objnum];