This is a parser for a very simple language to allow for execution of
dynamic expressions with return values for use as action parameters. The
only "dynamic" part this currently supports are random ranges but more
features are planned for the future.
This system adds the code necessary for letting content creators specify
complex events by specifying a simple, program-like sequence of
operations that will be executed by the engine when a certain event is
triggered.
This is the recommended way to set this up.
Using this technique allows the user to replace the launcher with any
number of combinations of solutions such as
-DCMAKE_CXX_COMPILER_LAUNCHER=ccache:distcc
Supported since CMake 3.4. On previous versions of CMake, it will just
ignore this setting.
I just tried building 21.0 which is a higher version than the one used
in the test data which broke this test.
This should be a high enough version to not break any time soon...
If SDL completely fails to get its preference path, at least warn the user so that it doesn't crash straight to the desktop without creating a debug build.
In the particle effect code there is a small hack required for getting
some constant pointers in a vector. However, there is another mechanism
where sources are not added to the sources vector if the sources are
currently being iterated through. That is necessary to avoid
accidentally invalidating the iterators.
The issue here was that the vector resizing hack was not applied to the
correct vector when we were currently iterating. This fixes that.
This fixes#2928.
This was 20.1 since I erronously thought that the "current" nightly
version was lower than that. This updates the version to a release that
has not been built yet.
When weapon info flags were changed to the flagset model in #851 (commit 127976cd74), two instances where `WIF2_CAPITAL_PLUS` was either actively desired or passively not prohibited were lost in the transition; this commit restores looking for `Weapon::Info_Flags::Capital_plus` when targeting a big ship, and no longer prohibits capital+ weapons from being selected if a bomber+ weapon is sought and smart secondary weapon selection is enabled.
This works around the Windows only limitation where the standard random
function only returns up to 2^15 which limits how many vertices in the
model can be picked.
Since we already have a function that handles this properly and returns
values in the entire integer range, using that fixes that low limit.
- use correct macro for player_id
- support more subsystems
- optimize size of secondary weapon info
- handle future compatibility issues with secondary ammo
(based on PR 2109 by Cyborg17)
- support compaign descriptions (Mantis 1826)
- allow sending multiple packets to get entire description
- update description of selected game on join screen if needed
- chnage op count data type to short
(can't have more space than that anyway)
- get rid of some loops in favor of plain memcpy()
- fewer magic numbers
- use SEXP_MAX_PACKET_SIZE to fix packet size discrepancy
These macros will grab a known sized block of data without
any manipulation. Should only be used with data which is
serialized/deserialized in another part of the code.
- add bfi_flags
- add proper bank/point data for fighters
- allow for more than 255 subsystems
- add data for targeted subsystem
- add support for TARGETING_COORDS flag
- add support for FLOATING_BEAM flag
- add fire method
- add initial packet support for type F beams
- use standard ADD/GET macros
- better detection of size issues
- support SHRT_MAX ship types
- support SHRT_MAX weapon types
- use MAX_WSS_SLOTS & MAX_SHIP_WEAPONS safely
- support sound indexes higher than 254
- ADD/GET_STRING() will use 1-byte lengths (up to 255 chars)
- ADD/GET_STRING_16() will use 2-byte lengths (up to 65,535 chars)
- ADD/GET_STRING_32() added for compatiblity (game_active packet only!)
* Expose disposing FBO's (with the option to keep the Bitmap Alive) to scripting
* Modernize nullptr
* Moved RenderTarget clearing to own public API
* Fixed Obsolete Comment
* Fix bad deletion of FBOs
* Resolve Memory Leak
* Change FBO cleanup to not reuse old ID's
* FIx oversight
* FIx oversight 2
By only looking at the HEADs of the respective branches, we included
irrelevant changes in the diff passed to clang-tidy-diff so it was
possible to generate irrelevant warnings in a PR.
Since instance-specific fields have been moved to polymodel_instance and submodel_instance, the gun_submodel_rotation field should also be moved. This is also reworked a bit to keeping track of the rotation via the normal submodel instance angles.
This removes an unnecessary look_at field as well.
Since angles are no longer written in three redundant places, the temporary hijacking of the turret angles in `model_make_turret_matrix` was overwriting the turret's proper position. So this PR just saves the angles and restores them when the calculation is done.
Since that function already has full support for UV scaling it makes
sense to unify the behavior in one function instead of having a separate
monochrome function that does weird things.
Also deprecates that function since all its use cases are now covered by
drawImage.
This uses GitHub actions for building Linux and Windows builds for
release tags.
Appveyor is now no longer used for building distribution packages and is
also not used for anything relevant anymore. If this works properly we
can disable that PR check to get better PR scalability.
This makes the workflows easier to manage, makes those build steps
reusable, and allows for easier migration to other CI services should
that be required at some point.
There were null checks for `Player_obj`, but whoever added the `No_pain_flash` flag bypassed them by dereferencing `Player_obj` in the top-level if() block. This caused a crash when self-destructing ships in the F3 lab.
This PR moves the `Player_obj` check to the top-level block (which is also an implicit null check because `ship_objp` is not null by this point) which fixes the crash and also is more efficient.
Also run distribution builds in container. This uses the same container
for building PRs and distribution packages to ensure consistency
between them.
Also tries to fix an issue with a missing environment variable for the
tests.
This just introduces the previously Travis integration and moves it to
GitHub actions.
This also found various issues around our libc++ support so I fixed that
as well.
This will make our builds independent of the underlying system and allow
for more reproducible builds since everything uses the same compilers
and environments.
* Keep ships that we are centered on from moving
This prevents NAN from appearing from obscure vector math somewhere in the depths of fred.
* Also fix movement of centered objects in qtFRED
* Can't simply use the previous fade_out color as the default, because of an edge-case with legacy usage. The refactor would disallow setting the fadout to black.
This is a follow-up to PR #2942. Given that the short-circuiting is now explicitly skipped for node trees containing the special argument, it should no longer be necessary to flush the conditional branch of the sexp tree. (The .cache field is already skipped for special-arg nodes.)
The sexp tree is still explicitly flushed for `every-time` and `every-time-argument`.
It takes a number as a maximum number of arguments that can be evaluated in a single call, but otherwise behaves very similarly to `any-of`; alternatively, if the number is 1, it's like an `in-sequence` that also skips arguments that don't satisfy the condition instead of just invalid ones.
There are some possibilities where we could get an expired pointer when
we create a persistent particle. This adds a check for that to avoid
crashing the engine in those case.
This is related to #2928.
* Should fix some crahes and inaccuracies at high pings
Feeding the wrong index to the rollback struct is a bad idea.... That's late night coding for you.
* Forgot one correction
* Also update the comment.
This is necessary for multi to ensure that music is stopped.
common_select_close() would do this, but it's never inited for
these screens. So we need to manually do it if we aren't
transitioning to a screen with common_music.
* Multiplayer Dumbfire Rollback
This creates a packet that sends the relative position and orientation info for a primary or dumbfire missle shot. The client creates this packet when firing those two types of weapons and sends it to the server. The server goes back to the frame that the client fired the weapon and quicky resimulates all the frames in-between.
This includes collision detection, restoring positions, orientations and veloicties, but not subsystem orientations.
* Address Feedback
* allow clients to send subsystem info
* Check for object number not weapon number
* Readability Adjustment
In commit 3b2af702f7, the hash truncation was changed so that instead of being part of the HUD, it's stored as the class's display name. However, this action was performed before `+Use Template:` was parsed, which would then overwrite the display name and clear the `Has_display_name` flag. I've moved it so that it now happens after the copy operation (and added a check for an existing display name, in case the template defines one). I use a new boolean variable to indicate that default display name creation needs to happen rather than duplicate that code.
Fixes#2834, a bug where non-capital ships did not generate debris pieces from their hull. It turns out this bug was introduced in #2416. If the `DoesNotExpire` flag is substituted for the `lifeleft` variable , it should be done in all locations.
The multilock patch did not handle `Lock_anim` in the best way, and handled `Lock_gauge` in a very bizarre way, despite the fact that they are two simple hud animations. This changes the `lock_info` struct to track the correct `time_elapsed` value for both, and changes the locking code to use the values in the correct way.
Additionally, this properly loops the lock triangles on the FS1 lock indicator. Strangely, even prior to the multilock merge it appears that the triangles wouldn't have animated more than a quarter turn.
Finally, this prevents the FS1 lock indicator from blinking, since in retail FS1 it didn't blink.
Tested with FSPort and no-mods. Fixes#2826.
Code was moved around between 3.8.0 and 19.0.0 which broke the colored backgrounds of paletted HUD gauges.
Palette index 15 is used by the HUD gauge graphics to indicate background area of HUD gauges. When the code to remap palette indexes to alpha values was moved to packunpack.cpp, palette index 15 was mistakenly mapped to the alpha for index 0 (nothing) rather than index 1 (what retail/3.8.0 code maps it to) causing all HUD gauges to be missing their dark transparent backgrounds.
Also: the code maps palette indexes [0, 15] to alpha values [0, 255]. But due to an oversight (palette index 15 not being part of this gradient] alpha value 255 is never used so the range of alpha values for HUD gauges ended up being [0, 238]. Conversion math tweaked to make the alpha range [0, 252] which is very close to 255.
This will make it easier to have a graphics interface without relying on
global objects since the object can be kept alive in the function
object. No other functional changes since the existing syntax is also
valid for function objects.
A follow-up of sorts to #2801, but independent of it. If a directive line is not split, the HUD should handle it properly rather than Asserting and displaying the same line twice.
If you create a kamikaze ship with ship-create, it won't work properly, because the explosion values are not initialized to -1 as expected. This fixes that.
This is basically the tutorial from vulkan-tutorial.com adapted to using
VulkanHpp and with some refactorings that extract some locigally
self-contained code.
Currently only draws a simple colored triangle.
If a message string contained a word that was too long, on its own, for the available screen real estate, the function wouldn't split the string at all. The new behavior is to split the string even if the split location is suboptimal, since it's better to have as much of the message visible as possible.
Quoting from the code:
```
// only update the line break if:
// a) we don't have a line break yet;
// b) we're still within the required real estate
// (basically we want the latest line break that doesn't go off the edge of the screen,
// but if the *first* line break is off the end of the screen, we want that)
```
This was the last thing that was missing for complete support of all
function parameter declarations.
To ensure parameter lists stay valid a unit test was added that will
validate the argument lists and cause the test to fail if they cannot be
parsed.
This one line fix properly specifies which ship to use for ETS managment. The recent merge of `Non-shielded ships manage ETS` had a object reference error, so this rectifies that. Thanks to Axem for finding this!
* Object Update Refactor
1. Keeps the object update packet aligned, even if the ship is dying or has not yet arrived on the client.
2. Properly handles model point shields (yes, that's what was causing multi to crash the most!)
3. Reworks positional interpolation timing and adds rotational interpolation, by sending timing information with every object update packet in a header shared between objects.
4. Saves a lot of bandwidth by only sending data that is changing. (no more sending all subsystems once per second!)
5. Better handles out of order packets (but can still use their information if recent enough!)
6. Builds the basis for Rollback by beginning to record the positions and orientations and velocities of ships for the last 30 frames.
7. Adds subsystem rotation -- Yeah, you saw that right, subsystems will now spin in multi.
8. Waypoint movement is now enabled via sexp, and time to arrival of waypoints is updated on the target info gauge.
* Fix edge case crash and Incorporate feedback
* Clean Up Interpolate Angles Quick
* Restrain the client
* How was this still here???
* Make sure every part of OO uses OOC_INDEX_NULLPTR_SUBSYSTEM define
* Fix Way to Store Return Values
* Ok travis, we get it
* Ok travis.........
* Fix underline length calculation in message scrollback
* Use SCP_string for message source (which allows ships with long display names to work without crashing) and message text
* Upgrade assorted functions to work with SCP_string
Using the `No_shields` flag for ships is common usage in multiple mods, and as it turns out ships with that flag set will not have the AI manage ETS values due to an early return in the `ai_manage_ets` function. This PR adds an AI flag to allow ships with no shields to manage ETS regarding weapons and engines. This flag was tested and works as expected.
Previously, if a script called a function that called another scripting
hook, some hook variables might be removed. This was the case since
after executing the hook the code would remove the set hook variables
again. If these variables had the same name as previously set variables,
they would overwrite and corrupt the state the original script expected.
This was unexpected behavior for script writers so this puts values on a
stack and only adds or removes from the stack instead of overwriting
values. This should make the hook variable state consistent for scripts
even if scripting hooks are called indirectly.
When flags are parsed, they can be reset. This is a problem for flags that are set based on lines elsewhere in the entry, so each table uses its own method to get around it. However, not all flags used this method - particularly the new Has_display_name flag. This brings the flag management up to date.
This is an effort to be able to use the same GLSL code for both Vulkan
and OpenGL. This is done by first compiling the Vulkan GLSL code to
SPIR-V and then using a custom tool (which uses SPIRV-Cross) to convert
that back into GLSL 1.50 compatible code.
The required tool will be downloaded by CMake when glslc is found in the
path. This is included in the Vulkan SDK. To avoid having a hard
dependency on this, the generated files are included in the VCS and are
only regenerated when glslc is found on the system.
The scripted code previously didn't check to see if a weapon bank was valid before firing it, which could have led to memory problems and starting March 15 would actually crash the game. This adds a few safety checks.
This PR adds a table entry that allows modders to specify the damage threshold for when turrents become less accurate due to weapon subsystem damage. A Game table setting is easier to set once and tune, thus this PR allows that efficent exposure to the modder and does not require a large change or complex table entry.
I have been thinking about some shader related techniques for the Vulkan
renderer and for that we will need to add embedded files in a different
environment than they are right now since the actual shader code will
not be needed in the engine.
For this reason, I extracted the "default file" mechanism to be more
generic so that all that is necessary to include a file is to just call
a custom CMake command and the function keeps track of what needs to be
done.
Also, since the "generic" code has worked pretty well so far I see no
reason to keep around two systems which just increases the amount of
code we need to maintain. So, I just removed the windows exclusive
implementation. Now all platforms use the same "generic" way of
embedding files.
The weapon loadout arrays wasted a ton of memory in several ways. First, only friendly fighters and bombers have weapon loadouts; most ship classes do not need this storage. Second, as DahBlount noticed, only 8 bits are needed for the flags, while the fields were using standard 32-bit ints. Third, there are currently 500 weapon types but most loadouts only provide a dozen or so options.
This refactors the loadout storage to keep a short vector of weapon-flag pairs for each bank, and the bank storage is allocated only when needed. The new `allowed_weapon_bank` class provides `operator[]` implementations so that the new API is almost completely compatible with the old one. The only things that require the new API are assignments, since `operator[]` is read-only. (A writable `operator[]` would not be able to tell when a flag value of 0 should be stored or not.)
This gives every document their own environment instead of using the
global environment. Previously it was necessary to store variables in
the global namespace since otherwise they could not be accessed by event
listeners.
This creates a separate environment table for every document so that all
<script> blocks and event handlers share the same "global" environment.
- support sync state before entering mission
- return to briefing for sync and stats saving
- handle campaign progression properly
- initialize net_player state properly (fixes#2560)
When I wrote the original change to a vector instead of an array, I was working on the assumption that this section of code was parsed after some other code that had already made sure that the special_char_indexes vector was at least three entries. Further testing has revealed this is not true, and this fix keeps it from crashing.
This PR adds a scripting hook which triggers when a ship fires a countermeasure. It has two variables, the ship firing the countermeasure and the number of countermeasures remaining. I have tested and it works as expected. This new hook complements the preexistsing `On Secondary Fire` and `On Primary Fire` hooks.
This can be used by script code for reliably storing Lua values without
having to build a custom serialization format.
The C++ code can also be used by other code modules that want to
serialize data. The new classes simply return a byte array with an
unspecified format.
At the moment this uses a plain JSON encoding but could be extended in
the future to include either compression or BSON encoding if necessary.
The format is future compatible by using a simple header to identify
different kinds of formats.
PR #2718 introduced the Has_display_name flag, but for mission parsing, the parse object flags were cleared subsequent to their assignment. This moves the flag reset earlier in the function.
Rampage noticed that the dialog would save a fiction viewer entry in some cases even if there was no story file. This makes the handling a bit more robust.
Also slightly optimizes some of the hooks because the adding/removing of hook variables should be guarded by the same if() block that controls execution.
1. Stores the filename from the table Parser into the font struct so we can lookup fonts via their filename.
2. Allow "+Special Character Font:" to specify the first entry with the same filename's special character index for their own special character index, provide a default if not, and allow the moddert to specify them manually, but do not override already recorded values if the default is picked in order to protect retail behavior.
3. Vectorize Special Character Indexes, so that we don't have a table limit that will randomly crash FSO based on what table you happened to write! Woohoo!
This makes the red-alert SEXP execute properly in multiplayer.
Note, this is just the SEXP. Multi-knowledgeable people will need to evaluate `red_alert_start_mission` and `red_alert_maybe_move_to_next_mission` to make sure those functions will work properly in multiplayer.
The previous version used the wrong function for the map and so values
added later were not written to the map and so not available to Lua.
This fixes that by using the simple array operator.
Fixes 2526 by making the array a vector and also adds a Shockwaves always damage bombs game_setting.tbl setting and a Shockwaves_consistently_apply_damage game_settings.tbl setting. The second one keeps bombs and asteroids from being hit more than once by shockwaves, like ships do!
This is a follow-up to #2100. Don't pause/unpause the audio if we are moving from/to the Control Config or HUD Config screens. We could hit F2 and move around a bit before resuming the game, so we don't want the audio to resume until we're ready.
Collision groups as previously coded were unusable due to Lua 5.1's lack of support for bitwise operators. This fixes that deficiency in two ways:
1) Objects now have the functions `addToCollisionGroup` and `removeFromCollisionGroup`
2) An `evaluateNumericSEXP` function has been added for returning SEXP results as numbers (so that the bitwise SEXP operators can be used)
At least on my system that saved ~25% of the compile time (2:01 to 1:33)
so it appears that this is indeed something that help compile
performance.
Also does some house cleaning by using the new PCH command of CMake if
it is available which reduces our dependencies.
The previous system was kind of hacky and made things a bit inflexible.
This improves that system quite a bit and also adds unit tests for the
hook variable functionality.
With dynamic debris, as soon as the Debris vector was reallocated it invalidated the `prev` and `next` pointers. I figured out how to dispense with the actual list entirely, since we mainly need to know how many hull debris pieces there are and whether an individual piece is on the "list".
This is a follow-up to #2649.
Try and Fix non windows compile errors
Fix Linux complete error(Hopefully)
More Linux fixes
Nearly There
Maybe?
Why were these in the original? They're never used?
Admiral Nelson led me to discover that the HUD gauges expected "right" or no string at all for the gauge alignment. I added basic recognition of LEFT and RIGHT alignment. Someone more familiar with the HUD than me can flesh it out more.
This allows the coder to test for the existence of a hook variable by comparing it to `nil`. The engine will currently error out and crash if you try to access a nonexistent table field, which is useful for catching typos, but has the disadvantage of disallowing a perfectly reasonable Lua coding practice. So this change checks whether the missing field is part of `HookVariables`, and if so, rather than throwing an error, it just prints a message to the log.
This adds full modular table support to mainhall.tbl, allowing subsequent tables to override previous main halls, and enabling use of the +nocreate option.
Several things going on here:
1) refactor `get_display_string()` to `get_display_name()` to be more precise
2) likewise, refactor `alt_name` to `display_name`
3) automatically generate display names when parsing the ship, ship class, and weapon class for the first time
4) remove the on-the-fly truncation of names with hash symbols
Basically this subsumes the `end_string_at_first_hash_symbol` logic into the display name. Rather than truncate the name every time it's displayed, truncate it once when it's parsed. This takes advantage of the previous display name infrastructure, since display names are a superset of the case of truncating the hash symbol.
This also has the benefit of now allowing hash symbols within display names. When updating Destiny of Peace, I noticed that "Lockheed Shuttle #4" would no longer display properly; and it was not previously possible to fix this even with display names.
I could pull out the `get_display_string()` and `alt_name` renaming into a separate PR if desired.
This adds the Vulkan code for choosing a physical device, creating a
logical device from that and then initializing a swap chain.
This also contains code for filling out the graphics API pointers with
stub functions so that the API functions can be developed gradually.
These changes allow FSO to "run" with Vulkan but nothing is rendered
yet.
First, in hudartillery.cpp, change some errors to warnings (actually error_display(1, ...) to error_display(0, ...), but same difference).
Second, change a Warning to an error_display(0, ...), and make it actually name the SSM strike instead of just reporting the name of the weapon it's using.
Third, do the weapon_info_lookup() earlier so we can use error_display() to point to the right line, and tell the modder that an invalid weapon invalidates the entire SSM strike (instead of just silently discarding the whole thing at the end).
Finally, in weapons.cpp, change validate_SSM_entries() to mention if Ssm_info is empty (instead of, say, telling the modder that the index needs to be between 0 and 4294967295—or, rather, -1 expressed as an unsigned 32-bit integer, since Ssm_info.size() - 1 is, indeed, -1 when the vector is empty).
This does two things:
1. Use thin archives which speeds up static library creation by only
storing references to the object files instead of copying them all
2. Allow to use the gold linker with GCC along with an option for
incremental linking. Since this is undesirable for non-development
builds it is disabled by default.
Back in PR #2390, I fixed translation behavior in `lcl_ext_localize_sub` for SCP_string, but neglected to also fix it for `char*`. This PR remedies that.
I also added `!=0` to the string compare to match the `!=0` used with `strcmp`.
Just for sanity's sake. This just displays a Warning without modifying the dockpoint name. I considered an nprintf but figured a Warning was more appropriate.
This can be used for producing even leaner builds for standalone
servers. It also provides a nice architecture verification since now
using internal OpenGL functions will cause a compilation or linking
failure.
These sexps work just like for-counter, supplying arguments for when-argument. They will list all ships that are present in the mission and are of a certain class or type.
This fixes three issues where the Lua stack was not cleaned up properly:
- On hook execution, the return value was left on the stack
- For ADE initialization, the global tables were left on the stack
- In libRocket, a metatable was left on the stack
This allows a script to create its own execution context so that it can
control when a coroutine is valid to play based on custom data.
Also adds a function which causes a coroutine to end in an error.
GCC 10.1.0 complained about the filename overwriting itself in the old version of the code. This was a false positive, but the code wasn't terribly clear, so I cleaned it up a bit.
These variables can be used for changing the behavior of the ade_ API
functions. However, they apply to all the ade_get calls so if there is a
call to ade_get_args from an ade_get_args call then it will reuse the
previously set values and produce incorrect results.
This captures those variables as soon as possible and then resets them
so that subsequent calls start with the default values for those
variables.
This emulates the "scrolling text" effect that is present in briefings.
It is not exactly the same since it just goes pixel wise and not by
character but it looks good enough.
After the multilock PR #2207, ships without secondary weapons will crash the game. This can easily be seen in the very first training mission of the FS2 main campaign, and it is due to an invalid bank access in `ship_stop_secondary_fire`. The `current_secondary_bank` is 0, but there are 0 secondary banks. The Assert catches this, but that's not enough.
This change fixes the crash, as it initializes the current banks to -1 instead of 0. However I'm not familiar with the new multilock way of doing things so I can't say if that is correct in all cases.
The previous API only allowed very limited access to the audio stream
system. These changes add full support for playing all types of audio
streams via a dedicated API.
This allows external libraries to load the Lua API from our executable
even if it is linked statically. This is useful for a Lua debugger which
needs to interact with the Lua API.
This is specifically for OPF_SHIP. Currently if you specify a LuaSEXP with OPF_SHIP, it only works for ships that are present in the mission when the SEXP is called. This is my attempt at a LuaSEXP parameter variant that will return a valid ship name regardless of the ship status. It required a bit of finagling the existing API.
Previously, `ai_link_energy_levels_always` or `ai_link_ammo_levels_maybe` could allow a ship to link weapons even if the `No_primary_linking` flag was setfor that ship. This PR fixes that by added a check for `No_primary_linking` before `ai_link_energy_levels_always` or `ai_link_ammo_levels_maybe` is evaluated.
In most cases you have one group to/from which you are adding or removing several ships, but the existing sexps are designed for one ship and many groups. This adds new sexps designed for one group and many ships.
Leaving the ability to go onto the multi screens will cause undesired behavior and asserts. (like trying to validate the tables when there is no connection in the first place.) Also only sets the game state to multi once we're sure that we're going to enter a multi game.
When I rewrote `strip_comments()` to take quotes into account, I didn't correspondingly update `get_line_num()`. This fixes that. I discovered that a Lua file with a lot of semicolons inside quotes was erroneously getting the past-EOF warning.
Also, in the event that the warning *is* tripped, this exits the loop instead of repeatedly displaying the warning.
Team Leader function was returning 0 instead of 1 when the team captain was messaging AI.
This optimizes, cleans up, and gets rid of edge-case buggy behaviour. Thank you ship_registry!
For older campaigns which used show-subtitle, the eval_num conversion inadvertently changed the rgb to default to 0, instead of 255. This restores the default to 255.
1) Upgrade the pilot file code to correctly save flags whether entries are added *or* removed
2) Make the tech-db/tech-db-multi ship flag handling consistent
3) Add scripting support for intel entries
4) Add scripting support for adding and removing entries from the tech room
5) Minor cleanup
The functions derived from `vm_vec_mag_quick` run *slower* than `vm_vec_mag`, according to @Baezon who did some testing. So this PR makes all calls to the _quick functions use their more accurate counterparts.
1) Write all non-UTF-8 strings to JSON, either by converting or truncating
2) Add `coerce_to_utf8` function
3) Tweak `read_raw_file_text` because the function returns length on success, not 0
This was a fun one. Volition used a bizarre and very poorly named "flag" static variable to track iterations through the `verify_and_fix_arguments` function. I'm not sure how this actually works, but on comparing with the original public source code I see that @asarium didn't quite fix the "declaration masks class variable" compiler warning the right way. This rolls back that 2016 change and fixes it properly.
The effect of this fix is so that FRED will correctly handle arguments when node data types change, such as when the modify-variable argument is changed from a numeric variable to a string variable.
The #2528 fix broke ships destroyed before mission start because their arrival delay was *already* set up (as a bogus timestamp). So this change adds a special exception for that.
Properly whacks all ships that are docked together when any are whacked, makes everything more consistent by calling ship_apply_whack instead of physics_apply_whack, whacking in general now unrotates its hit pos to get a world pos like physics whack was expecting and adds a few matrix helper functions.
Standalones would crash if they had an error dialog pop up because of a nullptr. This just checks for the nullptr and returns early to prevent the crash.
There was an AI class validity check for the pilot, but not for turret weapons. This fixes that.
Also, the p_object parameter to this functino was named `objp`, which is misleading because that's usually used for object. I renamed it p_objp.
This just uses vm_vec_normalize_safe. If two objects spawn on top of each other, the code will now sort them properly without printing a null vec3d warning.
FRED's handling of mission loading and creation is a bit wonky. The `stars_post_level_init()` function should run for each new mission, not just once when FRED is started. That fixes a background editor crash and I also did a bit of other cleanup.
This adds a "clear-debris" SEXP with a new system for declaring SEXPs
outside of sexp.cpp. This makes it easier to keep code modules self
contained since they do not need to export previously private
functionality just for having missiong being able to interface with it.
This is mostly a proof-of-concept which only supports basic parameter
types (booleans and integers).
The ship registry previously stored the ship name as a pointer, but that pointer was reused when subsequent waves of a wing overwrote a p_object from the first wave. So, the name is now copied into an array.
Additionally, subsequent waves of a wing are now "eagerly" stored in the ship registry so that the p_object reference can be stored as well.
For quite some time missions have had the ability to edit more than one background. This was previously used for fallback loading in case the first background's bitmaps were not available, but I realized it would be very handy to allow switching between backgrounds for in-mission jumps.
The FRED background dialog can now add and remove backgrounds from the list. Additionally, a new `change-background` sexp can instantly switch between backgrounds without messing around with bitmap references.
Tracked down another Volition bug, first reported by recead. When messages do not have the ": " substring (which only happens when they are from MSG_SOURCE_NONE), they would calculate the wrong string size. This is because the two-character offset was added to the pointer *before* the pointer was checked for null, and so non-matches were considered matches with strings beginning at memory offset 2.
Volition's arrival code used eager evaluation of arrival cues even before the mission was finished parsing. With the new sexp optimization code, this can fail because the sexps can depend on ships which are not even parsed yet and thus are not in the ship registry. So I moved the arrival_delay initialization and added some comprehensive comments explaining what is going on.
1) Prevent ships from turning in `ai_turn_towards_vector` if they have the `immobile` flag. This was missed because it is a rotation that doesn't originate in `obj_move_call_physics`.
2) Prevent ships from evading shockwaves if they're playing dead.
Also there is a small conversion of an int to a bool.
The cause of the #2512 bug was using the new main hall to look up sounds from the old main hall, which would crash in several cases. The lookup was performed when testing whether or not to truncate a door sound when changing screens or states. Dan Wentz requested that "glowy" sounds not be truncated, so this preserves that check. Rather than test the indexes of the door regions, this tests the indexes of the sounds in sounds.tbl.
Right now the retail sound indexes are hard-coded, but it would be easy to make this configurable from mainhall.tbl if modders wanted that ability.
This fixes#2512.
The ship table value `+Weapon Min Range:` was ever used for turret firing calculations. This PR adds it as part of the cacluation for other instances, but only if the AI flag `Use_actual_primary_range` is used.
Previously a ship's shields and weapon regeneration per second rates were only stored in the ship_info strut, thus they should not be changed during a mission or via scripting (see #2236 and and #2239). There are many precedents for taking a ship_info value ans copying it to a ship_object value so the value can be changed on a per ship basis in mission (auto aim FOV is one of many examples). This PR thus copies the shield and weapon recharge values to the ship_object and exposes those new values to scripting.
1) Something wookieejedi noticed: destroying all turrets didn't trigger the DISARMED mission log event. This is because a code ordering decision intended to accommodate the destroyed check caused the hitpoints to not be correct when they were checked within `do_subobj_destroyed_stuff`. Instead I changed the blow-up check to use the same code for set-strength as for sabotage-strength. This handles destruction properly and also tracks hitpoints properly.
2) Aggregate points were being recalculated for every subsystem operation where they only needed to be recalculated at the end of the sexp, so I moved that.
Many physics values are exposed to scripting, including rotational damp. This PR exposes the linear damp to scripting. Note that in the code the linear damp is called `side_slip_time_const`.
This adds access to the command briefing data parsed from the mission
file to the scripting API so it can be used by the UI scripts for the
high res UI.
Also switches the animation support to using the generic anim to use
streaming to improve performance.
Fix the waypoints-done-delay sexp to work for both ships and wings.
Also, fix the set-object-speed sexp (which is deprecated anyhow) to work for all ships in a wing, not just the wing leader.
Previously, the default distance for determining if a ship had finished a point in a model path was only 5. This worked fine for ships with low damp or no Newtonian physics. However, it did not work well with ships that use higher damps or Newtonian physics, becuase those ships contiunatlly overshoot that 5 meter distance and get stuck flying in a large circle trying to reach that point. This fix allows modders to set an AI flag to specify that the path distance check uses a larger value of 775 for points that are not the last point in the path. If desired I can add a game settings option that allows modders to set this value.
I added a pretty generic container structure for the scripting
documentation when adding JSON output. However, I did not use that new
structure for the HTML output since that was just too much work.
This moves the HTML output over to the new structure so now the
scripting API handling code is independent from how the resulting
documentation is generated. I also moved that code out of the main
scripting code which removes quite a lot of clutter in those files.
This is mostly a straight port of the old code with no significant
changes (except the changes to make it use the new data).
As noticed in issue #2458, intercom sounds did not stop when pausing the game or loading a mission. I fixed this by augmenting `main_hall_stop_ambient()` to also stop the intercom.
Additionally, it turns out that the intercom delays were not being calculated correctly due to a very bizarre random number formula. I overloaded `rand32()` to add a min/max variant and used this instead.
When special arguments are used, the current node cannot be cached because it always contains "<argument>". So this feature adds the ability to forward the caching to the SEXP node that contains the value being referenced. To enable this, the internal argument list now contains both the argument text and the node being referenced. (If there is no node to reference, such as with `for-counter`, the reference will be -1.)
This adds an Antlr grammar for parsing argument lists instead of using a
hand written parser. This allows to write much more complicated syntax
constructs and have all the code being auto-generated. It will also
produce a much more correct parser instead of having all those hacks in
the hand-written one.
This also adds (in addition to supporting the previous syntax) support
for function types along with support for them in HTML and JSON output
formats.
The ANTLR generated parser is included in source form so that it is not
necessary to have an ANTLR installation around if you are not going to
change the grammar. Also includes the necessary runtime code from Antlr.
If a standalone has only one player connected in a dogfight mission it will crash. Not fully sure why this doesn't crash in other circumstances, but this check should just be here, anyway.
This is a follow-up to PR #2373. Tomimaki noticed that the first character was truncated in the cutscene description, and it turned out that the algorithm was slightly wrong.
Retail has a hud_find_target_distance function that returns the distance between the player position and a bounding box. This is useful for the HUD because it shows the distance to the perimeter of an object like a jump node or a large ship. However, this function was re-used for the `distance` SEXP, resulting in the awkward situation where the distance is measured from one ship's center to another ship's bounding box. This can lead to unexpected results and it also means that the SEXP returns a different distance when the arguments are swapped.
This PR deprecates the original SEXP and introduces the new SEXPs `center-distance` and `bbox-distance` which use consistent methods for both ships. It also renames the `distance-ship-subystem` SEXP to `center-distance-subsystem` and adds a new `bbox-distance-subsystem` SEXP.
Another - hopefully bite-size - sexp upgrade stage. This takes the objective SEXPs (those which are primarily concerned with the mission log) and upgrades them to use the ship registry.
This adds a mechanism for running generic operations at specific points
of the frame execution. This can be used by any part of the code an not
just Lua since it simply executes std::functions. It also adds an
"execution context" concept that specifies in which situation an
operation should be executed.
This is then used by the Lua Coroutines code for resuming coroutines at
specific points instead of always when the awaited promise resolves.
This PR upgrades the function, and the sexps that use it, to take advantage of the new sexp caching. It also makes `script_eval_multi` more robust in the face of players who might be respawning.
This adds a simple parser that takes the existing argument
documentations and parses them so that better documentation can be
generated from that information. This should be sufficient for providing
proper documentation generation for the most common and simple cases of
argument lists (type, name, possible default value, and optional
groups).
This will ensure that Lua functions will always be executed in the
correct Lua state. Since we now have multiple threads (which are
different lua_State objects) it is possible that the current code could
execute a Lua function in the main state instead of the thread that is
currently executing. This can lead to weird behavior and probably also
to issues inside Lua.
This can be used by Lua code to trace the runtime of their code in the
same way the engine already is capable of doing for most in-mission and
mission loading code.
Also adds some tracing scopes to the libRocket code
There is a slight discontinuity where ships that are destroyed have their mission log entries added a bit before `ship_cleanup` is called. This addresses that.
This removes `readability-avoid-const-params-in-decls` from the list of things clang checks. Function declarations and headers should be the same, so it makes no sense to warn about `const` in one but not the other.
This also alphabetizes the exceptions for easier reading.
Previosuly, using the script function ArmorClass did not properly display the actual armor class, instead it always displayed -1. This PR fixes that. I have tested these changes and they now proprely display the armor class.
This PR uses `eval_ship` and `eval_wing` to optimize `object_ship_wing_point_team` and `sexp_deal_with_ship_flags`. The API changed a bit, but to ensure compatibility, there are fields and functions to support the old behavior. These are temporary and will be removed when all changes have been merged via PRs.
This PR fixes the logic for setting weapon amounts for both the pilot and subsystems of a ship. Previoisly in #PR 2318 this distinction was not checked, so this PR properly adds that check and distinction.
This makes the necessary campaign room API available to the scripting
API so that it can be implemented using libRocket. Also adds an
engine.sleep function which I needed for making my Lua debugger work
reliably.
This is part of the ongoing sexp overhaul relating to performance and caching. This PR combines functions for several sexps that are very similar, and it also uses the `eval_ship` speedy lookup function. As a bonus, it allows `turret-tagged-only` and `turret-tagged-clear` to run for multiple ships at a time.
The `special_argument_appears_in_sexp_tree` function can run multiple times per event, especially for repeating events, so it's a good idea to cache the result. This avoids the need to iterate through potentially the entire tree, checking every single node.
Awhile back, the get_operator_const and get_operator_index functions were enhanced to cache the result of the operator lookup. But this only works when called on the node itself, not the text. So let's call these functions on the node whenever possible.
If you press a key such as Ctrl the code gets a bitfield with a high bit
set so when the key code is used as an index it produces an out of range
error.
Thank you AddressSanitizer!
This adds a Lua API for representing asynchronous operations and running
coroutines based on those operations comfortably. This is very similar
to features other languages have introduced such as C# or JavaScript. In
fact, the whole "promise" thing is derived from how JavaScript
represents these operations.
This is the initial and very basic system for supporting async
coroutines in Lua. There is no native support for running these
operations at specific points (they run whenever the awaited promise
resolved) or making sure they do not leak through different game states.
In PR #2318, I consolidated the code a little too much. The partial-loadout checks should not have been under the `SUBSYS_STATUS_NO_CHANGE` check, because this would cause partial loadouts to fail if the percentage was adjusted but the actual weapon in the loadout was not changed.
Thanks to @wookieejedi for spotting this bug.
This is a minor follow-up to PR #2390. There are a few minor differences between untranslated strings and the internal strings in strings.tbl; this PR fixes them.
Previously the scripting call `gr.drawOffscreenIndicator` did not properly draw the indicator and/or return coordinates. After some bug hunting it turns out it is because there gauge was not being set to active. This PR adds that line and retores the intended functionality. Tested and works as expected.
If ever there were more than 100 goal targets in a mission, the old version of ai_get_goal_target_name would start corrupting memory. Rather than making a hacky workaround, this just makes it dynamic.
These issues caused the stats packet to keep growing during
every conversion between network and game structs causing
memory issues and data corruption. These bugs were hidden by
the fact that stats packets were discarded by the server due
to another bug.
This code is highly inefficient (find_parent_operator() is O(n) for Num_sexp_nodes, and it runs every frame for all sexps with negative values) and should not actually be necessary. But it is useful as a debug tool, so I added some #ifdef's.
This enables the clang readability checks that I found to be sensible. I
disabled a few that would have caused a lot of unnecessary warnings in
our code.
This PR allows the setting `Guards Attack This` in `objecttype.tbl` to actually work.
Background: there are two instances in the code where AI that is patrolloing/guarding a ship decideds to go attack guardees attacker. One case is if the guardee is hit, and the other case if there are just hostile ships present (ie it scans the mission every so often).
The `Guards Attack This` check was only applied to the scna the mission case, and not the guardee hit case. Thus if the guardee was hit by a ship that had the `Guards Attack This` setting off, the guard would still attack since that check was never being performed for that guard case. By default all object types hae `Guards Attack This` set to `true.` But if a modder didn't want fighters guarding a ship to go off and try to kill a large captial ship then they may think setting this value would be a good way to do that. Unforunately this wouldn't work, for the reasons outlined above.
Chnage: this PR adds the `Guards Attack This` check into the guardee is hit case, estentally making the behavior work as expected by a modder. Given this is a AI behavior change I have added an optional AI flag to toggle this fix on. I have tested this and it works as expected.
Since the original release of FS2, internal strings have been translated to their English entries in strings.tbl but external strings have not been translated to their English entries in tstrings.tbl. It appears that string translation was universal until it was disabled via a hack, probably due to FRED idiosyncrasies (see comment in `fred_init()`), and then not re-enabled for release. PR #2343 re-enabled it, but this turned out to have undesirable side-effects since many mods used incorrect XSTR indexes for external strings.
This PR restores the previous behavior and also cleanly separates localization into translated and untranslated modes. FRED will always run in untranslated mode. FSO will run in translated mode for all languages except English, where it will run in untranslated mode UNLESS the new option `$Use tabled strings for the default language` is enabled in game_settings.tbl.
The ship goals dialog was incorrectly assigning a goal target name for every dockpoint, which could quickly cause the limit to be exceeded if the FREDder browsed a lot of dockpoints.
This also indicates a need to fix the goal target name system as the counter is never decremented. That will be in a subsequent PR.
Having recalled that other SCP folks stated pow shoud not be used to do simple squaring, I figured it might be a good idea to update the two instances I found where that was the case.
This PR adds a scripting hook which triggers when a ship begins it's departure process. It has one variable that is the ship. I have tested and it works as expected. This new hook is very useful for triggering events whenever a ship needs an alteration to it's departure methods. For example, in Fate of the Galaxy we require ships to warp out along a certain vector. This hook allows us to see when the ship is begining that depature and then break the ship's warp, order the ship to instead follow a waypoint path, and then jump out.
This PR adds a scripting hook which triggers when the pain flash is shown. It has one variable that lists what type of flash was shown, shield with `Pain_Type == 0` and hull with `Pain_Type == 1` . I have tested and it works as expected.
The sexps that activate and deactive glowmaps are very useful for ships, though previously the glowmap status was not passed to the ship's cockpit. This PR adds the ability for glowmap status to carry to this ship's cockpit (if it has one).
Previously if a ship's glowmaps were deactivated via sexp, then the glowmaps would reaactivie at the ship's final explosinos. This PR fixes that by carrying that flag into the ship explosion FX code.
This adds the capability to have a Lua script that does not need to use
our table syntax at all but instead defines the hooks by calling API
functions. This also makes it possible to add hook functions at runtime
if the script requires that.
Also clean up some unused debug stuff.
Due to code rot, the support ship hull repair code was a bit more tangled than it should have been, so I tidied it up. I also fixed a bug Sarn noticed where a support ship would think all subsystems were repaired if the hull repair rate was set to 0.
As noticed in Discord, in loop1-2 some of your wingmen have missing weapons, but as the ships are locked it's impossible for the player to modify them. These ships should not be part of the check.
This is a pretty easy fix; sorry it took seven years!
Instead of firing an Int3() when a ship has no arrival paths, just log it and continue. And change the upstream warnings, which should have been more visible, from WarningEx to Warning.
Certain mods provide their own tstrings.tbl, but this runs into trouble when you localize data meant for one mod using a tstrings.tbl meant for another mod. See the Mantis ticket:
http://scp.indiegames.us/mantis/view.php?id=2942
and also the HLP post:
http://www.hard-light.net/forums/index.php?topic=85041.msg1716600#msg1716600
This PR adds an optional flag that will check the untranslated string against the "default language" translated string. The two strings should be identical. If they aren't, the code assumes there is a tstrings.tbl mismatch.
I modified the mission listing code to enable this check when localizing mission info (titles and descriptions), and to avoid adding the mission to the list if there is a mismatch. Fortunately, I think mission listing is the only place where this bug is likely to happen.
Currently `$Closeup_Pos:` and `$Closeup_Zoom:` control the camera zoom and position values for the techroom, briefing and HUD Target Box. Unfortunately, with very large ships this results in an issue, to fit the view of an entire big ship in the HUD Target Box the zoom and position must be set a certain way which results in the ship looking very far away when viewed in the techroom. This PR adds two new fields that control camera postion and zoom but only for the HUD Target Box, thus modders can now set values for both and have the ships look good in both the Techroom and HUD Target Box. The new hud target box values are optional, and if not specifed they default to the values for `$Closeup_Pos:` and `$Closeup_Zoom:` .
From the comments:
// Do some checks to see if we are actually going to play this message at all. These checks have been moved above the
// "if ( Num_messages_playing )" block because we don't want to cancel an existing message if we have nothing to replace it with.
Additionally, by not incrementing `Num_playing_messages` if the code skips to `all_done`, this prevents messages that aren't playing from delaying messages in the queue that are actually valid and should play.
This adds an ai_profiles flag that checks comm systems for non-player ships. If their comm system is damaged, they will not send messages and you will not be able to issue squadmsg orders.
See also:
http://scp.indiegames.us/mantis/view.php?id=1947
This updates #2299 and restores the use of `event_music_level_start(-1)` in `freespace.cpp`. This call was removed in #2299 because it was thought to be redundant but removal of that call resulted in music not playing upon mission restarts. This PR restores that call and fixes that issue.
This is in response to Mantis 1424:
http://scp.indiegames.us/mantis/view.php?id=1424
Since retail, the hotkey lists have been determined based on what attacks the player. Mod makers may want to change this, so this PR adds the following options:
Default - retail behavior
Friendly/Enemy (or Hostile) - display in the specified list regardless of who attacks whom
None - don't display in the hotkey list at all
This PR also slightly cleans up the hotkey list function with a small optimization and a few tweaky fixes for edge cases.
This adds the titular feature, as well as FRED support. There are also some associated minor UI fixes in FRED and some cleanup in missiongoals.cpp. And "Event Flags" are now a thing in case we want to add any other flags in the future.
Ships which do not have the maximum number of primary and secondary banks (3 and 4) will have gaps in the loadout slots, so be sure to only check the weapon slots that the ship class is actually equipped with.
Yet another obscure edge case from Aftermath: Reboot. The FREDder ought not to create this situation in the first place, but if he does, don't enter an endless loop.
In the SEXP parser, zero-length strings are valid, as are zero-length operators. But zero-length numbers are interpreted as missing arguments, since their only syntactic separators are spaces and the parser skips over whitespace. And in any case, zero-length numbers are not semantically valid anyway. This PR adds a sanity check to intercept all zero-length numbers, as well as malformed numbers, and convert them to 0.
This fixes issue #2314.
There is a special function, `hud_find_target_distance`, which is used in most places for target distance. However it wasn't used for jump nodes in this location.
Incidentally, the player's target's distance is cached, and this distance will always be current for the target box, so we can use the cached value and save a function call.
This moves towards defining the hooks in the code module that executes
them. Also provides the API necessary for better documentation of hooks.
This only covers a few hooks as a test and demonstration of the new API.
If no issues are found with this it can be extended in the future.
This is the best way to address Mantis 2715. I took a look at allowing empty banks in the course of working on PR #2318, and it was completely intractable. But in order to prevent certain "funnies" such as violation of bank restrictions, it's a good idea to ensure all banks are populated.
This PR adds a new XSTR for a popup message, and incidentally adds another XSTR to a message that should have had one already but didn't.
If ships have less than their full allocation of weapons, the code is supposed to compact the array so that these weapons all appear at the beginning. This is done for small ships (fighters and bombers), but was not done for capital ships. There was also a lot of code duplication with small ships getting extra error checking than capital ships. This commit removes the duplicate code, makes the error checking more robust, and incidentally fixes the weapon array compacting for capital ships.
Although not used very often, ai_info.target_signature should be set to -1 whenever no target is specified, just like everywhere else to make sure that the code is as predictable as possible.
(Found while trying to figure out why the heck would the Object update packet send this at all??)
This PR refactors the function's name to something more indicative of what it actually does, and removes a call made to it from within freespace.cpp which, due to changes in how the soundtrack system works, is now redundant and doesn't actually do anything anymore.
The sound was passed the data from before the resampling took place so
it though it would be playing a stereo sound and rightly cause an
assertion. This fixes that by refreshing the properties after appliying
the resampling properties.
PR #1514 made this change to avoid having to constantly update fred.rc with new FSO versions, but it was inadvertently reverted in commit 9ac97f24223a7446d4364acfdb451c90697d6577; this also reverts PR #2286, since that's a somewhat more hackish solution to the same problem.
This does some refactoring to make it possible to cimpile and run FSO
without needing to link to FFmpeg. Since that eliminates support for
cutscenes or sound this is mostly useful for running a standalone server
which has no need for this anyway.
This reduces the image size of the standalone Docker image to only 20MB
and also resolves any licensing issues that might have existed.
The standalone did not initialize SDL and so did not receive the quit
signal when it was sent SIGTERM or SIGINT. This fixes that by making the
standalone server just use the normal os initialization code.
Also includes some other code cleanup and some more logging to make it
more apparent in the log what is currently happening at standalone
startup.
This adds a Dockerfile which compiles FSO for the alpine Linux
distribution and then creates a standalone image based on those
binaries. That sidesteps the problem that existed with trying to use the
AppImage binaries on that distribution.
This produces a much smaller image (78MB instead of 230MB) so it should
be a bit more managable. Building can be done like this:
docker build --build-arg build_type=FastDebug -t scpfs2open/fso-standalone -f docker/standalone/Dockerfile .
This mostly meant for special docker standalone server builds where it
might be useful to have full release performance but also have the logs
available if necessary. This now always compiles the log statements but
enables or disables them with a constexpr so they should not appear in
actual release binaries.
This will provide a proper error message when such a function is called
that will mention the name of the function and that it is deprecated and
cannot be used anymore in the targetted engine version.
This will make it easier to get logs from FSO running in a docker
container since logging to stdout is the easiest solution there.
Also includes some other changes that will make this work better in
Docker containers.
If anything less than or equal to 0 was specified it would trigger some
kind of an assert in the standard library since that is not a valid
value for a normal distribution. Now a parse warning is generated and a
safe default value is used.
This fixes#2269.
This adds a new graphics type for the Vulkan graphics API. All this does
is to create a vulkan instance and a presentation surface with the help
of SDL.
The largest new feature is that it is now possible to include other
files into the RML by using the "include" tag. This is useful for making
markup files more modular.
Also added some more options for existing things (e.g. built-in detail
options).
This elimiates all of the remaining "old style" uniforms from our
shaders. This might not be optimal for all situations but I have
confirmed that it is at least not worse at the moment.
This is a generic way to get matrix data to shaders without using
(old-school) uniforms. This is another step towards more compatibility
with how new APIs (Vulkan) do things to increase the odds for a Vulkan
port at some point.
It seems that when RTT for cockpits was added that the scaling of ships in the target box fell through the cracks. Properly specifying the `clip_aspect` fixes the issue. This PR fixes issue #2250.
Weapon names with a `#` should not display text after that `#` in the HUD. For the most part this works, but there were a few cases this didn't (such as primaries using the weapon name). This PR fixes two spots that fell between the cracks.
Previously, Engine Wash Intensity didn't actually do anything in the code. This adds a game table setting that let's modders specify to the game to actually take the intensity value into account when calculating engine wash effects.
For some reason my repro had some critical issues and I was unable to comitt to the PR #2210. I have closed that PR and opened this one given the discussion in #2210. The result of that discussion was `but omit line 594`. That is what this PR does.
Three main changes in this PR:
1) The enums for the "easy settings" launcher options are now clearer and more explicit, and the enum assignments for a lot of graphics options are now fixed, as they were incorrect due to code rot.
2) Some of the command-line flags options have been recategorized: -window, -fullscreen_window, -nomotiondebris and -noscalevid are now Gameplay; and -fps is now HUD.
3) Since post-processing is required for nebula fading, it now defaults to on, and the flag has been changed to -no_post_process.
Persistent buffer mapping is an OpenGL technique where the contents of a
buffer object are mapped to a persistent pointer instead of having to
map and unmap a buffer every time it is modified.
This decreases the overhead for updating data in a uniform buffer object
which now only consists of a memcpy and a flush call.
This is in preparation for using persistently mapped buffers for uniform
buffers. Since that functionality is not available in the OpenGL version
we are targetting I implemented a fall-back which simply uses
glBufferSubData.
I did a benchmark with these changes and there was no change in
performance to the current master version.
error_display shows the line where the error was detected. Warning
itself is pretty useless for parsing related errors so I replaced all
Warnings (where appropriate) with an equivalent error_display.
Does this by refactoring how the timing is calculated. It also removes the Next Arrival Time Array, which does not actually do a good job of calculating it, anyway. We can now rely on the other oo_arrive_time arrays exclusively by subtracting from current time.
Squashed Commits:
1. Use function to pull FrametimeOverall to keep from breaking Fred.
2. Remove unsed parameter from multi_oo_calc_interp_splines
3. And also fix the corresponding declarations and functions calls.
In aiturret.cpp there is a mprintf, `mprintf(("nothing ok to fire\n"));` which greatly pollutes the debug log in missions with turreted ships. I'm not sure what this message helps debug, thus I propose commenting it out.
Previously, using max and min delays resulted in guns firing that were not within the specified range. This PR fixes that while also simplfying the code. `frand_range` is already using in each of those functions so I figured it would be fine to use it and also simplify the code. That, instead of `next_fire_delay = (((float)rand()) / (((float)RAND_MAX + 1.0f) * (winfo_p->max_delay - winfo_p->min_delay + 1.0f) + winfo_p->min_delay))`.
These function have been around since retail. What they were supposed to do was allow the V team to get a baseline of how much data object updating would use without the limiting system.
However, the way that multi_rate_add work, is that they say to the limting system, "The client is getting a lot of data, so limit it some more." And that eventually causes debug build object updates to slow to a crawl.
This PR tidies up the comments in the initial velocity setting, properly sets the player's throttle, and cleans up issues with initial velocity setting and hyperspace warpin types.
Note the removed code block for hyperspace warpin ending was removed becuase it is not needed, as physics calculatios already handles that. Also the calculations that were there did not properly account for initial ship velocity setting.
A few early on descriptions in this file are inconsistent or even plain wrong. This should correct that.
Also, rename vm_vec_imag() to vm_vec_inv_mag_quick() to better describe what it is.
It turns out that the code that set initial ship velocities did not account for local ship rotation changes. This bug is only noticeable when ships are very high speeds, high initial velocities, and have high drift values thus it was never recognized before. This PR fixes that by ensuring that the velocity vectors are set appropriately. As discussed with Goober on Discord, this fixed behaviour is indistingushable when using FS ships and most mods, this the behavipur will be on by default.
This was previously using the wrong direction of the conversion so it
produced wrong values. This should fix that and should hopefully bring
the nebula experience back to how it is supposed to look.
When the `+Max Delay:` and `+Min Delay` for `Fire Wait` were added they were only added to primary firing and not turret firing. Specifically, `turret_set_next_fire_timestamp` uses only `winfo_p->fire_wait` while `ship_fire_primary` uses the delays. Checking with the original author DahBlount they specified it was an oversight, thus this PR fixes that and allows the delays to now work properly with turret firerates.
Overview: This PR restores all expected functionalility of the 3D weapon select flag while also providing modders with a way to use both 3D models and custom weapon icons.
PR #2055 provided a way for modders to use 3D weapons while still using specified weapon icons. Unfortunately that resulted in weapon icons not changing to an image of the 3D model when the 3d weapon selection flag was used. It was requested on the forum that this behaviour be restored. This PR restores that behaviour while still allowing modders to use 3D weapon models and their own weapon icons. Instead of the approach taken in PR #2055, this PR will automatically show a 3D weapon model if there is not weapon animation specified and if a weapon tech model is specified. Thus, if a modder wants to use their custom weapon icon but also have a 3D weapon model shown, they simply do not specify a model animation but do specify a tech model for the weapon (the 3d weapon selection flag does not need to be checked). If the 3d weapon selection flag is checked then the 3D weapon model will of course still be used, but the weapon icons will now show the image of the 3D model instead of any custom weapon icons the modder specified. In other words, the flag acts exactly as expected for the player.
I also tested this for each case and it works as desribed above.
Should fix rare multi crash where reserving net signatures for spawened munitions would cause an ushort overflow, triggering an assert in multi_set_network_signature.
Turns out we can just remove the assert, and just guarantee that signature is going to be in the required range.
Squash history:
1. Improve Assertions (as per Taylor's suggestion) and reconfigure Int3
2. Wording change on last assertion
Any server build created this year will crash any client connected to it because it will send a packet cotaining hull updating information, but accidentally unset the flag for new hull info. The client was therefore unaligned with the packet, causing the local subsystem_update array to go bonkers.
Removes about half of the Int3()'s in multiutil.cpp by making Assertions more robust, changing two functions to void type (because there was no way to get an error value from them, anyway), and adding two Verify()'s in case we ever decide to start using the multi variable change functions.
Squash History:
1) Forgot to change one Assert to Assertion
2) Change Verify to Assertion, because of better argument support.
3) Fix a couple copy paste errors
Just a quick PR to make multiutil slightly more readable by removing one unused function (whose functionality is already in the object update packet), two globals which we only increment and we do nothing with, and some defines that have been commented out because the size returned can actually vary.
2019-12-25 22:06:38 -05:00
1276 changed files with 184762 additions and 37120 deletions
- With this release we decided to drop the "`3.Major_revision.Minor_revision`" versioning scheme in favor of a year based scheme since the Major and Minor versions did not have much meaning anymore. Instead the scheme will now be "`<year>.<number that is incremented every release>.0`". The last 0 is still there because some of our systems expect that. It will be gone at some point.
### Added
@@ -21,6 +21,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
- Model uniforms get sent to the GPU using uniform buffers for less overhead
- Various other minor changes
- Converted pilot files from custom binary format to JSON
- Replaced Blinn-Phong BRDF with GGX BRDF
### Fixed
- Refactored bitmap slot handling and removed the fixed upper limit on the number of bitmaps. No more bmpman corruption!
set_flag(profile,"$use actual primary range:",AI::Profile_Flags::Use_actual_primary_range);
if(optional_string("$override radius for subsystem path points:")){
intpath_radii;
stuff_int(&path_radii);
if(path_radii>=Minimum_subsystem_path_pt_dist){
profile->subsystem_path_radii=path_radii;
}else{
mprintf(("Warning: \"$override radius for subsystem path points:\" should be >= %i (read %i). Value will not be used. ",Minimum_subsystem_path_pt_dist,path_radii));
}
}
set_flag(profile,"$use POF radius for subsystem path points:",AI::Profile_Flags::Use_subsystem_path_point_radii);
File diff suppressed because it is too large.
Load diff
Loaded 100 of 1276 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
asarium