game/mario/maploader.cpp

#include "maploader.hpp"
#include "../sdlpp/sdlpp_rectrenderer.hpp"
#include <array>
#include <fstream>
#include "sprites.hpp"
#include "blocks.hpp"
#include "objectids.hpp"
#include "global_vars.hpp"

// TODO move to one function
void loadMap( std::shared_ptr< SDLPP::Scene > &scene,
              std::shared_ptr< SDLPP::RectangleRender > mario,
              const std::string &file,
              std::shared_ptr< SDLPP::Renderer > &renderer ) {
    std::ifstream map_file;
    map_file.open( file, std::ios::in | std::ios::binary );
    uint16_t cols;
    map_file.read( ( char * )&cols, sizeof( uint16_t ) / sizeof( char ) );
    for ( uint16_t i = 0; i < cols; i++ ) {
        for ( int j = 0; j < 16; j++ ) {
            uint16_t input_number;
            uint8_t additional_data = 0;
            uint8_t character_type = 0, character = 0, modifier_type = 0,
                    modifier_data = 0;
            map_file.read( ( char * )&input_number,
                           sizeof( uint16_t ) / sizeof( char ) );
            uint8_t type = ( input_number & 0xF000 ) >> 12;
            uint16_t id = ( input_number & 0x0FFF ) | BLOCK_PREFIX;
            if ( type & 0x8 ) {
                map_file.read( ( char * )&additional_data,
                               sizeof( uint8_t ) / sizeof( char ) );
                type &= ~0x8;
                if ( additional_data & 0x80 ) {
                    // modifier
                    additional_data &= ~0x80;
                    modifier_type = ( additional_data & 0xF0 ) >> 4;
                    modifier_data = additional_data & 0x0F;
                } else {
                    // character
                    character_type = ( additional_data & 0xF0 ) >> 4;
                    character = additional_data & 0x0F;
                }
            }
            bool collision = false;
            bool destructible = false;
            if ( id == FLOOR_ID || id == BRICK_ID || id == BRICK_TOP_ID ) {
                collision = true;
            }
            // TODO definitely make this somehow more streamlined, probably
            // flags
            if ( modifier_type == DESTRUCTIBLE_ID ) {
                destructible = true;
            }
            // TODO add modifiers to createTerrainBlock
            auto obj =
                createTerrainBlock( id, static_cast< LandType::Value >( type ),
                                    renderer, i, j, collision, destructible );
            if ( obj != nullptr )
                scene->addObject( obj );
            if ( character ) {
                if ( character == MARIO_ID ) {
                    mario->setPos( i * BLOCK_SIZE,
                                   1 - ( 16 - j ) * BLOCK_SIZE );
                }
            }
        }
    }
    scene->moveZTop( mario );
}

// editor loader
void loadMap( std::shared_ptr< SDLPP::Scene > &scene,
              std::shared_ptr< SDLPP::RenderObject > &mario,
              const std::string &file,
              std::shared_ptr< SDLPP::Renderer > &renderer,
              std::vector< mapColumnType > &objects ) {
    std::ifstream map_file;
    map_file.open( file, std::ios::in | std::ios::binary );
    uint16_t cols;
    map_file.read( ( char * )&cols, sizeof( uint16_t ) / sizeof( char ) );
    objects.resize( cols );
    for ( uint16_t i = 0; i < cols; i++ ) {
        auto &col = objects[i];
        for ( int j = 0; j < 16; j++ ) {
            uint16_t input_number;
            uint8_t additional_data = 0;
            uint8_t character_type = 0, character = 0, modifier_type = 0,
                    modifier_data = 0;
            map_file.read( ( char * )&input_number,
                           sizeof( uint16_t ) / sizeof( char ) );
            uint8_t type = ( input_number & 0xF000 ) >> 12;
            uint16_t id = ( input_number & 0x0FFF ) | BLOCK_PREFIX;
            if ( type & 0x8 ) {
                map_file.read( ( char * )&additional_data,
                               sizeof( uint8_t ) / sizeof( char ) );
                type &= ~0x8;
                if ( additional_data & 0x80 ) {
                    // modifier
                    additional_data &= ~0x80;
                    modifier_type = ( additional_data & 0xF0 ) >> 4;
                    modifier_data = additional_data & 0x0F;
                } else {
                    // character
                    character_type = ( additional_data & 0xF0 ) >> 4;
                    character = additional_data & 0x0F;
                }
            }
            col[j] = { type, id, character_type, character,
                       modifier_type, modifier_data };
            // TODO add modifiers to createTerrainBlock
            auto obj =
                createTerrainBlock( id, static_cast< LandType::Value >( type ),
                                    renderer, i, j, true );
            obj->getCollisions()[0]->setId( EDITOR_TERRAIN_ID );
            scene->addObject( obj );
            if ( character ) {
                if ( character == MARIO_ID ) {
                    scene->addObject( createMario(
                        static_cast< LandType::Value >( character_type ),
                        renderer, i, j ) );
                    mario = scene->getObject(scene->getObjects().size() - 1);
                }
            }
            if ( modifier_type ) {
                auto mod = createTerrainBlock(
                    modifier_type, LandType::OVERWORLD, renderer, i, j,
                    g_translucent_terrain_texture, true );
                mod->getCollisions()[0]->setId( EDITOR_TERRAIN_ID );
                dynamic_cast< MarioBlock * >( mod.get() )->setTerrain( false );
                scene->addObject( mod );
            }
        }
    }
    if ( objects.size() < 18 ) {
        objects.resize( 18 );
    }
}

// tuple - world object type, object, world character type, character, modifier
// type, modifier data
void saveMap( const std::string &file, std::vector< mapColumnType > &objects ) {
    std::ofstream output_file;
    output_file.open( file, std::ios::out | std::ios::binary );
    uint16_t cols = objects.size();
    output_file.write( ( char * )&cols, sizeof( uint16_t ) / sizeof( char ) );
    for ( auto &col : objects ) {
        for ( int i = 0; i < 16; i++ ) {
            auto &obj = col[i];
            uint16_t wide_type = std::get< MapObject::TERRAIN_TYPE >( obj );
            wide_type = wide_type << 12;
            uint16_t write_num =
                ( 0x0FFF & std::get< MapObject::TERRAIN_ID >( obj ) ) |
                wide_type;
            // character type can be 0 (overworld), modifier data can be 0
            if ( std::get< MapObject::CHARACTER_ID >( obj ) ||
                 std::get< MapObject::MODIFIER_TYPE >( obj ) ) {
                write_num |= 0x8000;
            }
            output_file.write( ( char * )&write_num,
                               sizeof( uint16_t ) / sizeof( char ) );
            uint8_t additional_data = 0;
            if ( std::get< MapObject::CHARACTER_ID >( obj ) ) {
                additional_data |= std::get< MapObject::CHARACTER_TYPE >( obj )
                                   << 4;
                additional_data |= std::get< MapObject::CHARACTER_ID >( obj );
            } else if ( std::get< MapObject::MODIFIER_TYPE >( obj ) ) {
                std::cout << "SAVING MODIFIERS!" << std::endl;
                additional_data |= std::get< MapObject::MODIFIER_TYPE >( obj )
                                   << 4;
                additional_data |= 0x80;
                additional_data |= std::get< MapObject::MODIFIER_DATA >( obj );
            }
            if ( additional_data ) {
                output_file.write( ( char * )&additional_data,
                                   sizeof( uint8_t ) / sizeof( char ) );
            }
        }
    }
    output_file.close();
}