UOX3.org

//
//  main.cpp
//  mapsize
//
//  Created by Charles Kerr on 9/20/20.
//

#include <iostream>
#include <filesystem>
#include <fstream>
#include <cstring>
#include <string>
#include <exception>

// Forward declares
void fillMapBlock(std::ofstream& output, unsigned short tileid, char alt, int header);

int main(int argc, const char * argv[]) {
   
    if (argc < 9) {
        std::cerr <<"Insufficient arguments" << std::endl;
        std::cerr <<"Calling sequence is:"<<std::endl;
        std::cerr <<"'mapsize oldXblksize oldYblksize newXblksize newYblksize mapmulpath staidxpath tileid altitude'"<<std::endl;
        return 1;
    }
    int oldX = 0 ;
    int oldY = 0 ;
    int newX = 0 ;
    int newY = 0 ;
    std::string mapfile ;
    std::string stafile ;
    unsigned short tileid = 0  ;
    char alt = 0 ;
    try {
        oldX = std::stoi(std::string(argv[1]),0,0) ;
        oldY = std::stoi(std::string(argv[2]),0,0) ;
        newX = std::stoi(std::string(argv[3]),0,0) ;
        newY = std::stoi(std::string(argv[4]),0,0) ;
        mapfile = std::string(argv[5]) ;
        stafile = std::string(argv[6]) ;
        tileid = static_cast<unsigned short>(std::stoi(std::string(argv[7]),0,0));
        alt = static_cast<char>(std::stoi(std::string(argv[8]),0,0));
       
       
    }
    catch (const std::exception& e) {
        std::cerr <<"Error converting arguments: " << e.what() << std::endl;
        return 1 ;
    }
   
    auto nmapfile = mapfile + ".resized" ;
    auto nstafile = stafile + ".resized" ;
    auto mapsize = std::filesystem::file_size(std::filesystem::path(mapfile));
    if (mapsize < (oldX*oldY * 196)) {
        std::cerr << "Specified old x/y blocksize is larger then mapfile size"<< std::endl;
        return 1 ;
    }
    // We know the file size is at least big enough, so we can read it now
    std::ifstream mapinput(mapfile,std::ifstream::in | std::ifstream::binary) ;
    if (!mapinput.is_open()) {
        std::cerr <<"Unable to open file: "<< mapfile <<std::endl;
        return 1;
    }
    std::ifstream stainput(stafile,std::fstream::in | std::ifstream::binary);
   
    if (!stainput.is_open()){
        std::cerr <<"Unable to open file: "<< mapfile <<std::endl;
        return 1;
       
    }
   
    // Both files are open,now open the new ones
    std::ofstream mapoutput(nmapfile,std::ofstream::out|std::ofstream::binary) ;
    if (!mapoutput.is_open()){
        std::cerr <<"Unable to create file: "<< nmapfile <<std::endl;
        return 1;
       
    }
    std::ofstream staoutput(nstafile,std::ofstream::out|std::ofstream::binary) ;
    if (!staoutput.is_open()){
        std::cerr <<"Unable to create file: "<< nstafile <<std::endl;
        mapoutput.close();
        std::filesystem::remove(std::filesystem::path(nmapfile));
        return 1;
       
    }
   
    // Now we have all files opened!
    char mapblock[196];
    char idxblock[12];
    int invalid = -1;
    int zero = 0 ;
   
    for ( auto x = 0 ; x < oldX ; x++){
        if (x >= newX) {
            // we are DONE!
            break;
        }
        for (auto y = 0 ; y < oldY; y++) {
            mapinput.read(mapblock,196);
            stainput.read(idxblock,12);
            if (y < newY) {
                mapoutput.write(mapblock, 196);
                staoutput.write(idxblock,12);
            }
        }
        // Do we have any blank y blocks we need to add?
        auto addblock = newY - oldY ;
        if (addblock > 0) {
            for (auto y=0 ; y< addblock; y++) {
                fillMapBlock(mapoutput, tileid, alt, zero);
                staoutput.write(reinterpret_cast<char*>(&invalid),4);
                staoutput.write(reinterpret_cast<char*>(&zero),4);
                staoutput.write(reinterpret_cast<char*>(&zero),4);
               
            }
        }
       
       
    }
    auto addblock = newX - oldX ;
    for (auto x = 0 ; x<addblock;x++) {
        for (auto y = 0 ; y < newY; y++) {
            fillMapBlock(mapoutput, tileid, alt, zero);
            staoutput.write(reinterpret_cast<char*>(&invalid),4);
            staoutput.write(reinterpret_cast<char*>(&zero),4);
            staoutput.write(reinterpret_cast<char*>(&zero),4);
        }
    }
   
    staoutput.close();
    mapoutput.close();
    mapinput.close();
    stainput.close();
   
   
    return 0;
}

void fillMapBlock(std::ofstream& output, unsigned short tileid, char alt, int header) {
    output.write(reinterpret_cast<char*>(&header),4);
    for (auto i=0 ; i < 64; i++){
        output.write(reinterpret_cast<char*>(&tileid),2);
        output.write(&alt,1);
    }
   
}