Many values in `ai.tbl` can be inserted as overrides for their equivalent `Ai_profiles.tbl` values. (They are all optional and if not set for an AI class, the values in AI Profiles will be used.)
This is particularly useful for making very specific AI classes that still follow the main AI profiles table with easy to change values.
This PR adds `$firing requires exact los:` as an optional override to set in `ai.tbl`. This particular override is very useful, since it can be set to off by default in the `ai_profiles.tbl` for performance, but then set to on for some select AI classes within `ai.tbl`, and those AI classes can be easily changed on the fly in a mission.
This initializes `mc_info` to the correct values when it is constructed, removing the need for `mc_info_init`.
This PR also fixes a group of incorrectly inverted assignments in beam.cpp.
Follow-up to #5040. This extends the checks to most iterations over `obj_used_list` in FSO. There are a few exceptions such as `waypoint_add` and `waypoint_remove`, plus a few others. And none of the object iterations in FRED have the guard because FRED does not use the same object life cycle as FSO.
When iterating through `Ship_obj_list`, check the `Should_be_dead` flag before using the object. This fixes#4990 and adds defense-in-depth checks to guard against similar errors elsewhere.
I considered moving the `Ship_obj_list` removal from `obj_delete` to `ship_cleanup`, but decided it would be prudent to avoid fundamental changes to lifecycle management.
Whether a ship is a support ship or its target, and whether it is destroyed or vanished, its repair/rearm mode should be cleaned up in a consistent way. This fixes a bug in Series Resurrecta where calling `ship-vanish` on a support ship put things into a broken state.
In the submodel reorganization in commit 575c050da4, subobject movement was moved out of the AI pipeline, which inadvertently removed the play-dead check that prevents subsystem movement. This broke a few missions such as Scroll's 'Thor's Hammer'. This PR restores the check.
Fixes#4933.
PR #4516 did not cover all of the autoscaled AI class attributes, since a few of them were labeled differently. This adds checks to grab the correct autoscale index for the remaining cases:
```
$Afterburner Use Factor:
$Shockwave Evade Chances Per Second:
$Get Away Chance:
$Secondary Range Multiplier:
```
Fortunately, Sushi's investigation was pretty thorough. Between these remaining cases and @EatThePath's autoscaling review, this PR should cover the complete set of autoscaling situations.
Fixes#4922.
Adds gravity! Applies on a per-mission basis, and weapons, ships, debris, and asteroids now have a configurable "gravity const" which multiplies the effect of gravity on them, by default everything except debris is 0 (meaning no effect even when the mission has gravity). AI and the lead indicator will also lead for ballistic trajectories as well, given a gravity-affected weapon. No FRED support or gravity direction control yet, to come in later PRs.
* Enable clients to move turrets
This allows clients to user server data to move turrets according to the timing and target data on the server. Uses a small packet to do so.
This adds an AI profiles flag that filters autoscaling so that only the index and number of autoscaled classes are considered, not the index and number of all AI classes.
Fixes#4516.
* Add AI flag to support ai bay arrivals > 10 seconds
Currently, if an AI ship is emerging from a bay path, the AI will stop following that path after only 10 seconds (and some distance away from the starting point). This results in AI breaking off a path early if a bay arrival path is long and/or uses a slow bay arrive multipliers. For bays that require the ship to follow the exact path this results in AI that then run into the parent ship and each other.
This PR adds a flag which disables that 10 second timeout. Also, in my tests having a flag to disable works best, as opposed to setting a max time (which is hard to calculate with varying ship speeds and varying bay path lengths).
PR is tested and works as expected.
* fix spelling
According to EatThePath's frame profiling, this one ship name lookup takes 2% of the frame time. It can be easily optimized by making use of the ship registry.
The original implementation of `ai_good_time_to_rearm` did not revert to being a "bad" time to rearm when the time was up. This fixes that and adds an AI profiles flag to toggle it.
Also converts `ai_rearm_timestamp` to use the new TIMESTAMP type.
* Allow `test_line_of_sight` to return intersecting object signature
The `test_line_of_sight` can currently provide the closest intersecting distance, but it would be very useful, especially for AI scripting, if this function could also return the signature of the intersecting object. This PR adds that functionality.
Tested and works as expected. Happy to discuss strategies for changing implementation, too. The extra, third return value for object signature was added to `getLineOfSightFirstIntersect` function because that function already returns 2 values. Thus, it will remain compatible with older scripts which only save the first 2 returned values.
* fix documentation
* fix typo
* return object instead of sig
* fix pointer
* use pointer pointer for full fix
* name clarification
* Add Animation Instance Flags
* Add SEXP barebones
* Unify and simplify animation parsing
* Clean up animation calling and use new animationlist api
* Add missing break
`Ai_flag_names[]`, `Object_flag_names[]`, and `Ship_flag_names[]` all had an associated `#define` containing their length that had to manually be incremented whenever new flag names were added to the list. This commit instead makes the number of flags in the list be computed by simple `sizeof` division, so now adding a new entry just requires adding the entry, rather than remembering to bump a `#define`. Tested in FRED to make sure populating `OPF_SHIP_FLAG` entries still works.
This assert catches any weapon's parent object type, which can include OBJ_GHOST, which is a dead player. OBJ_GHOST is being encountered in this function using BPC when the player dies via beam weapon and (likely) when the players weapon are hitting an enemy ship at the same time. Because the player ship can damage an enemy after it is dead, allow for that in this function.
PR #4500 added some checks, but accidentally compared `aip->target_objnum` to an object type (although the assertion message correctly retrieved the object type, leading to the bizarre assertion that `OBJ_SHIP`, i.e. 1, was an invalid target object type). This commit makes them all access the `Objects[]` array and retrieve the `.type`, just as the assertion message does (and the pre-#4500 conditional did).
Related to #4504, in that it's the source of the failed assertions, although I can't be sure it was the cause of the crashes without testing.
* Include more valid object types in this check
The previous version of the fix only included ships because it was believed to be the object that a ship used to be guarding. Now it's clear that this is an object that the ship is currently targeting *after* guarding something.
So remove the UNREACHABLE and manually check the valid object types with an assert. Then only continue with the function if it is the right target type.
* typo
wookieejedi