Compare commits

..

No commits in common. "58fd1a37a8652348bf878dddd4773f8e18fd5b8a" and "3a80fab3ddcf26d56517f928cbd542ce112ebf2d" have entirely different histories.

11 changed files with 334 additions and 373 deletions

View File

@ -24,55 +24,55 @@ using char_t = char;
namespace FSLib { namespace FSLib {
bool exists(const string &path); bool exists( const string &path );
bool isDirectory(const string &path); bool isDirectory( const string &path );
bool rename(const string &file_a, const string &file_b); bool rename( const string &file_a, const string &file_b );
bool deleteFile(const string &file); bool deleteFile( const string &file );
string canonical(const string &path); string canonical( const string &path );
bool createDirectoryFull(const string &path); bool createDirectoryFull( const string &path );
string getContainingDirectory(const string &path); string getContainingDirectory( const string &path );
string getFileName(const string &path); string getFileName( const string &path );
string getFileExtension(const string &path); string getFileExtension( const string &path );
extern char dir_divisor; extern char dir_divisor;
class Directory { class Directory {
public: public:
Directory() = delete; Directory() = delete;
explicit Directory(const string &path_); explicit Directory( const string &path_ );
explicit Directory(const Directory &d) = default; explicit Directory( const Directory &d ) = default;
explicit Directory(Directory &&d) = default; explicit Directory( Directory &&d ) = default;
class Iterator { class Iterator {
public: public:
explicit Iterator(const Directory &d_); explicit Iterator( const Directory &d_ );
~Iterator(); ~Iterator();
#ifdef _WIN32 #ifdef _WIN32
explicit Iterator(bool ended_); explicit Iterator( bool ended_ );
#else #else
Iterator(const Directory &d_, const struct dirent *current_entry_); Iterator( const Directory &d_, const struct dirent *current_entry_ );
#endif #endif
Iterator() = delete; Iterator() = delete;
Iterator(const Iterator &i) = default; Iterator( const Iterator &i ) = default;
Iterator(Iterator &&i) = default; Iterator( Iterator &&i ) = default;
char_t const *operator*() const; char_t const *operator*() const;
Iterator &operator++(); Iterator &operator++();
bool operator==(const Iterator &i_other) const; bool operator==( const Iterator &i_other ) const;
Iterator operator++(int) { Iterator operator++( int ) {
Iterator ret(*this); Iterator ret( *this );
operator++(); operator++();
return ret; return ret;
} }
bool operator!=(const Iterator &i_other) const { bool operator!=( const Iterator &i_other ) const {
return !(i_other == *this); return !( i_other == *this );
} }
private: private:
@ -94,11 +94,11 @@ public:
const_iterator end() const; const_iterator end() const;
iterator begin() { iterator begin() {
return Iterator(*this); return Iterator( *this );
} }
const_iterator begin() const { const_iterator begin() const {
return Iterator(*this); return Iterator( *this );
} }
const_iterator cbegin() const { const_iterator cbegin() const {
@ -115,7 +115,7 @@ public:
#ifdef _WIN32 #ifdef _WIN32
const char_t *validPath() const { const char_t *validPath() const {
return dir_path.substr(0, dir_path.length() - 2).c_str(); return dir_path.substr( 0, dir_path.length() - 2 ).c_str();
} }
#endif #endif

View File

@ -10,42 +10,44 @@
char FSLib::dir_divisor = '/'; char FSLib::dir_divisor = '/';
FSLib::Directory::Directory(const string &path_) : dir_path(path_) {} FSLib::Directory::Directory( const string &path_ ) : dir_path( path_ ) {}
FSLib::Directory::Iterator::Iterator(const Directory &d_) FSLib::Directory::Iterator::Iterator( const Directory &d_ )
: d(opendir(d_.path())) { : d( opendir( d_.path() ) ) {
if (!exists(d_.path()) || !isDirectory(d_.path())) { if ( !exists( d_.path() ) || !isDirectory( d_.path() ) ) {
throw std::runtime_error(std::string("Directory ") + d_.path() + throw std::runtime_error(
" either doesn't exist or isn't a directory"); std::string( "Directory " ) + d_.path() +
" either doesn't exist or isn't a directory" );
} }
current_entry = readdir(d); current_entry = readdir( d );
// skip "." and ".." // skip "." and ".."
if (current_entry != nullptr && (!strcmp(current_entry->d_name, ".") || if ( current_entry != nullptr &&
!strcmp(current_entry->d_name, ".."))) ( !strcmp( current_entry->d_name, "." ) ||
++(*this); !strcmp( current_entry->d_name, ".." ) ) )
++( *this );
} }
FSLib::Directory::Iterator::Iterator(const Directory &d_, FSLib::Directory::Iterator::Iterator( const Directory &d_,
const struct dirent *current_entry_) const struct dirent *current_entry_ )
: d(opendir(d_.path())), current_entry(current_entry_) {} : d( opendir( d_.path() ) ), current_entry( current_entry_ ) {}
FSLib::Directory::Iterator::~Iterator() { FSLib::Directory::Iterator::~Iterator() {
if (d) if ( d )
closedir(d); closedir( d );
} }
bool FSLib::exists(const string &path) { bool FSLib::exists( const string &path ) {
struct stat path_stat; struct stat path_stat;
return stat(path.c_str(), &path_stat) == 0; return stat( path.c_str(), &path_stat ) == 0;
} }
string FSLib::canonical(const string &path) { string FSLib::canonical( const string &path ) {
char_t *canonical_path = new char_t[PATH_MAX]; char_t *canonical_path = new char_t[PATH_MAX];
auto failed = realpath(path.c_str(), canonical_path) == nullptr; auto failed = realpath( path.c_str(), canonical_path ) == nullptr;
if (failed) { if ( failed ) {
delete[] canonical_path; delete[] canonical_path;
return string(); return string();
} }
@ -55,76 +57,76 @@ string FSLib::canonical(const string &path) {
return canonical_string; return canonical_string;
} }
bool FSLib::isDirectory(const string &path) { bool FSLib::isDirectory( const string &path ) {
struct stat path_stat; struct stat path_stat;
if (stat(path.c_str(), &path_stat) != 0) if ( stat( path.c_str(), &path_stat ) != 0 )
return false; return false;
return S_ISDIR(path_stat.st_mode); return S_ISDIR( path_stat.st_mode );
} }
bool FSLib::rename(const string &file_a, const string &file_b) { bool FSLib::rename( const string &file_a, const string &file_b ) {
// TODO log // TODO log
std::cout << file_a << " -> " << file_b << std::endl; std::cout << file_a << " -> " << file_b << std::endl;
return ::rename(file_a.c_str(), file_b.c_str()) == 0; return ::rename( file_a.c_str(), file_b.c_str() ) == 0;
} }
// TODO do windows version // TODO do windows version
bool deleteRecursive(const string &dir) { bool deleteRecursive(const string &dir) {
for (const auto &file : FSLib::Directory(dir)) { for(const auto &file : FSLib::Directory(dir)) {
auto path = dir + "/" + file; auto path = dir + "/" + file;
if (FSLib::isDirectory(path)) { if(FSLib::isDirectory(path)) {
if (!deleteRecursive(path)) { if(!deleteRecursive(path)) {
return false; return false;
} }
} else if (unlink(path.c_str()) != 0) { } else if(unlink(path.c_str()) != 0) {
return false; return false;
} }
} }
return rmdir(dir.c_str()) == 0; return rmdir(dir.c_str()) == 0;
} }
bool FSLib::deleteFile(const string &file) { bool FSLib::deleteFile( const string &file ) {
// TODO log // TODO log
auto canon = canonical(file); auto canon = canonical( file );
if (canon.empty()) { if(canon.empty()) {
return false; return false;
} }
if (isDirectory(canon)) { if(isDirectory(canon)) {
return deleteRecursive(canon); return deleteRecursive(canon);
} }
return unlink(canon.c_str()) == 0; return unlink(canon.c_str()) == 0;
} }
bool FSLib::createDirectoryFull(const string &path) { bool FSLib::createDirectoryFull( const string &path ) {
uint64_t pos{}; uint64_t pos{};
// go through all directories leading to the last one // go through all directories leading to the last one
// and create them if they don't exist // and create them if they don't exist
do { do {
// get partial directory path // get partial directory path
pos = path.find_first_of("/", pos); pos = path.find_first_of( "/", pos );
if (pos > 0) { if ( pos > 0 ) {
auto dirname = path.substr(0, pos); auto dirname = path.substr( 0, pos );
// create it if it doesn't exist // create it if it doesn't exist
if (!FSLib::exists(dirname)) { if ( !FSLib::exists( dirname ) ) {
if (mkdir(dirname.c_str(), if ( mkdir( dirname.c_str(),
S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) != 0) S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH ) != 0 )
return false; return false;
} }
} }
pos++; pos++;
} while (pos < path.length() && pos != 0); } while ( pos < path.length() && pos != 0 );
return true; return true;
} }
FSLib::Directory::iterator FSLib::Directory::end() { FSLib::Directory::iterator FSLib::Directory::end() {
return Iterator(*this, nullptr); return Iterator( *this, nullptr );
} }
FSLib::Directory::const_iterator FSLib::Directory::end() const { FSLib::Directory::const_iterator FSLib::Directory::end() const {
return Iterator(*this, nullptr); return Iterator( *this, nullptr );
} }
char_t const *FSLib::Directory::Iterator::operator*() const { char_t const *FSLib::Directory::Iterator::operator*() const {
@ -132,39 +134,40 @@ char_t const *FSLib::Directory::Iterator::operator*() const {
} }
FSLib::Directory::Iterator &FSLib::Directory::Iterator::operator++() { FSLib::Directory::Iterator &FSLib::Directory::Iterator::operator++() {
if (current_entry == nullptr) if ( current_entry == nullptr )
return *this; return *this;
current_entry = readdir(d); current_entry = readdir( d );
// skip . and .. // skip . and ..
if (current_entry != nullptr && (!strcmp(current_entry->d_name, ".") || if ( current_entry != nullptr &&
!strcmp(current_entry->d_name, ".."))) ( !strcmp( current_entry->d_name, "." ) ||
!strcmp( current_entry->d_name, ".." ) ) )
return operator++(); return operator++();
return *this; return *this;
} }
bool FSLib::Directory::Iterator::operator==(const Iterator &i_other) const { bool FSLib::Directory::Iterator::operator==( const Iterator &i_other ) const {
return i_other.current_entry == current_entry; return i_other.current_entry == current_entry;
} }
string FSLib::getContainingDirectory(const string &path) { string FSLib::getContainingDirectory( const string &path ) {
auto pos = path.find_last_of('/'); auto pos = path.find_last_of('/');
if (pos == string::npos) { if(pos == string::npos) {
return "."; return ".";
} }
return path.substr(0, pos); return path.substr(0, pos);
} }
string FSLib::getFileName(const string &path) { string FSLib::getFileName( const string &path ) {
auto pos = path.find_last_of('/'); auto pos = path.find_last_of('/');
if (pos == string::npos) { if(pos == string::npos) {
return path; return path;
} }
return path.substr(pos + 1); return path.substr(pos+1);
} }
string FSLib::getFileExtension(const string &path) { string FSLib::getFileExtension( const string &path ) {
auto pos = path.find_last_of('.'); auto pos = path.find_last_of('.');
if (pos == string::npos) { if(pos == string::npos) {
return ""; return "";
} }
return path.substr(pos + 1); return path.substr(pos + 1);

View File

@ -6,20 +6,21 @@
char FSLib::dir_divisor = '\\'; char FSLib::dir_divisor = '\\';
FSLib::Directory::Directory(const string &path_) : dir_path(path_) { FSLib::Directory::Directory( const string &path_ ) : dir_path( path_ ) {
// need to append \\* for windows to search files in directory // need to append \\* for windows to search files in directory
dir_path.append(L"\\*"); dir_path.append( L"\\*" );
} }
FSLib::Directory::Iterator::Iterator(const Directory &d_) { FSLib::Directory::Iterator::Iterator( const Directory &d_ ) {
if (!exists(d_.validPath()) || !isDirectory(d_.validPath())) { if ( !exists( d_.validPath() ) || !isDirectory( d_.validPath() ) ) {
throw std::runtime_error( throw std::runtime_error(
"Directory either doesn't exist or isn't a directory"); "Directory either doesn't exist or isn't a directory" );
} }
hFind = FindFirstFileW(d_.path(), &data); hFind = FindFirstFileW( d_.path(), &data );
if (hFind != INVALID_HANDLE_VALUE) { if ( hFind != INVALID_HANDLE_VALUE ) {
if (!wcscmp(data.cFileName, L".") || !wcscmp(data.cFileName, L"..")) { if ( !wcscmp( data.cFileName, L"." ) ||
++(*this); !wcscmp( data.cFileName, L".." ) ) {
++( *this );
} }
} else { } else {
ended = true; ended = true;
@ -27,37 +28,37 @@ FSLib::Directory::Iterator::Iterator(const Directory &d_) {
} }
FSLib::Directory::Iterator::~Iterator() { FSLib::Directory::Iterator::~Iterator() {
if (hFind) if ( hFind )
FindClose(hFind); FindClose( hFind );
} }
// this is definitely not a good way to create the "end" iterator // this is definitely not a good way to create the "end" iterator
// but it was the only way I thought of with my limited knowledge of // but it was the only way I thought of with my limited knowledge of
// windows.h // windows.h
FSLib::Directory::Iterator::Iterator(bool ended_) : ended(ended_) {} FSLib::Directory::Iterator::Iterator( bool ended_ ) : ended( ended_ ) {}
bool FSLib::exists(const string &path) { bool FSLib::exists( const string &path ) {
struct _stat path_stat; struct _stat path_stat;
return _wstat(path.c_str(), &path_stat) == 0; return _wstat( path.c_str(), &path_stat ) == 0;
} }
string FSLib::canonical(const string &path) { string FSLib::canonical( const string &path ) {
char_t *full_path = new char_t[MAX_PATH]; char_t *full_path = new char_t[MAX_PATH];
char_t *canonical_path = new char_t[MAX_PATH]; char_t *canonical_path = new char_t[MAX_PATH];
auto failed = !GetFullPathName(path.c_str(), MAX_PATH, full_path, NULL); auto failed = !GetFullPathName( path.c_str(), MAX_PATH, full_path, NULL );
if (failed) { if ( failed ) {
delete[] canonical_path; delete[] canonical_path;
delete[] full_path; delete[] full_path;
return string(); return string();
} }
failed = !PathCanonicalizeW(canonical_path, full_path); failed = !PathCanonicalizeW( canonical_path, full_path );
delete[] full_path; delete[] full_path;
if (failed) { if ( failed ) {
delete[] canonical_path; delete[] canonical_path;
return string(); return string();
} }
@ -67,46 +68,46 @@ string FSLib::canonical(const string &path) {
return canonical_string; return canonical_string;
} }
bool FSLib::isDirectory(const string &path) { bool FSLib::isDirectory( const string &path ) {
struct _stat path_stat; struct _stat path_stat;
if (_wstat(path.c_str(), &path_stat) != 0) if ( _wstat( path.c_str(), &path_stat ) != 0 )
return false; return false;
return path_stat.st_mode & _S_IFDIR; return path_stat.st_mode & _S_IFDIR;
} }
bool FSLib::rename(const string &file_a, const string &file_b) { bool FSLib::rename( const string &file_a, const string &file_b ) {
return MoveFileExW(file_a.c_str(), file_b.c_str(), return MoveFileExW( file_a.c_str(), file_b.c_str(),
MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING); MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING );
} }
bool FSLib::createDirectoryFull(const string &path) { bool FSLib::createDirectoryFull( const string &path ) {
uint64_t pos = path.find_first_of(L":", 0) + 2; uint64_t pos = path.find_first_of( L":", 0 ) + 2;
if (pos == string::npos) if ( pos == string::npos )
pos = 0; pos = 0;
// go through all directories leading to the last one // go through all directories leading to the last one
// and create them if they don't exist // and create them if they don't exist
do { do {
// get partial directory path // get partial directory path
pos = path.find_first_of(L"\\", pos); pos = path.find_first_of( L"\\", pos );
auto dirname = path.substr(0, pos); auto dirname = path.substr( 0, pos );
// create it if it doesn't exist // create it if it doesn't exist
if (!FSLib::exists(dirname)) { if ( !FSLib::exists( dirname ) ) {
if (!CreateDirectoryW(dirname.c_str(), NULL)) if ( !CreateDirectoryW( dirname.c_str(), NULL ) )
return false; return false;
} }
pos++; pos++;
} while (pos < path.length() && pos != 0); } while ( pos < path.length() && pos != 0 );
return true; return true;
} }
FSLib::Directory::iterator FSLib::Directory::end() { FSLib::Directory::iterator FSLib::Directory::end() {
return Iterator(true); return Iterator( true );
} }
FSLib::Directory::const_iterator FSLib::Directory::end() const { FSLib::Directory::const_iterator FSLib::Directory::end() const {
return Iterator(true); return Iterator( true );
} }
char_t const *FSLib::Directory::Iterator::operator*() const { char_t const *FSLib::Directory::Iterator::operator*() const {
@ -114,41 +115,41 @@ char_t const *FSLib::Directory::Iterator::operator*() const {
} }
FSLib::Directory::Iterator &FSLib::Directory::Iterator::operator++() { FSLib::Directory::Iterator &FSLib::Directory::Iterator::operator++() {
if (ended == true) if ( ended == true )
return *this; return *this;
// skip . and .. // skip . and ..
if (FindNextFileW(hFind, &data) == 0) { if ( FindNextFileW( hFind, &data ) == 0 ) {
ended = true; ended = true;
} else if (!wcscmp(data.cFileName, L".") || } else if ( !wcscmp( data.cFileName, L"." ) ||
!wcscmp(data.cFileName, L"..")) { !wcscmp( data.cFileName, L".." ) ) {
return operator++(); return operator++();
} }
return *this; return *this;
} }
bool FSLib::Directory::Iterator::operator==(const Iterator &i_other) const { bool FSLib::Directory::Iterator::operator==( const Iterator &i_other ) const {
return i_other.ended == ended; return i_other.ended == ended;
} }
string FSLib::getContainingDirectory(const string &path) { string FSLib::getContainingDirectory( const string &path ) {
auto pos = path.find_last_of('\\'); auto pos = path.find_last_of('\\');
if (pos == string::npos) { if(pos == string::npos) {
return "."; return ".";
} }
return path.substr(0, pos); return path.substr(0, pos);
} }
string FSLib::getFileName(const string &path) { string FSLib::getFileName( const string &path ) {
auto pos = path.find_last_of('\\'); auto pos = path.find_last_of('\\');
if (pos == string::npos) { if(pos == string::npos) {
return path; return path;
} }
return path.substr(pos + 1); return path.substr(pos+1);
} }
string FSLib::getFileExtension(const string &path) { string FSLib::getFileExtension( const string &path ) {
auto pos = path.find_last_of('.'); auto pos = path.find_last_of('.');
if (pos == string::npos) { if(pos == string::npos) {
return ""; return "";
} }
return path.substr(pos + 1); return path.substr(pos + 1);

12
mario/gui/gui.cpp Normal file
View File

@ -0,0 +1,12 @@
#include "gui.hpp"
/*std::shared_ptr<SDLPP::RectangleRender>
createButton(double x, double y, double w, double h,
std::shared_ptr<SDLPP::Renderer> &r, const std::string &text,
const std::string &color, const std::string &outline_color,
const std::string &background_color,
std::function<void(void *)> click_fun, void *input) {
auto button = std::make_shared<Button>(
x, y, w, h, r, text, color, outline_color, background_color, click_fun, input);
return std::static_pointer_cast<SDLPP::RectangleRender>(button);
}*/

View File

@ -33,9 +33,8 @@ public:
std::shared_ptr<SDLPP::Renderer> &r, const std::string &text, std::shared_ptr<SDLPP::Renderer> &r, const std::string &text,
const ButtonConfig &config, const ButtonConfig &config,
std::function<void(void *, Button *)> click_fun, void *input) std::function<void(void *, Button *)> click_fun, void *input)
: TextRenderer(x, y, w, h, r, g_text_config->getFont(), text, : TextRenderer(x, y, w, h, r, g_text_config->getFont(), text, config.font_color,
config.font_color, config.font_outline_color, config.font_outline_color, config.outline),
config.outline),
click_fun(std::move(click_fun)), func_input(input), click_fun(std::move(click_fun)), func_input(input),
config(config), button_text(text) { config(config), button_text(text) {
setColor(config.bg_color); setColor(config.bg_color);
@ -49,60 +48,60 @@ public:
} }
void setFontColor(const std::string &color) { void setFontColor(const std::string &color) {
config.font_color = color; config.font_color = color;
if (!highlighted && !disabled) { if(!highlighted && !disabled) {
should_update_color = true; should_update_color = true;
} }
} }
void setFontColorHighlight(const std::string &color) { void setFontColorHighlight(const std::string &color) {
config.font_color_highlight = color; config.font_color_highlight = color;
if (highlighted && !disabled) { if(highlighted && !disabled) {
should_update_color = true; should_update_color = true;
} }
} }
void setFontColorDisabled(const std::string &color) { void setFontColorDisabled(const std::string &color) {
config.font_color_disabled = color; config.font_color_disabled = color;
if (disabled) { if(disabled) {
should_update_color = true; should_update_color = true;
} }
} }
void setFontOutlineColor(const std::string &color) { void setFontOutlineColor(const std::string &color) {
config.font_outline_color = color; config.font_outline_color = color;
if (!highlighted && !disabled) { if(!highlighted && !disabled) {
should_update_color = true; should_update_color = true;
} }
} }
void setFontOutlineColorHighlight(const std::string &color) { void setFontOutlineColorHighlight(const std::string &color) {
config.font_outline_color_highlight = color; config.font_outline_color_highlight = color;
if (highlighted && !disabled) { if(highlighted && !disabled) {
should_update_color = true; should_update_color = true;
} }
} }
void setFontOutlineColorDisabled(const std::string &color) { void setFontOutlineColorDisabled(const std::string &color) {
config.font_outline_color_disabled = color; config.font_outline_color_disabled = color;
if (disabled) { if(disabled) {
should_update_color = true; should_update_color = true;
} }
} }
void setBackgroundColor(const std::string &color) { void setBackgroundColor(const std::string &color) {
config.bg_color = color; config.bg_color = color;
if (!highlighted && !disabled) { if(!highlighted && !disabled) {
setColor(color); setColor(color);
} }
} }
void setBackgroundColorHighlight(const std::string &color) { void setBackgroundColorHighlight(const std::string &color) {
config.bg_color_highlight = color; config.bg_color_highlight = color;
if (highlighted && !disabled) { if(highlighted && !disabled) {
setColor(color); setColor(color);
} }
} }
void setBackgroundColorDisabled(const std::string &color) { void setBackgroundColorDisabled(const std::string &color) {
config.bg_color_disabled = color; config.bg_color_disabled = color;
if (disabled) { if(disabled) {
setColor(color); setColor(color);
} }
} }
void performFunction() { void performFunction() {
if (!disabled) { if(!disabled) {
click_fun(func_input, this); click_fun(func_input, this);
} }
} }
@ -113,7 +112,7 @@ public:
_id = id; _id = id;
} }
void setHighlight() { void setHighlight() {
if (!disabled) { if(!disabled) {
setColor(config.bg_color_highlight); setColor(config.bg_color_highlight);
should_update_color = true; should_update_color = true;
state = HIGHLIGHTED; state = HIGHLIGHTED;
@ -121,7 +120,7 @@ public:
highlighted = true; highlighted = true;
} }
void unsetHighlight() { void unsetHighlight() {
if (!disabled) { if(!disabled) {
setColor(config.bg_color); setColor(config.bg_color);
should_update_color = true; should_update_color = true;
state = NORMAL; state = NORMAL;
@ -135,7 +134,7 @@ public:
disabled = true; disabled = true;
} }
void enable() { void enable() {
if (!highlighted) { if(!highlighted) {
setColor(config.bg_color); setColor(config.bg_color);
should_update_color = true; should_update_color = true;
state = NORMAL; state = NORMAL;
@ -148,30 +147,24 @@ public:
} }
void update() { void update() {
if (should_update_color) { if(should_update_color) {
switch (state) { switch(state) {
case NORMAL: case NORMAL:
setTextColor(g_text_config->getFont(), config.font_color, setTextColor(g_text_config->getFont(), config.font_color, config.font_outline_color, config.outline);
config.font_outline_color, config.outline);
break; break;
case HIGHLIGHTED: case HIGHLIGHTED:
setTextColor( setTextColor(g_text_config->getFont(), config.font_color_highlight, config.font_outline_color_highlight, config.outline);
g_text_config->getFont(), config.font_color_highlight,
config.font_outline_color_highlight, config.outline);
break; break;
case DISABLED: case DISABLED:
setTextColor( setTextColor(g_text_config->getFont(), config.font_color_disabled, config.font_outline_color_disabled, config.outline);
g_text_config->getFont(), config.font_color_disabled,
config.font_outline_color_disabled, config.outline);
default: default:
break; break;
} }
} }
if (should_update_text) { if(should_update_text) {
changeText(button_text); changeText(button_text);
} }
} }
private: private:
std::function<void(void *, Button *)> click_fun; std::function<void(void *, Button *)> click_fun;
void *func_input; void *func_input;

View File

@ -96,7 +96,7 @@ MapObject parseBlock(std::ifstream &map_file) {
modifier_id, modifier_data); modifier_id, modifier_data);
} }
void loadEmptyMap(std::vector<mapColumnType> &objects, size_t editor_width) { void loadEmptyMap( std::vector<mapColumnType> &objects, size_t editor_width) {
objects.resize(editor_width); objects.resize(editor_width);
} }
@ -106,7 +106,7 @@ void loadMap(std::shared_ptr<SDLPP::Scene> &scene,
std::shared_ptr<SDLPP::RenderObject> &mario, std::shared_ptr<SDLPP::RenderObject> &mario,
const std::string &file, std::vector<mapColumnType> &objects, const std::string &file, std::vector<mapColumnType> &objects,
bool editor, size_t editor_width) { bool editor, size_t editor_width) {
if (!FSLib::exists(file)) { if(!FSLib::exists(file)) {
// create empty array large enough for initial editor window // create empty array large enough for initial editor window
loadEmptyMap(objects, editor_width); loadEmptyMap(objects, editor_width);
return; return;
@ -116,10 +116,9 @@ void loadMap(std::shared_ptr<SDLPP::Scene> &scene,
map_file.open(file, std::ios::in | std::ios::binary); map_file.open(file, std::ios::in | std::ios::binary);
uint16_t version; uint16_t version;
map_file.read((char *)&version, sizeof(uint16_t) / sizeof(char)); map_file.read((char *)&version, sizeof(uint16_t) / sizeof(char));
switch (version) { switch(version) {
case 0x01: case 0x01:
loadMapV01(scene, mario, map_file, objects, editor, editor_width, loadMapV01(scene, mario, map_file, objects, editor, editor_width, renderer);
renderer);
break; break;
default: default:
throw "Invalid file version"; throw "Invalid file version";
@ -223,13 +222,14 @@ void loadMapV01(std::shared_ptr<SDLPP::Scene> &scene,
if (editor && objects.size() < editor_width) { if (editor && objects.size() < editor_width) {
objects.resize(editor_width); objects.resize(editor_width);
} }
} }
// TODO catch exception in calling func // TODO catch exception in calling func
void saveMap(const std::string &file, std::vector<mapColumnType> &objects) { void saveMap(const std::string &file, std::vector<mapColumnType> &objects) {
std::ofstream output_file; std::ofstream output_file;
output_file.open(file, std::ios::out | std::ios::binary); output_file.open(file, std::ios::out | std::ios::binary);
if (!output_file.is_open()) { if(!output_file.is_open()) {
throw "Could not open file '" + file + "'"; throw "Could not open file '" + file + "'";
} }
const uint16_t version = FILE_VERSION; const uint16_t version = FILE_VERSION;

View File

@ -14,7 +14,7 @@ void loadMap(std::shared_ptr<SDLPP::Scene> &scene,
std::shared_ptr<SDLPP::RenderObject> &mario, std::shared_ptr<SDLPP::RenderObject> &mario,
const std::string &file, std::vector<mapColumnType> &objects, const std::string &file, std::vector<mapColumnType> &objects,
bool editor = false, size_t editor_width = 0); bool editor = false, size_t editor_width = 0);
void loadEmptyMap(std::vector<mapColumnType> &objects, size_t editor_width); void loadEmptyMap( std::vector<mapColumnType> &objects, size_t editor_width);
void saveMap(const std::string &file, std::vector<mapColumnType> &objects); void saveMap(const std::string &file, std::vector<mapColumnType> &objects);
#endif #endif

View File

@ -121,13 +121,12 @@ std::mutex render_mutex;
std::vector<moveStruct> arrowInputs{}; std::vector<moveStruct> arrowInputs{};
std::shared_ptr<SDLPP::Scene> editorScene; std::shared_ptr<SDLPP::Scene> editorScene;
SceneStruct mainMenuScene; SceneStruct mainMenuScene;
// SceneStruct fileChoiceScene; //SceneStruct fileChoiceScene;
std::shared_ptr<SDLPP::TextRenderer> global_test_text{}; std::shared_ptr<SDLPP::TextRenderer> global_test_text{};
std::string global_test_text_text{}; std::string global_test_text_text{};
void openMapEditor(std::shared_ptr<SDLPP::Scene> &scene, void openMapEditor(std::shared_ptr<SDLPP::Scene> &scene, const std::string &filename);
const std::string &filename);
void setFlag(uint64_t flag) { void setFlag(uint64_t flag) {
global_vars.flags |= flag; global_vars.flags |= flag;
@ -139,17 +138,17 @@ bool getFlag(uint64_t flag) {
return global_vars.flags & flag; return global_vars.flags & flag;
} }
void saveMapCallback(void * /*UNUSED*/, Button * /*UNUSED*/) { void saveMapCallback(void */*UNUSED*/, Button */*UNUSED*/) {
std::cout << "SAVING" << std::endl; std::cout << "SAVING" << std::endl;
// TODO filename // TODO filename
saveMap("test_binary2.bin", global_vars.objects); saveMap("test_binary2.bin", global_vars.objects);
} }
void loadMapDialogCallback(void * /*UNUSED*/, Button * /*UNUSED*/) { void loadMapDialogCallback(void */*UNUSED*/, Button */*UNUSED*/) {
std::cout << "LOADING" << std::endl; std::cout << "LOADING" << std::endl;
setFlag(LOAD_MAP_FLAG); setFlag(LOAD_MAP_FLAG);
// TODO filename // TODO filename
/* editorScene->resetScene(); /* editorScene->resetScene();
openMapEditor(editorScene, "test_binary.bin");*/ openMapEditor(editorScene, "test_binary.bin");*/
} }
@ -250,15 +249,14 @@ void unsetToolColor() {
setToolColor("#FFFFFF00"); setToolColor("#FFFFFF00");
} }
void toolMoveUpdateButtons(Button *left, Button *right, int &cur_page, void toolMoveUpdateButtons(Button *left, Button *right, int &cur_page, int &max_page, bool canAdd) {
int &max_page, bool canAdd) { if(cur_page == 0) {
if (cur_page == 0) {
left->disable(); left->disable();
} else { } else {
left->enable(); left->enable();
} }
if (cur_page != max_page) { if(cur_page != max_page) {
if (canAdd) { if(canAdd) {
// TOOD global button config // TOOD global button config
right->changeText(">"); right->changeText(">");
right->setFontColor("#000000"); right->setFontColor("#000000");
@ -269,7 +267,7 @@ void toolMoveUpdateButtons(Button *left, Button *right, int &cur_page,
right->enable(); right->enable();
} }
} else { } else {
if (canAdd) { if(canAdd) {
right->changeText("+"); right->changeText("+");
right->setFontColor("#00FF00"); right->setFontColor("#00FF00");
right->setFontOutlineColor("#000000"); right->setFontOutlineColor("#000000");
@ -291,26 +289,19 @@ void updateToolSelection(int prev_index, ToolType::Value type) {
cur_page = 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;
toolMoveUpdateButtons(global_vars.tool.button_left_tools.get(), toolMoveUpdateButtons(global_vars.tool.button_left_tools.get(), global_vars.tool.button_right_tools.get(), cur_page, global_vars.tool.max_page_tools, false);
global_vars.tool.button_right_tools.get(),
cur_page, global_vars.tool.max_page_tools, false);
break; break;
case ToolType::MOD: case ToolType::MOD:
cur_page = 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;
toolMoveUpdateButtons(global_vars.tool.button_left_mods.get(), toolMoveUpdateButtons(global_vars.tool.button_left_mods.get(), global_vars.tool.button_right_mods.get(), cur_page, global_vars.tool.max_page_mods, false);
global_vars.tool.button_right_mods.get(),
cur_page, global_vars.tool.max_page_mods, false);
break; break;
case ToolType::CHARACTER: case ToolType::CHARACTER:
cur_page = 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;
toolMoveUpdateButtons(global_vars.tool.button_left_characters.get(), toolMoveUpdateButtons(global_vars.tool.button_left_characters.get(), global_vars.tool.button_right_characters.get(), cur_page, global_vars.tool.max_page_characters, false);
global_vars.tool.button_right_characters.get(),
cur_page, global_vars.tool.max_page_characters,
false);
default: default:
break; break;
} }
@ -528,7 +519,7 @@ void handleKeyUp(SDL_Keycode key, SDLPP::Scene &scene) {
switch (key) { switch (key) {
case SDLK_ESCAPE: case SDLK_ESCAPE:
std::cout << "Eskape" << std::endl; std::cout << "Eskape" << std::endl;
// setFlag(QUIT_FLAG); //setFlag(QUIT_FLAG);
game_scenes.push_back(mainMenuScene); game_scenes.push_back(mainMenuScene);
break; break;
case SDLK_a: case SDLK_a:
@ -575,12 +566,11 @@ void getMousePositionFlags(SDLPP::Scene &scene) {
MouseVisitor visitor; MouseVisitor visitor;
scene.visitCollisions(*mouse, visitor); scene.visitCollisions(*mouse, visitor);
if (visitor.getCurButton() != global_vars.mouse.cur_button_index) { if(visitor.getCurButton() != global_vars.mouse.cur_button_index) {
if (global_vars.mouse.cur_button_index != (uint64_t)-1) { if(global_vars.mouse.cur_button_index != (uint64_t)-1) {
global_vars.buttons[global_vars.mouse.cur_button_index] global_vars.buttons[global_vars.mouse.cur_button_index]->unsetHighlight();
->unsetHighlight();
} }
if (visitor.getCurButton() != (uint64_t)-1) { if(visitor.getCurButton() != (uint64_t)-1) {
global_vars.buttons[visitor.getCurButton()]->setHighlight(); global_vars.buttons[visitor.getCurButton()]->setHighlight();
} }
} }
@ -601,89 +591,76 @@ void getMousePositionFlags(SDLPP::Scene &scene) {
} }
} }
void toolMoveLeft(Button *left, Button *right, int &cur_page, int &max_page, void toolMoveLeft(Button *left, Button *right, int &cur_page, int &max_page, bool canAdd) {
bool canAdd) {
cur_page--; cur_page--;
toolMoveUpdateButtons(left, right, cur_page, max_page, canAdd); toolMoveUpdateButtons(left, right, cur_page, max_page, canAdd);
} }
void toolMoveRight(Button *left, Button *right, int &cur_page, int &max_page, void toolMoveRight(Button *left, Button *right, int &cur_page, int &max_page, bool canAdd) {
bool canAdd) {
cur_page += 1; cur_page += 1;
toolMoveUpdateButtons(left, right, cur_page, max_page, canAdd); toolMoveUpdateButtons(left, right, cur_page, max_page, canAdd);
} }
void moveMapLeft(void *input, Button *caller) { void moveMapLeft(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct *>(input); auto actual_input = static_cast<moveStruct*>(input);
actual_input->scene->moveEverything(BLOCK_SIZE, 0); actual_input->scene->moveEverything(BLOCK_SIZE, 0);
toolMoveLeft(caller, actual_input->other_button.get(), toolMoveLeft(caller, actual_input->other_button.get(), global_vars.map.cur_page, global_vars.map.max_page, true);
global_vars.map.cur_page, global_vars.map.max_page, true);
} }
void moveMapRight(void *input, Button *caller) { void moveMapRight(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct *>(input); auto actual_input = static_cast<moveStruct*>(input);
if (global_vars.map.cur_page == global_vars.map.max_page) { // add column if (global_vars.map.cur_page == global_vars.map.max_page) { // add column
global_vars.objects.resize(global_vars.objects.size() + 1); global_vars.objects.resize(global_vars.objects.size() + 1);
global_vars.map.max_page++; global_vars.map.max_page++;
} }
toolMoveRight(actual_input->other_button.get(), caller, toolMoveRight(actual_input->other_button.get(), caller, global_vars.map.cur_page, global_vars.map.max_page, true);
global_vars.map.cur_page, global_vars.map.max_page, true);
actual_input->scene->moveEverything(-BLOCK_SIZE, 0); actual_input->scene->moveEverything(-BLOCK_SIZE, 0);
} }
void moveToolsLeftButton(void *input, Button *caller) { void moveToolsLeftButton(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct *>(input); auto actual_input = static_cast<moveStruct*>(input);
toolMoveLeft(caller, actual_input->other_button.get(), toolMoveLeft(caller, actual_input->other_button.get(), global_vars.tool.cur_page_tools, global_vars.tool.max_page_tools, false);
global_vars.tool.cur_page_tools, updateToolSelection(global_vars.tool.cur_page_tools + 1,
global_vars.tool.max_page_tools, false); ToolType::BLOCK);
updateToolSelection(global_vars.tool.cur_page_tools + 1, ToolType::BLOCK);
} }
void moveToolsRightButton(void *input, Button *caller) { void moveToolsRightButton(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct *>(input); auto actual_input = static_cast<moveStruct*>(input);
toolMoveRight(actual_input->other_button.get(), caller, toolMoveRight(actual_input->other_button.get(), caller, global_vars.tool.cur_page_tools, global_vars.tool.max_page_tools, false);
global_vars.tool.cur_page_tools, updateToolSelection(global_vars.tool.cur_page_tools - 1,
global_vars.tool.max_page_tools, false); ToolType::BLOCK);
updateToolSelection(global_vars.tool.cur_page_tools - 1, ToolType::BLOCK);
} }
void moveModsLeft(void *input, Button *caller) { void moveModsLeft(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct *>(input); auto actual_input = static_cast<moveStruct*>(input);
toolMoveLeft(caller, actual_input->other_button.get(), toolMoveLeft(caller, actual_input->other_button.get(), global_vars.tool.cur_page_mods, global_vars.tool.max_page_mods, false);
global_vars.tool.cur_page_mods, global_vars.tool.max_page_mods, updateToolSelection(global_vars.tool.cur_page_tools + 1,
false); ToolType::MOD);
updateToolSelection(global_vars.tool.cur_page_tools + 1, ToolType::MOD);
} }
void moveModsRight(void *input, Button *caller) { void moveModsRight(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct *>(input); auto actual_input = static_cast<moveStruct*>(input);
toolMoveRight(actual_input->other_button.get(), caller, toolMoveRight(actual_input->other_button.get(), caller, global_vars.tool.cur_page_mods, global_vars.tool.max_page_mods, false);
global_vars.tool.cur_page_mods, updateToolSelection(global_vars.tool.cur_page_tools - 1,
global_vars.tool.max_page_mods, false); ToolType::MOD);
updateToolSelection(global_vars.tool.cur_page_tools - 1, ToolType::MOD);
} }
void moveCharsLeft(void *input, Button *caller) { void moveCharsLeft(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct *>(input); auto actual_input = static_cast<moveStruct*>(input);
toolMoveLeft(caller, actual_input->other_button.get(), toolMoveLeft(caller, actual_input->other_button.get(), global_vars.tool.cur_page_characters, global_vars.tool.max_page_characters, false);
global_vars.tool.cur_page_characters,
global_vars.tool.max_page_characters, false);
updateToolSelection(global_vars.tool.cur_page_tools + 1, updateToolSelection(global_vars.tool.cur_page_tools + 1,
ToolType::CHARACTER); ToolType::CHARACTER);
} }
void moveCharsRight(void *input, Button *caller) { void moveCharsRight(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct *>(input); auto actual_input = static_cast<moveStruct*>(input);
toolMoveRight(actual_input->other_button.get(), caller, toolMoveRight(actual_input->other_button.get(), caller, global_vars.tool.cur_page_characters, global_vars.tool.max_page_characters, false);
global_vars.tool.cur_page_characters,
global_vars.tool.max_page_characters, false);
updateToolSelection(global_vars.tool.cur_page_tools - 1, updateToolSelection(global_vars.tool.cur_page_tools - 1,
ToolType::CHARACTER); ToolType::CHARACTER);
} }
void mouseUpAction(uint64_t flags) { void mouseUpAction(uint64_t flags) {
if (MouseVisitor::button(flags)) { if(MouseVisitor::button(flags)) {
global_vars.buttons[global_vars.mouse.cur_button_index] global_vars.buttons[global_vars.mouse.cur_button_index]->performFunction();
->performFunction();
} }
} }
@ -802,28 +779,24 @@ void pollEvents(std::shared_ptr<SDLPP::Scene> &scene) {
setFlag(QUIT_FLAG); setFlag(QUIT_FLAG);
break; break;
case SDL_KEYUP: case SDL_KEYUP:
if (!getFlag(TEXT_INPUT_FLAG)) { if(!getFlag(TEXT_INPUT_FLAG)) {
handleKeyUp(event.key.keysym.sym, *scene); handleKeyUp(event.key.keysym.sym, *scene);
} else { } else {
if (event.key.keysym.sym == SDLK_ESCAPE || if ( event.key.keysym.sym == SDLK_ESCAPE || event.key.keysym.sym == SDLK_RETURN ) {
event.key.keysym.sym == SDLK_RETURN) {
SDL_StopTextInput(); SDL_StopTextInput();
unsetFlag(TEXT_INPUT_FLAG); unsetFlag(TEXT_INPUT_FLAG);
} }
} }
break; break;
case SDL_KEYDOWN: case SDL_KEYDOWN:
if (getFlag(TEXT_INPUT_FLAG)) { if(getFlag(TEXT_INPUT_FLAG)) {
if (event.key.keysym.sym == SDLK_BACKSPACE && if( event.key.keysym.sym == SDLK_BACKSPACE && !global_test_text_text.empty() ) {
!global_test_text_text.empty()) {
global_test_text_text.pop_back(); global_test_text_text.pop_back();
setFlag(TEXT_UPDATE_FLAG); setFlag(TEXT_UPDATE_FLAG);
} else if (event.key.keysym.sym == SDLK_c && } else if( event.key.keysym.sym == SDLK_c && SDL_GetModState() & KMOD_CTRL ) {
SDL_GetModState() & KMOD_CTRL) {
// handle copy // handle copy
SDL_SetClipboardText(global_test_text_text.c_str()); SDL_SetClipboardText( global_test_text_text.c_str() );
} else if (event.key.keysym.sym == SDLK_v && } else if( event.key.keysym.sym == SDLK_v && SDL_GetModState() & KMOD_CTRL ) {
SDL_GetModState() & KMOD_CTRL) {
// handle paste // handle paste
global_test_text_text += SDL_GetClipboardText(); global_test_text_text += SDL_GetClipboardText();
setFlag(TEXT_UPDATE_FLAG); setFlag(TEXT_UPDATE_FLAG);
@ -1025,13 +998,12 @@ void populateWorldType(
scene->addObject(tool_text); scene->addObject(tool_text);
} }
void testButtonFunc(void * /*UNUSED*/, Button * /*UNUSED*/) { void testButtonFunc(void */*UNUSED*/, Button */*UNUSED*/) {
setFlag(TEXT_INPUT_FLAG); setFlag(TEXT_INPUT_FLAG);
SDL_StartTextInput(); SDL_StartTextInput();
} }
void openMapEditor(std::shared_ptr<SDLPP::Scene> &scene, void openMapEditor(std::shared_ptr<SDLPP::Scene> &scene, const std::string &filename) {
const std::string &filename) {
auto renderer = scene->getRendererShared(); auto renderer = scene->getRendererShared();
auto font = std::make_shared<SDLPP::Font>("testfont.ttf", 36); auto font = std::make_shared<SDLPP::Font>("testfont.ttf", 36);
auto font_config = std::make_shared<SDLPP::FontConfiguration>( auto font_config = std::make_shared<SDLPP::FontConfiguration>(
@ -1044,11 +1016,11 @@ void openMapEditor(std::shared_ptr<SDLPP::Scene> &scene,
global_vars.current_world_type = LandType::OVERWORLD; global_vars.current_world_type = LandType::OVERWORLD;
if (filename.empty()) { if(filename.empty()) {
loadEmptyMap(global_vars.objects, MAP_WIDTH); loadEmptyMap(global_vars.objects, MAP_WIDTH);
} else { } else {
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);
} }
// map // map
@ -1092,17 +1064,15 @@ void openMapEditor(std::shared_ptr<SDLPP::Scene> &scene,
2, scene); 2, scene);
global_test_text = std::make_shared<SDLPP::TextRenderer>( global_test_text = std::make_shared<SDLPP::TextRenderer>(
0.3, 0.05, BLOCK_SIZE * 4, BLOCK_SIZE * 2, renderer, "TEST TEXT", 0.3, 0.05, BLOCK_SIZE*4, BLOCK_SIZE*2,
font_config, SDLPP_TEXT_CENTER); renderer, "TEST TEXT", font_config, SDLPP_TEXT_CENTER);
global_test_text->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER); global_test_text->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
global_test_text->setPermanent(); global_test_text->setPermanent();
scene->addObject(global_test_text); scene->addObject(global_test_text);
global_vars.map.max_page = global_vars.objects.size() - MAP_WIDTH; global_vars.map.max_page = global_vars.objects.size() - MAP_WIDTH;
// arrowInputs[1] - rightMapInput, arrowInputs[0] - leftMapInput // arrowInputs[1] - rightMapInput, arrowInputs[0] - leftMapInput
toolMoveUpdateButtons( toolMoveUpdateButtons(arrowInputs[1].other_button.get(), arrowInputs[0].other_button.get(), global_vars.map.cur_page, global_vars.map.max_page, true);
arrowInputs[1].other_button.get(), arrowInputs[0].other_button.get(),
global_vars.map.cur_page, global_vars.map.max_page, true);
auto mouse = auto mouse =
std::make_shared<SDLPP::RectangleRender>(0.01, 0.01, 0, 0, renderer); std::make_shared<SDLPP::RectangleRender>(0.01, 0.01, 0, 0, renderer);
@ -1149,7 +1119,7 @@ void openMapEditor(std::shared_ptr<SDLPP::Scene> &scene,
updateToolSelection(0, ToolType::CHARACTER); updateToolSelection(0, ToolType::CHARACTER);
setToolColor(); setToolColor();
for (auto &button : global_vars.buttons) { for(auto &button : global_vars.buttons) {
scene->addObject(button); scene->addObject(button);
} }
@ -1159,8 +1129,7 @@ void openMapEditor(std::shared_ptr<SDLPP::Scene> &scene,
global_vars.tool.cur_page_characters = 0; global_vars.tool.cur_page_characters = 0;
} }
std::shared_ptr<SDLPP::Scene> std::shared_ptr<SDLPP::Scene> createEditorMainScene(std::shared_ptr<SDLPP::Renderer> &renderer) {
createEditorMainScene(std::shared_ptr<SDLPP::Renderer> &renderer) {
auto scene = std::make_shared<SDLPP::Scene>(renderer); auto scene = std::make_shared<SDLPP::Scene>(renderer);
global_vars.tool.max_page_tools = global_vars.tool.max_page_tools =
@ -1191,8 +1160,7 @@ createEditorMainScene(std::shared_ptr<SDLPP::Renderer> &renderer) {
global_vars.buttons.emplace_back(std::make_shared<Button>( global_vars.buttons.emplace_back(std::make_shared<Button>(
0, 1 - MAP_HEIGHT * BLOCK_SIZE, BLOCK_SIZE, MAP_HEIGHT * BLOCK_SIZE, 0, 1 - MAP_HEIGHT * BLOCK_SIZE, BLOCK_SIZE, MAP_HEIGHT * BLOCK_SIZE,
renderer, "<", default_button_theme, moveMapLeft, &left_map_input)); renderer, "<", default_button_theme, moveMapLeft, &left_map_input));
global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setPermanent(); global_vars.buttons.back()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1); global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
// right map arrow // right map arrow
@ -1200,29 +1168,23 @@ createEditorMainScene(std::shared_ptr<SDLPP::Renderer> &renderer) {
right_map_input.scene = scene; right_map_input.scene = scene;
right_map_input.other_button = global_vars.buttons.back(); right_map_input.other_button = global_vars.buttons.back();
global_vars.buttons.emplace_back(std::make_shared<Button>( global_vars.buttons.emplace_back(std::make_shared<Button>(
(MAP_WIDTH + 1) * BLOCK_SIZE, 1 - MAP_HEIGHT * BLOCK_SIZE, BLOCK_SIZE, (MAP_WIDTH + 1) * BLOCK_SIZE, 1 - MAP_HEIGHT * BLOCK_SIZE, BLOCK_SIZE, MAP_HEIGHT * BLOCK_SIZE,
MAP_HEIGHT * BLOCK_SIZE, renderer, ">", default_button_theme, renderer, ">", default_button_theme, moveMapRight, &right_map_input));
moveMapRight, &right_map_input)); global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER,
SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setPermanent(); global_vars.buttons.back()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1); global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
left_map_input.other_button = global_vars.buttons.back(); left_map_input.other_button = global_vars.buttons.back();
// ensure disabled/enabled properly // ensure disabled/enabled properly
toolMoveUpdateButtons( toolMoveUpdateButtons(right_map_input.other_button.get(), global_vars.buttons.back().get(), global_vars.map.cur_page, global_vars.map.max_page, true);
right_map_input.other_button.get(), global_vars.buttons.back().get(),
global_vars.map.cur_page, global_vars.map.max_page, true);
// left tool arrow // left tool arrow
auto &left_tool_input = arrowInputs[2]; auto &left_tool_input = arrowInputs[2];
left_tool_input.scene = scene; left_tool_input.scene = scene;
left_tool_input.other_button = nullptr; left_tool_input.other_button = nullptr;
global_vars.buttons.emplace_back(std::make_shared<Button>( global_vars.buttons.emplace_back(std::make_shared<Button>(
(MAP_WIDTH - TOOLS_WIDTH - 1) * BLOCK_SIZE, (MAP_WIDTH - TOOLS_WIDTH - 1) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, renderer, renderer, "<", default_button_theme, moveToolsLeftButton, &left_tool_input));
"<", default_button_theme, moveToolsLeftButton, &left_tool_input)); global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER,
SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setPermanent(); global_vars.buttons.back()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1); global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
global_vars.tool.button_left_tools = global_vars.buttons.back(); global_vars.tool.button_left_tools = global_vars.buttons.back();
@ -1231,31 +1193,24 @@ createEditorMainScene(std::shared_ptr<SDLPP::Renderer> &renderer) {
right_tool_input.scene = scene; right_tool_input.scene = scene;
right_tool_input.other_button = global_vars.buttons.back(); right_tool_input.other_button = global_vars.buttons.back();
global_vars.buttons.emplace_back(std::make_shared<Button>( global_vars.buttons.emplace_back(std::make_shared<Button>(
MAP_WIDTH * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, MAP_WIDTH * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
2 * BLOCK_SIZE, renderer, ">", default_button_theme, renderer, ">", default_button_theme, moveToolsRightButton, &right_tool_input));
moveToolsRightButton, &right_tool_input)); global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER,
SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setPermanent(); global_vars.buttons.back()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1); global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
left_tool_input.other_button = global_vars.buttons.back(); left_tool_input.other_button = global_vars.buttons.back();
global_vars.tool.button_right_tools = global_vars.buttons.back(); global_vars.tool.button_right_tools = global_vars.buttons.back();
// ensure disabled/enabled properly // ensure disabled/enabled properly
toolMoveUpdateButtons(right_tool_input.other_button.get(), toolMoveUpdateButtons(right_tool_input.other_button.get(), global_vars.buttons.back().get(), global_vars.tool.cur_page_tools, global_vars.tool.max_page_tools, false);
global_vars.buttons.back().get(),
global_vars.tool.cur_page_tools,
global_vars.tool.max_page_tools, false);
// left mod arrow // left mod arrow
auto &left_mod_input = arrowInputs[4]; auto &left_mod_input = arrowInputs[4];
left_mod_input.scene = scene; left_mod_input.scene = scene;
left_mod_input.other_button = nullptr; left_mod_input.other_button = nullptr;
global_vars.buttons.emplace_back(std::make_shared<Button>( global_vars.buttons.emplace_back(std::make_shared<Button>(
4 * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 4 * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
2 * BLOCK_SIZE, renderer, "<", default_button_theme, moveModsLeft, renderer, "<", default_button_theme, moveModsLeft, &left_mod_input));
&left_mod_input)); global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER,
SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setPermanent(); global_vars.buttons.back()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1); global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
global_vars.tool.button_left_mods = global_vars.buttons.back(); global_vars.tool.button_left_mods = global_vars.buttons.back();
@ -1264,30 +1219,24 @@ createEditorMainScene(std::shared_ptr<SDLPP::Renderer> &renderer) {
right_mod_input.scene = scene; right_mod_input.scene = scene;
right_mod_input.other_button = global_vars.buttons.back(); right_mod_input.other_button = global_vars.buttons.back();
global_vars.buttons.emplace_back(std::make_shared<Button>( global_vars.buttons.emplace_back(std::make_shared<Button>(
(MOD_WIDTH + 5) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, (MOD_WIDTH + 5) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
BLOCK_SIZE, 2 * BLOCK_SIZE, renderer, ">", default_button_theme, renderer, ">", default_button_theme, moveModsRight, &right_mod_input));
moveModsRight, &right_mod_input)); global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER,
SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setPermanent(); global_vars.buttons.back()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1); global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
left_mod_input.other_button = global_vars.buttons.back(); left_mod_input.other_button = global_vars.buttons.back();
global_vars.tool.button_right_mods = global_vars.buttons.back(); global_vars.tool.button_right_mods = global_vars.buttons.back();
// ensure disabled/enabled properly // ensure disabled/enabled properly
toolMoveUpdateButtons( toolMoveUpdateButtons(right_mod_input.other_button.get(), global_vars.buttons.back().get(), global_vars.tool.cur_page_mods, global_vars.tool.max_page_mods, false);
right_mod_input.other_button.get(), global_vars.buttons.back().get(),
global_vars.tool.cur_page_mods, global_vars.tool.max_page_mods, false);
// left character arrow // left character arrow
auto &left_character_input = arrowInputs[6]; auto &left_character_input = arrowInputs[6];
left_character_input.scene = scene; left_character_input.scene = scene;
left_character_input.other_button = nullptr; left_character_input.other_button = nullptr;
global_vars.buttons.emplace_back(std::make_shared<Button>( global_vars.buttons.emplace_back(std::make_shared<Button>(
(MOD_WIDTH + 7) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, (MOD_WIDTH + 7) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
BLOCK_SIZE, 2 * BLOCK_SIZE, renderer, "<", default_button_theme, renderer, "<", default_button_theme, moveCharsLeft, &left_character_input));
moveCharsLeft, &left_character_input)); global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER,
SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setPermanent(); global_vars.buttons.back()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1); global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
global_vars.tool.button_left_characters = global_vars.buttons.back(); global_vars.tool.button_left_characters = global_vars.buttons.back();
@ -1296,24 +1245,17 @@ createEditorMainScene(std::shared_ptr<SDLPP::Renderer> &renderer) {
right_character_input.scene = scene; right_character_input.scene = scene;
right_character_input.other_button = global_vars.buttons.back(); right_character_input.other_button = global_vars.buttons.back();
global_vars.buttons.emplace_back(std::make_shared<Button>( global_vars.buttons.emplace_back(std::make_shared<Button>(
(MOD_WIDTH + 8 + CHARACTER_WIDTH) * BLOCK_SIZE, (MOD_WIDTH + 8 + CHARACTER_WIDTH) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, renderer, renderer, ">", default_button_theme, moveCharsRight, &right_character_input));
">", default_button_theme, moveCharsRight, &right_character_input)); global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER,
SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setPermanent(); global_vars.buttons.back()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1); global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
global_vars.tool.button_right_characters = global_vars.buttons.back(); global_vars.tool.button_right_characters = global_vars.buttons.back();
// ensure disabled/enabled properly // ensure disabled/enabled properly
toolMoveUpdateButtons(right_character_input.other_button.get(), toolMoveUpdateButtons(right_character_input.other_button.get(), global_vars.buttons.back().get(), global_vars.tool.cur_page_characters, global_vars.tool.max_page_characters, false);
global_vars.buttons.back().get(),
global_vars.tool.cur_page_characters,
global_vars.tool.max_page_characters, false);
left_character_input.other_button = global_vars.buttons.back(); left_character_input.other_button = global_vars.buttons.back();
global_vars.buttons.emplace_back(std::make_shared<Button>( global_vars.buttons.emplace_back(std::make_shared<Button>(0, 0, 0.2, 0.2, renderer, "Write Button", default_button_theme, testButtonFunc, nullptr));
0, 0, 0.2, 0.2, renderer, "Write Button", default_button_theme,
testButtonFunc, nullptr));
global_vars.buttons.back()->setPermanent(); global_vars.buttons.back()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1); global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
@ -1324,7 +1266,7 @@ createEditorMainScene(std::shared_ptr<SDLPP::Renderer> &renderer) {
void editorAdditionalRender(std::shared_ptr<SDLPP::Scene> &scene) { void editorAdditionalRender(std::shared_ptr<SDLPP::Scene> &scene) {
g_quit = getFlag(QUIT_FLAG); g_quit = getFlag(QUIT_FLAG);
for (auto &button : global_vars.buttons) { for(auto &button : global_vars.buttons) {
button->update(); button->update();
} }
if (getFlag(UPDATE_FLAG)) { if (getFlag(UPDATE_FLAG)) {
@ -1352,6 +1294,6 @@ SceneStruct createEditorScene(std::shared_ptr<SDLPP::Renderer> &renderer) {
editorScene = ret.scene; editorScene = ret.scene;
mainMenuScene = createEditorMainMenuScene(renderer); mainMenuScene = createEditorMainMenuScene(renderer);
// fileChoiceScene = createEditorFileChoiceScene(renderer); // fileChoiceScene = createEditorFileChoiceScene(renderer);
return ret; return ret;
} }

View File

@ -21,11 +21,11 @@ void resumeMainMenu() {
__quit_scenes_main_menu = true; __quit_scenes_main_menu = true;
} }
void quitMainMenuCallback(void * /*UNUSED*/, Button * /*UNUSED*/) { void quitMainMenuCallback(void */*UNUSED*/, Button */*UNUSED*/) {
quitMainMenu(); quitMainMenu();
} }
void resumeMainMenuCallback(void * /*UNUSED*/, Button * /*UNUSED*/) { void resumeMainMenuCallback(void */*UNUSED*/, Button */*UNUSED*/) {
resumeMainMenu(); resumeMainMenu();
} }
@ -35,12 +35,12 @@ void resetGlobals() {
__cur_button_index_main_menu = -1; __cur_button_index_main_menu = -1;
__cur_button_index_main_menu_down = -1; __cur_button_index_main_menu_down = -1;
__mouse_main_menu->setPos(0, 0); __mouse_main_menu->setPos(0, 0);
for (auto &button : __buttons_main_menu) { for(auto &button : __buttons_main_menu) {
button->unsetHighlight(); button->unsetHighlight();
} }
} }
void handleKeyUpMainMenu(SDL_Keycode key, SDLPP::Scene & /*UNUSED*/) { void handleKeyUpMainMenu(SDL_Keycode key, SDLPP::Scene &/*UNUSED*/) {
switch (key) { switch (key) {
case SDLK_ESCAPE: case SDLK_ESCAPE:
resumeMainMenu(); resumeMainMenu();
@ -50,11 +50,10 @@ void handleKeyUpMainMenu(SDL_Keycode key, SDLPP::Scene & /*UNUSED*/) {
} }
} }
std::shared_ptr<SDLPP::Scene> std::shared_ptr<SDLPP::Scene> createSceneMainMenu(std::shared_ptr<SDLPP::Renderer> &renderer) {
createSceneMainMenu(std::shared_ptr<SDLPP::Renderer> &renderer) {
auto scene = std::make_shared<SDLPP::Scene>(renderer); auto scene = std::make_shared<SDLPP::Scene>(renderer);
auto bg = std::make_shared<SDLPP::RectangleRender>(0, 0, 10, 10, renderer, auto bg = std::make_shared<SDLPP::RectangleRender>(
"#00000088", true); 0, 0, 10, 10, renderer, "#00000088", true);
bg->setPermanent(); bg->setPermanent();
bg->setId(1); bg->setId(1);
scene->addObject(bg); scene->addObject(bg);
@ -81,42 +80,38 @@ createSceneMainMenu(std::shared_ptr<SDLPP::Renderer> &renderer) {
default_button_theme.outline = 0.1; default_button_theme.outline = 0.1;
// buttons // buttons
__buttons_main_menu.emplace_back(std::make_shared<Button>( __buttons_main_menu.emplace_back(std::make_shared<Button>(
0.2, 0.25, 0.6, 0.1, renderer, "SAVE", default_button_theme, 0.2, 0.25, 0.6, 0.1,
saveMapCallback, nullptr)); renderer, "SAVE", default_button_theme, saveMapCallback, nullptr));
__buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER, __buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
SDLPP::OBJ_CENTER);
__buttons_main_menu.back()->setPermanent(); __buttons_main_menu.back()->setPermanent();
__buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1); __buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1);
__buttons_main_menu.emplace_back(std::make_shared<Button>( __buttons_main_menu.emplace_back(std::make_shared<Button>(
0.2, 0.4, 0.6, 0.1, renderer, "LOAD", default_button_theme, 0.2, 0.4, 0.6, 0.1,
loadMapDialogCallback, nullptr)); renderer, "LOAD", default_button_theme, loadMapDialogCallback, nullptr));
__buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER, __buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
SDLPP::OBJ_CENTER);
__buttons_main_menu.back()->setPermanent(); __buttons_main_menu.back()->setPermanent();
__buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1); __buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1);
__buttons_main_menu.emplace_back(std::make_shared<Button>( __buttons_main_menu.emplace_back(std::make_shared<Button>(
0.2, 0.55, 0.6, 0.1, renderer, "RESUME", default_button_theme, 0.2, 0.55, 0.6, 0.1,
resumeMainMenuCallback, nullptr)); renderer, "RESUME", default_button_theme, resumeMainMenuCallback, nullptr));
__buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER, __buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
SDLPP::OBJ_CENTER);
__buttons_main_menu.back()->setPermanent(); __buttons_main_menu.back()->setPermanent();
__buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1); __buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1);
__buttons_main_menu.emplace_back(std::make_shared<Button>( __buttons_main_menu.emplace_back(std::make_shared<Button>(
0.2, 0.7, 0.6, 0.1, renderer, "QUIT", default_button_theme, 0.2, 0.7, 0.6, 0.1,
quitMainMenuCallback, nullptr)); renderer, "QUIT", default_button_theme, quitMainMenuCallback, nullptr));
__buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER, __buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
SDLPP::OBJ_CENTER);
__buttons_main_menu.back()->setPermanent(); __buttons_main_menu.back()->setPermanent();
__buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1); __buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1);
for (auto &button : __buttons_main_menu) { for(auto &button : __buttons_main_menu) {
scene->addObject(button); scene->addObject(button);
} }
return scene; return scene;
} }
void additionalRenderMainMenu(std::shared_ptr<SDLPP::Scene> & /*UNUSED*/) { void additionalRenderMainMenu(std::shared_ptr<SDLPP::Scene> &/*UNUSED*/) {
if (__update_scenes_main_menu) { if (__update_scenes_main_menu) {
for (auto &_scene : game_scenes) { for(auto &_scene : game_scenes) {
_scene.scene->updateSizeAndPosition(); _scene.scene->updateSizeAndPosition();
} }
if (__started_main_menu) { if (__started_main_menu) {
@ -139,11 +134,11 @@ void getMousePositionFlagsMainMenu(SDLPP::Scene &scene) {
MouseVisitor visitor; MouseVisitor visitor;
scene.visitCollisions(*mouse, visitor); scene.visitCollisions(*mouse, visitor);
if (visitor.getCurButton() != __cur_button_index_main_menu) { if(visitor.getCurButton() != __cur_button_index_main_menu) {
if (__cur_button_index_main_menu != (uint64_t)-1) { if(__cur_button_index_main_menu != (uint64_t)-1) {
__buttons_main_menu[__cur_button_index_main_menu]->unsetHighlight(); __buttons_main_menu[__cur_button_index_main_menu]->unsetHighlight();
} }
if (visitor.getCurButton() != (uint64_t)-1) { if(visitor.getCurButton() != (uint64_t)-1) {
__buttons_main_menu[visitor.getCurButton()]->setHighlight(); __buttons_main_menu[visitor.getCurButton()]->setHighlight();
} }
} }
@ -169,11 +164,9 @@ void pollEventsMainMenu(std::shared_ptr<SDLPP::Scene> &scene) {
getMousePositionFlagsMainMenu(*scene); getMousePositionFlagsMainMenu(*scene);
break; break;
case SDL_MOUSEBUTTONUP: case SDL_MOUSEBUTTONUP:
if (__cur_button_index_main_menu_down == if (__cur_button_index_main_menu_down == __cur_button_index_main_menu &&
__cur_button_index_main_menu &&
__cur_button_index_main_menu != (uint64_t)-1) { __cur_button_index_main_menu != (uint64_t)-1) {
__buttons_main_menu[__cur_button_index_main_menu] __buttons_main_menu[__cur_button_index_main_menu]->performFunction();
->performFunction();
} }
break; break;
case SDL_MOUSEBUTTONDOWN: case SDL_MOUSEBUTTONDOWN:
@ -186,8 +179,7 @@ void pollEventsMainMenu(std::shared_ptr<SDLPP::Scene> &scene) {
} }
} }
SceneStruct SceneStruct createEditorMainMenuScene(std::shared_ptr<SDLPP::Renderer> &renderer) {
createEditorMainMenuScene(std::shared_ptr<SDLPP::Renderer> &renderer) {
SceneStruct ret{}; SceneStruct ret{};
ret.scene = createSceneMainMenu(renderer); ret.scene = createSceneMainMenu(renderer);
ret.additionalRender = additionalRenderMainMenu; ret.additionalRender = additionalRenderMainMenu;

View File

@ -7,8 +7,8 @@
struct SceneStruct { struct SceneStruct {
std::shared_ptr<SDLPP::Scene> scene; std::shared_ptr<SDLPP::Scene> scene;
std::function<void(std::shared_ptr<SDLPP::Scene> &)> doInput; std::function<void(std::shared_ptr<SDLPP::Scene>&)> doInput;
std::function<void(std::shared_ptr<SDLPP::Scene> &)> additionalRender; std::function<void(std::shared_ptr<SDLPP::Scene>&)> additionalRender;
}; };
extern std::mutex render_mutex; extern std::mutex render_mutex;
@ -18,9 +18,7 @@ void saveMapCallback(void *input, Button *caller);
void loadMapDialogCallback(void *input, Button *caller); void loadMapDialogCallback(void *input, Button *caller);
SceneStruct createEditorScene(std::shared_ptr<SDLPP::Renderer> &renderer); SceneStruct createEditorScene(std::shared_ptr<SDLPP::Renderer> &renderer);
SceneStruct SceneStruct createEditorMainMenuScene(std::shared_ptr<SDLPP::Renderer> &renderer);
createEditorMainMenuScene(std::shared_ptr<SDLPP::Renderer> &renderer); SceneStruct createEditorFileChoiceScene(std::shared_ptr<SDLPP::Renderer> &renderer);
SceneStruct
createEditorFileChoiceScene(std::shared_ptr<SDLPP::Renderer> &renderer);
#endif #endif

20
mario/testmap.txt Normal file
View File

@ -0,0 +1,20 @@
35
16
15
13
F
F
F zxc
F asd
F
F
F
F
F
F
F
F T
F IRD
F IRGLD qwwwr
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF