Robuste Daten und du

Scorcher24

Ich habe hier mal wieder eine dieser Grundsatzfragen... :p

Spritesheet Packer produziert diese Text Datei für den Atlas:

save = 1921 257 256 256
settings = 2178 0 256 256
sound-off = 1921 514 256 256
sound-on = 2435 0 256 256
stop = 2178 257 256 256
tick = 2692 0 256 256
trolley = 2435 257 256 256
twitter = 2178 514 256 256
up = 1921 771 256 256
volume-down = 1799 1081 256 256
volume-up = 2435 514 256 256
warship = 0 1852 242 194

Ist relativ einfach zu verstehen und zu parsen (dateiname, pos_x, pos_y, size_x, size_y):

//-----------------------------------------------------------------
/* static */ Atlas* Atlas::load(const std::wstring& txtFile, const std::wstring& png)
//-----------------------------------------------------------------
{
    //Create new Instance
    Atlas* atlas = new Atlas();

    // Load Texture
    atlas->m_texture = Texture::loadTexture(png);
    if (atlas->m_texture == nullptr)
    {
        WRITE_LOG_ERROR(L"Sprite Atlas cannot be loaded due to missing " + png);
        delete atlas;
        return nullptr;
    }

    // Load Data
    std::ifstream iStream(buildGamePath(txtFile));
    if (!iStream.is_open())
    {
        WRITE_LOG_ERROR(L"Sprite Atlas cannot be laded due to missing " + buildGamePath(txtFile));
        delete atlas;
        return nullptr;
    }

    // Parse Data
    while (!iStream.eof())
    {
        std::string line;
        std::vector<std::string> tokens;

        std::getline(iStream, line);
        const boost::char_delimiters_separator<char> separator(" ", "=");
        boost::tokenizer<> tokenizer(line, separator);

        for (auto it = tokenizer.begin(); it != tokenizer.end(); ++it)
        {
            tokens.push_back(*it);
        }

        try
        {
            if (!line.empty())
            {
                std::string name = tokens[0];
                std::transform(name.begin(), name.end(), name.begin(), ::tolower);

                // 1 is omitted, since it contains the equal sign
                int pos_x        = boost::lexical_cast<int>(tokens[2]);
		int pos_y        = boost::lexical_cast<int>(tokens[3]);
		int width        = boost::lexical_cast<int>(tokens[4]);
		int height       = boost::lexical_cast<int>(tokens[5]);                

	        VTextureCoords coords;
                coords.resize(4);

			    coords[0].s = pos_x / atlas->m_texture->getSize().x;
			    coords[0].t = pos_y / atlas->m_texture->getSize().y;

			    coords[1].s = ( pos_x + width ) / atlas->m_texture->getSize().x;
			    coords[1].t = pos_y / atlas->m_texture->getSize().y;

			    coords[2].s = pos_x / atlas->m_texture->getSize().x;
			    coords[2].t = (pos_y + height ) / atlas->m_texture->getSize().y;

			    coords[3].s = ( pos_x + width  ) / atlas->m_texture->getSize().x;
			    coords[3].t = ( pos_y + height ) / atlas->m_texture->getSize().y;      

                atlas->m_textureCoords.insert(std::make_pair(name, coords));                   
            }            
        }
        catch (const boost::bad_lexical_cast& e)
        {
            delete atlas;
            WRITE_LOG_ERROR(convertFromString(e.what()));
            return nullptr;
        }
    }    
    return atlas;
}

Irgendwas in mir hat jedoch das Bedürfnis das ganze in ein JSON oder XML Datei umzuwandeln, bevor ich sowas veröffentlichen würde.
Wie steht ihr dazu? Mir geht es hier nicht um Obfuskierung oder ähnliches, aber kleinste Änderungen können das obige Format aus der Bahn werfen. Eine Änderung in einer XML Datei allerdings auch. Auf der einen Seite sehe ich eventuell unnötige Arbeit (den Konverter schreiben) versus robustere Daten auf dem Rechner des Spielers.

Wie seht ihr das? Mach ich mir hier unnötig Gedanken zu?

inflames2k

Ich denke schon, das du dir unnötig Gedanken machst. In jedem Format ist es so, dass falsche Anpassungen das Format zerstören.

Die Grundfrage ist ja, soll der Endnutzer an den Infos rumspielen können oder soll er sie As-Is verwenden? - In ersterem Falle wäre ein saubereres Format sicher hilfreich, im zweiten Fall eher unnötige Arbeit.