zv0n/game
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Mario Editor: add tool highlighting + WSAD controls

Browse Source
This commit is contained in:
zv0n 2021-05-29 19:17:45 +02:00
parent 3cb36fe180
commit 58974f8a7e
3 changed files with 159 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

190
mario/editor.cpp
View File

@ -80,6 +80,9 @@ struct GlobalVars {
std::vector< std::shared_ptr< SDLPP::RenderObject > > tools; std::vector< std::shared_ptr< SDLPP::RenderObject > > tools;
std::vector< std::shared_ptr< SDLPP::RenderObject > > mods; std::vector< std::shared_ptr< SDLPP::RenderObject > > mods;
std::vector< std::shared_ptr< SDLPP::RenderObject > > characters; std::vector< std::shared_ptr< SDLPP::RenderObject > > characters;
std::vector< std::shared_ptr< SDLPP::RenderObject > > tool_boxes;
std::vector< std::shared_ptr< SDLPP::RenderObject > > mod_boxes;
std::vector< std::shared_ptr< SDLPP::RenderObject > > character_boxes;
std::shared_ptr< SDLPP::RenderObject > current_tool; std::shared_ptr< SDLPP::RenderObject > current_tool;
std::shared_ptr< SDLPP::Texture > translucent_terrain_texture; std::shared_ptr< SDLPP::Texture > translucent_terrain_texture;
std::shared_ptr< SDLPP::Texture > translucent_mario_texture; std::shared_ptr< SDLPP::Texture > translucent_mario_texture;
@ -142,29 +145,60 @@ void removeMario() {
global_vars.mario->destroy(); global_vars.mario->destroy();
} }
void setToolColor(const std::string &color) {
std::vector<std::shared_ptr<SDLPP::RenderObject>> *store;
int multiplier = 0;
switch(global_vars.tool.type) {
case ToolType::BLOCK:
multiplier = TOOLS_WIDTH;
store = &global_vars.tool_boxes;
break;
case ToolType::MOD:
multiplier = MOD_WIDTH;
store = &global_vars.mod_boxes;
break;
case ToolType::CHARACTER:
multiplier = CHARACTER_WIDTH;
store = &global_vars.character_boxes;
default:
break;
}
auto index = global_vars.tool.index % (2*multiplier);
store->at(index)->setColor(color);
}
void setToolColor() {
setToolColor("#FFFF8888");
}
void unsetToolColor() {
setToolColor("#FFFFFF00");
}
void updateToolSelection( int prev_index, ToolType::Value type ) { void updateToolSelection( int prev_index, ToolType::Value type ) {
size_t cur = 0; unsetToolColor();
size_t cur_page = 0;
size_t multiplier = 0; size_t multiplier = 0;
std::vector< std::shared_ptr< SDLPP::RenderObject > > *tool_vec = nullptr; std::vector< std::shared_ptr< SDLPP::RenderObject > > *tool_vec = nullptr;
switch(type) { switch(type) {
case ToolType::BLOCK: case ToolType::BLOCK:
cur = global_vars.tool.cur_page_tools; cur_page = global_vars.tool.cur_page_tools;
multiplier = 2*TOOLS_WIDTH; multiplier = 2*TOOLS_WIDTH;
tool_vec = &global_vars.tools; tool_vec = &global_vars.tools;
break; break;
case ToolType::MOD: case ToolType::MOD:
cur = global_vars.tool.cur_page_mods; cur_page = global_vars.tool.cur_page_mods;
multiplier = 2*MOD_WIDTH; multiplier = 2*MOD_WIDTH;
tool_vec = &global_vars.mods; tool_vec = &global_vars.mods;
break; break;
case ToolType::CHARACTER: case ToolType::CHARACTER:
cur = global_vars.tool.cur_page_characters; cur_page = global_vars.tool.cur_page_characters;
multiplier = 2*CHARACTER_WIDTH; multiplier = 2*CHARACTER_WIDTH;
tool_vec = &global_vars.characters; tool_vec = &global_vars.characters;
default: default:
break; break;
} }
cur *= multiplier; auto cur = cur_page * multiplier;
size_t prev = prev_index * multiplier; size_t prev = prev_index * multiplier;
for ( size_t i = prev; for ( size_t i = prev;
i < ( tool_vec->size() < prev + multiplier ? tool_vec->size() : prev + multiplier ); i < ( tool_vec->size() < prev + multiplier ? tool_vec->size() : prev + multiplier );
@ -177,6 +211,8 @@ void updateToolSelection( int prev_index, ToolType::Value type ) {
i++ ) { i++ ) {
tool_vec->at(i)->setHidden( false ); tool_vec->at(i)->setHidden( false );
} }
if(global_vars.tool.index / multiplier == cur_page)
setToolColor();
} }
void moveToolsLeft(ToolType::Value type) { void moveToolsLeft(ToolType::Value type) {
@ -215,57 +251,125 @@ void moveToolsRight(ToolType::Value type) {
} }
} }
// TODO add red outline to currently selected tool void updateToolIndex(uint64_t new_index) {
// add WSAD navigation for the red highlight
// add mouse wheel navigation
void selectPrevTool() {
int multiplier = 0; int multiplier = 0;
int *page = nullptr;
switch(global_vars.tool.type) { switch(global_vars.tool.type) {
case ToolType::BLOCK: case ToolType::BLOCK:
multiplier = 2*TOOLS_WIDTH; multiplier = 2*TOOLS_WIDTH;
page = &global_vars.tool.cur_page_tools;
break; break;
case ToolType::MOD: case ToolType::MOD:
multiplier = 2*MOD_WIDTH; multiplier = 2*MOD_WIDTH;
page = &global_vars.tool.cur_page_mods;
break; break;
case ToolType::CHARACTER: case ToolType::CHARACTER:
multiplier = 2*CHARACTER_WIDTH; multiplier = 2*CHARACTER_WIDTH;
page = &global_vars.tool.cur_page_characters;
default: default:
break; break;
} }
if ( global_vars.tool.index == 0 ) unsetToolColor();
return; global_vars.tool.index = new_index;
if ( global_vars.tool.index % multiplier == 0 ) { setToolColor();
moveToolsLeft(global_vars.tool.type);
}
global_vars.tool.index--;
updateTool(); updateTool();
if(new_index / multiplier != static_cast<uint64_t>(*page)) {
auto prev = *page;
*page = new_index / multiplier;
updateToolSelection(prev, global_vars.tool.type);
}
} }
void selectNextTool() { void selectLowerTool() {
int multiplier = 0; int multiplier = 0;
size_t max_index = 0; size_t max_index = 0;
switch(global_vars.tool.type) { switch(global_vars.tool.type) {
case ToolType::BLOCK: case ToolType::BLOCK:
multiplier = 2*TOOLS_WIDTH; multiplier = 2 * TOOLS_WIDTH;
max_index = global_vars.tools.size() - 1; max_index = global_vars.tools.size() - 1;
break; break;
case ToolType::MOD: case ToolType::MOD:
multiplier = 2*MOD_WIDTH; multiplier = 2 * MOD_WIDTH;
max_index = global_vars.mods.size() - 1; max_index = global_vars.mods.size() - 1;
break; break;
case ToolType::CHARACTER: case ToolType::CHARACTER:
multiplier = 2*CHARACTER_WIDTH; multiplier = 2 * CHARACTER_WIDTH;
max_index = global_vars.characters.size() - 1; max_index = global_vars.characters.size() - 1;
default: default:
break; break;
} }
if( global_vars.tool.index % multiplier >= static_cast<uint64_t>(multiplier/2) || global_vars.tool.index + multiplier/2 > max_index )
return;
updateToolIndex(global_vars.tool.index + multiplier/2);
}
void selectUpperTool() {
int multiplier = 0;
switch(global_vars.tool.type) {
case ToolType::BLOCK:
multiplier = 2 * TOOLS_WIDTH;
break;
case ToolType::MOD:
multiplier = 2 * MOD_WIDTH;
break;
case ToolType::CHARACTER:
multiplier = 2 * CHARACTER_WIDTH;
default:
break;
}
if( global_vars.tool.index % multiplier < static_cast<uint64_t>(multiplier/2) )
return;
updateToolIndex(global_vars.tool.index - multiplier/2);
}
void selectPrevTool() {
int multiplier = 0;
switch(global_vars.tool.type) {
case ToolType::BLOCK:
multiplier = TOOLS_WIDTH;
break;
case ToolType::MOD:
multiplier = MOD_WIDTH;
break;
case ToolType::CHARACTER:
multiplier = CHARACTER_WIDTH;
default:
break;
}
int subtraction = 1;
if ( global_vars.tool.index % multiplier == 0 )
subtraction = multiplier + 1;
if ( global_vars.tool.index == 0 || global_vars.tool.index - subtraction > static_cast<uint64_t>(-multiplier) )
return;
updateToolIndex(global_vars.tool.index - subtraction);
}
void selectNextTool() {
size_t max_index = 0;
int multiplier = 0;
switch(global_vars.tool.type) {
case ToolType::BLOCK:
max_index = global_vars.tools.size() - 1;
multiplier = TOOLS_WIDTH;
break;
case ToolType::MOD:
max_index = global_vars.mods.size() - 1;
multiplier = MOD_WIDTH;
break;
case ToolType::CHARACTER:
max_index = global_vars.characters.size() - 1;
multiplier = CHARACTER_WIDTH;
default:
break;
}
int addition = 1;
if ( global_vars.tool.index % multiplier == (multiplier - 1) )
addition = multiplier + 1;
if ( global_vars.tool.index == max_index ) if ( global_vars.tool.index == max_index )
return; return;
if ( global_vars.tool.index % multiplier == (multiplier-1) ) { if ( global_vars.tool.index + addition > max_index )
moveToolsRight(global_vars.tool.type); addition = 1;
} updateToolIndex(global_vars.tool.index + addition);
global_vars.tool.index++;
updateTool();
} }
void setFlag( uint64_t flag ) { void setFlag( uint64_t flag ) {
@ -278,6 +382,7 @@ bool getFlag( uint64_t flag ) {
return global_vars.flags & flag; return global_vars.flags & flag;
} }
// TODO add mouse wheel control for modifiers
void handleKeyUp( SDL_Keycode key, SDLPP::Scene &scene ) { void handleKeyUp( SDL_Keycode key, SDLPP::Scene &scene ) {
switch ( key ) { switch ( key ) {
case SDLK_ESCAPE: case SDLK_ESCAPE:
@ -289,6 +394,12 @@ void handleKeyUp( SDL_Keycode key, SDLPP::Scene &scene ) {
case SDLK_d: case SDLK_d:
selectNextTool(); selectNextTool();
break; break;
case SDLK_w:
selectUpperTool();
break;
case SDLK_s:
selectLowerTool();
break;
case SDLK_r: case SDLK_r:
scene.getRenderer().setRenderColiders( scene.getRenderer().setRenderColiders(
!scene.getRenderer().getRenderColiders() ); !scene.getRenderer().getRenderColiders() );
@ -509,11 +620,10 @@ void pollEvents( SDLPP::Scene &scene ) {
default: default:
break; break;
} }
global_vars.tool.type = global_vars.mouse.tool_type;
size_t index = tool_box.getY() * (multiplier/2) + tool_box.getX(); size_t index = tool_box.getY() * (multiplier/2) + tool_box.getX();
if ( index < max_index ) { if ( index < max_index ) {
global_vars.tool.index = cur_page * multiplier + index; global_vars.tool.type = global_vars.mouse.tool_type;
updateTool(); updateToolIndex(cur_page * multiplier + index);
} }
} }
break; break;
@ -597,13 +707,12 @@ std::pair<std::shared_ptr<SDLPP::TextRenderer>, std::shared_ptr<SDLPP::TextRende
return {left, right}; return {left, right};
} }
void populateToolGrid(int count_x, int count_y, float start_x, float start_y, ToolType::Value type, const std::vector<uint64_t> &blocks, std::vector<std::shared_ptr<SDLPP::RenderObject>> &tool_store, std::shared_ptr<SDLPP::Scene> &scene) { void populateToolGrid(int count_x, int count_y, float start_x, float start_y, ToolType::Value type, const std::vector<uint64_t> &blocks, std::vector<std::shared_ptr<SDLPP::RenderObject>> &tool_store, std::vector<std::shared_ptr<SDLPP::RenderObject>> &tool_box_store, std::shared_ptr<SDLPP::Scene> &scene) {
auto renderer = scene->getRendererShared(); auto renderer = scene->getRendererShared();
for ( int i = 0; i < count_x; i++ ) { for(int j = 0; j < count_y; j++) {
for(int j = 0; j < count_y; j++) { for ( int i = 0; i < count_x; i++ ) {
auto tool_box = std::make_shared< ToolBox >( i, j, auto tool_box = std::make_shared< ToolBox >( i, j,
start_x, start_y, renderer ); start_x, start_y, renderer, false );
tool_box->setType(type);
scene->addObject( tool_box ); scene->addObject( tool_box );
} }
} }
@ -629,6 +738,16 @@ void populateToolGrid(int count_x, int count_y, float start_x, float start_y, To
scene->addObject( tool_store.back() ); scene->addObject( tool_store.back() );
tool_index = ( tool_index + 1 ) % (2*count_x); tool_index = ( tool_index + 1 ) % (2*count_x);
} }
for(int j = 0; j < count_y; j++) {
for ( int i = 0; i < count_x; i++ ) {
auto tool_box = std::make_shared< ToolBox >( i, j,
start_x, start_y, renderer );
tool_box->setType(type);
scene->addObject( tool_box );
tool_box->setColor("#00000000");
tool_box_store.push_back(tool_box);
}
}
} }
void checkArrowsEnabled( uint64_t cur_page, uint64_t max_page, uint64_t left_flag, uint64_t right_flag, std::shared_ptr<SDLPP::TextRenderer> &left_arrow, std::shared_ptr<SDLPP::TextRenderer> &right_arrow, std::shared_ptr<SDLPP::Font> &font, bool map = false ) { void checkArrowsEnabled( uint64_t cur_page, uint64_t max_page, uint64_t left_flag, uint64_t right_flag, std::shared_ptr<SDLPP::TextRenderer> &left_arrow, std::shared_ptr<SDLPP::TextRenderer> &right_arrow, std::shared_ptr<SDLPP::Font> &font, bool map = false ) {
@ -718,19 +837,19 @@ int main() {
} }
// tools // tools
populateToolGrid(TOOLS_WIDTH, 2, (MAP_WIDTH - TOOLS_WIDTH) * BLOCK_SIZE, BLOCK_SIZE, ToolType::BLOCK, possibleBlocks, global_vars.tools, scene); populateToolGrid(TOOLS_WIDTH, 2, (MAP_WIDTH - TOOLS_WIDTH) * BLOCK_SIZE, BLOCK_SIZE, ToolType::BLOCK, possibleBlocks, global_vars.tools, global_vars.tool_boxes, scene);
arrows = createArrowControls((MAP_WIDTH - TOOLS_WIDTH - 1) * BLOCK_SIZE, MAP_WIDTH * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, EDITOR_LEFT_TOOL_ID, EDITOR_RIGHT_TOOL_ID, scene, font_config); arrows = createArrowControls((MAP_WIDTH - TOOLS_WIDTH - 1) * BLOCK_SIZE, MAP_WIDTH * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, EDITOR_LEFT_TOOL_ID, EDITOR_RIGHT_TOOL_ID, scene, font_config);
auto left_tool_arrow = arrows.first; auto left_tool_arrow = arrows.first;
auto right_tool_arrow = arrows.second; auto right_tool_arrow = arrows.second;
createGrid(( MAP_WIDTH - TOOLS_WIDTH ) * BLOCK_SIZE, BLOCK_SIZE, TOOLS_WIDTH, 2, scene); createGrid(( MAP_WIDTH - TOOLS_WIDTH ) * BLOCK_SIZE, BLOCK_SIZE, TOOLS_WIDTH, 2, scene);
// mods // mods
populateToolGrid(MOD_WIDTH, 2, 2 * BLOCK_SIZE, BLOCK_SIZE, ToolType::MOD, possibleMods, global_vars.mods, scene); populateToolGrid(MOD_WIDTH, 2, 2 * BLOCK_SIZE, BLOCK_SIZE, ToolType::MOD, possibleMods, global_vars.mods, global_vars.mod_boxes, scene);
arrows = createArrowControls(BLOCK_SIZE, (MOD_WIDTH + 2) * BLOCK_SIZE, BLOCK_SIZE, 2*BLOCK_SIZE, EDITOR_LEFT_MOD_ID, EDITOR_RIGHT_MOD_ID, scene, font_config); arrows = createArrowControls(BLOCK_SIZE, (MOD_WIDTH + 2) * BLOCK_SIZE, BLOCK_SIZE, 2*BLOCK_SIZE, EDITOR_LEFT_MOD_ID, EDITOR_RIGHT_MOD_ID, scene, font_config);
auto left_mod_arrow = arrows.first; auto left_mod_arrow = arrows.first;
auto right_mod_arrow = arrows.second; auto right_mod_arrow = arrows.second;
createGrid(2*BLOCK_SIZE, BLOCK_SIZE, MOD_WIDTH, 2, scene); createGrid(2*BLOCK_SIZE, BLOCK_SIZE, MOD_WIDTH, 2, scene);
// characters // characters
populateToolGrid(CHARACTER_WIDTH, 2, (MOD_WIDTH+5) * BLOCK_SIZE, BLOCK_SIZE, ToolType::CHARACTER, possibleCharacters, global_vars.characters, scene); populateToolGrid(CHARACTER_WIDTH, 2, (MOD_WIDTH+5) * BLOCK_SIZE, BLOCK_SIZE, ToolType::CHARACTER, possibleCharacters, global_vars.characters, global_vars.character_boxes, scene);
arrows = createArrowControls((MOD_WIDTH + 4) * BLOCK_SIZE, (MOD_WIDTH + 5 + CHARACTER_WIDTH) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, EDITOR_LEFT_CHARACTER_ID, EDITOR_RIGHT_CHARACTER_ID, scene, font_config); arrows = createArrowControls((MOD_WIDTH + 4) * BLOCK_SIZE, (MOD_WIDTH + 5 + CHARACTER_WIDTH) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, EDITOR_LEFT_CHARACTER_ID, EDITOR_RIGHT_CHARACTER_ID, scene, font_config);
auto left_char_arrow = arrows.first; auto left_char_arrow = arrows.first;
auto right_char_arrow = arrows.second; auto right_char_arrow = arrows.second;
@ -777,6 +896,7 @@ int main() {
updateToolSelection( 0, ToolType::BLOCK ); updateToolSelection( 0, ToolType::BLOCK );
updateToolSelection( 0, ToolType::MOD ); updateToolSelection( 0, ToolType::MOD );
updateToolSelection( 0, ToolType::CHARACTER ); updateToolSelection( 0, ToolType::CHARACTER );
setToolColor();
auto base = SDL_GetTicks(); auto base = SDL_GetTicks();
int frames = 0; int frames = 0;

5
mario/tool_box.cpp
View File

@ -3,7 +3,7 @@
#include "blocks.hpp" #include "blocks.hpp"
#include "sprites.hpp" #include "sprites.hpp"
ToolBox::ToolBox(int x, int y, double start_x, double start_y, std::shared_ptr<SDLPP::Renderer> renderer) : SDLPP::RectangleRender(start_x + x*BLOCK_SIZE, start_y + y*BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, renderer) { ToolBox::ToolBox(int x, int y, double start_x, double start_y, std::shared_ptr<SDLPP::Renderer> renderer, bool coliders) : SDLPP::RectangleRender(start_x + x*BLOCK_SIZE, start_y + y*BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, renderer) {
_x = x; _x = x;
_y = y; _y = y;
setId(EDITOR_TOOL_ID); setId(EDITOR_TOOL_ID);
@ -11,7 +11,8 @@ ToolBox::ToolBox(int x, int y, double start_x, double start_y, std::shared_ptr<S
setColor("#FFFFFF88"); setColor("#FFFFFF88");
setPermanent(); setPermanent();
setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
addCollision(SDLPP::RectColider(0,0,1,1)); if(coliders)
addCollision(SDLPP::RectColider(0,0,1,1));
} }
SDLPP::Vec2D<int> ToolBox::getIndexes() const { SDLPP::Vec2D<int> ToolBox::getIndexes() const {

2
mario/tool_box.hpp
View File

@ -5,7 +5,7 @@
class ToolBox : public SDLPP::RectangleRender { class ToolBox : public SDLPP::RectangleRender {
public: public:
ToolBox(int x, int y, double start_x, double start_y, std::shared_ptr<SDLPP::Renderer> renderer); ToolBox(int x, int y, double start_x, double start_y, std::shared_ptr<SDLPP::Renderer> renderer, bool coliders = true);
virtual SDLPP::Vec2D<int> getIndexes() const; virtual SDLPP::Vec2D<int> getIndexes() const;
virtual void visit( SDLPP::Visitor &visitor ) override; virtual void visit( SDLPP::Visitor &visitor ) override;
uint64_t getType() const { uint64_t getType() const {