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

Compare commits

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

2 Commits
3a80fab3dd ... 58fd1a37a8

Author SHA1 Message Date
zvon
58fd1a37a8 Mario: formatting
Some checks failed
continuous-integration/drone/push Build is failing
Details
2022-07-21 20:17:24 +02:00
zvon
6558329547 Mario: deleted useless files 2022-07-21 20:17:12 +02:00
11 changed files with 373 additions and 334 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 {
bool exists( const string &path );
bool isDirectory( const string &path );
bool rename( const string &file_a, const string &file_b );
bool deleteFile( const string &file );
string canonical( const string &path );
bool createDirectoryFull( const string &path );
string getContainingDirectory( const string &path );
string getFileName( const string &path );
string getFileExtension( const string &path );
bool exists(const string &path);
bool isDirectory(const string &path);
bool rename(const string &file_a, const string &file_b);
bool deleteFile(const string &file);
string canonical(const string &path);
bool createDirectoryFull(const string &path);
string getContainingDirectory(const string &path);
string getFileName(const string &path);
string getFileExtension(const string &path);
extern char dir_divisor;
class Directory {
public:
Directory() = delete;
explicit Directory( const string &path_ );
explicit Directory( const Directory &d ) = default;
explicit Directory( Directory &&d ) = default;
explicit Directory(const string &path_);
explicit Directory(const Directory &d) = default;
explicit Directory(Directory &&d) = default;
class Iterator {
public:
explicit Iterator( const Directory &d_ );
explicit Iterator(const Directory &d_);
~Iterator();
#ifdef _WIN32
explicit Iterator( bool ended_ );
explicit Iterator(bool ended_);
#else
Iterator( const Directory &d_, const struct dirent *current_entry_ );
Iterator(const Directory &d_, const struct dirent *current_entry_);
#endif
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;
Iterator &operator++();
bool operator==( const Iterator &i_other ) const;
bool operator==(const Iterator &i_other) const;
Iterator operator++( int ) {
Iterator ret( *this );
Iterator operator++(int) {
Iterator ret(*this);
operator++();
return ret;
}
bool operator!=( const Iterator &i_other ) const {
return !( i_other == *this );
bool operator!=(const Iterator &i_other) const {
return !(i_other == *this);
}
private:
@ -94,11 +94,11 @@ public:
const_iterator end() const;
iterator begin() {
return Iterator( *this );
return Iterator(*this);
}
const_iterator begin() const {
return Iterator( *this );
return Iterator(*this);
}
const_iterator cbegin() const {
@ -115,7 +115,7 @@ public:
#ifdef _WIN32
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

113
mario/filesystem/unix/filesystem.cpp
View File

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

93
mario/filesystem/windows/filesystem.cpp
View File

@ -6,21 +6,20 @@
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
dir_path.append( L"\\*" );
dir_path.append(L"\\*");
}
FSLib::Directory::Iterator::Iterator( const Directory &d_ ) {
if ( !exists( d_.validPath() ) || !isDirectory( d_.validPath() ) ) {
FSLib::Directory::Iterator::Iterator(const Directory &d_) {
if (!exists(d_.validPath()) || !isDirectory(d_.validPath())) {
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 );
if ( hFind != INVALID_HANDLE_VALUE ) {
if ( !wcscmp( data.cFileName, L"." ) ||
!wcscmp( data.cFileName, L".." ) ) {
++( *this );
hFind = FindFirstFileW(d_.path(), &data);
if (hFind != INVALID_HANDLE_VALUE) {
if (!wcscmp(data.cFileName, L".") || !wcscmp(data.cFileName, L"..")) {
++(*this);
}
} else {
ended = true;
@ -28,37 +27,37 @@ FSLib::Directory::Iterator::Iterator( const Directory &d_ ) {
}
FSLib::Directory::Iterator::~Iterator() {
if ( hFind )
FindClose( hFind );
if (hFind)
FindClose(hFind);
}
// 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
// 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;
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 *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[] full_path;
return string();
}
failed = !PathCanonicalizeW( canonical_path, full_path );
failed = !PathCanonicalizeW(canonical_path, full_path);
delete[] full_path;
if ( failed ) {
if (failed) {
delete[] canonical_path;
return string();
}
@ -68,46 +67,46 @@ string FSLib::canonical( const string &path ) {
return canonical_string;
}
bool FSLib::isDirectory( const string &path ) {
bool FSLib::isDirectory(const string &path) {
struct _stat path_stat;
if ( _wstat( path.c_str(), &path_stat ) != 0 )
if (_wstat(path.c_str(), &path_stat) != 0)
return false;
return path_stat.st_mode & _S_IFDIR;
}
bool FSLib::rename( const string &file_a, const string &file_b ) {
return MoveFileExW( file_a.c_str(), file_b.c_str(),
MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING );
bool FSLib::rename(const string &file_a, const string &file_b) {
return MoveFileExW(file_a.c_str(), file_b.c_str(),
MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING);
}
bool FSLib::createDirectoryFull( const string &path ) {
uint64_t pos = path.find_first_of( L":", 0 ) + 2;
if ( pos == string::npos )
bool FSLib::createDirectoryFull(const string &path) {
uint64_t pos = path.find_first_of(L":", 0) + 2;
if (pos == string::npos)
pos = 0;
// go through all directories leading to the last one
// and create them if they don't exist
do {
// get partial directory path
pos = path.find_first_of( L"\\", pos );
auto dirname = path.substr( 0, pos );
pos = path.find_first_of(L"\\", pos);
auto dirname = path.substr(0, pos);
// create it if it doesn't exist
if ( !FSLib::exists( dirname ) ) {
if ( !CreateDirectoryW( dirname.c_str(), NULL ) )
if (!FSLib::exists(dirname)) {
if (!CreateDirectoryW(dirname.c_str(), NULL))
return false;
}
pos++;
} while ( pos < path.length() && pos != 0 );
} while (pos < path.length() && pos != 0);
return true;
}
FSLib::Directory::iterator FSLib::Directory::end() {
return Iterator( true );
return Iterator(true);
}
FSLib::Directory::const_iterator FSLib::Directory::end() const {
return Iterator( true );
return Iterator(true);
}
char_t const *FSLib::Directory::Iterator::operator*() const {
@ -115,41 +114,41 @@ char_t const *FSLib::Directory::Iterator::operator*() const {
}
FSLib::Directory::Iterator &FSLib::Directory::Iterator::operator++() {
if ( ended == true )
if (ended == true)
return *this;
// skip . and ..
if ( FindNextFileW( hFind, &data ) == 0 ) {
if (FindNextFileW(hFind, &data) == 0) {
ended = true;
} else if ( !wcscmp( data.cFileName, L"." ) ||
!wcscmp( data.cFileName, L".." ) ) {
} else if (!wcscmp(data.cFileName, L".") ||
!wcscmp(data.cFileName, L"..")) {
return operator++();
}
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;
}
string FSLib::getContainingDirectory( const string &path ) {
string FSLib::getContainingDirectory(const string &path) {
auto pos = path.find_last_of('\\');
if(pos == string::npos) {
if (pos == string::npos) {
return ".";
}
return path.substr(0, pos);
}
string FSLib::getFileName( const string &path ) {
string FSLib::getFileName(const string &path) {
auto pos = path.find_last_of('\\');
if(pos == string::npos) {
if (pos == string::npos) {
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('.');
if(pos == string::npos) {
if (pos == string::npos) {
return "";
}
return path.substr(pos + 1);

12
mario/gui/gui.cpp
View File

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

36
mario/maploader.cpp
View File

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

244
mario/scenes/editor_main.cpp
View File

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

64
mario/scenes/editor_main_menu.cpp
View File

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

10
mario/scenes/editor_scenes.hpp
View File

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

20
mario/testmap.txt
View File

@ -1,20 +0,0 @@
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