mpo/VVVVVV
1
0
Fork 0
mirror of https://github.com/TerryCavanagh/VVVVVV.git synced 2024-12-23 01:59:43 +01:00
Code Issues Releases Wiki Activity
VVVVVV/desktop_version/src/KeyPoll.cpp

629 lines
17 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 KEY_DEFINITION
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#include "KeyPoll.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
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#include <string.h>
Replace all free calls with `VVV_free[func]` This replaces all calls to SDL_free with a new macro, VVV_free, that nulls the pointer afterwards. This mitigates any use-after-frees and also completely eliminates double-frees. The same is done for any function to free specific objects such as SDL_FreeSurface, with the VVV_freefunc macro. No exceptions for any of these calls, even if the pointer is discarded or zeroed afterwards anyway. Better safe than sorry. This is a macro rather than a function that takes in a pointer-to-pointer because such a function would have type issues that require casting and that's just not safe. Even though SDL_free and other SDL functions already check for NULL, the macro has a NULL check for other functions that don't. For example, FAudioVoice_DestroyVoice does not check for NULL. FILESYSTEM_freeMemory has been axed in favor of VVV_free because it functionally does the same thing except for `unsigned char*` only.
2022-12-01 07:30:16 +01:00
#include "Alloc.h"
Switch between controller glyphs and keyboard keys automatically If a controller button is pressed, a controller is connected (even at startup!) or an axis is moved, the game will switch to displaying controller glyphs. If a keyboard key is pressed or the last controller is removed, the game will switch to displaying keyboard keys.
2023-03-20 02:12:49 +01:00
#include "ButtonGlyphs.h"
Generalize stretch mode mouse scaling fix This puts the code to fix mouse coordinates in stretch mode directly inside KeyPoll::Poll, preventing the need for any other instances of mouse coordinate usage to copy-paste code.
2023-08-18 04:57:54 +02:00
#include "Constants.h"
Fix cycling menus in editor not updating While there's a check to recreate the menu if you cycle the language while in a menu, editor menus are a special case and need specific handling.
2024-02-03 01:06:11 +01:00
#include "Editor.h"
Call VVV_exit() when SDL_QUIT is received This fixes a regression introduced by #535 where a quit signal (e.g. Ctrl-C) sent to the window while the game was in unfocus pause wouldn't close the game. One problem was that key.quitProgram would only be checked when control flow switched back to the outer loop in main(), which would only happen when the loop order state machine switched to a delta function. As the unfocused func table didn't have any delta functions, this means key.quitProgram would never be checked. So a naïve solution to this would just be to add a no-op delta func entry to the unfocused func table. However, we then run into a separate issue where a delta function at the end of a func list never reassigns the active funcs, causing the game to be stuck in the unfocus pause forever. Active func reassignment only happens after fixed funcs. So then a naïve solution after that would be to simply add a no-op fixed func entry after that. And indeed, that would fix the whole issue. However, I want to do things the right way. And this does not seem like the right way. Even putting aside the separate last-func-being-delta issue, it mandates that every func list needs a delta function. Which seems quite unnecessary to me. Another solution I considered was copy-pasting the key.quitProgram check to the inner loops, or adding some sort of signal propagation to the inner loops - implemented by copy-pasting checks after each loop - so we didn't need to copy-paste key.quitProgram... but that seems really messy, too. So, I realized that we could throw away key.quitProgram, and simply call VVV_exit() directly when we receive an SDL_QUIT event. This fixes the issue, this removes an unnecessary middleman variable, and it's pretty cleanly and simply the right thing to do.
2021-04-02 00:24:14 +02:00
#include "Exit.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 "Game.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"
Add support for internal screenshots "But people already have screenshot tools", you might protest. The rationale is simple: If you play with any video setting other than 1x windowed (no stretching and no letterbox), then your screenshot will be too big if you want the internal resolution of 320x240, and downscaling will be an inconvenience. The point is to make screenshots based off of internal resolution so they are always pixel perfect and ideally never have to be altered once taken. I've added the keybind of F6 to do this. Right now it saves to a temporary test location with the same filename; future commits will save to properly-timestamped filenames.
2024-01-09 20:29:50 +01:00
#include "GraphicsUtil.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"
Fix limits check not updating with CTRL+F8 This makes it work pretty well. It basically just resets the state of the limits check and starts from the first limit broken (if any), which is behavior that makes sense to me. Otherwise, without this, it seems to invalidate pointers and, on my machine, start pulling strings from the language XML, which is horrifying.
2024-01-22 09:01:12 +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"
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"
Extern `gameScreen`, remove `screenbuffer` I know earlier I removed the gameScreen extern in favor of using screenbuffer, but that was only to be consistent. After further consideration, I have found that it's actually really stupid. There's no reason to be accessing it through screenbuffer, and it's probably an artifact of 2.0-2.2 passing stack-allocated otherwise-global classes everywhere through function arguments. Also, it leads to stupid bugs where screenbuffer could potentially be NULL, which has already resulted in various annoying crashes in the past. Although those could be fixed by simply initializing screenbuffer at the very top of main(), but, why not just scrap the whole thing anyway? So that's what I'm doing. As a nice side effect, I've removed the transitive include of Screen.h from Graphics.h. This could've been done already since it only includes it for the pointer anyway, but it's still good to do it now.
2021-12-25 08:56:47 +01:00
#include "Screen.h"
Replace utfcpp by UTF8.h in KeyPoll.cpp
2023-02-23 04:13:51 +01:00
#include "UTF8.h"
Add debug keybind CTRL+(SHIFT)+F8 to cycle lang This adds a debug keybind to cycle the current language forwards, CTRL+F8. It also adds a debug keybind to cycle it backwards, CTRL+SHIFT+F8. This is only active if the translator menu is active (and so if the regular F8 keybind is also active). This is useful for quickly catching errors in translations and/or inconsistencies between translations. In fact, I've already caught several translation mistakes using this keybind which made me mildly panic that I screwed something up in my own code, only to realize that no, actually, it was the translation that was at fault. For now, this is only meant to be used in-game, as text boxes get retranslated instantly, whereas things like menu options don't. But menu options will be retranslated on-the-fly in a later commit.
2024-01-21 23:39:18 +01:00
#include "UtilityClass.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"
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
Add support for internal screenshots "But people already have screenshot tools", you might protest. The rationale is simple: If you play with any video setting other than 1x windowed (no stretching and no letterbox), then your screenshot will be too big if you want the internal resolution of 320x240, and downscaling will be an inconvenience. The point is to make screenshots based off of internal resolution so they are always pixel perfect and ideally never have to be altered once taken. I've added the keybind of F6 to do this. Right now it saves to a temporary test location with the same filename; future commits will save to properly-timestamped filenames.
2024-01-09 20:29:50 +01:00
bool SaveScreenshot(void);
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
int inline KeyPoll::getThreshold(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
switch (sensitivity)
{
case 0:
return 28000;
case 1:
return 16000;
case 2:
return 8000;
case 3:
return 4000;
case 4:
return 2000;
}
return 8000;
Remove duplicate game.controllerSensitivity proxy It wasn't a direct duplicate of key.sensitivity, but it was still basically the same thing. Although to be fair, at least the case-switch conversion didn't get duplicated everywhere unlike game.slowdown. So now key.sensitivity functions the same as game.controllerSensitivity, and it only gets converted to its actual value whenever a joystick input happens in key.Poll(), unlike previously where it got converted every single frame on the title screen (there was even a comment that said "TODO bit wasteful doing this every poll").
2020-11-13 02:16:18 +01: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
KeyPoll::KeyPoll(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
xVel = 0;
yVel = 0;
// 0..5
sensitivity = 2;
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
keybuffer="";
leftbutton=0; rightbutton=0; middlebutton=0;
Generalize stretch mode mouse scaling fix This puts the code to fix mouse coordinates in stretch mode directly inside KeyPoll::Poll, preventing the need for any other instances of mouse coordinate usage to copy-paste code.
2023-08-18 04:57:54 +02:00
mousex = 0;
mousey = 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
resetWindow = 0;
pressedbackspace=false;
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
linealreadyemptykludge = false;
Fix resumemusic/musicfadein not working It seems like they were unfinished. This commit makes them properly work. When a track is stopped with stopmusic() or musicfadeout(), resumemusic() will resume from where the track stopped. musicfadein() does the same but does it with a gradual fade instead of suddenly playing it at full volume. I changed several interfaces around for this. First, setting currentsong to -1 when music is stopped is handled in the hook callback that gets called by SDL_mixer whenever the music stops. Otherwise, it'd be problematic if currentsong was set to -1 when the song starts fading out instead of when the song actually ends. Also, music.play() has a few optional arguments now, to reduce the copying-and-pasting of music code. Lastly, we have to roll our own tracker of music length by using SDL_GetPerformanceCounter(), because there's no way to get the music position if a song fades out. (We could implicitly keep the music position if we abruptly stopped the song using Mix_PauseMusic(), and resume it using Mix_ResumeMusic(), but ignoring the fact that those two functions are also used on the unfocus-pause (which, as it turns out, is basically a non-issue because the unfocus-pause can use some other functions), there's no equivalent for fading out, i.e. there's no "fade out and pause when it fully fades out" function in SDL_mixer.) And then we have to account for the unfocus-pause in our manual tracker. Other than that, these commands are now fully functional.
2020-06-27 10:31:09 +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
isActive = true;
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 KeyPoll::enabletextentry(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
keybuffer="";
SDL_StartTextInput();
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 KeyPoll::disabletextentry(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
SDL_StopTextInput();
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
bool KeyPoll::textentry(void)
Axe manual state trackers and use SDL_IsTextInputActive() After looking at pull request #446, I got a bit annoyed that we have TWO variables, key.textentrymode and ed.textentry, that we rolled ourselves to track the state of something SDL already provides us a function to easily query: SDL_IsTextInputActive(). We don't need to have either of these two variables, and we shouldn't. So that's what I do in this patch. Both variables have been axed in favor of using this function, and I just made a wrapper out of it, named key.textentry(). For bonus points, this gets rid of the ugly NO_CUSTOM_LEVELS and NO_EDITOR ifdef in main.cpp, since text entry is enabled when entering the script list and disabled when exiting it. This makes the code there easier to read, too. Furthermore, apparently key.textentrymode was initialized to *true* instead of false... for whatever reason. But that's gone now, too. Now, you'd think there wouldn't be any downside to using SDL_IsTextInputActive(). After all, it's a function that SDL itself provides, right? Wrong. For whatever reason, it seems like text input is active *from the start of the program*, meaning that what would happen is I would go into the editor, and find that I can't move around nor place tiles nor anything else. Then I would press Esc, and then suddenly become able to do those things I wanted to do before. I have no idea why the above happens, but all I can do is to just insert an SDL_StopTextInput() immediately after the SDL_Init() in main.cpp. Of course, I have to surround it with an SDL_IsTextInputActive() check to make sure I don't do anything extraneous by stopping input when it's already stopped.
2020-08-13 08:43:25 +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
return SDL_IsTextInputActive() == SDL_TRUE;
Axe manual state trackers and use SDL_IsTextInputActive() After looking at pull request #446, I got a bit annoyed that we have TWO variables, key.textentrymode and ed.textentry, that we rolled ourselves to track the state of something SDL already provides us a function to easily query: SDL_IsTextInputActive(). We don't need to have either of these two variables, and we shouldn't. So that's what I do in this patch. Both variables have been axed in favor of using this function, and I just made a wrapper out of it, named key.textentry(). For bonus points, this gets rid of the ugly NO_CUSTOM_LEVELS and NO_EDITOR ifdef in main.cpp, since text entry is enabled when entering the script list and disabled when exiting it. This makes the code there easier to read, too. Furthermore, apparently key.textentrymode was initialized to *true* instead of false... for whatever reason. But that's gone now, too. Now, you'd think there wouldn't be any downside to using SDL_IsTextInputActive(). After all, it's a function that SDL itself provides, right? Wrong. For whatever reason, it seems like text input is active *from the start of the program*, meaning that what would happen is I would go into the editor, and find that I can't move around nor place tiles nor anything else. Then I would press Esc, and then suddenly become able to do those things I wanted to do before. I have no idea why the above happens, but all I can do is to just insert an SDL_StopTextInput() immediately after the SDL_Init() in main.cpp. Of course, I have to surround it with an SDL_IsTextInputActive() check to make sure I don't do anything extraneous by stopping input when it's already stopped.
2020-08-13 08:43:25 +02:00
}
Directly toggle fullscreen if keybind pressed in key.Poll() This moves the responsibility of toggling fullscreen when any of the three toggle fullscreen keybinds are pressed (F11, Alt+Enter, Alt+F) directly into key.Poll() itself, and not its caller (which is main() - more specifically, fixedloop()). Furthermore, the fullscreen toggle itself has been moved to a separate function that key.Poll() just calls, to prevent cluttering key.Poll() with more business logic (the function is already quite big enough as it is). As part of my work in re-removing the 1-frame input delay in #535, I'm moving the callsite of key.Poll() around, and I don't want to have to lug this block of code around with it. I'd rather refactor it upfront than touch any more lines than necessary in that PR.
2021-03-17 07:26:34 +01:00
void KeyPoll::toggleFullscreen(void)
{
Extern `gameScreen`, remove `screenbuffer` I know earlier I removed the gameScreen extern in favor of using screenbuffer, but that was only to be consistent. After further consideration, I have found that it's actually really stupid. There's no reason to be accessing it through screenbuffer, and it's probably an artifact of 2.0-2.2 passing stack-allocated otherwise-global classes everywhere through function arguments. Also, it leads to stupid bugs where screenbuffer could potentially be NULL, which has already resulted in various annoying crashes in the past. Although those could be fixed by simply initializing screenbuffer at the very top of main(), but, why not just scrap the whole thing anyway? So that's what I'm doing. As a nice side effect, I've removed the transitive include of Screen.h from Graphics.h. This could've been done already since it only includes it for the pointer anyway, but it's still good to do it now.
2021-12-25 08:56:47 +01:00
gameScreen.toggleFullScreen();
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
keymap.clear(); /* we lost the input due to a new window. */
if (GlitchrunnerMode_less_than_or_equal(Glitchrunner2_2))
{
game.press_left = false;
game.press_right = false;
game.press_action = true;
game.press_map = false;
}
Directly toggle fullscreen if keybind pressed in key.Poll() This moves the responsibility of toggling fullscreen when any of the three toggle fullscreen keybinds are pressed (F11, Alt+Enter, Alt+F) directly into key.Poll() itself, and not its caller (which is main() - more specifically, fixedloop()). Furthermore, the fullscreen toggle itself has been moved to a separate function that key.Poll() just calls, to prevent cluttering key.Poll() with more business logic (the function is already quite big enough as it is). As part of my work in re-removing the 1-frame input delay in #535, I'm moving the callsite of key.Poll() around, and I don't want to have to lug this block of code around with it. I'd rather refactor it upfront than touch any more lines than necessary in that PR.
2021-03-17 07:26:34 +01:00
}
Show and hide mouse cursor based on user input This is quite simple - whenever the user uses their keyboard or controller, we hide the mouse cursor. Whenever they move the mouse, we show it again. This makes it so the cursor gets out of the way when they play the game, but reappears when they need it. There is also a timeout, to prevent strobing if the user decides to use the keyboard/controller and mouse at the same time. There is no timeout from hiding the mouse cursor, but there is a timeout from showing the mouse cursor - this because it's okay if the mouse lingers for a few frames when you start using the keyboard, but really annoying if the mouse doesn't instantly appear when you move it.
2021-04-17 07:46:43 +02:00
static int changemousestate(
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
int timeout,
const bool show,
const bool hide
Show and hide mouse cursor based on user input This is quite simple - whenever the user uses their keyboard or controller, we hide the mouse cursor. Whenever they move the mouse, we show it again. This makes it so the cursor gets out of the way when they play the game, but reappears when they need it. There is also a timeout, to prevent strobing if the user decides to use the keyboard/controller and mouse at the same time. There is no timeout from hiding the mouse cursor, but there is a timeout from showing the mouse cursor - this because it's okay if the mouse lingers for a few frames when you start using the keyboard, but really annoying if the mouse doesn't instantly appear when you move it.
2021-04-17 07:46:43 +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
int prev;
int new_;
if (timeout > 0)
{
return --timeout;
}
/* If we want to both show and hide at the same time, prioritize showing */
if (show)
{
new_ = SDL_ENABLE;
}
else if (hide)
{
new_ = SDL_DISABLE;
}
else
{
return timeout;
}
prev = SDL_ShowCursor(SDL_QUERY);
if (prev == new_)
{
return timeout;
}
SDL_ShowCursor(new_);
switch (new_)
{
case SDL_DISABLE:
timeout = 0;
break;
case SDL_ENABLE:
timeout = 30;
break;
}
return timeout;
Show and hide mouse cursor based on user input This is quite simple - whenever the user uses their keyboard or controller, we hide the mouse cursor. Whenever they move the mouse, we show it again. This makes it so the cursor gets out of the way when they play the game, but reappears when they need it. There is also a timeout, to prevent strobing if the user decides to use the keyboard/controller and mouse at the same time. There is no timeout from hiding the mouse cursor, but there is a timeout from showing the mouse cursor - this because it's okay if the mouse lingers for a few frames when you start using the keyboard, but really annoying if the mouse doesn't instantly appear when you move it.
2021-04-17 07:46:43 +02:00
}
Add debug keybind CTRL+(SHIFT)+F8 to cycle lang This adds a debug keybind to cycle the current language forwards, CTRL+F8. It also adds a debug keybind to cycle it backwards, CTRL+SHIFT+F8. This is only active if the translator menu is active (and so if the regular F8 keybind is also active). This is useful for quickly catching errors in translations and/or inconsistencies between translations. In fact, I've already caught several translation mistakes using this keybind which made me mildly panic that I screwed something up in my own code, only to realize that no, actually, it was the translation that was at fault. For now, this is only meant to be used in-game, as text boxes get retranslated instantly, whereas things like menu options don't. But menu options will be retranslated on-the-fly in a later commit.
2024-01-21 23:39:18 +01:00
/* Also used in Input.cpp. */
void recomputetextboxes(void);
Disable switching languages during cutscene tests Not gonna lie, I am a bit disappointed at having to do this, because it actually worked pretty well despite a few bugs depending on which language you entered with. But that's only because I'm working with the official translation files, which are in sync with each other. With translation files that are completely arbitrary, it would be apparent that switching languages during the cutscene test doesn't really make sense. Like, at all. That's because the list of cutscenes is populated entirely from language-specific XML and the cutscenes in them are also from language-specific XML. So keeping the same position in the menu doesn't really make sense, and keeping the same position in a cutscene definitely doesn't make sense.
2024-01-22 08:43:03 +01:00
bool cycle_language(bool should_recompute_textboxes)
{
extern KeyPoll key;
if (game.gamestate == TITLEMODE
&& game.currentmenuname == Menu::translator_options_cutscenetest)
{
/* Unfortunately, despite how it may appear to be working, the options
* are actually language-specific, and the order could be totally
* different between languages too. So we can't cycle in this menu. */
music.playef(Sound_CRY);
return should_recompute_textboxes;
}
if (game.translator_cutscene_test)
{
/* Refuse cycling here for similar reasons, even if it seems like it's
* working. The text boxes are based off of the language XML and
* could be completely different between languages. */
music.playef(Sound_CRY);
return should_recompute_textboxes;
}
int i = loc::languagelist_curlang;
if (key.keymap[SDLK_LSHIFT])
{
/* Backwards */
i--;
}
else
{
/* Forwards */
i++;
}
if (!loc::languagelist.empty())
{
i = POS_MOD(i, (int) loc::languagelist.size());
loc::languagelist_curlang = i;
loc::lang = loc::languagelist[i].code;
loc::loadtext(false);
graphics.grphx.init_translations();
should_recompute_textboxes = true;
}
Fix cycling menus in editor not updating While there's a check to recreate the menu if you cycle the language while in a menu, editor menus are a special case and need specific handling.
2024-02-03 01:06:11 +01:00
if (game.gamestate == TITLEMODE
|| (game.gamestate == EDITORMODE && ed.state == EditorState_MENU))
Disable switching languages during cutscene tests Not gonna lie, I am a bit disappointed at having to do this, because it actually worked pretty well despite a few bugs depending on which language you entered with. But that's only because I'm working with the official translation files, which are in sync with each other. With translation files that are completely arbitrary, it would be apparent that switching languages during the cutscene test doesn't really make sense. Like, at all. That's because the list of cutscenes is populated entirely from language-specific XML and the cutscenes in them are also from language-specific XML. So keeping the same position in the menu doesn't really make sense, and keeping the same position in a cutscene definitely doesn't make sense.
2024-01-22 08:43:03 +01:00
{
Fix limits check not updating with CTRL+F8 This makes it work pretty well. It basically just resets the state of the limits check and starts from the first limit broken (if any), which is behavior that makes sense to me. Otherwise, without this, it seems to invalidate pointers and, on my machine, start pulling strings from the language XML, which is horrifying.
2024-01-22 09:01:12 +01:00
if (game.currentmenuname == Menu::translator_options_limitscheck)
{
loc::local_limits_check();
}
Disable switching languages during cutscene tests Not gonna lie, I am a bit disappointed at having to do this, because it actually worked pretty well despite a few bugs depending on which language you entered with. But that's only because I'm working with the official translation files, which are in sync with each other. With translation files that are completely arbitrary, it would be apparent that switching languages during the cutscene test doesn't really make sense. Like, at all. That's because the list of cutscenes is populated entirely from language-specific XML and the cutscenes in them are also from language-specific XML. So keeping the same position in the menu doesn't really make sense, and keeping the same position in a cutscene definitely doesn't make sense.
2024-01-22 08:43:03 +01:00
int temp = game.menucountdown;
game.createmenu(game.currentmenuname, true);
game.menucountdown = temp;
if (game.currentmenuname == Menu::language)
{
game.currentmenuoption = i;
}
}
return should_recompute_textboxes;
}
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 KeyPoll::Poll(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Generalize stretch mode mouse scaling fix This puts the code to fix mouse coordinates in stretch mode directly inside KeyPoll::Poll, preventing the need for any other instances of mouse coordinate usage to copy-paste code.
2023-08-18 04:57:54 +02:00
static int raw_mousex = 0;
static int raw_mousey = 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
static int mousetoggletimeout = 0;
bool showmouse = false;
bool hidemouse = false;
bool altpressed = false;
bool fullscreenkeybind = false;
Controller layout detection
2023-08-22 15:52:53 +02:00
SDL_GameController *controller = NULL;
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_Event evt;
Recompute textboxes on active input device change This fixes a bug where some text boxes wouldn't update the displayed button if the active input device changed from a keyboard to controller, or vice versa. Namely, the "Press ACTION to continue" text boxes.
2024-01-22 00:49:16 +01:00
bool should_recompute_textboxes = false;
bool active_input_device_changed = false;
bool keyboard_was_active = BUTTONGLYPHS_keyboard_is_active();
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
while (SDL_PollEvent(&evt))
{
switch (evt.type)
{
/* Keyboard Input */
case SDL_KEYDOWN:
{
keymap[evt.key.keysym.sym] = true;
if (evt.key.keysym.sym == SDLK_BACKSPACE)
{
pressedbackspace = true;
}
Make the toggle fullscreen conditional more readable Each check has been put in its own variable, so the final conditional is more readable, and the ifdef is no longer right smack in the middle of an if-statement. Also the control flow has been changed (the "else" has been removed from the shortcut-checking conditional) so I could put the variables closer to the actual conditional itself. I don't think it affects anything, though.
2020-03-13 00:29:03 +01:00
Allow using F11 and (on macOS) RCmd+Enter/F to toggle fullscreen This patch allows the use of pressing F11 to toggle fullscreen, as well as allowing the use of Right Command when using the Command+Enter/F shortcut on macOS. Apparently Alt+Enter isn't the only shortcut to toggle fullscreen, Alt+F also works, which I didn't know before. I'm adding F11 as a shortcut because it's a far more natural shortcut to toggle fullscreen than this Alt+Enter or Alt+F business, which seems to be a relic mimicking some other games and some Microsoft stuff? I'm also adding RCommand+Enter/F because I see no reason not to. If you can use RAlt on non-macOS, why can't you use RCommand on macOS, too? I also cleaned up the formatting relating to the shortcut code, and made sure the closing parenthesis was outside the ifdef so my text editor wouldn't highlight the parenthesis inside the non-macOS ifdef-branch as a dangling closing parenthesis, because it assumes the one in the branch above is the actual closing parenthesis and doesn't parse macros.
2020-03-13 00:00:18 +01:00
#ifdef __APPLE__ /* OSX prefers the command keys over the alt keys. -flibit */
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
altpressed = keymap[SDLK_LGUI] || keymap[SDLK_RGUI];
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#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
altpressed = keymap[SDLK_LALT] || keymap[SDLK_RALT];
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#endif
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
bool returnpressed = evt.key.keysym.sym == SDLK_RETURN;
bool fpressed = evt.key.keysym.sym == SDLK_f;
bool f11pressed = evt.key.keysym.sym == SDLK_F11;
if ((altpressed && (returnpressed || fpressed)) || f11pressed)
{
fullscreenkeybind = true;
}
Remap lang reload keybind from F12 to F8 This remaps the keybind to reload language files from F12 to F8. This is because the F12 keybind conflicts with the default Steam keybind to take a Steam screenshot. I chose F8 because it is next to another keybind that reloads stuff, F9 (which reloads assets in the editor). Fixes #1089.
2024-01-09 20:14:11 +01:00
if (loc::show_translator_menu && evt.key.keysym.sym == SDLK_F8 && !evt.key.repeat)
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 debug keybind CTRL+(SHIFT)+F8 to cycle lang This adds a debug keybind to cycle the current language forwards, CTRL+F8. It also adds a debug keybind to cycle it backwards, CTRL+SHIFT+F8. This is only active if the translator menu is active (and so if the regular F8 keybind is also active). This is useful for quickly catching errors in translations and/or inconsistencies between translations. In fact, I've already caught several translation mistakes using this keybind which made me mildly panic that I screwed something up in my own code, only to realize that no, actually, it was the translation that was at fault. For now, this is only meant to be used in-game, as text boxes get retranslated instantly, whereas things like menu options don't. But menu options will be retranslated on-the-fly in a later commit.
2024-01-21 23:39:18 +01:00
if (keymap[SDLK_LCTRL])
{
Translate menu options on-the-fly I saw that the only problem with cycling languages in a title screen menu is that the menu options don't get updated. So I was like, we can just recreate the menu, and then I was like "Sure, why not." So that's what I did. To accommodate the CTRL+F8 keybind in the language menu, it automatically updates the menu option when you cycle it. This is because otherwise using the keybind in the language menu wouldn't visibly update the language, but it still actually does change your language, and that can be seen by pressing Escape. Also, the menucountdown needs to be preserved because otherwise createmenu() resets it, even if it's the "same" menu (this behavior is needed so that the menu that is shown during the countdown isn't added as a stack frame which would make it a menu that could be returned to).
2024-01-22 02:26:55 +01:00
/* Debug keybind to cycle language. */
Disable switching languages during cutscene tests Not gonna lie, I am a bit disappointed at having to do this, because it actually worked pretty well despite a few bugs depending on which language you entered with. But that's only because I'm working with the official translation files, which are in sync with each other. With translation files that are completely arbitrary, it would be apparent that switching languages during the cutscene test doesn't really make sense. Like, at all. That's because the list of cutscenes is populated entirely from language-specific XML and the cutscenes in them are also from language-specific XML. So keeping the same position in the menu doesn't really make sense, and keeping the same position in a cutscene definitely doesn't make sense.
2024-01-22 08:43:03 +01:00
should_recompute_textboxes = cycle_language(should_recompute_textboxes);
Add debug keybind CTRL+(SHIFT)+F8 to cycle lang This adds a debug keybind to cycle the current language forwards, CTRL+F8. It also adds a debug keybind to cycle it backwards, CTRL+SHIFT+F8. This is only active if the translator menu is active (and so if the regular F8 keybind is also active). This is useful for quickly catching errors in translations and/or inconsistencies between translations. In fact, I've already caught several translation mistakes using this keybind which made me mildly panic that I screwed something up in my own code, only to realize that no, actually, it was the translation that was at fault. For now, this is only meant to be used in-game, as text boxes get retranslated instantly, whereas things like menu options don't. But menu options will be retranslated on-the-fly in a later commit.
2024-01-21 23:39:18 +01:00
}
else
{
/* Reload language files */
loc::loadtext(false);
graphics.grphx.init_translations();
music.playef(Sound_COIN);
}
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 support for internal screenshots "But people already have screenshot tools", you might protest. The rationale is simple: If you play with any video setting other than 1x windowed (no stretching and no letterbox), then your screenshot will be too big if you want the internal resolution of 320x240, and downscaling will be an inconvenience. The point is to make screenshots based off of internal resolution so they are always pixel perfect and ideally never have to be altered once taken. I've added the keybind of F6 to do this. Right now it saves to a temporary test location with the same filename; future commits will save to properly-timestamped filenames.
2024-01-09 20:29:50 +01:00
if (evt.key.keysym.sym == SDLK_F6 && !evt.key.repeat)
{
Add border to indicate taking screenshot Originally, I was thinking of adding a notification text that you took a screenshot, but this is better because it is language-agnostic and it doesn't contribute to potential UI clutter/clashing. It flashes yellow if the screenshot successfully saved, and red if it didn't.
2024-01-09 19:55:00 +01:00
const bool success = SaveScreenshot();
game.old_screenshot_border_timer = 255;
game.screenshot_border_timer = 255;
game.screenshot_saved_success = success;
Add support for internal screenshots "But people already have screenshot tools", you might protest. The rationale is simple: If you play with any video setting other than 1x windowed (no stretching and no letterbox), then your screenshot will be too big if you want the internal resolution of 320x240, and downscaling will be an inconvenience. The point is to make screenshots based off of internal resolution so they are always pixel perfect and ideally never have to be altered once taken. I've added the keybind of F6 to do this. Right now it saves to a temporary test location with the same filename; future commits will save to properly-timestamped filenames.
2024-01-09 20:29:50 +01:00
}
Switch between controller glyphs and keyboard keys automatically If a controller button is pressed, a controller is connected (even at startup!) or an axis is moved, the game will switch to displaying controller glyphs. If a keyboard key is pressed or the last controller is removed, the game will switch to displaying keyboard keys.
2023-03-20 02:12:49 +01:00
BUTTONGLYPHS_keyboard_set_active(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
if (textentry())
{
if (evt.key.keysym.sym == SDLK_BACKSPACE && !keybuffer.empty())
{
Replace utfcpp by UTF8.h in KeyPoll.cpp
2023-02-23 04:13:51 +01:00
keybuffer.erase(UTF8_backspace(keybuffer.c_str(), keybuffer.length()));
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 (keybuffer.empty())
{
linealreadyemptykludge = true;
}
}
else if ( evt.key.keysym.sym == SDLK_v &&
keymap[SDLK_LCTRL] )
{
char* text = SDL_GetClipboardText();
if (text != NULL)
{
keybuffer += text;
Replace all free calls with `VVV_free[func]` This replaces all calls to SDL_free with a new macro, VVV_free, that nulls the pointer afterwards. This mitigates any use-after-frees and also completely eliminates double-frees. The same is done for any function to free specific objects such as SDL_FreeSurface, with the VVV_freefunc macro. No exceptions for any of these calls, even if the pointer is discarded or zeroed afterwards anyway. Better safe than sorry. This is a macro rather than a function that takes in a pointer-to-pointer because such a function would have type issues that require casting and that's just not safe. Even though SDL_free and other SDL functions already check for NULL, the macro has a NULL check for other functions that don't. For example, FAudioVoice_DestroyVoice does not check for NULL. FILESYSTEM_freeMemory has been axed in favor of VVV_free because it functionally does the same thing except for `unsigned char*` only.
2022-12-01 07:30:16 +01:00
VVV_free(text);
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 Ctrl+X for roomname translator mode This is a single block of code so it was easy to split from the foundation 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-31 02:18:07 +01:00
else if ( evt.key.keysym.sym == SDLK_x &&
keymap[SDLK_LCTRL] )
{
if (SDL_SetClipboardText(keybuffer.c_str()) == 0)
{
keybuffer = "";
}
}
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;
}
case SDL_KEYUP:
keymap[evt.key.keysym.sym] = false;
if (evt.key.keysym.sym == SDLK_BACKSPACE)
{
pressedbackspace = false;
}
break;
case SDL_TEXTINPUT:
if (!altpressed)
{
keybuffer += evt.text.text;
}
break;
/* Mouse Input */
case SDL_MOUSEMOTION:
Generalize stretch mode mouse scaling fix This puts the code to fix mouse coordinates in stretch mode directly inside KeyPoll::Poll, preventing the need for any other instances of mouse coordinate usage to copy-paste code.
2023-08-18 04:57:54 +02:00
raw_mousex = evt.motion.x;
raw_mousey = evt.motion.y;
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;
case SDL_MOUSEBUTTONDOWN:
switch (evt.button.button)
{
case SDL_BUTTON_LEFT:
Generalize stretch mode mouse scaling fix This puts the code to fix mouse coordinates in stretch mode directly inside KeyPoll::Poll, preventing the need for any other instances of mouse coordinate usage to copy-paste code.
2023-08-18 04:57:54 +02:00
raw_mousex = evt.button.x;
raw_mousey = evt.button.y;
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
leftbutton = 1;
break;
case SDL_BUTTON_RIGHT:
Generalize stretch mode mouse scaling fix This puts the code to fix mouse coordinates in stretch mode directly inside KeyPoll::Poll, preventing the need for any other instances of mouse coordinate usage to copy-paste code.
2023-08-18 04:57:54 +02:00
raw_mousex = evt.button.x;
raw_mousey = evt.button.y;
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
rightbutton = 1;
break;
case SDL_BUTTON_MIDDLE:
Generalize stretch mode mouse scaling fix This puts the code to fix mouse coordinates in stretch mode directly inside KeyPoll::Poll, preventing the need for any other instances of mouse coordinate usage to copy-paste code.
2023-08-18 04:57:54 +02:00
raw_mousex = evt.button.x;
raw_mousey = evt.button.y;
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
middlebutton = 1;
break;
}
break;
case SDL_MOUSEBUTTONUP:
switch (evt.button.button)
{
case SDL_BUTTON_LEFT:
Generalize stretch mode mouse scaling fix This puts the code to fix mouse coordinates in stretch mode directly inside KeyPoll::Poll, preventing the need for any other instances of mouse coordinate usage to copy-paste code.
2023-08-18 04:57:54 +02:00
raw_mousex = evt.button.x;
raw_mousey = evt.button.y;
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
leftbutton=0;
break;
case SDL_BUTTON_RIGHT:
Generalize stretch mode mouse scaling fix This puts the code to fix mouse coordinates in stretch mode directly inside KeyPoll::Poll, preventing the need for any other instances of mouse coordinate usage to copy-paste code.
2023-08-18 04:57:54 +02:00
raw_mousex = evt.button.x;
raw_mousey = evt.button.y;
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
rightbutton=0;
break;
case SDL_BUTTON_MIDDLE:
Generalize stretch mode mouse scaling fix This puts the code to fix mouse coordinates in stretch mode directly inside KeyPoll::Poll, preventing the need for any other instances of mouse coordinate usage to copy-paste code.
2023-08-18 04:57:54 +02:00
raw_mousex = evt.button.x;
raw_mousey = evt.button.y;
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
middlebutton=0;
break;
}
break;
/* Controller Input */
case SDL_CONTROLLERBUTTONDOWN:
buttonmap[(SDL_GameControllerButton) evt.cbutton.button] = true;
Switch between controller glyphs and keyboard keys automatically If a controller button is pressed, a controller is connected (even at startup!) or an axis is moved, the game will switch to displaying controller glyphs. If a keyboard key is pressed or the last controller is removed, the game will switch to displaying keyboard keys.
2023-03-20 02:12:49 +01:00
BUTTONGLYPHS_keyboard_set_active(false);
Controller layout detection
2023-08-22 15:52:53 +02:00
controller = controllers[evt.cbutton.which];
Add "type:" override check for virtual Sony gamepads. Fixes #1056
2023-12-01 18:08:26 +01:00
BUTTONGLYPHS_update_layout(controller);
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;
case SDL_CONTROLLERBUTTONUP:
buttonmap[(SDL_GameControllerButton) evt.cbutton.button] = false;
break;
case SDL_CONTROLLERAXISMOTION:
{
const int threshold = getThreshold();
switch (evt.caxis.axis)
{
case SDL_CONTROLLER_AXIS_LEFTX:
if ( evt.caxis.value > -threshold &&
evt.caxis.value < threshold )
{
xVel = 0;
}
else
{
xVel = (evt.caxis.value > 0) ? 1 : -1;
}
break;
case SDL_CONTROLLER_AXIS_LEFTY:
if ( evt.caxis.value > -threshold &&
evt.caxis.value < threshold )
{
yVel = 0;
}
else
{
yVel = (evt.caxis.value > 0) ? 1 : -1;
}
break;
}
Switch between controller glyphs and keyboard keys automatically If a controller button is pressed, a controller is connected (even at startup!) or an axis is moved, the game will switch to displaying controller glyphs. If a keyboard key is pressed or the last controller is removed, the game will switch to displaying keyboard keys.
2023-03-20 02:12:49 +01:00
BUTTONGLYPHS_keyboard_set_active(false);
Controller layout detection
2023-08-22 15:52:53 +02:00
controller = controllers[evt.caxis.which];
Add "type:" override check for virtual Sony gamepads. Fixes #1056
2023-12-01 18:08:26 +01:00
BUTTONGLYPHS_update_layout(controller);
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;
}
case SDL_CONTROLLERDEVICEADDED:
{
Controller layout detection
2023-08-22 15:52:53 +02:00
controller = SDL_GameControllerOpen(evt.cdevice.which);
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
vlog_info(
"Opened SDL_GameController ID #%i, %s",
evt.cdevice.which,
Controller layout detection
2023-08-22 15:52:53 +02:00
SDL_GameControllerName(controller)
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
);
Controller layout detection
2023-08-22 15:52:53 +02:00
controllers[SDL_JoystickInstanceID(SDL_GameControllerGetJoystick(controller))] = controller;
Switch between controller glyphs and keyboard keys automatically If a controller button is pressed, a controller is connected (even at startup!) or an axis is moved, the game will switch to displaying controller glyphs. If a keyboard key is pressed or the last controller is removed, the game will switch to displaying keyboard keys.
2023-03-20 02:12:49 +01:00
BUTTONGLYPHS_keyboard_set_active(false);
Add "type:" override check for virtual Sony gamepads. Fixes #1056
2023-12-01 18:08:26 +01:00
BUTTONGLYPHS_update_layout(controller);
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;
}
case SDL_CONTROLLERDEVICEREMOVED:
{
Controller layout detection
2023-08-22 15:52:53 +02:00
controller = controllers[evt.cdevice.which];
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
controllers.erase(evt.cdevice.which);
Controller layout detection
2023-08-22 15:52:53 +02:00
vlog_info("Closing %s", SDL_GameControllerName(controller));
SDL_GameControllerClose(controller);
Switch between controller glyphs and keyboard keys automatically If a controller button is pressed, a controller is connected (even at startup!) or an axis is moved, the game will switch to displaying controller glyphs. If a keyboard key is pressed or the last controller is removed, the game will switch to displaying keyboard keys.
2023-03-20 02:12:49 +01:00
if (controllers.empty())
{
BUTTONGLYPHS_keyboard_set_active(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
break;
}
/* Window Events */
case SDL_WINDOWEVENT:
switch (evt.window.event)
{
/* Window Resize */
case SDL_WINDOWEVENT_RESIZED:
if (SDL_GetWindowFlags(
SDL_GetWindowFromID(evt.window.windowID)
) & SDL_WINDOW_INPUT_FOCUS)
{
resetWindow = true;
}
break;
/* Window Focus */
case SDL_WINDOWEVENT_FOCUS_GAINED:
if (!game.disablepause)
{
isActive = true;
if ((!game.disableaudiopause || !game.disabletemporaryaudiopause) && music.currentsong != -1)
{
music.resume();
music.resumeef();
}
}
if (SDL_strcmp(SDL_GetCurrentVideoDriver(), "x11") == 0)
{
if (wasFullscreen)
{
Extern `gameScreen`, remove `screenbuffer` I know earlier I removed the gameScreen extern in favor of using screenbuffer, but that was only to be consistent. After further consideration, I have found that it's actually really stupid. There's no reason to be accessing it through screenbuffer, and it's probably an artifact of 2.0-2.2 passing stack-allocated otherwise-global classes everywhere through function arguments. Also, it leads to stupid bugs where screenbuffer could potentially be NULL, which has already resulted in various annoying crashes in the past. Although those could be fixed by simply initializing screenbuffer at the very top of main(), but, why not just scrap the whole thing anyway? So that's what I'm doing. As a nice side effect, I've removed the transitive include of Screen.h from Graphics.h. This could've been done already since it only includes it for the pointer anyway, but it's still good to do it now.
2021-12-25 08:56:47 +01:00
gameScreen.isWindowed = 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
SDL_SetWindowFullscreen(
SDL_GetWindowFromID(evt.window.windowID),
SDL_WINDOW_FULLSCREEN_DESKTOP
);
}
}
SDL_DisableScreenSaver();
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
gameScreen.recacheTextures();
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;
case SDL_WINDOWEVENT_FOCUS_LOST:
if (!game.disablepause)
{
isActive = false;
if (!game.disableaudiopause || !game.disabletemporaryaudiopause)
{
music.pause();
music.pauseef();
}
}
Disable unfocus on Emscripten
2021-03-31 21:12:13 +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
if (SDL_strcmp(SDL_GetCurrentVideoDriver(), "x11") == 0)
{
Extern `gameScreen`, remove `screenbuffer` I know earlier I removed the gameScreen extern in favor of using screenbuffer, but that was only to be consistent. After further consideration, I have found that it's actually really stupid. There's no reason to be accessing it through screenbuffer, and it's probably an artifact of 2.0-2.2 passing stack-allocated otherwise-global classes everywhere through function arguments. Also, it leads to stupid bugs where screenbuffer could potentially be NULL, which has already resulted in various annoying crashes in the past. Although those could be fixed by simply initializing screenbuffer at the very top of main(), but, why not just scrap the whole thing anyway? So that's what I'm doing. As a nice side effect, I've removed the transitive include of Screen.h from Graphics.h. This could've been done already since it only includes it for the pointer anyway, but it's still good to do it now.
2021-12-25 08:56:47 +01:00
wasFullscreen = !gameScreen.isWindowed;
gameScreen.isWindowed = 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
SDL_SetWindowFullscreen(
SDL_GetWindowFromID(evt.window.windowID),
0
);
}
SDL_EnableScreenSaver();
break;
/* Mouse Focus */
case SDL_WINDOWEVENT_ENTER:
SDL_DisableScreenSaver();
break;
case SDL_WINDOWEVENT_LEAVE:
SDL_EnableScreenSaver();
break;
}
break;
/* Quit Event */
case SDL_QUIT:
VVV_exit(0);
break;
}
switch (evt.type)
{
case SDL_KEYDOWN:
if (evt.key.repeat == 0)
{
hidemouse = true;
}
break;
case SDL_TEXTINPUT:
case SDL_CONTROLLERBUTTONDOWN:
case SDL_CONTROLLERAXISMOTION:
hidemouse = true;
break;
case SDL_MOUSEMOTION:
case SDL_MOUSEBUTTONDOWN:
showmouse = true;
break;
}
}
mousetoggletimeout = changemousestate(
mousetoggletimeout,
showmouse,
hidemouse
);
if (fullscreenkeybind)
{
toggleFullscreen();
}
Generalize stretch mode mouse scaling fix This puts the code to fix mouse coordinates in stretch mode directly inside KeyPoll::Poll, preventing the need for any other instances of mouse coordinate usage to copy-paste code.
2023-08-18 04:57:54 +02:00
Implement scaling modes manually For future PRs, it'll be very nice to have full control over how VVVVVV gets drawn to the window. This means we can use the entire window size for things like touch input, drawing borders, or anything we want.
2024-01-29 01:04:02 +01:00
SDL_Rect rect;
graphics.get_stretch_info(&rect);
Generalize stretch mode mouse scaling fix This puts the code to fix mouse coordinates in stretch mode directly inside KeyPoll::Poll, preventing the need for any other instances of mouse coordinate usage to copy-paste code.
2023-08-18 04:57:54 +02:00
Implement scaling modes manually For future PRs, it'll be very nice to have full control over how VVVVVV gets drawn to the window. This means we can use the entire window size for things like touch input, drawing borders, or anything we want.
2024-01-29 01:04:02 +01:00
mousex = (raw_mousex - rect.x) * SCREEN_WIDTH_PIXELS / rect.w;
mousey = (raw_mousey - rect.y) * SCREEN_HEIGHT_PIXELS / rect.h;
Recompute textboxes on active input device change This fixes a bug where some text boxes wouldn't update the displayed button if the active input device changed from a keyboard to controller, or vice versa. Namely, the "Press ACTION to continue" text boxes.
2024-01-22 00:49:16 +01:00
active_input_device_changed = keyboard_was_active != BUTTONGLYPHS_keyboard_is_active();
should_recompute_textboxes |= active_input_device_changed;
if (should_recompute_textboxes)
{
recomputetextboxes();
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
bool KeyPoll::isDown(SDL_Keycode key)
{
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
return keymap[key];
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
bool KeyPoll::isDown(std::vector<SDL_GameControllerButton> buttons)
{
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 (size_t i = 0; i < buttons.size(); i += 1)
{
if (buttonmap[buttons[i]])
{
return true;
}
}
return false;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
bool KeyPoll::isDown(SDL_GameControllerButton button)
{
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
return buttonmap[button];
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
bool KeyPoll::controllerButtonDown(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
for (
SDL_GameControllerButton button = SDL_CONTROLLER_BUTTON_A;
button < SDL_CONTROLLER_BUTTON_DPAD_UP;
button = (SDL_GameControllerButton) (button + 1)
) {
if (isDown(button))
{
return true;
}
}
return false;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
bool KeyPoll::controllerWantsLeft(bool includeVert)
{
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
return ( buttonmap[SDL_CONTROLLER_BUTTON_DPAD_LEFT] ||
xVel < 0 ||
( includeVert &&
( buttonmap[SDL_CONTROLLER_BUTTON_DPAD_UP] ||
yVel < 0 ) ) );
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
bool KeyPoll::controllerWantsRight(bool includeVert)
{
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
return ( buttonmap[SDL_CONTROLLER_BUTTON_DPAD_RIGHT] ||
xVel > 0 ||
( includeVert &&
( buttonmap[SDL_CONTROLLER_BUTTON_DPAD_DOWN] ||
yVel > 0 ) ) );
Hello WWWWWWorld!
2020-01-01 21:29:24 +01: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
bool KeyPoll::controllerWantsUp(void)
{
return buttonmap[SDL_CONTROLLER_BUTTON_DPAD_UP] || yVel < 0;
}
bool KeyPoll::controllerWantsDown(void)
{
return buttonmap[SDL_CONTROLLER_BUTTON_DPAD_DOWN] || yVel > 0;
}
Reference in a new issue Copy permalink