mpo
/
VVVVVV
mirror of https://github.com/TerryCavanagh/VVVVVV.git
1
0
Fork 0
Code Issues Releases Wiki Activity
VVVVVV/desktop_version/src/Script.cpp

3622 lines
120 KiB
C++
Raw Normal View History

Clean up and prevent unnecessary qualifiers to self By "unnecessary qualifiers to self", I mean something like using the 'game.' qualifier for a variable on the Game class when you're inside a function on the Game class itself. This patch is to enforce consistency as most of the code doesn't have these unnecessary qualifiers. To prevent further unnecessary qualifiers to self, I made it so the extern in each header file can be omitted by using a define. That way, if someone writes something referring to 'game.' on a Game function, there will be a compile error. However, if you really need to have a reference to the global name, and you're within the same .cpp file as the implementation of that object, you can just do the extern at the function-level. A good example of this is editorinput()/editorrender()/editorlogic() in editor.cpp. In my opinion, they should probably be split off into their own separate file because editor.cpp is getting way too big, but this will do for now.
2020-09-28 04:15:06 +02:00
#define SCRIPT_DEFINITION
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#include "Script.h"
Move Script.cpp <limits.h> #include to proper place It should be between the include of the corresponding header file for the source file (Script.h) and the includes of other local header files (the files that are specific to this codebase only); this is the convention that includes in all other source files follow. However, it seems like I misplaced this, so I'm fixing it now.
2021-02-16 03:49:24 +01:00
#include <limits.h>
Replace Gravitron RNG with seeded Xoshiro This is to make it so RNG is deterministic when played back with the same inputs in a libTAS movie even if screen effects or backgrounds are disabled. That way, Gravitron RNG is on its own system (seeded in hardreset()), separate from the constant fRandom() calls that go to visual systems and don't do anything of actual consequence. The seed is based off of SDL_GetTicks(), so RTA runners don't get the same Gravitron RNG every time. This also paves the way for a future in-built input-based recording system, which now only has to save the seed for a given recording in order for it to play back deterministically.
2021-08-22 04:51:19 +02:00
#include <SDL_timer.h>
Move Script.cpp <limits.h> #include to proper place It should be between the include of the corresponding header file for the source file (Script.h) and the includes of other local header files (the files that are specific to this codebase only); this is the convention that includes in all other source files follow. However, it seems like I misplaced this, so I'm fixing it now.
2021-02-16 03:49:24 +01:00
Add textbuttons() script command, make Violet's ENTER dialogue dynamic Violet's dialogue now looks like this: squeak(purple) text(purple,0,0,2) Remember that you can press {b_map} to check where you are on the map! position(purple,above) textbuttons() speak_active The new textbuttons() command sets the next textbox to replace {b_map} with the map button, and {b_int} with the interact button. The remaining keys would be added as soon as they need to be added to ActionSets.h as well.
2023-03-18 22:31:13 +01:00
#include "Alloc.h"
Add localization "foundation" (many code changes) This commit adds most of the code changes necessary for making the game translatable, but does not yet "unhardcode" nearly all of the strings (except in a few cases where it was hard to separate added loc::gettexts from foundational code changes, or all the localization- related menus which were also added by this commit.) This commit is part of rewritten history of the localization branch. The original (unsquashed) commit history can be found here: https://github.com/Dav999-v/VVVVVV/tree/localization-orig
2022-12-30 22:57:24 +01:00
#include "Constants.h"
Rename editor.h to CustomLevels.h This accompanies the editor.cpp -> CustomLevels.cpp change; I'll be splitting out the editor functions in the next commit. The name of the include guard has been changed as well, but not anything else.
2021-02-20 08:19:09 +01:00
#include "CustomLevels.h"
Move all editor-specific attributes to a new editorclass This is a pretty hefty commit! But essentially, I made a new editorclass object, and moved all functions and variables that only get used in the in-game level editor to that class. This cleanly demarcates which things are in the editor and which things are just general custom level stuff. Then I fixed up all the callers. I also fixed up some NO_CUSTOM_LEVELS and NO_EDITOR ifdefs, too, in several places.
2021-02-21 00:40:11 +01:00
#include "Editor.h"
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#include "Entity.h"
Remove unnecessary includes from header files Including a header file inside another header file means a bunch of files are going to be unnecessarily recompiled whenever that inner header file is changed. So I minimized the amount of header files included in a header file, and only included the ones that were necessary (system includes don't count, I'm only talking about includes from within this project). Then the includes are only in the .cpp files themselves. This also minimizes problems such as a NO_CUSTOM_LEVELS build failing because some file depended on an include that got included in editor.h, which is another benefit of removing unnecessary includes from header files.
2020-07-19 21:05:41 +02:00
#include "Enums.h"
Clean up all program close paths to use VVV_exit() Wow, there are a lot of these. All of these exit paths now use VVV_exit() instead, which attempts to save unlock.vvv and settings.vvv, and also frees all resources so Valgrind is happy. This is a good thing, because previously unlock.vvv/settings.vvv wouldn't be written to if we decided to bail for a given reason.
2021-02-16 03:53:17 +01:00
#include "Exit.h"
Move wordwrapping functions and len to Font.cpp/font:: namespace The following functions were moved directly: - next_wrap - next_wrap_s - string_wordwrap - string_wordwrap_balanced - string_unwordwrap These ones will probably still need get a flags argument, except for string_unwordwrap (since they need to know what font we're talking about. The implementation of graphics.len has also been moved to Font.cpp, but graphics.len still exists for now and is deprecated.
2023-01-06 19:17:50 +01:00
#include "Font.h"
Split glitchrunner mode into multiple versions Previously, turning glitchrunner mode on essentially locked you to emulating 2.0, and turning it off just meant normal 2.3 behavior. But what if you wanted 2.2 behavior instead? Well, that's what I had to ask when a TAS of mine would desync in 2.3 because of the two-frame delay fix (glitchrunner off), but would also desync because of 2.0 warp lines (glitchrunner on). What I've done is made it so there are three states to glitchrunner mode now: 2.0 (previously just the "on" state), 2.2 (previously a state you couldn't use), and "off". Furthermore, I made it an enum, so in case future versions of the game patch out more glitches, we can add them to the enum (and the only other thing we have to update is a lookup table in GlitchrunnerMode.c). Also, 2.2 glitches exist in 2.0, so you'll want to use GlitchrunnerMode_less_than_or_equal() to check glitchrunner version.
2021-08-05 02:09:49 +02:00
#include "GlitchrunnerMode.h"
Separate includes into sections and alphabetize them Okay, so basically here's the include layout that this game now consistently uses: [The "main" header file, if any (e.g. Graphics.h for Graphics.cpp)] [blank line] [All system includes, such as tinyxml2/physfs/utfcpp/SDL] [blank line] [All project includes, such as Game.h/Entity.h/etc.] And if applicable, another blank line, and then some special-case include screwy stuff (take a look at editor.cpp or FileSystemUtils.cpp, for example, they have ifdefs and defines with their includes).
2020-07-19 21:43:29 +02:00
#include "Graphics.h"
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#include "KeyPoll.h"
Add localization "foundation" (many code changes) This commit adds most of the code changes necessary for making the game translatable, but does not yet "unhardcode" nearly all of the strings (except in a few cases where it was hard to separate added loc::gettexts from foundational code changes, or all the localization- related menus which were also added by this commit.) This commit is part of rewritten history of the localization branch. The original (unsquashed) commit history can be found here: https://github.com/Dav999-v/VVVVVV/tree/localization-orig
2022-12-30 22:57:24 +01:00
#include "Localization.h"
Add cutscene test menu This allows translators to test all text boxes in the scripts. It doesn't run the scripts themselves - it only shows the basic appearance of each text box individually, so context may be lost but it's good to have a way to see any text boxes that might otherwise not be easily seen because they require specific circumstances to appear.
2022-12-24 04:16:56 +01:00
#include "LocalizationMaint.h"
Add localization "foundation" (many code changes) This commit adds most of the code changes necessary for making the game translatable, but does not yet "unhardcode" nearly all of the strings (except in a few cases where it was hard to separate added loc::gettexts from foundational code changes, or all the localization- related menus which were also added by this commit.) This commit is part of rewritten history of the localization branch. The original (unsquashed) commit history can be found here: https://github.com/Dav999-v/VVVVVV/tree/localization-orig
2022-12-30 22:57:24 +01:00
#include "LocalizationStorage.h"
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#include "Map.h"
Separate includes into sections and alphabetize them Okay, so basically here's the include layout that this game now consistently uses: [The "main" header file, if any (e.g. Graphics.h for Graphics.cpp)] [blank line] [All system includes, such as tinyxml2/physfs/utfcpp/SDL] [blank line] [All project includes, such as Game.h/Entity.h/etc.] And if applicable, another blank line, and then some special-case include screwy stuff (take a look at editor.cpp or FileSystemUtils.cpp, for example, they have ifdefs and defines with their includes).
2020-07-19 21:43:29 +02:00
#include "Music.h"
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
#include "Unreachable.h"
Remove unnecessary includes from header files Including a header file inside another header file means a bunch of files are going to be unnecessarily recompiled whenever that inner header file is changed. So I minimized the amount of header files included in a header file, and only included the ones that were necessary (system includes don't count, I'm only talking about includes from within this project). Then the includes are only in the .cpp files themselves. This also minimizes problems such as a NO_CUSTOM_LEVELS build failing because some file depended on an include that got included in editor.h, which is another benefit of removing unnecessary includes from header files.
2020-07-19 21:05:41 +02:00
#include "UtilityClass.h"
Add localization "foundation" (many code changes) This commit adds most of the code changes necessary for making the game translatable, but does not yet "unhardcode" nearly all of the strings (except in a few cases where it was hard to separate added loc::gettexts from foundational code changes, or all the localization- related menus which were also added by this commit.) This commit is part of rewritten history of the localization branch. The original (unsquashed) commit history can be found here: https://github.com/Dav999-v/VVVVVV/tree/localization-orig
2022-12-30 22:57:24 +01:00
#include "VFormat.h"
Replace all print calls with vlog calls This is pretty straight-forward to do.
2021-02-24 00:21:29 +01:00
#include "Vlogging.h"
Replace Gravitron RNG with seeded Xoshiro This is to make it so RNG is deterministic when played back with the same inputs in a libTAS movie even if screen effects or backgrounds are disabled. That way, Gravitron RNG is on its own system (seeded in hardreset()), separate from the constant fRandom() calls that go to visual systems and don't do anything of actual consequence. The seed is based off of SDL_GetTicks(), so RTA runners don't get the same Gravitron RNG every time. This also paves the way for a future in-built input-based recording system, which now only has to save the seed for a given recording in order for it to play back deterministically.
2021-08-22 04:51:19 +02:00
#include "Xoshiro.h"
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
scriptclass::scriptclass(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
position = 0;
scriptdelay = 0;
running = false;
b = 0;
g = 0;
i = 0;
j = 0;
k = 0;
loopcount = 0;
looppoint = 0;
r = 0;
textx = 0;
texty = 0;
Save textbox state, allow lang switches w/ textbox This allows switching languages while a text box is on screen by saving the necessary state for a text box to be retranslated when the language is switched. This saves the state of the position and direction of the crewmate that the text box position is based off of (if applicable), and the text case of the text box, the script name of the script, and the original (English) lines of the text box. I did not explicitly label the original lines as English lines except in a main game context, because technically, custom levels could have original lines in a different language. Unfortunately, this doesn't work for every text box in the game. Notably, the Level Complete, Game Complete, number of crewmates remaining, trinket collection, Intermission 1 guides, etc. text boxes are special and require further fixes, but that will be coming in later commits.
2024-01-19 05:21:02 +01:00
textcrewmateposition = TextboxCrewmatePosition();
textoriginalcontext = TextboxOriginalContext();
Remove hardcoded textbox colours We have a custom textbox colour system, why not use it? This also moves the map of colours from CustomLevels to Script.
2023-03-18 22:48:20 +01:00
textbox_colours.clear();
add_default_colours();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
textflipme = false;
Add textboxtimer command
2023-04-20 14:53:30 +02:00
textboxtimer = 0;
Add localization "foundation" (many code changes) This commit adds most of the code changes necessary for making the game translatable, but does not yet "unhardcode" nearly all of the strings (except in a few cases where it was hard to separate added loc::gettexts from foundational code changes, or all the localization- related menus which were also added by this commit.) This commit is part of rewritten history of the localization branch. The original (unsquashed) commit history can be found here: https://github.com/Dav999-v/VVVVVV/tree/localization-orig
2022-12-30 22:57:24 +01:00
textcase = 1;
Add textbuttons() script command, make Violet's ENTER dialogue dynamic Violet's dialogue now looks like this: squeak(purple) text(purple,0,0,2) Remember that you can press {b_map} to check where you are on the map! position(purple,above) textbuttons() speak_active The new textbuttons() command sets the next textbox to replace {b_map} with the map button, and {b_int} with the interact button. The remaining keys would be added as soon as they need to be added to ActionSets.h as well.
2023-03-18 22:31:13 +01:00
textbuttons = false;
Allow a maximum of 26 lines, with L suffix
2022-11-30 18:56:44 +01:00
textlarge = false;
Initial implementation of textbox sprites This commit adds a system for displaying sprites in textboxes, meant to replace the hardcoded system in the main game. This does not support levelcomplete.png and gamecomplete.png yet, which will most likely just be special cases.
2023-08-06 00:34:15 +02:00
textbox_sprites.clear();
Add `textimage` for `levelcomplete` and `gamecomplete` `levelcomplete` and `gamecomplete` were hardcoded using textbox colors which were offset by 1. This PR fixes that, no longer requiring slightly-off colors, and instead adding a new property to textboxes which tell the game to display either level complete or game complete.
2023-08-20 19:11:44 +02:00
textbox_image = TEXTIMAGE_NONE;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Remove hardcoded textbox colours We have a custom textbox colour system, why not use it? This also moves the map of colours from CustomLevels to Script.
2023-03-18 22:48:20 +01:00
void scriptclass::add_default_colours(void)
{
Unhardcode textbox colors in textbox arguments There's a few places where textboxes are constructed through code, but they pass in the color's RGB values in manually. This commit unhardcodes most of them them, replacing them with a color lookup. The ones that weren't changed are special cases, like `175, 174, 174`.
2023-03-18 23:11:49 +01:00
textbox_colours["player"] = graphics.getRGB(164, 164, 255);
Remove hardcoded textbox colours We have a custom textbox colour system, why not use it? This also moves the map of colours from CustomLevels to Script.
2023-03-18 22:48:20 +01:00
textbox_colours["cyan"] = graphics.getRGB(164, 164, 255);
textbox_colours["red"] = graphics.getRGB(255, 60, 60);
textbox_colours["green"] = graphics.getRGB(144, 255, 144);
textbox_colours["yellow"] = graphics.getRGB(255, 255, 134);
textbox_colours["blue"] = graphics.getRGB(95, 95, 255);
textbox_colours["purple"] = graphics.getRGB(255, 134, 255);
textbox_colours["white"] = graphics.getRGB(244, 244, 244);
textbox_colours["gray"] = graphics.getRGB(174, 174, 174);
textbox_colours["orange"] = graphics.getRGB(255, 130, 20);
textbox_colours["transparent"] = graphics.getRGB(0, 0, 0);
}
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void scriptclass::clearcustom(void)
Clean up resetting editor contents and scripts Contents and scripts should be reset in editorclass::reset(); there's no reason to reset them again right before you load them from an XML file in editorclass::load(). Additionally, the resets now consistently use SDL_zeroa() (for contents) and scriptclass::clearcustom() (for scripts).
2021-02-13 01:35:22 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
customscripts.clear();
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
createentity command: Actually have p1/p2/p3/p4 defaults Since createentity() started accepting p1/p2/p3/p4 arguments, it now unconditionally passes in whatever arguments were present there previously, when there weren't any before. This can lead to unexpected behavior when selectively using and then omitting p1/p2/p3/p4 arguments. Also, plenty of existing levels already only use the 5-argument version of createentity(). And createcrewman() can take up to 6 arguments at once. It's not far-fetched that an existing level could createentity() right after doing a 6-argument createcrewman(), which would lead to a different behavior than in 2.2 and previous. So instead, instead of checking if `words[index]` is an empty string (it only sets the string to be empty if there are enough argument separators on the line), ACTUALLY check if it's empty. I've added a static array (no need for it to be exported) that keeps track of this. createentity() now checks for that instead of `words`.
2021-08-12 04:32:36 +02:00
static bool argexists[NUM_SCRIPT_ARGS];
Allow spaces and capitals in script names when loading This lets any script name use capitals and spaces all they want, while still being able to jump to them via iftrinkets() or similar. The issue is that whenever tokenize() is ran, all spaces are stripped and every argument is lowercased before being put into `words`. So, the solution here is to create a raw_words array that doesn't perform space stripping or lowercasing, and to refer to that whenever there's a script command that loads a script. We keep the lowercasing and space removal elsewhere to be more forgiving to newcomers. This is technically a forwards compatibility break, but it's only a minor one, and all levels that utilize it can still be easily modified to work on older versions anyway.
2022-02-12 23:56:27 +01:00
static std::string raw_words[NUM_SCRIPT_ARGS];
createentity command: Actually have p1/p2/p3/p4 defaults Since createentity() started accepting p1/p2/p3/p4 arguments, it now unconditionally passes in whatever arguments were present there previously, when there weren't any before. This can lead to unexpected behavior when selectively using and then omitting p1/p2/p3/p4 arguments. Also, plenty of existing levels already only use the 5-argument version of createentity(). And createcrewman() can take up to 6 arguments at once. It's not far-fetched that an existing level could createentity() right after doing a 6-argument createcrewman(), which would lead to a different behavior than in 2.2 and previous. So instead, instead of checking if `words[index]` is an empty string (it only sets the string to be empty if there are enough argument separators on the line), ACTUALLY check if it's empty. I've added a static array (no need for it to be exported) that keeps track of this. createentity() now checks for that instead of `words`.
2021-08-12 04:32:36 +02:00
Make std::string-using script funcs pass around const references This makes it so that whenever a string is passed into these functions, it's no longer needlessly copied.
2020-07-05 01:01:35 +02:00
void scriptclass::tokenize( const std::string& t )
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
j = 0;
std::string tempword;
Allow spaces and capitals in script names when loading This lets any script name use capitals and spaces all they want, while still being able to jump to them via iftrinkets() or similar. The issue is that whenever tokenize() is ran, all spaces are stripped and every argument is lowercased before being put into `words`. So, the solution here is to create a raw_words array that doesn't perform space stripping or lowercasing, and to refer to that whenever there's a script command that loads a script. We keep the lowercasing and space removal elsewhere to be more forgiving to newcomers. This is technically a forwards compatibility break, but it's only a minor one, and all levels that utilize it can still be easily modified to work on older versions anyway.
2022-02-12 23:56:27 +01:00
std::string temprawword;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
char currentletter;
SDL_zeroa(argexists);
for (size_t i = 0; i < t.length(); i++)
{
currentletter = t[i];
if (currentletter == '(' || currentletter == ')' || currentletter == ',')
{
words[j] = tempword;
Allow spaces and capitals in script names when loading This lets any script name use capitals and spaces all they want, while still being able to jump to them via iftrinkets() or similar. The issue is that whenever tokenize() is ran, all spaces are stripped and every argument is lowercased before being put into `words`. So, the solution here is to create a raw_words array that doesn't perform space stripping or lowercasing, and to refer to that whenever there's a script command that loads a script. We keep the lowercasing and space removal elsewhere to be more forgiving to newcomers. This is technically a forwards compatibility break, but it's only a minor one, and all levels that utilize it can still be easily modified to work on older versions anyway.
2022-02-12 23:56:27 +01:00
raw_words[j] = temprawword;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
argexists[j] = words[j] != "";
for (size_t ii = 0; ii < words[j].length(); ii++)
{
words[j][ii] = SDL_tolower(words[j][ii]);
}
j++;
tempword = "";
Allow spaces and capitals in script names when loading This lets any script name use capitals and spaces all they want, while still being able to jump to them via iftrinkets() or similar. The issue is that whenever tokenize() is ran, all spaces are stripped and every argument is lowercased before being put into `words`. So, the solution here is to create a raw_words array that doesn't perform space stripping or lowercasing, and to refer to that whenever there's a script command that loads a script. We keep the lowercasing and space removal elsewhere to be more forgiving to newcomers. This is technically a forwards compatibility break, but it's only a minor one, and all levels that utilize it can still be easily modified to work on older versions anyway.
2022-02-12 23:56:27 +01:00
temprawword = "";
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else if (currentletter == ' ')
{
Allow spaces and capitals in script names when loading This lets any script name use capitals and spaces all they want, while still being able to jump to them via iftrinkets() or similar. The issue is that whenever tokenize() is ran, all spaces are stripped and every argument is lowercased before being put into `words`. So, the solution here is to create a raw_words array that doesn't perform space stripping or lowercasing, and to refer to that whenever there's a script command that loads a script. We keep the lowercasing and space removal elsewhere to be more forgiving to newcomers. This is technically a forwards compatibility break, but it's only a minor one, and all levels that utilize it can still be easily modified to work on older versions anyway.
2022-02-12 23:56:27 +01:00
/* Ignore spaces unless it's part of a script name. */
temprawword += currentletter;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else
{
tempword += currentletter;
Allow spaces and capitals in script names when loading This lets any script name use capitals and spaces all they want, while still being able to jump to them via iftrinkets() or similar. The issue is that whenever tokenize() is ran, all spaces are stripped and every argument is lowercased before being put into `words`. So, the solution here is to create a raw_words array that doesn't perform space stripping or lowercasing, and to refer to that whenever there's a script command that loads a script. We keep the lowercasing and space removal elsewhere to be more forgiving to newcomers. This is technically a forwards compatibility break, but it's only a minor one, and all levels that utilize it can still be easily modified to work on older versions anyway.
2022-02-12 23:56:27 +01:00
temprawword += currentletter;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
if (j >= (int) SDL_arraysize(words))
{
break;
}
}
if (j < (int) SDL_arraysize(words))
{
const bool lastargexists = tempword != "";
if (lastargexists)
{
words[j] = tempword;
Allow spaces and capitals in script names when loading This lets any script name use capitals and spaces all they want, while still being able to jump to them via iftrinkets() or similar. The issue is that whenever tokenize() is ran, all spaces are stripped and every argument is lowercased before being put into `words`. So, the solution here is to create a raw_words array that doesn't perform space stripping or lowercasing, and to refer to that whenever there's a script command that loads a script. We keep the lowercasing and space removal elsewhere to be more forgiving to newcomers. This is technically a forwards compatibility break, but it's only a minor one, and all levels that utilize it can still be easily modified to work on older versions anyway.
2022-02-12 23:56:27 +01:00
raw_words[j] = tempword;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
argexists[j] = lastargexists;
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Refactor colors in internal commands Originally this started as a "deduplicate a bunch of duplicated code in script commands" PR, but as I was working on that, I discovered there's a lot more that needs to be done than just deduplication. Anything which needs a crewmate entity now calls `getcrewmanfromname(name)`, and anything which just needs the crewmate's color calls `getcolorfromname(name)`. This was done to make sure that everything works consistently and no copy/pasting is required. Next is the fallback; instead of giving up and doing various things when it can't find a specific color, it now attempts to treat the color name as an ID, and if it can't then it returns -1, where each individual command handles that return value. This means we can keep around AEM -- a bug used in custom levels -- by not doing anything with the return value if it's -1. Also, for some reason, there were two `crewcolour` functions, so I stripped out the one in entityclass and left (and modified) the one in the graphics class, since the graphics class also has the `crewcolourreal` function.
2021-09-01 00:09:51 +02:00
static int getcolorfromname(std::string name)
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if (name == "player") return CYAN;
else if (name == "cyan") return CYAN;
else if (name == "red") return RED;
else if (name == "green") return GREEN;
else if (name == "yellow") return YELLOW;
else if (name == "blue") return BLUE;
else if (name == "purple") return PURPLE;
else if (name == "customcyan") return CYAN;
else if (name == "gray") return GRAY;
else if (name == "teleporter") return TELEPORTER;
int color = help.Int(name.c_str(), -1);
if (color < 0) return -1; // Not a number (or it's negative), so we give up
return color; // Last effort to give a valid color, maybe they just input the color?
Refactor colors in internal commands Originally this started as a "deduplicate a bunch of duplicated code in script commands" PR, but as I was working on that, I discovered there's a lot more that needs to be done than just deduplication. Anything which needs a crewmate entity now calls `getcrewmanfromname(name)`, and anything which just needs the crewmate's color calls `getcolorfromname(name)`. This was done to make sure that everything works consistently and no copy/pasting is required. Next is the fallback; instead of giving up and doing various things when it can't find a specific color, it now attempts to treat the color name as an ID, and if it can't then it returns -1, where each individual command handles that return value. This means we can keep around AEM -- a bug used in custom levels -- by not doing anything with the return value if it's -1. Also, for some reason, there were two `crewcolour` functions, so I stripped out the one in entityclass and left (and modified) the one in the graphics class, since the graphics class also has the `crewcolourreal` function.
2021-09-01 00:09:51 +02:00
}
static int getcrewmanfromname(std::string name)
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if (name == "player") return obj.getplayer(); // Return the player
int color = getcolorfromname(name); // Maybe they passed in a crewmate name, or an id?
if (color == -1) return -1; // ...Nope, return -1
return obj.getcrewman(color);
Refactor colors in internal commands Originally this started as a "deduplicate a bunch of duplicated code in script commands" PR, but as I was working on that, I discovered there's a lot more that needs to be done than just deduplication. Anything which needs a crewmate entity now calls `getcrewmanfromname(name)`, and anything which just needs the crewmate's color calls `getcolorfromname(name)`. This was done to make sure that everything works consistently and no copy/pasting is required. Next is the fallback; instead of giving up and doing various things when it can't find a specific color, it now attempts to treat the color name as an ID, and if it can't then it returns -1, where each individual command handles that return value. This means we can keep around AEM -- a bug used in custom levels -- by not doing anything with the return value if it's -1. Also, for some reason, there were two `crewcolour` functions, so I stripped out the one in entityclass and left (and modified) the one in the graphics class, since the graphics class also has the `crewcolourreal` function.
2021-09-01 00:09:51 +02:00
}
Add textbox indexes, update trinket/crew textboxes This adds an attribute to textboxclass to allow a text box to keep an index that references another text box inside the graphics.textboxes std::vector. This is needed because the second text box of a "You have found a shiny trinket!" or "You have found a lost crewmate!" pair of text boxes explicitly relies on the height of the first text box. With this, I have moved those text boxes over to the new text box translation system. Since the update order now matters, I added a comment to recomputetextboxes() that clarifies that the text boxes must be updated in linear order, starting from 0.
2024-01-21 21:39:15 +01:00
/* Also used in gamestate 1001. */
void foundtrinket_textbox1(textboxclass* THIS);
void foundtrinket_textbox2(textboxclass* THIS);
Move all other text boxes to new system These include the room name translator text boxes (which aren't translated) and the foundlab and foundlab2 text boxes.
2024-01-21 22:47:26 +01:00
static void foundlab_textbox1(textboxclass* THIS)
{
THIS->lines.clear();
THIS->lines.push_back(loc::gettext("Congratulations!\n\nYou have found the secret lab!"));
THIS->wrap(2);
THIS->centertext();
THIS->pad(1, 1);
}
static void foundlab_textbox2(textboxclass* THIS)
{
THIS->lines.clear();
THIS->lines.push_back(loc::gettext("The secret lab is separate from the rest of the game. You can now come back here at any time by selecting the new SECRET LAB option in the play menu."));
THIS->wrap(0);
}
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void scriptclass::run(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if (!running)
{
return;
}
// This counter here will stop the function when it gets too high
short execution_counter = 0;
while(running && scriptdelay<=0 && !game.pausescript)
{
if (INBOUNDS_VEC(position, commands))
{
//Let's split or command in an array of words
tokenize(commands[position]);
//For script assisted input
game.press_left = false;
game.press_right = false;
game.press_action = false;
game.press_map = false;
//Ok, now we run a command based on that string
if (words[0] == "moveplayer")
{
//USAGE: moveplayer(x offset, y offset)
int player = obj.getplayer();
if (INBOUNDS_VEC(player, obj.entities))
{
obj.entities[player].xp += ss_toi(words[1]);
obj.entities[player].yp += ss_toi(words[2]);
obj.entities[player].lerpoldxp = obj.entities[player].xp;
obj.entities[player].lerpoldyp = obj.entities[player].yp;
}
scriptdelay = 1;
}
Animated roomnames, setroomname command This commit adds a better system for animated roomnames. The old system, like many other systems, were very hardcoded, and can be described as mostly else-if chains, with some fun string comparisons. The new system uses lists of text for transformations and glitchy names, making it much easier to add new cases if needeed. This commit implements the system but does not replace the old system, where that is done in the next commit. The settings for special roomnames can be read from level XML, and `setroomname()` can be used from commands to set a new, static name.
2022-12-12 00:05:20 +01:00
if (words[0] == "setroomname")
{
++position;
if (INBOUNDS_VEC(position, commands))
{
map.roomname_special = true;
map.roomnameset = true;
map.setroomname(commands[position].c_str());
}
}
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if (words[0] == "warpdir")
{
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
2023-01-07 19:28:07 +01:00
int temprx = ss_toi(words[1]) - 1;
int tempry = ss_toi(words[2]) - 1;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
const RoomProperty* room;
cl.setroomwarpdir(temprx, tempry, ss_toi(words[3]));
room = cl.getroomprop(temprx, tempry);
//Do we update our own room?
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
2023-01-07 19:28:07 +01:00
if (game.roomx - 100 == temprx && game.roomy - 100 == tempry)
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
//If screen warping, then override all that:
graphics.backgrounddrawn = false;
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
2023-01-07 19:28:07 +01:00
map.warpx = false;
map.warpy = false;
if (room->warpdir == 0)
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
map.background = 1;
//Be careful, we could be in a Lab or Warp Zone room...
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
2023-01-07 19:28:07 +01:00
if (room->tileset == 2)
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
//Lab
map.background = 2;
graphics.rcol = room->tilecol;
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
2023-01-07 19:28:07 +01:00
}
else if (room->tileset == 3)
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
//Warp Zone
map.background = 6;
}
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
2023-01-07 19:28:07 +01:00
}
else if (room->warpdir == 1)
{
map.warpx = true;
map.background = 3;
graphics.rcol = cl.getwarpbackground(temprx, tempry);
}
else if (room->warpdir == 2)
{
map.warpy = true;
map.background = 4;
graphics.rcol = cl.getwarpbackground(temprx, tempry);
}
else if (room->warpdir == 3)
{
map.warpx = true;
map.warpy = true;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
map.background = 5;
Move from surfaces to the SDL render system Ever since VVVVVV was initially ported to C++ in 2.0, it has used surfaces from SDL. The downside is, that's all software rendering. This commit moves most things off of surfaces, and all into GPU, by using textures and SDL_Renderer. Pixel-perfect collision has been kept by keeping a copy of sprites as surfaces. There's plans for pixel-perfect collision to use masks instead of reading pixel data directly, but that's out of scope for this commit. - `graphics.reloadresources()` is now called later in `main`, because textures cannot be created without a renderer. - This commit also removes a bunch of surface functions which are no longer needed. - This also recaches target textures in certain places for d3d9. - graphics.images was converted to a fixed-size array. - fillbox and fillboxabs use SDL_RenderDrawRect instead of drawing an outline using four filled rectangles - Update my name in the credits
2023-01-07 19:28:07 +01:00
graphics.rcol = cl.getwarpbackground(temprx, tempry);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
}
}
if (words[0] == "ifwarp")
{
const RoomProperty* const room = cl.getroomprop(ss_toi(words[1])-1, ss_toi(words[2])-1);
if (room->warpdir == ss_toi(words[3]))
{
Prioritize loading processed script names This makes it so that whenever the game loads a script as directed by a script command, it will first try to load the script from the processed argument, and if that fails only then will it try to load the script from the raw argument. This fixes a regression reported by Dav999 in the custom level "Vungeon" created by Dynaboom, where a script `ifflag`s to `aselectP1.1` even though the actual script name is `aselectp1.1`. In 2.3, it would lowercase `aselectP1.1` and load the script properly, but previous to this commit it would try to load the script with a capital name and then fail.
2023-02-01 05:04:18 +01:00
loadalts("custom_" + words[4], "custom_" + raw_words[4]);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
position--;
}
}
if (words[0] == "destroy")
{
Fix bug with `destroy(moving)`/`destroy(disappear)` This commit fixes an obscure bug with `destroy(moving)` and `destroy(disappear)` where, when looping through entities, the code doesn't actually check what the entity is before trying to destroy the block underneath it. To fix this, we just put the block-destroying code *inside* of the check, instead of being outside of it. I also fixed the code style because it was horrible.
2023-09-04 05:34:20 +02:00
if (words[1] == "gravitylines")
{
for (size_t edi = 0; edi < obj.entities.size(); edi++)
{
if (obj.entities[edi].type == 9 || obj.entities[edi].type == 10)
{
obj.disableentity(edi);
}
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
Fix bug with `destroy(moving)`/`destroy(disappear)` This commit fixes an obscure bug with `destroy(moving)` and `destroy(disappear)` where, when looping through entities, the code doesn't actually check what the entity is before trying to destroy the block underneath it. To fix this, we just put the block-destroying code *inside* of the check, instead of being outside of it. I also fixed the code style because it was horrible.
2023-09-04 05:34:20 +02:00
}
else if (words[1] == "warptokens")
{
Apply review suggestion from InfoTeddy Co-authored-by: Misa Elizabeth Kai <infoteddy@infoteddy.info>
2023-09-10 02:54:42 +02:00
for (size_t edi = 0; edi < obj.entities.size(); edi++)
{
Fix bug with `destroy(moving)`/`destroy(disappear)` This commit fixes an obscure bug with `destroy(moving)` and `destroy(disappear)` where, when looping through entities, the code doesn't actually check what the entity is before trying to destroy the block underneath it. To fix this, we just put the block-destroying code *inside* of the check, instead of being outside of it. I also fixed the code style because it was horrible.
2023-09-04 05:34:20 +02:00
if (obj.entities[edi].type == 11)
{
obj.disableentity(edi);
}
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
Fix bug with `destroy(moving)`/`destroy(disappear)` This commit fixes an obscure bug with `destroy(moving)` and `destroy(disappear)` where, when looping through entities, the code doesn't actually check what the entity is before trying to destroy the block underneath it. To fix this, we just put the block-destroying code *inside* of the check, instead of being outside of it. I also fixed the code style because it was horrible.
2023-09-04 05:34:20 +02:00
}
else if (words[1] == "platforms" || words[1] == "moving")
{
Re-add `fixed` bool Co-authored-by: Misa Elizabeth Kai <infoteddy@infoteddy.info>
2023-09-10 03:13:26 +02:00
const bool fixed = words[1] == "moving";
Fix bug with `destroy(moving)`/`destroy(disappear)` This commit fixes an obscure bug with `destroy(moving)` and `destroy(disappear)` where, when looping through entities, the code doesn't actually check what the entity is before trying to destroy the block underneath it. To fix this, we just put the block-destroying code *inside* of the check, instead of being outside of it. I also fixed the code style because it was horrible.
2023-09-04 05:34:20 +02:00
for (size_t edi = 0; edi < obj.entities.size(); edi++)
{
if (obj.entities[edi].rule == 2 && obj.entities[edi].animate == 100)
{
Re-add `fixed` bool Co-authored-by: Misa Elizabeth Kai <infoteddy@infoteddy.info>
2023-09-10 03:13:26 +02:00
if (fixed)
Fix bug with `destroy(moving)`/`destroy(disappear)` This commit fixes an obscure bug with `destroy(moving)` and `destroy(disappear)` where, when looping through entities, the code doesn't actually check what the entity is before trying to destroy the block underneath it. To fix this, we just put the block-destroying code *inside* of the check, instead of being outside of it. I also fixed the code style because it was horrible.
2023-09-04 05:34:20 +02:00
{
obj.disableblockat(obj.entities[edi].xp, obj.entities[edi].yp);
}
obj.disableentity(edi);
}
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
Fix bug with `destroy(moving)`/`destroy(disappear)` This commit fixes an obscure bug with `destroy(moving)` and `destroy(disappear)` where, when looping through entities, the code doesn't actually check what the entity is before trying to destroy the block underneath it. To fix this, we just put the block-destroying code *inside* of the check, instead of being outside of it. I also fixed the code style because it was horrible.
2023-09-04 05:34:20 +02:00
}
else if (words[1] == "disappear")
{
for (size_t edi = 0; edi < obj.entities.size(); edi++)
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
obj.disableblockat(obj.entities[edi].xp, obj.entities[edi].yp);
Fix bug with `destroy(moving)`/`destroy(disappear)` This commit fixes an obscure bug with `destroy(moving)` and `destroy(disappear)` where, when looping through entities, the code doesn't actually check what the entity is before trying to destroy the block underneath it. To fix this, we just put the block-destroying code *inside* of the check, instead of being outside of it. I also fixed the code style because it was horrible.
2023-09-04 05:34:20 +02:00
if (obj.entities[edi].type == 2 && obj.entities[edi].rule == 3)
{
obj.disableentity(edi);
}
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
}
}
if (words[0] == "customiftrinkets")
{
if (game.trinkets() >= ss_toi(words[1]))
{
Prioritize loading processed script names This makes it so that whenever the game loads a script as directed by a script command, it will first try to load the script from the processed argument, and if that fails only then will it try to load the script from the raw argument. This fixes a regression reported by Dav999 in the custom level "Vungeon" created by Dynaboom, where a script `ifflag`s to `aselectP1.1` even though the actual script name is `aselectp1.1`. In 2.3, it would lowercase `aselectP1.1` and load the script properly, but previous to this commit it would try to load the script with a capital name and then fail.
2023-02-01 05:04:18 +01:00
loadalts("custom_" + words[2], "custom_" + raw_words[2]);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
position--;
}
}
if (words[0] == "customiftrinketsless")
{
if (game.trinkets() < ss_toi(words[1]))
{
Prioritize loading processed script names This makes it so that whenever the game loads a script as directed by a script command, it will first try to load the script from the processed argument, and if that fails only then will it try to load the script from the raw argument. This fixes a regression reported by Dav999 in the custom level "Vungeon" created by Dynaboom, where a script `ifflag`s to `aselectP1.1` even though the actual script name is `aselectp1.1`. In 2.3, it would lowercase `aselectP1.1` and load the script properly, but previous to this commit it would try to load the script with a capital name and then fail.
2023-02-01 05:04:18 +01:00
loadalts("custom_" + words[2], "custom_" + raw_words[2]);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
position--;
}
}
else if (words[0] == "customifflag")
{
int flag = ss_toi(words[1]);
if (INBOUNDS_ARR(flag, obj.flags) && obj.flags[flag])
{
Prioritize loading processed script names This makes it so that whenever the game loads a script as directed by a script command, it will first try to load the script from the processed argument, and if that fails only then will it try to load the script from the raw argument. This fixes a regression reported by Dav999 in the custom level "Vungeon" created by Dynaboom, where a script `ifflag`s to `aselectP1.1` even though the actual script name is `aselectp1.1`. In 2.3, it would lowercase `aselectP1.1` and load the script properly, but previous to this commit it would try to load the script with a capital name and then fail.
2023-02-01 05:04:18 +01:00
loadalts("custom_" + words[2], "custom_" + raw_words[2]);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
position--;
}
}
if (words[0] == "custommap")
{
if(words[1]=="on"){
map.customshowmm=true;
}else if(words[1]=="off"){
map.customshowmm=false;
}
}
if (words[0] == "delay")
{
//USAGE: delay(frames)
scriptdelay = ss_toi(words[1]);
}
if (words[0] == "flag")
{
int flag = ss_toi(words[1]);
if (INBOUNDS_ARR(flag, obj.flags))
{
if (words[2] == "on")
{
obj.flags[flag] = true;
}
else if (words[2] == "off")
{
obj.flags[flag] = false;
}
}
}
if (words[0] == "flash")
{
//USAGE: flash(frames)
game.flashlight = ss_toi(words[1]);
}
if (words[0] == "shake")
{
//USAGE: shake(frames)
game.screenshake = ss_toi(words[1]);
}
if (words[0] == "walk")
{
//USAGE: walk(dir,frames)
if (words[1] == "left")
{
game.press_left = true;
}
else if (words[1] == "right")
{
game.press_right = true;
}
scriptdelay = ss_toi(words[2]);
}
if (words[0] == "flip")
{
game.press_action = true;
scriptdelay = 1;
}
if (words[0] == "tofloor")
{
int player = obj.getplayer();
if(INBOUNDS_VEC(player, obj.entities) && obj.entities[player].onroof>0)
{
game.press_action = true;
scriptdelay = 1;
}
}
if (words[0] == "playef")
{
music.playef(ss_toi(words[1]));
}
if (words[0] == "play")
{
music.play(ss_toi(words[1]));
}
if (words[0] == "stopmusic")
{
music.haltdasmusik();
}
if (words[0] == "resumemusic")
{
music.resumefade(0);
}
if (words[0] == "musicfadeout")
{
music.fadeout(false);
}
if (words[0] == "musicfadein")
{
music.fadein();
}
if (words[0] == "trinketscriptmusic")
{
Use enums for music tracks This adds an anonymous enum for music tracks and replaces all calls to music.play and music.niceplay that use integer literals. Additionally, this is also done for integer literals for cl.levmusic (except 0) and music.currentsong where appropriate, but _not_ the music areamap because that would not make it look very aesthetically pleasing in the code. This is not a named enum (that can be used for strict typechecking) because music track IDs are essentially part of the API of the game - almost every custom level uses these numbers. This is just to make the source code more readable without needing a comment to denote what number is what track.
2023-05-24 03:37:32 +02:00
music.play(Music_PASSIONFOREXPLORING);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
if (words[0] == "gotoposition")
{
//USAGE: gotoposition(x position, y position, gravity position)
int player = obj.getplayer();
if (INBOUNDS_VEC(player, obj.entities))
{
obj.entities[player].xp = ss_toi(words[1]);
obj.entities[player].yp = ss_toi(words[2]);
obj.entities[player].lerpoldxp = obj.entities[player].xp;
obj.entities[player].lerpoldyp = obj.entities[player].yp;
}
game.gravitycontrol = ss_toi(words[3]);
}
if (words[0] == "gotoroom")
{
//USAGE: gotoroom(x,y) (manually add 100)
map.gotoroom(ss_toi(words[1])+100, ss_toi(words[2])+100);
}
if (words[0] == "cutscene")
{
graphics.showcutscenebars = true;
}
if (words[0] == "endcutscene")
{
graphics.showcutscenebars = false;
}
if (words[0] == "audiopause")
{
if (words[1] == "on")
{
game.disabletemporaryaudiopause = false;
}
else if (words[1] == "off")
{
game.disabletemporaryaudiopause = true;
}
}
if (words[0] == "untilbars")
{
if (graphics.showcutscenebars)
{
if (graphics.cutscenebarspos < 360)
{
scriptdelay = 1;
position--;
}
}
else
{
if (graphics.cutscenebarspos > 0)
{
scriptdelay = 1;
position--;
}
}
}
else if (words[0] == "text")
{
Remove hardcoded textbox colours We have a custom textbox colour system, why not use it? This also moves the map of colours from CustomLevels to Script.
2023-03-18 22:48:20 +01:00
// oh boy
// first word is the colour.
if (textbox_colours.count(words[1]) == 0)
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
Remove hardcoded textbox colours We have a custom textbox colour system, why not use it? This also moves the map of colours from CustomLevels to Script.
2023-03-18 22:48:20 +01:00
// No colour named this, use gray
words[1] = "gray";
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
Remove hardcoded textbox colours We have a custom textbox colour system, why not use it? This also moves the map of colours from CustomLevels to Script.
2023-03-18 22:48:20 +01:00
r = textbox_colours[words[1]].r;
g = textbox_colours[words[1]].g;
b = textbox_colours[words[1]].b;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
//next are the x,y coordinates
textx = ss_toi(words[2]);
texty = ss_toi(words[3]);
Apply suggestions from code review Co-authored-by: Misa Elizabeth Kai <infoteddy@infoteddy.info>
2023-02-14 23:30:06 +01:00
textlarge = endsWith(words[4].c_str(), "l") || endsWith(words[4].c_str(), "L");
int lines = ss_toi(words[4]);
Allow a maximum of 26 lines, with L suffix
2022-11-30 18:56:44 +01:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
//Number of lines for the textbox!
txt.clear();
Allow a maximum of 26 lines, with L suffix
2022-11-30 18:56:44 +01:00
for (int i = 0; i < lines; i++)
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
position++;
if (INBOUNDS_VEC(position, commands))
{
txt.push_back(commands[position]);
}
}
Add localization "foundation" (many code changes) This commit adds most of the code changes necessary for making the game translatable, but does not yet "unhardcode" nearly all of the strings (except in a few cases where it was hard to separate added loc::gettexts from foundational code changes, or all the localization- related menus which were also added by this commit.) This commit is part of rewritten history of the localization branch. The original (unsquashed) commit history can be found here: https://github.com/Dav999-v/VVVVVV/tree/localization-orig
2022-12-30 22:57:24 +01:00
Add textboxtimer command
2023-04-20 14:53:30 +02:00
textboxtimer = 0;
Save textbox state, allow lang switches w/ textbox This allows switching languages while a text box is on screen by saving the necessary state for a text box to be retranslated when the language is switched. This saves the state of the position and direction of the crewmate that the text box position is based off of (if applicable), and the text case of the text box, the script name of the script, and the original (English) lines of the text box. I did not explicitly label the original lines as English lines except in a main game context, because technically, custom levels could have original lines in a different language. Unfortunately, this doesn't work for every text box in the game. Notably, the Level Complete, Game Complete, number of crewmates remaining, trinket collection, Intermission 1 guides, etc. text boxes are special and require further fixes, but that will be coming in later commits.
2024-01-19 05:21:02 +01:00
textcrewmateposition = TextboxCrewmatePosition();
Initial implementation of textbox sprites This commit adds a system for displaying sprites in textboxes, meant to replace the hardcoded system in the main game. This does not support levelcomplete.png and gamecomplete.png yet, which will most likely just be special cases.
2023-08-06 00:34:15 +02:00
textbox_sprites.clear();
Add `textimage` for `levelcomplete` and `gamecomplete` `levelcomplete` and `gamecomplete` were hardcoded using textbox colors which were offset by 1. This PR fixes that, no longer requiring slightly-off colors, and instead adding a new property to textboxes which tell the game to display either level complete or game complete.
2023-08-20 19:11:44 +02:00
textbox_image = TEXTIMAGE_NONE;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else if (words[0] == "position")
{
//are we facing left or right? for some objects we don't care, default at 0.
j = 0;
//the first word is the object to position relative to
if (words[1] == "centerx")
{
words[2] = "donothing";
j = -1;
textx = -500;
}
else if (words[1] == "centery")
{
words[2] = "donothing";
j = -1;
texty = -500;
}
else if (words[1] == "center")
{
words[2] = "donothing";
j = -1;
textx = -500;
texty = -500;
}
else // Well, are they asking for a crewmate...?
{
i = getcrewmanfromname(words[1]);
if (INBOUNDS_VEC(i, obj.entities))
{
j = obj.entities[i].dir;
}
}
Save textbox state, allow lang switches w/ textbox This allows switching languages while a text box is on screen by saving the necessary state for a text box to be retranslated when the language is switched. This saves the state of the position and direction of the crewmate that the text box position is based off of (if applicable), and the text case of the text box, the script name of the script, and the original (English) lines of the text box. I did not explicitly label the original lines as English lines except in a main game context, because technically, custom levels could have original lines in a different language. Unfortunately, this doesn't work for every text box in the game. Notably, the Level Complete, Game Complete, number of crewmates remaining, trinket collection, Intermission 1 guides, etc. text boxes are special and require further fixes, but that will be coming in later commits.
2024-01-19 05:21:02 +01:00
if (INBOUNDS_VEC(i, obj.entities) && (j == 0 || j == 1))
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
Save textbox state, allow lang switches w/ textbox This allows switching languages while a text box is on screen by saving the necessary state for a text box to be retranslated when the language is switched. This saves the state of the position and direction of the crewmate that the text box position is based off of (if applicable), and the text case of the text box, the script name of the script, and the original (English) lines of the text box. I did not explicitly label the original lines as English lines except in a main game context, because technically, custom levels could have original lines in a different language. Unfortunately, this doesn't work for every text box in the game. Notably, the Level Complete, Game Complete, number of crewmates remaining, trinket collection, Intermission 1 guides, etc. text boxes are special and require further fixes, but that will be coming in later commits.
2024-01-19 05:21:02 +01:00
if (words[2] == "above")
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
Save textbox state, allow lang switches w/ textbox This allows switching languages while a text box is on screen by saving the necessary state for a text box to be retranslated when the language is switched. This saves the state of the position and direction of the crewmate that the text box position is based off of (if applicable), and the text case of the text box, the script name of the script, and the original (English) lines of the text box. I did not explicitly label the original lines as English lines except in a main game context, because technically, custom levels could have original lines in a different language. Unfortunately, this doesn't work for every text box in the game. Notably, the Level Complete, Game Complete, number of crewmates remaining, trinket collection, Intermission 1 guides, etc. text boxes are special and require further fixes, but that will be coming in later commits.
2024-01-19 05:21:02 +01:00
textcrewmateposition.text_above = true;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
Save textbox state, allow lang switches w/ textbox This allows switching languages while a text box is on screen by saving the necessary state for a text box to be retranslated when the language is switched. This saves the state of the position and direction of the crewmate that the text box position is based off of (if applicable), and the text case of the text box, the script name of the script, and the original (English) lines of the text box. I did not explicitly label the original lines as English lines except in a main game context, because technically, custom levels could have original lines in a different language. Unfortunately, this doesn't work for every text box in the game. Notably, the Level Complete, Game Complete, number of crewmates remaining, trinket collection, Intermission 1 guides, etc. text boxes are special and require further fixes, but that will be coming in later commits.
2024-01-19 05:21:02 +01:00
Save text box centering state This is another piece of state that needs to be kept and re-played when switching language, because a different language could change the dimensions of the text box, which affects how it's centered. Also, to make sure that crewmate positions override any text centering, the scriptclass variables textx and texty should be reset in the position and customposition commands.
2024-01-21 02:02:35 +01:00
textx = 0;
texty = 0;
Save textbox state, allow lang switches w/ textbox This allows switching languages while a text box is on screen by saving the necessary state for a text box to be retranslated when the language is switched. This saves the state of the position and direction of the crewmate that the text box position is based off of (if applicable), and the text case of the text box, the script name of the script, and the original (English) lines of the text box. I did not explicitly label the original lines as English lines except in a main game context, because technically, custom levels could have original lines in a different language. Unfortunately, this doesn't work for every text box in the game. Notably, the Level Complete, Game Complete, number of crewmates remaining, trinket collection, Intermission 1 guides, etc. text boxes are special and require further fixes, but that will be coming in later commits.
2024-01-19 05:21:02 +01:00
textcrewmateposition.x = obj.entities[i].xp;
textcrewmateposition.override_x = true;
textcrewmateposition.y = obj.entities[i].yp;
textcrewmateposition.override_y = true;
textcrewmateposition.dir = j;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
}
else if (words[0] == "customposition")
{
//are we facing left or right? for some objects we don't care, default at 0.
j = 0;
//the first word is the object to position relative to
if (words[1] == "player")
{
i = obj.getcustomcrewman(0);
j = obj.entities[i].dir;
}
else if (words[1] == "cyan")
{
i = obj.getcustomcrewman(0);
j = obj.entities[i].dir;
}
else if (words[1] == "purple")
{
i = obj.getcustomcrewman(1);
j = obj.entities[i].dir;
}
else if (words[1] == "yellow")
{
i = obj.getcustomcrewman(2);
j = obj.entities[i].dir;
}
else if (words[1] == "red")
{
i = obj.getcustomcrewman(3);
j = obj.entities[i].dir;
}
else if (words[1] == "green")
{
i = obj.getcustomcrewman(4);
j = obj.entities[i].dir;
}
else if (words[1] == "blue")
{
i = obj.getcustomcrewman(5);
j = obj.entities[i].dir;
}
else if (words[1] == "centerx")
{
words[2] = "donothing";
j = -1;
textx = -500;
}
else if (words[1] == "centery")
{
words[2] = "donothing";
j = -1;
texty = -500;
}
else if (words[1] == "center")
{
words[2] = "donothing";
j = -1;
textx = -500;
texty = -500;
}
if(i==0 && words[1]!="player" && words[1]!="cyan"){
//Requested crewmate is not actually on screen
words[2] = "donothing";
j = -1;
textx = -500;
texty = -500;
}
Save textbox state, allow lang switches w/ textbox This allows switching languages while a text box is on screen by saving the necessary state for a text box to be retranslated when the language is switched. This saves the state of the position and direction of the crewmate that the text box position is based off of (if applicable), and the text case of the text box, the script name of the script, and the original (English) lines of the text box. I did not explicitly label the original lines as English lines except in a main game context, because technically, custom levels could have original lines in a different language. Unfortunately, this doesn't work for every text box in the game. Notably, the Level Complete, Game Complete, number of crewmates remaining, trinket collection, Intermission 1 guides, etc. text boxes are special and require further fixes, but that will be coming in later commits.
2024-01-19 05:21:02 +01:00
if (INBOUNDS_VEC(i, obj.entities) && (j == 0 || j == 1))
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
Save textbox state, allow lang switches w/ textbox This allows switching languages while a text box is on screen by saving the necessary state for a text box to be retranslated when the language is switched. This saves the state of the position and direction of the crewmate that the text box position is based off of (if applicable), and the text case of the text box, the script name of the script, and the original (English) lines of the text box. I did not explicitly label the original lines as English lines except in a main game context, because technically, custom levels could have original lines in a different language. Unfortunately, this doesn't work for every text box in the game. Notably, the Level Complete, Game Complete, number of crewmates remaining, trinket collection, Intermission 1 guides, etc. text boxes are special and require further fixes, but that will be coming in later commits.
2024-01-19 05:21:02 +01:00
if (words[2] == "above")
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
Save textbox state, allow lang switches w/ textbox This allows switching languages while a text box is on screen by saving the necessary state for a text box to be retranslated when the language is switched. This saves the state of the position and direction of the crewmate that the text box position is based off of (if applicable), and the text case of the text box, the script name of the script, and the original (English) lines of the text box. I did not explicitly label the original lines as English lines except in a main game context, because technically, custom levels could have original lines in a different language. Unfortunately, this doesn't work for every text box in the game. Notably, the Level Complete, Game Complete, number of crewmates remaining, trinket collection, Intermission 1 guides, etc. text boxes are special and require further fixes, but that will be coming in later commits.
2024-01-19 05:21:02 +01:00
textcrewmateposition.text_above = true;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
Save textbox state, allow lang switches w/ textbox This allows switching languages while a text box is on screen by saving the necessary state for a text box to be retranslated when the language is switched. This saves the state of the position and direction of the crewmate that the text box position is based off of (if applicable), and the text case of the text box, the script name of the script, and the original (English) lines of the text box. I did not explicitly label the original lines as English lines except in a main game context, because technically, custom levels could have original lines in a different language. Unfortunately, this doesn't work for every text box in the game. Notably, the Level Complete, Game Complete, number of crewmates remaining, trinket collection, Intermission 1 guides, etc. text boxes are special and require further fixes, but that will be coming in later commits.
2024-01-19 05:21:02 +01:00
Save text box centering state This is another piece of state that needs to be kept and re-played when switching language, because a different language could change the dimensions of the text box, which affects how it's centered. Also, to make sure that crewmate positions override any text centering, the scriptclass variables textx and texty should be reset in the position and customposition commands.
2024-01-21 02:02:35 +01:00
textx = 0;
texty = 0;
Save textbox state, allow lang switches w/ textbox This allows switching languages while a text box is on screen by saving the necessary state for a text box to be retranslated when the language is switched. This saves the state of the position and direction of the crewmate that the text box position is based off of (if applicable), and the text case of the text box, the script name of the script, and the original (English) lines of the text box. I did not explicitly label the original lines as English lines except in a main game context, because technically, custom levels could have original lines in a different language. Unfortunately, this doesn't work for every text box in the game. Notably, the Level Complete, Game Complete, number of crewmates remaining, trinket collection, Intermission 1 guides, etc. text boxes are special and require further fixes, but that will be coming in later commits.
2024-01-19 05:21:02 +01:00
textcrewmateposition.x = obj.entities[i].xp;
textcrewmateposition.override_x = true;
textcrewmateposition.y = obj.entities[i].xp;
textcrewmateposition.override_y = true;
textcrewmateposition.dir = j;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
}
else if (words[0] == "backgroundtext")
{
game.backgroundtext = true;
}
Add textboxtimer command
2023-04-20 14:53:30 +02:00
else if (words[0] == "textboxtimer")
{
textboxtimer = ss_toi(words[1]);
}
Initial implementation of textbox sprites This commit adds a system for displaying sprites in textboxes, meant to replace the hardcoded system in the main game. This does not support levelcomplete.png and gamecomplete.png yet, which will most likely just be special cases.
2023-08-06 00:34:15 +02:00
else if (words[0] == "textsprite")
{
TextboxSprite sprite;
sprite.x = ss_toi(words[1]);
sprite.y = ss_toi(words[2]);
sprite.tile = ss_toi(words[3]);
sprite.col = ss_toi(words[4]);
textbox_sprites.push_back(sprite);
}
Add `textimage` for `levelcomplete` and `gamecomplete` `levelcomplete` and `gamecomplete` were hardcoded using textbox colors which were offset by 1. This PR fixes that, no longer requiring slightly-off colors, and instead adding a new property to textboxes which tell the game to display either level complete or game complete.
2023-08-20 19:11:44 +02:00
else if (words[0] == "textimage")
{
if (words[1] == "levelcomplete")
{
textbox_image = TEXTIMAGE_LEVELCOMPLETE;
}
else if (words[1] == "gamecomplete")
{
textbox_image = TEXTIMAGE_GAMECOMPLETE;
}
else
{
textbox_image = TEXTIMAGE_NONE;
}
}
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
else if (words[0] == "flipme")
{
textflipme = !textflipme;
}
else if (words[0] == "speak_active" || words[0] == "speak")
{
//Ok, actually display the textbox we've initilised now!
//If using "speak", don't make the textbox active (so we can use multiple textboxes)
if (txt.empty())
{
txt.resize(1);
}
graphics.createtextboxreal(txt[0], textx, texty, r, g, b, textflipme);
textflipme = false;
Allow a maximum of 26 lines, with L suffix
2022-11-30 18:56:44 +01:00
graphics.setlarge(textlarge);
textlarge = false;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if ((int) txt.size() > 1)
{
for (i = 1; i < (int) txt.size(); i++)
{
graphics.addline(txt[i]);
}
}
Add textboxtimer command
2023-04-20 14:53:30 +02:00
if (textboxtimer > 0)
{
graphics.textboxtimer(textboxtimer);
}
Initial implementation of textbox sprites This commit adds a system for displaying sprites in textboxes, meant to replace the hardcoded system in the main game. This does not support levelcomplete.png and gamecomplete.png yet, which will most likely just be special cases.
2023-08-06 00:34:15 +02:00
for (size_t i = 0; i < textbox_sprites.size(); i++)
{
graphics.addsprite(textbox_sprites[i].x, textbox_sprites[i].y, textbox_sprites[i].tile, textbox_sprites[i].col);
}
Add `textimage` for `levelcomplete` and `gamecomplete` `levelcomplete` and `gamecomplete` were hardcoded using textbox colors which were offset by 1. This PR fixes that, no longer requiring slightly-off colors, and instead adding a new property to textboxes which tell the game to display either level complete or game complete.
2023-08-20 19:11:44 +02:00
graphics.setimage(textbox_image);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if (textx == -500 || textx == -1)
{
graphics.textboxcenterx();
Save textbox state, allow lang switches w/ textbox This allows switching languages while a text box is on screen by saving the necessary state for a text box to be retranslated when the language is switched. This saves the state of the position and direction of the crewmate that the text box position is based off of (if applicable), and the text case of the text box, the script name of the script, and the original (English) lines of the text box. I did not explicitly label the original lines as English lines except in a main game context, because technically, custom levels could have original lines in a different language. Unfortunately, this doesn't work for every text box in the game. Notably, the Level Complete, Game Complete, number of crewmates remaining, trinket collection, Intermission 1 guides, etc. text boxes are special and require further fixes, but that will be coming in later commits.
2024-01-19 05:21:02 +01:00
textcrewmateposition.override_x = false;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
if (texty == -500)
{
graphics.textboxcentery();
Save textbox state, allow lang switches w/ textbox This allows switching languages while a text box is on screen by saving the necessary state for a text box to be retranslated when the language is switched. This saves the state of the position and direction of the crewmate that the text box position is based off of (if applicable), and the text case of the text box, the script name of the script, and the original (English) lines of the text box. I did not explicitly label the original lines as English lines except in a main game context, because technically, custom levels could have original lines in a different language. Unfortunately, this doesn't work for every text box in the game. Notably, the Level Complete, Game Complete, number of crewmates remaining, trinket collection, Intermission 1 guides, etc. text boxes are special and require further fixes, but that will be coming in later commits.
2024-01-19 05:21:02 +01:00
textcrewmateposition.override_y = false;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
Save textbox state, allow lang switches w/ textbox This allows switching languages while a text box is on screen by saving the necessary state for a text box to be retranslated when the language is switched. This saves the state of the position and direction of the crewmate that the text box position is based off of (if applicable), and the text case of the text box, the script name of the script, and the original (English) lines of the text box. I did not explicitly label the original lines as English lines except in a main game context, because technically, custom levels could have original lines in a different language. Unfortunately, this doesn't work for every text box in the game. Notably, the Level Complete, Game Complete, number of crewmates remaining, trinket collection, Intermission 1 guides, etc. text boxes are special and require further fixes, but that will be coming in later commits.
2024-01-19 05:21:02 +01:00
TextboxOriginalContext context = TextboxOriginalContext();
context.text_case = textcase;
context.lines = std::vector<std::string>(txt);
context.script_name = scriptname;
Store original position of text box This stores the original x-position and y-position of the text box, and when a text box gets repositioned, it will use those unless a crewmate position overrides it. This is the original position of the text box, before centering or crewmate position is considered. This fixes a bug where a cutscene text box can be "shifted" from its normal position via CTRL+F8 cycling if there is a translation that is too long for the screen and thus gets pushed by adjust(). I tested this with the text box in the Comms Relay cutscene that starts with "If YOU can find a teleporter". This is not applicable to function-based translations (TEXTTRANSLATE_FUNCTION), because the responsibility of correctly positioning the text box resides with the function.
2024-01-21 23:56:08 +01:00
context.x = textx;
context.y = texty;
Save textbox state, allow lang switches w/ textbox This allows switching languages while a text box is on screen by saving the necessary state for a text box to be retranslated when the language is switched. This saves the state of the position and direction of the crewmate that the text box position is based off of (if applicable), and the text case of the text box, the script name of the script, and the original (English) lines of the text box. I did not explicitly label the original lines as English lines except in a main game context, because technically, custom levels could have original lines in a different language. Unfortunately, this doesn't work for every text box in the game. Notably, the Level Complete, Game Complete, number of crewmates remaining, trinket collection, Intermission 1 guides, etc. text boxes are special and require further fixes, but that will be coming in later commits.
2024-01-19 05:21:02 +01:00
graphics.textboxcrewmateposition(&textcrewmateposition);
graphics.textboxoriginalcontext(&context);
graphics.textboxcase(textcase);
Properly fix setfont/setrtl in between text boxes There used to be a problem with the setfont and setrtl script commands. Namely, if you used them in between text boxes naïvely, without any careful thought, then the fading out text box would suddenly gain the font of the new one. A kludge solution to this was implemented by simply blocking the script until the existing text box faded out before switching the font or RTL, and shipped for 2.4.0. However, a better solution is to simply bake the font flags in to the text box, so that way, if the level font switches, then the text box keeps its font. This is only for custom levels, because in the main game, the font in a text box needs to be able to change depending on language. But it seems like custom level translations weren't much on the roadmap, and so even the existing hack didn't support changing the font based on translation (even though translation of custom level cutscenes is supported). So baking the font flags into the text box here doesn't make things any worse. It also makes things better, arguably, by allowing multiple text boxes to exist on screen at once with different fonts. Maybe in the future we'll need a flag that specifies that the font should change depending on language if a translation in said language exists for the text box, or something like that. For people that want to override the fonts of every existing text box on screen, you can specify "all" as the second parameter of setfont or setrtl to do so.
2024-01-22 07:09:35 +01:00
if (map.custommode)
{
uint32_t flags = PR_FONT_IDX(font::font_idx_level, cl.rtl);
if (font::font_idx_level_is_custom)
{
flags |= PR_FONT_IDX_IS_CUSTOM;
}
graphics.textboxprintflags(flags);
}
Save special text box state using functions This adds a way to save the text box state of the crew remaining, ACTION prompt, etc. text boxes by just letting there be a function that is called to retranslate the text box when needed. It also adds a way to ignore translating a text box and to leave it alone, in case there's actually no text in the text box, which is the case with Level Complete and Game Complete. Both ways are now in an enum, TextboxTranslate. The former is TEXTTRANSLATE_FUNCTION and the latter is TEXTTRANSLATE_NONE. The existing way of translating text boxes became TEXTTRANSLATE_CUTSCENE, since it's only used for cutscene scripts. Here's a quick guide to the three ways of creating a text box now. - TEXTTRANSLATE_NONE: You must call graphics.textboxoriginalcontextauto() to save the existing text to the original context of the text box, as that will be copied back to the text box after the text of the text box is updated due to not having a translation. - TEXTTRANSLATE_CUTSCENE: Translates the text from cutscenes.xml, and overrides the spacing (padding and text centering). Shouldn't need to be used outside of scriptclass. - TEXTTRANSLATE_FUNCTION: You must pass in a function that takes in a single parameter, a pointer to the textboxclass object to be modified. General advice when retranslating text is to clear the `lines` vector and then push_back the retranslated text. The function is also solely responsible for spacing. In most cases, you will also need to call graphics.textboxapplyposition() or graphics.textboxadjust() afterwards. (Some text boxes shouldn't use graphics.textboxadjust() as they are within the 10-pixel inner border around the screen that textboxclass::adjust tries to push the text box out of.) This commit doesn't fix every text box just yet, though. But it fixes the Level Complete, Game Complete, crew remaining, and ACTION prompt text boxes, for a start.
2024-01-21 05:27:31 +01:00
graphics.textboxtranslate(TEXTTRANSLATE_CUTSCENE, NULL);
Properly fix setfont/setrtl in between text boxes There used to be a problem with the setfont and setrtl script commands. Namely, if you used them in between text boxes naïvely, without any careful thought, then the fading out text box would suddenly gain the font of the new one. A kludge solution to this was implemented by simply blocking the script until the existing text box faded out before switching the font or RTL, and shipped for 2.4.0. However, a better solution is to simply bake the font flags in to the text box, so that way, if the level font switches, then the text box keeps its font. This is only for custom levels, because in the main game, the font in a text box needs to be able to change depending on language. But it seems like custom level translations weren't much on the roadmap, and so even the existing hack didn't support changing the font based on translation (even though translation of custom level cutscenes is supported). So baking the font flags into the text box here doesn't make things any worse. It also makes things better, arguably, by allowing multiple text boxes to exist on screen at once with different fonts. Maybe in the future we'll need a flag that specifies that the font should change depending on language if a translation in said language exists for the text box, or something like that. For people that want to override the fonts of every existing text box on screen, you can specify "all" as the second parameter of setfont or setrtl to do so.
2024-01-22 07:09:35 +01:00
Transfer adjust call to applyposition This transfers the responsibility of the adjust() call to applyposition(). This is because cutscene text boxes (TEXTTRANSLATE_CUTSCENE) will have adjust() called, but all other text boxes won't. And I can't place the adjust() call inside applyposition(), because adjust() also calls applyposition(), and that leads to an infinite loop which leads to a stack overflow, so I had to remove the applyposition() call from adjust(), and replace the other existing call to Graphics::textboxadjust() with Graphics::textboxapplyposition(), and then remove Graphics::textboxadjust() function because it's no longer used.
2024-01-21 19:48:39 +01:00
graphics.textboxapplyposition();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if (words[0] == "speak_active")
{
graphics.textboxactive();
}
if (!game.backgroundtext)
{
game.advancetext = true;
game.hascontrol = false;
game.pausescript = true;
if (key.isDown(90) || key.isDown(32) || key.isDown(86)
|| key.isDown(KEYBOARD_UP) || key.isDown(KEYBOARD_DOWN)) game.jumpheld = true;
}
game.backgroundtext = false;
Add textbuttons() script command, make Violet's ENTER dialogue dynamic Violet's dialogue now looks like this: squeak(purple) text(purple,0,0,2) Remember that you can press {b_map} to check where you are on the map! position(purple,above) textbuttons() speak_active The new textbuttons() command sets the next textbox to replace {b_map} with the map button, and {b_int} with the interact button. The remaining keys would be added as soon as they need to be added to ActionSets.h as well.
2023-03-18 22:31:13 +01:00
if (textbuttons)
{
graphics.textboxbuttons();
}
textbuttons = false;
Reset textcase in speak/speak_active Originally, textcase was reset in scriptclass::translate_dialogue(), which is called inside the `text` script command. However, this didn't really work with the new on-the-fly text box translation system, and that function is gone now, so I removed that and kind of forgot about it. Of course, this now causes a regression. Namely, that the text boxes after the VVVVVV-Man sequence in the Secret Lab entrance cutscene are not translated. I can't reset the text case in `text`, as the scripts assume that they can set the text case before `text`. So the next best thing is to reset it in speak/speak_active.
2024-01-22 01:49:06 +01:00
textcase = 1;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else if (words[0] == "endtext")
{
graphics.textboxremove();
game.hascontrol = true;
game.advancetext = false;
}
else if (words[0] == "endtextfast")
{
graphics.textboxremovefast();
game.hascontrol = true;
game.advancetext = false;
}
else if (words[0] == "do")
{
//right, loop from this point
looppoint = position;
loopcount = ss_toi(words[1]);
}
else if (words[0] == "loop")
{
//right, loop from this point
loopcount--;
if (loopcount > 0)
{
position = looppoint;
}
}
else if (words[0] == "vvvvvvman")
{
//Create the super VVVVVV combo!
i = obj.getplayer();
if (INBOUNDS_VEC(i, obj.entities))
{
obj.entities[i].xp = 30;
obj.entities[i].yp = 46;
Update lerp positions during VVVVVV-Man transforms This updates the interpolation positions of the player when transforming into and out of VVVVVV-Man. Otherwise, it can be seen that the player "zips" quickly during these transformations if the Secret Lab entrance cutscene is played with screen effects off.
2023-04-06 04:51:58 +02:00
obj.entities[i].lerpoldxp = obj.entities[i].xp;
obj.entities[i].lerpoldyp = obj.entities[i].yp;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
obj.entities[i].size = 13;
obj.entities[i].colour = 23;
obj.entities[i].cx = 36;// 6;
obj.entities[i].cy = 12+80;// 2;
obj.entities[i].h = 126-80;// 21;
}
}
else if (words[0] == "undovvvvvvman")
{
//Create the super VVVVVV combo!
i = obj.getplayer();
if (INBOUNDS_VEC(i, obj.entities))
{
obj.entities[i].xp = 100;
Update lerp positions during VVVVVV-Man transforms This updates the interpolation positions of the player when transforming into and out of VVVVVV-Man. Otherwise, it can be seen that the player "zips" quickly during these transformations if the Secret Lab entrance cutscene is played with screen effects off.
2023-04-06 04:51:58 +02:00
obj.entities[i].lerpoldxp = obj.entities[i].xp;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
obj.entities[i].size = 0;
obj.entities[i].colour = 0;
obj.entities[i].cx = 6;
obj.entities[i].cy = 2;
obj.entities[i].h = 21;
}
}
else if (words[0] == "createentity")
{
std::string word6 = words[6];
std::string word7 = words[7];
std::string word8 = words[8];
std::string word9 = words[9];
if (!argexists[6]) words[6] = "0";
if (!argexists[7]) words[7] = "0";
if (!argexists[8]) words[8] = "320";
if (!argexists[9]) words[9] = "240";
obj.createentity(
ss_toi(words[1]),
ss_toi(words[2]),
ss_toi(words[3]),
ss_toi(words[4]),
ss_toi(words[5]),
ss_toi(words[6]),
ss_toi(words[7]),
ss_toi(words[8]),
ss_toi(words[9])
);
words[6] = word6;
words[7] = word7;
words[8] = word8;
words[9] = word9;
}
else if (words[0] == "createcrewman")
{
// Note: Do not change the "r" variable, it's used in custom levels
// to have glitchy textbox colors, where the game treats the value
// we set here as the red channel for the color.
r = getcolorfromname(words[3]);
if (r == -1) r = 19;
//convert the command to the right index
if (words[5] == "followplayer") words[5] = "10";
if (words[5] == "followpurple") words[5] = "11";
if (words[5] == "followyellow") words[5] = "12";
if (words[5] == "followred") words[5] = "13";
if (words[5] == "followgreen") words[5] = "14";
if (words[5] == "followblue") words[5] = "15";
if (words[5] == "followposition") words[5] = "16";
if (words[5] == "faceleft")
{
words[5] = "17";
words[6] = "0";
}
if (words[5] == "faceright")
{
words[5] = "17";
words[6] = "1";
}
if (words[5] == "faceplayer")
{
words[5] = "18";
words[6] = "0";
}
if (words[5] == "panic")
{
words[5] = "20";
words[6] = "0";
}
if (ss_toi(words[5]) >= 16)
{
obj.createentity(ss_toi(words[1]), ss_toi(words[2]), 18, r, ss_toi(words[4]), ss_toi(words[5]), ss_toi(words[6]));
}
else
{
obj.createentity(ss_toi(words[1]), ss_toi(words[2]), 18, r, ss_toi(words[4]), ss_toi(words[5]));
}
}
else if (words[0] == "changemood")
{
int crewmate = getcrewmanfromname(words[1]);
if (crewmate != -1) i = crewmate; // Ensure AEM is kept
if (INBOUNDS_VEC(i, obj.entities) && ss_toi(words[2]) == 0)
{
obj.entities[i].tile = 0;
}
else if (INBOUNDS_VEC(i, obj.entities))
{
obj.entities[i].tile = 144;
}
}
else if (words[0] == "changecustommood")
{
if (words[1] == "player")
{
i=obj.getcustomcrewman(0);
obj.customcrewmoods[0]=ss_toi(words[2]);
}
else if (words[1] == "cyan")
{
i=obj.getcustomcrewman(0);
obj.customcrewmoods[0]=ss_toi(words[2]);
}
else if (words[1] == "customcyan")
{
i=obj.getcustomcrewman(0);
obj.customcrewmoods[0]=ss_toi(words[2]);
}
else if (words[1] == "red")
{
i=obj.getcustomcrewman(3);
obj.customcrewmoods[3]=ss_toi(words[2]);
}
else if (words[1] == "green")
{
i=obj.getcustomcrewman(4);
obj.customcrewmoods[4]=ss_toi(words[2]);
}
else if (words[1] == "yellow")
{
i=obj.getcustomcrewman(2);
obj.customcrewmoods[2]=ss_toi(words[2]);
}
else if (words[1] == "blue")
{
i=obj.getcustomcrewman(5);
obj.customcrewmoods[5]=ss_toi(words[2]);
}
else if (words[1] == "purple")
{
i=obj.getcustomcrewman(1);
obj.customcrewmoods[1]=ss_toi(words[2]);
}
else if (words[1] == "pink")
{
i=obj.getcustomcrewman(1);
obj.customcrewmoods[1]=ss_toi(words[2]);
}
if (INBOUNDS_VEC(i, obj.entities) && ss_toi(words[2]) == 0)
{
obj.entities[i].tile = 0;
}
else if (INBOUNDS_VEC(i, obj.entities))
{
obj.entities[i].tile = 144;
}
}
else if (words[0] == "changetile")
{
int crewmate = getcrewmanfromname(words[1]);
if (crewmate != -1) i = crewmate; // Ensure AEM is kept
if (INBOUNDS_VEC(i, obj.entities))
{
obj.entities[i].tile = ss_toi(words[2]);
}
}
else if (words[0] == "flipgravity")
{
//not something I'll use a lot, I think. Doesn't need to be very robust!
if (words[1] == "player")
{
game.gravitycontrol = !game.gravitycontrol;
++game.totalflips;
}
else
{
int crewmate = getcrewmanfromname(words[1]);
if (crewmate != -1) i = crewmate; // Ensure AEM is kept
if (INBOUNDS_VEC(i, obj.entities) && obj.entities[i].rule == 7)
{
obj.entities[i].rule = 6;
obj.entities[i].tile = 0;
}
else if (INBOUNDS_VEC(i, obj.entities) && obj.getplayer() != i) // Don't destroy player entity
{
obj.entities[i].rule = 7;
obj.entities[i].tile = 6;
}
}
}
else if (words[0] == "changegravity")
{
//not something I'll use a lot, I think. Doesn't need to be very robust!
int crewmate = getcrewmanfromname(words[1]);
if (crewmate != -1) i = crewmate; // Ensure AEM is kept
if (INBOUNDS_VEC(i, obj.entities))
{
obj.entities[i].tile +=12;
}
}
else if (words[0] == "changedir")
{
int crewmate = getcrewmanfromname(words[1]);
if (crewmate != -1) i = crewmate; // Ensure AEM is kept
if (INBOUNDS_VEC(i, obj.entities) && ss_toi(words[2]) == 0)
{
obj.entities[i].dir = 0;
}
else if (INBOUNDS_VEC(i, obj.entities))
{
obj.entities[i].dir = 1;
}
}
else if (words[0] == "alarmon")
{
game.alarmon = true;
game.alarmdelay = 0;
}
else if (words[0] == "alarmoff")
{
game.alarmon = false;
}
else if (words[0] == "changeai")
{
int crewmate = getcrewmanfromname(words[1]);
if (crewmate != -1) i = crewmate; // Ensure AEM is kept
if (words[2] == "followplayer") words[2] = "10";
if (words[2] == "followpurple") words[2] = "11";
if (words[2] == "followyellow") words[2] = "12";
if (words[2] == "followred") words[2] = "13";
if (words[2] == "followgreen") words[2] = "14";
if (words[2] == "followblue") words[2] = "15";
if (words[2] == "followposition") words[2] = "16";
if (words[2] == "faceleft")
{
words[2] = "17";
words[3] = "0";
}
if (words[2] == "faceright")
{
words[2] = "17";
words[3] = "1";
}
if (INBOUNDS_VEC(i, obj.entities))
{
obj.entities[i].state = ss_toi(words[2]);
if (obj.entities[i].state == 16)
{
obj.entities[i].para=ss_toi(words[3]);
}
else if (obj.entities[i].state == 17)
{
obj.entities[i].dir=ss_toi(words[3]);
}
}
}
else if (words[0] == "activateteleporter")
{
i = obj.getteleporter();
if (INBOUNDS_VEC(i, obj.entities))
{
obj.entities[i].tile = 6;
obj.entities[i].colour = 102;
}
}
else if (words[0] == "changecolour")
{
int crewmate = getcrewmanfromname(words[1]);
if (crewmate != -1) i = crewmate; // Ensure AEM is kept
if (INBOUNDS_VEC(i, obj.entities))
{
obj.entities[i].colour = getcolorfromname(words[2]);
}
}
else if (words[0] == "squeak")
{
if (words[1] == "player")
{
Use enums for sound effects This adds an anonymous enum for sound effects and replaces all calls to music.playef that use integer literals. This is not a named enum (that can be used for strict typechecking) because sound effect IDs are essentially part of the API of the game - many custom levels use these numbers. This is just to make the source code more readable without needing a comment to denote what number is what sound.
2023-06-04 00:29:02 +02:00
music.playef(Sound_VIRIDIAN);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else if (words[1] == "cyan")
{
Use enums for sound effects This adds an anonymous enum for sound effects and replaces all calls to music.playef that use integer literals. This is not a named enum (that can be used for strict typechecking) because sound effect IDs are essentially part of the API of the game - many custom levels use these numbers. This is just to make the source code more readable without needing a comment to denote what number is what sound.
2023-06-04 00:29:02 +02:00
music.playef(Sound_VIRIDIAN);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else if (words[1] == "red")
{
Use enums for sound effects This adds an anonymous enum for sound effects and replaces all calls to music.playef that use integer literals. This is not a named enum (that can be used for strict typechecking) because sound effect IDs are essentially part of the API of the game - many custom levels use these numbers. This is just to make the source code more readable without needing a comment to denote what number is what sound.
2023-06-04 00:29:02 +02:00
music.playef(Sound_VERMILION);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else if (words[1] == "green")
{
Use enums for sound effects This adds an anonymous enum for sound effects and replaces all calls to music.playef that use integer literals. This is not a named enum (that can be used for strict typechecking) because sound effect IDs are essentially part of the API of the game - many custom levels use these numbers. This is just to make the source code more readable without needing a comment to denote what number is what sound.
2023-06-04 00:29:02 +02:00
music.playef(Sound_VERDIGRIS);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else if (words[1] == "yellow")
{
Use enums for sound effects This adds an anonymous enum for sound effects and replaces all calls to music.playef that use integer literals. This is not a named enum (that can be used for strict typechecking) because sound effect IDs are essentially part of the API of the game - many custom levels use these numbers. This is just to make the source code more readable without needing a comment to denote what number is what sound.
2023-06-04 00:29:02 +02:00
music.playef(Sound_VITELLARY);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else if (words[1] == "blue")
{
Use enums for sound effects This adds an anonymous enum for sound effects and replaces all calls to music.playef that use integer literals. This is not a named enum (that can be used for strict typechecking) because sound effect IDs are essentially part of the API of the game - many custom levels use these numbers. This is just to make the source code more readable without needing a comment to denote what number is what sound.
2023-06-04 00:29:02 +02:00
music.playef(Sound_VICTORIA);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else if (words[1] == "purple")
{
Use enums for sound effects This adds an anonymous enum for sound effects and replaces all calls to music.playef that use integer literals. This is not a named enum (that can be used for strict typechecking) because sound effect IDs are essentially part of the API of the game - many custom levels use these numbers. This is just to make the source code more readable without needing a comment to denote what number is what sound.
2023-06-04 00:29:02 +02:00
music.playef(Sound_VIOLET);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else if (words[1] == "cry")
{
Use enums for sound effects This adds an anonymous enum for sound effects and replaces all calls to music.playef that use integer literals. This is not a named enum (that can be used for strict typechecking) because sound effect IDs are essentially part of the API of the game - many custom levels use these numbers. This is just to make the source code more readable without needing a comment to denote what number is what sound.
2023-06-04 00:29:02 +02:00
music.playef(Sound_CRY);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else if (words[1] == "terminal")
{
Use enums for sound effects This adds an anonymous enum for sound effects and replaces all calls to music.playef that use integer literals. This is not a named enum (that can be used for strict typechecking) because sound effect IDs are essentially part of the API of the game - many custom levels use these numbers. This is just to make the source code more readable without needing a comment to denote what number is what sound.
2023-06-04 00:29:02 +02:00
music.playef(Sound_TERMINALTEXT);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
}
else if (words[0] == "blackout")
{
game.blackout = true;
}
else if (words[0] == "blackon")
{
game.blackout = false;
}
else if (words[0] == "setcheckpoint")
{
i = obj.getplayer();
game.savepoint = 0;
if (INBOUNDS_VEC(i, obj.entities))
{
game.savex = obj.entities[i].xp ;
game.savey = obj.entities[i].yp;
}
game.savegc = game.gravitycontrol;
game.saverx = game.roomx;
game.savery = game.roomy;
if (INBOUNDS_VEC(i, obj.entities))
{
game.savedir = obj.entities[i].dir;
}
}
else if (words[0] == "gamestate")
{
Apply suggestions from code review Co-authored-by: Misa Elizabeth Kai <infoteddy@infoteddy.info>
2022-12-07 18:32:28 +01:00
// Allow the gamestate command to bypass statelock, at least for now
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
game.state = ss_toi(words[1]);
game.statedelay = 0;
}
else if (words[0] == "textboxactive")
{
graphics.textboxactive();
}
else if (words[0] == "gamemode")
{
if (words[1] == "teleporter")
{
game.gamestate = GAMEMODE; /* to set prevgamestate */
game.mapmenuchange(TELEPORTERMODE, false);
game.useteleporter = false; //good heavens don't actually use it
}
else if (words[1] == "game")
{
graphics.resumegamemode = true;
game.prevgamestate = GAMEMODE;
}
}
else if (words[0] == "ifexplored")
{
if (map.isexplored(ss_toi(words[1]), ss_toi(words[2])))
{
Prioritize loading processed script names This makes it so that whenever the game loads a script as directed by a script command, it will first try to load the script from the processed argument, and if that fails only then will it try to load the script from the raw argument. This fixes a regression reported by Dav999 in the custom level "Vungeon" created by Dynaboom, where a script `ifflag`s to `aselectP1.1` even though the actual script name is `aselectp1.1`. In 2.3, it would lowercase `aselectP1.1` and load the script properly, but previous to this commit it would try to load the script with a capital name and then fail.
2023-02-01 05:04:18 +01:00
loadalts(words[3], raw_words[3]);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
position--;
}
}
else if (words[0] == "iflast")
{
if (game.lastsaved==ss_toi(words[1]))
{
Prioritize loading processed script names This makes it so that whenever the game loads a script as directed by a script command, it will first try to load the script from the processed argument, and if that fails only then will it try to load the script from the raw argument. This fixes a regression reported by Dav999 in the custom level "Vungeon" created by Dynaboom, where a script `ifflag`s to `aselectP1.1` even though the actual script name is `aselectp1.1`. In 2.3, it would lowercase `aselectP1.1` and load the script properly, but previous to this commit it would try to load the script with a capital name and then fail.
2023-02-01 05:04:18 +01:00
loadalts(words[2], raw_words[2]);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
position--;
}
}
else if (words[0] == "ifskip")
{
if (game.nocutscenes)
{
Prioritize loading processed script names This makes it so that whenever the game loads a script as directed by a script command, it will first try to load the script from the processed argument, and if that fails only then will it try to load the script from the raw argument. This fixes a regression reported by Dav999 in the custom level "Vungeon" created by Dynaboom, where a script `ifflag`s to `aselectP1.1` even though the actual script name is `aselectp1.1`. In 2.3, it would lowercase `aselectP1.1` and load the script properly, but previous to this commit it would try to load the script with a capital name and then fail.
2023-02-01 05:04:18 +01:00
loadalts(words[1], raw_words[1]);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
position--;
}
}
else if (words[0] == "ifflag")
{
int flag = ss_toi(words[1]);
if (INBOUNDS_ARR(flag, obj.flags) && obj.flags[flag])
{
Prioritize loading processed script names This makes it so that whenever the game loads a script as directed by a script command, it will first try to load the script from the processed argument, and if that fails only then will it try to load the script from the raw argument. This fixes a regression reported by Dav999 in the custom level "Vungeon" created by Dynaboom, where a script `ifflag`s to `aselectP1.1` even though the actual script name is `aselectp1.1`. In 2.3, it would lowercase `aselectP1.1` and load the script properly, but previous to this commit it would try to load the script with a capital name and then fail.
2023-02-01 05:04:18 +01:00
loadalts(words[2], raw_words[2]);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
position--;
}
}
else if (words[0] == "ifcrewlost")
{
int crewmate = ss_toi(words[1]);
if (INBOUNDS_ARR(crewmate, game.crewstats) && !game.crewstats[crewmate])
{
Prioritize loading processed script names This makes it so that whenever the game loads a script as directed by a script command, it will first try to load the script from the processed argument, and if that fails only then will it try to load the script from the raw argument. This fixes a regression reported by Dav999 in the custom level "Vungeon" created by Dynaboom, where a script `ifflag`s to `aselectP1.1` even though the actual script name is `aselectp1.1`. In 2.3, it would lowercase `aselectP1.1` and load the script properly, but previous to this commit it would try to load the script with a capital name and then fail.
2023-02-01 05:04:18 +01:00
loadalts(words[2], raw_words[2]);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
position--;
}
}
else if (words[0] == "iftrinkets")
{
if (game.trinkets() >= ss_toi(words[1]))
{
Prioritize loading processed script names This makes it so that whenever the game loads a script as directed by a script command, it will first try to load the script from the processed argument, and if that fails only then will it try to load the script from the raw argument. This fixes a regression reported by Dav999 in the custom level "Vungeon" created by Dynaboom, where a script `ifflag`s to `aselectP1.1` even though the actual script name is `aselectp1.1`. In 2.3, it would lowercase `aselectP1.1` and load the script properly, but previous to this commit it would try to load the script with a capital name and then fail.
2023-02-01 05:04:18 +01:00
loadalts(words[2], raw_words[2]);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
position--;
}
}
else if (words[0] == "iftrinketsless")
{
if (game.stat_trinkets < ss_toi(words[1]))
{
Prioritize loading processed script names This makes it so that whenever the game loads a script as directed by a script command, it will first try to load the script from the processed argument, and if that fails only then will it try to load the script from the raw argument. This fixes a regression reported by Dav999 in the custom level "Vungeon" created by Dynaboom, where a script `ifflag`s to `aselectP1.1` even though the actual script name is `aselectp1.1`. In 2.3, it would lowercase `aselectP1.1` and load the script properly, but previous to this commit it would try to load the script with a capital name and then fail.
2023-02-01 05:04:18 +01:00
loadalts(words[2], raw_words[2]);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
position--;
}
}
else if (words[0] == "hidecoordinates")
{
map.setexplored(ss_toi(words[1]), ss_toi(words[2]), false);
}
else if (words[0] == "showcoordinates")
{
map.setexplored(ss_toi(words[1]), ss_toi(words[2]), true);
}
else if (words[0] == "hideship")
{
map.hideship();
}
else if (words[0] == "showship")
{
map.showship();
}
else if (words[0] == "showsecretlab")
{
map.setexplored(16, 5, true);
map.setexplored(17, 5, true);
map.setexplored(18, 5, true);
map.setexplored(17, 6, true);
map.setexplored(18, 6, true);
map.setexplored(19, 6, true);
map.setexplored(19, 7, true);
map.setexplored(19, 8, true);
}
else if (words[0] == "hidesecretlab")
{
map.setexplored(16, 5, false);
map.setexplored(17, 5, false);
map.setexplored(18, 5, false);
map.setexplored(17, 6, false);
map.setexplored(18, 6, false);
map.setexplored(19, 6, false);
map.setexplored(19, 7, false);
map.setexplored(19, 8, false);
}
else if (words[0] == "showteleporters")
{
map.showteleporters = true;
}
else if (words[0] == "showtargets")
{
map.showtargets = true;
}
else if (words[0] == "showtrinkets")
{
map.showtrinkets = true;
}
else if (words[0] == "hideteleporters")
{
map.showteleporters = false;
}
else if (words[0] == "hidetargets")
{
map.showtargets = false;
}
else if (words[0] == "hidetrinkets")
{
map.showtrinkets = false;
}
else if (words[0] == "hideplayer")
{
int player = obj.getplayer();
if (INBOUNDS_VEC(player, obj.entities))
{
obj.entities[player].invis = true;
}
}
else if (words[0] == "showplayer")
{
int player = obj.getplayer();
if (INBOUNDS_VEC(player, obj.entities))
{
obj.entities[player].invis = false;
}
}
else if (words[0] == "teleportscript")
{
game.teleportscript = words[1];
}
else if (words[0] == "clearteleportscript")
{
game.teleportscript = "";
}
else if (words[0] == "nocontrol")
{
game.hascontrol = false;
}
else if (words[0] == "hascontrol")
{
game.hascontrol = true;
}
else if (words[0] == "companion")
{
game.companion = ss_toi(words[1]);
}
else if (words[0] == "befadein")
{
graphics.setfade(0);
Enumify all fade modes This removes the magic numbers previously used for controlling the fade mode, which are really not readable at all unless you already know what they mean. 0: FADE_NONE 1: FADE_FULLY_BLACK 2: FADE_START_FADEOUT 3: FADE_FADING_OUT 4: FADE_START_FADEIN 5: FADE_FADING_IN There is also the macro FADEMODE_IS_FADING, which indicates when the intention is to only check if the game is fading right now, which wasn't clearly conveyed previously. I also took the opportunity to clean up the style of any lines I touched. This included rewriting if-else chains into case-switches, turning one-liner if-then statements into proper blocks, fixing up comments, and even commenting the `fademode == FADE_NONE` on the tower spike checks (which, it was previously undocumented why that check was there, but I think I know why it's there). As for type safety, we already get some by transforming the variable types into the enum. Assignment is prohibited without a cast. But, apparently, comparison is perfectly legal and won't even give so much as a warning. To work around this and make absolutely sure I made all existing comparisons now use the enum, I temporarily changed it to be an `enum class`, which is a C++11 feature that makes it so all comparisons are illegal. Unfortunately, it scopes them in a namespace with the same name as a class, so I had to temporarily define macros to make sure my existing code worked. I also had to temporarily up the standard in CMakeLists.txt to get it to compile. But after all that was done, I found the rest of the places where a comparison to an integer was used, and fixed them.
2022-04-25 09:57:47 +02:00
graphics.fademode = FADE_NONE;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else if (words[0] == "fadein")
{
Enumify all fade modes This removes the magic numbers previously used for controlling the fade mode, which are really not readable at all unless you already know what they mean. 0: FADE_NONE 1: FADE_FULLY_BLACK 2: FADE_START_FADEOUT 3: FADE_FADING_OUT 4: FADE_START_FADEIN 5: FADE_FADING_IN There is also the macro FADEMODE_IS_FADING, which indicates when the intention is to only check if the game is fading right now, which wasn't clearly conveyed previously. I also took the opportunity to clean up the style of any lines I touched. This included rewriting if-else chains into case-switches, turning one-liner if-then statements into proper blocks, fixing up comments, and even commenting the `fademode == FADE_NONE` on the tower spike checks (which, it was previously undocumented why that check was there, but I think I know why it's there). As for type safety, we already get some by transforming the variable types into the enum. Assignment is prohibited without a cast. But, apparently, comparison is perfectly legal and won't even give so much as a warning. To work around this and make absolutely sure I made all existing comparisons now use the enum, I temporarily changed it to be an `enum class`, which is a C++11 feature that makes it so all comparisons are illegal. Unfortunately, it scopes them in a namespace with the same name as a class, so I had to temporarily define macros to make sure my existing code worked. I also had to temporarily up the standard in CMakeLists.txt to get it to compile. But after all that was done, I found the rest of the places where a comparison to an integer was used, and fixed them.
2022-04-25 09:57:47 +02:00
graphics.fademode = FADE_START_FADEIN;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else if (words[0] == "fadeout")
{
Enumify all fade modes This removes the magic numbers previously used for controlling the fade mode, which are really not readable at all unless you already know what they mean. 0: FADE_NONE 1: FADE_FULLY_BLACK 2: FADE_START_FADEOUT 3: FADE_FADING_OUT 4: FADE_START_FADEIN 5: FADE_FADING_IN There is also the macro FADEMODE_IS_FADING, which indicates when the intention is to only check if the game is fading right now, which wasn't clearly conveyed previously. I also took the opportunity to clean up the style of any lines I touched. This included rewriting if-else chains into case-switches, turning one-liner if-then statements into proper blocks, fixing up comments, and even commenting the `fademode == FADE_NONE` on the tower spike checks (which, it was previously undocumented why that check was there, but I think I know why it's there). As for type safety, we already get some by transforming the variable types into the enum. Assignment is prohibited without a cast. But, apparently, comparison is perfectly legal and won't even give so much as a warning. To work around this and make absolutely sure I made all existing comparisons now use the enum, I temporarily changed it to be an `enum class`, which is a C++11 feature that makes it so all comparisons are illegal. Unfortunately, it scopes them in a namespace with the same name as a class, so I had to temporarily define macros to make sure my existing code worked. I also had to temporarily up the standard in CMakeLists.txt to get it to compile. But after all that was done, I found the rest of the places where a comparison to an integer was used, and fixed them.
2022-04-25 09:57:47 +02:00
graphics.fademode = FADE_START_FADEOUT;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else if (words[0] == "untilfade")
{
Enumify all fade modes This removes the magic numbers previously used for controlling the fade mode, which are really not readable at all unless you already know what they mean. 0: FADE_NONE 1: FADE_FULLY_BLACK 2: FADE_START_FADEOUT 3: FADE_FADING_OUT 4: FADE_START_FADEIN 5: FADE_FADING_IN There is also the macro FADEMODE_IS_FADING, which indicates when the intention is to only check if the game is fading right now, which wasn't clearly conveyed previously. I also took the opportunity to clean up the style of any lines I touched. This included rewriting if-else chains into case-switches, turning one-liner if-then statements into proper blocks, fixing up comments, and even commenting the `fademode == FADE_NONE` on the tower spike checks (which, it was previously undocumented why that check was there, but I think I know why it's there). As for type safety, we already get some by transforming the variable types into the enum. Assignment is prohibited without a cast. But, apparently, comparison is perfectly legal and won't even give so much as a warning. To work around this and make absolutely sure I made all existing comparisons now use the enum, I temporarily changed it to be an `enum class`, which is a C++11 feature that makes it so all comparisons are illegal. Unfortunately, it scopes them in a namespace with the same name as a class, so I had to temporarily define macros to make sure my existing code worked. I also had to temporarily up the standard in CMakeLists.txt to get it to compile. But after all that was done, I found the rest of the places where a comparison to an integer was used, and fixed them.
2022-04-25 09:57:47 +02:00
if (FADEMODE_IS_FADING(graphics.fademode))
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
scriptdelay = 1;
position--;
}
}
else if (words[0] == "entersecretlab")
{
Use enums for unlock, unlocknotify, unlocknum This adds an anonymous enum for the unlock and unlocknotify arrays and unlocknum function, and replaces all integer literals with them. This is not named and thus cannot be used for strict typechecking because these are actually indexes into an array in XML save files, so the numbers themselves matter a lot.
2023-06-06 02:34:27 +02:00
game.unlocknum(Unlock_SECRETLAB);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
game.insecretlab = true;
SDL_memset(map.explored, true, sizeof(map.explored));
}
else if (words[0] == "leavesecretlab")
{
game.insecretlab = false;
}
else if (words[0] == "resetgame")
{
map.resetmap();
map.resetplayer();
graphics.towerbg.tdrawback = true;
obj.resetallflags();
i = obj.getplayer();
if (INBOUNDS_VEC(i, obj.entities))
{
obj.entities[i].tile = 0;
}
for (i = 0; i < 100; i++)
{
obj.collect[i] = false;
obj.customcollect[i] = false;
}
game.deathcounts = 0;
game.advancetext = false;
game.hascontrol = true;
game.resetgameclock();
game.gravitycontrol = 0;
game.teleport = false;
game.companion = 0;
game.teleport_to_new_area = false;
game.teleport_to_x = 0;
game.teleport_to_y = 0;
game.teleportscript = "";
//get out of final level mode!
map.finalmode = false;
map.final_colormode = false;
map.final_mapcol = 0;
map.final_colorframe = 0;
map.finalstretch = false;
}
else if (words[0] == "loadscript")
{
Prioritize loading processed script names This makes it so that whenever the game loads a script as directed by a script command, it will first try to load the script from the processed argument, and if that fails only then will it try to load the script from the raw argument. This fixes a regression reported by Dav999 in the custom level "Vungeon" created by Dynaboom, where a script `ifflag`s to `aselectP1.1` even though the actual script name is `aselectp1.1`. In 2.3, it would lowercase `aselectP1.1` and load the script properly, but previous to this commit it would try to load the script with a capital name and then fail.
2023-02-01 05:04:18 +01:00
loadalts(words[1], raw_words[1]);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
position--;
}
else if (words[0] == "rollcredits")
{
if (map.custommode && !map.custommodeforreal)
{
game.returntoeditor();
Move everything to the editor state system This commit moves everything left out of the previous commit to the state system. This means a bunch of new functions were added as well, to avoid the code in each function becoming too huge. A lot of cleanup was done as well, simplifying logic, merging duplicated code, etc. This commit does NOT touch "script hooks", script editor logic and autotiling, as those seem to be their own separate beasts.
2023-03-05 19:59:36 +01:00
ed.show_note(loc::gettext("Rolled credits"));
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else
{
game.gamestate = GAMECOMPLETE;
Enumify all fade modes This removes the magic numbers previously used for controlling the fade mode, which are really not readable at all unless you already know what they mean. 0: FADE_NONE 1: FADE_FULLY_BLACK 2: FADE_START_FADEOUT 3: FADE_FADING_OUT 4: FADE_START_FADEIN 5: FADE_FADING_IN There is also the macro FADEMODE_IS_FADING, which indicates when the intention is to only check if the game is fading right now, which wasn't clearly conveyed previously. I also took the opportunity to clean up the style of any lines I touched. This included rewriting if-else chains into case-switches, turning one-liner if-then statements into proper blocks, fixing up comments, and even commenting the `fademode == FADE_NONE` on the tower spike checks (which, it was previously undocumented why that check was there, but I think I know why it's there). As for type safety, we already get some by transforming the variable types into the enum. Assignment is prohibited without a cast. But, apparently, comparison is perfectly legal and won't even give so much as a warning. To work around this and make absolutely sure I made all existing comparisons now use the enum, I temporarily changed it to be an `enum class`, which is a C++11 feature that makes it so all comparisons are illegal. Unfortunately, it scopes them in a namespace with the same name as a class, so I had to temporarily define macros to make sure my existing code worked. I also had to temporarily up the standard in CMakeLists.txt to get it to compile. But after all that was done, I found the rest of the places where a comparison to an integer was used, and fixed them.
2022-04-25 09:57:47 +02:00
graphics.fademode = FADE_START_FADEIN;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
game.creditposition = 0;
Show skip prompt during credits and ending picture This adds a "- Press {button} to skip -" prompt to both the credits and ending picture sequences. It was always possible to skip them by pressing Enter, but not many people knew this. In fact, even I didn't know this until I saw Elomavi do it a year or so ago. So it's not really intuitive that this is possible. The prompt only shows up if you've completed the game before, and disappears after two seconds similar to the "[Press {button} to return to editor]" text. Unfortunately, given how the game works, game completion is detected based on if you have unlocked Flip Mode or not. At this point, the unlock for the game being completed (unlock 5) will already be set to true no matter what during the Plenary fanfare, but the Flip Mode unlock (unlock 18) won't be until the player hits "play" on the main menu. As a special case, the prompt will always show up in M&P (because Flip Mode is always unlocked in M&P).
2023-05-22 21:18:40 +02:00
game.skip_message_timer = 1000;
game.old_skip_message_timer = 1000;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
}
else if (words[0] == "finalmode")
{
map.finalmode = true;
map.gotoroom(ss_toi(words[1]), ss_toi(words[2]));
}
else if (words[0] == "rescued")
{
if (words[1] == "red")
{
game.crewstats[3] = true;
}
else if (words[1] == "green")
{
game.crewstats[4] = true;
}
else if (words[1] == "yellow")
{
game.crewstats[2] = true;
}
else if (words[1] == "blue")
{
game.crewstats[5] = true;
}
else if (words[1] == "purple")
{
game.crewstats[1] = true;
}
else if (words[1] == "player")
{
game.crewstats[0] = true;
}
else if (words[1] == "cyan")
{
game.crewstats[0] = true;
}
}
else if (words[0] == "missing")
{
if (words[1] == "red")
{
game.crewstats[3] = false;
}
else if (words[1] == "green")
{
game.crewstats[4] = false;
}
else if (words[1] == "yellow")
{
game.crewstats[2] = false;
}
else if (words[1] == "blue")
{
game.crewstats[5] = false;
}
else if (words[1] == "purple")
{
game.crewstats[1] = false;
}
else if (words[1] == "player")
{
game.crewstats[0] = false;
}
else if (words[1] == "cyan")
{
game.crewstats[0] = false;
}
}
else if (words[0] == "face")
{
int crewmate = getcrewmanfromname(words[1]);
if (crewmate != -1) i = crewmate; // Ensure AEM is kept
crewmate = getcrewmanfromname(words[2]);
if (crewmate != -1) j = crewmate; // Ensure AEM is kept
if (INBOUNDS_VEC(i, obj.entities) && INBOUNDS_VEC(j, obj.entities) && obj.entities[j].xp > obj.entities[i].xp + 5)
{
obj.entities[i].dir = 1;
}
else if (INBOUNDS_VEC(i, obj.entities) && INBOUNDS_VEC(j, obj.entities) && obj.entities[j].xp < obj.entities[i].xp - 5)
{
obj.entities[i].dir = 0;
}
}
else if (words[0] == "jukebox")
{
for (j = 0; j < (int) obj.entities.size(); j++)
{
if (obj.entities[j].type == 13)
{
obj.entities[j].colour = 4;
}
}
if (ss_toi(words[1]) == 1)
{
obj.createblock(5, 88 - 4, 80, 20, 16, 25);
for (j = 0; j < (int) obj.entities.size(); j++)
{
if (obj.entities[j].xp == 88 && obj.entities[j].yp==80)
{
obj.entities[j].colour = 5;
}
}
}
else if (ss_toi(words[1]) == 2)
{
obj.createblock(5, 128 - 4, 80, 20, 16, 26);
for (j = 0; j < (int) obj.entities.size(); j++)
{
if (obj.entities[j].xp == 128 && obj.entities[j].yp==80)
{
obj.entities[j].colour = 5;
}
}
}
else if (ss_toi(words[1]) == 3)
{
obj.createblock(5, 176 - 4, 80, 20, 16, 27);
for (j = 0; j < (int) obj.entities.size(); j++)
{
if (obj.entities[j].xp == 176 && obj.entities[j].yp==80)
{
obj.entities[j].colour = 5;
}
}
}
else if (ss_toi(words[1]) == 4)
{
obj.createblock(5, 216 - 4, 80, 20, 16, 28);
for (j = 0; j < (int) obj.entities.size(); j++)
{
if (obj.entities[j].xp == 216 && obj.entities[j].yp==80)
{
obj.entities[j].colour = 5;
}
}
}
else if (ss_toi(words[1]) == 5)
{
obj.createblock(5, 88 - 4, 128, 20, 16, 29);
for (j = 0; j < (int) obj.entities.size(); j++)
{
if (obj.entities[j].xp == 88 && obj.entities[j].yp==128)
{
obj.entities[j].colour = 5;
}
}
}
else if (ss_toi(words[1]) == 6)
{
obj.createblock(5, 176 - 4, 128, 20, 16, 30);
for (j = 0; j < (int) obj.entities.size(); j++)
{
if (obj.entities[j].xp == 176 && obj.entities[j].yp==128)
{
obj.entities[j].colour = 5;
}
}
}
else if (ss_toi(words[1]) == 7)
{
obj.createblock(5, 40 - 4, 40, 20, 16, 31);
for (j = 0; j < (int) obj.entities.size(); j++)
{
if (obj.entities[j].xp == 40 && obj.entities[j].yp==40)
{
obj.entities[j].colour = 5;
}
}
}
else if (ss_toi(words[1]) == 8)
{
obj.createblock(5, 216 - 4, 128, 20, 16, 32);
for (j = 0; j < (int) obj.entities.size(); j++)
{
if (obj.entities[j].xp == 216 && obj.entities[j].yp==128)
{
obj.entities[j].colour = 5;
}
}
}
else if (ss_toi(words[1]) == 9)
{
obj.createblock(5, 128 - 4, 128, 20, 16, 33);
for (j = 0; j < (int) obj.entities.size(); j++)
{
if (obj.entities[j].xp == 128 && obj.entities[j].yp==128)
{
obj.entities[j].colour = 5;
}
}
}
else if (ss_toi(words[1]) == 10)
{
obj.createblock(5, 264 - 4, 40, 20, 16, 34);
for (j = 0; j < (int) obj.entities.size(); j++)
{
if (obj.entities[j].xp == 264 && obj.entities[j].yp==40)
{
obj.entities[j].colour = 5;
}
}
}
}
else if (words[0] == "createactivityzone")
{
int crew_color = i; // stay consistent with past behavior!
if (words[1] == "red")
{
i = 3;
crew_color = RED;
}
else if (words[1] == "green")
{
i = 4;
crew_color = GREEN;
}
else if (words[1] == "yellow")
{
i = 2;
crew_color = YELLOW;
}
else if (words[1] == "blue")
{
i = 5;
crew_color = BLUE;
}
else if (words[1] == "purple")
{
i = 1;
crew_color = PURPLE;
}
int crewman = obj.getcrewman(crew_color);
if (INBOUNDS_VEC(crewman, obj.entities) && crew_color == GREEN)
{
obj.createblock(5, obj.entities[crewman].xp - 32, obj.entities[crewman].yp-20, 96, 60, i, "", (i == 35));
}
else if (INBOUNDS_VEC(crewman, obj.entities))
{
obj.createblock(5, obj.entities[crewman].xp - 32, 0, 96, 240, i, "", (i == 35));
}
}
else if (words[0] == "setactivitycolour")
{
obj.customactivitycolour = words[1];
}
else if (words[0] == "setactivitytext")
{
++position;
if (INBOUNDS_VEC(position, commands))
{
obj.customactivitytext = commands[position];
}
}
Add `setactivityposition(x,y)`, add new textbox color `transparent` (#847) * Add `setactivityposition(x,y)`, add new textbox color `transparent` This commit adds a new internal command as a part of the visual activity zone changes I've been making. This one allows the user to reposition the activity zone to anywhere on the screen. In addition, this commit adds the textbox color `transparent`, which just sets r, g and b to 0. rgb(0, 0, 0) normally creates the color black, however in VVVVVV textboxes, it makes the background of them invisible, and makes the text the off-white color which the game uses elsewhere. * add new variables to hardreset * Fix unwanted text centering; offset position by 16, 4 It makes sense for `setactivityposition(0, 0)` to place the activity zone in the default position, so the x has been offset by 16, and the y has been offset by 4. Text was being automatically centered, meaning any activity zone which wasn't centered had misplaced text. This has been fixed by calculating the center manually, and offsetting it by the passed value.
2021-10-14 00:38:51 +02:00
else if (words[0] == "setactivityposition")
{
Fix setactivityposition still taking two arguments This command was changed from setactivityposition(x,y) to setactivityposition(y), but there's a small problem here: ```diff else if (words[0] == "setactivityposition") { - obj.customactivitypositionx = ss_toi(words[1]); obj.customactivitypositiony = ss_toi(words[2]); } ``` This meant that the function still took two arguments, the first of which was unused and the second of which was the Y position of the activity zone. This is now fixed.
2023-06-04 17:52:01 +02:00
obj.customactivitypositiony = ss_toi(words[1]);
Add `setactivityposition(x,y)`, add new textbox color `transparent` (#847) * Add `setactivityposition(x,y)`, add new textbox color `transparent` This commit adds a new internal command as a part of the visual activity zone changes I've been making. This one allows the user to reposition the activity zone to anywhere on the screen. In addition, this commit adds the textbox color `transparent`, which just sets r, g and b to 0. rgb(0, 0, 0) normally creates the color black, however in VVVVVV textboxes, it makes the background of them invisible, and makes the text the off-white color which the game uses elsewhere. * add new variables to hardreset * Fix unwanted text centering; offset position by 16, 4 It makes sense for `setactivityposition(0, 0)` to place the activity zone in the default position, so the x has been offset by 16, and the y has been offset by 4. Text was being automatically centered, meaning any activity zone which wasn't centered had misplaced text. This has been fixed by calculating the center manually, and offsetting it by the passed value.
2021-10-14 00:38:51 +02:00
}
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
else if (words[0] == "createrescuedcrew")
{
//special for final level cutscene
//starting at 180, create the rescued crewmembers (ingoring violet, who's at 155)
i = 215;
if (game.crewstats[2] && game.lastsaved!=2)
{
obj.createentity(i, 153, 18, 14, 0, 17, 0);
i += 25;
}
if (game.crewstats[3] && game.lastsaved!=3)
{
obj.createentity(i, 153, 18, 15, 0, 17, 0);
i += 25;
}
if (game.crewstats[4] && game.lastsaved!=4)
{
obj.createentity(i, 153, 18, 13, 0, 17, 0);
i += 25;
}
if (game.crewstats[5] && game.lastsaved!=5)
{
obj.createentity(i, 153, 18, 16, 0, 17, 0);
i += 25;
}
}
else if (words[0] == "restoreplayercolour")
{
i = obj.getplayer();
if (INBOUNDS_VEC(i, obj.entities))
{
obj.entities[i].colour = 0;
}
}
else if (words[0] == "changeplayercolour")
{
i = obj.getplayer();
if (INBOUNDS_VEC(i, obj.entities))
{
obj.entities[i].colour = getcolorfromname(words[1]);
}
}
else if (words[0] == "changerespawncolour")
{
game.savecolour = getcolorfromname(words[1]);
}
else if (words[0] == "altstates")
{
obj.altstates = ss_toi(words[1]);
}
else if (words[0] == "activeteleporter")
{
i = obj.getteleporter();
if (INBOUNDS_VEC(i, obj.entities))
{
obj.entities[i].colour = 101;
}
}
else if (words[0] == "foundtrinket")
{
music.silencedasmusik();
Use enums for sound effects This adds an anonymous enum for sound effects and replaces all calls to music.playef that use integer literals. This is not a named enum (that can be used for strict typechecking) because sound effect IDs are essentially part of the API of the game - many custom levels use these numbers. This is just to make the source code more readable without needing a comment to denote what number is what sound.
2023-06-04 00:29:02 +02:00
music.playef(Sound_TRINKET);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
size_t trinket = ss_toi(words[1]);
if (trinket < SDL_arraysize(obj.collect))
{
obj.collect[trinket] = true;
}
graphics.textboxremovefast();
Add textbox indexes, update trinket/crew textboxes This adds an attribute to textboxclass to allow a text box to keep an index that references another text box inside the graphics.textboxes std::vector. This is needed because the second text box of a "You have found a shiny trinket!" or "You have found a lost crewmate!" pair of text boxes explicitly relies on the height of the first text box. With this, I have moved those text boxes over to the new text box translation system. Since the update order now matters, I added a comment to recomputetextboxes() that clarifies that the text boxes must be updated in linear order, starting from 0.
2024-01-21 21:39:15 +01:00
graphics.createtextboxflipme("", 50, 85, TEXT_COLOUR("gray"));
Migrate more prints to font::, determine font for most textboxes Some textboxes need to be in the level font (like room names, cutscene dialogue, etc - even in the main game), and some need to be in the interface font (like when you collect a shiny trinket or crewmate). So most of these textboxes now have graphics.textboxprintflags(font_flag) as appropriate. RoomnameTranslator.cpp is now also migrated to the new print system - in room name translator mode, the room name is now displayed in the 8x8 font if it's untranslated and the level font if it is.
2023-01-13 05:11:39 +01:00
graphics.textboxprintflags(PR_FONT_INTERFACE);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
graphics.textboxcenterx();
Add textbox indexes, update trinket/crew textboxes This adds an attribute to textboxclass to allow a text box to keep an index that references another text box inside the graphics.textboxes std::vector. This is needed because the second text box of a "You have found a shiny trinket!" or "You have found a lost crewmate!" pair of text boxes explicitly relies on the height of the first text box. With this, I have moved those text boxes over to the new text box translation system. Since the update order now matters, I added a comment to recomputetextboxes() that clarifies that the text boxes must be updated in linear order, starting from 0.
2024-01-21 21:39:15 +01:00
graphics.textboxtranslate(TEXTTRANSLATE_FUNCTION, foundtrinket_textbox1);
graphics.textboxapplyposition();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
Add textbox indexes, update trinket/crew textboxes This adds an attribute to textboxclass to allow a text box to keep an index that references another text box inside the graphics.textboxes std::vector. This is needed because the second text box of a "You have found a shiny trinket!" or "You have found a lost crewmate!" pair of text boxes explicitly relies on the height of the first text box. With this, I have moved those text boxes over to the new text box translation system. Since the update order now matters, I added a comment to recomputetextboxes() that clarifies that the text boxes must be updated in linear order, starting from 0.
2024-01-21 21:39:15 +01:00
graphics.createtextboxflipme("", 50, 95, TEXT_COLOUR("gray"));
Migrate more prints to font::, determine font for most textboxes Some textboxes need to be in the level font (like room names, cutscene dialogue, etc - even in the main game), and some need to be in the interface font (like when you collect a shiny trinket or crewmate). So most of these textboxes now have graphics.textboxprintflags(font_flag) as appropriate. RoomnameTranslator.cpp is now also migrated to the new print system - in room name translator mode, the room name is now displayed in the 8x8 font if it's untranslated and the level font if it is.
2023-01-13 05:11:39 +01:00
graphics.textboxprintflags(PR_FONT_INTERFACE);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
graphics.textboxcenterx();
Add textbox indexes, update trinket/crew textboxes This adds an attribute to textboxclass to allow a text box to keep an index that references another text box inside the graphics.textboxes std::vector. This is needed because the second text box of a "You have found a shiny trinket!" or "You have found a lost crewmate!" pair of text boxes explicitly relies on the height of the first text box. With this, I have moved those text boxes over to the new text box translation system. Since the update order now matters, I added a comment to recomputetextboxes() that clarifies that the text boxes must be updated in linear order, starting from 0.
2024-01-21 21:39:15 +01:00
graphics.textboxindex(graphics.textboxes.size() - 2);
graphics.textboxtranslate(TEXTTRANSLATE_FUNCTION, foundtrinket_textbox2);
graphics.textboxapplyposition();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if (!game.backgroundtext)
{
game.advancetext = true;
game.hascontrol = false;
game.pausescript = true;
if (key.isDown(90) || key.isDown(32) || key.isDown(86)
|| key.isDown(KEYBOARD_UP) || key.isDown(KEYBOARD_DOWN)) game.jumpheld = true;
}
game.backgroundtext = false;
}
else if (words[0] == "foundlab")
{
Use enums for sound effects This adds an anonymous enum for sound effects and replaces all calls to music.playef that use integer literals. This is not a named enum (that can be used for strict typechecking) because sound effect IDs are essentially part of the API of the game - many custom levels use these numbers. This is just to make the source code more readable without needing a comment to denote what number is what sound.
2023-06-04 00:29:02 +02:00
music.playef(Sound_TRINKET);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
graphics.textboxremovefast();
Move all other text boxes to new system These include the room name translator text boxes (which aren't translated) and the foundlab and foundlab2 text boxes.
2024-01-21 22:47:26 +01:00
graphics.createtextbox("", 50, 85, TEXT_COLOUR("gray"));
Migrate more prints to font::, determine font for most textboxes Some textboxes need to be in the level font (like room names, cutscene dialogue, etc - even in the main game), and some need to be in the interface font (like when you collect a shiny trinket or crewmate). So most of these textboxes now have graphics.textboxprintflags(font_flag) as appropriate. RoomnameTranslator.cpp is now also migrated to the new print system - in room name translator mode, the room name is now displayed in the 8x8 font if it's untranslated and the level font if it is.
2023-01-13 05:11:39 +01:00
graphics.textboxprintflags(PR_FONT_INTERFACE);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
graphics.textboxcenterx();
graphics.textboxcentery();
Move all other text boxes to new system These include the room name translator text boxes (which aren't translated) and the foundlab and foundlab2 text boxes.
2024-01-21 22:47:26 +01:00
graphics.textboxtranslate(TEXTTRANSLATE_FUNCTION, foundlab_textbox1);
graphics.textboxapplyposition();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if (!game.backgroundtext)
{
game.advancetext = true;
game.hascontrol = false;
game.pausescript = true;
if (key.isDown(90) || key.isDown(32) || key.isDown(86)
|| key.isDown(KEYBOARD_UP) || key.isDown(KEYBOARD_DOWN)) game.jumpheld = true;
}
game.backgroundtext = false;
}
else if (words[0] == "foundlab2")
{
graphics.textboxremovefast();
Move all other text boxes to new system These include the room name translator text boxes (which aren't translated) and the foundlab and foundlab2 text boxes.
2024-01-21 22:47:26 +01:00
graphics.createtextbox("", 50, 85, TEXT_COLOUR("gray"));
Migrate more prints to font::, determine font for most textboxes Some textboxes need to be in the level font (like room names, cutscene dialogue, etc - even in the main game), and some need to be in the interface font (like when you collect a shiny trinket or crewmate). So most of these textboxes now have graphics.textboxprintflags(font_flag) as appropriate. RoomnameTranslator.cpp is now also migrated to the new print system - in room name translator mode, the room name is now displayed in the 8x8 font if it's untranslated and the level font if it is.
2023-01-13 05:11:39 +01:00
graphics.textboxprintflags(PR_FONT_INTERFACE);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
graphics.textboxcenterx();
graphics.textboxcentery();
Move all other text boxes to new system These include the room name translator text boxes (which aren't translated) and the foundlab and foundlab2 text boxes.
2024-01-21 22:47:26 +01:00
graphics.textboxtranslate(TEXTTRANSLATE_FUNCTION, foundlab_textbox2);
graphics.textboxapplyposition();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if (!game.backgroundtext)
{
game.advancetext = true;
game.hascontrol = false;
game.pausescript = true;
if (key.isDown(90) || key.isDown(32) || key.isDown(86)
|| key.isDown(KEYBOARD_UP) || key.isDown(KEYBOARD_DOWN)) game.jumpheld = true;
}
game.backgroundtext = false;
}
else if (words[0] == "everybodysad")
{
for (i = 0; i < (int) obj.entities.size(); i++)
{
if (obj.entities[i].rule == 6 || obj.entities[i].rule == 0)
{
obj.entities[i].tile = 144;
}
}
}
else if (words[0] == "startintermission2")
{
map.finalmode = true; //Enable final level mode
game.savex = 228;
game.savey = 129;
game.saverx = 53;
game.savery = 49;
game.savegc = 0;
game.savedir = 0; //Intermission level 2
game.savepoint = 0;
game.gravitycontrol = 0;
map.gotoroom(46, 54);
}
else if (words[0] == "telesave")
{
if (!game.intimetrial && !game.nodeathmode && !game.inintermission) game.savetele();
}
else if (words[0] == "createlastrescued")
{
r = graphics.crewcolour(game.lastsaved);
if (r == 0 || r == PURPLE)
{
r = GRAY; // Default to gray if invalid color.
}
obj.createentity(200, 153, 18, r, 0, 19, 30);
i = obj.getcrewman(game.lastsaved);
if (INBOUNDS_VEC(i, obj.entities))
{
obj.entities[i].dir = 1;
}
}
else if (words[0] == "specialline")
{
Add localization "foundation" (many code changes) This commit adds most of the code changes necessary for making the game translatable, but does not yet "unhardcode" nearly all of the strings (except in a few cases where it was hard to separate added loc::gettexts from foundational code changes, or all the localization- related menus which were also added by this commit.) This commit is part of rewritten history of the localization branch. The original (unsquashed) commit history can be found here: https://github.com/Dav999-v/VVVVVV/tree/localization-orig
2022-12-30 22:57:24 +01:00
//Localization is handled with regular cutscene dialogue
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
switch(ss_toi(words[1]))
{
case 1:
txt.resize(1);
txt[0] = "I'm worried about " + game.unrescued() + ", Doctor!";
break;
case 2:
txt.resize(3);
if (game.crewrescued() < 5)
{
txt[1] = "to helping you find the";
txt[2] = "rest of the crew!";
}
else
{
txt.resize(2);
txt[1] = "to helping you find " + game.unrescued() + "!";
}
break;
}
}
else if (words[0] == "trinketbluecontrol")
{
if (game.trinkets() == 20 && obj.flags[67])
{
load("talkblue_trinket6");
position--;
}
else if (game.trinkets() >= 19 && !obj.flags[67])
{
load("talkblue_trinket5");
position--;
}
else
{
load("talkblue_trinket4");
position--;
}
}
else if (words[0] == "trinketyellowcontrol")
{
if (game.trinkets() >= 19)
{
load("talkyellow_trinket3");
position--;
}
else
{
load("talkyellow_trinket2");
position--;
}
}
else if (words[0] == "redcontrol")
{
if (game.insecretlab)
{
load("talkred_14");
position--;
}
else if (game.roomx != 104)
{
if (game.roomx == 100)
{
load("talkred_10");
position--;
}
else if (game.roomx == 107)
{
load("talkred_11");
position--;
}
else if (game.roomx == 114)
{
load("talkred_12");
position--;
}
}
else if (obj.flags[67])
{
//game complete
load("talkred_13");
position--;
}
else if (obj.flags[35] && !obj.flags[52])
{
//Intermission level
obj.flags[52] = true;
load("talkred_9");
position--;
}
else if (!obj.flags[51])
{
//We're back home!
obj.flags[51] = true;
load("talkred_5");
position--;
}
else if (!obj.flags[48] && game.crewstats[5])
{
//Victoria's back
obj.flags[48] = true;
load("talkred_6");
position--;
}
else if (!obj.flags[49] && game.crewstats[4])
{
//Verdigris' back
obj.flags[49] = true;
load("talkred_7");
position--;
}
else if (!obj.flags[50] && game.crewstats[2])
{
//Vitellary's back
obj.flags[50] = true;
load("talkred_8");
position--;
}
else if (!obj.flags[45] && !game.crewstats[5])
{
obj.flags[45] = true;
load("talkred_2");
position--;
}
else if (!obj.flags[46] && !game.crewstats[4])
{
obj.flags[46] = true;
load("talkred_3");
position--;
}
else if (!obj.flags[47] && !game.crewstats[2])
{
obj.flags[47] = true;
load("talkred_4");
position--;
}
else
{
obj.flags[45] = false;
obj.flags[46] = false;
obj.flags[47] = false;
load("talkred_1");
position--;
}
}
//TODO: Non Urgent fix compiler nesting errors without adding complexity
if (words[0] == "greencontrol")
{
if (game.insecretlab)
{
load("talkgreen_11");
position--;
}
else if (game.roomx == 103 && game.roomy == 109)
{
load("talkgreen_8");
position--;
}
else if (game.roomx == 101 && game.roomy == 109)
{
load("talkgreen_9");
position--;
}
else if (obj.flags[67])
{
//game complete
load("talkgreen_10");
position--;
}
else if (obj.flags[34] && !obj.flags[57])
{
//Intermission level
obj.flags[57] = true;
load("talkgreen_7");
position--;
}
else if (!obj.flags[53])
{
//Home!
obj.flags[53] = true;
load("talkgreen_6");
position--;
}
else if (!obj.flags[54] && game.crewstats[2])
{
obj.flags[54] = true;
load("talkgreen_5");
position--;
}
else if (!obj.flags[55] && game.crewstats[3])
{
obj.flags[55] = true;
load("talkgreen_4");
position--;
}
else if (!obj.flags[56] && game.crewstats[5])
{
obj.flags[56] = true;
load("talkgreen_3");
position--;
}
else if (!obj.flags[58])
{
obj.flags[58] = true;
load("talkgreen_2");
position--;
}
else
{
load("talkgreen_1");
position--;
}
}
else if (words[0] == "bluecontrol")
{
if (game.insecretlab)
{
load("talkblue_9");
position--;
}
else if (obj.flags[67])
{
//game complete, everything changes for victoria
if (obj.flags[41] && !obj.flags[42])
{
//second trinket conversation
obj.flags[42] = true;
load("talkblue_trinket2");
position--;
}
else if (!obj.flags[41] && !obj.flags[42])
{
//Third trinket conversation
obj.flags[42] = true;
load("talkblue_trinket3");
position--;
}
else
{
//Ok, we've already dealt with the trinket thing; so either you have them all, or you don't. If you do:
if (game.trinkets() >= 20)
{
load("startepilogue");
position--;
}
else
{
load("talkblue_8");
position--;
}
}
}
else if (obj.flags[33] && !obj.flags[40])
{
//Intermission level
obj.flags[40] = true;
load("talkblue_7");
position--;
}
else if (!obj.flags[36] && game.crewstats[5])
{
//Back on the ship!
obj.flags[36] = true;
load("talkblue_3");
position--;
}
else if (!obj.flags[41] && game.crewrescued() <= 4)
{
//First trinket conversation
obj.flags[41] = true;
load("talkblue_trinket1");
position--;
}
else if (obj.flags[41] && !obj.flags[42] && game.crewrescued() == 5)
{
//second trinket conversation
obj.flags[42] = true;
load("talkblue_trinket2");
position--;
}
else if (!obj.flags[41] && !obj.flags[42] && game.crewrescued() == 5)
{
//Third trinket conversation
obj.flags[42] = true;
load("talkblue_trinket3");
position--;
}
else if (!obj.flags[37] && game.crewstats[2])
{
obj.flags[37] = true;
load("talkblue_4");
position--;
}
else if (!obj.flags[38] && game.crewstats[3])
{
obj.flags[38] = true;
load("talkblue_5");
position--;
}
else if (!obj.flags[39] && game.crewstats[4])
{
obj.flags[39] = true;
load("talkblue_6");
position--;
}
else
{
//if all else fails:
//if yellow is found
if (game.crewstats[2])
{
load("talkblue_2");
position--;
}
else
{
load("talkblue_1");
position--;
}
}
}
else if (words[0] == "yellowcontrol")
{
if (game.insecretlab)
{
load("talkyellow_12");
position--;
}
else if (obj.flags[67])
{
//game complete
load("talkyellow_11");
position--;
}
else if (obj.flags[32] && !obj.flags[31])
{
//Intermission level
obj.flags[31] = true;
load("talkyellow_6");
position--;
}
else if (!obj.flags[27] && game.crewstats[2])
{
//Back on the ship!
obj.flags[27] = true;
load("talkyellow_10");
position--;
}
else if (!obj.flags[43] && game.crewrescued() == 5 && !game.crewstats[5])
{
//If by chance we've rescued everyone except Victoria by the end, Vitellary provides you with
//the trinket information instead.
obj.flags[43] = true;
obj.flags[42] = true;
obj.flags[41] = true;
load("talkyellow_trinket1");
position--;
}
else if (!obj.flags[24] && game.crewstats[5])
{
obj.flags[24] = true;
load("talkyellow_8");
position--;
}
else if (!obj.flags[26] && game.crewstats[4])
{
obj.flags[26] = true;
load("talkyellow_7");
position--;
}
else if (!obj.flags[25] && game.crewstats[3])
{
obj.flags[25] = true;
load("talkyellow_9");
position--;
}
else if (!obj.flags[28])
{
obj.flags[28] = true;
load("talkyellow_3");
position--;
}
else if (!obj.flags[29])
{
obj.flags[29] = true;
load("talkyellow_4");
position--;
}
else if (!obj.flags[30])
{
obj.flags[30] = true;
load("talkyellow_5");
position--;
}
else if (!obj.flags[23])
{
obj.flags[23] = true;
load("talkyellow_2");
position--;
}
else
{
load("talkyellow_1");
position--;
obj.flags[23] = false;
}
}
else if (words[0] == "purplecontrol")
{
//Controls Purple's conversion
//Crew rescued:
if (game.insecretlab)
{
load("talkpurple_9");
position--;
}
else if (obj.flags[67])
{
//game complete
load("talkpurple_8");
position--;
}
else if (!obj.flags[17] && game.crewstats[4])
{
obj.flags[17] = true;
load("talkpurple_6");
position--;
}
else if (!obj.flags[15] && game.crewstats[5])
{
obj.flags[15] = true;
load("talkpurple_4");
position--;
}
else if (!obj.flags[16] && game.crewstats[3])
{
obj.flags[16] = true;
load("talkpurple_5");
position--;
}
else if (!obj.flags[18] && game.crewstats[2])
{
obj.flags[18] = true;
load("talkpurple_7");
position--;
}
else if (obj.flags[19] && !obj.flags[20] && !obj.flags[21])
{
//intermission one: if played one / not had first conversation / not played two [conversation one]
obj.flags[21] = true;
load("talkpurple_intermission1");
position--;
}
else if (obj.flags[20] && obj.flags[21] && !obj.flags[22])
{
//intermission two: if played two / had first conversation / not had second conversation [conversation two]
obj.flags[22] = true;
load("talkpurple_intermission2");
position--;
}
else if (obj.flags[20] && !obj.flags[21] && !obj.flags[22])
{
//intermission two: if played two / not had first conversation / not had second conversation [conversation three]
obj.flags[22] = true;
load("talkpurple_intermission3");
position--;
}
else if (!obj.flags[12])
{
//Intro conversation
obj.flags[12] = true;
load("talkpurple_intro");
position--;
}
else if (!obj.flags[14])
{
//Shorter intro conversation
obj.flags[14] = true;
load("talkpurple_3");
position--;
}
else
{
//if all else fails:
//if green is found
if (game.crewstats[4])
{
load("talkpurple_2");
position--;
}
else
{
load("talkpurple_1");
position--;
}
}
}
Add textbuttons() script command, make Violet's ENTER dialogue dynamic Violet's dialogue now looks like this: squeak(purple) text(purple,0,0,2) Remember that you can press {b_map} to check where you are on the map! position(purple,above) textbuttons() speak_active The new textbuttons() command sets the next textbox to replace {b_map} with the map button, and {b_int} with the interact button. The remaining keys would be added as soon as they need to be added to ActionSets.h as well.
2023-03-18 22:31:13 +01:00
else if (words[0] == "textbuttons")
{
// Parse buttons in the next textbox
textbuttons = true;
}
Add localization "foundation" (many code changes) This commit adds most of the code changes necessary for making the game translatable, but does not yet "unhardcode" nearly all of the strings (except in a few cases where it was hard to separate added loc::gettexts from foundational code changes, or all the localization- related menus which were also added by this commit.) This commit is part of rewritten history of the localization branch. The original (unsquashed) commit history can be found here: https://github.com/Dav999-v/VVVVVV/tree/localization-orig
2022-12-30 22:57:24 +01:00
else if (words[0] == "textcase")
{
// Used to disambiguate identical textboxes for translations (1 by default)
Add bounds check to textcase() command This makes it so that only inputs between 1 and 255 inclusive will be accepted. Otherwise, the command has no effect. This is because the text case is stored as one byte in a string, and a value of zero would be the null terminator. We also want to minimize potential weirdness with integer wrapping if we accept inputs from outside those bounds. While the textcase variable as used throughout the codebase is plain unqualified `char` (which, unlike other integers, exists in a quantum superposition of being signed and unsigned depending on compiler, machine, and various other stuff) and so there still might be issues there, we definitely don't want anything higher than 255.
2024-01-10 08:57:14 +01:00
const int number = ss_toi(words[1]);
if (number >= 1 && number <= 255)
{
textcase = number;
}
Add localization "foundation" (many code changes) This commit adds most of the code changes necessary for making the game translatable, but does not yet "unhardcode" nearly all of the strings (except in a few cases where it was hard to separate added loc::gettexts from foundational code changes, or all the localization- related menus which were also added by this commit.) This commit is part of rewritten history of the localization branch. The original (unsquashed) commit history can be found here: https://github.com/Dav999-v/VVVVVV/tree/localization-orig
2022-12-30 22:57:24 +01:00
}
else if (words[0] == "loadtext")
{
if (map.custommode)
{
Fix iflang, loadtext and setfont not working with uppercase For example, pt_PT/pt_BR needs to work as well, and now it does.
2023-07-23 00:06:26 +02:00
loc::lang_custom = raw_words[1];
Add localization "foundation" (many code changes) This commit adds most of the code changes necessary for making the game translatable, but does not yet "unhardcode" nearly all of the strings (except in a few cases where it was hard to separate added loc::gettexts from foundational code changes, or all the localization- related menus which were also added by this commit.) This commit is part of rewritten history of the localization branch. The original (unsquashed) commit history can be found here: https://github.com/Dav999-v/VVVVVV/tree/localization-orig
2022-12-30 22:57:24 +01:00
loc::loadtext_custom(NULL);
}
}
else if (words[0] == "iflang")
{
Fix iflang, loadtext and setfont not working with uppercase For example, pt_PT/pt_BR needs to work as well, and now it does.
2023-07-23 00:06:26 +02:00
if (loc::lang == raw_words[1])
Add localization "foundation" (many code changes) This commit adds most of the code changes necessary for making the game translatable, but does not yet "unhardcode" nearly all of the strings (except in a few cases where it was hard to separate added loc::gettexts from foundational code changes, or all the localization- related menus which were also added by this commit.) This commit is part of rewritten history of the localization branch. The original (unsquashed) commit history can be found here: https://github.com/Dav999-v/VVVVVV/tree/localization-orig
2022-12-30 22:57:24 +01:00
{
Prioritize loading processed script names This makes it so that whenever the game loads a script as directed by a script command, it will first try to load the script from the processed argument, and if that fails only then will it try to load the script from the raw argument. This fixes a regression reported by Dav999 in the custom level "Vungeon" created by Dynaboom, where a script `ifflag`s to `aselectP1.1` even though the actual script name is `aselectp1.1`. In 2.3, it would lowercase `aselectP1.1` and load the script properly, but previous to this commit it would try to load the script with a capital name and then fail.
2023-02-01 05:04:18 +01:00
loadalts("custom_" + words[2], "custom_" + raw_words[2]);
Add localization "foundation" (many code changes) This commit adds most of the code changes necessary for making the game translatable, but does not yet "unhardcode" nearly all of the strings (except in a few cases where it was hard to separate added loc::gettexts from foundational code changes, or all the localization- related menus which were also added by this commit.) This commit is part of rewritten history of the localization branch. The original (unsquashed) commit history can be found here: https://github.com/Dav999-v/VVVVVV/tree/localization-orig
2022-12-30 22:57:24 +01:00
position--;
}
}
Add setrtl(on/off) scripting command With the <font> tag (which doesn't indicate RTL-ness as explained), we've had a setfont(font) scripting command. Now we have an <rtl> tag, so we need a setrtl(on/off) command too to control that.
2024-01-03 20:43:37 +01:00
else if (words[0] == "setfont" || words[0] == "setrtl")
Add setfont scripting command The <font> in the level file is basically the starting font, but it can be changed at any time via scripting.
2023-01-20 04:57:06 +01:00
{
Properly fix setfont/setrtl in between text boxes There used to be a problem with the setfont and setrtl script commands. Namely, if you used them in between text boxes naïvely, without any careful thought, then the fading out text box would suddenly gain the font of the new one. A kludge solution to this was implemented by simply blocking the script until the existing text box faded out before switching the font or RTL, and shipped for 2.4.0. However, a better solution is to simply bake the font flags in to the text box, so that way, if the level font switches, then the text box keeps its font. This is only for custom levels, because in the main game, the font in a text box needs to be able to change depending on language. But it seems like custom level translations weren't much on the roadmap, and so even the existing hack didn't support changing the font based on translation (even though translation of custom level cutscenes is supported). So baking the font flags into the text box here doesn't make things any worse. It also makes things better, arguably, by allowing multiple text boxes to exist on screen at once with different fonts. Maybe in the future we'll need a flag that specifies that the font should change depending on language if a translation in said language exists for the text box, or something like that. For people that want to override the fonts of every existing text box on screen, you can specify "all" as the second parameter of setfont or setrtl to do so.
2024-01-22 07:09:35 +01:00
if (words[0] == "setrtl")
Add setfont scripting command The <font> in the level file is basically the starting font, but it can be changed at any time via scripting.
2023-01-20 04:57:06 +01:00
{
Properly fix setfont/setrtl in between text boxes There used to be a problem with the setfont and setrtl script commands. Namely, if you used them in between text boxes naïvely, without any careful thought, then the fading out text box would suddenly gain the font of the new one. A kludge solution to this was implemented by simply blocking the script until the existing text box faded out before switching the font or RTL, and shipped for 2.4.0. However, a better solution is to simply bake the font flags in to the text box, so that way, if the level font switches, then the text box keeps its font. This is only for custom levels, because in the main game, the font in a text box needs to be able to change depending on language. But it seems like custom level translations weren't much on the roadmap, and so even the existing hack didn't support changing the font based on translation (even though translation of custom level cutscenes is supported). So baking the font flags into the text box here doesn't make things any worse. It also makes things better, arguably, by allowing multiple text boxes to exist on screen at once with different fonts. Maybe in the future we'll need a flag that specifies that the font should change depending on language if a translation in said language exists for the text box, or something like that. For people that want to override the fonts of every existing text box on screen, you can specify "all" as the second parameter of setfont or setrtl to do so.
2024-01-22 07:09:35 +01:00
if (words[1] == "on")
Fix setfont() changing font of fading out text boxes Closes #925. My fix here is to delay the font change until all fading-out textboxes have disappeared. See it as adding a sort of `untilbars` or `untilfade` for text box fadeout, into setfont. This doesn't prevent every possible way to change the font of an existing textbox, but you would need to use internal scripting to still do it (and basically be doing it on purpose) - the problem in simplified scripting when you simply do textbox-setfont-textbox is gone.
2023-08-28 03:19:57 +02:00
{
Properly fix setfont/setrtl in between text boxes There used to be a problem with the setfont and setrtl script commands. Namely, if you used them in between text boxes naïvely, without any careful thought, then the fading out text box would suddenly gain the font of the new one. A kludge solution to this was implemented by simply blocking the script until the existing text box faded out before switching the font or RTL, and shipped for 2.4.0. However, a better solution is to simply bake the font flags in to the text box, so that way, if the level font switches, then the text box keeps its font. This is only for custom levels, because in the main game, the font in a text box needs to be able to change depending on language. But it seems like custom level translations weren't much on the roadmap, and so even the existing hack didn't support changing the font based on translation (even though translation of custom level cutscenes is supported). So baking the font flags into the text box here doesn't make things any worse. It also makes things better, arguably, by allowing multiple text boxes to exist on screen at once with different fonts. Maybe in the future we'll need a flag that specifies that the font should change depending on language if a translation in said language exists for the text box, or something like that. For people that want to override the fonts of every existing text box on screen, you can specify "all" as the second parameter of setfont or setrtl to do so.
2024-01-22 07:09:35 +01:00
cl.rtl = true;
Fix setfont() changing font of fading out text boxes Closes #925. My fix here is to delay the font change until all fading-out textboxes have disappeared. See it as adding a sort of `untilbars` or `untilfade` for text box fadeout, into setfont. This doesn't prevent every possible way to change the font of an existing textbox, but you would need to use internal scripting to still do it (and basically be doing it on purpose) - the problem in simplified scripting when you simply do textbox-setfont-textbox is gone.
2023-08-28 03:19:57 +02:00
}
Properly fix setfont/setrtl in between text boxes There used to be a problem with the setfont and setrtl script commands. Namely, if you used them in between text boxes naïvely, without any careful thought, then the fading out text box would suddenly gain the font of the new one. A kludge solution to this was implemented by simply blocking the script until the existing text box faded out before switching the font or RTL, and shipped for 2.4.0. However, a better solution is to simply bake the font flags in to the text box, so that way, if the level font switches, then the text box keeps its font. This is only for custom levels, because in the main game, the font in a text box needs to be able to change depending on language. But it seems like custom level translations weren't much on the roadmap, and so even the existing hack didn't support changing the font based on translation (even though translation of custom level cutscenes is supported). So baking the font flags into the text box here doesn't make things any worse. It also makes things better, arguably, by allowing multiple text boxes to exist on screen at once with different fonts. Maybe in the future we'll need a flag that specifies that the font should change depending on language if a translation in said language exists for the text box, or something like that. For people that want to override the fonts of every existing text box on screen, you can specify "all" as the second parameter of setfont or setrtl to do so.
2024-01-22 07:09:35 +01:00
else if (words[1] == "off")
Add setrtl(on/off) scripting command With the <font> tag (which doesn't indicate RTL-ness as explained), we've had a setfont(font) scripting command. Now we have an <rtl> tag, so we need a setrtl(on/off) command too to control that.
2024-01-03 20:43:37 +01:00
{
Properly fix setfont/setrtl in between text boxes There used to be a problem with the setfont and setrtl script commands. Namely, if you used them in between text boxes naïvely, without any careful thought, then the fading out text box would suddenly gain the font of the new one. A kludge solution to this was implemented by simply blocking the script until the existing text box faded out before switching the font or RTL, and shipped for 2.4.0. However, a better solution is to simply bake the font flags in to the text box, so that way, if the level font switches, then the text box keeps its font. This is only for custom levels, because in the main game, the font in a text box needs to be able to change depending on language. But it seems like custom level translations weren't much on the roadmap, and so even the existing hack didn't support changing the font based on translation (even though translation of custom level cutscenes is supported). So baking the font flags into the text box here doesn't make things any worse. It also makes things better, arguably, by allowing multiple text boxes to exist on screen at once with different fonts. Maybe in the future we'll need a flag that specifies that the font should change depending on language if a translation in said language exists for the text box, or something like that. For people that want to override the fonts of every existing text box on screen, you can specify "all" as the second parameter of setfont or setrtl to do so.
2024-01-22 07:09:35 +01:00
cl.rtl = false;
Add setrtl(on/off) scripting command With the <font> tag (which doesn't indicate RTL-ness as explained), we've had a setfont(font) scripting command. Now we have an <rtl> tag, so we need a setrtl(on/off) command too to control that.
2024-01-03 20:43:37 +01:00
}
Properly fix setfont/setrtl in between text boxes There used to be a problem with the setfont and setrtl script commands. Namely, if you used them in between text boxes naïvely, without any careful thought, then the fading out text box would suddenly gain the font of the new one. A kludge solution to this was implemented by simply blocking the script until the existing text box faded out before switching the font or RTL, and shipped for 2.4.0. However, a better solution is to simply bake the font flags in to the text box, so that way, if the level font switches, then the text box keeps its font. This is only for custom levels, because in the main game, the font in a text box needs to be able to change depending on language. But it seems like custom level translations weren't much on the roadmap, and so even the existing hack didn't support changing the font based on translation (even though translation of custom level cutscenes is supported). So baking the font flags into the text box here doesn't make things any worse. It also makes things better, arguably, by allowing multiple text boxes to exist on screen at once with different fonts. Maybe in the future we'll need a flag that specifies that the font should change depending on language if a translation in said language exists for the text box, or something like that. For people that want to override the fonts of every existing text box on screen, you can specify "all" as the second parameter of setfont or setrtl to do so.
2024-01-22 07:09:35 +01:00
}
else if (words[1] == "")
{
font::set_level_font(cl.level_font_name.c_str());
}
else
{
font::set_level_font(raw_words[1].c_str());
}
Remove 'all' argument from setrtl It doesn't make sense to change the alignment of all existing text boxes when you're not otherwise able to mutate the text. Whereas the point of the 'all' argument in setfont is to be able to animate text boxes using fonts.
2024-01-24 01:53:01 +01:00
if (words[0] == "setfont" && argexists[2] && words[2] == "all")
Properly fix setfont/setrtl in between text boxes There used to be a problem with the setfont and setrtl script commands. Namely, if you used them in between text boxes naïvely, without any careful thought, then the fading out text box would suddenly gain the font of the new one. A kludge solution to this was implemented by simply blocking the script until the existing text box faded out before switching the font or RTL, and shipped for 2.4.0. However, a better solution is to simply bake the font flags in to the text box, so that way, if the level font switches, then the text box keeps its font. This is only for custom levels, because in the main game, the font in a text box needs to be able to change depending on language. But it seems like custom level translations weren't much on the roadmap, and so even the existing hack didn't support changing the font based on translation (even though translation of custom level cutscenes is supported). So baking the font flags into the text box here doesn't make things any worse. It also makes things better, arguably, by allowing multiple text boxes to exist on screen at once with different fonts. Maybe in the future we'll need a flag that specifies that the font should change depending on language if a translation in said language exists for the text box, or something like that. For people that want to override the fonts of every existing text box on screen, you can specify "all" as the second parameter of setfont or setrtl to do so.
2024-01-22 07:09:35 +01:00
{
/* Immediately update all text boxes. */
uint32_t flags = PR_FONT_IDX(font::font_idx_level, cl.rtl);
if (font::font_idx_level_is_custom)
Fix setfont() changing font of fading out text boxes Closes #925. My fix here is to delay the font change until all fading-out textboxes have disappeared. See it as adding a sort of `untilbars` or `untilfade` for text box fadeout, into setfont. This doesn't prevent every possible way to change the font of an existing textbox, but you would need to use internal scripting to still do it (and basically be doing it on purpose) - the problem in simplified scripting when you simply do textbox-setfont-textbox is gone.
2023-08-28 03:19:57 +02:00
{
Properly fix setfont/setrtl in between text boxes There used to be a problem with the setfont and setrtl script commands. Namely, if you used them in between text boxes naïvely, without any careful thought, then the fading out text box would suddenly gain the font of the new one. A kludge solution to this was implemented by simply blocking the script until the existing text box faded out before switching the font or RTL, and shipped for 2.4.0. However, a better solution is to simply bake the font flags in to the text box, so that way, if the level font switches, then the text box keeps its font. This is only for custom levels, because in the main game, the font in a text box needs to be able to change depending on language. But it seems like custom level translations weren't much on the roadmap, and so even the existing hack didn't support changing the font based on translation (even though translation of custom level cutscenes is supported). So baking the font flags into the text box here doesn't make things any worse. It also makes things better, arguably, by allowing multiple text boxes to exist on screen at once with different fonts. Maybe in the future we'll need a flag that specifies that the font should change depending on language if a translation in said language exists for the text box, or something like that. For people that want to override the fonts of every existing text box on screen, you can specify "all" as the second parameter of setfont or setrtl to do so.
2024-01-22 07:09:35 +01:00
flags |= PR_FONT_IDX_IS_CUSTOM;
Fix setfont() changing font of fading out text boxes Closes #925. My fix here is to delay the font change until all fading-out textboxes have disappeared. See it as adding a sort of `untilbars` or `untilfade` for text box fadeout, into setfont. This doesn't prevent every possible way to change the font of an existing textbox, but you would need to use internal scripting to still do it (and basically be doing it on purpose) - the problem in simplified scripting when you simply do textbox-setfont-textbox is gone.
2023-08-28 03:19:57 +02:00
}
Properly fix setfont/setrtl in between text boxes There used to be a problem with the setfont and setrtl script commands. Namely, if you used them in between text boxes naïvely, without any careful thought, then the fading out text box would suddenly gain the font of the new one. A kludge solution to this was implemented by simply blocking the script until the existing text box faded out before switching the font or RTL, and shipped for 2.4.0. However, a better solution is to simply bake the font flags in to the text box, so that way, if the level font switches, then the text box keeps its font. This is only for custom levels, because in the main game, the font in a text box needs to be able to change depending on language. But it seems like custom level translations weren't much on the roadmap, and so even the existing hack didn't support changing the font based on translation (even though translation of custom level cutscenes is supported). So baking the font flags into the text box here doesn't make things any worse. It also makes things better, arguably, by allowing multiple text boxes to exist on screen at once with different fonts. Maybe in the future we'll need a flag that specifies that the font should change depending on language if a translation in said language exists for the text box, or something like that. For people that want to override the fonts of every existing text box on screen, you can specify "all" as the second parameter of setfont or setrtl to do so.
2024-01-22 07:09:35 +01:00
for (size_t i = 0; i < graphics.textboxes.size(); i++)
Fix setfont() changing font of fading out text boxes Closes #925. My fix here is to delay the font change until all fading-out textboxes have disappeared. See it as adding a sort of `untilbars` or `untilfade` for text box fadeout, into setfont. This doesn't prevent every possible way to change the font of an existing textbox, but you would need to use internal scripting to still do it (and basically be doing it on purpose) - the problem in simplified scripting when you simply do textbox-setfont-textbox is gone.
2023-08-28 03:19:57 +02:00
{
Properly fix setfont/setrtl in between text boxes There used to be a problem with the setfont and setrtl script commands. Namely, if you used them in between text boxes naïvely, without any careful thought, then the fading out text box would suddenly gain the font of the new one. A kludge solution to this was implemented by simply blocking the script until the existing text box faded out before switching the font or RTL, and shipped for 2.4.0. However, a better solution is to simply bake the font flags in to the text box, so that way, if the level font switches, then the text box keeps its font. This is only for custom levels, because in the main game, the font in a text box needs to be able to change depending on language. But it seems like custom level translations weren't much on the roadmap, and so even the existing hack didn't support changing the font based on translation (even though translation of custom level cutscenes is supported). So baking the font flags into the text box here doesn't make things any worse. It also makes things better, arguably, by allowing multiple text boxes to exist on screen at once with different fonts. Maybe in the future we'll need a flag that specifies that the font should change depending on language if a translation in said language exists for the text box, or something like that. For people that want to override the fonts of every existing text box on screen, you can specify "all" as the second parameter of setfont or setrtl to do so.
2024-01-22 07:09:35 +01:00
graphics.textboxes[i].print_flags = flags;
graphics.textboxes[i].resize();
Fix setfont() changing font of fading out text boxes Closes #925. My fix here is to delay the font change until all fading-out textboxes have disappeared. See it as adding a sort of `untilbars` or `untilfade` for text box fadeout, into setfont. This doesn't prevent every possible way to change the font of an existing textbox, but you would need to use internal scripting to still do it (and basically be doing it on purpose) - the problem in simplified scripting when you simply do textbox-setfont-textbox is gone.
2023-08-28 03:19:57 +02:00
}
Add setfont scripting command The <font> in the level file is basically the starting font, but it can be changed at any time via scripting.
2023-01-20 04:57:06 +01:00
}
}
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
position++;
}
else
{
running = false;
}
// Don't increment if we're at the max, signed int overflow is UB
if (execution_counter == SHRT_MAX)
{
// We must be in an infinite loop
vlog_warn("Warning: execution counter got to %i, stopping script", SHRT_MAX);
running = false;
}
else
{
execution_counter++;
}
}
if(scriptdelay>0)
{
scriptdelay--;
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Do not close game if custom level has assets issues It's quite rude to close the game entirely if there is trouble with assets. Instead, just unload the assets and gracefully return to the title screen.
2021-08-07 05:57:34 +02:00
static void gotoerrorloadinglevel(void)
{
Use quittomenu in gotoerrorloadinglevel game.quittomenu() correctly resets state, as it's the function that's always used when quitting to menu. This fixes a bug where if a level with assets failed to load, it wouldn't unload the assets.
2023-05-17 20:45:21 +02:00
game.quittomenu();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
game.createmenu(Menu::errorloadinglevel);
music.currentsong = -1; /* otherwise music.play won't work */
Use enums for music tracks This adds an anonymous enum for music tracks and replaces all calls to music.play and music.niceplay that use integer literals. Additionally, this is also done for integer literals for cl.levmusic (except 0) and music.currentsong where appropriate, but _not_ the music areamap because that would not make it look very aesthetically pleasing in the code. This is not a named enum (that can be used for strict typechecking) because music track IDs are essentially part of the API of the game - almost every custom level uses these numbers. This is just to make the source code more readable without needing a comment to denote what number is what track.
2023-05-24 03:37:32 +02:00
music.play(Music_PRESENTINGVVVVVV);
Do not close game if custom level has assets issues It's quite rude to close the game entirely if there is trouble with assets. Instead, just unload the assets and gracefully return to the title screen.
2021-08-07 05:57:34 +02:00
}
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
#define DECLARE_MODE_FUNC(funcname, modename) \
static bool funcname(const enum StartMode mode) \
{ \
return mode >= Start_FIRST_##modename && mode <= Start_LAST_##modename; \
}
DECLARE_MODE_FUNC(is_no_death_mode, NODEATHMODE)
DECLARE_MODE_FUNC(is_intermission_1, INTERMISSION1)
DECLARE_MODE_FUNC(is_intermission_2, INTERMISSION2)
#undef DECLARE_MODE_FUNC
void scriptclass::startgamemode(const enum StartMode mode)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
if (mode == Start_QUIT)
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
VVV_exit(0);
}
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
Always destroy and create new player in startgamemode This fixes a bug where players could flip in mid-air at the start of custom levels whose start points were in mid-air, because onground/onroof were not being reset. This could also be done when loading in to a save with a checkpoint in mid-air. All that's required is to exit the game while standing on a surface (or otherwise having a nonzero onground/onroof). This reminded me that there were other variables on the player entity persisting through that made loading in to a level not have a totally clean slate, such as walkingframe (which could affect sequencing individual TASes together into one TAS), so it's better to just destroy the player entity and recreate it. Except some attributes still have to be persisted for 2.2 and 2.0 glitchrunner mode. But it's better that this is done via a whitelist rather than a blacklist. The player duplicate removal code in hardreset is mostly redundant now (except for some very unlikely corner cases), but there's nothing wrong with having redundant code as long as it's not harmful. I had a paragraph here justifying why it could be removed but decided it was simpler to just keep it.
2022-12-30 00:00:01 +01:00
struct
{
bool initialized;
int size;
int cx;
int cy;
int w;
int h;
}
player_hitbox;
SDL_zero(player_hitbox);
if (GlitchrunnerMode_less_than_or_equal(Glitchrunner2_2))
{
/* Preserve player hitbox */
const int player_idx = obj.getplayer();
if (INBOUNDS_VEC(player_idx, obj.entities))
{
const entclass* player = &obj.entities[player_idx];
player_hitbox.initialized = true;
player_hitbox.size = player->size;
player_hitbox.cx = player->cx;
player_hitbox.cy = player->cy;
player_hitbox.w = player->w;
player_hitbox.h = player->h;
}
}
Reset textbox colors properly
2023-03-27 22:53:13 +02:00
/* Containers which need to be reset before gameplay starts
* ex. before custom levels get loaded */
switch (mode)
{
case Start_EDITORPLAYTESTING:
break;
default:
textbox_colours.clear();
add_default_colours();
break;
}
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
hardreset();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
if (mode == Start_EDITOR)
{
game.gamestate = EDITORMODE;
}
else
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
game.gamestate = GAMEMODE;
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
}
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
Add menu for selecting the level font By default, when you open the level editor to start a new level, the level font will now match your VVVVVV language; so if you're, say, Japanese, then you can make Japanese levels from the get-go. If you want to make levels for a different target audience, you can change the font via a new menu (map settings > change description > change font). The game will remember this choice and it will become the new initial level font.
2023-01-21 19:06:30 +01:00
// Font handling
Make main game content use interface font instead of 8x8 font If a custom level doesn't specify a font, it should be the 8x8 font. But the main game can't specify a font, it's just the interface font because that's for the language that the game is in.
2023-01-21 03:27:55 +01:00
switch (mode)
{
case Start_EDITORPLAYTESTING:
case Start_CUSTOM:
case Start_CUSTOM_QUICKSAVE:
break;
Add menu for selecting the level font By default, when you open the level editor to start a new level, the level font will now match your VVVVVV language; so if you're, say, Japanese, then you can make Japanese levels from the get-go. If you want to make levels for a different target audience, you can change the font via a new menu (map settings > change description > change font). The game will remember this choice and it will become the new initial level font.
2023-01-21 19:06:30 +01:00
case Start_EDITOR:
font::set_level_font_new();
break;
Make main game content use interface font instead of 8x8 font If a custom level doesn't specify a font, it should be the 8x8 font. But the main game can't specify a font, it's just the interface font because that's for the language that the game is in.
2023-01-21 03:27:55 +01:00
default:
font::set_level_font_interface();
}
Indicate modes when loading in to gameplay If you load in to gameplay with invincibility mode, glitchrunner mode, Flip Mode, or slowdown enabled, then there will be text displayed on screen for a few seconds that says so. This is to serve as a useful reminder. A common pitfall with using invincibility is forgetting to turn it off when you don't want it anymore. What usually happens is that players forget that they have it on until they encounter a hazard. Now, they can realize it as soon as they load in. See #1091.
2024-01-07 05:53:51 +01:00
/* Indicate invincibility, glitchrunner, etc. for all modes except these */
switch (mode)
{
case Start_EDITOR:
case Start_CUTSCENETEST:
break;
case Start_QUIT:
VVV_unreachable();
default:
/* If there's editor return text, make this show up after it */
game.mode_indicator_timer = ed.return_message_timer + 2000;
game.old_mode_indicator_timer = game.mode_indicator_timer;
}
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
game.jumpheld = true;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
switch (mode)
{
case Start_MAINGAME:
case Start_MAINGAME_TELESAVE:
case Start_MAINGAME_QUICKSAVE:
case Start_NODEATHMODE_WITHCUTSCENES:
case Start_NODEATHMODE_NOCUTSCENES:
game.nodeathmode = is_no_death_mode(mode);
game.nocutscenes = (mode == Start_NODEATHMODE_NOCUTSCENES);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
game.start();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
switch (mode)
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
case Start_MAINGAME_TELESAVE:
game.loadtele();
graphics.fademode = FADE_START_FADEIN;
break;
case Start_MAINGAME_QUICKSAVE:
game.loadquick();
graphics.fademode = FADE_START_FADEIN;
break;
default:
graphics.showcutscenebars = true;
graphics.setbars(320);
load("intro");
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
break;
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
case Start_TIMETRIAL_SPACESTATION1:
case Start_TIMETRIAL_LABORATORY:
case Start_TIMETRIAL_TOWER:
case Start_TIMETRIAL_SPACESTATION2:
case Start_TIMETRIAL_WARPZONE:
case Start_TIMETRIAL_FINALLEVEL:
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
music.fadeout();
game.nocutscenes = true;
game.intimetrial = true;
game.timetrialcountdown = 150;
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
game.timetriallevel = mode - Start_FIRST_TIMETRIAL;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
Add localization "foundation" (many code changes) This commit adds most of the code changes necessary for making the game translatable, but does not yet "unhardcode" nearly all of the strings (except in a few cases where it was hard to separate added loc::gettexts from foundational code changes, or all the localization- related menus which were also added by this commit.) This commit is part of rewritten history of the localization branch. The original (unsquashed) commit history can be found here: https://github.com/Dav999-v/VVVVVV/tree/localization-orig
2022-12-30 22:57:24 +01:00
if (map.invincibility)
{
game.sabotage_time_trial();
}
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
switch (mode)
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
case Start_TIMETRIAL_SPACESTATION1:
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
game.timetrialpar = 75;
game.timetrialshinytarget = 2;
break;
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
case Start_TIMETRIAL_LABORATORY:
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
game.timetrialpar = 165;
game.timetrialshinytarget = 4;
break;
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
case Start_TIMETRIAL_TOWER:
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
game.timetrialpar = 105;
game.timetrialshinytarget = 2;
break;
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
case Start_TIMETRIAL_SPACESTATION2:
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
game.timetrialpar = 200;
game.timetrialshinytarget = 5;
break;
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
case Start_TIMETRIAL_WARPZONE:
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
game.timetrialpar = 120;
game.timetrialshinytarget = 1;
break;
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
case Start_TIMETRIAL_FINALLEVEL:
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
game.timetrialpar = 135;
game.timetrialshinytarget = 1;
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
map.finalmode = true;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
map.final_colormode = false;
map.final_mapcol = 0;
map.final_colorframe = 0;
break;
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
default:
VVV_unreachable();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
game.starttrial(game.timetriallevel);
Add level exploring menu for translators I would, of course, recommend translators to translate the roomnames while playing the full game (optionally in invincibility) so they can immediately get all the context and maybe the most inspiration. And if you want to go back into a specific level, then there's always the time trials and intermission replays which will give you full coverage of all the room names. However, the time trials weren't really made for room name translation. They have some annoying features like the instant restart when you press ENTER at the wrong time, they remove context clues like teleporters and companions, but the worst problem is that the last room in a level is often completely untranslatable inside the time trials because you immediately get sent to the results screen... So, I added a new menu in the translator options, "explore game", which gives you access to all the time trials and the two intermissions, from the same menu. All these time trials (which they're still based off of, under the hood) are stripped of the annoying features that come with time trials. These are the changes I made to time trial behavior in translator exploring mode: - No 3-2-1-Go! countdown - No on-screen time/death/shiny/par - ENTER doesn't restart, and the map menu works. The entire map is also revealed. - Prize for the Reckless is in its normal form - The teleporters in Entanglement Generator, Wheeler's Wormhole and Level Complete are restored as context for room names (actually, we should probably restore them in time trials anyway? Their "press to teleport" prompt is already blocked out in time trials and they do nothing other than being a checkpoint. I guess the reason they were removed was to stop people from opening the teleporter menu when that was not specifically blocked out in time trials yet.) - The companions are there at the end of levels, and behave like in no death mode (become happy and follow you to the teleporter). Also for context. - At the end of each level, you're not suddenly sent to the menu, but you can use the teleporter at your leisure just like in the intermission replays. In the Final Level, you do get sent to the menu automatically, but after a longer delay. I made another mark on VVVVVV: don't be startled, I added gamestates. I wanted all teleporters at the end of levels to behave like the ones at the end of the intermission replays, and all handling for teleporting with specific companions is already done in gamestates, so rather than adding conditional blocks across 5 or so different gamestates, it made more sense to make a single gamestate for "teleporting in translator exploring mode" (3090). I also added an alternative to having to use gamestate 3500 or 82 for the end of the final level: 3091-3092. One other thing I want to add to the "explore game" menu: a per-level count of how many room names are left to translate. That shouldn't be too difficult, and I'm planning that for the next commit.
2022-11-26 03:33:17 +01:00
if (game.translator_exploring)
{
game.timetrialcountdown = 0;
game.timetrialparlost = true;
SDL_memset(map.explored, true, sizeof(map.explored));
}
Enumify all fade modes This removes the magic numbers previously used for controlling the fade mode, which are really not readable at all unless you already know what they mean. 0: FADE_NONE 1: FADE_FULLY_BLACK 2: FADE_START_FADEOUT 3: FADE_FADING_OUT 4: FADE_START_FADEIN 5: FADE_FADING_IN There is also the macro FADEMODE_IS_FADING, which indicates when the intention is to only check if the game is fading right now, which wasn't clearly conveyed previously. I also took the opportunity to clean up the style of any lines I touched. This included rewriting if-else chains into case-switches, turning one-liner if-then statements into proper blocks, fixing up comments, and even commenting the `fademode == FADE_NONE` on the tower spike checks (which, it was previously undocumented why that check was there, but I think I know why it's there). As for type safety, we already get some by transforming the variable types into the enum. Assignment is prohibited without a cast. But, apparently, comparison is perfectly legal and won't even give so much as a warning. To work around this and make absolutely sure I made all existing comparisons now use the enum, I temporarily changed it to be an `enum class`, which is a C++11 feature that makes it so all comparisons are illegal. Unfortunately, it scopes them in a namespace with the same name as a class, so I had to temporarily define macros to make sure my existing code worked. I also had to temporarily up the standard in CMakeLists.txt to get it to compile. But after all that was done, I found the rest of the places where a comparison to an integer was used, and fixed them.
2022-04-25 09:57:47 +02:00
graphics.fademode = FADE_START_FADEIN;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
break;
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
case Start_SECRETLAB:
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
game.startspecial(0);
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
/* Unlock the entire map */
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
SDL_memset(obj.collect, true, sizeof(obj.collect[0]) * 20);
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
/* Give all 20 trinkets */
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
SDL_memset(map.explored, true, sizeof(map.explored));
i = 400; /* previously a nested for-loop set this */
game.insecretlab = true;
map.showteleporters = true;
Use enums for music tracks This adds an anonymous enum for music tracks and replaces all calls to music.play and music.niceplay that use integer literals. Additionally, this is also done for integer literals for cl.levmusic (except 0) and music.currentsong where appropriate, but _not_ the music areamap because that would not make it look very aesthetically pleasing in the code. This is not a named enum (that can be used for strict typechecking) because music track IDs are essentially part of the API of the game - almost every custom level uses these numbers. This is just to make the source code more readable without needing a comment to denote what number is what track.
2023-05-24 03:37:32 +02:00
music.play(Music_PIPEDREAM);
Enumify all fade modes This removes the magic numbers previously used for controlling the fade mode, which are really not readable at all unless you already know what they mean. 0: FADE_NONE 1: FADE_FULLY_BLACK 2: FADE_START_FADEOUT 3: FADE_FADING_OUT 4: FADE_START_FADEIN 5: FADE_FADING_IN There is also the macro FADEMODE_IS_FADING, which indicates when the intention is to only check if the game is fading right now, which wasn't clearly conveyed previously. I also took the opportunity to clean up the style of any lines I touched. This included rewriting if-else chains into case-switches, turning one-liner if-then statements into proper blocks, fixing up comments, and even commenting the `fademode == FADE_NONE` on the tower spike checks (which, it was previously undocumented why that check was there, but I think I know why it's there). As for type safety, we already get some by transforming the variable types into the enum. Assignment is prohibited without a cast. But, apparently, comparison is perfectly legal and won't even give so much as a warning. To work around this and make absolutely sure I made all existing comparisons now use the enum, I temporarily changed it to be an `enum class`, which is a C++11 feature that makes it so all comparisons are illegal. Unfortunately, it scopes them in a namespace with the same name as a class, so I had to temporarily define macros to make sure my existing code worked. I also had to temporarily up the standard in CMakeLists.txt to get it to compile. But after all that was done, I found the rest of the places where a comparison to an integer was used, and fixed them.
2022-04-25 09:57:47 +02:00
graphics.fademode = FADE_START_FADEIN;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
break;
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
case Start_INTERMISSION1_VITELLARY:
case Start_INTERMISSION1_VERMILION:
case Start_INTERMISSION1_VERDIGRIS:
case Start_INTERMISSION1_VICTORIA:
case Start_INTERMISSION2_VITELLARY:
case Start_INTERMISSION2_VERMILION:
case Start_INTERMISSION2_VERDIGRIS:
case Start_INTERMISSION2_VICTORIA:
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
music.fadeout();
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
switch (mode)
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
case Start_INTERMISSION1_VITELLARY:
case Start_INTERMISSION2_VITELLARY:
game.lastsaved = 2;
break;
case Start_INTERMISSION1_VERMILION:
case Start_INTERMISSION2_VERMILION:
game.lastsaved = 3;
break;
case Start_INTERMISSION1_VERDIGRIS:
case Start_INTERMISSION2_VERDIGRIS:
game.lastsaved = 4;
break;
case Start_INTERMISSION1_VICTORIA:
case Start_INTERMISSION2_VICTORIA:
game.lastsaved = 5;
break;
default:
VVV_unreachable();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
game.crewstats[game.lastsaved] = true;
game.inintermission = true;
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
if (is_intermission_1(mode))
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
game.companion = 11;
game.supercrewmate = true;
game.scmprogress = 0;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
map.finalmode = true;
map.final_colormode = false;
map.final_mapcol = 0;
map.final_colorframe = 0;
game.startspecial(1);
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
if (is_intermission_1(mode))
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
load("intermission_1");
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
else if (is_intermission_2(mode))
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
load("intermission_2");
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
break;
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
case Start_EDITOR:
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
cl.reset();
ed.reset();
music.fadeout();
map.custommode = true;
map.custommodeforreal = false;
Enumify all fade modes This removes the magic numbers previously used for controlling the fade mode, which are really not readable at all unless you already know what they mean. 0: FADE_NONE 1: FADE_FULLY_BLACK 2: FADE_START_FADEOUT 3: FADE_FADING_OUT 4: FADE_START_FADEIN 5: FADE_FADING_IN There is also the macro FADEMODE_IS_FADING, which indicates when the intention is to only check if the game is fading right now, which wasn't clearly conveyed previously. I also took the opportunity to clean up the style of any lines I touched. This included rewriting if-else chains into case-switches, turning one-liner if-then statements into proper blocks, fixing up comments, and even commenting the `fademode == FADE_NONE` on the tower spike checks (which, it was previously undocumented why that check was there, but I think I know why it's there). As for type safety, we already get some by transforming the variable types into the enum. Assignment is prohibited without a cast. But, apparently, comparison is perfectly legal and won't even give so much as a warning. To work around this and make absolutely sure I made all existing comparisons now use the enum, I temporarily changed it to be an `enum class`, which is a C++11 feature that makes it so all comparisons are illegal. Unfortunately, it scopes them in a namespace with the same name as a class, so I had to temporarily define macros to make sure my existing code worked. I also had to temporarily up the standard in CMakeLists.txt to get it to compile. But after all that was done, I found the rest of the places where a comparison to an integer was used, and fixed them.
2022-04-25 09:57:47 +02:00
graphics.fademode = FADE_START_FADEIN;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
break;
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
case Start_EDITORPLAYTESTING:
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
music.fadeout();
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
//If warpdir() is used during playtesting, we need to set it back after!
for (int j = 0; j < cl.maxheight; j++)
{
for (int i = 0; i < cl.maxwidth; i++)
{
ed.kludgewarpdir[i+(j*cl.maxwidth)]=cl.roomproperties[i+(j*cl.maxwidth)].warpdir;
}
}
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
game.customstart();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
ed.ghosts.clear();
map.custommode = true;
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
map.custommodeforreal = false;
Move generatecustomminimap to case 21
2022-11-30 17:17:05 +01:00
map.customshowmm = true;
if (cl.levmusic > 0)
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
music.play(cl.levmusic);
Move generatecustomminimap to case 21
2022-11-30 17:17:05 +01:00
}
else
{
music.currentsong = -1;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
break;
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
case Start_CUSTOM:
case Start_CUSTOM_QUICKSAVE:
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
Set custommode and custommodeforreal before loading level This fixes a bug where if a level errors upon loading, it wouldn't take you back to the levels list.
2023-05-17 21:12:36 +02:00
map.custommodeforreal = true;
map.custommode = true;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
std::string filename = std::string(cl.ListOfMetaData[game.playcustomlevel].filename);
if (!cl.load(filename))
{
gotoerrorloadinglevel();
Set TITLEMODE if loading level results in error After the scriptclass::startgamemode refactor, a lot of common code is still being executed even if the level loading failed. This sets the game-gamestate to TITLEMODE in gotoerrorloadinglevel(), and also returns early just in case. Fixes #975.
2023-05-17 17:42:50 +02:00
return;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
cl.findstartpoint();
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
map.customshowmm = true;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
music.fadeout();
game.customstart();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
switch (mode)
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
case Start_CUSTOM:
if (cl.levmusic > 0)
{
music.play(cl.levmusic);
}
else
{
music.currentsong = -1;
}
break;
case Start_CUSTOM_QUICKSAVE:
game.customloadquick(cl.ListOfMetaData[game.playcustomlevel].filename);
break;
default:
VVV_unreachable();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
Enumify all fade modes This removes the magic numbers previously used for controlling the fade mode, which are really not readable at all unless you already know what they mean. 0: FADE_NONE 1: FADE_FULLY_BLACK 2: FADE_START_FADEOUT 3: FADE_FADING_OUT 4: FADE_START_FADEIN 5: FADE_FADING_IN There is also the macro FADEMODE_IS_FADING, which indicates when the intention is to only check if the game is fading right now, which wasn't clearly conveyed previously. I also took the opportunity to clean up the style of any lines I touched. This included rewriting if-else chains into case-switches, turning one-liner if-then statements into proper blocks, fixing up comments, and even commenting the `fademode == FADE_NONE` on the tower spike checks (which, it was previously undocumented why that check was there, but I think I know why it's there). As for type safety, we already get some by transforming the variable types into the enum. Assignment is prohibited without a cast. But, apparently, comparison is perfectly legal and won't even give so much as a warning. To work around this and make absolutely sure I made all existing comparisons now use the enum, I temporarily changed it to be an `enum class`, which is a C++11 feature that makes it so all comparisons are illegal. Unfortunately, it scopes them in a namespace with the same name as a class, so I had to temporarily define macros to make sure my existing code worked. I also had to temporarily up the standard in CMakeLists.txt to get it to compile. But after all that was done, I found the rest of the places where a comparison to an integer was used, and fixed them.
2022-04-25 09:57:47 +02:00
graphics.fademode = FADE_START_FADEIN;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
break;
}
Add cutscene test menu This allows translators to test all text boxes in the scripts. It doesn't run the scripts themselves - it only shows the basic appearance of each text box individually, so context may be lost but it's good to have a way to see any text boxes that might otherwise not be easily seen because they require specific circumstances to appear.
2022-12-24 04:16:56 +01:00
case Start_CUTSCENETEST:
music.fadeout();
game.translator_exploring = true;
game.translator_cutscene_test = true;
game.startspecial(2);
game.mapheld = true;
loadtest(game.cutscenetest_menu_play_id);
break;
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
case Start_QUIT:
VVV_unreachable();
Silence various warnings in builds removing content The MAKEANDPLAY, NO_CUSTOM_LEVELS, and NO_EDITOR defines remove content or features. However, they then raise several warnings because of some cases, functions, or variables that end up not being used. This silences them by using the UNUSED macro, or by adding a default catch-all case if the define is defined (so unhandled cases will still raise warnings in a build that doesn't have these defines).
2023-02-04 09:14:04 +01:00
break;
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
}
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
game.gravitycontrol = game.savegc;
graphics.flipmode = graphics.setflipmode;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
if (!map.custommode && !graphics.setflipmode)
{
/* Invalidate Flip Mode trophy */
obj.flags[73] = true;
}
Always destroy and create new player in startgamemode This fixes a bug where players could flip in mid-air at the start of custom levels whose start points were in mid-air, because onground/onroof were not being reset. This could also be done when loading in to a save with a checkpoint in mid-air. All that's required is to exit the game while standing on a surface (or otherwise having a nonzero onground/onroof). This reminded me that there were other variables on the player entity persisting through that made loading in to a level not have a totally clean slate, such as walkingframe (which could affect sequencing individual TASes together into one TAS), so it's better to just destroy the player entity and recreate it. Except some attributes still have to be persisted for 2.2 and 2.0 glitchrunner mode. But it's better that this is done via a whitelist rather than a blacklist. The player duplicate removal code in hardreset is mostly redundant now (except for some very unlikely corner cases), but there's nothing wrong with having redundant code as long as it's not harmful. I had a paragraph here justifying why it could be removed but decided it was simpler to just keep it.
2022-12-30 00:00:01 +01:00
obj.entities.clear();
obj.createentity(game.savex, game.savey, 0, 0);
if (player_hitbox.initialized)
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
{
Always destroy and create new player in startgamemode This fixes a bug where players could flip in mid-air at the start of custom levels whose start points were in mid-air, because onground/onroof were not being reset. This could also be done when loading in to a save with a checkpoint in mid-air. All that's required is to exit the game while standing on a surface (or otherwise having a nonzero onground/onroof). This reminded me that there were other variables on the player entity persisting through that made loading in to a level not have a totally clean slate, such as walkingframe (which could affect sequencing individual TASes together into one TAS), so it's better to just destroy the player entity and recreate it. Except some attributes still have to be persisted for 2.2 and 2.0 glitchrunner mode. But it's better that this is done via a whitelist rather than a blacklist. The player duplicate removal code in hardreset is mostly redundant now (except for some very unlikely corner cases), but there's nothing wrong with having redundant code as long as it's not harmful. I had a paragraph here justifying why it could be removed but decided it was simpler to just keep it.
2022-12-30 00:00:01 +01:00
/* Restore player hitbox */
const int player_idx = obj.getplayer();
if (INBOUNDS_VEC(player_idx, obj.entities))
{
entclass* player = &obj.entities[player_idx];
player->size = player_hitbox.size;
player->cx = player_hitbox.cx;
player->cy = player_hitbox.cy;
player->w = player_hitbox.w;
player->h = player_hitbox.h;
}
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
}
Always destroy and create new player in startgamemode This fixes a bug where players could flip in mid-air at the start of custom levels whose start points were in mid-air, because onground/onroof were not being reset. This could also be done when loading in to a save with a checkpoint in mid-air. All that's required is to exit the game while standing on a surface (or otherwise having a nonzero onground/onroof). This reminded me that there were other variables on the player entity persisting through that made loading in to a level not have a totally clean slate, such as walkingframe (which could affect sequencing individual TASes together into one TAS), so it's better to just destroy the player entity and recreate it. Except some attributes still have to be persisted for 2.2 and 2.0 glitchrunner mode. But it's better that this is done via a whitelist rather than a blacklist. The player duplicate removal code in hardreset is mostly redundant now (except for some very unlikely corner cases), but there's nothing wrong with having redundant code as long as it's not harmful. I had a paragraph here justifying why it could be removed but decided it was simpler to just keep it.
2022-12-30 00:00:01 +01:00
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
map.resetplayer();
map.gotoroom(game.saverx, game.savery);
map.initmapdata();
if (map.custommode)
{
cl.generatecustomminimap();
}
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
/* If we are spawning in a tower, ensure variables are set correctly */
if (map.towermode)
{
map.resetplayer();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
i = obj.getplayer();
if (INBOUNDS_VEC(i, obj.entities))
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
map.ypos = obj.entities[i].yp - 120;
map.oldypos = map.ypos;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
Refactor scriptclass::startgamemode This overhauls scriptclass::gamemode massively. The first change is that it now uses an enum, and enforces using that enum via using its type instead of an int. This is because whenever you're reading any calls to startgamemode, you have no idea what magic number actually corresponds to what unless you read startgamemode itself. And when you do read it, not every case is commented adequately, so you'd have to do more work to figure out what each case is. With the enum, it's obvious and self-evident, and that also removes the need for all the comments in the function too. Some math is still done on mode variables (to simplify time trial code), but it's okay, we can just cast between int and the enum as needed. The second is that common code is now de-duplicated. There was a lot of code that every case does, such as calling hardreset, setting Flip Mode, resetting the player, calling gotoroom and so on. Now some code may be duplicated between cases, so I've tried to group up similar cases where possible (most notable example is grouping up the main game and No Death Mode cases together). But some code still might be duplicated in the end. Which is okay - I could've tried to de-duplicate it further but that just results in logic relevant to a specific case that's located far from the actual case itself. It's much better to leave things like setting fademode or loading scripts in the case itself. This also fixes a bug since 2.3 where playing No Death Mode (and never opening and closing the options menu) and beating it would also give you the Flip Mode trophy, since turning on the flag to invalidate Flip Mode in startgamemode only happened for the main game cases and in previous versions the game relied upon this flag being set when using a teleporter for some reason (which I removed in 2.3). Now instead of specifying it per case, I just do a !map.custommode check instead so it covers every single case at once.
2022-12-29 23:01:36 +01:00
map.setbgobjlerp(graphics.towerbg);
map.cameramode = 0;
map.colsuperstate = 0;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void scriptclass::teleport(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
//er, ok! Teleport to a new area, so!
//A general rule of thumb: if you teleport with a companion, get rid of them!
game.companion = 0;
i = obj.getplayer(); //less likely to have a serious collision error if the player is centered
if (INBOUNDS_VEC(i, obj.entities))
{
obj.entities[i].xp = 150;
obj.entities[i].yp = 110;
if(game.teleport_to_x==17 && game.teleport_to_y==17) obj.entities[i].xp = 88; //prevent falling!
obj.entities[i].lerpoldxp = obj.entities[i].xp;
obj.entities[i].lerpoldyp = obj.entities[i].yp;
}
if (game.teleportscript == "levelonecomplete")
{
game.teleport_to_x = 2;
game.teleport_to_y = 11;
}
else if (game.teleportscript == "gamecomplete")
{
game.teleport_to_x = 2;
game.teleport_to_y = 11;
}
game.gravitycontrol = 0;
map.gotoroom(100+game.teleport_to_x, 100+game.teleport_to_y);
j = obj.getteleporter();
if (INBOUNDS_VEC(j, obj.entities))
{
obj.entities[j].state = 2;
}
game.teleport_to_new_area = false;
if (INBOUNDS_VEC(j, obj.entities))
{
game.savepoint = obj.entities[j].para;
game.savex = obj.entities[j].xp + 44;
game.savey = obj.entities[j].yp + 44;
}
game.savegc = 0;
game.saverx = game.roomx;
game.savery = game.roomy;
int player = obj.getplayer();
if (INBOUNDS_VEC(player, obj.entities))
{
game.savedir = obj.entities[player].dir;
}
if(game.teleport_to_x==0 && game.teleport_to_y==0)
{
state locking
2022-12-07 00:20:48 +01:00
game.setstate(4020);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else if(game.teleport_to_x==0 && game.teleport_to_y==16)
{
state locking
2022-12-07 00:20:48 +01:00
game.setstate(4030);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else if(game.teleport_to_x==7 && game.teleport_to_y==9)
{
state locking
2022-12-07 00:20:48 +01:00
game.setstate(4040);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else if(game.teleport_to_x==8 && game.teleport_to_y==11)
{
state locking
2022-12-07 00:20:48 +01:00
game.setstate(4050);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else if(game.teleport_to_x==14 && game.teleport_to_y==19)
{
state locking
2022-12-07 00:20:48 +01:00
game.setstate(4030);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else if(game.teleport_to_x==17 && game.teleport_to_y==12)
{
state locking
2022-12-07 00:20:48 +01:00
game.setstate(4020);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else if(game.teleport_to_x==17 && game.teleport_to_y==17)
{
state locking
2022-12-07 00:20:48 +01:00
game.setstate(4020);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else if(game.teleport_to_x==18 && game.teleport_to_y==7)
{
state locking
2022-12-07 00:20:48 +01:00
game.setstate(4060);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else
{
state locking
2022-12-07 00:20:48 +01:00
game.setstate(4010);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
if (game.teleportscript != "")
{
state locking
2022-12-07 00:20:48 +01:00
game.setstate(0);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
load(game.teleportscript);
game.teleportscript = "";
}
else
{
//change music based on location
if (game.teleport_to_x == 2 && game.teleport_to_y == 11)
{
/* Special case: Ship music needs to be set here;
* ship teleporter on music map is -1 for jukebox. */
Use enums for music tracks This adds an anonymous enum for music tracks and replaces all calls to music.play and music.niceplay that use integer literals. Additionally, this is also done for integer literals for cl.levmusic (except 0) and music.currentsong where appropriate, but _not_ the music areamap because that would not make it look very aesthetically pleasing in the code. This is not a named enum (that can be used for strict typechecking) because music track IDs are essentially part of the API of the game - almost every custom level uses these numbers. This is just to make the source code more readable without needing a comment to denote what number is what track.
2023-05-24 03:37:32 +02:00
music.niceplay(Music_PASSIONFOREXPLORING);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
game.savetele_textbox();
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void scriptclass::hardreset(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
const bool version2_2 = GlitchrunnerMode_less_than_or_equal(Glitchrunner2_2);
Seed with frame counter instead of `SDL_GetTicks` Using SDL_GetTicks() to seed the Gravitron RNG caused many reproducibility issues while syncing https://tasvideos.org/7575S . To fix this, add a frame counter, which is a number that is incremented every frame and never resets, and use it instead. If someone needs to switch back to SDL_GetTicks() for old TASes, then provide the -seed-use-sdl-getticks command-line option for them.
2022-11-14 23:10:24 +01:00
if (game.seed_use_sdl_getticks)
{
/* The RNG is 32-bit. We don't _really_ need 64-bit... */
xoshiro_seed((Uint32) SDL_GetTicks64());
}
else
{
xoshiro_seed(game.framecounter);
}
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
//Game:
game.hascontrol = true;
game.gravitycontrol = 0;
game.teleport = false;
game.companion = 0;
if (!version2_2)
{
// Ironically, resetting more variables makes the janky fadeout system in glitchrunnermode even more glitchy
game.roomx = 0;
game.roomy = 0;
}
game.prevroomx = 0;
game.prevroomy = 0;
game.teleport_to_new_area = false;
game.teleport_to_x = 0;
game.teleport_to_y = 0;
game.teleportscript = "";
game.tapleft = 0;
game.tapright = 0;
game.startscript = false;
game.newscript = "";
game.alarmon = false;
game.alarmdelay = 0;
game.blackout = false;
game.useteleporter = false;
game.teleport_to_teleporter = 0;
game.nodeathmode = false;
game.nocutscenes = false;
for (i = 0; i < (int) SDL_arraysize(game.crewstats); i++)
{
game.crewstats[i] = false;
}
game.crewstats[0] = true;
game.lastsaved = 0;
game.deathcounts = 0;
game.gameoverdelay = 0;
game.resetgameclock();
game.gamesaved = false;
game.gamesavefailed = false;
game.savetime = "00:00";
game.savetrinkets = 0;
if (!version2_2)
{
// Ironically, resetting more variables makes the janky fadeout system in glitchrunnermode even more glitchy
game.saverx = 0;
game.savery = 0;
Reset savex, savey, and savegc in hardreset While refactoring scriptclass::startgamemode, I noticed that these variables weren't being reset. Fortunately, this doesn't seem to have affected anything because they get overwritten one way or another in startgamemode. But it's good just to be defensive and reset them anyway. They are not reset in 2.2 or 2.0 glitchrunner mode because dying during exiting to the menu is needed for credits warp, and that means the checkpoint position needs to be maintained through.
2022-12-29 21:15:30 +01:00
game.savex = 0;
game.savey = 0;
game.savegc = 0;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
game.savecolour = 0;
game.intimetrial = false;
game.timetrialcountdown = 0;
game.timetrialshinytarget = 0;
game.timetrialparlost = false;
game.timetrialpar = 0;
Add localization "foundation" (many code changes) This commit adds most of the code changes necessary for making the game translatable, but does not yet "unhardcode" nearly all of the strings (except in a few cases where it was hard to separate added loc::gettexts from foundational code changes, or all the localization- related menus which were also added by this commit.) This commit is part of rewritten history of the localization branch. The original (unsquashed) commit history can be found here: https://github.com/Dav999-v/VVVVVV/tree/localization-orig
2022-12-30 22:57:24 +01:00
game.timetrialcheater = false;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
Add level exploring menu for translators I would, of course, recommend translators to translate the roomnames while playing the full game (optionally in invincibility) so they can immediately get all the context and maybe the most inspiration. And if you want to go back into a specific level, then there's always the time trials and intermission replays which will give you full coverage of all the room names. However, the time trials weren't really made for room name translation. They have some annoying features like the instant restart when you press ENTER at the wrong time, they remove context clues like teleporters and companions, but the worst problem is that the last room in a level is often completely untranslatable inside the time trials because you immediately get sent to the results screen... So, I added a new menu in the translator options, "explore game", which gives you access to all the time trials and the two intermissions, from the same menu. All these time trials (which they're still based off of, under the hood) are stripped of the annoying features that come with time trials. These are the changes I made to time trial behavior in translator exploring mode: - No 3-2-1-Go! countdown - No on-screen time/death/shiny/par - ENTER doesn't restart, and the map menu works. The entire map is also revealed. - Prize for the Reckless is in its normal form - The teleporters in Entanglement Generator, Wheeler's Wormhole and Level Complete are restored as context for room names (actually, we should probably restore them in time trials anyway? Their "press to teleport" prompt is already blocked out in time trials and they do nothing other than being a checkpoint. I guess the reason they were removed was to stop people from opening the teleporter menu when that was not specifically blocked out in time trials yet.) - The companions are there at the end of levels, and behave like in no death mode (become happy and follow you to the teleporter). Also for context. - At the end of each level, you're not suddenly sent to the menu, but you can use the teleporter at your leisure just like in the intermission replays. In the Final Level, you do get sent to the menu automatically, but after a longer delay. I made another mark on VVVVVV: don't be startled, I added gamestates. I wanted all teleporters at the end of levels to behave like the ones at the end of the intermission replays, and all handling for teleporting with specific companions is already done in gamestates, so rather than adding conditional blocks across 5 or so different gamestates, it made more sense to make a single gamestate for "teleporting in translator exploring mode" (3090). I also added an alternative to having to use gamestate 3500 or 82 for the end of the final level: 3091-3092. One other thing I want to add to the "explore game" menu: a per-level count of how many room names are left to translate. That shouldn't be too difficult, and I'm planning that for the next commit.
2022-11-26 03:33:17 +01:00
game.translator_exploring = game.start_translator_exploring;
game.start_translator_exploring = false;
game.translator_exploring_allowtele = false;
Add cutscene test menu This allows translators to test all text boxes in the scripts. It doesn't run the scripts themselves - it only shows the basic appearance of each text box individually, so context may be lost but it's good to have a way to see any text boxes that might otherwise not be easily seen because they require specific circumstances to appear.
2022-12-24 04:16:56 +01:00
game.translator_cutscene_test = false;
Add level exploring menu for translators I would, of course, recommend translators to translate the roomnames while playing the full game (optionally in invincibility) so they can immediately get all the context and maybe the most inspiration. And if you want to go back into a specific level, then there's always the time trials and intermission replays which will give you full coverage of all the room names. However, the time trials weren't really made for room name translation. They have some annoying features like the instant restart when you press ENTER at the wrong time, they remove context clues like teleporters and companions, but the worst problem is that the last room in a level is often completely untranslatable inside the time trials because you immediately get sent to the results screen... So, I added a new menu in the translator options, "explore game", which gives you access to all the time trials and the two intermissions, from the same menu. All these time trials (which they're still based off of, under the hood) are stripped of the annoying features that come with time trials. These are the changes I made to time trial behavior in translator exploring mode: - No 3-2-1-Go! countdown - No on-screen time/death/shiny/par - ENTER doesn't restart, and the map menu works. The entire map is also revealed. - Prize for the Reckless is in its normal form - The teleporters in Entanglement Generator, Wheeler's Wormhole and Level Complete are restored as context for room names (actually, we should probably restore them in time trials anyway? Their "press to teleport" prompt is already blocked out in time trials and they do nothing other than being a checkpoint. I guess the reason they were removed was to stop people from opening the teleporter menu when that was not specifically blocked out in time trials yet.) - The companions are there at the end of levels, and behave like in no death mode (become happy and follow you to the teleporter). Also for context. - At the end of each level, you're not suddenly sent to the menu, but you can use the teleporter at your leisure just like in the intermission replays. In the Final Level, you do get sent to the menu automatically, but after a longer delay. I made another mark on VVVVVV: don't be startled, I added gamestates. I wanted all teleporters at the end of levels to behave like the ones at the end of the intermission replays, and all handling for teleporting with specific companions is already done in gamestates, so rather than adding conditional blocks across 5 or so different gamestates, it made more sense to make a single gamestate for "teleporting in translator exploring mode" (3090). I also added an alternative to having to use gamestate 3500 or 82 for the end of the final level: 3091-3092. One other thing I want to add to the "explore game" menu: a per-level count of how many room names are left to translate. That shouldn't be too difficult, and I'm planning that for the next commit.
2022-11-26 03:33:17 +01:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
game.totalflips = 0;
Translate hardest room at display time instead of at time of death The hardest room used to be stored as a room name in whatever language it was in when you last died enough times to break the record (before localization, that was always English). Even after localization became a thing we could get away with this since we only had a single font, but now we might have actual question marks appearing when the new font doesn't support characters from the old language. Therefore, this commit adds more info about the hardest room to save files - everything that is needed to know in order to do the translation at display time. These are hardestroom_x and hardestroom_y for the room coordinates, as well as hardestroom_specialname to mark special names, in addition to changing the stored room name back to English. I've also added hardestroom_finalstretch in case we later decide to drop the English name as a key and rely on just the coordinates (even though I think that change itself would be more complicated than any simplification it would accomplish, and I don't think it's necessary, but better to have it if we do need it later)
2023-09-04 15:27:29 +02:00
game.hardestroom = "Welcome Aboard";
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
game.hardestroomdeaths = 0;
Translate hardest room at display time instead of at time of death The hardest room used to be stored as a room name in whatever language it was in when you last died enough times to break the record (before localization, that was always English). Even after localization became a thing we could get away with this since we only had a single font, but now we might have actual question marks appearing when the new font doesn't support characters from the old language. Therefore, this commit adds more info about the hardest room to save files - everything that is needed to know in order to do the translation at display time. These are hardestroom_x and hardestroom_y for the room coordinates, as well as hardestroom_specialname to mark special names, in addition to changing the stored room name back to English. I've also added hardestroom_finalstretch in case we later decide to drop the English name as a key and rely on just the coordinates (even though I think that change itself would be more complicated than any simplification it would accomplish, and I don't think it's necessary, but better to have it if we do need it later)
2023-09-04 15:27:29 +02:00
game.hardestroom_x = 13;
game.hardestroom_y = 5;
game.hardestroom_specialname = false;
game.hardestroom_finalstretch = false;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
game.currentroomdeaths=0;
game.swnmode = false;
game.swntimer = 0;
Use enums for swngame This replaces the swngame int variable with a named enum and enforces strict typechecking on it. Strict typechecking is okay here as the swngame variable is not part of the API surface of the game in any way and is completely internal. And just to make things clear, I've added a SWN_NONE enum to use for initialization, because previously it was being initialized to 0, even though 0 was the Gravitron.
2023-06-05 08:24:31 +02:00
game.swngame = SWN_NONE; // Not playing sine wave ninja!
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
game.swnstate = 0;
game.swnstate2 = 0;
game.swnstate3 = 0;
game.swnstate4 = 0;
game.swndelay = 0;
game.swndeaths = 0;
game.supercrewmate = false;
game.scmhurt = false;
game.scmprogress = 0;
game.swncolstate = 0;
game.swncoldelay = 0;
game.swnrank = 0;
game.swnmessage = 0;
game.creditposx = 0;
game.creditposy = 0;
game.creditposdelay = 0;
game.inintermission = false;
game.insecretlab = false;
state locking
2022-12-07 00:20:48 +01:00
game.unlockstate();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
game.state = 0;
game.statedelay = 0;
game.hascontrol = true;
if (!GlitchrunnerMode_less_than_or_equal(Glitchrunner2_0))
{
// Keep the "- Press ACTION to advance text -" prompt around,
// apparently the speedrunners call it the "text storage" glitch
game.advancetext = false;
}
game.pausescript = false;
game.completestop = false;
game.flashlight = 0;
game.screenshake = 0;
game.activeactivity = -1;
game.act_fade = 5;
game.disabletemporaryaudiopause = true;
`hardreset`: Reset `ingame_titlemode` You'll note that getting in to the glitchy state of the game (the state where you could play the game after it had hardreset() called on it) required the player to quit to menu with ingame_titlemode set to true. Well, quitting to menu calls hardreset(). So if hardreset() is called when quitting, then you can no longer preserve ingame_titlemode that way. This is a bit overkill, but I'm just taking precautions.
2021-12-18 08:39:26 +01:00
game.ingame_titlemode = false;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
//dwgraphicsclass
graphics.backgrounddrawn = false;
Rename `textbox` to `textboxes` and textbox `line` to `lines` It's really dumb that these array names aren't plural when they should be, because they contain more than one thing.
2021-09-13 06:02:15 +02:00
graphics.textboxes.clear();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
graphics.flipmode = false; //This will be reset if needs be elsewhere
graphics.showcutscenebars = false;
graphics.setbars(0);
//mapclass
map.warpx = false;
map.warpy = false;
map.showteleporters = false;
map.showtargets = false;
map.showtrinkets = false;
map.finalmode = false;
map.finalstretch = false;
map.final_colormode = false;
map.final_colorframe = 0;
map.final_colorframedelay = 0;
map.final_mapcol = 0;
map.final_aniframe = 0;
map.final_aniframedelay = 0;
map.rcol = 0;
map.custommode=false;
map.custommodeforreal=false;
if (!version2_2)
{
// Ironically, resetting more variables makes the janky fadeout system even more glitchy
map.towermode=false;
}
map.cameraseekframe = 0;
map.resumedelay = 0;
graphics.towerbg.scrolldir = 0;
map.customshowmm=true;
SDL_memset(map.roomdeaths, 0, sizeof(map.roomdeaths));
SDL_memset(map.roomdeathsfinal, 0, sizeof(map.roomdeathsfinal));
map.resetmap();
//entityclass
obj.nearelephant = false;
obj.upsetmode = false;
obj.upset = 0;
obj.trophytext = 0 ;
obj.trophytype = 0;
obj.altstates = 0;
obj.resetallflags();
for (i = 0; i < (int) SDL_arraysize(obj.customcrewmoods); i++){
obj.customcrewmoods[i]=true;
}
SDL_memset(obj.collect, false, sizeof(obj.collect));
SDL_memset(obj.customcollect, false, sizeof(obj.customcollect));
i = 100; //previously a for-loop iterating over collect/customcollect set this to 100
int theplayer = obj.getplayer();
if (INBOUNDS_VEC(theplayer, obj.entities)){
obj.entities[theplayer].tile = 0;
}
/* Disable duplicate player entities */
for (int i = 0; i < (int) obj.entities.size(); i++)
{
if (obj.entities[i].rule == 0 && i != theplayer)
{
obj.disableentity(i);
}
}
obj.customscript = "";
//Script Stuff
position = 0;
commands.clear();
scriptdelay = 0;
scriptname = "null";
running = false;
Allow spaces and capitals in script names when loading This lets any script name use capitals and spaces all they want, while still being able to jump to them via iftrinkets() or similar. The issue is that whenever tokenize() is ran, all spaces are stripped and every argument is lowercased before being put into `words`. So, the solution here is to create a raw_words array that doesn't perform space stripping or lowercasing, and to refer to that whenever there's a script command that loads a script. We keep the lowercasing and space removal elsewhere to be more forgiving to newcomers. This is technically a forwards compatibility break, but it's only a minor one, and all levels that utilize it can still be easily modified to work on older versions anyway.
2022-02-12 23:56:27 +01:00
for (size_t ii = 0; ii < NUM_SCRIPT_ARGS; ++ii)
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
words[ii] = "";
Allow spaces and capitals in script names when loading This lets any script name use capitals and spaces all they want, while still being able to jump to them via iftrinkets() or similar. The issue is that whenever tokenize() is ran, all spaces are stripped and every argument is lowercased before being put into `words`. So, the solution here is to create a raw_words array that doesn't perform space stripping or lowercasing, and to refer to that whenever there's a script command that loads a script. We keep the lowercasing and space removal elsewhere to be more forgiving to newcomers. This is technically a forwards compatibility break, but it's only a minor one, and all levels that utilize it can still be easily modified to work on older versions anyway.
2022-02-12 23:56:27 +01:00
raw_words[ii] = "";
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
Reset new variables in hardreset
2021-08-31 20:07:38 +02:00
obj.customactivitycolour = "";
obj.customactivitytext = "";
Add `setactivityposition(x,y)`, add new textbox color `transparent` (#847) * Add `setactivityposition(x,y)`, add new textbox color `transparent` This commit adds a new internal command as a part of the visual activity zone changes I've been making. This one allows the user to reposition the activity zone to anywhere on the screen. In addition, this commit adds the textbox color `transparent`, which just sets r, g and b to 0. rgb(0, 0, 0) normally creates the color black, however in VVVVVV textboxes, it makes the background of them invisible, and makes the text the off-white color which the game uses elsewhere. * add new variables to hardreset * Fix unwanted text centering; offset position by 16, 4 It makes sense for `setactivityposition(0, 0)` to place the activity zone in the default position, so the x has been offset by 16, and the y has been offset by 4. Text was being automatically centered, meaning any activity zone which wasn't centered had misplaced text. This has been fixed by calculating the center manually, and offsetting it by the passed value.
2021-10-14 00:38:51 +02:00
obj.customactivitypositiony = -1;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Move custom script parser to its own function scriptclass::load() is a large enough function as it is, we don't need any more trouble by shoving the custom script parser in there as well.
2020-05-18 19:08:34 +02:00
Prioritize loading processed script names This makes it so that whenever the game loads a script as directed by a script command, it will first try to load the script from the processed argument, and if that fails only then will it try to load the script from the raw argument. This fixes a regression reported by Dav999 in the custom level "Vungeon" created by Dynaboom, where a script `ifflag`s to `aselectP1.1` even though the actual script name is `aselectp1.1`. In 2.3, it would lowercase `aselectP1.1` and load the script properly, but previous to this commit it would try to load the script with a capital name and then fail.
2023-02-01 05:04:18 +01:00
bool scriptclass::loadcustom(const std::string& t)
Move custom script parser to its own function scriptclass::load() is a large enough function as it is, we don't need any more trouble by shoving the custom script parser in there as well.
2020-05-18 19:08:34 +02:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
//this magic function breaks down the custom script and turns into real scripting!
std::string cscriptname="";
for(size_t i=0; i<t.length(); i++){
if(i>=7) cscriptname+=t[i];
}
std::string tstring;
std::vector<std::string>* contents = NULL;
for(size_t i = 0; i < customscripts.size(); i++){
Script& script_ = customscripts[i];
if(script_.name == cscriptname){
contents = &script_.contents;
break;
}
}
if(contents == NULL){
Prioritize loading processed script names This makes it so that whenever the game loads a script as directed by a script command, it will first try to load the script from the processed argument, and if that fails only then will it try to load the script from the raw argument. This fixes a regression reported by Dav999 in the custom level "Vungeon" created by Dynaboom, where a script `ifflag`s to `aselectP1.1` even though the actual script name is `aselectp1.1`. In 2.3, it would lowercase `aselectP1.1` and load the script properly, but previous to this commit it would try to load the script with a capital name and then fail.
2023-02-01 05:04:18 +01:00
return false;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
std::vector<std::string>& lines = *contents;
//Ok, we've got the relavent script segment, we do a pass to assess it, then run it!
int customcutscenemode=0;
for(size_t i=0; i<lines.size(); i++){
tokenize(lines[i]);
if(words[0] == "say"){
customcutscenemode=1;
}else if(words[0] == "reply"){
customcutscenemode=1;
}
}
if(customcutscenemode==1){
add("cutscene()");
add("untilbars()");
}
int customtextmode=0;
int speakermode=0; //0, terminal, numbers for crew
int squeakmode=0;//default on
//Now run the script
for(size_t i=0; i<lines.size(); i++){
words[0]="nothing"; //Default!
words[1]="1"; //Default!
tokenize(lines[i]);
for (size_t ii = 0; ii < words[0].length(); ii++)
{
words[0][ii] = SDL_tolower(words[0][ii]);
}
if(words[0] == "music"){
if(customtextmode==1){ add("endtext"); customtextmode=0;}
if(words[1]=="0"){
tstring="stopmusic()";
}else{
if(words[1]=="11"){ tstring="play(14)";
}else if(words[1]=="10"){ tstring="play(13)";
}else if(words[1]=="9"){ tstring="play(12)";
}else if(words[1]=="8"){ tstring="play(11)";
}else if(words[1]=="7"){ tstring="play(10)";
}else if(words[1]=="6"){ tstring="play(8)";
}else if(words[1]=="5"){ tstring="play(6)";
}else { tstring="play("+words[1]+")"; }
}
add(tstring);
}else if(words[0] == "playremix"){
add("play(15)");
}else if(words[0] == "flash"){
if(customtextmode==1){ add("endtext"); customtextmode=0;}
add("flash(5)");
add("shake(20)");
add("playef(9)");
}else if(words[0] == "sad" || words[0] == "cry"){
if(customtextmode==1){ add("endtext"); customtextmode=0;}
if(words[1]=="player"){
add("changemood(player,1)");
}else if(words[1]=="cyan" || words[1]=="viridian" || words[1]=="1"){
add("changecustommood(customcyan,1)");
}else if(words[1]=="purple" || words[1]=="violet" || words[1]=="pink" || words[1]=="2"){
add("changecustommood(purple,1)");
}else if(words[1]=="yellow" || words[1]=="vitellary" || words[1]=="3"){
add("changecustommood(yellow,1)");
}else if(words[1]=="red" || words[1]=="vermilion" || words[1]=="4"){
add("changecustommood(red,1)");
}else if(words[1]=="green" || words[1]=="verdigris" || words[1]=="5"){
add("changecustommood(green,1)");
}else if(words[1]=="blue" || words[1]=="victoria" || words[1]=="6"){
add("changecustommood(blue,1)");
}else if(words[1]=="all" || words[1]=="everybody" || words[1]=="everyone"){
add("changemood(player,1)");
add("changecustommood(customcyan,1)");
add("changecustommood(purple,1)");
add("changecustommood(yellow,1)");
add("changecustommood(red,1)");
add("changecustommood(green,1)");
add("changecustommood(blue,1)");
}else{
add("changemood(player,1)");
}
if(squeakmode==0) add("squeak(cry)");
}else if(words[0] == "happy"){
if(customtextmode==1){ add("endtext"); customtextmode=0;}
if(words[1]=="player"){
add("changemood(player,0)");
if(squeakmode==0) add("squeak(player)");
}else if(words[1]=="cyan" || words[1]=="viridian" || words[1]=="1"){
add("changecustommood(customcyan,0)");
if(squeakmode==0) add("squeak(player)");
}else if(words[1]=="purple" || words[1]=="violet" || words[1]=="pink" || words[1]=="2"){
add("changecustommood(purple,0)");
if(squeakmode==0) add("squeak(purple)");
}else if(words[1]=="yellow" || words[1]=="vitellary" || words[1]=="3"){
add("changecustommood(yellow,0)");
if(squeakmode==0) add("squeak(yellow)");
}else if(words[1]=="red" || words[1]=="vermilion" || words[1]=="4"){
add("changecustommood(red,0)");
if(squeakmode==0) add("squeak(red)");
}else if(words[1]=="green" || words[1]=="verdigris" || words[1]=="5"){
add("changecustommood(green,0)");
if(squeakmode==0) add("squeak(green)");
}else if(words[1]=="blue" || words[1]=="victoria" || words[1]=="6"){
add("changecustommood(blue,0)");
if(squeakmode==0) add("squeak(blue)");
}else if(words[1]=="all" || words[1]=="everybody" || words[1]=="everyone"){
add("changemood(player,0)");
add("changecustommood(customcyan,0)");
add("changecustommood(purple,0)");
add("changecustommood(yellow,0)");
add("changecustommood(red,0)");
add("changecustommood(green,0)");
add("changecustommood(blue,0)");
}else{
add("changemood(player,0)");
if(squeakmode==0) add("squeak(player)");
}
}else if(words[0] == "squeak"){
if(customtextmode==1){ add("endtext"); customtextmode=0;}
if(words[1]=="player"){
add("squeak(player)");
}else if(words[1]=="cyan" || words[1]=="viridian" || words[1]=="1"){
add("squeak(player)");
}else if(words[1]=="purple" || words[1]=="violet" || words[1]=="pink" || words[1]=="2"){
add("squeak(purple)");
}else if(words[1]=="yellow" || words[1]=="vitellary" || words[1]=="3"){
add("squeak(yellow)");
}else if(words[1]=="red" || words[1]=="vermilion" || words[1]=="4"){
add("squeak(red)");
}else if(words[1]=="green" || words[1]=="verdigris" || words[1]=="5"){
add("squeak(green)");
}else if(words[1]=="blue" || words[1]=="victoria" || words[1]=="6"){
add("squeak(blue)");
}else if(words[1]=="cry" || words[1]=="sad"){
add("squeak(cry)");
}else if(words[1]=="on"){
squeakmode=0;
}else if(words[1]=="off"){
squeakmode=1;
}
}else if(words[0] == "delay"){
if(customtextmode==1){ add("endtext"); customtextmode=0;}
add(lines[i]);
}else if(words[0] == "flag"){
if(customtextmode==1){ add("endtext"); customtextmode=0;}
add(lines[i]);
}else if(words[0] == "map"){
if(customtextmode==1){ add("endtext"); customtextmode=0;}
add("custom"+lines[i]);
}else if(words[0] == "warpdir"){
if(customtextmode==1){ add("endtext"); customtextmode=0;}
add(lines[i]);
}else if(words[0] == "ifwarp"){
if(customtextmode==1){ add("endtext"); customtextmode=0;}
add(lines[i]);
}else if(words[0] == "iftrinkets"){
if(customtextmode==1){ add("endtext"); customtextmode=0;}
add("custom"+lines[i]);
}else if(words[0] == "ifflag"){
if(customtextmode==1){ add("endtext"); customtextmode=0;}
add("custom"+lines[i]);
}else if(words[0] == "iftrinketsless"){
if(customtextmode==1){ add("endtext"); customtextmode=0;}
add("custom"+lines[i]);
Add localization "foundation" (many code changes) This commit adds most of the code changes necessary for making the game translatable, but does not yet "unhardcode" nearly all of the strings (except in a few cases where it was hard to separate added loc::gettexts from foundational code changes, or all the localization- related menus which were also added by this commit.) This commit is part of rewritten history of the localization branch. The original (unsquashed) commit history can be found here: https://github.com/Dav999-v/VVVVVV/tree/localization-orig
2022-12-30 22:57:24 +01:00
}else if(words[0] == "textcase"){
if(customtextmode==1){ add("endtext"); customtextmode=0;}
add(lines[i]);
}else if(words[0] == "iflang"){
if(customtextmode==1){ add("endtext"); customtextmode=0;}
add(lines[i]);
}else if(words[0] == "loadtext"){
if(customtextmode==1){ add("endtext"); customtextmode=0;}
add(lines[i]);
Add setfont scripting command The <font> in the level file is basically the starting font, but it can be changed at any time via scripting.
2023-01-20 04:57:06 +01:00
}else if(words[0] == "setfont"){
if(customtextmode==1){ add("endtext"); customtextmode=0;}
add(lines[i]);
Add setrtl(on/off) scripting command With the <font> tag (which doesn't indicate RTL-ness as explained), we've had a setfont(font) scripting command. Now we have an <rtl> tag, so we need a setrtl(on/off) command too to control that.
2024-01-03 20:43:37 +01:00
}else if(words[0] == "setrtl"){
if(customtextmode==1){ add("endtext"); customtextmode=0;}
add(lines[i]);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}else if(words[0] == "destroy"){
if(customtextmode==1){ add("endtext"); customtextmode=0;}
add(lines[i]);
}else if(words[0] == "speaker"){
speakermode=0;
if(words[1]=="gray" || words[1]=="grey" || words[1]=="terminal" || words[1]=="0") speakermode=0;
if(words[1]=="cyan" || words[1]=="viridian" || words[1]=="player" || words[1]=="1") speakermode=1;
if(words[1]=="purple" || words[1]=="violet" || words[1]=="pink" || words[1]=="2") speakermode=2;
if(words[1]=="yellow" || words[1]=="vitellary" || words[1]=="3") speakermode=3;
if(words[1]=="red" || words[1]=="vermilion" || words[1]=="4") speakermode=4;
if(words[1]=="green" || words[1]=="verdigris" || words[1]=="5") speakermode=5;
if(words[1]=="blue" || words[1]=="victoria" || words[1]=="6") speakermode=6;
}else if(words[0] == "say"){
//Speakers!
if(words[2]=="terminal" || words[2]=="gray" || words[2]=="grey" || words[2]=="0") speakermode=0;
if(words[2]=="cyan" || words[2]=="viridian" || words[2]=="player" || words[2]=="1") speakermode=1;
if(words[2]=="purple" || words[2]=="violet" || words[2]=="pink" || words[2]=="2") speakermode=2;
if(words[2]=="yellow" || words[2]=="vitellary" || words[2]=="3") speakermode=3;
if(words[2]=="red" || words[2]=="vermilion" || words[2]=="4") speakermode=4;
if(words[2]=="green" || words[2]=="verdigris" || words[2]=="5") speakermode=5;
if(words[2]=="blue" || words[2]=="victoria" || words[2]=="6") speakermode=6;
switch(speakermode){
case 0:
if(squeakmode==0) add("squeak(terminal)");
add("text(gray,0,114,"+words[1]+")");
break;
case 1: //NOT THE PLAYER
if(squeakmode==0) add("squeak(cyan)");
add("text(cyan,0,0,"+words[1]+")");
break;
case 2:
if(squeakmode==0) add("squeak(purple)");
add("text(purple,0,0,"+words[1]+")");
break;
case 3:
if(squeakmode==0) add("squeak(yellow)");
add("text(yellow,0,0,"+words[1]+")");
break;
case 4:
if(squeakmode==0) add("squeak(red)");
add("text(red,0,0,"+words[1]+")");
break;
case 5:
if(squeakmode==0) add("squeak(green)");
add("text(green,0,0,"+words[1]+")");
break;
case 6:
if(squeakmode==0) add("squeak(blue)");
add("text(blue,0,0,"+words[1]+")");
break;
}
Apply suggestions from code review Co-authored-by: Misa Elizabeth Kai <infoteddy@infoteddy.info>
2023-02-14 23:30:06 +01:00
int ti = ss_toi(words[1]);
Allow a maximum of 26 lines, with L suffix
2022-11-30 18:56:44 +01:00
int nti = ti >= 0 ? ti : 1;
for (int ti2 = 0; ti2 < nti; ti2++)
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
i++;
Allow a maximum of 26 lines, with L suffix
2022-11-30 18:56:44 +01:00
if (INBOUNDS_VEC(i, lines))
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
add(lines[i]);
}
}
switch(speakermode){
case 0: add("customposition(center)"); break;
case 1: add("customposition(cyan,above)"); break;
case 2: add("customposition(purple,above)"); break;
case 3: add("customposition(yellow,above)"); break;
case 4: add("customposition(red,above)"); break;
case 5: add("customposition(green,above)"); break;
case 6: add("customposition(blue,above)"); break;
}
add("speak_active");
customtextmode=1;
}else if(words[0] == "reply"){
//For this version, terminal only
if(squeakmode==0) add("squeak(player)");
add("text(cyan,0,0,"+words[1]+")");
int ti=help.Int(words[1].c_str());
Actually fix #913 oops
2022-11-30 00:04:46 +01:00
int nti = ti>=0 ? ti : 1;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
for(int ti2=0; ti2<nti; ti2++){
i++;
if(INBOUNDS_VEC(i, lines)){
add(lines[i]);
}
}
add("position(player,above)");
add("speak_active");
customtextmode=1;
}
}
if(customtextmode==1){ add("endtext"); customtextmode=0;}
if(customcutscenemode==1){
add("endcutscene()");
add("untilbars()");
}
Prioritize loading processed script names This makes it so that whenever the game loads a script as directed by a script command, it will first try to load the script from the processed argument, and if that fails only then will it try to load the script from the raw argument. This fixes a regression reported by Dav999 in the custom level "Vungeon" created by Dynaboom, where a script `ifflag`s to `aselectP1.1` even though the actual script name is `aselectp1.1`. In 2.3, it would lowercase `aselectP1.1` and load the script properly, but previous to this commit it would try to load the script with a capital name and then fail.
2023-02-01 05:04:18 +01:00
return true;
}
void scriptclass::loadalts(const std::string& processed, const std::string& raw)
{
const bool exists = load(processed);
if (!exists)
{
load(raw);
}
Move custom script parser to its own function scriptclass::load() is a large enough function as it is, we don't need any more trouble by shoving the custom script parser in there as well.
2020-05-18 19:08:34 +02:00
}
Add cutscene test menu This allows translators to test all text boxes in the scripts. It doesn't run the scripts themselves - it only shows the basic appearance of each text box individually, so context may be lost but it's good to have a way to see any text boxes that might otherwise not be easily seen because they require specific circumstances to appear.
2022-12-24 04:16:56 +01:00
Make Violet's button dialogue work in cutscene test This was easier than I expected - just add an optional buttons="1" attribute to cutscenes.xml. It's treated like the speaker attribute - it's only there as context for the translator, and for the cutscene test.
2023-03-22 21:30:42 +01:00
void scriptclass::add_test_line(
const std::string& speaker,
const std::string& english,
const char textcase,
const bool textbuttons
) {
Add cutscene test menu This allows translators to test all text boxes in the scripts. It doesn't run the scripts themselves - it only shows the basic appearance of each text box individually, so context may be lost but it's good to have a way to see any text boxes that might otherwise not be easily seen because they require specific circumstances to appear.
2022-12-24 04:16:56 +01:00
if (speaker == "gray")
{
add("squeak(terminal)");
}
else
{
add("squeak("+speaker+")");
}
add("textcase("+help.String(textcase)+")");
add("text("+speaker+",0,0,1)");
add(english);
add("position(center)");
Make Violet's button dialogue work in cutscene test This was easier than I expected - just add an optional buttons="1" attribute to cutscenes.xml. It's treated like the speaker attribute - it's only there as context for the translator, and for the cutscene test.
2023-03-22 21:30:42 +01:00
if (textbuttons)
{
add("textbuttons()");
}
Add cutscene test menu This allows translators to test all text boxes in the scripts. It doesn't run the scripts themselves - it only shows the basic appearance of each text box individually, so context may be lost but it's good to have a way to see any text boxes that might otherwise not be easily seen because they require specific circumstances to appear.
2022-12-24 04:16:56 +01:00
add("speak_active");
}
void scriptclass::loadtest(const std::string& name)
{
// Another magic function, that turns language files into a demo script
position = 0;
commands.clear();
scriptname = name;
running = true;
loc::populate_cutscene_test(name.c_str());
add("endtext");
add("gamestate(3100)");
}