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

Compare commits

base: zv0n:58fd1a37a8652348bf878dddd4773f8e18fd5b8a
Branches Tags
zv0n:master
zv0n:dev
..
compare: zv0n:3a80fab3ddcf26d56517f928cbd542ce112ebf2d
Branches Tags
zv0n:dev
zv0n:master

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

11 changed files with 334 additions and 373 deletions
Show Stats Expand all files Collapse all files

50
mario/filesystem.hpp
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

113
mario/filesystem/unix/filesystem.cpp
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);

93
mario/filesystem/windows/filesystem.cpp
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);
}*/

63
mario/gui/gui.hpp
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(g_text_config->getFont(), config.font_color_highlight, config.font_outline_color_highlight, config.outline);
setTextColor( break;
g_text_config->getFont(), config.font_color_highlight, case DISABLED:
config.font_outline_color_highlight, config.outline); setTextColor(g_text_config->getFont(), config.font_color_disabled, config.font_outline_color_disabled, config.outline);
break; default:
case DISABLED: break;
setTextColor(
g_text_config->getFont(), config.font_color_disabled,
config.font_outline_color_disabled, config.outline);
default:
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;

36
mario/maploader.cpp
View File

@ -14,10 +14,10 @@
#define FILE_VERSION 0x01 #define FILE_VERSION 0x01
void loadMapV01(std::shared_ptr<SDLPP::Scene> &scene, void loadMapV01(std::shared_ptr<SDLPP::Scene> &scene,
std::shared_ptr<SDLPP::RenderObject> &mario, std::shared_ptr<SDLPP::RenderObject> &mario,
std::ifstream &map_file, std::vector<mapColumnType> &objects, std::ifstream &map_file, std::vector<mapColumnType> &objects,
bool editor, size_t editor_width, bool editor, size_t editor_width,
std::shared_ptr<SDLPP::Renderer> &renderer); std::shared_ptr<SDLPP::Renderer> &renderer);
void loadMap(std::shared_ptr<SDLPP::Scene> &scene, void loadMap(std::shared_ptr<SDLPP::Scene> &scene,
std::shared_ptr<SDLPP::RenderObject> mario, std::shared_ptr<SDLPP::RenderObject> mario,
@ -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,21 +116,20 @@ 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";
} }
} }
void loadMapV01(std::shared_ptr<SDLPP::Scene> &scene, void loadMapV01(std::shared_ptr<SDLPP::Scene> &scene,
std::shared_ptr<SDLPP::RenderObject> &mario, std::shared_ptr<SDLPP::RenderObject> &mario,
std::ifstream &map_file, std::vector<mapColumnType> &objects, std::ifstream &map_file, std::vector<mapColumnType> &objects,
bool editor, size_t editor_width, bool editor, size_t editor_width,
std::shared_ptr<SDLPP::Renderer> &renderer) { std::shared_ptr<SDLPP::Renderer> &renderer) {
uint16_t cols; uint16_t cols;
map_file.read((char *)&cols, sizeof(uint16_t) / sizeof(char)); map_file.read((char *)&cols, sizeof(uint16_t) / sizeof(char));
if (editor) { if (editor) {
@ -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;

2
mario/maploader.hpp
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

244
mario/scenes/editor_main.cpp
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,18 +138,18 @@ 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");*/
} }
void updateTool() { void updateTool() {
@ -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;
} }

64
mario/scenes/editor_main_menu.cpp
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;

10
mario/scenes/editor_scenes.hpp
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