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

Remove redundant functions from blocks.cpp, fix editor problem with pagination

Browse Source
This commit is contained in:
zvon 2021-07-24 19:59:25 +02:00
parent 3be728843a
commit d638108223
8 changed files with 113 additions and 381 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
mario/Makefile
View File

@ -18,7 +18,7 @@ LDFLAGS ?= -lSDL2 -lSDL2_image -lSDL2_gfx -lSDL2_ttf -pthread
OUTPUTFLAG = -o OUTPUTFLAG = -o
endif endif
COMMON_OBJECTS = global_vars.${OBJEXT} sprites.${OBJEXT} maploader.${OBJEXT} mapobject.${OBJEXT} coinblock.${OBJEXT} simpleblocks.${OBJEXT} mario.${OBJEXT} COMMON_OBJECTS = global_vars.${OBJEXT} sprites.${OBJEXT} maploader.${OBJEXT} mapobject.${OBJEXT} coineditorblock.${OBJEXT} simpleblocks.${OBJEXT} mario.${OBJEXT}
ifneq ($(UNAME_S),Windows) ifneq ($(UNAME_S),Windows)
COMMON_OBJECTS += libsdlpp.a COMMON_OBJECTS += libsdlpp.a
endif endif
@ -69,7 +69,7 @@ tool_box.${OBJEXT}: tool_box.cpp ../sdlpp/sdlpp.hpp sprites.hpp tool_box.hpp
$(CXX) $(CXXFLAGS) -c ${OUTPUTFLAG}$@ $< $(CXX) $(CXXFLAGS) -c ${OUTPUTFLAG}$@ $<
editor_visitor.${OBJEXT}: editor_visitor.cpp ../sdlpp/sdlpp.hpp sprites.hpp editor_visitor.hpp editor_visitor.${OBJEXT}: editor_visitor.cpp ../sdlpp/sdlpp.hpp sprites.hpp editor_visitor.hpp
$(CXX) $(CXXFLAGS) -c ${OUTPUTFLAG}$@ $< $(CXX) $(CXXFLAGS) -c ${OUTPUTFLAG}$@ $<
coinblock.${OBJEXT}: blocks/coinblock.cpp ../sdlpp/sdlpp.hpp sprites.hpp global_vars.hpp blocks.hpp blocks/coinblock.hpp coineditorblock.${OBJEXT}: blocks/coineditorblock.cpp ../sdlpp/sdlpp.hpp sprites.hpp global_vars.hpp blocks.hpp blocks/coineditorblock.hpp
$(CXX) $(CXXFLAGS) -c ${OUTPUTFLAG}$@ $< $(CXX) $(CXXFLAGS) -c ${OUTPUTFLAG}$@ $<
simpleblocks.${OBJEXT}: blocks/simpleblocks.cpp ../sdlpp/sdlpp.hpp sprites.hpp global_vars.hpp blocks.hpp blocks/simpleblocks.hpp simpleblocks.${OBJEXT}: blocks/simpleblocks.cpp ../sdlpp/sdlpp.hpp sprites.hpp global_vars.hpp blocks.hpp blocks/simpleblocks.hpp
$(CXX) $(CXXFLAGS) -c ${OUTPUTFLAG}$@ $< $(CXX) $(CXXFLAGS) -c ${OUTPUTFLAG}$@ $<

194
mario/blocks.cpp
View File

@ -1,5 +1,4 @@
#include "blocks.hpp" #include "blocks.hpp"
#include "blocks/coinblock.hpp"
#include "global_vars.hpp" #include "global_vars.hpp"
#include "objectids.hpp" #include "objectids.hpp"
#include "sprites.hpp" #include "sprites.hpp"
@ -7,7 +6,7 @@
#include <unordered_map> #include <unordered_map>
#include "mario_visitor.hpp" #include "mario_visitor.hpp"
#include "blocks/simpleblocks.hpp" #include "blocks/simpleblocks.hpp"
#include "blocks/coinblock.hpp" #include "blocks/coineditorblock.hpp"
#include "mario.hpp" #include "mario.hpp"
#define CAN_BE_DESTROYED_FLAG 0x0000000000000001 #define CAN_BE_DESTROYED_FLAG 0x0000000000000001
@ -24,6 +23,7 @@ MarioBlock::MarioBlock( int x, int y,
setMovementSpeed( 1 ); setMovementSpeed( 1 );
_coins = 0; _coins = 0;
_mushroom = false; _mushroom = false;
_base_src = src;
} }
void MarioBlock::visit( SDLPP::Visitor &visitor ) { void MarioBlock::visit( SDLPP::Visitor &visitor ) {
#ifdef EDITOR #ifdef EDITOR
@ -128,7 +128,7 @@ void MarioBlock::ensureCollision() {
} }
} }
void MarioBlock::setWorldTypeSrc( LandType::Value world ) { void MarioBlock::setWorldTypeSrc( LandType::Value world ) {
auto rect = getTextureSourceRect(); auto rect = _base_src;
switch ( world ) { switch ( world ) {
case LandType::OVERWORLD: case LandType::OVERWORLD:
rect.x += OVERWORLD_SHIFT.getX(); rect.x += OVERWORLD_SHIFT.getX();
@ -226,151 +226,6 @@ const std::vector< LandType::Value > possibleLands = {
LandType::OVERWORLD, LandType::UNDERWORLD, LandType::WATER, LandType::BOWSER LandType::OVERWORLD, LandType::UNDERWORLD, LandType::WATER, LandType::BOWSER
}; };
const std::unordered_map< uint64_t, const SDL_Rect * > block_mapping = {
{ FLOOR_ID, &FLOOR_SRC },
{ HILL_INCLINE_ID, &HILL_INCLINE_SRC },
{ HILL_DECLINE_ID, &HILL_DECLINE_SRC },
{ HILL_DOTS_RIGHT_ID, &HILL_DOTS_RIGHT_SRC },
{ HILL_DOTS_LEFT_ID, &HILL_DOTS_LEFT_SRC },
{ HILL_FILL_ID, &HILL_FILL_SRC },
{ HILL_TOP_ID, &HILL_TOP_SRC },
{ BUSH_LEFT_ID, &BUSH_LEFT_SRC },
{ BUSH_MIDDLE_ID, &BUSH_MIDDLE_SRC },
{ BUSH_RIGHT_ID, &BUSH_RIGHT_SRC },
{ CLOUD_LEFT_BOTTOM_ID, &CLOUD_LEFT_BOTTOM_SRC },
{ CLOUD_MIDDLE_BOTTOM_ID, &CLOUD_MIDDLE_BOTTOM_SRC },
{ CLOUD_RIGHT_BOTTOM_ID, &CLOUD_RIGHT_BOTTOM_SRC },
{ CLOUD_LEFT_TOP_ID, &CLOUD_LEFT_TOP_SRC },
{ CLOUD_MIDDLE_TOP_ID, &CLOUD_MIDDLE_TOP_SRC },
{ CLOUD_RIGHT_TOP_ID, &CLOUD_RIGHT_TOP_SRC },
{ PIPE_LEFT_BOTTOM_ID, &PIPE_LEFT_BOTTOM_SRC },
{ PIPE_LEFT_TOP_ID, &PIPE_LEFT_TOP_SRC },
{ PIPE_RIGHT_BOTTOM_ID, &PIPE_RIGHT_BOTTOM_SRC },
{ PIPE_RIGHT_TOP_ID, &PIPE_RIGHT_TOP_SRC },
{ CASTLE_LEFT_ID, &CASTLE_LEFT_SRC },
{ CASTLE_RIGHT_ID, &CASTLE_RIGHT_SRC },
{ CASTLE_BLACK_ID, &CASTLE_BLACK_SRC },
{ CASTLE_ENTRY_ID, &CASTLE_ENTRY_SRC },
{ CASTLE_TOWER_ID, &CASTLE_TOWER_SRC },
{ CASTLE_TOWER_FILLED_ID, &CASTLE_TOWER_FILLED_SRC },
{ VINE_TOP_ID, &VINE_TOP_SRC },
{ VINE_BOTTOM_ID, &VINE_BOTTOM_SRC },
{ POLE_TOP_ID, &POLE_TOP_SRC },
{ POLE_BOTTOM_ID, &POLE_BOTTOM_SRC },
{ FLAG_ID, &FLAG_SRC },
{ STEP_ID, &STEP_SRC },
{ BRICK_ID, &BRICK_SRC },
{ BRICK_TOP_ID, &BRICK_TOP_SRC },
{ SIDEWAY_PIPE_END_TOP_ID, &SIDEWAY_PIPE_END_TOP_SRC },
{ SIDEWAY_PIPE_END_BOTTOM_ID, &SIDEWAY_PIPE_END_BOTTOM_SRC },
{ SIDEWAY_PIPE_MIDDLE_TOP_ID, &SIDEWAY_PIPE_MIDDLE_TOP_SRC },
{ SIDEWAY_PIPE_MIDDLE_BOTTOM_ID, &SIDEWAY_PIPE_MIDDLE_BOTTOM_SRC },
{ SIDEWAY_PIPE_CONNECTOR_TOP_ID, &SIDEWAY_PIPE_CONNECTOR_TOP_SRC },
{ SIDEWAY_PIPE_CONNECTOR_BOTTOM_ID, &SIDEWAY_PIPE_CONNECTOR_BOTTOM_SRC },
{ TREE_PLATFORM_TOP_LEFT_ID, &TREE_PLATFORM_TOP_LEFT_SRC },
{ TREE_PLATFORM_TOP_MIDDLE_ID, &TREE_PLATFORM_TOP_MIDDLE_SRC },
{ TREE_PLATFORM_TOP_RIGHT_ID, &TREE_PLATFORM_TOP_RIGHT_SRC },
{ TREE_PLATFORM_BARK_ID, &TREE_PLATFORM_BARK_SRC },
{ WATER_TOP_ID, &WATER_TOP_SRC },
{ WATER_FILL_ID, &WATER_FILL_SRC },
{ MUSHROOM_PLATFORM_TOP_LEFT_ID, &MUSHROOM_PLATFORM_TOP_LEFT_SRC },
{ MUSHROOM_PLATFORM_TOP_MIDDLE_ID, &MUSHROOM_PLATFORM_TOP_MIDDLE_SRC },
{ MUSHROOM_PLATFORM_TOP_RIGHT_ID, &MUSHROOM_PLATFORM_TOP_RIGHT_SRC },
{ MUSHROOM_PLATFORM_BARK_TOP_ID, &MUSHROOM_PLATFORM_BARK_TOP_SRC },
{ MUSHROOM_PLATFORM_BARK_BOTTOM_ID, &MUSHROOM_PLATFORM_BARK_BOTTOM_SRC },
{ TREE_BARK_ID, &TREE_BARK_SRC },
{ TREE_LEAVES_SMALL_ID, &TREE_LEAVES_SMALL_SRC },
{ TREE_LEAVES_TOP_ID, &TREE_LEAVES_TOP_SRC },
{ TREE_LEAVES_BOTTOM_ID, &TREE_LEAVES_BOTTOM_SRC },
{ CANNON_TOWER_ID, &CANNON_TOWER_SRC },
{ CANNON_PEDESTAL_ID, &CANNON_PEDESTAL_SRC },
{ CANNON_ID, &CANNON_SRC },
{ MARIO_ID, &MARIO_STANDING_SRC },
{ DESTRUCTIBLE_MODIFIER_ID, &MOD_DESTRUCTIBLE_SRC },
{ BACKGROUND_MODIFIER_ID, &MOD_BACKGROUND_SRC },
{ COIN_MODIFIER_ID, &MOD_COIN_SRC },
{ MUSHROOM_MODIFIER_ID, &MOD_MUSHROOM_SRC },
};
const std::unordered_map< uint64_t, uint64_t > block_flags = {
{ FLOOR_ID, CAN_BE_DESTROYED_FLAG | HAS_COLLISION },
{ HILL_INCLINE_ID, 0 },
{ HILL_DECLINE_ID, 0 },
{ HILL_DOTS_RIGHT_ID, 0 },
{ HILL_DOTS_LEFT_ID, 0 },
{ HILL_FILL_ID, 0 },
{ HILL_TOP_ID, 0 },
{ BUSH_LEFT_ID, 0 },
{ BUSH_MIDDLE_ID, 0 },
{ BUSH_RIGHT_ID, 0 },
{ CLOUD_LEFT_BOTTOM_ID, 0 },
{ CLOUD_MIDDLE_BOTTOM_ID, 0 },
{ CLOUD_RIGHT_BOTTOM_ID, 0 },
{ CLOUD_LEFT_TOP_ID, 0 },
{ CLOUD_MIDDLE_TOP_ID, 0 },
{ CLOUD_RIGHT_TOP_ID, 0 },
{ PIPE_LEFT_BOTTOM_ID, HAS_COLLISION },
{ PIPE_LEFT_TOP_ID, HAS_COLLISION },
{ PIPE_RIGHT_BOTTOM_ID, HAS_COLLISION },
{ PIPE_RIGHT_TOP_ID, HAS_COLLISION },
{ CASTLE_LEFT_ID, 0 },
{ CASTLE_RIGHT_ID, 0 },
{ CASTLE_BLACK_ID, 0 },
{ CASTLE_ENTRY_ID, 0 },
{ CASTLE_TOWER_ID, 0 },
{ CASTLE_TOWER_FILLED_ID, 0 },
{ VINE_TOP_ID, HAS_COLLISION },
{ VINE_BOTTOM_ID, HAS_COLLISION },
{ POLE_TOP_ID, HAS_COLLISION },
{ POLE_BOTTOM_ID, HAS_COLLISION },
{ FLAG_ID, 0 },
{ STEP_ID, CAN_BE_DESTROYED_FLAG | HAS_COLLISION },
{ BRICK_ID, CAN_BE_DESTROYED_FLAG | HAS_COLLISION },
{ BRICK_TOP_ID, CAN_BE_DESTROYED_FLAG | HAS_COLLISION },
{ SIDEWAY_PIPE_END_TOP_ID, HAS_COLLISION },
{ SIDEWAY_PIPE_END_BOTTOM_ID, HAS_COLLISION },
{ SIDEWAY_PIPE_MIDDLE_TOP_ID, HAS_COLLISION },
{ SIDEWAY_PIPE_MIDDLE_BOTTOM_ID, HAS_COLLISION },
{ SIDEWAY_PIPE_CONNECTOR_TOP_ID, HAS_COLLISION },
{ SIDEWAY_PIPE_CONNECTOR_BOTTOM_ID, HAS_COLLISION },
{ TREE_PLATFORM_TOP_LEFT_ID, HAS_COLLISION },
{ TREE_PLATFORM_TOP_MIDDLE_ID, HAS_COLLISION },
{ TREE_PLATFORM_TOP_RIGHT_ID, HAS_COLLISION },
{ TREE_PLATFORM_BARK_ID, HAS_COLLISION },
{ WATER_TOP_ID, HAS_COLLISION },
{ WATER_FILL_ID, HAS_COLLISION },
{ MUSHROOM_PLATFORM_TOP_LEFT_ID, HAS_COLLISION },
{ MUSHROOM_PLATFORM_TOP_MIDDLE_ID, HAS_COLLISION },
{ MUSHROOM_PLATFORM_TOP_RIGHT_ID, HAS_COLLISION },
{ MUSHROOM_PLATFORM_BARK_TOP_ID, HAS_COLLISION },
{ MUSHROOM_PLATFORM_BARK_BOTTOM_ID, HAS_COLLISION },
{ TREE_BARK_ID, HAS_COLLISION },
{ TREE_LEAVES_SMALL_ID, HAS_COLLISION },
{ TREE_LEAVES_TOP_ID, HAS_COLLISION },
{ TREE_LEAVES_BOTTOM_ID, HAS_COLLISION },
{ CANNON_TOWER_ID, HAS_COLLISION },
{ CANNON_PEDESTAL_ID, HAS_COLLISION },
{ CANNON_ID, HAS_COLLISION },
{ MARIO_ID, 0 },
{ DESTRUCTIBLE_MODIFIER_ID, 0 },
{ BACKGROUND_MODIFIER_ID, 0 },
};
bool blockCanBeDestroyed( uint64_t id ) {
auto it = block_flags.find( id );
if ( it == block_flags.end() )
return false;
return it->second & CAN_BE_DESTROYED_FLAG;
}
bool blockHasCollision( uint64_t id ) {
auto it = block_flags.find( id );
if ( it == block_flags.end() ) {
return false;
}
return it->second & HAS_COLLISION;
}
std::shared_ptr< MarioBlock > std::shared_ptr< MarioBlock >
createBlockById( uint64_t id, int x, int y, createBlockById( uint64_t id, int x, int y,
std::shared_ptr< SDLPP::Renderer > &renderer ) { std::shared_ptr< SDLPP::Renderer > &renderer ) {
@ -618,23 +473,23 @@ createBlockById( uint64_t id, int x, int y,
break; break;
case MARIO_ID: case MARIO_ID:
result = std::static_pointer_cast< MarioBlock >( result = std::static_pointer_cast< MarioBlock >(
std::make_shared<Mario>(x,y,renderer)); std::make_shared< Mario >( x, y, renderer ) );
break; break;
case DESTRUCTIBLE_MODIFIER_ID: case DESTRUCTIBLE_MODIFIER_ID:
result = std::static_pointer_cast< MarioBlock >( result = std::static_pointer_cast< MarioBlock >(
std::make_shared<DestructibleModifierBlock>(x,y,renderer)); std::make_shared< DestructibleModifierBlock >( x, y, renderer ) );
break; break;
case BACKGROUND_MODIFIER_ID: case BACKGROUND_MODIFIER_ID:
result = std::static_pointer_cast< MarioBlock >( result = std::static_pointer_cast< MarioBlock >(
std::make_shared<BackgroundModifierBlock>(x,y,renderer)); std::make_shared< BackgroundModifierBlock >( x, y, renderer ) );
break; break;
case COIN_MODIFIER_ID: case COIN_MODIFIER_ID:
result = std::static_pointer_cast< MarioBlock >( result = std::static_pointer_cast< MarioBlock >(
std::make_shared<CoinEditorBlock>(x,y,renderer)); std::make_shared< CoinEditorBlock >( x, y, renderer ) );
break; break;
case MUSHROOM_MODIFIER_ID: case MUSHROOM_MODIFIER_ID:
result = std::static_pointer_cast< MarioBlock >( result = std::static_pointer_cast< MarioBlock >(
std::make_shared<MushroomModifierBlock>(x,y,renderer)); std::make_shared< MushroomModifierBlock >( x, y, renderer ) );
break; break;
} }
return result; return result;
@ -645,13 +500,13 @@ createBlock( std::shared_ptr< SDLPP::Renderer > &renderer, int x, int y,
uint64_t id, LandType::Value land_type, bool destructible, uint64_t id, LandType::Value land_type, bool destructible,
bool editor ) { bool editor ) {
auto block = createBlockById( id, x, y, renderer ); auto block = createBlockById( id, x, y, renderer );
if(block == nullptr) { if ( block == nullptr ) {
return nullptr; return nullptr;
} }
block->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ); block->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
block->setStatic(); block->setStatic();
block->setType( land_type ); block->setType( land_type );
if(destructible) { if ( destructible ) {
block->setDestructible(); block->setDestructible();
} }
if ( editor ) { if ( editor ) {
@ -660,31 +515,6 @@ createBlock( std::shared_ptr< SDLPP::Renderer > &renderer, int x, int y,
return block; return block;
} }
SDL_Rect getSourceRectByID( uint64_t id, LandType::Value type ) {
auto mapping = block_mapping.find( id );
if ( mapping == block_mapping.end() )
return {};
SDL_Rect ret_src = *mapping->second;
switch ( type ) {
case LandType::OVERWORLD:
ret_src.x += OVERWORLD_SHIFT.getX();
ret_src.y += OVERWORLD_SHIFT.getY();
break;
case LandType::UNDERWORLD:
ret_src.x += UNDERWORLD_SHIFT.getX();
ret_src.y += UNDERWORLD_SHIFT.getY();
break;
case LandType::WATER:
ret_src.x += WATER_SHIFT.getX();
ret_src.y += WATER_SHIFT.getY();
break;
case LandType::BOWSER:
ret_src.x += BOWSER_SHIFT.getX();
ret_src.y += BOWSER_SHIFT.getY();
break;
}
return ret_src;
}
// TODO coin count // TODO coin count
std::shared_ptr< MarioBlock > std::shared_ptr< MarioBlock >
createTerrainBlock( uint64_t block_id, LandType::Value type, createTerrainBlock( uint64_t block_id, LandType::Value type,
@ -705,8 +535,8 @@ std::shared_ptr< MarioBlock >
createMario( LandType::Value type, std::shared_ptr< SDLPP::Renderer > &renderer, createMario( LandType::Value type, std::shared_ptr< SDLPP::Renderer > &renderer,
int x, int y, bool editor ) { int x, int y, bool editor ) {
// TODO add type additions // TODO add type additions
auto mario = createBlock(renderer, x, y, MARIO_ID, type, false, true); auto mario = createBlock( renderer, x, y, MARIO_ID, type, false, true );
if(editor) { if ( editor ) {
mario->setTerrain( false ); mario->setTerrain( false );
mario->removeCollisions(); mario->removeCollisions();
mario->ensureCollision(); mario->ensureCollision();

28
mario/blocks.hpp
View File

@ -2,7 +2,6 @@
#define BLOCKS_H #define BLOCKS_H
#include "../sdlpp/sdlpp_rectrenderer.hpp" #include "../sdlpp/sdlpp_rectrenderer.hpp"
#include "../sdlpp/sdlpp_fontconfiguration.hpp"
#include <memory> #include <memory>
struct LandType { struct LandType {
@ -11,25 +10,29 @@ struct LandType {
class MarioBlock : public SDLPP::RectangleRender { class MarioBlock : public SDLPP::RectangleRender {
public: public:
MarioBlock( int x, int y, const std::shared_ptr< SDLPP::Renderer > &renderer, MarioBlock( int x, int y,
std::shared_ptr< SDLPP::Texture > texture, SDL_Rect src, bool can_be_destroyed = false, bool destructible = false ); const std::shared_ptr< SDLPP::Renderer > &renderer,
std::shared_ptr< SDLPP::Texture > texture, SDL_Rect src,
bool can_be_destroyed = false, bool destructible = false );
void visit( SDLPP::Visitor &visitor ) override; void visit( SDLPP::Visitor &visitor ) override;
void setTool( bool tool = true ); void setTool( bool tool = true );
void setTerrain( bool terrain = true ); void setTerrain( bool terrain = true );
void bounce(); void bounce();
virtual void custom_move(int ticks) override; virtual void custom_move( int ticks ) override;
void setType(LandType::Value type); void setType( LandType::Value type );
LandType::Value getType() const; LandType::Value getType() const;
virtual void onScrollUp() {} virtual void onScrollUp() {}
virtual void onScrollDown() {} virtual void onScrollDown() {}
virtual uint8_t getData() {return 0;} virtual uint8_t getData() {
virtual void setData(uint8_t /*UNUSED*/) {} return 0;
}
virtual void setData( uint8_t /*UNUSED*/ ) {}
bool hasCoin(); bool hasCoin();
bool hasMushroom(); bool hasMushroom();
void removeCoin(); void removeCoin();
void removeMushroom(); void removeMushroom();
void setCoinCount(int coins); void setCoinCount( int coins );
void setDestructible(bool destructible = true); void setDestructible( bool destructible = true );
void ensureCollision(); void ensureCollision();
private: private:
@ -42,10 +45,11 @@ private:
bool _mushroom = false; bool _mushroom = false;
const int bounce_ticks = 100; const int bounce_ticks = 100;
int ticks_to_bounce = bounce_ticks; int ticks_to_bounce = bounce_ticks;
SDLPP::Vec2D<double> og_pos = {}; SDLPP::Vec2D< double > og_pos = {};
LandType::Value _type; LandType::Value _type;
SDL_Rect _base_src;
virtual void setWorldTypeSrc(LandType::Value world); virtual void setWorldTypeSrc( LandType::Value world );
}; };
extern const std::vector< uint64_t > possibleBlocks; extern const std::vector< uint64_t > possibleBlocks;
@ -76,6 +80,4 @@ createMario( LandType::Value type, std::shared_ptr< SDLPP::Renderer > &renderer,
enum BlockRole::Value getBlockRole( uint64_t id ); enum BlockRole::Value getBlockRole( uint64_t id );
SDL_Rect getSourceRectByID( uint64_t id, LandType::Value type );
#endif #endif

70
mario/blocks/coinblock.cpp
View File

@ -1,70 +0,0 @@
#include "coinblock.hpp"
#include "../objectids.hpp"
CoinEditorBlock::CoinEditorBlock( int x, int y, std::shared_ptr< SDLPP::Renderer > renderer ) :
MarioBlock( x, y, renderer, g_translucent_mod_texture, MOD_COIN_SRC, false, false ) {
setId(COIN_MODIFIER_ID);
auto mypos = getDoubleRect();
auto size = mypos.second.getX() / 1.5;
_amount_text = std::make_shared<SDLPP::TextRenderer>( mypos.first.getX() + mypos.second.getX() - size, mypos.first.getY() + mypos.second.getX() - size, size, size, renderer, "1", g_text_config );
setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
_amount_text->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
}
void CoinEditorBlock::render() {
MarioBlock::render();
if ( _amount_text != NULL ) {
_amount_text->render();
}
}
void CoinEditorBlock::updateSizeAndPosition() {
MarioBlock::updateSizeAndPosition();
auto block_size = getDoubleRect().second;
_amount_text->setPos( getPos() + block_size - block_size / 1.5 );
_amount_text->updateSizeAndPosition();
}
void CoinEditorBlock::addOne() {
if(_amount < 15) {
_amount++;
updateText();
}
}
void CoinEditorBlock::subtractOne() {
if(_amount > 1) {
_amount--;
updateText();
}
}
void CoinEditorBlock::setAmount(int amount) {
if(amount < 1) {
amount = 1;
} else if(amount > 15) {
amount = 15;
}
_amount = amount;
updateText();
}
void CoinEditorBlock::updateText() {
_amount_text->changeText(std::to_string(_amount));
}
void CoinEditorBlock::onScrollUp() {
addOne();
}
void CoinEditorBlock::onScrollDown() {
subtractOne();
}
uint8_t CoinEditorBlock::getData() {
return _amount;
}
void CoinEditorBlock::setData(uint8_t data) {
setAmount(data);
}

27
mario/blocks/coinblock.hpp
View File

@ -1,27 +0,0 @@
#ifndef COIN_BLOCK_H
#define COIN_BLOCK_H
#include "../blocks.hpp"
#include "../global_vars.hpp"
#include "../sprites.hpp"
#include "../../sdlpp/sdlpp_textrenderer.hpp"
class CoinEditorBlock : public MarioBlock {
public:
CoinEditorBlock( int x, int y, std::shared_ptr< SDLPP::Renderer > renderer );
virtual void render() override;
virtual void updateSizeAndPosition() override;
void addOne();
void subtractOne();
void setAmount(int amount);
virtual void onScrollUp() override;
virtual void onScrollDown() override;
virtual uint8_t getData() override;
virtual void setData(uint8_t data) override;
private:
void updateText();
int _amount = 1;
std::shared_ptr<SDLPP::TextRenderer> _amount_text;
};
#endif

131
mario/editor.cpp
View File

@ -20,7 +20,7 @@
#include "edit_box.hpp" #include "edit_box.hpp"
#include "editor_visitor.hpp" #include "editor_visitor.hpp"
#include "tool_box.hpp" #include "tool_box.hpp"
#include "blocks/coinblock.hpp" #include "blocks/coineditorblock.hpp"
#define MAP_WIDTH 24 #define MAP_WIDTH 24
#define MAP_HEIGHT 16 #define MAP_HEIGHT 16
@ -66,6 +66,7 @@ struct MapInfo {
struct ToolInfo { struct ToolInfo {
ToolType::Value type; ToolType::Value type;
uint64_t index; uint64_t index;
SDL_Rect texture_src;
int cur_page_tools; int cur_page_tools;
int max_page_tools; int max_page_tools;
int cur_page_mods; int cur_page_mods;
@ -80,9 +81,9 @@ struct GlobalVars {
ToolInfo tool; ToolInfo tool;
uint64_t flags; uint64_t flags;
std::vector< mapColumnType > objects; std::vector< mapColumnType > objects;
std::vector< std::shared_ptr< SDLPP::RenderObject > > tools; std::vector< std::shared_ptr< MarioBlock > > tools;
std::vector< std::shared_ptr< SDLPP::RenderObject > > mods; std::vector< std::shared_ptr< MarioBlock > > mods;
std::vector< std::shared_ptr< SDLPP::RenderObject > > characters; std::vector< std::shared_ptr< MarioBlock > > characters;
std::vector< std::shared_ptr< SDLPP::RenderObject > > tool_boxes; 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 > > mod_boxes;
std::vector< std::shared_ptr< SDLPP::RenderObject > > character_boxes; std::vector< std::shared_ptr< SDLPP::RenderObject > > character_boxes;
@ -117,33 +118,36 @@ void updateTool() {
} }
auto tool_role = getBlockRole( tool_id ); auto tool_role = getBlockRole( tool_id );
std::shared_ptr< SDLPP::Texture > target_texture = nullptr; std::shared_ptr< SDLPP::Texture > target_texture = nullptr;
SDL_Rect target_src;
switch ( tool_role ) { switch ( tool_role ) {
case BlockRole::TERRAIN: case BlockRole::TERRAIN:
target_texture = global_vars.translucent_terrain_texture; target_texture = global_vars.translucent_terrain_texture;
target_src = global_vars.tools[global_vars.tool.index]->getTextureSourceRect();
break; break;
case BlockRole::MARIO: case BlockRole::MARIO:
target_texture = global_vars.translucent_mario_texture; target_texture = global_vars.translucent_mario_texture;
target_src = global_vars.characters[global_vars.tool.index]->getTextureSourceRect();
break; break;
case BlockRole::MODIFIER: case BlockRole::MODIFIER:
target_texture = global_vars.translucent_mod_texture; target_texture = global_vars.translucent_mod_texture;
target_src = global_vars.mods[global_vars.tool.index]->getTextureSourceRect();
break; break;
case BlockRole::CHARACTER: case BlockRole::CHARACTER:
target_src = global_vars.characters[global_vars.tool.index]->getTextureSourceRect();
break; break;
} }
global_vars.current_tool->setHidden(true); global_vars.current_tool->setHidden( true );
if(tool_id == COIN_MODIFIER_ID) { if ( tool_id == COIN_MODIFIER_ID ) {
global_vars.coin_tool->setPos(global_vars.current_tool->getPos()); global_vars.coin_tool->setPos( global_vars.current_tool->getPos() );
global_vars.current_tool = global_vars.coin_tool; global_vars.current_tool = global_vars.coin_tool;
} else { } else {
global_vars.generic_tool->setPos(global_vars.current_tool->getPos()); global_vars.generic_tool->setPos( global_vars.current_tool->getPos() );
global_vars.current_tool = global_vars.generic_tool; global_vars.current_tool = global_vars.generic_tool;
global_vars.current_tool->setTexture( global_vars.current_tool->setTexture( target_texture, target_src );
target_texture,
getSourceRectByID( tool_id, global_vars.current_world_type ) );
global_vars.current_tool->setId( tool_id ); global_vars.current_tool->setId( tool_id );
global_vars.current_tool->getCollisions()[0]->setId( tool_id ); global_vars.current_tool->getCollisions()[0]->setId( tool_id );
} }
global_vars.current_tool->setHidden(false); global_vars.current_tool->setHidden( false );
} }
void removeMario() { void removeMario() {
@ -193,7 +197,7 @@ void updateToolSelection( int prev_index, ToolType::Value type ) {
unsetToolColor(); unsetToolColor();
size_t cur_page = 0; 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< MarioBlock > > *tool_vec = nullptr;
switch ( type ) { switch ( type ) {
case ToolType::BLOCK: case ToolType::BLOCK:
cur_page = global_vars.tool.cur_page_tools; cur_page = global_vars.tool.cur_page_tools;
@ -272,7 +276,7 @@ void moveToolsRight( ToolType::Value type ) {
void updateToolIndex( uint64_t new_index, ToolType::Value new_type ) { void updateToolIndex( uint64_t new_index, ToolType::Value new_type ) {
int multiplier = 0; int multiplier = 0;
int *page = nullptr; int *page = nullptr;
switch ( global_vars.tool.type ) { switch ( new_type ) {
case ToolType::BLOCK: case ToolType::BLOCK:
multiplier = 2 * TOOLS_WIDTH; multiplier = 2 * TOOLS_WIDTH;
page = &global_vars.tool.cur_page_tools; page = &global_vars.tool.cur_page_tools;
@ -416,20 +420,13 @@ bool getFlag( uint64_t flag ) {
void updateWorld() { void updateWorld() {
for ( auto &block : global_vars.tools ) { for ( auto &block : global_vars.tools ) {
block->setTextureSourceRect( getSourceRectByID( block->setType( global_vars.current_world_type );
block->getId(), global_vars.current_world_type ) );
dynamic_cast< MarioBlock * >( block.get() )
->setType( global_vars.current_world_type );
} }
for ( auto &block : global_vars.characters ) { for ( auto &block : global_vars.characters ) {
block->setTextureSourceRect( getSourceRectByID( block->setType( global_vars.current_world_type );
block->getId(), global_vars.current_world_type ) );
dynamic_cast< MarioBlock * >( block.get() )
->setType( global_vars.current_world_type );
} }
if(getBlockRole(global_vars.current_tool->getId()) != BlockRole::MODIFIER) { if ( getBlockRole( global_vars.current_tool->getId() ) !=
global_vars.current_tool->setTextureSourceRect( getSourceRectByID( BlockRole::MODIFIER ) {
global_vars.current_tool->getId(), global_vars.current_world_type ) );
global_vars.current_tool->setType( global_vars.current_world_type ); global_vars.current_tool->setType( global_vars.current_world_type );
} }
} }
@ -582,7 +579,6 @@ void placeTool( SDLPP::Scene &scene ) {
scene.visitCollisions( *global_vars.current_tool, visitor ); scene.visitCollisions( *global_vars.current_tool, visitor );
auto &obj = getSelectedObject(); auto &obj = getSelectedObject();
if ( visitor.removeBlock() && !visitor.addBlock() ) { if ( visitor.removeBlock() && !visitor.addBlock() ) {
std::cout << "DO NOT ADD" << std::endl;
switch ( visitor.getVisitorType() ) { switch ( visitor.getVisitorType() ) {
case VisitorType::Terrain: case VisitorType::Terrain:
obj.unsetTerrain(); obj.unsetTerrain();
@ -594,7 +590,6 @@ void placeTool( SDLPP::Scene &scene ) {
break; break;
} }
} else if ( visitor.addBlock() ) { } else if ( visitor.addBlock() ) {
std::cout << "ADD" << std::endl;
auto renderer = scene.getRendererShared(); auto renderer = scene.getRendererShared();
int z_index = 1; int z_index = 1;
std::shared_ptr< MarioBlock > new_obj = nullptr; std::shared_ptr< MarioBlock > new_obj = nullptr;
@ -603,18 +598,18 @@ void placeTool( SDLPP::Scene &scene ) {
obj.setTerrain( global_vars.current_tool->getId(), obj.setTerrain( global_vars.current_tool->getId(),
global_vars.current_world_type ); global_vars.current_world_type );
new_obj = createTerrainBlock( new_obj = createTerrainBlock(
obj.getTerrainId(), obj.getTerrainId(), obj.getTerrainType(), renderer,
obj.getTerrainType(), renderer,
global_vars.mouse.edit_box.getX(), global_vars.mouse.edit_box.getX(),
global_vars.mouse.edit_box.getY(), false, true ); global_vars.mouse.edit_box.getY(), false, true );
new_obj->getCollisions()[0]->setId( EDITOR_TERRAIN_ID ); new_obj->getCollisions()[0]->setId( EDITOR_TERRAIN_ID );
break; break;
case VisitorType::Modifier: case VisitorType::Modifier:
if ( tool_type == BlockRole::MARIO ) { if ( tool_type == BlockRole::MARIO ) {
obj.setCharacter(MARIO_ID, global_vars.current_world_type); obj.setCharacter( MARIO_ID, global_vars.current_world_type );
new_obj = createMario( global_vars.current_world_type, renderer, new_obj =
global_vars.mouse.edit_box.getX(), createMario( global_vars.current_world_type, renderer,
global_vars.mouse.edit_box.getY(), true ); global_vars.mouse.edit_box.getX(),
global_vars.mouse.edit_box.getY(), true );
// remove mario if exists // remove mario if exists
removeMario(); removeMario();
global_vars.mario = new_obj; global_vars.mario = new_obj;
@ -623,15 +618,15 @@ void placeTool( SDLPP::Scene &scene ) {
z_index = scene.getObjects().size() - 1; z_index = scene.getObjects().size() - 1;
// TODO BlockRole::Character // TODO BlockRole::Character
} else { } else {
obj.setModifier(global_vars.current_tool->getId(), global_vars.current_tool->getData()); obj.setModifier( global_vars.current_tool->getId(),
global_vars.current_tool->getData() );
new_obj = createTerrainBlock( new_obj = createTerrainBlock(
obj.getModifierId(), obj.getModifierId(), LandType::OVERWORLD, renderer,
LandType::OVERWORLD, renderer,
global_vars.mouse.edit_box.getX(), global_vars.mouse.edit_box.getX(),
global_vars.mouse.edit_box.getY(), global_vars.mouse.edit_box.getY(), false, true );
false, true ); new_obj->setTextureKeepSRC(
new_obj->setTextureKeepSRC(global_vars.translucent_mod_texture); global_vars.translucent_mod_texture );
new_obj->setData(global_vars.current_tool->getData()); new_obj->setData( global_vars.current_tool->getData() );
new_obj->getCollisions()[0]->setId( EDITOR_TERRAIN_ID ); new_obj->getCollisions()[0]->setId( EDITOR_TERRAIN_ID );
// TODO createModifierBlock // TODO createModifierBlock
dynamic_cast< MarioBlock * >( new_obj.get() ) dynamic_cast< MarioBlock * >( new_obj.get() )
@ -714,9 +709,9 @@ void pollEvents( SDLPP::Scene &scene ) {
global_vars.mouse.prev_flags = global_vars.mouse.cur_flags; global_vars.mouse.prev_flags = global_vars.mouse.cur_flags;
break; break;
case SDL_MOUSEWHEEL: case SDL_MOUSEWHEEL:
if(event.wheel.y > 0) { if ( event.wheel.y > 0 ) {
global_vars.current_tool->onScrollUp(); global_vars.current_tool->onScrollUp();
} else if (event.wheel.y < 0) { } else if ( event.wheel.y < 0 ) {
global_vars.current_tool->onScrollDown(); global_vars.current_tool->onScrollDown();
} }
break; break;
@ -804,7 +799,7 @@ createArrowControls(
void populateToolGrid( void populateToolGrid(
int count_x, int count_y, float start_x, float start_y, int count_x, int count_y, float start_x, float start_y,
ToolType::Value type, const std::vector< uint64_t > &blocks, ToolType::Value type, const std::vector< uint64_t > &blocks,
std::vector< std::shared_ptr< SDLPP::RenderObject > > &tool_store, std::vector< std::shared_ptr< MarioBlock > > &tool_store,
std::vector< std::shared_ptr< SDLPP::RenderObject > > &tool_box_store, std::vector< std::shared_ptr< SDLPP::RenderObject > > &tool_box_store,
std::shared_ptr< SDLPP::Scene > &scene, const std::string &title, std::shared_ptr< SDLPP::Scene > &scene, const std::string &title,
const std::shared_ptr< SDLPP::FontConfiguration > &font_config ) { const std::shared_ptr< SDLPP::FontConfiguration > &font_config ) {
@ -825,17 +820,17 @@ void populateToolGrid(
global_vars.current_world_type, renderer, 0, 0, true ) ); global_vars.current_world_type, renderer, 0, 0, true ) );
break; break;
} }
// fall through // fall through
case ToolType::MOD: case ToolType::MOD:
tool_store.push_back( tool_store.push_back(
createTerrainBlock( block, global_vars.current_world_type, createTerrainBlock( block, global_vars.current_world_type,
renderer, false, true ) ); renderer, false, true ) );
break; break;
case ToolType::BLOCK: case ToolType::BLOCK:
tool_store.push_back( tool_store.push_back(
createTerrainBlock( block, global_vars.current_world_type, createTerrainBlock( block, global_vars.current_world_type,
renderer, false, true ) ); renderer, false, true ) );
break; break;
default: default:
break; break;
} }
@ -958,13 +953,13 @@ int main() {
renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY ); renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY );
g_mario_texture = std::make_shared< SDLPP::Texture >( g_mario_texture = std::make_shared< SDLPP::Texture >(
renderer, "sprites/mario.png", MARIO_OVERWORLD_COLORKEY ); renderer, "sprites/mario.png", MARIO_OVERWORLD_COLORKEY );
g_mod_texture = std::make_shared<SDLPP::Texture>( g_mod_texture =
renderer, "sprites/mods.png"); std::make_shared< SDLPP::Texture >( renderer, "sprites/mods.png" );
g_translucent_terrain_texture = std::make_shared< SDLPP::Texture >( g_translucent_terrain_texture = std::make_shared< SDLPP::Texture >(
renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY ); renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY );
g_translucent_terrain_texture->setAlpha( 100 ); g_translucent_terrain_texture->setAlpha( 100 );
g_translucent_mod_texture = std::make_shared<SDLPP::Texture>( g_translucent_mod_texture =
renderer, "sprites/mods.png"); std::make_shared< SDLPP::Texture >( renderer, "sprites/mods.png" );
g_translucent_mod_texture->setAlpha( 100 ); g_translucent_mod_texture->setAlpha( 100 );
auto scene = std::make_shared< SDLPP::Scene >( renderer ); auto scene = std::make_shared< SDLPP::Scene >( renderer );
@ -977,8 +972,8 @@ int main() {
global_vars.current_world_type = LandType::OVERWORLD; global_vars.current_world_type = LandType::OVERWORLD;
// TODO file name // TODO file name
loadMap( scene, global_vars.mario, "test_binary.bin", loadMap( scene, global_vars.mario, "test_binary.bin", global_vars.objects,
global_vars.objects, true, MAP_WIDTH ); true, MAP_WIDTH );
// create grids and arrow controls // create grids and arrow controls
// map // map
@ -1076,17 +1071,19 @@ int main() {
global_vars.translucent_mario_texture = std::make_shared< SDLPP::Texture >( global_vars.translucent_mario_texture = std::make_shared< SDLPP::Texture >(
renderer, "sprites/mario.png", MARIO_OVERWORLD_COLORKEY ); renderer, "sprites/mario.png", MARIO_OVERWORLD_COLORKEY );
global_vars.translucent_mario_texture->setAlpha( 100 ); global_vars.translucent_mario_texture->setAlpha( 100 );
global_vars.generic_tool = createTerrainBlock( global_vars.generic_tool =
possibleBlocks[global_vars.tool.index], global_vars.current_world_type, createTerrainBlock( possibleBlocks[global_vars.tool.index],
renderer, false ); global_vars.current_world_type, renderer, false );
global_vars.generic_tool->setTextureKeepSRC(global_vars.translucent_terrain_texture); global_vars.generic_tool->setTextureKeepSRC(
global_vars.translucent_terrain_texture );
global_vars.generic_tool->removeCollisions(); global_vars.generic_tool->removeCollisions();
global_vars.generic_tool->addCollision( global_vars.generic_tool->addCollision(
SDLPP::RectColider( 0.1, 0.1, 0.8, 0.8 ) ); SDLPP::RectColider( 0.1, 0.1, 0.8, 0.8 ) );
global_vars.current_tool = global_vars.generic_tool; global_vars.current_tool = global_vars.generic_tool;
global_vars.coin_tool = createTerrainBlock(COIN_MODIFIER_ID, LandType::OVERWORLD, renderer, 0, 0, false, true ); global_vars.coin_tool = createTerrainBlock(
global_vars.coin_tool->setData(1); COIN_MODIFIER_ID, LandType::OVERWORLD, renderer, 0, 0, false, true );
global_vars.coin_tool->setData( 1 );
global_vars.coin_tool->removeCollisions(); global_vars.coin_tool->removeCollisions();
global_vars.coin_tool->addCollision( global_vars.coin_tool->addCollision(
SDLPP::RectColider( 0.1, 0.1, 0.8, 0.8 ) ); SDLPP::RectColider( 0.1, 0.1, 0.8, 0.8 ) );
@ -1094,7 +1091,7 @@ int main() {
dynamic_cast< MarioBlock & >( *global_vars.current_tool ).setTool(); dynamic_cast< MarioBlock & >( *global_vars.current_tool ).setTool();
scene->addObject( global_vars.current_tool ); scene->addObject( global_vars.current_tool );
scene->addObject( global_vars.coin_tool ); scene->addObject( global_vars.coin_tool );
global_vars.coin_tool->setHidden(true); global_vars.coin_tool->setHidden( true );
scene->moveZTop( global_vars.current_tool ); scene->moveZTop( global_vars.current_tool );
scene->moveZTop( global_vars.coin_tool ); scene->moveZTop( global_vars.coin_tool );

20
mario/maploader.cpp
View File

@ -131,17 +131,17 @@ void loadMap( std::shared_ptr< SDLPP::Scene > &scene,
auto obj = createTerrainBlock( auto obj = createTerrainBlock(
block.getTerrainId(), block.getTerrainType(), block.getTerrainId(), block.getTerrainType(),
renderer, i, j, destructible, editor ); renderer, i, j, destructible, editor );
if(obj == nullptr) if(obj != nullptr) {
continue; obj->setCoinCount(coinCount);
obj->setCoinCount(coinCount); if(removeCollisions) {
if(removeCollisions) { obj->removeCollisions();
obj->removeCollisions(); }
} if ( obj != nullptr ) {
if ( obj != nullptr ) { if ( editor ) {
if ( editor ) { obj->getCollisions()[0]->setId( EDITOR_TERRAIN_ID );
obj->getCollisions()[0]->setId( EDITOR_TERRAIN_ID ); }
scene->addObject( obj );
} }
scene->addObject( obj );
} }
} }
if ( block.hasCharacter() ) { if ( block.hasCharacter() ) {

20
mario/mario.hpp
View File

@ -6,19 +6,19 @@
#include "sprites.hpp" #include "sprites.hpp"
#include "blocks.hpp" #include "blocks.hpp"
// TODO change to MarioBlock instead of RectangleRender
class Mario : public MarioBlock { class Mario : public MarioBlock {
public: public:
Mario(int x, int y, const std::shared_ptr< SDLPP::Renderer > &renderer); Mario( int x, int y, const std::shared_ptr< SDLPP::Renderer > &renderer );
Mario(const std::shared_ptr< SDLPP::Renderer > &renderer); Mario( const std::shared_ptr< SDLPP::Renderer > &renderer );
void walkLeft(); void walkLeft();
void walkRight(); void walkRight();
void setStanding(); void setStanding();
void handleVisitor(MarioVisitor &visitor); void handleVisitor( MarioVisitor &visitor );
void jump(); void jump();
void stopJump(); void stopJump();
virtual void custom_move( int ticks ) override; virtual void custom_move( int ticks ) override;
void visit(SDLPP::Visitor &visitor) override; void visit( SDLPP::Visitor &visitor ) override;
private: private:
bool faces_right = true; bool faces_right = true;
double side_movement = 0.39; double side_movement = 0.39;
@ -31,11 +31,11 @@ private:
bool on_ground = true; bool on_ground = true;
int ticks_till_gravity = 0; int ticks_till_gravity = 0;
// gravity should be added every frame in 60fps game // gravity should be added every frame in 60fps game
const int base_gravity_ticks = 1000/60; const int base_gravity_ticks = 1000 / 60;
const double gravity_add_jumping = jump_movement/32.0; const double gravity_add_jumping = jump_movement / 32.0;
const double gravity_add_falling = jump_movement/(64.0/7.0); const double gravity_add_falling = jump_movement / ( 64.0 / 7.0 );
std::shared_ptr<SDLPP::RectColider> top_collision = nullptr; std::shared_ptr< SDLPP::RectColider > top_collision = nullptr;
virtual void setWorldTypeSrc(LandType::Value world) override; virtual void setWorldTypeSrc( LandType::Value world ) override;
}; };
#endif #endif