mpo/VVVVVV
1
0
Fork 0
mirror of https://github.com/TerryCavanagh/VVVVVV.git synced 2024-06-02 19:13:31 +02:00
Code Issues Releases Wiki Activity
7b5ef40926
VVVVVV/desktop_version/src/Editor.cpp

4252 lines
125 KiB
C++
Raw Normal View History

Move editor functions to separate file This moves editorrenderfixed(), editorrender(), editorinput(), editorlogic(), and their associated functions to a new file named Editor.cpp - which is exactly what it says on the tin; it stores all the functions related to the actual in-game editor loop. Also, the existing editor.cpp has been renamed to CustomLevels.cpp.
2021-02-20 05:51:25 +01:00
#if !defined(NO_CUSTOM_LEVELS) && !defined(NO_EDITOR)
Add option to compile without the level editor
2020-02-10 01:53:01 +01:00
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
#define ED_DEFINITION
#include "Editor.h"
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
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 <string>
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
#include "Constants.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 "CustomLevels.h"
Fix 1-frame glitch when going to in-game options from edsettings The menu creation of Graphic Options or Game Options, as well as the map.nexttowercolour() call, all need to be deferred until the end of the frame.
2021-03-19 05:14:40 +01:00
#include "DeferCallbacks.h"
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#include "Entity.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 "Enums.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"
Move editor functions to separate file This moves editorrenderfixed(), editorrender(), editorinput(), editorlogic(), and their associated functions to a new file named Editor.cpp - which is exactly what it says on the tin; it stores all the functions related to the actual in-game editor loop. Also, the existing editor.cpp has been renamed to CustomLevels.cpp.
2021-02-20 05:51:25 +01:00
#include "Game.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"
Move editor functions to separate file This moves editorrenderfixed(), editorrender(), editorinput(), editorlogic(), and their associated functions to a new file named Editor.cpp - which is exactly what it says on the tin; it stores all the functions related to the actual in-game editor loop. Also, the existing editor.cpp has been renamed to CustomLevels.cpp.
2021-02-20 05:51:25 +01:00
#include "GraphicsUtil.h"
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#include "KeyPoll.h"
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
#include "Localization.h"
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#include "Map.h"
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
#include "Maths.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"
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#include "Script.h"
Replace utfcpp by UTF8.h in Editor.cpp
2023-02-23 04:13:15 +01:00
#include "UTF8.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"
Implement new string formatting system (VFormat) This commit adds a new string formatting system to replace uses of `SDL_snprintf` and string concatenation. Making our own string formatting system has been briefly discussed during the review of the localization branch, and on the VVVVVV Discord. It's inspired by Python's format strings, but simpler. This is primarily to benefit localization - strings will be easier to understand (`Now using %s Tileset` → `Now using {area} Tileset`, `"%s remain"` → `"{n_crewmates|wordy} remain"`), translators can change the word order for their language's grammar (`%1$s` is a POSIX extension), and this system is also less error-prone (making the format string not align with the actual arguments won't result in a crash or UB). It also integrates our needs better - particularly the "wordy" numbers without having to have a `help.number_words(n).c_str()` at the callsite, translators can opt in and out of wordy numbers per string, and this should also make it easier to solve #859. This commit adds the formatting system itself, and changes one `SDL_snprintf` in the code to use it as a small demo (the rest should probably be done in the localization branch to avoid more unneeded work). The system is described in full detail in VFormat.h and in the pull request description.
2022-04-30 21:09:11 +02:00
#include "VFormat.h"
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
#include "Vlogging.h"
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
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
editorclass::editorclass(void)
{
reset();
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
register_tool(EditorTool_WALLS, "Walls", "1", SDLK_1, false);
register_tool(EditorTool_BACKING, "Backing", "2", SDLK_2, false);
register_tool(EditorTool_SPIKES, "Spikes", "3", SDLK_3, false);
register_tool(EditorTool_TRINKETS, "Trinkets", "4", SDLK_4, false);
register_tool(EditorTool_CHECKPOINTS, "Checkpoints", "5", SDLK_5, false);
register_tool(EditorTool_DISAPPEARING_PLATFORMS, "Disappear", "6", SDLK_6, false);
register_tool(EditorTool_CONVEYORS, "Conveyors", "7", SDLK_7, false);
register_tool(EditorTool_MOVING_PLATFORMS, "Moving", "8", SDLK_8, false);
register_tool(EditorTool_ENEMIES, "Enemies", "9", SDLK_9, false);
register_tool(EditorTool_GRAVITY_LINES, "Grav Lines", "0", SDLK_0, false);
register_tool(EditorTool_ROOMTEXT, "Roomtext", "R", SDLK_r, false);
register_tool(EditorTool_TERMINALS, "Terminals", "T", SDLK_t, false);
register_tool(EditorTool_SCRIPTS, "Script Boxes", "Y", SDLK_y, false);
register_tool(EditorTool_WARP_TOKENS, "Warp Tokens", "U", SDLK_u, false);
register_tool(EditorTool_WARP_LINES, "Warp Lines", "I", SDLK_i, false);
register_tool(EditorTool_CREWMATES, "Crewmates", "O", SDLK_o, false);
register_tool(EditorTool_START_POINT, "Start Point", "P", SDLK_p, false);
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
}
void editorclass::reset(void)
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
current_tool = EditorTool_WALLS;
roomnamehide = 0;
zmod = false;
xmod = false;
cmod = false;
vmod = false;
hmod = false;
bmod = false;
spacemod = false;
shiftmenu = false;
shiftkey = false;
saveandquit = false;
note = "";
notedelay = 0;
oldnotedelay = 0;
deletekeyheld = false;
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
textmod = TEXT_NONE;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
titlemod = false;
creatormod = false;
desc1mod = false;
desc2mod = false;
desc3mod = false;
websitemod = false;
settingsmod = false;
warpmod = false; //Two step process
warpent = -1;
boundarymod = 0;
boundarytype = 0;
boundx1 = 0;
boundx2 = 0;
boundy1 = 0;
boundy2 = 0;
textent = 0;
scripttexttype = 0;
drawmode = 0;
dmtile = 0;
dmtileeditor = 0;
entcol = 0;
tilex = 0;
tiley = 0;
levx = 0;
levy = 0;
keydelay = 0;
lclickdelay = 0;
savekey = false;
loadkey = false;
updatetiles = true;
changeroom = true;
entframe = 0;
entframedelay = 0;
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
SDL_zeroa(kludgewarpdir);
hooklist.clear();
sb.clear();
clearscriptbuffer();
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
sbx = 0;
sby = 0;
pagey = 0;
Start using level-specific font where needed, make CJK tweaks Level text such as room names, text box content, and the contents of the script editor need to be displayed in the level-specific font, and tweaked to look right. This involves displaying less lines in the script editor, making text boxes bigger, displaying some text higher and some text lower. This is still unfinished, but it's the real start of a migration to font::print functions!
2023-01-12 05:27:52 +01:00
lines_visible = 25;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
scripteditmod = false;
sbscript = "null";
scripthelppage = 0;
scripthelppagedelay = 0;
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
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
hookmenupage = 0;
hookmenu = 0;
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
returneditoralpha = 0;
oldreturneditoralpha = 0;
ghosts.clear();
currentghosts = 0;
loaded_filepath = "";
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
state = EditorState_DRAW;
substate = EditorSubState_MAIN;
}
void editorclass::handle_tile_placement(const int tile)
{
int range = 1;
if (bmod)
{
// Vertical line
for (int i = 0; i < 30; i++)
{
settile(tilex, i, tile);
}
return;
}
else if (hmod)
{
// Horizontal line
for (int i = 0; i < 40; i++)
{
settile(i, tiley, tile);
}
return;
}
else if (vmod)
{
range = 4;
}
else if (cmod)
{
range = 3;
}
else if (xmod)
{
range = 2;
}
else if (zmod)
{
range = 1;
}
else
{
settile(tilex, tiley, tile);
return;
}
for (int i = -range; i <= range; i++)
{
for (int j = -range; j <= range; j++)
{
settile(tilex + i, tiley + j, tile);
}
}
}
void editorclass::tool_remove()
{
switch (current_tool)
{
case EditorTool_WALLS:
case EditorTool_BACKING:
handle_tile_placement(0);
break;
default:
break;
}
for (size_t i = 0; i < customentities.size(); i++)
{
if (customentities[i].x == tilex + (levx * 40) && customentities[i].y == tiley + (levy * 30))
{
removeedentity(i);
}
}
}
void editorclass::entity_clicked(const int index)
{
CustomEntity* entity = &customentities[index];
lclickdelay = 1;
switch (entity->t)
{
case 1:
// Enemies
entity->p1 = (entity->p1 + 1) % 4;
break;
case 2:
{
// Moving Platforms and Conveyors
const bool conveyor = entity->p1 >= 5;
entity->p1++;
if (conveyor)
{
entity->p1 = (entity->p1 - 5) % 4 + 5;
}
else
{
entity->p1 %= 4;
}
break;
}
case 10:
// Checkpoints
// If it's not textured as a checkpoint, then just leave it be
if (entity->p1 == 0 || entity->p1 == 1)
{
entity->p1 = (entity->p1 + 1) % 2;
}
break;
case 11:
case 16:
// Gravity Lines, Start Point
entity->p1 = (entity->p1 + 1) % 2;
break;
case 15:
// Crewmates
entity->p1 = (entity->p1 + 1) % 6;
break;
case 17:
// Roomtext
getlin(TEXT_ROOMTEXT, loc::gettext("Enter roomtext:"), &entity->scriptname);
textent = index;
break;
case 18:
// Terminals
if (entity->p1 == 0 || entity->p1 == 1)
{
// Flip the terminal, but if it's not textured as a terminal leave it alone
entity->p1 = (entity->p1 + 1) % 2;
}
SDL_FALLTHROUGH;
case 19:
// Script Boxes (and terminals)
getlin(TEXT_SCRIPT, loc::gettext("Enter script name:"), &entity->scriptname);
textent = index;
break;
}
}
void editorclass::tool_place()
{
const int entity = edentat(tilex + (levx * 40), tiley + (levy * 30));
if (entity != -1)
{
entity_clicked(entity);
return;
}
switch (current_tool)
{
case EditorTool_WALLS:
case EditorTool_BACKING:
{
int tile = 0;
if (cl.getroomprop(levx, levy)->directmode >= 1)
{
tile = dmtile;
}
else if (current_tool == EditorTool_WALLS)
{
tile = 1;
}
else if (current_tool == EditorTool_BACKING)
{
tile = 2;
}
handle_tile_placement(tile);
break;
}
case EditorTool_SPIKES:
settile(tilex, tiley, 8);
break;
case EditorTool_TRINKETS:
if (cl.numtrinkets() < 100)
{
addedentity(tilex + (levx * 40), tiley + (levy * 30), 9);
lclickdelay = 1;
}
else
{
note = loc::gettext("ERROR: Max number of trinkets is 100");
notedelay = 45;
}
break;
case EditorTool_CHECKPOINTS:
addedentity(tilex + (levx * 40), tiley + (levy * 30), 10, 1);
lclickdelay = 1;
break;
case EditorTool_DISAPPEARING_PLATFORMS:
addedentity(tilex + (levx * 40), tiley + (levy * 30), 3);
lclickdelay = 1;
break;
case EditorTool_CONVEYORS:
addedentity(tilex + (levx * 40), tiley + (levy * 30), 2, 5);
lclickdelay = 1;
break;
case EditorTool_MOVING_PLATFORMS:
addedentity(tilex + (levx * 40), tiley + (levy * 30), 2, 0);
lclickdelay = 1;
break;
case EditorTool_ENEMIES:
addedentity(tilex + (levx * 40), tiley + (levy * 30), 1, 0);
lclickdelay = 1;
break;
case EditorTool_GRAVITY_LINES:
addedentity(tilex + (levx * 40), tiley + (levy * 30), 11, 0);
lclickdelay = 1;
break;
case EditorTool_ROOMTEXT:
lclickdelay = 1;
textent = customentities.size();
addedentity(tilex + (levx * 40), tiley + (levy * 30), 17);
getlin(TEXT_ROOMTEXT, loc::gettext("Enter roomtext:"), &(customentities[textent].scriptname));
break;
case EditorTool_TERMINALS:
lclickdelay = 1;
textent = customentities.size();
addedentity(tilex + (levx * 40), tiley + (levy * 30), 18, 0);
getlin(TEXT_SCRIPT, loc::gettext("Enter script name:"), &(customentities[textent].scriptname));
break;
case EditorTool_SCRIPTS:
boundarytype = 0;
boundx1 = tilex * 8;
boundy1 = tiley * 8;
boundarymod = 2;
lclickdelay = 1;
break;
case EditorTool_WARP_TOKENS:
warpmod = true;
warpent = customentities.size();
addedentity(tilex + (levx * 40), tiley + (levy * 30), 13);
lclickdelay = 1;
break;
case EditorTool_WARP_LINES:
//Warp lines
if (tilex == 0)
{
addedentity(tilex + (levx * 40), tiley + (levy * 30), 50, 0);
}
else if (tilex == 39)
{
addedentity(tilex + (levx * 40), tiley + (levy * 30), 50, 1);
}
else if (tiley == 0)
{
addedentity(tilex + (levx * 40), tiley + (levy * 30), 50, 2);
}
else if (tiley == 29)
{
addedentity(tilex + (levx * 40), tiley + (levy * 30), 50, 3);
}
else
{
note = loc::gettext("ERROR: Warp lines must be on edges");
notedelay = 45;
}
lclickdelay = 1;
break;
case EditorTool_CREWMATES:
if (cl.numcrewmates() < 100)
{
addedentity(tilex + (levx * 40), tiley + (levy * 30), 15, int(fRandom() * 6));
lclickdelay = 1;
}
else
{
note = loc::gettext("ERROR: Max number of crewmates is 100");
notedelay = 45;
}
break;
case EditorTool_START_POINT:
//If there is another start point, destroy it
for (size_t i = 0; i < customentities.size(); i++)
{
if (customentities[i].t == 16)
{
removeedentity(i);
i--;
}
}
addedentity(tilex + (levx * 40), tiley + (levy * 30), 16, 0);
lclickdelay = 1;
break;
}
}
void editorclass::draw_tool(EditorTools tool, int x, int y)
{
extern editorclass ed;
switch (tool)
{
case EditorTool_WALLS:
graphics.drawtile(x, y, 83);
graphics.drawtile(x + 8, y, 83);
graphics.drawtile(x, y + 8, 83);
graphics.drawtile(x + 8, y + 8, 83);
break;
case EditorTool_BACKING:
graphics.drawtile(x, y, 680);
graphics.drawtile(x + 8, y, 680);
graphics.drawtile(x, y + 8, 680);
graphics.drawtile(x + 8, y + 8, 680);
break;
case EditorTool_SPIKES:
graphics.drawtile(x + 4, y + 4, 8);
break;
case EditorTool_TRINKETS:
graphics.draw_sprite(x, y, 22, 196, 196, 196);
break;
case EditorTool_CHECKPOINTS:
graphics.draw_sprite(x, y, 21, 196, 196, 196);
break;
case EditorTool_DISAPPEARING_PLATFORMS:
graphics.drawtile(x, y + 4, 3);
graphics.drawtile(x + 8, y + 4, 4);
break;
case EditorTool_CONVEYORS:
graphics.drawtile(x, y + 4, 24);
graphics.drawtile(x + 8, y + 4, 24);
break;
case EditorTool_MOVING_PLATFORMS:
graphics.drawtile(x, y + 4, 1);
graphics.drawtile(x + 8, y + 4, 1);
break;
case EditorTool_ENEMIES:
graphics.draw_sprite(x, y, 78 + ed.entframe, 196, 196, 196);
break;
case EditorTool_GRAVITY_LINES:
graphics.fill_rect(x + 2, y + 8, 12, 1, graphics.getRGB(255, 255, 255));
break;
case EditorTool_ROOMTEXT:
font::print(PR_FONT_8X8, x + 1, y, "AB", 196, 196, 255 - help.glow);
font::print(PR_FONT_8X8, x + 1, y + 9, "CD", 196, 196, 255 - help.glow);
break;
case EditorTool_TERMINALS:
graphics.draw_sprite(x, y, 17, 196, 196, 196);
break;
case EditorTool_SCRIPTS:
graphics.draw_rect(x + 4, y + 4, 8, 8, graphics.getRGB(96, 96, 96));
break;
case EditorTool_WARP_TOKENS:
graphics.draw_sprite(x, y, 18 + (ed.entframe % 2), 196, 196, 196);
break;
case EditorTool_WARP_LINES:
graphics.fill_rect(x + 6, y + 2, 4, 12, graphics.getRGB(255, 255, 255));
break;
case EditorTool_CREWMATES:
graphics.draw_sprite(x, y, 186, graphics.col_crewblue);
break;
case EditorTool_START_POINT:
graphics.draw_sprite(x, y, 184, graphics.col_crewcyan);
break;
}
}
void editorclass::register_tool(EditorTools tool, const char* name, const char* keychar, const SDL_KeyCode key, const bool shift)
{
toolnames[tool] = name;
toolkeychar[tool] = keychar;
toolkey[tool] = key;
toolshift[tool] = shift;
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
}
void editorclass::gethooks(void)
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// Scan through the script and create a hooks list based on it
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
hooklist.clear();
for (size_t i = 0; i < script.customscripts.size(); i++)
{
Script& script_ = script.customscripts[i];
hooklist.push_back(script_.name);
}
}
Use `const std::string&` where possible in function params If it's at all possible to use `const std::string&` when passing `std::string`s around, then we use it. This is to limit the amount of memory usage as a result of the frequent use of `std::string`s, so the game no longer unnecessarily copies strings when it doesn't need to.
2021-09-07 00:41:49 +02:00
void editorclass::loadhookineditor(const std::string& t)
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
{
//Find hook t in the scriptclass, then load it into the editor
clearscriptbuffer();
for(size_t i = 0; i < script.customscripts.size(); i++)
{
Script& script_ = script.customscripts[i];
if(script_.name == t)
{
sb = script_.contents;
break;
}
}
if(sb.empty())
{
//Always have one line or we'll have problems
sb.resize(1);
}
}
Use `const std::string&` where possible in function params If it's at all possible to use `const std::string&` when passing `std::string`s around, then we use it. This is to limit the amount of memory usage as a result of the frequent use of `std::string`s, so the game no longer unnecessarily copies strings when it doesn't need to.
2021-09-07 00:41:49 +02:00
void editorclass::addhooktoscript(const std::string& t)
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
{
//Adds hook+the scriptbuffer to the end of the scriptclass
removehookfromscript(t);
Script script_;
script_.name = t;
script_.contents = sb;
script.customscripts.push_back(script_);
}
Use `const std::string&` where possible in function params If it's at all possible to use `const std::string&` when passing `std::string`s around, then we use it. This is to limit the amount of memory usage as a result of the frequent use of `std::string`s, so the game no longer unnecessarily copies strings when it doesn't need to.
2021-09-07 00:41:49 +02:00
void editorclass::removehookfromscript(const std::string& t)
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
{
/* Find hook t in the scriptclass, then removes it (and any other code with it)
* When this loop reaches the end, it wraps to SIZE_MAX; SIZE_MAX + 1 is 0 */
size_t i;
for (i = script.customscripts.size() - 1; i + 1 > 0; --i)
{
if (script.customscripts[i].name == t)
{
script.customscripts.erase(script.customscripts.begin() + i);
}
}
}
Use `const std::string&` where possible in function params If it's at all possible to use `const std::string&` when passing `std::string`s around, then we use it. This is to limit the amount of memory usage as a result of the frequent use of `std::string`s, so the game no longer unnecessarily copies strings when it doesn't need to.
2021-09-07 00:41:49 +02:00
void editorclass::removehook(const std::string& t)
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
{
//Check the hooklist for the hook t. If it's there, remove it from here and the script
size_t i;
removehookfromscript(t);
/* When this loop reaches the end, it wraps to SIZE_MAX; SIZE_MAX + 1 is 0 */
for (i = hooklist.size() - 1; i + 1 > 0; --i)
{
if (hooklist[i] == t)
{
hooklist.erase(hooklist.begin() + i);
}
}
}
Use `const std::string&` where possible in function params If it's at all possible to use `const std::string&` when passing `std::string`s around, then we use it. This is to limit the amount of memory usage as a result of the frequent use of `std::string`s, so the game no longer unnecessarily copies strings when it doesn't need to.
2021-09-07 00:41:49 +02:00
void editorclass::addhook(const std::string& t)
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
{
//Add an empty function to the list in both editor and script
removehook(t);
hooklist.push_back(t);
addhooktoscript(t);
}
Use `const std::string&` where possible in function params If it's at all possible to use `const std::string&` when passing `std::string`s around, then we use it. This is to limit the amount of memory usage as a result of the frequent use of `std::string`s, so the game no longer unnecessarily copies strings when it doesn't need to.
2021-09-07 00:41:49 +02:00
bool editorclass::checkhook(const std::string& t)
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
{
//returns true if hook t already is in the list
for(size_t i=0; i<hooklist.size(); i++)
{
if(hooklist[i]==t) return true;
}
return false;
}
void editorclass::clearscriptbuffer(void)
{
sb.clear();
}
void editorclass::removeline(int t)
{
//Remove line t from the script
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if ((int) sb.size() > 1)
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
{
sb.erase(sb.begin() + t);
}
}
void editorclass::insertline(int t)
{
//insert a blank line into script at line t
sb.insert(sb.begin() + t, "");
}
void editorclass::getlin(const enum textmode mode, const std::string& prompt, std::string* ptr)
{
textmod = mode;
textptr = ptr;
textdesc = prompt;
key.enabletextentry();
if (ptr)
{
key.keybuffer = *ptr;
}
else
{
key.keybuffer = "";
textptr = &(key.keybuffer);
}
oldenttext = key.keybuffer;
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
void editorclass::addedentity(int xp, int yp, int tp, int p1, int p2, int p3, int p4, int p5, int p6)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Rename edentities to CustomEntity That's what it is - it's an entity in a custom level. Not something to do with the editor, necessarily. Like before, the name of the XML element will remain the same.
2021-02-21 00:56:59 +01:00
CustomEntity entity;
Refactor edentities to not use separate length-trackers This turns the array 'edentity' into a proper vector, and removes the need to use a separate length-tracking variable and manually keep track of the actual amount of edentities in the level by using the long-winded 'EditorData::GetInstance().numedentities'. This manual tracking was more error-prone and much less maintainable. editorclass::naddedentity() has been removed due to now functionally being the same as editorclass::addedentity() (there's no more 'EditorData::GetInstance().numedentities' to not increment) and for also being unused in the first place. editorclass::copyedentity() has been removed because it was only used to shift the rest of the edentities up manually, but now that we let C++ do all the hard work it's no longer necessary.
2020-03-01 21:24:43 +01:00
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
entity.x = xp;
entity.y = yp;
entity.t = tp;
entity.p1 = p1;
entity.p2 = p2;
entity.p3 = p3;
entity.p4 = p4;
entity.p5 = p5;
entity.p6 = p6;
entity.scriptname = "";
Refactor edentities to not use separate length-trackers This turns the array 'edentity' into a proper vector, and removes the need to use a separate length-tracking variable and manually keep track of the actual amount of edentities in the level by using the long-winded 'EditorData::GetInstance().numedentities'. This manual tracking was more error-prone and much less maintainable. editorclass::naddedentity() has been removed due to now functionally being the same as editorclass::addedentity() (there's no more 'EditorData::GetInstance().numedentities' to not increment) and for also being unused in the first place. editorclass::copyedentity() has been removed because it was only used to shift the rest of the edentities up manually, but now that we let C++ do all the hard work it's no longer necessary.
2020-03-01 21:24:43 +01:00
Rename edentity to customentities This fixes the fact that the name of the singular type is plural, but the name of the plural array is singular. Which has always annoyed me, too. Also this makes it more clear that custom entities don't have much to do with the editor.
2021-02-21 01:01:39 +01:00
customentities.push_back(entity);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
void editorclass::removeedentity(int t)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Rename edentity to customentities This fixes the fact that the name of the singular type is plural, but the name of the plural array is singular. Which has always annoyed me, too. Also this makes it more clear that custom entities don't have much to do with the editor.
2021-02-21 01:01:39 +01:00
customentities.erase(customentities.begin() + t);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
int editorclass::edentat(int xp, int yp)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
for (size_t i = 0; i < customentities.size(); i++)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if (customentities[i].x == xp && customentities[i].y == yp) return i;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
return -1;
}
Clean up unnecessary exports and add static keywords This patch cleans up unnecessary exports from header files (there were only a few), as well as adds the static keyword to all symbols that aren't exported and are specific to a file. This helps the linker out in not doing any unnecessary work, speeding it up and avoiding silent symbol conflicts (otherwise two symbols with the same name (and type/signature in C++) would quietly resolve as okay by the linker).
2021-01-10 18:14:37 +01:00
static void editormenurender(int tr, int tg, int tb)
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
{
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
extern editorclass ed;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
Turn game.currentmenuname "else-if"s into case-switches Much more stylistic, you don't need to repeat "game.currentmenuname" for each case, and you don't need to deal with the dangling first "if" that doesn't have an "else".
2020-04-17 00:19:17 +02:00
switch (game.currentmenuname)
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
{
Turn game.currentmenuname "else-if"s into case-switches Much more stylistic, you don't need to repeat "game.currentmenuname" for each case, and you don't need to deal with the dangling first "if" that doesn't have an "else".
2020-04-17 00:19:17 +02:00
case Menu::ed_settings:
Completely remove Graphics::bigprint The last two deprecated functions are: - Graphics::Print - Graphics::PrintWrap These are used a lot, but they're relatively easy to replace, since the only flag I probably have to immediately worry about is PR_CEN. I do often need to add PR_FONT_* flags but I don't need to add any PR_2X/PR_3X/PR_4X anymore.
2023-01-18 23:04:47 +01:00
font::print(PR_2X | PR_CEN, -1, 75, loc::gettext("Map Settings"), tr, tg, tb);
Add a player trail to the editor (ghosts) A few months ago, I added ghosts to the VVVVVV: Community Edition editor. I was told recently I should think about upstreaming it, and with Terry saying go ahead I finally ported them into VVVVVV. There's one slight difference however--you can choose whether you have them or not in the editor's settings menu. They're off by default, and this is saved to the save file. Anyway, when you're playtesting, the game saves the players position, color, room coordinates and sprite every 3 frames. The max is 100, where if it tries to add more, the oldest one gets removed. When you exit playtesting, the saved positions appear one at a time, and you can use the Z key to speed it up. [Here's a video of them in action.](https://o.lol-sa.me/4H21zCv.mp4)
2020-06-13 00:04:35 +02:00
if (game.currentmenuoption == 3)
{
if (!game.ghostsenabled)
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
font::print(0, 2, 230, loc::gettext("Editor ghost trail is OFF"), tr/2, tg/2, tb/2);
Add a player trail to the editor (ghosts) A few months ago, I added ghosts to the VVVVVV: Community Edition editor. I was told recently I should think about upstreaming it, and with Terry saying go ahead I finally ported them into VVVVVV. There's one slight difference however--you can choose whether you have them or not in the editor's settings menu. They're off by default, and this is saved to the save file. Anyway, when you're playtesting, the game saves the players position, color, room coordinates and sprite every 3 frames. The max is 100, where if it tries to add more, the oldest one gets removed. When you exit playtesting, the saved positions appear one at a time, and you can use the Z key to speed it up. [Here's a video of them in action.](https://o.lol-sa.me/4H21zCv.mp4)
2020-06-13 00:04:35 +02:00
else
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
font::print(0, 2, 230, loc::gettext("Editor ghost trail is ON"), tr, tg, tb);
Add a player trail to the editor (ghosts) A few months ago, I added ghosts to the VVVVVV: Community Edition editor. I was told recently I should think about upstreaming it, and with Terry saying go ahead I finally ported them into VVVVVV. There's one slight difference however--you can choose whether you have them or not in the editor's settings menu. They're off by default, and this is saved to the save file. Anyway, when you're playtesting, the game saves the players position, color, room coordinates and sprite every 3 frames. The max is 100, where if it tries to add more, the oldest one gets removed. When you exit playtesting, the saved positions appear one at a time, and you can use the Z key to speed it up. [Here's a video of them in action.](https://o.lol-sa.me/4H21zCv.mp4)
2020-06-13 00:04:35 +02:00
}
Turn game.currentmenuname "else-if"s into case-switches Much more stylistic, you don't need to repeat "game.currentmenuname" for each case, and you don't need to deal with the dangling first "if" that doesn't have an "else".
2020-04-17 00:19:17 +02:00
break;
case Menu::ed_desc:
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
{
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
if(ed.titlemod)
{
if(ed.entframe<2)
{
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
font::print(PR_2X | PR_CEN | PR_FONT_LEVEL, -1, 35, key.keybuffer+"_", tr, tg, tb);
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
}
else
{
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
font::print(PR_2X | PR_CEN | PR_FONT_LEVEL, -1, 35, key.keybuffer+" ", tr, tg, tb);
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
}
}
else
{
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
bool title_is_gettext;
std::string title = translate_title(cl.title, &title_is_gettext);
font::print(PR_2X | PR_CEN | (title_is_gettext ? PR_FONT_INTERFACE : PR_FONT_LEVEL), -1, 35, title, tr, tg, tb);
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
}
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
bool creator_is_gettext = false;
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
std::string creator;
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
if(ed.creatormod)
{
if(ed.entframe<2)
{
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
creator = key.keybuffer + "_";
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
}
else
{
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
creator = key.keybuffer + " ";
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
}
}
else
{
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
creator = translate_creator(cl.creator, &creator_is_gettext);
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
}
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
int sp = SDL_max(10, font::height(PR_FONT_LEVEL));
Replace "by" for level authors with happy face "by {author}" is a string that will cause a lot of localization-related problems, which then become much worse when different languages and levels can also need different fonts: - If the author name is set to something in English instead of a name, then it'll come out a bit weird if your VVVVVV is set to a different language: "de various people", "por various people", etc. It's the same problem with Discord bots completing "playing" or "watching" in their statuses. - Translators can't always fit "by" in two letters, and level creators have understandably always assumed, and will continue to assume, that "by" is two letters. So if you have your VVVVVV set to a language that translates "by" as something long, then: | by Various People and Others | ...may suddenly show up as something like: |thorer Various People and Othe| - "by" and author may need mutually incompatible fonts. For example, a Japanese level in a Korean VVVVVV needs to be displayed with "by" in Korean characters and the author name with Japanese characters, which would need some very special code since languages may want to add text both before and after the name. - It's very possible that some languages can't translate "by" without knowing the gender of the name, and I know some languages even inflect names in really interesting ways (adding and even replacing letters in first names, surnames, and anything in between, depending on gender and what else is in the sentence). So to solve all of this, the "by" is now replaced by a 10x10 face from sprites.png, like a :viridian: emote. See it as a kind of avatar next to a username, to clarify and assert that this line is for the author's name. It should be a fairly obvious/recognizable icon, it fixes all the above problems, and it's a bonus that we now have more happy faces in VVVVVV.
2023-01-31 00:41:46 +01:00
graphics.print_level_creator((creator_is_gettext ? PR_FONT_INTERFACE : PR_FONT_LEVEL), 60, creator, tr, tg, tb);
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
if(ed.websitemod)
{
if(ed.entframe<2)
{
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
font::print(PR_CEN | PR_FONT_LEVEL, -1, 60+sp, key.keybuffer+"_", tr, tg, tb);
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
}
else
{
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
font::print(PR_CEN | PR_FONT_LEVEL, -1, 60+sp, key.keybuffer+" ", tr, tg, tb);
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
}
}
else
{
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
font::print(PR_CEN | PR_FONT_LEVEL, -1, 60+sp, cl.website, tr, tg, tb);
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
}
if(ed.desc1mod)
{
if(ed.entframe<2)
{
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
font::print(PR_CEN | PR_FONT_LEVEL, -1, 60+sp*3, key.keybuffer+"_", tr, tg, tb);
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
}
else
{
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
font::print(PR_CEN | PR_FONT_LEVEL, -1, 60+sp*3, key.keybuffer+" ", tr, tg, tb);
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
}
}
else
{
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
font::print(PR_CEN | PR_FONT_LEVEL, -1, 60+sp*3, cl.Desc1, tr, tg, tb);
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
}
if(ed.desc2mod)
{
if(ed.entframe<2)
{
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
font::print(PR_CEN | PR_FONT_LEVEL, -1, 60+sp*4, key.keybuffer+"_", tr, tg, tb);
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
}
else
{
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
font::print(PR_CEN | PR_FONT_LEVEL, -1, 60+sp*4, key.keybuffer+" ", tr, tg, tb);
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
}
}
else
{
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
font::print(PR_CEN | PR_FONT_LEVEL, -1, 60+sp*4, cl.Desc2, tr, tg, tb);
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
}
if(ed.desc3mod)
{
if(ed.entframe<2)
{
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
font::print(PR_CEN | PR_FONT_LEVEL, -1, 60+sp*5, key.keybuffer+"_", tr, tg, tb);
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
}
else
{
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
font::print(PR_CEN | PR_FONT_LEVEL, -1, 60+sp*5, key.keybuffer+" ", tr, tg, tb);
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
}
}
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
else if (sp <= 10)
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
{
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
font::print(PR_CEN | PR_FONT_LEVEL, -1, 60+sp*5, cl.Desc3, tr, tg, tb);
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +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
const char* label = loc::gettext("Font: ");
int len_label = font::len(0, label);
const char* name = font::get_level_font_display_name();
font::print(0, 2, 230, label, tr/2, tg/2, tb/2);
font::print(PR_FONT_LEVEL, 2+len_label, 230, name, tr/2, tg/2, tb/2);
Turn game.currentmenuname "else-if"s into case-switches Much more stylistic, you don't need to repeat "game.currentmenuname" for each case, and you don't need to deal with the dangling first "if" that doesn't have an "else".
2020-04-17 00:19:17 +02:00
break;
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
}
Turn game.currentmenuname "else-if"s into case-switches Much more stylistic, you don't need to repeat "game.currentmenuname" for each case, and you don't need to deal with the dangling first "if" that doesn't have an "else".
2020-04-17 00:19:17 +02:00
case Menu::ed_music:
De-duplicate editor music name printing No need to copy-paste the graphics.Print() for every single case.
2020-07-01 03:40:18 +02:00
{
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
font::print(PR_2X | PR_CEN | PR_CJK_HIGH, -1, 65, loc::gettext("Map Music"), tr, tg, tb);
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
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
font::print_wrap(PR_CEN | PR_CJK_LOW, -1, 85, loc::gettext("Current map music:"), tr, tg, tb);
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
const char* songname;
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
switch(cl.levmusic)
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
{
case 0:
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
songname = loc::gettext("No background music");
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
break;
case 1:
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
songname = loc::gettext("1: Pushing Onwards");
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
break;
case 2:
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
songname = loc::gettext("2: Positive Force");
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
break;
case 3:
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
songname = loc::gettext("3: Potential for Anything");
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
break;
case 4:
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
songname = loc::gettext("4: Passion for Exploring");
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
break;
Add names for previously disallowed songs That way, they don't show up as "?: something else" and their proper names are shown. I didn't update the song numbers to include the newly-allowed songs because otherwise it'd no longer correlate with what song numbers you use for the music() simplified command.
2020-07-01 03:41:20 +02:00
case 5:
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
songname = loc::gettext("N/A: Pause");
Add names for previously disallowed songs That way, they don't show up as "?: something else" and their proper names are shown. I didn't update the song numbers to include the newly-allowed songs because otherwise it'd no longer correlate with what song numbers you use for the music() simplified command.
2020-07-01 03:41:20 +02:00
break;
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
case 6:
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
songname = loc::gettext("5: Presenting VVVVVV");
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
break;
Add names for previously disallowed songs That way, they don't show up as "?: something else" and their proper names are shown. I didn't update the song numbers to include the newly-allowed songs because otherwise it'd no longer correlate with what song numbers you use for the music() simplified command.
2020-07-01 03:41:20 +02:00
case 7:
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
songname = loc::gettext("N/A: Plenary");
Add names for previously disallowed songs That way, they don't show up as "?: something else" and their proper names are shown. I didn't update the song numbers to include the newly-allowed songs because otherwise it'd no longer correlate with what song numbers you use for the music() simplified command.
2020-07-01 03:41:20 +02:00
break;
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
case 8:
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
songname = loc::gettext("6: Predestined Fate");
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
break;
Add names for previously disallowed songs That way, they don't show up as "?: something else" and their proper names are shown. I didn't update the song numbers to include the newly-allowed songs because otherwise it'd no longer correlate with what song numbers you use for the music() simplified command.
2020-07-01 03:41:20 +02:00
case 9:
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
songname = loc::gettext("N/A: ecroF evitisoP");
Add names for previously disallowed songs That way, they don't show up as "?: something else" and their proper names are shown. I didn't update the song numbers to include the newly-allowed songs because otherwise it'd no longer correlate with what song numbers you use for the music() simplified command.
2020-07-01 03:41:20 +02:00
break;
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
case 10:
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
songname = loc::gettext("7: Popular Potpourri");
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
break;
case 11:
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
songname = loc::gettext("8: Pipe Dream");
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
break;
case 12:
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
songname = loc::gettext("9: Pressure Cooker");
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
break;
case 13:
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
songname = loc::gettext("10: Paced Energy");
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
break;
case 14:
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
songname = loc::gettext("11: Piercing the Sky");
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
break;
Add names for previously disallowed songs That way, they don't show up as "?: something else" and their proper names are shown. I didn't update the song numbers to include the newly-allowed songs because otherwise it'd no longer correlate with what song numbers you use for the music() simplified command.
2020-07-01 03:41:20 +02:00
case 15:
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
songname = loc::gettext("N/A: Predestined Fate Remix");
Add names for previously disallowed songs That way, they don't show up as "?: something else" and their proper names are shown. I didn't update the song numbers to include the newly-allowed songs because otherwise it'd no longer correlate with what song numbers you use for the music() simplified command.
2020-07-01 03:41:20 +02:00
break;
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
default:
Editor.cpp: make editormenurender translatable This mainly adds loc::gettext calls. 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 23:17:58 +01:00
songname = loc::gettext("?: something else");
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
break;
}
Completely remove Graphics::PrintWrap All print calls are font:: ones now and all the old Graphics:: print functions have been removed, the migration is complete!
2023-01-20 21:11:18 +01:00
font::print_wrap(PR_CEN, -1, 120, songname, tr, tg, tb);
Turn game.currentmenuname "else-if"s into case-switches Much more stylistic, you don't need to repeat "game.currentmenuname" for each case, and you don't need to deal with the dangling first "if" that doesn't have an "else".
2020-04-17 00:19:17 +02:00
break;
De-duplicate editor music name printing No need to copy-paste the graphics.Print() for every single case.
2020-07-01 03:40:18 +02:00
}
Turn game.currentmenuname "else-if"s into case-switches Much more stylistic, you don't need to repeat "game.currentmenuname" for each case, and you don't need to deal with the dangling first "if" that doesn't have an "else".
2020-04-17 00:19:17 +02:00
case Menu::ed_quit:
Completely remove Graphics::PrintWrap All print calls are font:: ones now and all the old Graphics:: print functions have been removed, the migration is complete!
2023-01-20 21:11:18 +01:00
font::print_wrap(PR_CEN, -1, 90, loc::gettext("Save before quitting?"), tr, tg, tb);
Turn game.currentmenuname "else-if"s into case-switches Much more stylistic, you don't need to repeat "game.currentmenuname" for each case, and you don't need to deal with the dangling first "if" that doesn't have an "else".
2020-04-17 00:19:17 +02:00
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 Menu::ed_font:
{
font::print(PR_2X | PR_CEN, -1, 30, loc::gettext("Level Font"), tr, tg, tb);
font::print_wrap(PR_CEN, -1, 65, loc::gettext("Select the language in which the text in this level is written."), tr, tg, tb);
const char* label = loc::gettext("Font: ");
int len_label = font::len(0, label);
const char* name = font::get_level_font_display_name();
font::print(0, 2, 230, label, tr/2, tg/2, tb/2);
font::print(PR_FONT_LEVEL, 2+len_label, 230, name, tr/2, tg/2, tb/2);
break;
}
Turn game.currentmenuname "else-if"s into case-switches Much more stylistic, you don't need to repeat "game.currentmenuname" for each case, and you don't need to deal with the dangling first "if" that doesn't have an "else".
2020-04-17 00:19:17 +02:00
default:
break;
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
}
}
Clean code for direct mode drawer The drawer could definitely be improved further, however I cleaned up a little bit of the code duplication. I'll have to take a closer look some other time, but I'm pretty sure that the duplicated code at the bottom can be removed with a few tweaks, but I'll do that carefully in a different commit.
2023-03-02 08:10:17 +01:00
static void draw_background_grid(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
De-duplicate room tile drawing code in editor It previously duplicated the for-loop twice, once for tiles.png and tiles2.png, which just made me sad. Now it doesn't do that. Also it previously had an alternate tileset == 10 condition for tiles.png, which didn't seem to do anything because there's no such thing as tileset 10, and anyways it's useless in-game because when playing in the actual game it won't draw tiles.png, so I removed it. I don't know why it was there in the first place. Since I removed the temp variable from the outer scope, the other usage of it has to be updated.
2022-12-30 07:19:40 +01:00
for (int j = 0; j < 30; j++)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
De-duplicate room tile drawing code in editor It previously duplicated the for-loop twice, once for tiles.png and tiles2.png, which just made me sad. Now it doesn't do that. Also it previously had an alternate tileset == 10 condition for tiles.png, which didn't seem to do anything because there's no such thing as tileset 10, and anyways it's useless in-game because when playing in the actual game it won't draw tiles.png, so I removed it. I don't know why it was there in the first place. Since I removed the temp variable from the outer scope, the other usage of it has to be updated.
2022-12-30 07:19:40 +01:00
for (int i = 0; i < 40; i++)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if (i == 19 || i == 20 || j == 14 || j == 29)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// Major guidelines
graphics.draw_rect(i * 8, j * 8, 7, 7, graphics.getRGB(32, 32, 32));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
else if (i == 9 || i == 30 || j == 6 || j == 7 || j == 21 || j == 22)
De-duplicate room tile drawing code in editor It previously duplicated the for-loop twice, once for tiles.png and tiles2.png, which just made me sad. Now it doesn't do that. Also it previously had an alternate tileset == 10 condition for tiles.png, which didn't seem to do anything because there's no such thing as tileset 10, and anyways it's useless in-game because when playing in the actual game it won't draw tiles.png, so I removed it. I don't know why it was there in the first place. Since I removed the temp variable from the outer scope, the other usage of it has to be updated.
2022-12-30 07:19:40 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// Minor guidelines
graphics.draw_rect(i * 8, j * 8, 7, 7, graphics.getRGB(24, 24, 24));
}
else if (i % 4 == 0 || j % 4 == 0)
{
graphics.draw_rect(i * 8, j * 8, 7, 7, graphics.getRGB(16, 16, 16));
De-duplicate room tile drawing code in editor It previously duplicated the for-loop twice, once for tiles.png and tiles2.png, which just made me sad. Now it doesn't do that. Also it previously had an alternate tileset == 10 condition for tiles.png, which didn't seem to do anything because there's no such thing as tileset 10, and anyways it's useless in-game because when playing in the actual game it won't draw tiles.png, so I removed it. I don't know why it was there in the first place. Since I removed the temp variable from the outer scope, the other usage of it has to be updated.
2022-12-30 07:19:40 +01:00
}
else
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.draw_rect(i * 8, j * 8, 7, 7, graphics.getRGB(8, 8, 8));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Clean code for direct mode drawer The drawer could definitely be improved further, however I cleaned up a little bit of the code duplication. I'll have to take a closer look some other time, but I'm pretty sure that the duplicated code at the bottom can be removed with a few tweaks, but I'll do that carefully in a different commit.
2023-03-02 08:10:17 +01:00
static void draw_background(int warpdir)
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
{
extern editorclass ed;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
switch (warpdir)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
case 1:
graphics.rcol = cl.getwarpbackground(ed.levx, ed.levy);
graphics.drawbackground(3);
break;
case 2:
graphics.rcol = cl.getwarpbackground(ed.levx, ed.levy);
graphics.drawbackground(4);
break;
case 3:
graphics.rcol = cl.getwarpbackground(ed.levx, ed.levy);
graphics.drawbackground(5);
break;
default:
break;
}
}
Clean code for direct mode drawer The drawer could definitely be improved further, however I cleaned up a little bit of the code duplication. I'll have to take a closer look some other time, but I'm pretty sure that the duplicated code at the bottom can be removed with a few tweaks, but I'll do that carefully in a different commit.
2023-03-02 08:10:17 +01:00
static void draw_edgeguide(int type, int x, int y, bool vertical)
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
{
static const SDL_Color white = graphics.getRGB(255 - help.glow, 255, 255);
static const SDL_Color red = graphics.getRGB(255 - help.glow, 127, 127);
if (type != TileType_SOLID && type != TileType_SPIKE)
{
return;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if (vertical)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.fill_rect(x, y, 8, 2, (type == TileType_SOLID) ? white : red);
}
else
{
graphics.fill_rect(x, y, 2, 8, (type == TileType_SOLID) ? white : red);
}
}
Clean code for direct mode drawer The drawer could definitely be improved further, however I cleaned up a little bit of the code duplication. I'll have to take a closer look some other time, but I'm pretty sure that the duplicated code at the bottom can be removed with a few tweaks, but I'll do that carefully in a different commit.
2023-03-02 08:10:17 +01:00
static void draw_edgeguides(void)
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
{
extern editorclass ed;
const int global_x = ed.levx * 40;
const int global_y = ed.levy * 30;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// Draw edge-guides, so there's no room misalignments!
for (int i = 0; i < 40; i++)
{
if (i < 30)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// Left edge
draw_edgeguide(ed.tile_type_wrap(global_x - 1, global_y + i), 0, i * 8, false);
// Right edge
draw_edgeguide(ed.tile_type_wrap(global_x + 40, global_y + i), 318, i * 8, false);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// Top edge
draw_edgeguide(ed.tile_type_wrap(global_x + i, global_y - 1), i * 8, 0, true);
// Bottom edge
draw_edgeguide(ed.tile_type_wrap(global_x + i, global_y + 30), i * 8, 238, true);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
}
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
static void update_entities(void)
{
extern editorclass ed;
for (size_t i = 0; i < customentities.size(); ++i)
{
CustomEntity* entity = &customentities[i];
if (entity->x / 40 != ed.levx || entity->y / 30 != ed.levy)
{
// It's not in this room, so just continue
continue;
}
bool grav_line = (entity->t == 11);
bool warp_line = (entity->t == 50);
if ((grav_line || warp_line) && entity->p4 != 1)
{
// If it's a grav line or a warp line, and it's not locked
if ((grav_line && entity->p1 == 0) || (warp_line && entity->p1 >= 2))
{
/* Horizontal */
int tx = entity->x % 40;
int tx2 = tx;
int ty = entity->y % 30;
while (!ed.spikefree(tx, ty))
{
--tx;
}
while (!ed.spikefree(tx2, ty))
{
++tx2;
}
++tx;
entity->p2 = tx;
entity->p3 = (tx2 - tx) * 8;
}
else
{
/* Vertical */
int tx = entity->x % 40;
int ty = entity->y % 30;
int ty2 = ty;
while (!ed.spikefree(tx, ty))
{
--ty;
}
while (!ed.spikefree(tx, ty2))
{
++ty2;
}
++ty;
entity->p2 = ty;
entity->p3 = (ty2 - ty) * 8;
}
}
}
}
Clean code for direct mode drawer The drawer could definitely be improved further, however I cleaned up a little bit of the code duplication. I'll have to take a closer look some other time, but I'm pretty sure that the duplicated code at the bottom can be removed with a few tweaks, but I'll do that carefully in a different commit.
2023-03-02 08:10:17 +01:00
static void draw_entities(void)
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
{
extern editorclass ed;
const RoomProperty* const room = cl.getroomprop(ed.levx, ed.levy);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
//Draw entities
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
obj.customplatformtile = game.customcol * 12;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
const int edent_under_cursor = ed.edentat(ed.tilex + ed.levx * 40, ed.tiley + ed.levy * 30);
Draw editor entities according to ingame order Ingame entities are drawn backwards, probably to draw the player on top, being entity 0 (usually, at least). Make the level editor draw entities in the same order.
2020-01-27 02:15:49 +01:00
Fix entities in the Warp Zone's gray tileset not being gray in the editor (#480) In-level, they were made to be gray in #323. The editor does not reflect this however; they're still shown as green. For the same reasons in #323, this adds special cases to draw the entities as gray. Closes #372. Also, I changed my name in contributors.txt to be my username as I didn't feel comfortable with it being my name. Co-authored-by: Misa <ness.of.onett.earthbound@gmail.com>
2020-09-25 19:35:03 +02:00
// Special case for drawing gray entities
Refactor room properties to use setter and getter funcs This replaces all raw ed.level accesses with new setter and getter funcs, which makes it easier to add bounds checks later. And I've also removed all the manually-written bounds checks, since they will go into the new getter and setter. To get the room properties of a specific room, you use editorclass::getroomprop(), which returns a pointer to the room properties - then you just read off of that pointer. To set a room property, you use editorclass::setroom<PROP>(), where <PROP> is the name of the property. These are maintained using X macros to avoid copy-pasting. editorclass::getroompropidx() is a helper function and shouldn't be used directly.
2021-03-24 19:59:36 +01:00
bool custom_gray = room->tileset == 3 && room->tilecol == 6;
Fix entities in the Warp Zone's gray tileset not being gray in the editor (#480) In-level, they were made to be gray in #323. The editor does not reflect this however; they're still shown as green. For the same reasons in #323, this adds special cases to draw the entities as gray. Closes #372. Also, I changed my name in contributors.txt to be my username as I didn't feel comfortable with it being my name. Co-authored-by: Misa <ness.of.onett.earthbound@gmail.com>
2020-09-25 19:35:03 +02:00
Draw editor entities according to ingame order Ingame entities are drawn backwards, probably to draw the player on top, being entity 0 (usually, at least). Make the level editor draw entities in the same order.
2020-01-27 02:15:49 +01:00
// Draw entities backward to remain accurate with ingame
Rename edentity to customentities This fixes the fact that the name of the singular type is plural, but the name of the plural array is singular. Which has always annoyed me, too. Also this makes it more clear that custom entities don't have much to do with the editor.
2021-02-21 01:01:39 +01:00
for (int i = customentities.size() - 1; i >= 0; i--)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
CustomEntity* entity = &customentities[i];
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// If the entity is in the current room, draw it
if (entity->x / 40 == ed.levx && entity->y / 30 == ed.levy)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
const int x = entity->x % 40 * 8;
const int y = entity->y % 30 * 8;
static const char arrows[] = "V^<>";
switch (entity->t)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
case 1: // Enemies
{
const int movement = entity->p1;
Use SDL_Color for colors instead of colourTransform colourTransform is a struct with only one member, a Uint32. The issue with `Uint32`s is that it requires a bunch of bit shifting logic to edit the colors. The issue with bit shifting logic is that people have a tendency to hardcode the shift amounts instead of using the shift amount variables of the SDL_PixelFormat, which makes it annoying to change the color masks of surfaces. This commit fixes both issues by unhardcoding the bit shift amounts in DrawPixel and ReadPixel, and by axing the `Uint32`s in favor of using SDL_Color. According to the SDL_PixelFormat documentation ( https://wiki.libsdl.org/SDL2/SDL_PixelFormat ), the logic to read and draw to pixels from colors below 32-bit was just wrong. Specifically, for 8-bit, there's a color palette used instead of some intrinsic color information stored in the pixel itself. But we shouldn't need that logic anyways because we don't use colors below 32-bit. So I axed that too.
2023-01-02 01:36:43 +01:00
if (custom_gray)
{
Axe Graphics::ct and Graphics::setcolreal `ct` was used to be a variable that a color was temporarily stored in before being passed to a draw function. But this is unnecessary and you might as well just have a temporary of the color directly. I guess this was the practice used because temporaries were apparently really bad in Flash. setcolreal() was added in 2.3 to do basically the same thing (set it directly from entities' realcol attributes). But it's no longer needed. Correspondingly, Graphics::setcol has been renamed to Graphics::getcol and now returns an SDL_Color, and Graphics::huetilesetcol has been renamed to Graphics::huetilegetcol for the same reason. Some functions (notably Graphics::drawimagecol and Graphics::drawhuetile) were relying on the `ct` to be implicitly set and weren't ever having it passed in directly. They have been corrected accordingly.
2023-01-02 05:16:08 +01:00
ed.entcolreal = graphics.getcol(18);
Fix entities in the Warp Zone's gray tileset not being gray in the editor (#480) In-level, they were made to be gray in #323. The editor does not reflect this however; they're still shown as green. For the same reasons in #323, this adds special cases to draw the entities as gray. Closes #372. Also, I changed my name in contributors.txt to be my username as I didn't feel comfortable with it being my name. Co-authored-by: Misa <ness.of.onett.earthbound@gmail.com>
2020-09-25 19:35:03 +02:00
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.draw_sprite(x, y, ed.getenemyframe(room->enemytype), ed.entcolreal);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if (movement >= 0 && movement < 4)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// If they have a basic movement type, draw an arrow to indicate direction
font::print(PR_FONT_8X8, x + 4, y + 4, std::string(1, arrows[movement]), 255, 255, 255 - help.glow);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.draw_rect(x, y, 16, 16, graphics.getRGB(255, 164, 255));
break;
}
case 2: // Conveyors & Platforms
{
const int movement = entity->p1;
const short length = (movement == 7 || movement == 8) ? 8 : 4;
const short glow = 255 - help.glow;
for (int j = 0; j < length; j++) {
graphics.draw_grid_tile(custom_gray ? graphics.grphx.im_entcolours_tint : graphics.grphx.im_entcolours, obj.customplatformtile, x + (j * 8), y, 8, 8);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
switch (movement)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
case 0:
case 1:
case 2:
case 3:
// If they have a basic movement type, draw an arrow to indicate direction
font::print(PR_FONT_8X8, x + 12, y, std::string(1, arrows[movement]), glow, glow, glow);
break;
case 4:
// Always move right, stopping when hitting collision
font::print(PR_FONT_8X8, x + 8, y, ">I", glow, glow, glow);
break;
case 5:
font::print(PR_FONT_8X8, x, y, ">>>>", glow, glow, glow);
break;
case 6:
font::print(PR_FONT_8X8, x, y, "<<<<", glow, glow, glow);
break;
case 7:
font::print(PR_FONT_8X8, x + 4, y, "> > > > ", glow, glow, glow);
break;
case 8:
font::print(PR_FONT_8X8, x + 4, y, "< < < < ", glow, glow, glow);
break;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if (movement < 0)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// Well, it's a negative type, so it'll just be still.
font::print(PR_FONT_8X8, x + 8, y, "[]", glow, glow, glow);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
else if (movement > 8)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// Invalid... draw a scary red X
font::print(PR_FONT_8X8, x + 12, y, "X", glow, 0, 0);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.draw_rect(x, y, 8 * length, 8, graphics.getRGB(255, 255, 255));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
break;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
}
case 3: // Disappearing Platforms
Fix "name lookup of ‘i’ changed" warning in editor.cpp I got this warning during compilation because there were two nested for loops both defining i. Better to have different names to make sure some compilers won't overwrite the outer variable with the inner one.
2020-10-11 22:56:17 +02:00
for (int j = 0; j < 4; j++) {
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.draw_grid_tile(custom_gray ? graphics.grphx.im_entcolours_tint : graphics.grphx.im_entcolours, obj.customplatformtile, x + (j * 8), y, 8, 8);
Fix entities in the Warp Zone's gray tileset not being gray in the editor (#480) In-level, they were made to be gray in #323. The editor does not reflect this however; they're still shown as green. For the same reasons in #323, this adds special cases to draw the entities as gray. Closes #372. Also, I changed my name in contributors.txt to be my username as I didn't feel comfortable with it being my name. Co-authored-by: Misa <ness.of.onett.earthbound@gmail.com>
2020-09-25 19:35:03 +02:00
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
font::print(PR_FONT_8X8, x, y, "////", 255 - help.glow, 255 - help.glow, 255 - help.glow);
graphics.draw_rect(x, y, 32, 8, graphics.getRGB(255, 255, 255));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
break;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
case 9: // Shiny Trinkets
graphics.draw_sprite(x, y, 22, 196, 196, 196);
graphics.draw_rect(x, y, 16, 16, graphics.getRGB(255, 164, 164));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
break;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
case 10: // Checkpoints
graphics.draw_sprite(x, y, 20 + entity->p1, 196, 196, 196);
graphics.draw_rect(x, y, 16, 16, graphics.getRGB(255, 164, 164));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
break;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
case 11: // Gravity Lines
// p2 is in tiles, and p3 is in pixels
if (entity->p1 == 0)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// Horizontal gravity line
const int left = entity->p2 * 8;
const int width = entity->p3;
graphics.fill_rect(left, y + 4, width, 1, graphics.getRGB(194, 194, 194));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
else
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// Vertical gravity line
const int top = entity->p2 * 8;
const int height = entity->p3;
graphics.fill_rect(x + 3, top, 1, height, graphics.getRGB(194, 194, 194));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.draw_rect(x, y, 8, 8, graphics.getRGB(164, 255, 164));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
break;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
case 13: // Warp Tokens
{
std::string text;
graphics.draw_sprite(x, y, 18 + (ed.entframe % 2), 196, 196, 196);
graphics.draw_rect(x, y, 16, 16, graphics.getRGB(255, 164, 164));
Fix up temporary variables being in topmost scope and bad style This makes it so temporary variables have their scopes reduced (if possible). I also didn't hesitate to fix style issues, such as their names ("temp" is such a bad name), making them const if possible, and any code it touched too.
2022-12-30 07:23:48 +01:00
if (i == edent_under_cursor)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
text = "(" + help.String(entity->p1 / 40 + 1) + "," + help.String(entity->p2 / 30 + 1) + ")";
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
text = help.String(cl.findwarptoken(i));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
font::print(PR_BOR | PR_CJK_HIGH, x, y - 8, text, 210, 210, 255);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
break;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
}
case 15: // Crewmates
graphics.draw_sprite(x - 4, y, 144, graphics.crewcolourreal(entity->p1));
graphics.draw_rect(x, y, 16, 24, graphics.getRGB(164, 164, 164));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
break;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
case 16: // Start Point
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
const short labelcol = ed.entframe < 2 ? 255 : 196;
if (entity->p1 == 0) // Facing right
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.draw_sprite(x - 4, y, 0, graphics.col_crewcyan);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
else // Non-zero is facing left
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.draw_sprite(x - 4, y, 3, graphics.col_crewcyan);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.draw_rect(x, y, 16, 24, graphics.getRGB(255, 255, 164));
font::print(PR_BOR | PR_CEN | PR_CJK_HIGH, x + 8, y - 8, loc::gettext("START"), labelcol, labelcol, labelcol);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
break;
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
case 17: // Roomtext
{
int width = 8;
int height = 8;
if (entity->scriptname.length() > 0)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
width = font::len(PR_FONT_LEVEL, entity->scriptname.c_str());
height = font::height(PR_FONT_LEVEL);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.draw_rect(x, y, width, height, graphics.getRGB(96, 96, 96));
font::print(PR_FONT_LEVEL | PR_CJK_LOW, x, y, entity->scriptname, 196, 196, 255 - help.glow);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
break;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
}
case 18: // Terminals
Improve support for retextured checkpoints and terminals in the editor Retextured checkpoints have always been in the game, but clicking on them in the editor would lead to them losing their retextured-ness. So, checkpoints should be left alone if their p1 isn't either 0 or 1. Also, they don't show up properly in the editor, so that's fixed, too. Retextured and flipped terminals were added in 2.3, and show up properly in-game, but don't properly show up in the editor, either. So now they show up in the editor. Additionally, clicking on them will flip the terminal as well, but only if its p1 is 0 or 1, just like checkpoints now do.
2021-01-12 02:19:20 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
int sprite = entity->p1;
int corrected_y = y;
Improve support for retextured checkpoints and terminals in the editor Retextured checkpoints have always been in the game, but clicking on them in the editor would lead to them losing their retextured-ness. So, checkpoints should be left alone if their p1 isn't either 0 or 1. Also, they don't show up properly in the editor, so that's fixed, too. Retextured and flipped terminals were added in 2.3, and show up properly in-game, but don't properly show up in the editor, either. So now they show up in the editor. Additionally, clicking on them will flip the terminal as well, but only if its p1 is 0 or 1, just like checkpoints now do.
2021-01-12 02:19:20 +01:00
// Not a boolean: just swapping 0 and 1, leaving the rest alone
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if (sprite == 0)
Improve support for retextured checkpoints and terminals in the editor Retextured checkpoints have always been in the game, but clicking on them in the editor would lead to them losing their retextured-ness. So, checkpoints should be left alone if their p1 isn't either 0 or 1. Also, they don't show up properly in the editor, so that's fixed, too. Retextured and flipped terminals were added in 2.3, and show up properly in-game, but don't properly show up in the editor, either. So now they show up in the editor. Additionally, clicking on them will flip the terminal as well, but only if its p1 is 0 or 1, just like checkpoints now do.
2021-01-12 02:19:20 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
sprite = 1; // Unflipped
Improve support for retextured checkpoints and terminals in the editor Retextured checkpoints have always been in the game, but clicking on them in the editor would lead to them losing their retextured-ness. So, checkpoints should be left alone if their p1 isn't either 0 or 1. Also, they don't show up properly in the editor, so that's fixed, too. Retextured and flipped terminals were added in 2.3, and show up properly in-game, but don't properly show up in the editor, either. So now they show up in the editor. Additionally, clicking on them will flip the terminal as well, but only if its p1 is 0 or 1, just like checkpoints now do.
2021-01-12 02:19:20 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
else if (sprite == 1)
Improve support for retextured checkpoints and terminals in the editor Retextured checkpoints have always been in the game, but clicking on them in the editor would lead to them losing their retextured-ness. So, checkpoints should be left alone if their p1 isn't either 0 or 1. Also, they don't show up properly in the editor, so that's fixed, too. Retextured and flipped terminals were added in 2.3, and show up properly in-game, but don't properly show up in the editor, either. So now they show up in the editor. Additionally, clicking on them will flip the terminal as well, but only if its p1 is 0 or 1, just like checkpoints now do.
2021-01-12 02:19:20 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
sprite = 0; // Flipped;
corrected_y -= 8;
Improve support for retextured checkpoints and terminals in the editor Retextured checkpoints have always been in the game, but clicking on them in the editor would lead to them losing their retextured-ness. So, checkpoints should be left alone if their p1 isn't either 0 or 1. Also, they don't show up properly in the editor, so that's fixed, too. Retextured and flipped terminals were added in 2.3, and show up properly in-game, but don't properly show up in the editor, either. So now they show up in the editor. Additionally, clicking on them will flip the terminal as well, but only if its p1 is 0 or 1, just like checkpoints now do.
2021-01-12 02:19:20 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.draw_sprite(x, corrected_y + 8, sprite + 16, 96, 96, 96);
graphics.draw_rect(x, y, 16, 24, graphics.getRGB(164, 164, 164));
Fix up temporary variables being in topmost scope and bad style This makes it so temporary variables have their scopes reduced (if possible). I also didn't hesitate to fix style issues, such as their names ("temp" is such a bad name), making them const if possible, and any code it touched too.
2022-12-30 07:23:48 +01:00
if (i == edent_under_cursor)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
font::print(PR_FONT_LEVEL | PR_BOR | PR_CJK_HIGH, x, y - 8, entity->scriptname, 210, 210, 255);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
break;
Improve support for retextured checkpoints and terminals in the editor Retextured checkpoints have always been in the game, but clicking on them in the editor would lead to them losing their retextured-ness. So, checkpoints should be left alone if their p1 isn't either 0 or 1. Also, they don't show up properly in the editor, so that's fixed, too. Retextured and flipped terminals were added in 2.3, and show up properly in-game, but don't properly show up in the editor, either. So now they show up in the editor. Additionally, clicking on them will flip the terminal as well, but only if its p1 is 0 or 1, just like checkpoints now do.
2021-01-12 02:19:20 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
case 19: // Script Triggers
graphics.draw_rect(x, y, entity->p1 * 8, entity->p2 * 8, graphics.getRGB(255, 164, 255));
graphics.draw_rect(x, y, 8, 8, graphics.getRGB(255, 255, 255));
Fix up temporary variables being in topmost scope and bad style This makes it so temporary variables have their scopes reduced (if possible). I also didn't hesitate to fix style issues, such as their names ("temp" is such a bad name), making them const if possible, and any code it touched too.
2022-12-30 07:23:48 +01:00
if (i == edent_under_cursor)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
font::print(PR_FONT_LEVEL | PR_BOR | PR_CJK_HIGH, x, y - 8, entity->scriptname, 210, 210, 255);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
break;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
case 50: // Warp Lines
if (entity->p1 >= 2) // Horizontal
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
int left = entity->p2;
int right = left + entity->p3 / 8;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.draw_rect((left * 8), y + 1, (right - left) * 8, 6, graphics.getRGB(194, 255, 255));
graphics.draw_rect(x, y, 8, 8, graphics.getRGB(164, 255, 255));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
else // Vertical
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
int top = entity->p2;
int bottom = top + entity->p3 / 8;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.draw_rect(x + 1, (top * 8), 6, (bottom - top) * 8, graphics.getRGB(194, 255, 255));
graphics.draw_rect(x, y, 8, 8, graphics.getRGB(164, 255, 255));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
break;
}
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// Need to also check warp point destinations
if (entity->t == 13 && ed.warpent != i)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// Is the destination in this room?
if (entity->p1 / 40 == ed.levx && entity->p2 / 30 == ed.levy)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
const int x = entity->p1 % 40 * 8;
const int y = entity->p2 % 30 * 8;
std::string text;
graphics.draw_sprite(x, y, 18 + (ed.entframe % 2), 64, 64, 64);
graphics.draw_rect((entity->p1 * 8) - (ed.levx * 40 * 8), (entity->p2 * 8) - (ed.levy * 30 * 8), 16, 16, graphics.getRGB(96, 64, 64));
if (ed.tilex == x / 8 && ed.tiley == y / 8)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
text = "(" + help.String(entity->x / 40 + 1) + "," + help.String(entity->y / 30 + 1) + ")";
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
text = help.String(cl.findwarptoken(i));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
font::print(PR_BOR | PR_CJK_HIGH, x, y - 8, text, 190, 190, 225);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Clean code for direct mode drawer The drawer could definitely be improved further, however I cleaned up a little bit of the code duplication. I'll have to take a closer look some other time, but I'm pretty sure that the duplicated code at the bottom can be removed with a few tweaks, but I'll do that carefully in a different commit.
2023-03-02 08:10:17 +01:00
static void draw_ghosts(void)
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
{
extern editorclass ed;
//Draw ghosts (spooky!)
if (game.ghostsenabled) {
graphics.set_render_target(graphics.ghostTexture);
graphics.set_blendmode(graphics.ghostTexture, SDL_BLENDMODE_BLEND);
graphics.clear(0, 0, 0, 0);
for (int i = 0; i < (int) ed.ghosts.size(); i++) {
if (i <= ed.currentghosts) { // We don't want all of them to show up at once :)
if (ed.ghosts[i].rx != ed.levx || ed.ghosts[i].ry != ed.levy)
continue;
SDL_Color ct = ed.ghosts[i].realcol;
const int alpha = 3 * ct.a / 4;
ct.a = (Uint8)alpha;
graphics.draw_sprite(ed.ghosts[i].x, ed.ghosts[i].y, ed.ghosts[i].frame, ct);
}
}
graphics.set_render_target(graphics.gameTexture);
graphics.set_texture_alpha_mod(graphics.ghostTexture, 128);
graphics.copy_texture(graphics.ghostTexture, NULL, NULL);
}
}
Clean code for direct mode drawer The drawer could definitely be improved further, however I cleaned up a little bit of the code duplication. I'll have to take a closer look some other time, but I'm pretty sure that the duplicated code at the bottom can be removed with a few tweaks, but I'll do that carefully in a different commit.
2023-03-02 08:10:17 +01:00
static void draw_bounds(void)
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
{
extern editorclass ed;
const RoomProperty* const room = cl.getroomprop(ed.levx, ed.levy);
if (ed.boundarymod>0)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
if(ed.boundarymod==1)
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.draw_rect(ed.tilex*8, ed.tiley*8, 8,8,graphics.getRGB(210 + help.glow/2, 191 + help.glow, 255 - help.glow/2));
graphics.draw_rect((ed.tilex*8)+2, (ed.tiley*8)+2, 4,4,graphics.getRGB(105 + help.glow/4, 100 + help.glow/2, 128 - help.glow/4));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else if(ed.boundarymod==2)
{
if((ed.tilex*8)+8<=ed.boundx1 || (ed.tiley*8)+8<=ed.boundy1)
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.draw_rect(ed.boundx1, ed.boundy1, 8, 8,graphics.getRGB(210 + help.glow/2, 191 + help.glow, 255 - help.glow/2));
graphics.draw_rect(ed.boundx1+2, ed.boundy1+2, 4, 4,graphics.getRGB(105 + help.glow/4, 100 + help.glow/2, 128 - help.glow/4));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.draw_rect(ed.boundx1, ed.boundy1, (ed.tilex*8)+8-ed.boundx1,(ed.tiley*8)+8-ed.boundy1,graphics.getRGB(210 + help.glow/2, 191 + help.glow, 255 - help.glow/2));
graphics.draw_rect(ed.boundx1+2, ed.boundy1+2, (ed.tilex*8)+8-ed.boundx1-4,(ed.tiley*8)+8-ed.boundy1-4,graphics.getRGB(105 + help.glow/4, 100 + help.glow/2, 128 - help.glow/4));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
}
else
{
//Draw boundaries
Fix enemy/plat bounds not being drawn if any side touches a screen edge Enemy/platform bounds are intended to not be drawn if they cover the whole screen, since that's what their default bounds are. However, the code inadvertently made it so if ANY of the bounds touched a screen edge, the bounds wouldn't be drawn. This is because the conditionals used "and"s instead of "or"s. The proper way to write the positive conditional is "x1 is 0 and y1 is 0 and x2 is 320 and y2 is 240", and when you invert that conditional, you need to also invert all "and"s to be "or"s. This is not the first time that the game developers failed to properly negate conjunctional statements...
2021-08-28 22:03:04 +02:00
if(room->enemyx1!=0 || room->enemyy1!=0
|| room->enemyx2!=320 || room->enemyy2!=240)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.draw_rect( room->enemyx1, room->enemyy1,
Refactor room properties to use setter and getter funcs This replaces all raw ed.level accesses with new setter and getter funcs, which makes it easier to add bounds checks later. And I've also removed all the manually-written bounds checks, since they will go into the new getter and setter. To get the room properties of a specific room, you use editorclass::getroomprop(), which returns a pointer to the room properties - then you just read off of that pointer. To set a room property, you use editorclass::setroom<PROP>(), where <PROP> is the name of the property. These are maintained using X macros to avoid copy-pasting. editorclass::getroompropidx() is a helper function and shouldn't be used directly.
2021-03-24 19:59:36 +01:00
room->enemyx2-room->enemyx1,
room->enemyy2-room->enemyy1,
Remove getBGR getBGR, when used in FillRect, was actually passing colors in RGB order. But now the masks are fixed, so remove it, and fix up all existing getBGR colors to use getRGB instead.
2021-08-28 21:59:46 +02:00
graphics.getRGB(255-(help.glow/2),64,64));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Fix enemy/plat bounds not being drawn if any side touches a screen edge Enemy/platform bounds are intended to not be drawn if they cover the whole screen, since that's what their default bounds are. However, the code inadvertently made it so if ANY of the bounds touched a screen edge, the bounds wouldn't be drawn. This is because the conditionals used "and"s instead of "or"s. The proper way to write the positive conditional is "x1 is 0 and y1 is 0 and x2 is 320 and y2 is 240", and when you invert that conditional, you need to also invert all "and"s to be "or"s. This is not the first time that the game developers failed to properly negate conjunctional statements...
2021-08-28 22:03:04 +02:00
if(room->platx1!=0 || room->platy1!=0
|| room->platx2!=320 || room->platy2!=240)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.draw_rect( room->platx1, room->platy1,
Refactor room properties to use setter and getter funcs This replaces all raw ed.level accesses with new setter and getter funcs, which makes it easier to add bounds checks later. And I've also removed all the manually-written bounds checks, since they will go into the new getter and setter. To get the room properties of a specific room, you use editorclass::getroomprop(), which returns a pointer to the room properties - then you just read off of that pointer. To set a room property, you use editorclass::setroom<PROP>(), where <PROP> is the name of the property. These are maintained using X macros to avoid copy-pasting. editorclass::getroompropidx() is a helper function and shouldn't be used directly.
2021-03-24 19:59:36 +01:00
room->platx2-room->platx1,
room->platy2-room->platy1,
Remove getBGR getBGR, when used in FillRect, was actually passing colors in RGB order. But now the masks are fixed, so remove it, and fix up all existing getBGR colors to use getRGB instead.
2021-08-28 21:59:46 +02:00
graphics.getRGB(64,64,255-(help.glow/2)));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Clean code for direct mode drawer The drawer could definitely be improved further, however I cleaned up a little bit of the code duplication. I'll have to take a closer look some other time, but I'm pretty sure that the duplicated code at the bottom can be removed with a few tweaks, but I'll do that carefully in a different commit.
2023-03-02 08:10:17 +01:00
static void draw_cursor(void)
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
{
extern editorclass ed;
Add a player trail to the editor (ghosts) A few months ago, I added ghosts to the VVVVVV: Community Edition editor. I was told recently I should think about upstreaming it, and with Terry saying go ahead I finally ported them into VVVVVV. There's one slight difference however--you can choose whether you have them or not in the editor's settings menu. They're off by default, and this is saved to the save file. Anyway, when you're playtesting, the game saves the players position, color, room coordinates and sprite every 3 frames. The max is 100, where if it tries to add more, the oldest one gets removed. When you exit playtesting, the saved positions appear one at a time, and you can use the Z key to speed it up. [Here's a video of them in action.](https://o.lol-sa.me/4H21zCv.mp4)
2020-06-13 00:04:35 +02:00
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
static const SDL_Color blue = graphics.getRGB(32, 32, 200);
const int x = ed.tilex * 8;
const int y = ed.tiley * 8;
switch (ed.current_tool)
{
case EditorTool_WALLS:
case EditorTool_BACKING:
// Modifiers!
if (ed.bmod) graphics.draw_rect(x, 0, 8, 240, blue); // Vertical
else if (ed.hmod) graphics.draw_rect(0, y, 320, 8, blue); // Horizontal
else if (ed.vmod) graphics.draw_rect(x - 32, y - 32, 24 + 48, 24 + 48, blue); // 9x9
else if (ed.cmod) graphics.draw_rect(x - 24, y - 24, 24 + 32, 24 + 32, blue); // 7x7
else if (ed.xmod) graphics.draw_rect(x - 16, y - 16, 24 + 16, 24 + 16, blue); // 5x5
else if (ed.zmod) graphics.draw_rect(x - 8, y - 8, 24, 24, blue); // 3x3
SDL_FALLTHROUGH;
case EditorTool_SPIKES:
case EditorTool_GRAVITY_LINES:
case EditorTool_ROOMTEXT:
case EditorTool_SCRIPTS:
// 1x1
graphics.draw_rect(x, y, 8, 8, blue);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
break;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
case EditorTool_TRINKETS:
case EditorTool_CHECKPOINTS:
case EditorTool_ENEMIES:
case EditorTool_WARP_TOKENS:
// 2x2
graphics.draw_rect(x, y, 16, 16, blue);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
break;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
case EditorTool_DISAPPEARING_PLATFORMS:
case EditorTool_CONVEYORS:
case EditorTool_MOVING_PLATFORMS:
// 1x4 (platforms)
graphics.draw_rect(x, y, 32, 8, blue);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
break;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
case EditorTool_WARP_LINES:
// 1x1, but X if not on an edge (warp lines)
if (ed.tilex == 0 || ed.tilex == 39 || ed.tiley == 0 || ed.tiley == 29)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.draw_rect(x, y, 8, 8, blue);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
font::print(PR_FONT_8X8, x, y, "X", 255, 0, 0);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
break;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
case EditorTool_TERMINALS:
case EditorTool_CREWMATES:
case EditorTool_START_POINT:
// 2x3
graphics.draw_rect(x, y, 16, 24, blue);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
break;
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
}
Clean code for direct mode drawer The drawer could definitely be improved further, however I cleaned up a little bit of the code duplication. I'll have to take a closer look some other time, but I'm pretty sure that the duplicated code at the bottom can be removed with a few tweaks, but I'll do that carefully in a different commit.
2023-03-02 08:10:17 +01:00
static void draw_tile_toolbox(int tileset)
{
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
extern editorclass ed;
Clean code for direct mode drawer The drawer could definitely be improved further, however I cleaned up a little bit of the code duplication. I'll have to take a closer look some other time, but I'm pretty sure that the duplicated code at the bottom can be removed with a few tweaks, but I'll do that carefully in a different commit.
2023-03-02 08:10:17 +01:00
// Tile toolbox for direct mode
int t2 = 0;
if (ed.dmtileeditor > 0)
{
if (ed.dmtileeditor <= 4)
{
t2 = graphics.lerp((4 - ed.dmtileeditor + 1) * 12, (4 - ed.dmtileeditor) * 12);
}
// Draw five lines of the editor
const int temp = ed.dmtile - (ed.dmtile % 40) - 80;
graphics.fill_rect(0, -t2, 320, 40, graphics.getRGB(0, 0, 0));
graphics.fill_rect(0, -t2 + 40, 320, 2, graphics.getRGB(255, 255, 255));
int texturewidth;
int textureheight;
if (graphics.query_texture(graphics.grphx.im_tiles, NULL, NULL, &texturewidth, &textureheight) != 0)
{
return;
}
const int numtiles = (int)(texturewidth / 8) * (textureheight / 8);
for (int x = 0; x < 40; x++)
{
for (int y = 0; y < 5; y++)
{
if (tileset == 0)
{
graphics.drawtile(x * 8, (y * 8) - t2, (temp + numtiles + (y * 40) + x) % numtiles);
}
else
{
graphics.drawtile2(x * 8, (y * 8) - t2, (temp + numtiles + (y * 40) + x) % numtiles);
}
}
}
// Highlight our little block
graphics.draw_rect(((ed.dmtile % 40) * 8) - 2, 16 - t2 - 2, 12, 12, graphics.getRGB(255 - help.glow, 196, 196));
graphics.draw_rect(((ed.dmtile % 40) * 8) - 1, 16 - t2 - 1, 10, 10, graphics.getRGB(0, 0, 0));
}
if (ed.dmtileeditor > 0 && t2 <= 30)
{
short labellen = 2 + font::len(0, loc::gettext("Tile:"));
font::print(PR_BOR, 2, 45 - t2, loc::gettext("Tile:"), 196, 196, 255 - help.glow);
font::print(PR_BOR, labellen + 16, 45 - t2, help.String(ed.dmtile), 196, 196, 255 - help.glow);
graphics.fill_rect(labellen + 2, 44 - t2, 10, 10, graphics.getRGB(255 - help.glow, 196, 196));
graphics.fill_rect(labellen + 3, 45 - t2, 8, 8, graphics.getRGB(0, 0, 0));
if (tileset == 0)
{
graphics.drawtile(labellen + 3, 45 - t2, ed.dmtile);
}
else
{
graphics.drawtile2(labellen + 3, 45 - t2, ed.dmtile);
}
}
else
{
short labellen = 2 + font::len(0, loc::gettext("Tile:"));
int y = 2 + font::height(0);
y = SDL_max(y, 12);
font::print(PR_BOR, 2, y, loc::gettext("Tile:"), 196, 196, 255 - help.glow);
font::print(PR_BOR, labellen + 16, y, help.String(ed.dmtile), 196, 196, 255 - help.glow);
graphics.fill_rect(labellen + 2, y - 1, 10, 10, graphics.getRGB(255 - help.glow, 196, 196));
graphics.fill_rect(labellen + 3, y, 8, 8, graphics.getRGB(0, 0, 0));
if (tileset == 0)
{
graphics.drawtile(labellen + 3, 12, ed.dmtile);
}
else
{
graphics.drawtile2(labellen + 3, 12, ed.dmtile);
}
}
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
void editorrender(void)
{
extern editorclass ed;
const RoomProperty* const room = cl.getroomprop(ed.levx, ed.levy);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.clear();
switch (ed.state)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
case EditorState_DRAW:
// Draw the editor guidelines
draw_background_grid();
// Draw the background, if any, over the guidelines
if (!ed.settingsmod)
Fix #199 This makes the modifiers for removing tiles only work if you're using tools 0 or 1 (wall or background). In the future it might be worth it to add some extra subtools for spikes, but for now this should be fine. Also, there was a small inconsistency with the tool drawn and the tool used. If you started holding down V, then started holding down Z, you would place tiles like you're holding V (9x9) but your cursor would look like you're holding Z (3x3). The `if` chain for drawing the resized cursors has been flipped around for this.
2020-08-01 21:23:56 +02:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
draw_background(room->warpdir);
Add 7x7, 9x9, full horizontal and vertical brush sizes
2020-06-17 23:49:57 +02:00
}
Fix #199 This makes the modifiers for removing tiles only work if you're using tools 0 or 1 (wall or background). In the future it might be worth it to add some extra subtools for spikes, but for now this should be fine. Also, there was a small inconsistency with the tool drawn and the tool used. If you started holding down V, then started holding down Z, you would place tiles like you're holding V (9x9) but your cursor would look like you're holding Z (3x3). The `if` chain for drawing the resized cursors has been flipped around for this.
2020-08-01 21:23:56 +02:00
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.drawmap();
draw_edgeguides();
draw_entities();
draw_ghosts();
draw_bounds();
Clean code for direct mode drawer The drawer could definitely be improved further, however I cleaned up a little bit of the code duplication. I'll have to take a closer look some other time, but I'm pretty sure that the duplicated code at the bottom can be removed with a few tweaks, but I'll do that carefully in a different commit.
2023-03-02 08:10:17 +01:00
if (room->directmode == 1)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Clean code for direct mode drawer The drawer could definitely be improved further, however I cleaned up a little bit of the code duplication. I'll have to take a closer look some other time, but I'm pretty sure that the duplicated code at the bottom can be removed with a few tweaks, but I'll do that carefully in a different commit.
2023-03-02 08:10:17 +01:00
draw_tile_toolbox(room->tileset);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Clean code for direct mode drawer The drawer could definitely be improved further, however I cleaned up a little bit of the code duplication. I'll have to take a closer look some other time, but I'm pretty sure that the duplicated code at the bottom can be removed with a few tweaks, but I'll do that carefully in a different commit.
2023-03-02 08:10:17 +01:00
draw_cursor();
break;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Clean code for direct mode drawer The drawer could definitely be improved further, however I cleaned up a little bit of the code duplication. I'll have to take a closer look some other time, but I'm pretty sure that the duplicated code at the bottom can be removed with a few tweaks, but I'll do that carefully in a different commit.
2023-03-02 08:10:17 +01:00
// Draw GUI
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
if(ed.boundarymod>0)
{
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
std::string message;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
if(ed.boundarymod==1)
{
switch(ed.boundarytype)
{
case 0:
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
message = loc::gettext("SCRIPT BOX: Click on top left");
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
break;
case 1:
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
message = loc::gettext("ENEMY BOUNDS: Click on top left");
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
break;
case 2:
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
message = loc::gettext("PLATFORM BOUNDS: Click on top left");
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
break;
default:
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
message = loc::gettext("Click on top left");
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
break;
}
}
else if(ed.boundarymod==2)
{
switch(ed.boundarytype)
{
case 0:
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
message = loc::gettext("SCRIPT BOX: Click on bottom right");
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
break;
case 1:
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
message = loc::gettext("ENEMY BOUNDS: Click on bottom right");
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
break;
case 2:
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
message = loc::gettext("PLATFORM BOUNDS: Click on bottom right");
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
break;
default:
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
message = loc::gettext("Click on bottom right");
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
break;
}
}
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
short lines;
Make wordwrapping functions take font arguments They need to know how wide the text is going to be in a particular font, so font::string_wordwrap and font::string_wordwrap_balanced now take a flags argument like all the printing and dimensions-getting functions. next_wrap and next_wrap_s take a Font* now, they're internal to Font.cpp so they can take a Font and avoid double flag-parsing. But if any non-Font.cpp code needs next_wrap/next_wrap_s in the future, I'd just make a public wrapper that takes a uint32_t flags and passes the Font* to the internal functions.
2023-01-21 02:31:44 +01:00
message = font::string_wordwrap(0, message, 312, &lines);
Completely remove Graphics::Print, make many CJK positioning fixes Only Graphics::PrintWrap is left of the old print functions!
2023-01-20 20:24:41 +01:00
short textheight = font::height(0)*lines;
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
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.fill_rect(0,238-textheight,320,240, graphics.getRGB(32,32,32));
graphics.fill_rect(0,239-textheight,320,240, graphics.getRGB(0,0,0));
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
Change font::print_wrap text argument from std::string to const char* We no longer need to pass a std::string object to the print and len functions - in fact, we often only have a C string that we want to print or get the visual width of (that C string most often comes from loc::gettext), and it's a bit wasteful to wrap it in a new std::string object on every print/len call. This does mean adding a few more .c_str()s, but there's not many places where a std::string is being passed to these functions, and we already use .c_str() sometimes. -> Commit 1/3: font::print_wrap Commit 2/3: font::print Commit 3/3: font::len
2023-03-04 23:29:12 +01:00
font::print_wrap(0, 4, 240-textheight, message.c_str(), 255,255,255, 8, 312);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else if(ed.scripteditmod)
{
//Elaborate C64 BASIC menu goes here!
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.fill_rect(0,0,320,240, graphics.getRGB(123, 111, 218));
graphics.fill_rect(14,16,292,208, graphics.getRGB(61, 48, 162));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
switch(ed.scripthelppage)
{
case 0:
Completely remove Graphics::Print, make many CJK positioning fixes Only Graphics::PrintWrap is left of the old print functions!
2023-01-20 20:24:41 +01:00
font::print(PR_CEN, -1,28,loc::gettext("**** VVVVVV SCRIPT EDITOR ****"), 123, 111, 218);
font::print(PR_CEN, -1,44,loc::gettext("PRESS ESC TO RETURN TO MENU"), 123, 111, 218);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Make `commands`, `sb`, and `hooklist` not use separate length-trackers This is a refactor that turns the script-related arrays `ed.sb`, and `ed.hooklist` into C++ vectors (`script.commands` was already a vector, it was just misused). The code handling these vectors now looks more like idiomatic C++ than sloppily-pasted pseudo-ActionScript. This removes the variables `script.scriptlength`, `ed.sblength`, and `ed.numhooks`, too. This reduces the amount of code needed to e.g. simply remove something from any of these vectors. Previously the code had to manually shift the rest of the elements down one-by-one, and doing it manually is definitely error-prone and tedious. But now we can just use fancy functions like `std::vector::erase()` and `std::remove()` to do it all in one line! Don't worry, I checked and `std::remove()` is in the C++ standard since at least 1998. This patch makes it so the `commands` vector gets cleared when `scriptclass::load()` is ran. Previously, the `commands` vector never actually properly got cleared, so there could potentially be glitches that rely on the game indexing past the bounds set by `scriptlength` but still in-bounds in the eyes of C++, and people could potentially rely on such an exploit... However, I checked, and I'm pretty sure that no such glitch previously existed at all, because the only times the vector gets indexed are when `scriptlength` is either being incremented after starting from 0 (`add()`) or when it's underneath a `position < scriptlength` conditional. Furthermore, I'm unaware of anyone who has actually found or used such an exploit, and I've been in the custom level community for 6 years. So I think it's fine.
2020-02-20 18:43:52 +01:00
if(!ed.hooklist.empty())
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
for(int i=0; i<9; i++)
{
Make `commands`, `sb`, and `hooklist` not use separate length-trackers This is a refactor that turns the script-related arrays `ed.sb`, and `ed.hooklist` into C++ vectors (`script.commands` was already a vector, it was just misused). The code handling these vectors now looks more like idiomatic C++ than sloppily-pasted pseudo-ActionScript. This removes the variables `script.scriptlength`, `ed.sblength`, and `ed.numhooks`, too. This reduces the amount of code needed to e.g. simply remove something from any of these vectors. Previously the code had to manually shift the rest of the elements down one-by-one, and doing it manually is definitely error-prone and tedious. But now we can just use fancy functions like `std::vector::erase()` and `std::remove()` to do it all in one line! Don't worry, I checked and `std::remove()` is in the C++ standard since at least 1998. This patch makes it so the `commands` vector gets cleared when `scriptclass::load()` is ran. Previously, the `commands` vector never actually properly got cleared, so there could potentially be glitches that rely on the game indexing past the bounds set by `scriptlength` but still in-bounds in the eyes of C++, and people could potentially rely on such an exploit... However, I checked, and I'm pretty sure that no such glitch previously existed at all, because the only times the vector gets indexed are when `scriptlength` is either being incremented after starting from 0 (`add()`) or when it's underneath a `position < scriptlength` conditional. Furthermore, I'm unaware of anyone who has actually found or used such an exploit, and I've been in the custom level community for 6 years. So I think it's fine.
2020-02-20 18:43:52 +01:00
if(ed.hookmenupage+i<(int)ed.hooklist.size())
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
if(ed.hookmenupage+i==ed.hookmenu)
{
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
std::string text_upper(loc::toupper(ed.hooklist[(ed.hooklist.size()-1)-(ed.hookmenupage+i)]));
char buffer[SCREEN_WIDTH_CHARS + 1];
vformat_buf(buffer, sizeof(buffer), loc::get_langmeta()->menu_select.c_str(), "label:str", text_upper.c_str());
Completely remove Graphics::Print, make many CJK positioning fixes Only Graphics::PrintWrap is left of the old print functions!
2023-01-20 20:24:41 +01:00
font::print(PR_CEN, -1, 68+(i*16), buffer, 123, 111, 218);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else
{
Completely remove Graphics::Print, make many CJK positioning fixes Only Graphics::PrintWrap is left of the old print functions!
2023-01-20 20:24:41 +01:00
font::print(PR_CEN, -1, 68+(i*16), ed.hooklist[(ed.hooklist.size()-1)-(ed.hookmenupage+i)], 123, 111, 218);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
}
}
else
{
Completely remove Graphics::Print, make many CJK positioning fixes Only Graphics::PrintWrap is left of the old print functions!
2023-01-20 20:24:41 +01:00
font::print(PR_CEN, -1,110,loc::gettext("NO SCRIPT IDS FOUND"), 123, 111, 218);
Completely remove Graphics::PrintWrap All print calls are font:: ones now and all the old Graphics:: print functions have been removed, the migration is complete!
2023-01-20 21:11:18 +01:00
font::print_wrap(PR_CEN, -1,130,loc::gettext("CREATE A SCRIPT WITH EITHER THE TERMINAL OR SCRIPT BOX TOOLS"), 123, 111, 218, 10, 288);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
break;
case 1:
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
{
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
//Current scriptname
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.fill_rect(14,226,292,12, graphics.getRGB(61, 48, 162));
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
char namebuffer[SCREEN_WIDTH_CHARS + 1];
vformat_buf(
namebuffer, sizeof(namebuffer),
loc::gettext("CURRENT SCRIPT: {name}"),
"name:str",
ed.sbscript.c_str()
);
Completely remove Graphics::Print, make many CJK positioning fixes Only Graphics::PrintWrap is left of the old print functions!
2023-01-20 20:24:41 +01:00
font::print(PR_CEN, -1,228, namebuffer, 123, 111, 218);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
//Draw text
Start using level-specific font where needed, make CJK tweaks Level text such as room names, text box content, and the contents of the script editor need to be displayed in the level-specific font, and tweaked to look right. This involves displaying less lines in the script editor, making text boxes bigger, displaying some text higher and some text lower. This is still unfinished, but it's the real start of a migration to font::print functions!
2023-01-12 05:27:52 +01:00
int font_height = font::height(PR_FONT_LEVEL);
for(int i=0; i<ed.lines_visible; i++)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Make `commands`, `sb`, and `hooklist` not use separate length-trackers This is a refactor that turns the script-related arrays `ed.sb`, and `ed.hooklist` into C++ vectors (`script.commands` was already a vector, it was just misused). The code handling these vectors now looks more like idiomatic C++ than sloppily-pasted pseudo-ActionScript. This removes the variables `script.scriptlength`, `ed.sblength`, and `ed.numhooks`, too. This reduces the amount of code needed to e.g. simply remove something from any of these vectors. Previously the code had to manually shift the rest of the elements down one-by-one, and doing it manually is definitely error-prone and tedious. But now we can just use fancy functions like `std::vector::erase()` and `std::remove()` to do it all in one line! Don't worry, I checked and `std::remove()` is in the C++ standard since at least 1998. This patch makes it so the `commands` vector gets cleared when `scriptclass::load()` is ran. Previously, the `commands` vector never actually properly got cleared, so there could potentially be glitches that rely on the game indexing past the bounds set by `scriptlength` but still in-bounds in the eyes of C++, and people could potentially rely on such an exploit... However, I checked, and I'm pretty sure that no such glitch previously existed at all, because the only times the vector gets indexed are when `scriptlength` is either being incremented after starting from 0 (`add()`) or when it's underneath a `position < scriptlength` conditional. Furthermore, I'm unaware of anyone who has actually found or used such an exploit, and I've been in the custom level community for 6 years. So I think it's fine.
2020-02-20 18:43:52 +01:00
if(i+ed.pagey<(int)ed.sb.size())
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
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
font::print(PR_FONT_LEVEL | PR_CJK_LOW, 16, 20+(i*font_height), ed.sb[i+ed.pagey], 123, 111, 218);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
//Draw cursor
if(ed.entframe<2)
{
Change font::len text argument from std::string to const char* See the previous two commits, a lot of the time we don't need std::string objects to be passed to these functions because we already have C strings. Commit 1/3: font::print_wrap Commit 2/3: font::print -> Commit 3/3: font::len
2023-03-05 00:32:58 +01:00
font::print(PR_FONT_LEVEL | PR_CJK_LOW, 16+font::len(PR_FONT_LEVEL, ed.sb[ed.pagey+ed.sby].c_str()),20+(ed.sby*font_height),"_",123, 111, 218);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
break;
}
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else if(ed.settingsmod)
{
Fix editor menu being drawn on top of editor with BGs disabled Previously, if you had backgrounds disabled in accessibility options, and went to the editor and opened up the editor menu, it would be drawn straight on top of what was already there in the editor instead of being drawn on top of black. So now it's drawn on top of black.
2020-04-29 20:15:23 +02:00
if(!game.colourblindmode)
{
Move title usages of towerbg to titlebg With the previous commit in place, we can now simply move some usages of the previous towerbg to use a separate object instead. That way, we don't have to mess with a monolithic state, or some better way to phrase what I just said, and we instead have two separate objects that can coexist side-by-side.
2020-11-03 00:23:53 +01:00
graphics.drawtowerbackground(graphics.titlebg);
Fix editor menu being drawn on top of editor with BGs disabled Previously, if you had backgrounds disabled in accessibility options, and went to the editor and opened up the editor menu, it would be drawn straight on top of what was already there in the editor instead of being drawn on top of black. So now it's drawn on top of black.
2020-04-29 20:15:23 +02:00
}
else
{
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.clear();
Fix editor menu being drawn on top of editor with BGs disabled Previously, if you had backgrounds disabled in accessibility options, and went to the editor and opened up the editor menu, it would be drawn straight on top of what was already there in the editor instead of being drawn on top of black. So now it's drawn on top of black.
2020-04-29 20:15:23 +02:00
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Move mapclass r/g/b variables off onto TowerBG This fixes a bug where if you entered a tower before watching the credits sequence, the credits sequence would have mismatched text and background colors. This bug happened because entering a tower modified the r/g/b attributes of mapclass, and updated graphics.towerbg, without updating graphics.titlebg too. Then gamecompleterender() uses the r/g/b attributes of mapclass. The solution is to put the r/g/b attributes on TowerBG instead. That way, entering a tower will only modify the r/g/b attributes used to render towers, and won't affect the r/g/b attributes used to render the credits sequence. Additionally, I also de-duplicated the case-switch that updated the r/g/b attributes based off of the current colstate, because it got copy-pasted twice, leading to three instances of one piece of code.
2021-01-08 02:37:38 +01:00
int tr = graphics.titlebg.r - (help.glow / 4) - int(fRandom() * 4);
int tg = graphics.titlebg.g - (help.glow / 4) - int(fRandom() * 4);
int tb = graphics.titlebg.b - (help.glow / 4) - int(fRandom() * 4);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
if (tr < 0) tr = 0;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if (tr > 255) tr = 255;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
if (tg < 0) tg = 0;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if (tg > 255) tg = 255;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
if (tb < 0) tb = 0;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if (tb > 255) tb = 255;
Move editor menu option rendering to separate function Just like before, it makes editorrender() easier to read and reduces the indentation level of the option rendering by one level.
2020-04-16 05:55:34 +02:00
editormenurender(tr, tg, tb);
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
graphics.drawmenu(tr, tg, tb, game.currentmenuname);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
else if (ed.textmod)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
short lines;
Make wordwrapping functions take font arguments They need to know how wide the text is going to be in a particular font, so font::string_wordwrap and font::string_wordwrap_balanced now take a flags argument like all the printing and dimensions-getting functions. next_wrap and next_wrap_s take a Font* now, they're internal to Font.cpp so they can take a Font and avoid double flag-parsing. But if any non-Font.cpp code needs next_wrap/next_wrap_s in the future, I'd just make a public wrapper that takes a uint32_t flags and passes the Font* to the internal functions.
2023-01-21 02:31:44 +01:00
std::string wrapped = font::string_wordwrap(0, ed.textdesc, 312, &lines);
Completely remove Graphics::Print, make many CJK positioning fixes Only Graphics::PrintWrap is left of the old print functions!
2023-01-20 20:24:41 +01:00
short textheight = font::height(0)*lines+font::height(PR_FONT_LEVEL);
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
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.fill_rect(0, 238-textheight, 320, 240, graphics.getRGB(32, 32, 32));
graphics.fill_rect(0, 239-textheight, 320, 240, graphics.getRGB(0, 0, 0));
Change font::print_wrap text argument from std::string to const char* We no longer need to pass a std::string object to the print and len functions - in fact, we often only have a C string that we want to print or get the visual width of (that C string most often comes from loc::gettext), and it's a bit wasteful to wrap it in a new std::string object on every print/len call. This does mean adding a few more .c_str()s, but there's not many places where a std::string is being passed to these functions, and we already use .c_str() sometimes. -> Commit 1/3: font::print_wrap Commit 2/3: font::print Commit 3/3: font::len
2023-03-04 23:29:12 +01:00
font::print_wrap(0, 4, 240-textheight, wrapped.c_str(), 255, 255, 255, 8, 312);
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
std::string input = key.keybuffer;
if (ed.entframe < 2)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
input += "_";
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else
{
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
input += " ";
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Completely remove Graphics::Print, make many CJK positioning fixes Only Graphics::PrintWrap is left of the old print functions!
2023-01-20 20:24:41 +01:00
font::print(PR_CEN | PR_FONT_LEVEL | PR_CJK_HIGH, -1, 232, input, 196, 196, 255 - help.glow);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else if(ed.warpmod)
{
//placing warp token
Completely remove Graphics::Print, make many CJK positioning fixes Only Graphics::PrintWrap is left of the old print functions!
2023-01-20 20:24:41 +01:00
int textheight = font::height(0);
graphics.fill_rect(0,237-textheight*2,320,240, graphics.getRGB(32,32,32));
graphics.fill_rect(0,238-textheight*2,320,240, graphics.getRGB(0,0,0));
font::print(PR_CJK_LOW, 4, 240-textheight*2, loc::gettext("Left click to place warp destination"), 196, 196, 255 - help.glow);
font::print(PR_CJK_LOW, 4, 240-textheight, loc::gettext("Right click to cancel"), 196, 196, 255 - help.glow);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else
{
Position CJK room name correctly in editor
2023-01-29 05:03:51 +01:00
char coords[8];
SDL_snprintf(coords, sizeof(coords), "(%d,%d)", ed.levx+1, ed.levy+1);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
if(ed.spacemod)
{
Completely remove Graphics::Print, make many CJK positioning fixes Only Graphics::PrintWrap is left of the old print functions!
2023-01-20 20:24:41 +01:00
graphics.fill_rect(0,207,320,240, graphics.getRGB(32,32,32));
graphics.fill_rect(0,208,320,240, graphics.getRGB(0,0,0));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// Draw tool icons!
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
int tx = 6;
const int ty = 210;
const int tg = 32;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
const int page = ed.current_tool / 10;
const int max_pages = SDL_ceil(NUM_EditorTools / 10);
const int page_tool_count = SDL_min(10, NUM_EditorTools - (page * 10));
for (int i = 0; i < page_tool_count; i++)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
const int current_tool_id = i + (page * 10);
Fix editor tool menu inconsistencies This patch de-duplicates the tool drawing code a bit in the menu that gets brought up when you press Space in the level editor, as well as fixes several bugs related to the fact that the original author(s) of the code decided to copy-paste everything. (It was most likely Terry, judging by the distinct lack of whitespace between tokens in the code.) There are two "pages" of tools that get shown when you open the tool menu, according to your currently-selected tool. 1. On the first page, your currently-selected tool gets a brighter outline. However, on the second page, the code to draw the outline over your currently-selected tool is missing. So I've fixed that. 2. On the first page, the glyph indicator next to the tool icon also gets brighter when you have that tool selected. However, on the second page, the code that drew the brighter-colored indicator got ran before the code that drew the normal-colored indicator, so this was never shown. This is also fixed. 3. The glyph indicator of the gravity line tool didn't get brighter when you had it selected, due to its special-cased copy-pasted code drawing its brighter color before drawing its normal color. This has also been fixed. 4. Lastly, the tool menu no longer draws the brighter-colored glyphs on top of the normal-colored glyphs. Instead, the menu will simply draw the brighter-colored glyphs and will not draw the normal-colored glyphs in the first place. This is because double-drawing text like this will look bad if the user has a custom font.png that has translucent pixels, like I do. All of these bugs have been fixed by paying off the technical debt of copy-pasting code.
2021-01-11 06:10:03 +01:00
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// First, draw the background
graphics.fill_rect(4 + (i * tg), 208, 20, 20, graphics.getRGB(32, 32, 32));
Remove global args from editorclass This removes global arg passing from all functions on editorclass. Callers have been updated correspondingly. Additionally, all 'dwgfx' has been replaced with 'graphics' in editor.cpp.
2020-03-31 21:52:10 +02:00
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// Draw the actual tool icon
ed.draw_tool((EditorTools) current_tool_id, 4 + (i * tg) + 2, 208 + 2);
// Draw the tool outline...
graphics.draw_rect(4 + (i * tg), 208, 20, 20, (current_tool_id == ed.current_tool) ? graphics.getRGB(200, 200, 200) : graphics.getRGB(96, 96, 96));
// ...and the hotkey
const int col = current_tool_id == ed.current_tool ? 255 : 164;
font::print(PR_FONT_8X8 | PR_BOR, 22 + i * tg - 4, 224 - 4, ed.toolkeychar[current_tool_id], col, col, col);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// Draw the page number, limit is 1 digit, so the max is 9 pages
char buffer[4];
SDL_snprintf(buffer, sizeof(buffer), "%d/%d", page + 1, max_pages + 1);
font::print(PR_CJK_HIGH, 4, 232, buffer, 196, 196, 255 - help.glow);
// Draw the button hint text
Add cases for intermission replay options, button fillers in editor The strings "Vitellary"/"Vermilion"/"Verdigris"/"Victoria" now have two cases to support changing them for the intermission replay menu options (like "with Vitellary"). Also, the string "< and > keys change tool" is now "{button1} and {button2} keys change tool", so it can be changed dynamically without having to retranslate the string.
2022-12-07 21:03:01 +01:00
char changetooltext[SCREEN_WIDTH_CHARS + 1];
vformat_buf(changetooltext, sizeof(changetooltext),
loc::gettext("{button1} and {button2} keys change tool"),
"button1:str, button2:str",
",", "."
);
Start using level-specific font where needed, make CJK tweaks Level text such as room names, text box content, and the contents of the script editor need to be displayed in the level-specific font, and tweaked to look right. This involves displaying less lines in the script editor, making text boxes bigger, displaying some text higher and some text lower. This is still unfinished, but it's the real start of a migration to font::print functions!
2023-01-12 05:27:52 +01:00
font::print(PR_CJK_HIGH | PR_RIGHT, 320, 232, changetooltext, 196, 196, 255 - help.glow);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// Draw the current tool name
char toolname[SCREEN_WIDTH_CHARS + 1];
SDL_snprintf(toolname, sizeof(toolname), "%s: %s", ed.toolkeychar[ed.current_tool], loc::gettext(ed.toolnames[ed.current_tool]));
Migrate more prints and graphics.len calls to font:: I especially focused on graphics.len and the print calls around them, because graphics.len calls appear a bit less often, might be overlooked when migrating print calls (thus possibly using different fonts by accident) and are often used for some kind of right-alignment or centering which can be changed into PR_RIGHT or PR_CEN with a different X anyway. Notably, I also added a new function to generate these kinds of sliders: ....[]............ Different languages means that the slider for analogue stick sensitivity needs to be longer to fit possibly long words for Low/Medium/High, and then different font sizes means that the longer slider won't fit onscreen in a language that needs a 12-wide font. So slider_get() can take a "target width", which dynamically changes the number of characters depending on the width of them in the interface font. I kinda forgot that I could force the 8x8 font instead of adapting the characters in the slider to the font, and other ideas (like using different characters or a more graphical progress bar) have been brought up on Discord, so this might all change again sooner or later.
2023-01-16 21:29:50 +01:00
int bgheight = 2 + font::height(0);
int toolnamelen = font::len(0, toolname);
Completely remove Graphics::Print, make many CJK positioning fixes Only Graphics::PrintWrap is left of the old print functions!
2023-01-20 20:24:41 +01:00
graphics.fill_rect(0,206-bgheight,toolnamelen+8,bgheight+1, graphics.getRGB(32,32,32));
graphics.fill_rect(0,207-bgheight,toolnamelen+7,bgheight, graphics.getRGB(0,0,0));
font::print(PR_BOR | PR_CJK_HIGH, 2,198, toolname, 196, 196, 255 - help.glow);
Migrate more prints and graphics.len calls to font:: I especially focused on graphics.len and the print calls around them, because graphics.len calls appear a bit less often, might be overlooked when migrating print calls (thus possibly using different fonts by accident) and are often used for some kind of right-alignment or centering which can be changed into PR_RIGHT or PR_CEN with a different X anyway. Notably, I also added a new function to generate these kinds of sliders: ....[]............ Different languages means that the slider for analogue stick sensitivity needs to be longer to fit possibly long words for Low/Medium/High, and then different font sizes means that the longer slider won't fit onscreen in a language that needs a 12-wide font. So slider_get() can take a "target width", which dynamically changes the number of characters depending on the width of them in the interface font. I kinda forgot that I could force the 8x8 font instead of adapting the characters in the slider to the font, and other ideas (like using different characters or a more graphical progress bar) have been brought up on Discord, so this might all change again sooner or later.
2023-01-16 21:29:50 +01:00
int coordslen = font::len(0, coords);
Completely remove Graphics::Print, make many CJK positioning fixes Only Graphics::PrintWrap is left of the old print functions!
2023-01-20 20:24:41 +01:00
graphics.fill_rect(319-coordslen-8,206-bgheight,coordslen+8,bgheight+1, graphics.getRGB(32,32,32));
graphics.fill_rect(320-coordslen-8,207-bgheight,coordslen+8,bgheight, graphics.getRGB(0,0,0));
font::print(PR_BOR | PR_CJK_HIGH | PR_RIGHT, 316, 198, coords, 196, 196, 255 - help.glow);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else
{
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.fill_rect(0,230,72,240, graphics.RGB(32,32,32));
//graphics.fill_rect(0,231,71,240, graphics.RGB(0,0,0));
Refactor room properties to use setter and getter funcs This replaces all raw ed.level accesses with new setter and getter funcs, which makes it easier to add bounds checks later. And I've also removed all the manually-written bounds checks, since they will go into the new getter and setter. To get the room properties of a specific room, you use editorclass::getroomprop(), which returns a pointer to the room properties - then you just read off of that pointer. To set a room property, you use editorclass::setroom<PROP>(), where <PROP> is the name of the property. These are maintained using X macros to avoid copy-pasting. editorclass::getroompropidx() is a helper function and shouldn't be used directly.
2021-03-24 19:59:36 +01:00
if(room->roomname!="")
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Position CJK room name correctly in editor
2023-01-29 05:03:51 +01:00
int font_height = font::height(PR_FONT_LEVEL);
if (font_height <= 8)
{
graphics.footerrect.h = font_height + 2;
}
else
{
graphics.footerrect.h = font_height + 1;
}
graphics.footerrect.y = 240 - graphics.footerrect.h + ed.roomnamehide;
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.set_blendmode(SDL_BLENDMODE_BLEND);
graphics.fill_rect(&graphics.footerrect, graphics.getRGBA(0, 0, 0, graphics.translucentroomname ? 127 : 255));
graphics.set_blendmode(SDL_BLENDMODE_NONE);
Position CJK room name correctly in editor
2023-01-29 05:03:51 +01:00
font::print(PR_CEN | PR_BOR | PR_FONT_LEVEL | PR_CJK_LOW, -1, graphics.footerrect.y+1+ed.roomnamehide, room->roomname, 196, 196, 255 - help.glow);
font::print(PR_BOR | PR_CJK_HIGH, 4, 232-graphics.footerrect.h, loc::gettext("SPACE ^ SHIFT ^"), 196, 196, 255 - help.glow);
font::print(PR_BOR | PR_CJK_HIGH | PR_RIGHT, 316, 232-graphics.footerrect.h, coords, 196, 196, 255 - help.glow);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else
{
Start using level-specific font where needed, make CJK tweaks Level text such as room names, text box content, and the contents of the script editor need to be displayed in the level-specific font, and tweaked to look right. This involves displaying less lines in the script editor, making text boxes bigger, displaying some text higher and some text lower. This is still unfinished, but it's the real start of a migration to font::print functions!
2023-01-12 05:27:52 +01:00
font::print(PR_BOR | PR_CJK_HIGH, 4, 232, loc::gettext("SPACE ^ SHIFT ^"), 196, 196, 255 - help.glow);
Position CJK room name correctly in editor
2023-01-29 05:03:51 +01:00
font::print(PR_BOR | PR_CJK_HIGH | PR_RIGHT, 316, 232, coords, 196, 196, 255 - help.glow);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
if(ed.shiftmenu)
{
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
const char* shiftmenuoptions[] = {
loc::gettext("F1: Change Tileset"),
loc::gettext("F2: Change Colour"),
loc::gettext("F3: Change Enemies"),
loc::gettext("F4: Enemy Bounds"),
loc::gettext("F5: Platform Bounds"),
"",
loc::gettext("F9: Reload Resources"),
loc::gettext("F10: Direct Mode"),
"",
loc::gettext("W: Change Warp Dir"),
loc::gettext("E: Change Roomname"),
};
int menuwidth = 0;
for (size_t i = 0; i < SDL_arraysize(shiftmenuoptions); i++)
{
Migrate more prints and graphics.len calls to font:: I especially focused on graphics.len and the print calls around them, because graphics.len calls appear a bit less often, might be overlooked when migrating print calls (thus possibly using different fonts by accident) and are often used for some kind of right-alignment or centering which can be changed into PR_RIGHT or PR_CEN with a different X anyway. Notably, I also added a new function to generate these kinds of sliders: ....[]............ Different languages means that the slider for analogue stick sensitivity needs to be longer to fit possibly long words for Low/Medium/High, and then different font sizes means that the longer slider won't fit onscreen in a language that needs a 12-wide font. So slider_get() can take a "target width", which dynamically changes the number of characters depending on the width of them in the interface font. I kinda forgot that I could force the 8x8 font instead of adapting the characters in the slider to the font, and other ideas (like using different characters or a more graphical progress bar) have been brought up on Discord, so this might all change again sooner or later.
2023-01-16 21:29:50 +01:00
int len = font::len(0, shiftmenuoptions[i]);
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
if (len > menuwidth)
menuwidth = len;
}
Remove global args from editorclass This removes global arg passing from all functions on editorclass. Callers have been updated correspondingly. Additionally, all 'dwgfx' has been replaced with 'graphics' in editor.cpp.
2020-03-31 21:52:10 +02:00
Migrate more prints and graphics.len calls to font:: I especially focused on graphics.len and the print calls around them, because graphics.len calls appear a bit less often, might be overlooked when migrating print calls (thus possibly using different fonts by accident) and are often used for some kind of right-alignment or centering which can be changed into PR_RIGHT or PR_CEN with a different X anyway. Notably, I also added a new function to generate these kinds of sliders: ....[]............ Different languages means that the slider for analogue stick sensitivity needs to be longer to fit possibly long words for Low/Medium/High, and then different font sizes means that the longer slider won't fit onscreen in a language that needs a 12-wide font. So slider_get() can take a "target width", which dynamically changes the number of characters depending on the width of them in the interface font. I kinda forgot that I could force the 8x8 font instead of adapting the characters in the slider to the font, and other ideas (like using different characters or a more graphical progress bar) have been brought up on Discord, so this might all change again sooner or later.
2023-01-16 21:29:50 +01:00
int lineheight = font::height(0);
lineheight = SDL_max(10, lineheight);
int left_y = 230-SDL_arraysize(shiftmenuoptions)*lineheight;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.draw_rect(0, left_y-3, menuwidth+17, 240,graphics.getRGB(64,64,64));
Migrate more prints and graphics.len calls to font:: I especially focused on graphics.len and the print calls around them, because graphics.len calls appear a bit less often, might be overlooked when migrating print calls (thus possibly using different fonts by accident) and are often used for some kind of right-alignment or centering which can be changed into PR_RIGHT or PR_CEN with a different X anyway. Notably, I also added a new function to generate these kinds of sliders: ....[]............ Different languages means that the slider for analogue stick sensitivity needs to be longer to fit possibly long words for Low/Medium/High, and then different font sizes means that the longer slider won't fit onscreen in a language that needs a 12-wide font. So slider_get() can take a "target width", which dynamically changes the number of characters depending on the width of them in the interface font. I kinda forgot that I could force the 8x8 font instead of adapting the characters in the slider to the font, and other ideas (like using different characters or a more graphical progress bar) have been brought up on Discord, so this might all change again sooner or later.
2023-01-16 21:29:50 +01:00
graphics.fill_rect(0,left_y-2,menuwidth+16,240, graphics.getRGB(0,0,0));
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
for (size_t i = 0; i < SDL_arraysize(shiftmenuoptions); i++)
Completely remove Graphics::Print, make many CJK positioning fixes Only Graphics::PrintWrap is left of the old print functions!
2023-01-20 20:24:41 +01:00
font::print(0, 4, left_y+i*lineheight, shiftmenuoptions[i], 164,164,164);
Remove global args from editorclass This removes global arg passing from all functions on editorclass. Callers have been updated correspondingly. Additionally, all 'dwgfx' has been replaced with 'graphics' in editor.cpp.
2020-03-31 21:52:10 +02:00
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.draw_rect(220, 207,100,60,graphics.getRGB(64,64,64));
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.fill_rect(221,208,160,60, graphics.getRGB(0,0,0));
Completely remove Graphics::Print, make many CJK positioning fixes Only Graphics::PrintWrap is left of the old print functions!
2023-01-20 20:24:41 +01:00
font::print(0, 224, 210, loc::gettext("S: Save Map"),164,164,164);
font::print(0, 224, 210+lineheight, loc::gettext("L: Load Map"),164,164,164);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
if(!ed.settingsmod && !ed.scripteditmod)
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// Draw the current tool name
char toolname[SCREEN_WIDTH_CHARS + 1];
SDL_snprintf(toolname, sizeof(toolname), "%s: %s", ed.toolkeychar[ed.current_tool], loc::gettext(ed.toolnames[ed.current_tool]));
font::print(PR_BOR, 2, 2, toolname, 196, 196, 255 - help.glow);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Smoothly interpolate editor notedelay This makes editor notes fade out smoothly. And even though the notedelay only gets decremented by one every editor-frame (the editor runs at 1000/24 FPS fixed-timestep here), it actually gets multiplied by 4, so a floating-point interpolated value would make a difference here.
2020-05-02 19:42:39 +02:00
if(ed.notedelay>0 || ed.oldnotedelay>0)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
short lines;
Make wordwrapping functions take font arguments They need to know how wide the text is going to be in a particular font, so font::string_wordwrap and font::string_wordwrap_balanced now take a flags argument like all the printing and dimensions-getting functions. next_wrap and next_wrap_s take a Font* now, they're internal to Font.cpp so they can take a Font and avoid double flag-parsing. But if any non-Font.cpp code needs next_wrap/next_wrap_s in the future, I'd just make a public wrapper that takes a uint32_t flags and passes the Font* to the internal functions.
2023-01-21 02:31:44 +01:00
std::string wrapped = font::string_wordwrap(0, ed.note, 304, &lines);
Completely remove Graphics::Print, make many CJK positioning fixes Only Graphics::PrintWrap is left of the old print functions!
2023-01-20 20:24:41 +01:00
short textheight = 8+(lines-1)*SDL_max(10, font::height(0));
Editor.cpp: make editorrender translatable This mainly adds loc::gettext calls. 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 23:20:50 +01:00
short banner_y = 120 - textheight/2 - 5;
Smoothly interpolate editor notedelay This makes editor notes fade out smoothly. And even though the notedelay only gets decremented by one every editor-frame (the editor runs at 1000/24 FPS fixed-timestep here), it actually gets multiplied by 4, so a floating-point interpolated value would make a difference here.
2020-05-02 19:42:39 +02:00
float alpha = graphics.lerp(ed.oldnotedelay, ed.notedelay);
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.fill_rect(0, banner_y, 320, 10+textheight, graphics.getRGB(92,92,92));
graphics.fill_rect(0, banner_y+1, 320, 8+textheight, graphics.getRGB(0,0,0));
Change font::print_wrap text argument from std::string to const char* We no longer need to pass a std::string object to the print and len functions - in fact, we often only have a C string that we want to print or get the visual width of (that C string most often comes from loc::gettext), and it's a bit wasteful to wrap it in a new std::string object on every print/len call. This does mean adding a few more .c_str()s, but there's not many places where a std::string is being passed to these functions, and we already use .c_str() sometimes. -> Commit 1/3: font::print_wrap Commit 2/3: font::print Commit 3/3: font::len
2023-03-04 23:29:12 +01:00
font::print_wrap(PR_CEN, -1,banner_y+5, wrapped.c_str(), 196-((45.0f-alpha)*4), 196-((45.0f-alpha)*4), 196-((45.0f-alpha)*4));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Remove global args from editorclass This removes global arg passing from all functions on editorclass. Callers have been updated correspondingly. Additionally, all 'dwgfx' has been replaced with 'graphics' in editor.cpp.
2020-03-31 21:52:10 +02:00
graphics.drawfade();
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Only render screen effects on the title screen and in-game In-game because that's where screen effects are used the most. But on the title screen, screen effects are used when you press ACTION to start the game, and when you enable screen effects, too. Otherwise, we don't need screen effects for any other game-gamestate.
2020-04-27 04:29:40 +02:00
graphics.render();
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 editorrenderfixed(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
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
extern editorclass ed;
Rename edlevelclass to RoomProperty That's what edlevelclass is... so that's what it should be named. (Also removes that "ed", too, making this less coupled to the in-game editor.) Unfortunately, for compatibility reasons, the name of the XML element will still remain the same.
2021-02-21 00:45:48 +01:00
const RoomProperty* const room = cl.getroomprop(ed.levx, ed.levy);
Make sure sprite colors in the editor don't update more than 30 FPS This adds Graphics::crewcolourreal(), which is like the entityclass::crewcolour() that the editor already uses, except for the real color instead of the color ID. Also, editorclass now has an attribute `entcolreal` so enemy colors don't update more than 30 frames a second.
2020-05-02 22:53:19 +02:00
graphics.updatetitlecolours();
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
game.customcol=cl.getlevelcol(room->tileset, room->tilecol)+1;
ed.entcol=cl.getenemycol(game.customcol);
Make sure sprite colors in the editor don't update more than 30 FPS This adds Graphics::crewcolourreal(), which is like the entityclass::crewcolour() that the editor already uses, except for the real color instead of the color ID. Also, editorclass now has an attribute `entcolreal` so enemy colors don't update more than 30 frames a second.
2020-05-02 22:53:19 +02:00
Axe Graphics::ct and Graphics::setcolreal `ct` was used to be a variable that a color was temporarily stored in before being passed to a draw function. But this is unnecessary and you might as well just have a temporary of the color directly. I guess this was the practice used because temporaries were apparently really bad in Flash. setcolreal() was added in 2.3 to do basically the same thing (set it directly from entities' realcol attributes). But it's no longer needed. Correspondingly, Graphics::setcol has been renamed to Graphics::getcol and now returns an SDL_Color, and Graphics::huetilesetcol has been renamed to Graphics::huetilegetcol for the same reason. Some functions (notably Graphics::drawimagecol and Graphics::drawhuetile) were relying on the `ct` to be implicitly set and weren't ever having it passed in directly. They have been corrected accordingly.
2023-01-02 05:16:08 +01:00
ed.entcolreal = graphics.getcol(ed.entcol);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Fix ed.currentghosts updating way too fast Just like all the other fixes, the variable that controls the amount of ghosts to show was being updated every render frame instead of every logic frame.
2020-06-13 02:24:08 +02:00
if (game.ghostsenabled)
{
Fix editor ghost colors updating too fast Like actual entities, editor ghost colors were updating every render frame instead of logic frame. So just like actual entities, I added a realcol attribute to them that editorrender() uses instead, and added code to update said realcol attribute in editorlogic(). That way the colors don't go by too quickly (especially the death color).
2020-06-13 02:34:19 +02:00
for (size_t i = 0; i < ed.ghosts.size(); i++)
{
GhostInfo& ghost = ed.ghosts[i];
if ((int) i > ed.currentghosts || ghost.rx != ed.levx || ghost.ry != ed.levy)
{
continue;
}
Axe Graphics::ct and Graphics::setcolreal `ct` was used to be a variable that a color was temporarily stored in before being passed to a draw function. But this is unnecessary and you might as well just have a temporary of the color directly. I guess this was the practice used because temporaries were apparently really bad in Flash. setcolreal() was added in 2.3 to do basically the same thing (set it directly from entities' realcol attributes). But it's no longer needed. Correspondingly, Graphics::setcol has been renamed to Graphics::getcol and now returns an SDL_Color, and Graphics::huetilesetcol has been renamed to Graphics::huetilegetcol for the same reason. Some functions (notably Graphics::drawimagecol and Graphics::drawhuetile) were relying on the `ct` to be implicitly set and weren't ever having it passed in directly. They have been corrected accordingly.
2023-01-02 05:16:08 +01:00
ghost.realcol = graphics.getcol(ghost.col);
Fix editor ghost colors updating too fast Like actual entities, editor ghost colors were updating every render frame instead of logic frame. So just like actual entities, I added a realcol attribute to them that editorrender() uses instead, and added code to update said realcol attribute in editorlogic(). That way the colors don't go by too quickly (especially the death color).
2020-06-13 02:34:19 +02:00
}
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
ed.currentghosts++;
if (ed.zmod)
{
Fix ed.currentghosts updating way too fast Just like all the other fixes, the variable that controls the amount of ghosts to show was being updated every render frame instead of every logic frame.
2020-06-13 02:24:08 +02:00
ed.currentghosts++;
}
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
ed.currentghosts = SDL_min(ed.currentghosts, ed.ghosts.size());
Fix ed.currentghosts updating way too fast Just like all the other fixes, the variable that controls the amount of ghosts to show was being updated every render frame instead of every logic frame.
2020-06-13 02:24:08 +02:00
}
Move horizontal warp background to Graphics::updatebackground() This is so the background doesn't NYOOOOM past at light speed. Although for a game set in space like VVVVVV, light speed ain't bad. And this finally requires that editorlogic() have a call to Graphics::updatebackground().
2020-04-29 19:37:56 +02:00
if (!ed.settingsmod)
{
Refactor room properties to use setter and getter funcs This replaces all raw ed.level accesses with new setter and getter funcs, which makes it easier to add bounds checks later. And I've also removed all the manually-written bounds checks, since they will go into the new getter and setter. To get the room properties of a specific room, you use editorclass::getroomprop(), which returns a pointer to the room properties - then you just read off of that pointer. To set a room property, you use editorclass::setroom<PROP>(), where <PROP> is the name of the property. These are maintained using X macros to avoid copy-pasting. editorclass::getroompropidx() is a helper function and shouldn't be used directly.
2021-03-24 19:59:36 +01:00
switch(room->warpdir)
Move horizontal warp background to Graphics::updatebackground() This is so the background doesn't NYOOOOM past at light speed. Although for a game set in space like VVVVVV, light speed ain't bad. And this finally requires that editorlogic() have a call to Graphics::updatebackground().
2020-04-29 19:37:56 +02:00
{
case 1:
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
graphics.rcol=cl.getwarpbackground(ed.levx, ed.levy);
Move horizontal warp background to Graphics::updatebackground() This is so the background doesn't NYOOOOM past at light speed. Although for a game set in space like VVVVVV, light speed ain't bad. And this finally requires that editorlogic() have a call to Graphics::updatebackground().
2020-04-29 19:37:56 +02:00
graphics.updatebackground(3);
break;
Move vertical warp background updating to Graphics::updatebackground() Otherwise it will zoom by pretty quickly.
2020-04-29 20:06:03 +02:00
case 2:
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
graphics.rcol=cl.getwarpbackground(ed.levx, ed.levy);
Move vertical warp background updating to Graphics::updatebackground() Otherwise it will zoom by pretty quickly.
2020-04-29 20:06:03 +02:00
graphics.updatebackground(4);
break;
Move all-sides warp background update code to logic functions Otherwise it'll go by really fast and rapidly pulsate. To the point where it seems like it would be an epilepsy trigger, although I wouldn't know anything about epilepsy other than that it's bad.
2020-04-30 00:37:39 +02:00
case 3:
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
graphics.rcol=cl.getwarpbackground(ed.levx, ed.levy);
Move all-sides warp background update code to logic functions Otherwise it'll go by really fast and rapidly pulsate. To the point where it seems like it would be an epilepsy trigger, although I wouldn't know anything about epilepsy other than that it's bad.
2020-04-30 00:37:39 +02:00
graphics.updatebackground(5);
break;
Move horizontal warp background to Graphics::updatebackground() This is so the background doesn't NYOOOOM past at light speed. Although for a game set in space like VVVVVV, light speed ain't bad. And this finally requires that editorlogic() have a call to Graphics::updatebackground().
2020-04-29 19:37:56 +02:00
default:
break;
}
}
Move tower background update code to logic functions Otherwise it'll go really really quickly, which is not good.
2020-04-30 00:25:01 +02:00
else if (!game.colourblindmode)
{
Move title usages of towerbg to titlebg With the previous commit in place, we can now simply move some usages of the previous towerbg to use a separate object instead. That way, we don't have to mess with a monolithic state, or some better way to phrase what I just said, and we instead have two separate objects that can coexist side-by-side.
2020-11-03 00:23:53 +01:00
graphics.updatetowerbackground(graphics.titlebg);
Move tower background update code to logic functions Otherwise it'll go really really quickly, which is not good.
2020-04-30 00:25:01 +02:00
}
Move gravity line correction to editorrenderfixed Gravity line correction no longer happens on every deltaframe. This means less CPU time is wasted. Although, there's probably no need to correct gravity lines on every single frame... hm... well, that's an optimization for later (there's plenty of other stuff to cache, like minimap drawing or editor foreground drawing).
2021-03-10 00:36:05 +01:00
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
if (cl.getroomprop(ed.levx, ed.levy)->directmode == 1)
Move Direct Mode drawer close to editorrenderfixed Now the drawer closing animation won't be based on deltatime.
2021-03-10 00:41:19 +01:00
{
if (ed.dmtileeditor > 0)
{
ed.dmtileeditor--;
}
}
Reset drawer timer if not in Direct Mode room This fixes the drawer suddenly popping up only to disappear, if the user leaves a Direct Mode room into a non-Direct Mode room when the drawer hasn't closed all the way, and then re-enters a Direct Mode room.
2021-03-10 06:04:04 +01:00
else
{
ed.dmtileeditor = 0;
}
Move room name hiding update to editorrenderfixed Now the room name hiding animation won't be based on FPS.
2021-03-10 00:42:06 +01:00
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
if (cl.getroomprop(ed.levx, ed.levy)->roomname != "")
Move room name hiding update to editorrenderfixed Now the room name hiding animation won't be based on FPS.
2021-03-10 00:42:06 +01:00
{
if (ed.tiley < 28)
{
if (ed.roomnamehide > 0)
{
ed.roomnamehide--;
}
}
else
{
Position CJK room name correctly in editor
2023-01-29 05:03:51 +01:00
if (ed.roomnamehide < 14)
Move room name hiding update to editorrenderfixed Now the room name hiding animation won't be based on FPS.
2021-03-10 00:42:06 +01:00
{
ed.roomnamehide++;
}
}
}
Reset room name hide timer if in an unnamed room This avoids the room name awkwardly moving back up if the cursor is at the bottom of the screen in a room with a room name, then the user switches to a room without a room name, then moves the cursor away from the bottom, then switches to a named room - even though the cursor was already away from the bottom of the screen. Conversely, if the user moves their cursor to the bottom of the screen in an unnamed room, then switches into a named room, the room name will already have been hidden and they won't need to wait for it to hide.
2021-03-10 06:05:36 +01:00
else
{
if (ed.tiley < 28)
{
ed.roomnamehide = 0;
}
else
{
Position CJK room name correctly in editor
2023-01-29 05:03:51 +01:00
ed.roomnamehide = 14;
Reset room name hide timer if in an unnamed room This avoids the room name awkwardly moving back up if the cursor is at the bottom of the screen in a room with a room name, then the user switches to a room without a room name, then moves the cursor away from the bottom, then switches to a named room - even though the cursor was already away from the bottom of the screen. Conversely, if the user moves their cursor to the bottom of the screen in an unnamed room, then switches into a named room, the room name will already have been hidden and they won't need to wait for it to hide.
2021-03-10 06:05:36 +01:00
}
}
Move all fixed-timestep render updates to new file RenderFixed.cpp As part of fixing #464, I'll need to move these pieces of code around easily. In #220 I just kind of shoved them awkwardly in whatever fixed function would be last called in the gamestate loop, which I shouldn't have done as I've now had to make formal fixed-render functions anyway. Because these fixed functions need to be called directly before a render function, and I'm fixing the order to put render functions in their proper place, so I need to be able to move these around easily, and making them function calls instead of inlined makes them easier to manipulate.
2020-11-08 00:47:49 +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 editorlogic(void)
Move all fixed-timestep render updates to new file RenderFixed.cpp As part of fixing #464, I'll need to move these pieces of code around easily. In #220 I just kind of shoved them awkwardly in whatever fixed function would be last called in the gamestate loop, which I shouldn't have done as I've now had to make formal fixed-render functions anyway. Because these fixed functions need to be called directly before a render function, and I'm fixing the order to put render functions in their proper place, so I need to be able to move these around easily, and making them function calls instead of inlined makes them easier to manipulate.
2020-11-08 00:47:49 +01:00
{
extern editorclass ed;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
Move all fixed-timestep render updates to new file RenderFixed.cpp As part of fixing #464, I'll need to move these pieces of code around easily. In #220 I just kind of shoved them awkwardly in whatever fixed function would be last called in the gamestate loop, which I shouldn't have done as I've now had to make formal fixed-render functions anyway. Because these fixed functions need to be called directly before a render function, and I'm fixing the order to put render functions in their proper place, so I need to be able to move these around easily, and making them function calls instead of inlined makes them easier to manipulate.
2020-11-08 00:47:49 +01:00
//Misc
help.updateglow();
graphics.titlebg.bypos -= 2;
graphics.titlebg.bscroll = -2;
ed.entframedelay--;
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
if (ed.entframedelay <= 0)
Move all fixed-timestep render updates to new file RenderFixed.cpp As part of fixing #464, I'll need to move these pieces of code around easily. In #220 I just kind of shoved them awkwardly in whatever fixed function would be last called in the gamestate loop, which I shouldn't have done as I've now had to make formal fixed-render functions anyway. Because these fixed functions need to be called directly before a render function, and I'm fixing the order to put render functions in their proper place, so I need to be able to move these around easily, and making them function calls instead of inlined makes them easier to manipulate.
2020-11-08 00:47:49 +01:00
{
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
ed.entframe = (ed.entframe + 1) % 4;
ed.entframedelay = 8;
Move all fixed-timestep render updates to new file RenderFixed.cpp As part of fixing #464, I'll need to move these pieces of code around easily. In #220 I just kind of shoved them awkwardly in whatever fixed function would be last called in the gamestate loop, which I shouldn't have done as I've now had to make formal fixed-render functions anyway. Because these fixed functions need to be called directly before a render function, and I'm fixing the order to put render functions in their proper place, so I need to be able to move these around easily, and making them function calls instead of inlined makes them easier to manipulate.
2020-11-08 00:47:49 +01:00
}
ed.oldnotedelay = ed.notedelay;
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
ed.notedelay = SDL_max(ed.notedelay - 1, 0);
update_entities();
Move horizontal warp background to Graphics::updatebackground() This is so the background doesn't NYOOOOM past at light speed. Although for a game set in space like VVVVVV, light speed ain't bad. And this finally requires that editorlogic() have a call to Graphics::updatebackground().
2020-04-29 19:37:56 +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
if (graphics.fademode == FADE_FULLY_BLACK)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
//Return to game
Move title usages of towerbg to titlebg With the previous commit in place, we can now simply move some usages of the previous towerbg to use a separate object instead. That way, we don't have to mess with a monolithic state, or some better way to phrase what I just said, and we instead have two separate objects that can coexist side-by-side.
2020-11-03 00:23:53 +01:00
graphics.titlebg.colstate = 10;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
map.nexttowercolour();
Clean up all exit paths to the menu to use common code There are multiple different exit paths to the main menu. In 2.2, they all had a bunch of copy-pasted code. In 2.3 currently, most of them use game.quittomenu(), but there are some stragglers that still use hand-copied code. This is a bit of a problem, because all exit paths should consistently have FILESYSTEM_unmountassets(), as part of the 2.3 feature of per-level custom assets. Furthermore, most (but not all) of the paths call script.hardreset() too, and some of the stragglers don't. So there could be something persisting through to the title screen (like a really long flash/shake timer) that could only persist if exiting to the title screen through those paths. But, actually, it seems like there's a good reason for some of those to not call script.hardreset() - namely, dying or completing No Death Mode and completing a Time Trial presents some information onscreen that would get reset by script.hardreset(), so I'll fix that in a later commit. So what I've done for this commit is found every exit path that didn't already use game.quittomenu(), and made them use game.quittomenu(). As well, some of them had special handling that existed on top of them already having a corresponding entry in game.quittomenu() (but the path would take the special handling because it never did game.quittomenu()), so I removed that special handling as well (e.g. exiting from a custom level used returntomenu(Menu::levellist) when quittomenu() already had that same returntomenu()). The menu that exiting from the level editor returns to is now handled in game.quittomenu() as well, where the map.custommode branch now also checks for map.custommodeforreal. Unfortunately, it seems like entering the level editor doesn't properly initialize map.custommode, so entering the level editor now initializes map.custommode, too. I've also taken the music.play(6) out of game.quittomenu(), because not all exit paths immediately play Presenting VVVVVV, so all exit paths that DO immediately play Presenting VVVVVV now have music.play(6) special-cased for them, which is fine enough for me. Here is the list of all exit paths to the menu: - Exiting through the pause menu (without glitchrunner mode) - Exiting through the pause menu (with glitchrunner mode) - Completing a custom level - Completing a Time Trial - Dying in No Death Mode - Completing No Death Mode - Completing an Intermission replay - Exiting from the level editor - Completing the main game
2021-01-07 23:20:37 +01:00
game.quittomenu();
music.play(6); //should be before game.quittomenu()
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
ed.settingsmod=false;
}
}
Fix 1-frame glitch when going to in-game options from edsettings The menu creation of Graphic Options or Game Options, as well as the map.nexttowercolour() call, all need to be deferred until the end of the frame.
2021-03-19 05:14:40 +01:00
static void creategameoptions(void)
{
game.createmenu(Menu::options);
}
static void nextbgcolor(void)
{
map.nexttowercolour();
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Fix a few missing implicit void arg declarations While working on #535, I noticed that editormenuactionpress() still didn't do the explicit void declaration. Then I ran `rg 'void.*\(\)'` and found three other functions that I somehow missed in #628. Whoops. Well, now they no longer are missed.
2021-03-19 05:20:05 +01:00
static void editormenuactionpress(void)
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
{
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
extern editorclass ed;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
Turn game.currentmenuname "else-if"s into case-switches Much more stylistic, you don't need to repeat "game.currentmenuname" for each case, and you don't need to deal with the dangling first "if" that doesn't have an "else".
2020-04-17 00:19:17 +02:00
switch (game.currentmenuname)
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
{
Turn game.currentmenuname "else-if"s into case-switches Much more stylistic, you don't need to repeat "game.currentmenuname" for each case, and you don't need to deal with the dangling first "if" that doesn't have an "else".
2020-04-17 00:19:17 +02:00
case Menu::ed_desc:
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
switch (game.currentmenuoption)
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
{
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
case 0:
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
{
bool title_is_gettext;
translate_title(cl.title, &title_is_gettext);
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
ed.titlemod=true;
key.enabletextentry();
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
if (title_is_gettext)
{
key.keybuffer="";
}
else
{
key.keybuffer = cl.title;
}
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
break;
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
}
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
case 1:
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
{
bool creator_is_gettext;
translate_creator(cl.creator, &creator_is_gettext);
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
ed.creatormod=true;
key.enabletextentry();
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
if (creator_is_gettext)
{
key.keybuffer="";
}
else
{
key.keybuffer = cl.creator;
}
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
break;
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
}
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
case 2:
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
ed.desc1mod=true;
key.enabletextentry();
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
key.keybuffer=cl.Desc1;
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
break;
case 3:
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
ed.websitemod=true;
key.enabletextentry();
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
key.keybuffer=cl.website;
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
break;
case 4:
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
game.createmenu(Menu::ed_font);
map.nexttowercolour();
break;
case 5:
Fix editor menu options going back to editor not using returnmenu() Instead of directly using Game::createmenu(Menu::ed_settings), we should be using Game::returnmenu() here, so the stack frames don't keep piling up.
2020-04-26 04:25:30 +02:00
game.returnmenu();
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
map.nexttowercolour();
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
break;
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
}
Play Viridian squeak when editing level desc fields For consistency, the Viridian squeak will now play whenever you start editing a level description field, or finish editing it (either by pressing Esc or Enter).
2021-06-11 21:52:28 +02:00
music.playef(11);
Turn game.currentmenuname "else-if"s into case-switches Much more stylistic, you don't need to repeat "game.currentmenuname" for each case, and you don't need to deal with the dangling first "if" that doesn't have an "else".
2020-04-17 00:19:17 +02:00
break;
case Menu::ed_settings:
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
switch (game.currentmenuoption)
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
{
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
case 0:
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
//Change level description stuff
music.playef(11);
Convert menu names to be an enum instead of being stringly-typed Stringly-typed things are bad, because if you make a typo when typing out a string, it's not caught at compile-time. And in the case of this menu system, you'd have to do an excessive amount of testing to uncover any bugs caused by a typo. Why do that when you can just use an enum and catch compile-time errors instead? Also, you can't use switch-case statements on stringly-typed variables. So every menu name is now in the enum Menu::MenuName, but you can simply refer to a menu name by just prefixing it with Menu::. Unfortunately, I've had to change the "continue" menu name to be "continuemenu", because "continue" is a keyword in C and C++. Also, it looks like "timetrialcomplete4" is an unused menu name, even though it was referenced in Render.cpp.
2020-04-16 06:53:36 +02:00
game.createmenu(Menu::ed_desc);
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
map.nexttowercolour();
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
break;
case 1:
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
//Enter script editormode
music.playef(11);
ed.scripteditmod=true;
ed.clearscriptbuffer();
key.keybuffer="";
ed.hookmenupage=0;
ed.hookmenu=0;
ed.scripthelppage=0;
ed.scripthelppagedelay=0;
ed.sby=0;
ed.sbx=0, ed.pagey=0;
Start using level-specific font where needed, make CJK tweaks Level text such as room names, text box content, and the contents of the script editor need to be displayed in the level-specific font, and tweaked to look right. This involves displaying less lines in the script editor, making text boxes bigger, displaying some text higher and some text lower. This is still unfinished, but it's the real start of a migration to font::print functions!
2023-01-12 05:27:52 +01:00
ed.lines_visible = 200/font::height(PR_FONT_LEVEL);
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
break;
case 2:
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
music.playef(11);
Convert menu names to be an enum instead of being stringly-typed Stringly-typed things are bad, because if you make a typo when typing out a string, it's not caught at compile-time. And in the case of this menu system, you'd have to do an excessive amount of testing to uncover any bugs caused by a typo. Why do that when you can just use an enum and catch compile-time errors instead? Also, you can't use switch-case statements on stringly-typed variables. So every menu name is now in the enum Menu::MenuName, but you can simply refer to a menu name by just prefixing it with Menu::. Unfortunately, I've had to change the "continue" menu name to be "continuemenu", because "continue" is a keyword in C and C++. Also, it looks like "timetrialcomplete4" is an unused menu name, even though it was referenced in Render.cpp.
2020-04-16 06:53:36 +02:00
game.createmenu(Menu::ed_music);
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
map.nexttowercolour();
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
if(cl.levmusic>0) music.play(cl.levmusic);
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
break;
case 3:
Add a player trail to the editor (ghosts) A few months ago, I added ghosts to the VVVVVV: Community Edition editor. I was told recently I should think about upstreaming it, and with Terry saying go ahead I finally ported them into VVVVVV. There's one slight difference however--you can choose whether you have them or not in the editor's settings menu. They're off by default, and this is saved to the save file. Anyway, when you're playtesting, the game saves the players position, color, room coordinates and sprite every 3 frames. The max is 100, where if it tries to add more, the oldest one gets removed. When you exit playtesting, the saved positions appear one at a time, and you can use the Z key to speed it up. [Here's a video of them in action.](https://o.lol-sa.me/4H21zCv.mp4)
2020-06-13 00:04:35 +02:00
music.playef(11);
game.ghostsenabled = !game.ghostsenabled;
break;
case 4:
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
//Load level
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
ed.settingsmod = false;
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
map.nexttowercolour();
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
ed.keydelay = 6;
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
ed.getlin(TEXT_LOAD, loc::gettext("Enter map filename to load:"), &(ed.filename));
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
game.mapheld = true;
graphics.backgrounddrawn = false;
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
break;
Add a player trail to the editor (ghosts) A few months ago, I added ghosts to the VVVVVV: Community Edition editor. I was told recently I should think about upstreaming it, and with Terry saying go ahead I finally ported them into VVVVVV. There's one slight difference however--you can choose whether you have them or not in the editor's settings menu. They're off by default, and this is saved to the save file. Anyway, when you're playtesting, the game saves the players position, color, room coordinates and sprite every 3 frames. The max is 100, where if it tries to add more, the oldest one gets removed. When you exit playtesting, the saved positions appear one at a time, and you can use the Z key to speed it up. [Here's a video of them in action.](https://o.lol-sa.me/4H21zCv.mp4)
2020-06-13 00:04:35 +02:00
case 5:
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
//Save level
ed.settingsmod=false;
map.nexttowercolour();
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
ed.keydelay = 6;
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
ed.getlin(TEXT_SAVE, loc::gettext("Enter map filename to save as:"), &(ed.filename));
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
game.mapheld = true;
graphics.backgrounddrawn = false;
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
break;
Add a player trail to the editor (ghosts) A few months ago, I added ghosts to the VVVVVV: Community Edition editor. I was told recently I should think about upstreaming it, and with Terry saying go ahead I finally ported them into VVVVVV. There's one slight difference however--you can choose whether you have them or not in the editor's settings menu. They're off by default, and this is saved to the save file. Anyway, when you're playtesting, the game saves the players position, color, room coordinates and sprite every 3 frames. The max is 100, where if it tries to add more, the oldest one gets removed. When you exit playtesting, the saved positions appear one at a time, and you can use the Z key to speed it up. [Here's a video of them in action.](https://o.lol-sa.me/4H21zCv.mp4)
2020-06-13 00:04:35 +02:00
case 6:
Clean up of options menus for v2.3 (fixes #696)
2021-04-09 12:09:12 +02:00
/* Game options */
Add graphic options and game options to editor settings This is a small quality-of-life tweak that makes it so if you're in the middle of editing a level, you don't have to save the level, exit to the menu, change whatever setting you wanted, re-enter the editor, and type in the level name, just to change one setting. This is the same as adding Graphic Options and Game Options to the in-game pause menu, except for the editor, too. To do this, I'm reusing Game::returntopausemenu() (because all of its callers are the same callers for returning to editor settings) and renamed it to returntoingame(), then added a variable named ingame_editormode to Game. When we're in the options menus but still in the editor, BOTH ingame_titlemode and ingame_editormode will be true.
2021-03-19 03:52:30 +01:00
music.playef(11);
game.gamestate = TITLEMODE;
game.ingame_titlemode = true;
game.ingame_editormode = true;
Clean up of options menus for v2.3 (fixes #696)
2021-04-09 12:09:12 +02:00
DEFER_CALLBACK(creategameoptions);
Fix 1-frame glitch when going to in-game options from edsettings The menu creation of Graphic Options or Game Options, as well as the map.nexttowercolour() call, all need to be deferred until the end of the frame.
2021-03-19 05:14:40 +01:00
DEFER_CALLBACK(nextbgcolor);
Add graphic options and game options to editor settings This is a small quality-of-life tweak that makes it so if you're in the middle of editing a level, you don't have to save the level, exit to the menu, change whatever setting you wanted, re-enter the editor, and type in the level name, just to change one setting. This is the same as adding Graphic Options and Game Options to the in-game pause menu, except for the editor, too. To do this, I'm reusing Game::returntopausemenu() (because all of its callers are the same callers for returning to editor settings) and renamed it to returntoingame(), then added a variable named ingame_editormode to Game. When we're in the options menus but still in the editor, BOTH ingame_titlemode and ingame_editormode will be true.
2021-03-19 03:52:30 +01:00
break;
default:
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
music.playef(11);
Convert menu names to be an enum instead of being stringly-typed Stringly-typed things are bad, because if you make a typo when typing out a string, it's not caught at compile-time. And in the case of this menu system, you'd have to do an excessive amount of testing to uncover any bugs caused by a typo. Why do that when you can just use an enum and catch compile-time errors instead? Also, you can't use switch-case statements on stringly-typed variables. So every menu name is now in the enum Menu::MenuName, but you can simply refer to a menu name by just prefixing it with Menu::. Unfortunately, I've had to change the "continue" menu name to be "continuemenu", because "continue" is a keyword in C and C++. Also, it looks like "timetrialcomplete4" is an unused menu name, even though it was referenced in Render.cpp.
2020-04-16 06:53:36 +02:00
game.createmenu(Menu::ed_quit);
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
map.nexttowercolour();
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
break;
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
}
Turn game.currentmenuname "else-if"s into case-switches Much more stylistic, you don't need to repeat "game.currentmenuname" for each case, and you don't need to deal with the dangling first "if" that doesn't have an "else".
2020-04-17 00:19:17 +02:00
break;
case Menu::ed_music:
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
switch (game.currentmenuoption)
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
{
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
case 0:
Add previous song option to editor music screen This is just a small quality-of-life feature - it's annoying to have to press ACTION 15 times in order to cycle back through to the previous song.
2021-03-05 09:55:57 +01:00
case 1:
switch (game.currentmenuoption)
{
case 0:
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
cl.levmusic++;
Add previous song option to editor music screen This is just a small quality-of-life feature - it's annoying to have to press ACTION 15 times in order to cycle back through to the previous song.
2021-03-05 09:55:57 +01:00
break;
case 1:
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
cl.levmusic--;
Add previous song option to editor music screen This is just a small quality-of-life feature - it's annoying to have to press ACTION 15 times in order to cycle back through to the previous song.
2021-03-05 09:55:57 +01:00
break;
}
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
cl.levmusic = POS_MOD(cl.levmusic, 16);
if (cl.levmusic > 0)
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
{
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
music.play(cl.levmusic);
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
}
else
{
music.haltdasmusik();
}
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
music.playef(11);
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
break;
Add previous song option to editor music screen This is just a small quality-of-life feature - it's annoying to have to press ACTION 15 times in order to cycle back through to the previous song.
2021-03-05 09:55:57 +01:00
case 2:
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
music.playef(11);
music.fadeout();
Fix editor menu options going back to editor not using returnmenu() Instead of directly using Game::createmenu(Menu::ed_settings), we should be using Game::returnmenu() here, so the stack frames don't keep piling up.
2020-04-26 04:25:30 +02:00
game.returnmenu();
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
map.nexttowercolour();
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
break;
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
}
Turn game.currentmenuname "else-if"s into case-switches Much more stylistic, you don't need to repeat "game.currentmenuname" for each case, and you don't need to deal with the dangling first "if" that doesn't have an "else".
2020-04-17 00:19:17 +02:00
break;
case Menu::ed_quit:
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
switch (game.currentmenuoption)
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
{
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
case 0:
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
//Saving and quit
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
ed.saveandquit = true;
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
ed.settingsmod = false;
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
map.nexttowercolour();
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
ed.keydelay = 6;
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
ed.getlin(TEXT_SAVE, loc::gettext("Enter map filename to save as:"), &(ed.filename));
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
game.mapheld = true;
graphics.backgrounddrawn = false;
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
break;
case 1:
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
//Quit without saving
music.playef(11);
music.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;
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.backgrounddrawn = false;
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
break;
case 2:
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
//Go back to editor
music.playef(11);
Fix editor menu options going back to editor not using returnmenu() Instead of directly using Game::createmenu(Menu::ed_settings), we should be using Game::returnmenu() here, so the stack frames don't keep piling up.
2020-04-26 04:25:30 +02:00
game.returnmenu();
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
map.nexttowercolour();
Change "else if"-chain in editormenuactionpress to case-switch It makes it better so you don't have to deal with that dangling first "if" that doesn't have an 'else'.
2020-04-16 06:01:00 +02:00
break;
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
}
Turn game.currentmenuname "else-if"s into case-switches Much more stylistic, you don't need to repeat "game.currentmenuname" for each case, and you don't need to deal with the dangling first "if" that doesn't have an "else".
2020-04-17 00:19:17 +02:00
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 Menu::ed_font:
{
uint8_t idx_selected = font::font_idx_options[game.currentmenuoption];
cl.level_font_name = font::get_main_font_name(idx_selected);
if (idx_selected == loc::get_langmeta()->font_idx)
{
loc::new_level_font = "";
}
else
{
loc::new_level_font = cl.level_font_name;
}
font::set_level_font(cl.level_font_name.c_str());
music.playef(11);
game.returnmenu();
map.nexttowercolour();
game.savestatsandsettings_menu();
break;
}
Turn game.currentmenuname "else-if"s into case-switches Much more stylistic, you don't need to repeat "game.currentmenuname" for each case, and you don't need to deal with the dangling first "if" that doesn't have an "else".
2020-04-17 00:19:17 +02:00
default:
break;
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02: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 editorinput(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
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
extern editorclass ed;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01: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
if (graphics.fademode == FADE_FADING_OUT)
Don't take editor input when fading out This fixes being able to re-trigger the fadeout while a fadeout is already happening. It also fixes being able to enter playtesting during the fadeout, which means the level now has a fadeout you normally can't do in actual gameplay.
2021-08-05 22:12:15 +02:00
{
return;
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
ed.tilex = (key.mx - (key.mx % 8)) / 8;
ed.tiley = (key.my - (key.my % 8)) / 8;
Add and use scaling mode enum This enum is to just make each mode be readable, instead of mysterious 0/1/2 values. It's not a strictly-typed enum because we still have to serialize it as ints in the XML, but it's better than just leaving them as ints. This also adds a NUM_SCALING_MODES enum, so we don't have to hardcode that 3 when cycling scaling modes anymore.
2021-12-26 08:05:14 +01:00
if (gameScreen.scalingMode == SCALING_STRETCH) {
Fix scaling editor mouse coords properly in stretch mode Now your cursor will properly align with the editor's cursor if you're in stretch mode. Closes #27.
2020-01-12 10:09:32 +01:00
// In this mode specifically, we have to fix the mouse coordinates
Persist windowed mode size through fullscreen mode Previously, the game would not store the size of the window itself, and would always call SDL_GetRendererOutputSize() (via Screen::GetWindowSize()) to figure out the size of the window. The only problem is, this would return the size of the whole monitor if the game was in fullscreen mode. And the only place where the original windowed mode size was stored would be in SDL itself, but that wouldn't persist after the game was closed. So, if you exited the game while in fullscreen mode, then your window size would get set to the size of your monitor (1920 by 1080 in my case). Then when you opened the game and toggled fullscreen off, it would go back to the default window size, which is 640 by 480. This is made worse, however, if you were in forced fullscreen mode when you previously exited the game in windowed mode. In that case, the game saves the size of 1920 by 1080, but doesn't save that you were in fullscreen mode, so opening the game not in forced fullscreen mode would result in you having a 1920 by 1080 window, but in windowed mode. Meaning that not even fullscreening and unfullscreening would put the game window back to normal size. The solution, of course, is to just store the window size ourselves, like any other screen setting, and only use GetWindowSize() if needed. And just to make things clear, I've also renamed the GetWindowSize() function to GetScreenSize(), because if it was named "window" it could lead one to think that it would always return the size of the screen in windowed mode, when in fact it returns the size of the screen whatever mode it is in - fullscreen size if in fullscreen mode and window size if in windowed mode. And doing this also fixes the FIXME above Screen::isForcedFullscreen().
2023-03-21 04:59:37 +01:00
int screenwidth, screenheight;
gameScreen.GetScreenSize(&screenwidth, &screenheight);
ed.tilex = ed.tilex * 320 / screenwidth;
ed.tiley = ed.tiley * 240 / screenheight;
Fix scaling editor mouse coords properly in stretch mode Now your cursor will properly align with the editor's cursor if you're in stretch mode. Closes #27.
2020-01-12 10:09:32 +01:00
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Fix pressing Enter moving you leftwards in the editor Whoops.
2020-07-01 04:40:24 +02:00
bool up_pressed = key.isDown(SDLK_UP) || key.isDown(SDL_CONTROLLER_BUTTON_DPAD_UP);
bool down_pressed = key.isDown(SDLK_DOWN) || key.isDown(SDL_CONTROLLER_BUTTON_DPAD_DOWN);
bool left_pressed = key.isDown(SDLK_LEFT) || key.isDown(SDL_CONTROLLER_BUTTON_DPAD_LEFT);
bool right_pressed = key.isDown(SDLK_RIGHT) || key.isDown(SDL_CONTROLLER_BUTTON_DPAD_RIGHT);
Allow D-Pad to act as arrow keys in the editor This doesn't make the editor completely accessible on controller, but it's a good start at least. VCE already let you move between rooms with the D-Pad, though.
2020-07-01 02:39:32 +02:00
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
game.press_left = false;
game.press_right = false;
game.press_action = false;
game.press_map = false;
Separate pressing Enter to open map from pressing Enter to interact This is a lot of copy-pasted code, but a little bit of copy-pasting never hurt anyone... The keybind to interact with activity zones and teleporters is now separate from the keybind to open the map, or return to the editor from in-editor playtesting, or restart a time trial. The keybind is now E, and the default controller bind is X. No controller button prompts, but the game didn't have controller button prompts anyways, so whatever. Doing this now because if people's muscle memory are going to be broken by not being able to spam the map keybind anymore, at least we can help a bit by changing the keybind so they can keep spamming it - their muscle memory is going to be broken anyways. This option has to be enabled by going to the speedrunner menu options and selecting "interact button". It is disabled by default. All prompt text needs to be string-interpolated every time they are drawn, because it is possible for people to change which interact button they use in the middle of gameplay, via the in-game options. Closes #736.
2021-04-19 08:23:44 +02:00
game.press_interact = false;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Allow D-Pad to act as arrow keys in the editor This doesn't make the editor completely accessible on controller, but it's a good start at least. VCE already let you move between rooms with the D-Pad, though.
2020-07-01 02:39:32 +02:00
if (key.isDown(KEYBOARD_LEFT) || key.isDown(KEYBOARD_a) || key.controllerWantsLeft(false))
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
game.press_left = true;
}
Allow D-Pad to act as arrow keys in the editor This doesn't make the editor completely accessible on controller, but it's a good start at least. VCE already let you move between rooms with the D-Pad, though.
2020-07-01 02:39:32 +02:00
if (key.isDown(KEYBOARD_RIGHT) || key.isDown(KEYBOARD_d) || key.controllerWantsRight(false))
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
game.press_right = true;
}
Allow D-Pad to act as arrow keys in the editor This doesn't make the editor completely accessible on controller, but it's a good start at least. VCE already let you move between rooms with the D-Pad, though.
2020-07-01 02:39:32 +02:00
if (key.isDown(KEYBOARD_z) || key.isDown(KEYBOARD_SPACE) || key.isDown(KEYBOARD_v) || key.isDown(game.controllerButton_flip))
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
game.press_action = true;
};
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
if (key.keymap[SDLK_F9] && (ed.keydelay == 0)) {
Per-level custom asset loading functionality (#262)
2020-06-01 01:31:02 +02:00
ed.keydelay = 30;
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
ed.note = loc::gettext("Reloaded resources");
ed.notedelay = 45;
Per-level custom asset loading functionality (#262)
2020-06-01 01:31:02 +02:00
graphics.reloadresources();
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
if (key.isDown(KEYBOARD_ENTER)) game.press_map = true;
if (key.isDown(27) && !ed.settingskey)
{
ed.settingskey=true;
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
if (ed.textmod)
{
key.disabletextentry();
if (ed.textmod >= FIRST_ENTTEXT && ed.textmod <= LAST_ENTTEXT)
{
*ed.textptr = ed.oldenttext;
if (ed.oldenttext == "")
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
ed.removeedentity(ed.textent);
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
}
}
ed.textmod = TEXT_NONE;
ed.shiftmenu = false;
ed.shiftkey = false;
}
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
else if (key.textentry())
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
key.disabletextentry();
ed.titlemod=false;
ed.desc1mod=false;
ed.desc2mod=false;
ed.desc3mod=false;
ed.websitemod=false;
ed.creatormod=false;
Play Viridian squeak when editing level desc fields For consistency, the Viridian squeak will now play whenever you start editing a level description field, or finish editing it (either by pressing Esc or Enter).
2021-06-11 21:52:28 +02:00
music.playef(11);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
ed.shiftmenu=false;
ed.shiftkey=false;
}
else if(ed.boundarymod>0)
{
ed.boundarymod=0;
}
else
{
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
bool esc_from_font = false;
Add being able to press Esc to return to previous menu This is a small quality-of-life thing that makes it so you don't have to move your menu selection all the way over to the "return" button in order to return to the previous menu. You can just press Escape instead to return to the previous menu. The previous behavior of pressing Escape was to bring up the 'confirm quit' menu, or if you were in an options menu in-game, return to the pause menu. If you're on the main menu (and thus don't have any previous menu) and press Escape, the game will instead bring up the 'confirm quit' menu. For consistency, the "quit game" option on the main menu will also bring up the 'confirm quit' menu as well, instead of immediately closing the game. Pressing the controller button mapped to Escape will also work as well. The only menus that don't have return buttons are the 'countdown' menus - so the game will not let you press Escape if there's a menu countdown happening. Now that pressing Escape in the 'continue' menu will just bring you back to the 'play' menu, there's no need to specifically put map.nexttowercolour() first when canceling the 'confirm quit' menu.
2021-02-22 09:28:43 +01:00
music.playef(11);
if (ed.settingsmod)
{
if (ed.scripteditmod)
{
ed.scripteditmod = false;
}
else if (ed.settingsmod)
{
if (game.currentmenuname == Menu::ed_settings)
{
ed.settingsmod = false;
}
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
else if (game.currentmenuname == Menu::ed_font)
{
// Prevent double return
esc_from_font = true;
game.returnmenu();
map.nexttowercolour();
}
Add being able to press Esc to return to previous menu This is a small quality-of-life thing that makes it so you don't have to move your menu selection all the way over to the "return" button in order to return to the previous menu. You can just press Escape instead to return to the previous menu. The previous behavior of pressing Escape was to bring up the 'confirm quit' menu, or if you were in an options menu in-game, return to the pause menu. If you're on the main menu (and thus don't have any previous menu) and press Escape, the game will instead bring up the 'confirm quit' menu. For consistency, the "quit game" option on the main menu will also bring up the 'confirm quit' menu as well, instead of immediately closing the game. Pressing the controller button mapped to Escape will also work as well. The only menus that don't have return buttons are the 'countdown' menus - so the game will not let you press Escape if there's a menu countdown happening. Now that pressing Escape in the 'continue' menu will just bring you back to the 'play' menu, there's no need to specifically put map.nexttowercolour() first when canceling the 'confirm quit' menu.
2021-02-22 09:28:43 +01:00
else
{
game.returnmenu();
map.nexttowercolour();
}
}
}
else
{
ed.settingsmod = true;
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01: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
if (ed.settingsmod && !esc_from_font)
Improve ed_settings Esc press handling This fixes being able to rack up a large amount of stack frames by pressing Esc repeatedly in the editor, which would be a problem if you were to then return to the main menu afterwards. Instead, if Menu::ed_settings is already in the stack, the game will simply return to that menu instead of creating it. Else, it will just create the menu. Also, as extra attention to detail, I made sure that the menu create or return only happens if Esc opens the settings menu, and not when Esc is closes it.
2020-04-26 04:37:33 +02:00
{
Fix duplicating ed_settings when opening editor menu second time This fixes a bug where after loading in to the level editor, pressing Esc and then switching your option to something other than the first option, then pressing Esc again to close the menu, then pressing Esc once more would not keep your menu option. This is because the code that checks if Menu::ed_settings is already in the stack doesn't account for if ed_settings is the current menu - the current menu doesn't get put in to the stack. In hindsight, maybe I could have designed the new menu system better so the current menu IS on the stack, and/or should have used a statically-allocated linked list for each menu name for the stack frames (instead of an std::vector) and asserted if a menu that already existed in the stack was created instead... that'll have to be done later, though.
2021-04-18 18:55:11 +02:00
bool edsettings_in_stack = game.currentmenuname == Menu::ed_settings;
if (!edsettings_in_stack)
Improve ed_settings Esc press handling This fixes being able to rack up a large amount of stack frames by pressing Esc repeatedly in the editor, which would be a problem if you were to then return to the main menu afterwards. Instead, if Menu::ed_settings is already in the stack, the game will simply return to that menu instead of creating it. Else, it will just create the menu. Also, as extra attention to detail, I made sure that the menu create or return only happens if Esc opens the settings menu, and not when Esc is closes it.
2020-04-26 04:37:33 +02:00
{
Fix duplicating ed_settings when opening editor menu second time This fixes a bug where after loading in to the level editor, pressing Esc and then switching your option to something other than the first option, then pressing Esc again to close the menu, then pressing Esc once more would not keep your menu option. This is because the code that checks if Menu::ed_settings is already in the stack doesn't account for if ed_settings is the current menu - the current menu doesn't get put in to the stack. In hindsight, maybe I could have designed the new menu system better so the current menu IS on the stack, and/or should have used a statically-allocated linked list for each menu name for the stack frames (instead of an std::vector) and asserted if a menu that already existed in the stack was created instead... that'll have to be done later, though.
2021-04-18 18:55:11 +02:00
size_t i;
for (i = 0; i < game.menustack.size(); ++i)
Improve ed_settings Esc press handling This fixes being able to rack up a large amount of stack frames by pressing Esc repeatedly in the editor, which would be a problem if you were to then return to the main menu afterwards. Instead, if Menu::ed_settings is already in the stack, the game will simply return to that menu instead of creating it. Else, it will just create the menu. Also, as extra attention to detail, I made sure that the menu create or return only happens if Esc opens the settings menu, and not when Esc is closes it.
2020-04-26 04:37:33 +02:00
{
Fix duplicating ed_settings when opening editor menu second time This fixes a bug where after loading in to the level editor, pressing Esc and then switching your option to something other than the first option, then pressing Esc again to close the menu, then pressing Esc once more would not keep your menu option. This is because the code that checks if Menu::ed_settings is already in the stack doesn't account for if ed_settings is the current menu - the current menu doesn't get put in to the stack. In hindsight, maybe I could have designed the new menu system better so the current menu IS on the stack, and/or should have used a statically-allocated linked list for each menu name for the stack frames (instead of an std::vector) and asserted if a menu that already existed in the stack was created instead... that'll have to be done later, though.
2021-04-18 18:55:11 +02:00
if (game.menustack[i].name == Menu::ed_settings)
{
edsettings_in_stack = true;
break;
}
Improve ed_settings Esc press handling This fixes being able to rack up a large amount of stack frames by pressing Esc repeatedly in the editor, which would be a problem if you were to then return to the main menu afterwards. Instead, if Menu::ed_settings is already in the stack, the game will simply return to that menu instead of creating it. Else, it will just create the menu. Also, as extra attention to detail, I made sure that the menu create or return only happens if Esc opens the settings menu, and not when Esc is closes it.
2020-04-26 04:37:33 +02:00
}
}
if (edsettings_in_stack)
{
game.returntomenu(Menu::ed_settings);
}
else
{
game.createmenu(Menu::ed_settings);
}
map.nexttowercolour();
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
if (!key.isDown(27))
{
ed.settingskey=false;
}
if(ed.scripteditmod)
{
if(ed.scripthelppage==0)
{
//hook select menu
if(ed.keydelay>0) ed.keydelay--;
Allow D-Pad to act as arrow keys in the editor This doesn't make the editor completely accessible on controller, but it's a good start at least. VCE already let you move between rooms with the D-Pad, though.
2020-07-01 02:39:32 +02:00
if(up_pressed && ed.keydelay<=0)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
ed.keydelay=6;
ed.hookmenu--;
}
Allow D-Pad to act as arrow keys in the editor This doesn't make the editor completely accessible on controller, but it's a good start at least. VCE already let you move between rooms with the D-Pad, though.
2020-07-01 02:39:32 +02:00
if(down_pressed && ed.keydelay<=0)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
ed.keydelay=6;
ed.hookmenu++;
}
Make `commands`, `sb`, and `hooklist` not use separate length-trackers This is a refactor that turns the script-related arrays `ed.sb`, and `ed.hooklist` into C++ vectors (`script.commands` was already a vector, it was just misused). The code handling these vectors now looks more like idiomatic C++ than sloppily-pasted pseudo-ActionScript. This removes the variables `script.scriptlength`, `ed.sblength`, and `ed.numhooks`, too. This reduces the amount of code needed to e.g. simply remove something from any of these vectors. Previously the code had to manually shift the rest of the elements down one-by-one, and doing it manually is definitely error-prone and tedious. But now we can just use fancy functions like `std::vector::erase()` and `std::remove()` to do it all in one line! Don't worry, I checked and `std::remove()` is in the C++ standard since at least 1998. This patch makes it so the `commands` vector gets cleared when `scriptclass::load()` is ran. Previously, the `commands` vector never actually properly got cleared, so there could potentially be glitches that rely on the game indexing past the bounds set by `scriptlength` but still in-bounds in the eyes of C++, and people could potentially rely on such an exploit... However, I checked, and I'm pretty sure that no such glitch previously existed at all, because the only times the vector gets indexed are when `scriptlength` is either being incremented after starting from 0 (`add()`) or when it's underneath a `position < scriptlength` conditional. Furthermore, I'm unaware of anyone who has actually found or used such an exploit, and I've been in the custom level community for 6 years. So I think it's fine.
2020-02-20 18:43:52 +01:00
if(ed.hookmenu>=(int)ed.hooklist.size())
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Make `commands`, `sb`, and `hooklist` not use separate length-trackers This is a refactor that turns the script-related arrays `ed.sb`, and `ed.hooklist` into C++ vectors (`script.commands` was already a vector, it was just misused). The code handling these vectors now looks more like idiomatic C++ than sloppily-pasted pseudo-ActionScript. This removes the variables `script.scriptlength`, `ed.sblength`, and `ed.numhooks`, too. This reduces the amount of code needed to e.g. simply remove something from any of these vectors. Previously the code had to manually shift the rest of the elements down one-by-one, and doing it manually is definitely error-prone and tedious. But now we can just use fancy functions like `std::vector::erase()` and `std::remove()` to do it all in one line! Don't worry, I checked and `std::remove()` is in the C++ standard since at least 1998. This patch makes it so the `commands` vector gets cleared when `scriptclass::load()` is ran. Previously, the `commands` vector never actually properly got cleared, so there could potentially be glitches that rely on the game indexing past the bounds set by `scriptlength` but still in-bounds in the eyes of C++, and people could potentially rely on such an exploit... However, I checked, and I'm pretty sure that no such glitch previously existed at all, because the only times the vector gets indexed are when `scriptlength` is either being incremented after starting from 0 (`add()`) or when it's underneath a `position < scriptlength` conditional. Furthermore, I'm unaware of anyone who has actually found or used such an exploit, and I've been in the custom level community for 6 years. So I think it's fine.
2020-02-20 18:43:52 +01:00
ed.hookmenu=ed.hooklist.size()-1;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
if(ed.hookmenu<0) ed.hookmenu=0;
if(ed.hookmenu<ed.hookmenupage)
{
ed.hookmenupage=ed.hookmenu;
}
if(ed.hookmenu>=ed.hookmenupage+9)
{
ed.hookmenupage=ed.hookmenu+8;
}
if(!key.keymap[SDLK_BACKSPACE]) ed.deletekeyheld=0;
Fix undefined behavior when backspacing in script list with 0 scripts The problem is that it would index out-of-bounds if you did this, but this UB hasn't caused an exception until my change to refactor script-related vectors by removing their separate length-trackers.
2020-04-03 21:23:37 +02:00
if(key.keymap[SDLK_BACKSPACE] && ed.deletekeyheld==0 && !ed.hooklist.empty())
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
ed.deletekeyheld=1;
music.playef(2);
Make `commands`, `sb`, and `hooklist` not use separate length-trackers This is a refactor that turns the script-related arrays `ed.sb`, and `ed.hooklist` into C++ vectors (`script.commands` was already a vector, it was just misused). The code handling these vectors now looks more like idiomatic C++ than sloppily-pasted pseudo-ActionScript. This removes the variables `script.scriptlength`, `ed.sblength`, and `ed.numhooks`, too. This reduces the amount of code needed to e.g. simply remove something from any of these vectors. Previously the code had to manually shift the rest of the elements down one-by-one, and doing it manually is definitely error-prone and tedious. But now we can just use fancy functions like `std::vector::erase()` and `std::remove()` to do it all in one line! Don't worry, I checked and `std::remove()` is in the C++ standard since at least 1998. This patch makes it so the `commands` vector gets cleared when `scriptclass::load()` is ran. Previously, the `commands` vector never actually properly got cleared, so there could potentially be glitches that rely on the game indexing past the bounds set by `scriptlength` but still in-bounds in the eyes of C++, and people could potentially rely on such an exploit... However, I checked, and I'm pretty sure that no such glitch previously existed at all, because the only times the vector gets indexed are when `scriptlength` is either being incremented after starting from 0 (`add()`) or when it's underneath a `position < scriptlength` conditional. Furthermore, I'm unaware of anyone who has actually found or used such an exploit, and I've been in the custom level community for 6 years. So I think it's fine.
2020-02-20 18:43:52 +01:00
ed.removehook(ed.hooklist[(ed.hooklist.size()-1)-ed.hookmenu]);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
if (!game.press_action && !game.press_left && !game.press_right
Allow D-Pad to act as arrow keys in the editor This doesn't make the editor completely accessible on controller, but it's a good start at least. VCE already let you move between rooms with the D-Pad, though.
2020-07-01 02:39:32 +02:00
&& !up_pressed && !down_pressed && !key.isDown(27)) game.jumpheld = false;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
if (!game.jumpheld)
{
if (game.press_action || game.press_left || game.press_right || game.press_map
Allow D-Pad to act as arrow keys in the editor This doesn't make the editor completely accessible on controller, but it's a good start at least. VCE already let you move between rooms with the D-Pad, though.
2020-07-01 02:39:32 +02:00
|| up_pressed || down_pressed || key.isDown(27))
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
game.jumpheld = true;
}
Make `commands`, `sb`, and `hooklist` not use separate length-trackers This is a refactor that turns the script-related arrays `ed.sb`, and `ed.hooklist` into C++ vectors (`script.commands` was already a vector, it was just misused). The code handling these vectors now looks more like idiomatic C++ than sloppily-pasted pseudo-ActionScript. This removes the variables `script.scriptlength`, `ed.sblength`, and `ed.numhooks`, too. This reduces the amount of code needed to e.g. simply remove something from any of these vectors. Previously the code had to manually shift the rest of the elements down one-by-one, and doing it manually is definitely error-prone and tedious. But now we can just use fancy functions like `std::vector::erase()` and `std::remove()` to do it all in one line! Don't worry, I checked and `std::remove()` is in the C++ standard since at least 1998. This patch makes it so the `commands` vector gets cleared when `scriptclass::load()` is ran. Previously, the `commands` vector never actually properly got cleared, so there could potentially be glitches that rely on the game indexing past the bounds set by `scriptlength` but still in-bounds in the eyes of C++, and people could potentially rely on such an exploit... However, I checked, and I'm pretty sure that no such glitch previously existed at all, because the only times the vector gets indexed are when `scriptlength` is either being incremented after starting from 0 (`add()`) or when it's underneath a `position < scriptlength` conditional. Furthermore, I'm unaware of anyone who has actually found or used such an exploit, and I've been in the custom level community for 6 years. So I think it's fine.
2020-02-20 18:43:52 +01:00
if ((game.press_action || game.press_map) && !ed.hooklist.empty())
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
game.mapheld=true;
ed.scripthelppage=1;
Move text entry start to script open instead of script list open This fixes a bug where opening a script, then closing the script but not exiting the script list, then opening a script again (it can be the same script as before) would result in you being unable to type in the script. You would have to close the script, then close the script list, then re-open the script list in order to be able to type properly. This was caused by the fact that key.enabletextentry() was being called when the script list was opened, but key.disabletextentry() was being called when closing a script. So the fix for this is to simply move the key.enabletextentry() to its proper place, which is when the script is being opened, and not when the script list is.
2020-08-18 00:39:19 +02:00
key.enabletextentry();
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
key.keybuffer="";
Make `commands`, `sb`, and `hooklist` not use separate length-trackers This is a refactor that turns the script-related arrays `ed.sb`, and `ed.hooklist` into C++ vectors (`script.commands` was already a vector, it was just misused). The code handling these vectors now looks more like idiomatic C++ than sloppily-pasted pseudo-ActionScript. This removes the variables `script.scriptlength`, `ed.sblength`, and `ed.numhooks`, too. This reduces the amount of code needed to e.g. simply remove something from any of these vectors. Previously the code had to manually shift the rest of the elements down one-by-one, and doing it manually is definitely error-prone and tedious. But now we can just use fancy functions like `std::vector::erase()` and `std::remove()` to do it all in one line! Don't worry, I checked and `std::remove()` is in the C++ standard since at least 1998. This patch makes it so the `commands` vector gets cleared when `scriptclass::load()` is ran. Previously, the `commands` vector never actually properly got cleared, so there could potentially be glitches that rely on the game indexing past the bounds set by `scriptlength` but still in-bounds in the eyes of C++, and people could potentially rely on such an exploit... However, I checked, and I'm pretty sure that no such glitch previously existed at all, because the only times the vector gets indexed are when `scriptlength` is either being incremented after starting from 0 (`add()`) or when it's underneath a `position < scriptlength` conditional. Furthermore, I'm unaware of anyone who has actually found or used such an exploit, and I've been in the custom level community for 6 years. So I think it's fine.
2020-02-20 18:43:52 +01:00
ed.sbscript=ed.hooklist[(ed.hooklist.size()-1)-ed.hookmenu];
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
ed.loadhookineditor(ed.sbscript);
Make `commands`, `sb`, and `hooklist` not use separate length-trackers This is a refactor that turns the script-related arrays `ed.sb`, and `ed.hooklist` into C++ vectors (`script.commands` was already a vector, it was just misused). The code handling these vectors now looks more like idiomatic C++ than sloppily-pasted pseudo-ActionScript. This removes the variables `script.scriptlength`, `ed.sblength`, and `ed.numhooks`, too. This reduces the amount of code needed to e.g. simply remove something from any of these vectors. Previously the code had to manually shift the rest of the elements down one-by-one, and doing it manually is definitely error-prone and tedious. But now we can just use fancy functions like `std::vector::erase()` and `std::remove()` to do it all in one line! Don't worry, I checked and `std::remove()` is in the C++ standard since at least 1998. This patch makes it so the `commands` vector gets cleared when `scriptclass::load()` is ran. Previously, the `commands` vector never actually properly got cleared, so there could potentially be glitches that rely on the game indexing past the bounds set by `scriptlength` but still in-bounds in the eyes of C++, and people could potentially rely on such an exploit... However, I checked, and I'm pretty sure that no such glitch previously existed at all, because the only times the vector gets indexed are when `scriptlength` is either being incremented after starting from 0 (`add()`) or when it's underneath a `position < scriptlength` conditional. Furthermore, I'm unaware of anyone who has actually found or used such an exploit, and I've been in the custom level community for 6 years. So I think it's fine.
2020-02-20 18:43:52 +01:00
ed.sby=ed.sb.size()-1;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
ed.pagey=0;
Start using level-specific font where needed, make CJK tweaks Level text such as room names, text box content, and the contents of the script editor need to be displayed in the level-specific font, and tweaked to look right. This involves displaying less lines in the script editor, making text boxes bigger, displaying some text higher and some text lower. This is still unfinished, but it's the real start of a migration to font::print functions!
2023-01-12 05:27:52 +01:00
while(ed.sby>=ed.lines_visible-5)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
ed.pagey++;
ed.sby--;
}
key.keybuffer=ed.sb[ed.pagey+ed.sby];
Replace utfcpp by UTF8.h in Editor.cpp
2023-02-23 04:13:15 +01:00
ed.sbx = UTF8_total_codepoints(ed.sb[ed.pagey+ed.sby].c_str());
Editor: Play Viridan squeak when entering a script For consistency.
2021-08-12 04:43:33 +02:00
music.playef(11);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
}
else if(ed.scripthelppage==1)
{
//Script editor!
if (key.isDown(27))
{
ed.scripthelppage=0;
game.jumpheld = true;
//save the script for use again!
ed.addhook(ed.sbscript);
}
if(ed.keydelay>0) ed.keydelay--;
Allow D-Pad to act as arrow keys in the editor This doesn't make the editor completely accessible on controller, but it's a good start at least. VCE already let you move between rooms with the D-Pad, though.
2020-07-01 02:39:32 +02:00
if(up_pressed && ed.keydelay<=0)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
ed.keydelay=6;
ed.sby--;
if(ed.sby<=5)
{
if(ed.pagey>0)
{
ed.pagey--;
ed.sby++;
}
else
{
if(ed.sby<0) ed.sby=0;
}
}
key.keybuffer=ed.sb[ed.pagey+ed.sby];
}
Allow D-Pad to act as arrow keys in the editor This doesn't make the editor completely accessible on controller, but it's a good start at least. VCE already let you move between rooms with the D-Pad, though.
2020-07-01 02:39:32 +02:00
if(down_pressed && ed.keydelay<=0)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
ed.keydelay=6;
Make `commands`, `sb`, and `hooklist` not use separate length-trackers This is a refactor that turns the script-related arrays `ed.sb`, and `ed.hooklist` into C++ vectors (`script.commands` was already a vector, it was just misused). The code handling these vectors now looks more like idiomatic C++ than sloppily-pasted pseudo-ActionScript. This removes the variables `script.scriptlength`, `ed.sblength`, and `ed.numhooks`, too. This reduces the amount of code needed to e.g. simply remove something from any of these vectors. Previously the code had to manually shift the rest of the elements down one-by-one, and doing it manually is definitely error-prone and tedious. But now we can just use fancy functions like `std::vector::erase()` and `std::remove()` to do it all in one line! Don't worry, I checked and `std::remove()` is in the C++ standard since at least 1998. This patch makes it so the `commands` vector gets cleared when `scriptclass::load()` is ran. Previously, the `commands` vector never actually properly got cleared, so there could potentially be glitches that rely on the game indexing past the bounds set by `scriptlength` but still in-bounds in the eyes of C++, and people could potentially rely on such an exploit... However, I checked, and I'm pretty sure that no such glitch previously existed at all, because the only times the vector gets indexed are when `scriptlength` is either being incremented after starting from 0 (`add()`) or when it's underneath a `position < scriptlength` conditional. Furthermore, I'm unaware of anyone who has actually found or used such an exploit, and I've been in the custom level community for 6 years. So I think it's fine.
2020-02-20 18:43:52 +01:00
if(ed.sby+ed.pagey<(int)ed.sb.size()-1)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
ed.sby++;
Start using level-specific font where needed, make CJK tweaks Level text such as room names, text box content, and the contents of the script editor need to be displayed in the level-specific font, and tweaked to look right. This involves displaying less lines in the script editor, making text boxes bigger, displaying some text higher and some text lower. This is still unfinished, but it's the real start of a migration to font::print functions!
2023-01-12 05:27:52 +01:00
if(ed.sby>=ed.lines_visible-5)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
ed.pagey++;
ed.sby--;
}
}
key.keybuffer=ed.sb[ed.pagey+ed.sby];
}
Fix frame-ordering backspacing empty line bug in script editor There is a long-standing bug with the script editor where if you delete the last character of a line, it IMMEDIATELY deletes the line you're on, and then moves your cursor back to the previous line. This is annoying, to say the least. The reason for this is that, in the sequence of events that happens in one frame (known as frame ordering), the code that backspaces one character from the line when you press Backspace is ran BEFORE the code to remove an empty line if you backspace it is ran. The former is located in key.Poll(), and the latter is located in editorinput(). Thus, when you press Backspace, the game first runs key.Poll(), sees that you've pressed Backspace, and dutifully removes the last character from a line. The line is now empty. Then, when the game gets around to the "Are you pressing Backspace on an empty line?" check in editorinput(), it thinks that you're pressing Backspace on an empty line, and then does the usual line-removing stuff. And actually, when it does the check in editorinput(), it ACTUALLY asks "Are you pressing Backspace on THIS frame and was the line empty LAST frame?" because it's checking against its own copy of the input buffer, before copying the input buffer to its own local copy. So the problem only happens if you press and hold Backspace for more than 1 frame. It's a small consolation prize for this annoyance, getting to tap-tap-tap Backspace in the hopes that you only press it for 1 frame, while in the middle of something more important to do like, oh I don't know, writing a script. So there are two potential solutions here: (1) Just change the frame ordering around. This is risky to say the least, because I'm not sure what behavior depends on exactly which frame order. It's not like it's key.Poll() and then IMMEDIATELY afterwards editorinput() is run, it's more like key.Poll(), some things that obviously depend on key.Poll() running before them, and THEN editorinput(). Also, editorinput() is only one possible thing that could be ran afterwards, on the next frame we could be running something else entirely instead. (2) Add a kludge variable to signal when the line is ALREADY empty so the game doesn't re-check the already-empty line and conclude that you're already immediately backspacing an empty line. I went with (2) for this commit, and I've added the kludge variable key.linealreadyemptykludge. However, that by itself isn't enough to fix it. It only adds about a frame or so of delay before the game goes right back to saying "Oh, you're ALREADY somehow pressing backspace again? I'll just delete this line real quick" and the behavior is basically the same as before, except now you have to hit Backspace for TWO frames or less instead of one in order to not have it happen. What we need is to have a delay set as well, when the game deletes the last line of a char. So I set ed.keydelay to 6 as well if editorinput() sses that key.linealreadyemptykludge is on.
2020-01-19 03:17:46 +01:00
if(key.linealreadyemptykludge)
{
ed.keydelay=6;
key.linealreadyemptykludge=false;
}
if(key.pressedbackspace && ed.sb[ed.pagey+ed.sby]=="" && ed.keydelay<=0)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
//Remove this line completely
ed.removeline(ed.pagey+ed.sby);
ed.sby--;
if(ed.sby<=5)
{
if(ed.pagey>0)
{
ed.pagey--;
ed.sby++;
}
else
{
if(ed.sby<0) ed.sby=0;
}
}
key.keybuffer=ed.sb[ed.pagey+ed.sby];
Set ed.keydelay when backspacing an empty line Similar to 2ebccbc3e9a06b4148e8014808ef6fe45e298c8d, there's also a long-standing bug where if you backspace an empty line (and this time, the line IS actually already empty, not merely emptied-earlier-in-the-frame), the game will quickly delete more blank lines if there are any above the blank line you deleted. Again, this is annoying too, if you so happen to need to use lots of blank lines. To fix this, it's simple - just set ed.keydelay to 6 when the game backspaces an empty line. Then it won't be so trigger-happy in deleting blank lines.
2020-01-19 03:39:39 +01:00
ed.keydelay=6;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Remove use of <algorithm> from editor.cpp No need to use it when good ol' loops work just fine. Iterating backwards is correct here, in case there happen to be more than one of the item in the vectors, and also to minimize the amount of memory that needs to be relocated.
2021-04-20 20:29:50 +02:00
/* Remove all pipes, they are the line separator in the XML
* When this loop reaches the end, it wraps to SIZE_MAX; SIZE_MAX + 1 is 0 */
{size_t i; for (i = key.keybuffer.length() - 1; i + 1 > 0; --i)
{
if (key.keybuffer[i] == '|')
{
key.keybuffer.erase(key.keybuffer.begin() + i);
}
}}
Prevent typing pipes in the script editor This prevents users from being confused whenever they type a pipe in the script editor, then save the level and load it again and see their script lines unexpectedly splitting in two. Now if you attempt to type a pipe, it simply won't happen at all. Fixes #379.
2020-09-28 00:14:42 +02:00
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
ed.sb[ed.pagey+ed.sby]=key.keybuffer;
Replace utfcpp by UTF8.h in Editor.cpp
2023-02-23 04:13:15 +01:00
ed.sbx = UTF8_total_codepoints(ed.sb[ed.pagey+ed.sby].c_str());
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
if(!game.press_map && !key.isDown(27)) game.mapheld=false;
if (!game.mapheld)
{
if(game.press_map)
{
game.mapheld=true;
//Continue to next line
Make `commands`, `sb`, and `hooklist` not use separate length-trackers This is a refactor that turns the script-related arrays `ed.sb`, and `ed.hooklist` into C++ vectors (`script.commands` was already a vector, it was just misused). The code handling these vectors now looks more like idiomatic C++ than sloppily-pasted pseudo-ActionScript. This removes the variables `script.scriptlength`, `ed.sblength`, and `ed.numhooks`, too. This reduces the amount of code needed to e.g. simply remove something from any of these vectors. Previously the code had to manually shift the rest of the elements down one-by-one, and doing it manually is definitely error-prone and tedious. But now we can just use fancy functions like `std::vector::erase()` and `std::remove()` to do it all in one line! Don't worry, I checked and `std::remove()` is in the C++ standard since at least 1998. This patch makes it so the `commands` vector gets cleared when `scriptclass::load()` is ran. Previously, the `commands` vector never actually properly got cleared, so there could potentially be glitches that rely on the game indexing past the bounds set by `scriptlength` but still in-bounds in the eyes of C++, and people could potentially rely on such an exploit... However, I checked, and I'm pretty sure that no such glitch previously existed at all, because the only times the vector gets indexed are when `scriptlength` is either being incremented after starting from 0 (`add()`) or when it's underneath a `position < scriptlength` conditional. Furthermore, I'm unaware of anyone who has actually found or used such an exploit, and I've been in the custom level community for 6 years. So I think it's fine.
2020-02-20 18:43:52 +01:00
if(ed.sby+ed.pagey>=(int)ed.sb.size()) //we're on the last line
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
ed.sby++;
Start using level-specific font where needed, make CJK tweaks Level text such as room names, text box content, and the contents of the script editor need to be displayed in the level-specific font, and tweaked to look right. This involves displaying less lines in the script editor, making text boxes bigger, displaying some text higher and some text lower. This is still unfinished, but it's the real start of a migration to font::print functions!
2023-01-12 05:27:52 +01:00
if(ed.sby>=ed.lines_visible-5)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
ed.pagey++;
ed.sby--;
}
key.keybuffer=ed.sb[ed.pagey+ed.sby];
Replace utfcpp by UTF8.h in Editor.cpp
2023-02-23 04:13:15 +01:00
ed.sbx = UTF8_total_codepoints(ed.sb[ed.pagey+ed.sby].c_str());
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else
{
//We're not, insert a line instead
ed.sby++;
Start using level-specific font where needed, make CJK tweaks Level text such as room names, text box content, and the contents of the script editor need to be displayed in the level-specific font, and tweaked to look right. This involves displaying less lines in the script editor, making text boxes bigger, displaying some text higher and some text lower. This is still unfinished, but it's the real start of a migration to font::print functions!
2023-01-12 05:27:52 +01:00
if(ed.sby>=ed.lines_visible-5)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
ed.pagey++;
ed.sby--;
}
ed.insertline(ed.sby+ed.pagey);
key.keybuffer="";
ed.sbx = 0;
}
}
}
}
}
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
else if (ed.textmod)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
*ed.textptr = key.keybuffer;
if (!game.press_map && !key.isDown(27))
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
game.mapheld = false;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
if (!game.mapheld && game.press_map)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
game.mapheld = true;
key.disabletextentry();
switch (ed.textmod)
{
Add G keybind to go to room Ved has this useful feature where instead of having to manually travel to a room whose coordinates you know, you can just press G and type in coordinates to go there. VCE added this, but I changed the text to be "x,y" instead of "(x,y)" because otherwise it could confuse someone into thinking they need to type parentheses when in reality they don't need to and typing them will just make it not work. Also I made sure to add an error message if the user types in an invalid format. Failing silently would just confuse people, and maybe they'll start thinking the feature doesn't work or something like that. VCE doesn't have this helpful error message. Lastly, VCE has a bug where if you use the shortcut to go from one horizontally/vertically warping room to another, the background of the previous room will still be there and scroll off with the background of the room you went to, instead of just having the new background only. This is because they forgot a 'graphics.backgrounddrawn = false;'. But don't worry, *I* didn't forget about it.
2020-07-01 08:35:59 +02:00
case TEXT_GOTOROOM:
{
Refactor editor gotoroom shortcut to not use split() Even if split() didn't use the STL, using this function here is a bit unnecessary, because a simple SDL_strchr() suffices. Refactoring split() to not use the STL will break this caller anyway, so I might as well just refactor this to not use split() in the first place. This refactor also properly checks if the inputs are valid integers. And since split() is no longer used, it also rejects inputs ending with a trailing comma as being invalid, too; this didn't happen previously. It's intentional that I used is_number() here instead of is_positive_num(), thus accepting negative numbers; in the future it might be possible to have negative room coordinates.
2021-02-12 02:02:32 +01:00
char coord_x[16];
char coord_y[16];
const char* comma = SDL_strchr(key.keybuffer.c_str(), ',');
bool valid_input = comma != NULL;
if (valid_input)
{
SDL_strlcpy(
coord_x,
key.keybuffer.c_str(),
Remove `VVV_min/max` in favor of `SDL_min/max` VVV_min/max are functions that only operate on ints, and SDL_min/max are macros that operate on any type but double-evaluate everything. I know I more-or-less said earlier that SDL_min/max were dumb but I've changed my mind and think it's better to use them, taking care to make sure you don't double-evaluate, rather than trying to generate your own litany of functions with either your own hand-rolled generation macros, C++ templates, C11 generics, or GCC extensions (that last one you'd technically use in a macro but it doesn't really matter), all of which have more downsides than just not double-evaluating. And the upside of not double-evaluating is that you're disencouraged from having really complicated single-line min/max expressions and encouraged to precompute the values beforehand anyway so the final min/max is more readable. And furthermore you'll notice when you yourself end up doing double-evaluations anyway. I removed a couple instances of Graphics::len() being double-evaluated in this commit (as well as cleaned up some other min/max-using code). Although the only downside to those double-evaluations was unnecessary computation, rather than checking the wrong result or having multiple side effects, thankfully, it's still good to minimize double-evaluations where possible.
2021-12-23 01:43:31 +01:00
SDL_min((size_t) (comma - key.keybuffer.c_str() + 1), sizeof(coord_x))
Refactor editor gotoroom shortcut to not use split() Even if split() didn't use the STL, using this function here is a bit unnecessary, because a simple SDL_strchr() suffices. Refactoring split() to not use the STL will break this caller anyway, so I might as well just refactor this to not use split() in the first place. This refactor also properly checks if the inputs are valid integers. And since split() is no longer used, it also rejects inputs ending with a trailing comma as being invalid, too; this didn't happen previously. It's intentional that I used is_number() here instead of is_positive_num(), thus accepting negative numbers; in the future it might be possible to have negative room coordinates.
2021-02-12 02:02:32 +01:00
);
SDL_strlcpy(coord_y, &comma[1], sizeof(coord_y));
valid_input = is_number(coord_x) && is_number(coord_y);
}
if (!valid_input)
Add G keybind to go to room Ved has this useful feature where instead of having to manually travel to a room whose coordinates you know, you can just press G and type in coordinates to go there. VCE added this, but I changed the text to be "x,y" instead of "(x,y)" because otherwise it could confuse someone into thinking they need to type parentheses when in reality they don't need to and typing them will just make it not work. Also I made sure to add an error message if the user types in an invalid format. Failing silently would just confuse people, and maybe they'll start thinking the feature doesn't work or something like that. VCE doesn't have this helpful error message. Lastly, VCE has a bug where if you use the shortcut to go from one horizontally/vertically warping room to another, the background of the previous room will still be there and scroll off with the background of the room you went to, instead of just having the new background only. This is because they forgot a 'graphics.backgrounddrawn = false;'. But don't worry, *I* didn't forget about it.
2020-07-01 08:35:59 +02:00
{
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
ed.note = loc::gettext("ERROR: Invalid format");
Add G keybind to go to room Ved has this useful feature where instead of having to manually travel to a room whose coordinates you know, you can just press G and type in coordinates to go there. VCE added this, but I changed the text to be "x,y" instead of "(x,y)" because otherwise it could confuse someone into thinking they need to type parentheses when in reality they don't need to and typing them will just make it not work. Also I made sure to add an error message if the user types in an invalid format. Failing silently would just confuse people, and maybe they'll start thinking the feature doesn't work or something like that. VCE doesn't have this helpful error message. Lastly, VCE has a bug where if you use the shortcut to go from one horizontally/vertically warping room to another, the background of the previous room will still be there and scroll off with the background of the room you went to, instead of just having the new background only. This is because they forgot a 'graphics.backgrounddrawn = false;'. But don't worry, *I* didn't forget about it.
2020-07-01 08:35:59 +02:00
ed.notedelay = 45;
break;
}
Refactor editor gotoroom shortcut to not use split() Even if split() didn't use the STL, using this function here is a bit unnecessary, because a simple SDL_strchr() suffices. Refactoring split() to not use the STL will break this caller anyway, so I might as well just refactor this to not use split() in the first place. This refactor also properly checks if the inputs are valid integers. And since split() is no longer used, it also rejects inputs ending with a trailing comma as being invalid, too; this didn't happen previously. It's intentional that I used is_number() here instead of is_positive_num(), thus accepting negative numbers; in the future it might be possible to have negative room coordinates.
2021-02-12 02:02:32 +01:00
Remove `clamp` in favor of `SDL_clamp` For the same reasons as I removed VVV_min/max in favor of SDL_min/max in aa7b63fa5f3a46d0e41f784210332d7cd7306474, I'm doing the same thing here.
2021-12-23 01:55:07 +01:00
ed.levx = SDL_clamp(help.Int(coord_x) - 1, 0, cl.mapwidth - 1);
ed.levy = SDL_clamp(help.Int(coord_y) - 1, 0, cl.mapheight - 1);
Add G keybind to go to room Ved has this useful feature where instead of having to manually travel to a room whose coordinates you know, you can just press G and type in coordinates to go there. VCE added this, but I changed the text to be "x,y" instead of "(x,y)" because otherwise it could confuse someone into thinking they need to type parentheses when in reality they don't need to and typing them will just make it not work. Also I made sure to add an error message if the user types in an invalid format. Failing silently would just confuse people, and maybe they'll start thinking the feature doesn't work or something like that. VCE doesn't have this helpful error message. Lastly, VCE has a bug where if you use the shortcut to go from one horizontally/vertically warping room to another, the background of the previous room will still be there and scroll off with the background of the room you went to, instead of just having the new background only. This is because they forgot a 'graphics.backgrounddrawn = false;'. But don't worry, *I* didn't forget about it.
2020-07-01 08:35:59 +02:00
graphics.backgrounddrawn = false;
break;
}
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
case TEXT_LOAD:
{
std::string loadstring = ed.filename + ".vvvvvv";
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
if (cl.load(loadstring))
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
{
// don't use filename, it has the full path
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
char buffer[3*SCREEN_WIDTH_CHARS + 1];
vformat_buf(buffer, sizeof(buffer), loc::gettext("Loaded map: {filename}.vvvvvv"), "filename:str", ed.filename.c_str());
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
ed.note = buffer;
}
else
{
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
ed.note = loc::gettext("ERROR: Could not load level");
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
}
ed.notedelay = 45;
break;
}
case TEXT_SAVE:
{
std::string savestring = ed.filename + ".vvvvvv";
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
if (cl.save(savestring))
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
{
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
char buffer[3*SCREEN_WIDTH_CHARS + 1];
vformat_buf(buffer, sizeof(buffer), loc::gettext("Saved map: {filename}.vvvvvv"), "filename:str", ed.filename.c_str());
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
ed.note = buffer;
}
else
{
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
ed.note = loc::gettext("ERROR: Could not save level!");
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
ed.saveandquit = false;
}
ed.notedelay = 45;
if (ed.saveandquit)
{
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; /* quit editor */
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
}
break;
}
case TEXT_SCRIPT:
ed.clearscriptbuffer();
if (!ed.checkhook(key.keybuffer))
{
ed.addhook(key.keybuffer);
}
break;
default:
break;
}
ed.shiftmenu = false;
ed.shiftkey = false;
ed.textmod = TEXT_NONE;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
}
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
else if (key.textentry())
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
{
if(ed.titlemod)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Remove EditorData and put its attributes on customlevelclass This object basically had no reason to exist... it was just more verbose to use, which really reminded me of Java. Anyway, this is the last thing named after the editor for no reason when it should be a part of the customlevelclass, so I moved its attributes to customlevelclass.
2021-02-21 01:04:50 +01:00
cl.title=key.keybuffer;
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
if (cl.title == "")
{
cl.title = "Untitled Level";
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else if(ed.creatormod)
{
Remove EditorData and put its attributes on customlevelclass This object basically had no reason to exist... it was just more verbose to use, which really reminded me of Java. Anyway, this is the last thing named after the editor for no reason when it should be a part of the customlevelclass, so I moved its attributes to customlevelclass.
2021-02-21 01:04:50 +01:00
cl.creator=key.keybuffer;
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
if (cl.creator == "")
{
cl.creator = "Unknown";
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else if(ed.websitemod)
{
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
cl.website=key.keybuffer;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else if(ed.desc1mod)
{
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
cl.Desc1=key.keybuffer;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else if(ed.desc2mod)
{
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
cl.Desc2=key.keybuffer;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else if(ed.desc3mod)
{
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
cl.Desc3=key.keybuffer;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
if(!game.press_map && !key.isDown(27)) game.mapheld=false;
if (!game.mapheld)
{
if(game.press_map)
{
game.mapheld=true;
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
if(ed.titlemod)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Remove EditorData and put its attributes on customlevelclass This object basically had no reason to exist... it was just more verbose to use, which really reminded me of Java. Anyway, this is the last thing named after the editor for no reason when it should be a part of the customlevelclass, so I moved its attributes to customlevelclass.
2021-02-21 01:04:50 +01:00
cl.title=key.keybuffer;
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
if (cl.title == "")
{
cl.title = "Untitled Level";
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
ed.titlemod=false;
}
else if(ed.creatormod)
{
Remove EditorData and put its attributes on customlevelclass This object basically had no reason to exist... it was just more verbose to use, which really reminded me of Java. Anyway, this is the last thing named after the editor for no reason when it should be a part of the customlevelclass, so I moved its attributes to customlevelclass.
2021-02-21 01:04:50 +01:00
cl.creator=key.keybuffer;
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
if (cl.creator == "")
{
cl.creator = "Unknown";
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
ed.creatormod=false;
}
else if(ed.websitemod)
{
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
cl.website=key.keybuffer;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
ed.websitemod=false;
}
else if(ed.desc1mod)
{
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
cl.Desc1=key.keybuffer;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else if(ed.desc2mod)
{
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
cl.Desc2=key.keybuffer;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else if(ed.desc3mod)
{
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
cl.Desc3=key.keybuffer;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
ed.desc3mod=false;
}
key.disabletextentry();
if(ed.desc1mod)
{
ed.desc1mod=false;
ed.desc2mod=true;
key.enabletextentry();
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
key.keybuffer=cl.Desc2;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else if(ed.desc2mod)
{
ed.desc2mod=false;
Improve level metadata display and font handling - If the level font is higher than 10 pixels, the third description line (Desc3) is disabled and unavailable. CJK languages require less characters to convey the same message (140 characters caused people to cram tweets in all languages except CJK) and this gives us enough room in the levels list without having to cram the metadata even more than it already was or showing less levels per page. - The "Untitled Level" and "by Unknown" now selectively show up in the interface font instead of the level font.
2023-01-19 20:15:17 +01:00
if (font::height(PR_FONT_LEVEL) <= 10)
{
ed.desc3mod=true;
key.enabletextentry();
key.keybuffer=cl.Desc3;
}
else
{
cl.Desc3="";
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Play Viridian squeak when editing level desc fields For consistency, the Viridian squeak will now play whenever you start editing a level description field, or finish editing it (either by pressing Esc or Enter).
2021-06-11 21:52:28 +02:00
music.playef(11);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
}
else
{
if(ed.settingsmod)
{
if (!game.press_action && !game.press_left && !game.press_right
Allow D-Pad to act as arrow keys in the editor This doesn't make the editor completely accessible on controller, but it's a good start at least. VCE already let you move between rooms with the D-Pad, though.
2020-07-01 02:39:32 +02:00
&& !up_pressed && !down_pressed) game.jumpheld = false;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
if (!game.jumpheld)
{
if (game.press_action || game.press_left || game.press_right || game.press_map
Allow D-Pad to act as arrow keys in the editor This doesn't make the editor completely accessible on controller, but it's a good start at least. VCE already let you move between rooms with the D-Pad, though.
2020-07-01 02:39:32 +02:00
|| up_pressed || down_pressed)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
game.jumpheld = true;
}
if(game.menustart)
{
Allow D-Pad to act as arrow keys in the editor This doesn't make the editor completely accessible on controller, but it's a good start at least. VCE already let you move between rooms with the D-Pad, though.
2020-07-01 02:39:32 +02:00
if (game.press_left || up_pressed)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
game.currentmenuoption--;
}
Allow D-Pad to act as arrow keys in the editor This doesn't make the editor completely accessible on controller, but it's a good start at least. VCE already let you move between rooms with the D-Pad, though.
2020-07-01 02:39:32 +02:00
else if (game.press_right || down_pressed)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
game.currentmenuoption++;
}
}
Refactor menu creation code Firstly, menu options are no longer ad-hoc objects, and are added by using Game::option() (this is the biggest change). This removes the vector Game::menuoptionsactive, and Game::menuoptions is now a vector of MenuOption instead of std::string. Secondly, the manual tracker variable of the amount of menu options, Game::nummenuoptions, has been removed, in favor of using vectors properly and using Game::menuoptions::size(). As a result, a lot of copy-pasted code has been removed from Game::createmenu(), mostly due to having to have different versions of menus depending on whether or not we have certain defines, or having an mmmmmm.vvv file inside the VVVVVV directory. In the old days, you couldn't just add or remove a menu option conveniently, you had to shuffle around the position of every other menu option too, which resulted in lots of copy-pasted code. But now this copy-pasted code has been de-duplicated, at least in Game::createmenu().
2020-04-15 06:50:17 +02:00
if (game.currentmenuoption < 0) game.currentmenuoption = game.menuoptions.size()-1;
if (game.currentmenuoption >= (int) game.menuoptions.size() ) game.currentmenuoption = 0;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
if (game.press_action)
{
Move editor menu ACTION press handling to separate function This removes a whopping four indentation levels from the ACTION handling, and makes editorinput() easier to read.
2020-04-16 05:52:21 +02:00
editormenuactionpress();
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
}
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
else if (ed.keydelay > 0)
{
ed.keydelay--;
}
else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL])
{
// Ctrl modifiers
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 texturewidth;
int textureheight;
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
if (cl.getroomprop(ed.levx, ed.levy)->tileset == 0)
Don't assume tilesheet size in Direct Mode This lets users place down tiles above 1199 in Direct Mode, if their tilesheet has more than 1200 tiles. I don't like the copy-pasted code here but it'll have to make do.
2021-08-23 06:13:28 +02:00
{
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 (graphics.query_texture(graphics.grphx.im_tiles, NULL, NULL, &texturewidth, &textureheight) != 0)
{
return;
}
Don't assume tilesheet size in Direct Mode This lets users place down tiles above 1199 in Direct Mode, if their tilesheet has more than 1200 tiles. I don't like the copy-pasted code here but it'll have to make do.
2021-08-23 06:13:28 +02:00
}
else
{
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 (graphics.query_texture(graphics.grphx.im_tiles2, NULL, NULL, &texturewidth, &textureheight) != 0)
{
return;
}
Don't assume tilesheet size in Direct Mode This lets users place down tiles above 1199 in Direct Mode, if their tilesheet has more than 1200 tiles. I don't like the copy-pasted code here but it'll have to make do.
2021-08-23 06:13:28 +02:00
}
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
const int numtiles = (int) (texturewidth / 8) * (textureheight / 8);
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
ed.dmtileeditor=10;
if(left_pressed)
{
ed.dmtile--;
ed.keydelay=3;
Don't assume tilesheet size in Direct Mode This lets users place down tiles above 1199 in Direct Mode, if their tilesheet has more than 1200 tiles. I don't like the copy-pasted code here but it'll have to make do.
2021-08-23 06:13:28 +02:00
if(ed.dmtile<0) ed.dmtile+=numtiles;
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
}
else if(right_pressed)
{
ed.dmtile++;
ed.keydelay=3;
Don't assume tilesheet size in Direct Mode This lets users place down tiles above 1199 in Direct Mode, if their tilesheet has more than 1200 tiles. I don't like the copy-pasted code here but it'll have to make do.
2021-08-23 06:13:28 +02:00
if(ed.dmtile>=numtiles) ed.dmtile-=numtiles;
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
}
if(up_pressed)
{
ed.dmtile-=40;
ed.keydelay=3;
Don't assume tilesheet size in Direct Mode This lets users place down tiles above 1199 in Direct Mode, if their tilesheet has more than 1200 tiles. I don't like the copy-pasted code here but it'll have to make do.
2021-08-23 06:13:28 +02:00
if(ed.dmtile<0) ed.dmtile+=numtiles;
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
}
else if(down_pressed)
{
ed.dmtile+=40;
ed.keydelay=3;
Don't assume tilesheet size in Direct Mode This lets users place down tiles above 1199 in Direct Mode, if their tilesheet has more than 1200 tiles. I don't like the copy-pasted code here but it'll have to make do.
2021-08-23 06:13:28 +02:00
if(ed.dmtile>=numtiles) ed.dmtile-=numtiles;
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
}
}
else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT])
{
// Shift modifiers
Add Shift+F1/F2/F3 hotkeys Allowing users to reverse cycle tilesets/tilecols/enemies prevents them from having to press the hotkey a zillion times in order to get to the one they want if the one they want just happens to be behind the current one they're on.
2020-07-01 06:53:11 +02:00
if (key.keymap[SDLK_F1])
{
ed.switch_tileset(true);
ed.keydelay = 6;
}
if (key.keymap[SDLK_F2])
{
ed.switch_tilecol(true);
ed.keydelay = 6;
}
if (key.keymap[SDLK_F3])
{
ed.switch_enemy(true);
ed.keydelay=6;
}
Add being able to use Shift+W to change warp dir backwards A minor convenience, but a convenience is a convenience.
2021-08-23 05:51:51 +02:00
if (key.keymap[SDLK_w])
{
ed.switch_warpdir(true);
ed.keydelay = 6;
}
Add Shift+F1/F2/F3 hotkeys Allowing users to reverse cycle tilesets/tilecols/enemies prevents them from having to press the hotkey a zillion times in order to get to the one they want if the one they want just happens to be behind the current one they're on.
2020-07-01 06:53:11 +02:00
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
if (up_pressed || down_pressed || left_pressed || right_pressed)
{
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
ed.keydelay = 6;
if (up_pressed)
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
{
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
cl.mapheight--;
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
}
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
else if (down_pressed)
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
{
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
cl.mapheight++;
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
}
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
else if (left_pressed)
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
{
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
cl.mapwidth--;
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
}
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
else if (right_pressed)
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
{
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
cl.mapwidth++;
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
}
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
cl.mapwidth = SDL_clamp(cl.mapwidth, 1, cl.maxwidth);
cl.mapheight = SDL_clamp(cl.mapheight, 1, cl.maxheight);
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
char buffer[3*SCREEN_WIDTH_CHARS + 1];
vformat_buf(
buffer, sizeof(buffer),
loc::gettext("Mapsize is now [{width},{height}]"),
"width:int, height:int",
cl.mapwidth, cl.mapheight
);
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
ed.note = buffer;
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
ed.notedelay = 45;
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
}
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
if (!ed.shiftkey)
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
{
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
if (ed.shiftmenu)
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
{
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
ed.shiftmenu = false;
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
}
else
{
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
ed.shiftmenu = true;
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
}
}
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
ed.shiftkey = true;
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
else
{
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
// No modifiers
ed.shiftkey=false;
if(key.keymap[SDLK_F1])
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Remove default arguments from ed switch_* funcs I don't like default arguments and if we're going to be moving to C we'll need to remove them anyway.
2021-08-23 05:44:18 +02:00
ed.switch_tileset(false);
Abstract tileset/tilecol/enemy switching to functions This results in me having to copy-paste less code around, because editorinput() is big enough as it is.
2020-07-01 06:39:10 +02:00
ed.keydelay = 6;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
if(key.keymap[SDLK_F2])
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Remove default arguments from ed switch_* funcs I don't like default arguments and if we're going to be moving to C we'll need to remove them anyway.
2021-08-23 05:44:18 +02:00
ed.switch_tilecol(false);
Abstract tileset/tilecol/enemy switching to functions This results in me having to copy-paste less code around, because editorinput() is big enough as it is.
2020-07-01 06:39:10 +02:00
ed.keydelay = 6;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
if(key.keymap[SDLK_F3])
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Remove default arguments from ed switch_* funcs I don't like default arguments and if we're going to be moving to C we'll need to remove them anyway.
2021-08-23 05:44:18 +02:00
ed.switch_enemy(false);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
ed.keydelay=6;
}
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
if(key.keymap[SDLK_F4])
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
ed.keydelay=6;
ed.boundarytype=1;
ed.boundarymod=1;
}
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
if(key.keymap[SDLK_F5])
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
ed.keydelay=6;
ed.boundarytype=2;
ed.boundarymod=1;
}
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
if(key.keymap[SDLK_F10])
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
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
if(cl.getroomprop(ed.levx, ed.levy)->directmode==1)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
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
cl.setroomdirectmode(ed.levx, ed.levy, 0);
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
ed.note=loc::gettext("Direct Mode Disabled");
Add being able to use Lab rainbow background in editor If you use Lab tilecol 6, you get the rainbow background. However, this is unintended, because the associated autotiling is... not very good. To combat that, Ved disallows using the Lab rainbow background outside of Direct Mode. We will follow Ved here and only allow switching to the rainbow background if you're in Direct Mode. Also make sure if someone is disabling Direct Mode with the rainbow background that it gets reset properly.
2021-08-23 05:56:47 +02:00
/* Kludge fix for rainbow BG here... */
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
if (cl.getroomprop(ed.levx, ed.levy)->tileset == 2
&& cl.getroomprop(ed.levx, ed.levy)->tilecol == 6)
Add being able to use Lab rainbow background in editor If you use Lab tilecol 6, you get the rainbow background. However, this is unintended, because the associated autotiling is... not very good. To combat that, Ved disallows using the Lab rainbow background outside of Direct Mode. We will follow Ved here and only allow switching to the rainbow background if you're in Direct Mode. Also make sure if someone is disabling Direct Mode with the rainbow background that it gets reset properly.
2021-08-23 05:56:47 +02:00
{
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
cl.setroomtilecol(ed.levx, ed.levy, 0);
Add being able to use Lab rainbow background in editor If you use Lab tilecol 6, you get the rainbow background. However, this is unintended, because the associated autotiling is... not very good. To combat that, Ved disallows using the Lab rainbow background outside of Direct Mode. We will follow Ved here and only allow switching to the rainbow background if you're in Direct Mode. Also make sure if someone is disabling Direct Mode with the rainbow background that it gets reset properly.
2021-08-23 05:56:47 +02:00
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else
{
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
cl.setroomdirectmode(ed.levx, ed.levy, 1);
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
ed.note=loc::gettext("Direct Mode Enabled");
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
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.backgrounddrawn = false;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
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
ed.notedelay = 45;
ed.updatetiles = true;
ed.keydelay = 6;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
for (int i = 0; i < NUM_EditorTools; i++)
{
if (key.keymap[ed.toolkey[i]])
{
ed.current_tool = (EditorTools) i;
}
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
if(key.keymap[SDLK_w])
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Refactor warp dir switching to separate function This is so the same code can be used to go in reverse instead of copy-pasting it.
2021-08-23 05:51:21 +02:00
ed.switch_warpdir(false);
ed.keydelay = 6;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
if(key.keymap[SDLK_e])
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
ed.keydelay = 6;
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
ed.getlin(TEXT_ROOMNAME, loc::gettext("Enter new room name:"), const_cast<std::string*>(&(cl.getroomprop(ed.levx, ed.levy)->roomname)));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
game.mapheld=true;
}
Add G keybind to go to room Ved has this useful feature where instead of having to manually travel to a room whose coordinates you know, you can just press G and type in coordinates to go there. VCE added this, but I changed the text to be "x,y" instead of "(x,y)" because otherwise it could confuse someone into thinking they need to type parentheses when in reality they don't need to and typing them will just make it not work. Also I made sure to add an error message if the user types in an invalid format. Failing silently would just confuse people, and maybe they'll start thinking the feature doesn't work or something like that. VCE doesn't have this helpful error message. Lastly, VCE has a bug where if you use the shortcut to go from one horizontally/vertically warping room to another, the background of the previous room will still be there and scroll off with the background of the room you went to, instead of just having the new background only. This is because they forgot a 'graphics.backgrounddrawn = false;'. But don't worry, *I* didn't forget about it.
2020-07-01 08:35:59 +02:00
if (key.keymap[SDLK_g])
{
ed.keydelay = 6;
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
ed.getlin(TEXT_GOTOROOM, loc::gettext("Enter room coordinates x,y:"), NULL);
Add G keybind to go to room Ved has this useful feature where instead of having to manually travel to a room whose coordinates you know, you can just press G and type in coordinates to go there. VCE added this, but I changed the text to be "x,y" instead of "(x,y)" because otherwise it could confuse someone into thinking they need to type parentheses when in reality they don't need to and typing them will just make it not work. Also I made sure to add an error message if the user types in an invalid format. Failing silently would just confuse people, and maybe they'll start thinking the feature doesn't work or something like that. VCE doesn't have this helpful error message. Lastly, VCE has a bug where if you use the shortcut to go from one horizontally/vertically warping room to another, the background of the previous room will still be there and scroll off with the background of the room you went to, instead of just having the new background only. This is because they forgot a 'graphics.backgrounddrawn = false;'. But don't worry, *I* didn't forget about it.
2020-07-01 08:35:59 +02:00
game.mapheld=true;
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
//Save and load
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
if(key.keymap[SDLK_s])
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
ed.keydelay = 6;
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
ed.getlin(TEXT_SAVE, loc::gettext("Enter map filename to save as:"), &(ed.filename));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
game.mapheld=true;
}
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
if(key.keymap[SDLK_l])
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
ed.keydelay = 6;
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
ed.getlin(TEXT_LOAD, loc::gettext("Enter map filename to load:"), &(ed.filename));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
game.mapheld=true;
}
if(!game.press_map) game.mapheld=false;
if (!game.mapheld)
{
if(game.press_map)
{
game.mapheld=true;
//Ok! Scan the room for the closest checkpoint
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
int testeditor = -1;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
bool startpoint = false;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
//First up; is there a start point on this screen?
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
for (size_t i = 0; i < customentities.size(); i++)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
//if() on screen
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
if (customentities[i].t == 16 && testeditor == -1)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
int tx = customentities[i].x / 40;
int ty = customentities[i].y / 30;
if (tx == ed.levx && ty == ed.levy)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
testeditor = i;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
startpoint = true;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
}
if(testeditor==-1)
{
//Ok, settle for a check point
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
for (size_t i = 0; i < customentities.size(); i++)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
//if() on screen
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
if (customentities[i].t == 10 && testeditor == -1)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
int tx = customentities[i].x / 40;
int ty = customentities[i].y / 30;
if (tx == ed.levx && ty == ed.levy)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
testeditor = i;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
}
}
if(testeditor==-1)
{
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
ed.note=loc::gettext("ERROR: No checkpoint to spawn at");
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
ed.notedelay=45;
}
else
{
Add a player trail to the editor (ghosts) A few months ago, I added ghosts to the VVVVVV: Community Edition editor. I was told recently I should think about upstreaming it, and with Terry saying go ahead I finally ported them into VVVVVV. There's one slight difference however--you can choose whether you have them or not in the editor's settings menu. They're off by default, and this is saved to the save file. Anyway, when you're playtesting, the game saves the players position, color, room coordinates and sprite every 3 frames. The max is 100, where if it tries to add more, the oldest one gets removed. When you exit playtesting, the saved positions appear one at a time, and you can use the Z key to speed it up. [Here's a video of them in action.](https://o.lol-sa.me/4H21zCv.mp4)
2020-06-13 00:04:35 +02:00
ed.currentghosts = 0;
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if(!startpoint)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
//Checkpoint spawn
Remove overcomplicated integer divisions Believe it or not, there are still some remnants of the ActionScript coding standards in the codebase! And one of them sometimes pops up whenever an integer division happens. As it so happens, it seems like division in ActionScript automatically produces a decimal number. So to prevent that, the game sometimes subtracts off the remainder of the number to be divided before performing the division on it. Thus, we get statements that look like (a - (a % b)) / b And probably more parentheses surrounding it too, since it would be copy-pasted into yet another larger expression, because of course it would. `(a % b)` here is subtracting the remainder of `a` divided by `b`, using the modulo operator, before it gets divided by `b`. Thus, the number will always be divisible by `b`, so dividing it will mathematically not produce a decimal number. Needless to say, this is unnecessary, and very unreadable. In fact, when I saw these for the first time, I thought they were overcomplicated _modulos_, _not_ integer division! In C and C++, dividing an integer by an integer will always result in an integer, so there's no need to do all this runaround just to divide two integers. To find all of these, I used the command rg --pcre2 '(.+?).+?-.+?(?=\1).+?%.+?([\d]+?).+?\/.+?(?=\2)' which basically matches expressions of the form 'a - a % b / b', where 'a' and 'b' are identical and there could be any characters in the spaces.
2021-09-25 02:21:46 +02:00
int tx=customentities[testeditor].x/40;
int ty=customentities[testeditor].y/30;
Rename edentity to customentities This fixes the fact that the name of the singular type is plural, but the name of the plural array is singular. Which has always annoyed me, too. Also this makes it more clear that custom entities don't have much to do with the editor.
2021-02-21 01:01:39 +01:00
game.edsavex = (customentities[testeditor].x%40)*8 - 4;
game.edsavey = (customentities[testeditor].y%30)*8;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
game.edsaverx = 100+tx;
game.edsavery = 100+ty;
Rename edentity to customentities This fixes the fact that the name of the singular type is plural, but the name of the plural array is singular. Which has always annoyed me, too. Also this makes it more clear that custom entities don't have much to do with the editor.
2021-02-21 01:01:39 +01:00
if (customentities[testeditor].p1 == 0) // NOT a bool check!
Fix spawning from an exotic checkpoint setting invalid gravitycontrol An exotic checkpoint is a checkpoint with a sprite that is neither the flipped checkpoint nor unflipped checkpoint. More specifically, it's a checkpoint whose edentity p1 attribute is something other than 0 or 1. Normally, whenever you touch an exotic checkpoint in-game, your savepoint's y-position and gravitycontrol don't get touched. However, in the editor, spawning from an exotic checkpoint means that your gravitycontrol gets set to a value that is neither 0 nor 1. In this invalid gravitycontrol state, Viridian is treated like they're flipped, but they cannot unflip. This is an inconsistency between the editor and in-game, so I'm fixing it. Now, spawning from an exotic checkpoint in the editor will just set your gravitycontrol to 0, i.e. unflipped.
2020-10-06 08:04:58 +02:00
{
game.edsavegc = 1;
Fix inconsistencies with y-positions of spawns It seems like the start point of a custom level and all checkpoints in the game end up putting your spawn point one pixel away from the surface it touches, which seems like an oversight. I'm going to enforce some consistency here and make it so that all spawn points, whenever you start from a start point or a checkpoint, will always be correctly positioned flush with the surface they're standing on, and not one pixel more or less than that.
2020-10-06 08:13:07 +02:00
game.edsavey -= 2;
Fix spawning from an exotic checkpoint setting invalid gravitycontrol An exotic checkpoint is a checkpoint with a sprite that is neither the flipped checkpoint nor unflipped checkpoint. More specifically, it's a checkpoint whose edentity p1 attribute is something other than 0 or 1. Normally, whenever you touch an exotic checkpoint in-game, your savepoint's y-position and gravitycontrol don't get touched. However, in the editor, spawning from an exotic checkpoint means that your gravitycontrol gets set to a value that is neither 0 nor 1. In this invalid gravitycontrol state, Viridian is treated like they're flipped, but they cannot unflip. This is an inconsistency between the editor and in-game, so I'm fixing it. Now, spawning from an exotic checkpoint in the editor will just set your gravitycontrol to 0, i.e. unflipped.
2020-10-06 08:04:58 +02:00
}
else
{
game.edsavegc = 0;
Fix inconsistencies with y-positions of spawns It seems like the start point of a custom level and all checkpoints in the game end up putting your spawn point one pixel away from the surface it touches, which seems like an oversight. I'm going to enforce some consistency here and make it so that all spawn points, whenever you start from a start point or a checkpoint, will always be correctly positioned flush with the surface they're standing on, and not one pixel more or less than that.
2020-10-06 08:13:07 +02:00
game.edsavey -= 7;
Fix spawning from an exotic checkpoint setting invalid gravitycontrol An exotic checkpoint is a checkpoint with a sprite that is neither the flipped checkpoint nor unflipped checkpoint. More specifically, it's a checkpoint whose edentity p1 attribute is something other than 0 or 1. Normally, whenever you touch an exotic checkpoint in-game, your savepoint's y-position and gravitycontrol don't get touched. However, in the editor, spawning from an exotic checkpoint means that your gravitycontrol gets set to a value that is neither 0 nor 1. In this invalid gravitycontrol state, Viridian is treated like they're flipped, but they cannot unflip. This is an inconsistency between the editor and in-game, so I'm fixing it. Now, spawning from an exotic checkpoint in the editor will just set your gravitycontrol to 0, i.e. unflipped.
2020-10-06 08:04:58 +02:00
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
game.edsavedir = 0;
}
else
{
//Start point spawn
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
int tx = customentities[testeditor].x / 40;
int ty = customentities[testeditor].y / 30;
game.edsavex = (customentities[testeditor].x % 40) * 8 - 4;
game.edsavey = (customentities[testeditor].y % 30) * 8;
game.edsaverx = 100 + tx;
game.edsavery = 100 + ty;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
game.edsavegc = 0;
Fix inconsistencies with y-positions of spawns It seems like the start point of a custom level and all checkpoints in the game end up putting your spawn point one pixel away from the surface it touches, which seems like an oversight. I'm going to enforce some consistency here and make it so that all spawn points, whenever you start from a start point or a checkpoint, will always be correctly positioned flush with the surface they're standing on, and not one pixel more or less than that.
2020-10-06 08:13:07 +02:00
game.edsavey++;
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
game.edsavedir = 1 - customentities[testeditor].p1;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Remove duplicate function musicclass::stopmusic() It is an exact duplicate of musicclass::haltdasmusik(), so use that function instead and update callers. Looks like musicclass::haltdasmusik() came first, anyway (musicclass::stopmusic() was only used in editor.cpp).
2020-04-04 00:44:04 +02:00
music.haltdasmusik();
Make "[Press ENTER to return to editor]" fade out after a bit This makes the "[Press ENTER to return to editor]" fade out after a few frames, allowing screenshots of custom levels to be cleaner and to make sure nothing is obscured while the user is editing their level. This commit also adds alpha support in BlitSurfaceColoured, where it takes into account the alpha of the pixel *and* the alpha of the color. `graphics::getRGBA(r,g,b,a)` was added to help with this.
2020-02-10 03:23:12 +01:00
ed.returneditoralpha = 1000; // Let's start it higher than 255 since it gets clamped
Smoothly interpolate "[Press ENTER to return to editor]" fadeout Now it'll be real smooth at 60 FPS. Or above. Or whichever one you want above 30.
2020-05-02 19:49:41 +02:00
ed.oldreturneditoralpha = 1000;
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
script.startgamemode(Start_EDITORPLAYTESTING);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
}
Add 7x7, 9x9, full horizontal and vertical brush sizes
2020-06-17 23:49:57 +02:00
ed.hmod = key.keymap[SDLK_h];
ed.vmod = key.keymap[SDLK_v];
ed.bmod = key.keymap[SDLK_b];
ed.cmod = key.keymap[SDLK_c];
ed.xmod = key.keymap[SDLK_x];
ed.zmod = key.keymap[SDLK_z];
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if(key.keymap[SDLK_COMMA])
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
ed.current_tool = (EditorTools) POS_MOD(ed.current_tool - 1, NUM_EditorTools);
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
ed.keydelay = 6;
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
else if(key.keymap[SDLK_PERIOD])
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
ed.current_tool = (EditorTools) POS_MOD(ed.current_tool + 1, NUM_EditorTools);
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
ed.keydelay = 6;
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
if(up_pressed)
{
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
ed.keydelay = 6;
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
ed.levy--;
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
ed.updatetiles = true;
ed.changeroom = true;
graphics.backgrounddrawn = false;
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
}
else if(down_pressed)
{
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
ed.keydelay = 6;
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
ed.levy++;
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
ed.updatetiles = true;
ed.changeroom = true;
graphics.backgrounddrawn = false;
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
}
else if(left_pressed)
{
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
ed.keydelay = 6;
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
ed.levx--;
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
ed.updatetiles = true;
ed.changeroom = true;
graphics.backgrounddrawn = false;
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
}
else if(right_pressed)
{
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
ed.keydelay = 6;
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
ed.levx++;
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
ed.updatetiles = true;
ed.changeroom = true;
graphics.backgrounddrawn = false;
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Fix gravity/warp lines being modified during draw While warp lines were being drawn, they also got resized to automatically fit between collision. In renderfixed, gravity lines are resized the same way. Doing logic while drawing is very poor practice, so resizing of these has been moved into logic, and merged together. Aside from some more cleanup, this commit also removes the very poorly done right click emulation, when you hold CTRL and click. It never worked well in the past, and even requires a right click to use, so there's not really any point to keeping it around.
2023-03-02 21:28:02 +01:00
ed.levx = POS_MOD(ed.levx, cl.mapwidth);
ed.levy = POS_MOD(ed.levy, cl.mapheight);
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 (key.keymap[SDLK_SPACE])
Re-organize editor shortcuts logic Previously, it was: if (ed.settingsmod) { (Settings menu controls) ... } else { (Literally everything else Also a bunch of copy-pasted ed.keydelay checks) ... } Now it is: if (ed.settingsmod) { (Settings menu controls) ... } else if (ed.keydelay > 0) { ed.keydelay--; } else if (key.keymap[SDLK_LCTRL] || key.keymap[SDLK_RCTRL]) { // Ctrl modifiers ... } else if (key.keymap[SDLK_LSHIFT] || key.keymap[SDLK_RSHIFT]) { // Shift modifiers ... } else { // No modifiers ed.shiftkey = false; ... } It might not counteract how completely huge this code is, but it's at least organized better. Also, I had to change the map resize logic around slightly, else it'll get triggered any time you do a shift modifier keypress.
2020-07-01 05:39:36 +02:00
{
ed.spacemod = !ed.spacemod;
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
ed.keydelay = 6;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
if(!ed.settingsmod)
{
if(ed.boundarymod>0)
{
if(key.leftbutton)
{
if(ed.lclickdelay==0)
{
if(ed.boundarymod==1)
{
ed.lclickdelay=1;
ed.boundx1=(ed.tilex*8);
ed.boundy1=(ed.tiley*8);
ed.boundarymod=2;
}
else if(ed.boundarymod==2)
{
Fix attempts to place enemy/plat bounds & scripts with bad corner order There is a certain ordering of which corners you click on to place enemy and platform boundaries, and script boxes. You must first click on the top-left corner, then click on the bottom-right corner. The visual box that is drawn after you've first clicked on the top-left corner clearly shows this intended way of doing things. However, it seems like despite the visuals, the game didn't properly prevent you from clicking on the corners in the wrong way. If you placed it from top-right to bottom-left, or bottom-left to top-right, then the game would place the boxes accordingly, and they would have a weird shape where two of its opposite sides would just be missing. But, placing them from bottom-right to top-left is prevented accordingly. The bug comes down to a simple use of "or", instead of the correct "and". This isn't the first time the wrong conjunction was used in a conditional... (8260bb2696f4843b3e6a29b0c4deea7ba6779aea, #136) Since the code block that the if-statement guards is the code that will execute if the corners placed were correct, the if-statement thus should be written in the positive case and use a more restrictive "and", instead of the negative case, which would use a more looser "or". There are less cases that are correct than cases which are incorrect - in this case, there is only 1 correct way of doing things (top-left to bottom-right), compared to 3 incorrect ways of doing things (top-right to bottom-left, bottom-left to top-right, bottom-right to top-left) - so when thinking of positive cases, you should be using "and". Or, you can always just test it. This bug has been in the game since 2.0, so it seems like no one just tested that incorrect input actually didn't work.
2021-01-09 09:27:53 +01:00
if((ed.tilex*8)+8>=ed.boundx1 && (ed.tiley*8)+8>=ed.boundy1)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
ed.boundx2=(ed.tilex*8)+8;
ed.boundy2=(ed.tiley*8)+8;
}
else
{
ed.boundx2=ed.boundx1+8;
ed.boundy2=ed.boundy1+8;
}
if(ed.boundarytype==0)
{
//Script trigger
Refactor/de-duplicate entity text input This is basically FIQ's patch from VCE, except he never upstreamed it because he said something along the lines of it seeming to not fit the purpose of upstream. But anyway, it basically just de-duplicates all the text input and text finishing handling code and cuts down on the large amount of copy-paste in the editor functions. It makes things way more maintainable. Interesting note, it seems like FIQ had the intent to refactor the text input in editor settings (i.e. the level metadata details), but never got around to it in VCE. Maybe we'll finish that job for him later.
2020-07-01 08:17:26 +02:00
ed.lclickdelay=1;
Rename edentity to customentities This fixes the fact that the name of the singular type is plural, but the name of the plural array is singular. Which has always annoyed me, too. Also this makes it more clear that custom entities don't have much to do with the editor.
2021-02-21 01:01:39 +01:00
ed.textent=customentities.size();
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
ed.addedentity((ed.boundx1/8)+(ed.levx*40),(ed.boundy1/8)+ (ed.levy*30),19,
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
(ed.boundx2-ed.boundx1)/8, (ed.boundy2-ed.boundy1)/8);
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
ed.getlin(TEXT_SCRIPT, loc::gettext("Enter script name:"), &(customentities[ed.textent].scriptname));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
ed.lclickdelay=1;
}
else if(ed.boundarytype==1)
{
//Enemy bounds
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
cl.setroomenemyx1(ed.levx, ed.levy, ed.boundx1);
cl.setroomenemyy1(ed.levx, ed.levy, ed.boundy1);
cl.setroomenemyx2(ed.levx, ed.levy, ed.boundx2);
cl.setroomenemyy2(ed.levx, ed.levy, ed.boundy2);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else if(ed.boundarytype==2)
{
//Platform bounds
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
cl.setroomplatx1(ed.levx, ed.levy, ed.boundx1);
cl.setroomplaty1(ed.levx, ed.levy, ed.boundy1);
cl.setroomplatx2(ed.levx, ed.levy, ed.boundx2);
cl.setroomplaty2(ed.levx, ed.levy, ed.boundy2);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else if(ed.boundarytype==3)
{
//Copy
}
ed.boundarymod=0;
ed.lclickdelay=1;
}
}
}
else
{
ed.lclickdelay=0;
}
if(key.rightbutton)
{
ed.boundarymod=0;
}
}
else if(ed.warpmod)
{
//Placing warp token
if(key.leftbutton)
{
if(ed.lclickdelay==0)
{
if(ed.free(ed.tilex, ed.tiley)==0)
{
Rename edentity to customentities This fixes the fact that the name of the singular type is plural, but the name of the plural array is singular. Which has always annoyed me, too. Also this makes it more clear that custom entities don't have much to do with the editor.
2021-02-21 01:01:39 +01:00
customentities[ed.warpent].p1=ed.tilex+(ed.levx*40);
customentities[ed.warpent].p2=ed.tiley+(ed.levy*30);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
ed.warpmod=false;
ed.warpent=-1;
ed.lclickdelay=1;
}
}
}
else
{
ed.lclickdelay=0;
}
if(key.rightbutton)
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
ed.removeedentity(ed.warpent);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
ed.warpmod=false;
ed.warpent=-1;
}
}
else
{
//Mouse input
if(key.leftbutton)
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if (ed.lclickdelay == 0)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
ed.tool_place();
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
else
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
ed.lclickdelay = 0;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if (key.rightbutton)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// place tiles
ed.tool_remove();
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
if(key.middlebutton)
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
ed.dmtile = cl.gettile(ed.levx, ed.levy, ed.tilex, ed.tiley);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
}
}
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
if(ed.updatetiles && cl.getroomprop(ed.levx, ed.levy)->directmode==0)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
ed.updatetiles=false;
//Correctly set the tiles in the current room
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
switch(cl.getroomprop(ed.levx, ed.levy)->tileset)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
case 0: //The Space Station
for(int j=0; j<30; j++)
{
for(int i=0; i<40; i++)
{
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
int temp=cl.gettile(ed.levx, ed.levy, i, j);
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
if(temp>=3 && temp<80)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
//Fix spikes
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
cl.settile(ed.levx, ed.levy, i, j, ed.spikedir(i, j));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
else if(temp==2 || temp>=680)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
//Fix background
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
cl.settile(
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
ed.levx,
ed.levy,
i,
j,
ed.backedgetile(i, j) + ed.backbase(ed.levx, ed.levy)
);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
else if(temp>0)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
//Fix tiles
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
cl.settile(
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
ed.levx,
ed.levy,
i,
j,
ed.edgetile(i, j) + ed.base(ed.levx, ed.levy)
);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
}
break;
case 1: //Outside
for(int j=0; j<30; j++)
{
for(int i=0; i<40; i++)
{
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
int temp=cl.gettile(ed.levx, ed.levy, i, j);
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
if(temp>=3 && temp<80)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
//Fix spikes
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
cl.settile(ed.levx, ed.levy, i, j, ed.spikedir(i, j));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
else if(temp==2 || temp>=680)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
//Fix background
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
cl.settile(
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
ed.levx,
ed.levy,
i,
j,
ed.outsideedgetile(i, j) + ed.backbase(ed.levx, ed.levy)
);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
else if(temp>0)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
//Fix tiles
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
cl.settile(
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
ed.levx,
ed.levy,
i,
j,
ed.edgetile(i, j) + ed.base(ed.levx, ed.levy)
);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
}
break;
case 2: //Lab
for(int j=0; j<30; j++)
{
for(int i=0; i<40; i++)
{
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
int temp=cl.gettile(ed.levx, ed.levy, i, j);
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
if(temp>=3 && temp<80)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
//Fix spikes
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
cl.settile(
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
ed.levx,
ed.levy,
i,
j,
ed.labspikedir(
i,
j,
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
cl.getroomprop(ed.levx, ed.levy)->tilecol
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
)
);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
else if(temp==2 || temp>=680)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
//Fix background
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
cl.settile(ed.levx, ed.levy, i, j, 713);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
else if(temp>0)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
//Fix tiles
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
cl.settile(
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
ed.levx,
ed.levy,
i,
j,
ed.edgetile(i, j) + ed.base(ed.levx, ed.levy)
);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
}
break;
case 3: //Warp Zone/Intermission
for(int j=0; j<30; j++)
{
for(int i=0; i<40; i++)
{
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
int temp=cl.gettile(ed.levx, ed.levy, i, j);
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
if(temp>=3 && temp<80)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
//Fix spikes
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
cl.settile(ed.levx, ed.levy, i, j, ed.spikedir(i, j));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
else if(temp==2 || temp>=680)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
//Fix background
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
cl.settile(ed.levx, ed.levy, i, j, 713);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
else if(temp>0)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
//Fix tiles
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
cl.settile(
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
ed.levx,
ed.levy,
i,
j,
ed.edgetile(i, j) + ed.base(ed.levx, ed.levy)
);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
}
break;
case 4: //The ship
for(int j=0; j<30; j++)
{
for(int i=0; i<40; i++)
{
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
int temp=cl.gettile(ed.levx, ed.levy, i, j);
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
if(temp>=3 && temp<80)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
//Fix spikes
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
cl.settile(ed.levx, ed.levy, i, j, ed.spikedir(i, j));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
else if(temp==2 || temp>=680)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
//Fix background
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
cl.settile(
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
ed.levx,
ed.levy,
i,
j,
ed.backedgetile(i, j) + ed.backbase(ed.levx, ed.levy)
);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
else if(temp>0)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
//Fix tiles
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
cl.settile(
Refactor tiles to use setter and getter functions This makes it easier to add bounds checks to all accesses of ed.contents. To do this, I've added editorclass::gettile(), editorclass::settile(), and editorclass::getabstile() (with a helper function of editorclass::gettileidx() that really shouldn't be used directly), and replaced all raw accesses of ed.contents with those functions appropriately. This also makes the code more readable, as a side effect.
2021-03-24 19:26:19 +01:00
ed.levx,
ed.levy,
i,
j,
ed.edgetile(i, j) + ed.base(ed.levx, ed.levy)
);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
}
break;
case 5: //The Tower
break;
case 6: //Custom Set 1
break;
case 7: //Custom Set 2
break;
case 8: //Custom Set 3
break;
case 9: //Custom Set 4
break;
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.foregrounddrawn = false;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
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
int editorclass::getenemyframe(int t)
{
switch(t)
{
case 0:
return 78;
break;
case 1:
return 88;
break;
case 2:
return 36;
break;
case 3:
return 164;
break;
case 4:
return 68;
break;
case 5:
return 48;
break;
case 6:
return 176;
break;
case 7:
return 168;
break;
case 8:
return 112;
break;
case 9:
return 114;
break;
default:
return 78;
break;
}
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
void editorclass::settile( int x, int y, int t )
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
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if (x >= 0 && y >= 0 && x < 40 && y < 30)
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
{
cl.settile(levx, levy, x, y, t);
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
graphics.foregrounddrawn = false;
updatetiles = true;
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
}
int editorclass::base( int x, int y )
{
//Return the base tile for the given tileset and colour
Rename edlevelclass to RoomProperty That's what edlevelclass is... so that's what it should be named. (Also removes that "ed", too, making this less coupled to the in-game editor.) Unfortunately, for compatibility reasons, the name of the XML element will still remain the same.
2021-02-21 00:45:48 +01:00
const RoomProperty* const room = cl.getroomprop(x, y);
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
if(room->tileset==0) //Space Station
{
if(room->tilecol>=22)
{
return 483 + ((room->tilecol-22)*3);
}
else if(room->tilecol>=11)
{
return 283 + ((room->tilecol-11)*3);
}
else
{
return 83 + (room->tilecol*3);
}
}
else if(room->tileset==1) //Outside
{
return 480 + (room->tilecol*3);
}
else if(room->tileset==2) //Lab
{
return 280 + (room->tilecol*3);
}
else if(room->tileset==3) //Warp Zone/Intermission
{
return 80 + (room->tilecol*3);
}
else if(room->tileset==4) //SHIP
{
return 101 + (room->tilecol*3);
}
return 0;
}
int editorclass::backbase( int x, int y )
{
//Return the base tile for the background of the given tileset and colour
Rename edlevelclass to RoomProperty That's what edlevelclass is... so that's what it should be named. (Also removes that "ed", too, making this less coupled to the in-game editor.) Unfortunately, for compatibility reasons, the name of the XML element will still remain the same.
2021-02-21 00:45:48 +01:00
const RoomProperty* const room = cl.getroomprop(x, y);
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
if(room->tileset==0) //Space Station
{
//Pick depending on tilecol
switch(room->tilecol)
{
case 0:
case 5:
case 26:
return 680; //Blue
break;
case 3:
case 16:
case 23:
return 683; //Yellow
break;
case 9:
case 12:
case 21:
return 686; //Greeny Cyan
break;
case 4:
case 8:
case 24:
case 28:
case 30:
return 689; //Green
break;
case 20:
case 29:
return 692; //Orange
break;
case 2:
case 6:
case 11:
case 22:
case 27:
return 695; //Red
break;
case 1:
case 10:
case 15:
case 19:
case 31:
return 698; //Pink
break;
case 14:
case 18:
return 701; //Dark Blue
break;
case 7:
case 13:
case 17:
case 25:
return 704; //Cyan
break;
default:
return 680;
break;
}
}
else if(room->tileset==1) //outside
{
return 680 + (room->tilecol*3);
}
else if(room->tileset==2) //Lab
{
return 0;
}
else if(room->tileset==3) //Warp Zone/Intermission
{
return 120 + (room->tilecol*3);
}
else if(room->tileset==4) //SHIP
{
return 741 + (room->tilecol*3);
}
return 0;
}
int editorclass::at( int x, int y )
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
x = SDL_max(0, SDL_min(x, 39));
y = SDL_max(0, SDL_min(y, 29));
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
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
return cl.gettile(levx, levy, x, y);
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
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
int editorclass::tile_type_wrap(int x, int y)
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
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
x = POS_MOD(x, cl.mapwidth * 40);
y = POS_MOD(y, cl.mapheight * 30);
const RoomProperty* const room = cl.getroomprop(x / 40, y / 30);
int tile = cl.getabstile(x, y);
if (tile == 1 || (tile >= 80 && tile <= 679))
{
// It's solid.
return TileType_SOLID;
}
if ((tile >= 6 && tile <= 9) || tile == 49 || tile == 50)
{
// It's a spike!
return TileType_SPIKE;
}
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
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if (room->tileset != 0)
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
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// tiles2.png is slightly different.
if (tile >= 51 && tile <= 74)
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
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// It has more spikes!
return TileType_SPIKE;
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
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if (tile == 740)
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
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// And a stray solid.
return TileType_SOLID;
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
}
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
return TileType_NONSOLID;
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
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
int editorclass::backonlyfree(int x, int y)
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
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
// Returns 1 if tile is a background tile, 0 otherwise
if (x < 0) return backonlyfree(0, y);
if (y < 0) return backonlyfree(x, 0);
if (x >= 40) return backonlyfree(39, y);
if (y >= 30) return backonlyfree(x, 29);
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
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if (x >= 0 && y >= 0 && x < 40 && y < 30)
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
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if (cl.gettile(levx, levy, x, y) >= 680)
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
{
return 1;
}
}
return 0;
}
int editorclass::backfree( int x, int y )
{
//Returns 0 if tile is not a block or background tile, 1 otherwise
if(x<0) return backfree(0,y);
if(y<0) return backfree(x,0);
if(x>=40) return backfree(39,y);
if(y>=30) return backfree(x,29);
if(x>=0 && y>=0 && x<40 && y<30)
{
if(cl.gettile(levx, levy, x, y)==0)
{
return 0;
}
}
return 1;
}
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
int editorclass::spikefree(int x, int y)
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
{
//Returns 0 if tile is not a block or spike, 1 otherwise
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if (x == -1) return free(0, y);
if (y == -1) return free(x, 0);
if (x == 40) return free(39, y);
if (y == 30) return free(x, 29);
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
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if (x >= 0 && y >= 0 && x < 40 && y < 30)
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
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if (cl.gettile(levx, levy, x, y) == 0)
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
{
return 0;
}
else
{
Cleanup tools & main rendering Tools were a mess, spread all over the code with hundreds of `else-if` statements. Instead of magic numbers denoting tools, an enum has been created, and logic has been extracted into simple switch/cases, shared logic being deduplicated. The base of a state system for the editor has been created as well, laying a good path for further organization improvements. Because of this, the entire editor no longer gets drawn underneath the menus, except for a few pieces which I haven't extracted yet. Either way, this should be good for performance, if that was a concern.
2023-03-02 07:45:22 +01:00
if (cl.gettile(levx, levy, x, y) >= 680)
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
{
return 0;
}
}
}
return 1;
}
int editorclass::free( int x, int y )
{
//Returns 0 if tile is not a block, 1 otherwise
if(x==-1) return free(0,y);
if(y==-1) return free(x,0);
if(x==40) return free(39,y);
if(y==30) return free(x,29);
if(x>=0 && y>=0 && x<40 && y<30)
{
if(cl.gettile(levx, levy, x, y)==0)
{
return 0;
}
else
{
if(cl.gettile(levx, levy, x, y)>=2 && cl.gettile(levx, levy, x, y)<80)
{
return 0;
}
if(cl.gettile(levx, levy, x, y)>=680)
{
return 0;
}
}
}
return 1;
}
int editorclass::match( int x, int y )
{
if(free(x-1,y)==0 && free(x,y-1)==0 && free(x+1,y)==0 && free(x,y+1)==0) return 0;
if(free(x-1,y)==0 && free(x,y-1)==0) return 10;
if(free(x+1,y)==0 && free(x,y-1)==0) return 11;
if(free(x-1,y)==0 && free(x,y+1)==0) return 12;
if(free(x+1,y)==0 && free(x,y+1)==0) return 13;
if(free(x,y-1)==0) return 1;
if(free(x-1,y)==0) return 2;
if(free(x,y+1)==0) return 3;
if(free(x+1,y)==0) return 4;
if(free(x-1,y-1)==0) return 5;
if(free(x+1,y-1)==0) return 6;
if(free(x-1,y+1)==0) return 7;
if(free(x+1,y+1)==0) return 8;
return 0;
}
int editorclass::outsidematch( int x, int y )
{
if(backonlyfree(x-1,y)==0 && backonlyfree(x+1,y)==0) return 2;
if(backonlyfree(x,y-1)==0 && backonlyfree(x,y+1)==0) return 1;
return 0;
}
int editorclass::backmatch( int x, int y )
{
//Returns the first position match for a border
// 5 1 6
// 2 X 4
// 7 3 8
if(backfree(x-1,y)==0 && backfree(x,y-1)==0 && backfree(x+1,y)==0 && backfree(x,y+1)==0) return 0;
if(backfree(x-1,y)==0 && backfree(x,y-1)==0) return 10;
if(backfree(x+1,y)==0 && backfree(x,y-1)==0) return 11;
if(backfree(x-1,y)==0 && backfree(x,y+1)==0) return 12;
if(backfree(x+1,y)==0 && backfree(x,y+1)==0) return 13;
if(backfree(x,y-1)==0) return 1;
if(backfree(x-1,y)==0) return 2;
if(backfree(x,y+1)==0) return 3;
if(backfree(x+1,y)==0) return 4;
if(backfree(x-1,y-1)==0) return 5;
if(backfree(x+1,y-1)==0) return 6;
if(backfree(x-1,y+1)==0) return 7;
if(backfree(x+1,y+1)==0) return 8;
return 0;
}
int editorclass::edgetile( int x, int y )
{
switch(match(x,y))
{
case 14:
return 0;
break;
case 10:
return 80;
break;
case 11:
return 82;
break;
case 12:
return 160;
break;
case 13:
return 162;
break;
case 1:
return 81;
break;
case 2:
return 120;
break;
case 3:
return 161;
break;
case 4:
return 122;
break;
case 5:
return 42;
break;
case 6:
return 41;
break;
case 7:
return 2;
break;
case 8:
return 1;
break;
case 0:
default:
return 0;
break;
}
}
int editorclass::outsideedgetile( int x, int y )
{
switch(outsidematch(x,y))
{
case 2:
return 0;
break;
case 1:
return 1;
break;
case 0:
default:
return 2;
break;
}
}
int editorclass::backedgetile( int x, int y )
{
switch(backmatch(x,y))
{
case 14:
return 0;
break;
case 10:
return 80;
break;
case 11:
return 82;
break;
case 12:
return 160;
break;
case 13:
return 162;
break;
case 1:
return 81;
break;
case 2:
return 120;
break;
case 3:
return 161;
break;
case 4:
return 122;
break;
case 5:
return 42;
break;
case 6:
return 41;
break;
case 7:
return 2;
break;
case 8:
return 1;
break;
case 0:
default:
return 0;
break;
}
}
int editorclass::labspikedir( int x, int y, int t )
{
// a slightly more tricky case
if(free(x,y+1)==1) return 63 + (t*2);
if(free(x,y-1)==1) return 64 + (t*2);
if(free(x-1,y)==1) return 51 + (t*2);
if(free(x+1,y)==1) return 52 + (t*2);
return 63 + (t*2);
}
int editorclass::spikedir( int x, int y )
{
if(free(x,y+1)==1) return 8;
if(free(x,y-1)==1) return 9;
if(free(x-1,y)==1) return 49;
if(free(x+1,y)==1) return 50;
return 8;
}
void editorclass::switch_tileset(const bool reversed)
{
const char* tilesets[] = {"Space Station", "Outside", "Lab", "Warp Zone", "Ship"};
int tiles = cl.getroomprop(levx, levy)->tileset;
if (reversed)
{
tiles--;
}
else
{
tiles++;
}
const int modulus = SDL_arraysize(tilesets);
Add `POS_MOD` macro and use for all positive modulos This macro is to make it so it won't be error-prone to write the semi-confusing `(a % b + b) % b` statement, and you can just use an easy macro instead. Currently, the only places a positive modulo is needed is when switching tilesets, enemies, and warp directions in the editor, as well as when getting a tile in the tower, since towers just repeat themselves vertically. Towers used this weird while-loop to sort of emulate a modulo, which isn't half-bad, but is unnecessary, and I don't think any compiler would recognize it as a modulo. (And if it's not optimized to a proper modulo... what happens if the number being moduloed is really, really big?)
2021-09-25 02:48:15 +02:00
tiles = POS_MOD(tiles, modulus);
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
cl.setroomtileset(levx, levy, tiles);
clamp_tilecol(levx, levy, false);
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
char buffer[3*SCREEN_WIDTH_CHARS + 1];
vformat_buf(
buffer, sizeof(buffer),
loc::gettext("Now using {area} Tileset"),
"area:str",
loc::gettext(tilesets[tiles])
);
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
note = buffer;
notedelay = 45;
updatetiles = true;
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.backgrounddrawn = false;
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
}
void editorclass::switch_tilecol(const bool reversed)
{
int tilecol = cl.getroomprop(levx, levy)->tilecol;
if (reversed)
{
tilecol--;
}
else
{
tilecol++;
}
cl.setroomtilecol(levx, levy, tilecol);
clamp_tilecol(levx, levy, true);
notedelay = 45;
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
note = loc::gettext("Tileset Colour Changed");
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
updatetiles = true;
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.backgrounddrawn = false;
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
}
void editorclass::clamp_tilecol(const int rx, const int ry, const bool wrap)
{
Rename edlevelclass to RoomProperty That's what edlevelclass is... so that's what it should be named. (Also removes that "ed", too, making this less coupled to the in-game editor.) Unfortunately, for compatibility reasons, the name of the XML element will still remain the same.
2021-02-21 00:45:48 +01:00
const RoomProperty* const room = cl.getroomprop(rx, ry);
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
const int tileset = room->tileset;
int tilecol = room->tilecol;
int mincol = -1;
int maxcol = 5;
// Only Space Station allows tileset -1
if (tileset != 0)
{
mincol = 0;
}
switch (tileset)
{
case 0:
maxcol = 31;
break;
case 1:
maxcol = 7;
break;
Fix regression with rainbow lab BG in editor 731fb89c901891b021c899c5fbbc123e267c3516 was partially reverted by #624 because of my bad rebase.
2021-10-29 02:27:13 +02:00
case 2:
if (room->directmode)
{
maxcol = 6;
}
break;
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
case 3:
maxcol = 6;
break;
case 5:
maxcol = 29;
break;
}
// If wrap is true, wrap-around, otherwise just cap
if (tilecol > maxcol)
{
tilecol = (wrap ? mincol : maxcol);
}
if (tilecol < mincol)
{
tilecol = (wrap ? maxcol : mincol);
}
cl.setroomtilecol(rx, ry, tilecol);
}
void editorclass::switch_enemy(const bool reversed)
{
Rename edlevelclass to RoomProperty That's what edlevelclass is... so that's what it should be named. (Also removes that "ed", too, making this less coupled to the in-game editor.) Unfortunately, for compatibility reasons, the name of the XML element will still remain the same.
2021-02-21 00:45:48 +01:00
const RoomProperty* const room = cl.getroomprop(levx, levy);
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
int enemy = room->enemytype;
if (reversed)
{
enemy--;
}
else
{
enemy++;
}
const int modulus = 10;
Add `POS_MOD` macro and use for all positive modulos This macro is to make it so it won't be error-prone to write the semi-confusing `(a % b + b) % b` statement, and you can just use an easy macro instead. Currently, the only places a positive modulo is needed is when switching tilesets, enemies, and warp directions in the editor, as well as when getting a tile in the tower, since towers just repeat themselves vertically. Towers used this weird while-loop to sort of emulate a modulo, which isn't half-bad, but is unnecessary, and I don't think any compiler would recognize it as a modulo. (And if it's not optimized to a proper modulo... what happens if the number being moduloed is really, really big?)
2021-09-25 02:48:15 +02:00
enemy = POS_MOD(enemy, modulus);
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
cl.setroomenemytype(levx, levy, enemy);
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
note = loc::gettext("Enemy Type Changed");
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
notedelay = 45;
}
void editorclass::switch_warpdir(const bool reversed)
{
static const int modulus = 4;
Rename edlevelclass to RoomProperty That's what edlevelclass is... so that's what it should be named. (Also removes that "ed", too, making this less coupled to the in-game editor.) Unfortunately, for compatibility reasons, the name of the XML element will still remain the same.
2021-02-21 00:45:48 +01:00
const RoomProperty* const room = cl.getroomprop(levx, levy);
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
int warpdir = room->warpdir;
if (reversed)
{
--warpdir;
}
else
{
++warpdir;
}
Add `POS_MOD` macro and use for all positive modulos This macro is to make it so it won't be error-prone to write the semi-confusing `(a % b + b) % b` statement, and you can just use an easy macro instead. Currently, the only places a positive modulo is needed is when switching tilesets, enemies, and warp directions in the editor, as well as when getting a tile in the tower, since towers just repeat themselves vertically. Towers used this weird while-loop to sort of emulate a modulo, which isn't half-bad, but is unnecessary, and I don't think any compiler would recognize it as a modulo. (And if it's not optimized to a proper modulo... what happens if the number being moduloed is really, really big?)
2021-09-25 02:48:15 +02:00
warpdir = POS_MOD(warpdir, modulus);
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
cl.setroomwarpdir(levx, levy, warpdir);
switch (warpdir)
{
default:
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
note = loc::gettext("Room warping disabled");
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
break;
case 1:
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
note = loc::gettext("Room warps horizontally");
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
break;
case 2:
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
note = loc::gettext("Room warps vertically");
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
break;
case 3:
Editor.cpp: make remaining strings translatable The affected functions are: - editormenuactionpress - editorinput - editorclass::switch_tileset - editorclass::switch_tilecol - editorclass::switch_enemy - editorclass::switch_warpdir This mainly adds loc::gettext calls. 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 23:23:29 +01:00
note = loc::gettext("Room warps in all directions");
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
break;
}
notedelay = 45;
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.backgrounddrawn = false;
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
}
Move editor functions to separate file This moves editorrenderfixed(), editorrender(), editorinput(), editorlogic(), and their associated functions to a new file named Editor.cpp - which is exactly what it says on the tin; it stores all the functions related to the actual in-game editor loop. Also, the existing editor.cpp has been renamed to CustomLevels.cpp.
2021-02-20 05:51:25 +01:00
#endif /* NO_CUSTOM_LEVELS and NO_EDITOR */
Reference in New Issue Copy Permalink