GameParam.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
/*
 * This code is based on the CRAB engine
 *
 * Copyright (c) Arvind Raja Yadav
 *
 * Licensed under MIT
 *
 */
 
#ifndef CRAB_GAMEPARAM_H
#define CRAB_GAMEPARAM_H
 
#include "common/hashmap.h"
#include "common/hash-str.h"
#include "common/list.h"
#include "common/rect.h"
#include "common/str.h"
#include "crab/loaders.h"
#include "crab/rapidxml/rapidxml.hpp"
 
namespace Crab {
 
// The index for all levels in the game
struct LevelPath {
    // The file paths
    Common::Path _layout, _asset;
 
    // The name of the level
    Common::String _name;
 
    LevelPath() {}
 
    void load(rapidxml::xml_node<char> *node) {
        loadStr(_name, "name", node);
        loadPath(_layout, "layout", node);
        loadPath(_asset, "res", node);
    }
};
 
// Stores all layout paths for the game
struct FilePaths {
    // Resources common to all levels and states
    Common::Path _common;
 
    // Mod file location, current mod and their extension
    Common::Path _modPath, _modCur;
    Common::String _modExt;
 
    // Main menu resources
    Common::Path _mainmenuL, _mainmenuR;
 
    // Sounds
    Common::Path _soundEffect, _soundMusic;
 
    // Fonts and window icon file
    Common::Path _font, _icon;
 
    // Save directory and extension
    Common::Path _saveDir;
    Common::String _saveExt;
 
    // The location of the shader index file
    Common::Path _shaders;
 
    // The location of the color index file
    Common::Path _colors;
 
    // The list of levels in the game
    Common::HashMap<Common::String, LevelPath> _level;
 
    // The file path of the current resource file
    Common::Path _currentR;
 
    // The application data path (where saves and settings are stored)
    Common::Path _appdata;
 
    // Has this been loaded?
    bool _loaded;
 
    FilePaths();
    void load(const Common::Path &filename);
    void loadLevel(const Common::Path &filename);
};
 
// Storage pool used for saving numbers as strings
class StringPool {
    // Store integer strings here
    // std::unordered_map<int, Common::String> pool_i;
    Common::HashMap<int, Common::String> poolI;
 
    // Store floating point strings here
    struct FloatString {
        float _val;
        Common::String _str;
 
        FloatString() {
            _val = 0.0f;
        }
    };
 
    // std::list<FloatString> pool_f;
    Common::List<FloatString> poolF;
 
public:
    StringPool() {
        poolI.clear();
        poolF.clear();
    }
 
    const char *get(const int &num) {
        if (poolI.contains(num) == false)
            poolI[num] = numberToString<int>(num);
 
        return poolI.getVal(num).c_str();
    }
 
    const char *fGet(const float &num) {
        for (auto &i : poolF)
            if (i._val == num)
                return i._str.c_str();
 
        FloatString fs;
        fs._val = num;
        fs._str = numberToString<float>(num);
        poolF.push_back(fs);
 
        auto ret = poolF.back();
        return ret._str.c_str();
    }
};
 
struct TempValue {
    // Differences between normal mode and iron man mode
    // save button - iron man saves in existing file
    // load button - hidden in iron man
    // exit - saves and exits in iron man
    // quick save and quick load - operate on the iron man file in iron man mode
    bool _ironman;
 
    // This is the filename a player chose when selecting "new game" + iron man mode
    Common::String _filename;
 
    // We use this to see whether the player is exiting to main menu or to credits
    bool _credits;
 
    TempValue() : _filename("No IronMan") {
        _ironman = false;
        _credits = false;
    }
};
 
// Our global objects
 
// Whether to draw debug outlines on polygons
extern bool GameDebug;
 
} // End of namespace Crab
 
#endif // CRAB_GAMEPARAM_H