Target priorities could previous only select based on very few flags, for the simple reason that very few were defined in the ai_tgt_*_flags[] arrays. This simply adds additional flags (even some that seem a little silly; I can't actually think of a reason to especially target "objects that are being rendered", but hey, maybe somebody will find a use for it in the future).
This introduces a new mechanism for handling bit flags. Instead of using an int (or two, or three) to write bits into, this uses the std::bitset in a wrapper class that accepts an enum class as input. This means that certain classes of errors we've had a few of in the engine, where a coder used the wrong set of flags or checked them against the wrong variable (SF_STEALTH vs SIF_STEALTH, for example) can now be detected at a compiler level rather than not at all.
Originally, "share fire dir" forced the "salvo mode" flag. This
interfered with the "use multiple guns" flag. In order to avoid this, I
instead made "share fire dir" if either "salvo mode" or "use multiple
guns" is not found, as those are the only two flags that, coupled with
"share fire dir" give the desired results.
"If a or b else a" should never ever execute the "else a" branch; this appears to be an artifact left over from Wanderer's reorganization of the autoaim/convergence code in 7bb10d8, before which standard convergence and automatic convergence were handled in separate conditionals.
If a modular ship table modifies a ship entry without specifying a "$Countermeasure type:" entry, and the species has a "$Countermeasure type:" entry, FSO would reset the ship's countermeasure type to match the species default, even if we weren't defining the class for the first time. This just adds a first_time check to the else branch to avoid that.
Allows support for as many subsystems as available memory allows by replacing the Ship_subsystems[] pointer array with a pointer vector. It still just contains pointers to dynamically-allocated subsystem arrays (allocated in blocks of NUM_SHIP_SUBSYSTEMS_PER_SET), so this should behave almost identically to the current code.
The APNG changes required some additional work. A cursor now owns the
bitmap handle that will be used for the cursor. This is required in
order to support variable FPS cursors.
This was a bit of a doozy.
If the player's current target changes ship class with change_ship_type(), Player_ai->targeted_subsys will still be pointing to the old subsystem list; this could cause problems (specifically out-of-bounds array accesses) when trying to e.g. look up nonexistant submodels. Similar problems occur with any other AIs targeting a subsystem on the ship in question. In order to fix this, several changes were made.
Firstly, change_ship_type() will now go through every Ai_info object looking for ones targeting a subsystem of the ship changing classes, or with an AI_GOAL_DESTROY_SUBSYSTEM goal for the ship changing classes, and convert them all to the new subsystem (if there's a match) or remove the target/goal (if there isn't), reusing the existing subsystem comparison logic (for transferring damage). Near the end, there's a Player_ai comparison to call hud_cease_subsystem_targeting(0) if necessary.
Additionally, change_ship_type() will also look through every weapon looking for anything that might be homing in on or fired from a subsystem on the ship changing types; these are handled similarly to targeted subsystems, including clearing the weapon's homing_subsys/turret_subsys attribute if a matching subsystem isn't found.
Also handles sp->last_targeted_subobject[], which contains subsystem pointers to keep track of which subsystem each player was previously targeting on that ship.
Lastly, change_ship_type() will now kill ship sparks if the model number has changed (trying to transfer sparks to matching submodels would be a herculean task and probably fail most of the time anyway, with similarly-named subobjects with different shapes so the coordinates wouldn't make sense anyway).
Moves the sip->draw_primary_models[bank_to_fire] check so that it only contains the code related to shipp->primary_rotate_ang[bank_to_fire], since that really does only matter if external models are present. The rest of the spinup code doesn't actually care about the model, though, so it seems odd (and unfair to modders) to not allow it to function just because the ship has external primary models disabled.
I also wrapped the spinup code in a basic check that winfo_p->weapon_submodel_rotate_vel is greater than zero because most weapons aren't going to have a spinup, so there's no need to perform the other calculations for them (it's probably a marginal savings at best, but since I was getting rid of the best-case savings of most ships not having external primary models enabled, I figured I may as well replace it).
Minor formatting changes to the other lines just because it took me a while to figure out what the code was doing when I first read it; "if(" changed to "if (", and line breaks inserted into the one-line conditionals.
Allows the players ship to have a minimum speed set. If the ships speed
drops below this (per ship) value, the throttle is increased to the
minimum.
For ships that are gliding, their engines will be reactivated when the
ships overall velocity falls below the minimum speed.
Currently only sets a minimum Z speed, Y & X are ignored.
Fix silly issue preventing getFrame() from working
Remove infinite loop when calculating frame num
Convert more animations to use new frame calc function
i.e. apngs (pre)loaded into bmpman slots
handles apng variable frame delays
Includes new lua function (getFrames) to find the current frame for
apngs. Also uses new function to correctly display apngs for mission
loading animations, ship thrusters & engine glows.
Replaces calls to double-precision floating point trig functions with
calls to single-precision floating point trig functions as follows:
cos() -> cosf()
sin() -> sinf()
tan() -> tanf()
acos() -> acosf()
asin() -> asinf()
atan() -> atanf()
This allows the compiler to avoid generating unnecessary instructions
that convert a float to a double and then a double back to a float.
Signed-off-by: Peter Mitsis <[email protected]>
Both the ANG_TO_RAD() and fl_radians() macros were serving the same
purpose; they converted an angle from degrees to radians. To reduce
code duplication, ANG_TO_RAD() was replaced with the existing
fl_radians().
Signed-off-by: Peter Mitsis <[email protected]>
This is a renaming of the Dumb_rotation infrastructure, which is now called Intrinsic_rotation. Intrinsic rotations are automatically applied to submodels without the need for an associated subsystem. Dumb rotations are now a type of intrinsic rotation, and look_at rotations will be added in a future PR. The same code will handle both; the only difference is in how the intrinsic rotation is calculated. (In the case of dumb-rotation, it is calculated the same way as normal rotation; in the case of look-at, it will be calculated using submodel_look_at.)
m!m