* Add custom data to ship tables
* add index check to shipclass.cpp
* fix hasCustomData name to use the proper casing
* Add custom data to weapon tables
* Add validity checks and remove superfluous empty check
* Attempt to appease clang-tidy
* Use F_RAW as recommended by @BMagnu
* Creates a function to parse maps and uses it in ship.cpp and weapons.cpp
* another attempt to appease clang-tidy
* Remove superfluous using
* Small style and grammar fixes
* Accidentally forgot this change. Rename 'delimiter' to 'end_marker'
The old XSTR parsing code was a bit of a mess and did not even properly enforce its format. These new routines enforce the actual XSTR format and warn when it is malformed, which is helpful for catching table errors as early as possible. This fixes#3627 and also catches mismatched quotes and other common XSTR errors. No more wondering why comments are being mysteriously parsed instead of ignored!
When an empty string is encountered in the weapon list, it's valid, but the -1 should actually be stored, not skipped.
This bug was preventing ship weapons from being explicitly set to None.
* wip
* basics are working
* turret case is handled
* better fighter beam handling
* missing commit?
* handle missile spawn
* clean up, commenting and ssb handling
* random in sphere and per burst rot counts for "share random" flag
* clean up, clarity and comments
* accidental whitespace changes
* bugfix
* NULL -> nullptr
* more efficiency/clarity
* review tweaks and bugfixes
Here's a bug that's been around ever since version 3.6. If the subsystem names were not essentially the same, the function wouldn't do the expected string comparison.
Commit 6c2ebab01c (#3439) added a `max_line_length` argument to `split_str()`, but one call had the extra argument added in the wrong spot, and so a previously-pointless-but-harmless `ignored_char` of 0 became a `max_line_length` of 0, resulting (ultimately) in an exception in the unicode code when the iterator tried to decrement at the beginning of a ship's description. This gets rid of the argument entirely, rather than reordering them, because ignoring null characters doesn't really do anything anyway.
I've also added `Assertion`s to check `max_line_length` that should prevent this specific problem from occurring again in the future.
* Added a byte limit for line length in split function
* Fix call error
* Ádd missing limits import
* Change hardcoded values into defines
* Cleanup default argument
#3271 changed the logic of `stuff_token_list()` in such a way that the supplied index being used to access an array was no longer skipped if it was invalid; naturally, this means that this warning was now being inevitably followed up by an out-of-bounds array access. Adding a `!skip_this_entry` check should hopefully fix the problem while still allowing the loadout count parsing code below it to run, which was presumably the reason the `continue` statement was replaced with the `skip_this_entry` variable in the first place. Fixes#3405.
This moves the ## to # escape sequence logic from `mission_process_alt_types` to its own function where it can be used elsewhere (such as for ship class and weapon class display names that need to do the same thing). Also, this introduces a !! escape sequence for exclamation points that is needed for exclamation points to be used in scripts, as @naomimyselfandi pointed out.
Consolidate all the functions which parse lists of data. They're almost the same except for the data itself, so use templates.
As for the templated function which handles the list, boost the robustness by adding additional checking and error messages.
This refactors the tolower/toupper code to use standards-conformant logic, and also adds some helpful utility functions. Regular tolower/toupper must be supplied a value that can be represented as `unsigned char`, but the std:: functions are a bit more robust.
One small detail that was overlooked in PR #3021... KeldorKatarn's old code used `strtod` while the new code used `stuff_float`. This wouldn't be a problem except that a couple MVP models use annoyingly formatted floats like 8.9e-08. So I decided to convert `stuff_float` to use `strtof` and do some more upgrades while I was at it.
For compatibility purposes some mods want alt names to truncate at the hash symbol. But we can't actually do that at mission load,
since we have to save them again in FRED. So this commit processes the names just before the mission starts.
To further complicate things, some mods actually want the hash to be displayed. So this commit introduces the double-hash as an escape sequence for a single hash.
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)
```
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.
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 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.
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.
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.
This bug has been around since the original public source code release!
The error message character calculation did not agree with the actual error check. This PR fixes that. Thanks to Novachen on Discord for discovering this.
This can be used for mark parts of the code which should be unreachable
in normal execution. In debug mode, if such a statement is reached an
Error dialog is shown which aborts the execution. In release mode the
macro is replaced with a compiler specific expression that lets the
compiler know that this part is unreachable which allows it to optimize
the code better.
The code did not account for unicode escape sequences when inserting
scrambling characters which distorted the text and fequently caused
invalid UTF-8 sequences to appear in the text. This fixes that by
using the text iterators already present in the game code. I needed to
rewrite the logic of this block a bit since the previous logic could not
be converted to the way we need to handle unicode sequences at the
moment.
This fixes#1720.
Kiloku