settings.h

Go to the documentation of this file.

//       _________ __                 __
//      /   _____//  |_____________ _/  |______     ____  __ __  ______
//      \_____  \\   __\_  __ \__  \\   __\__  \   / ___\|  |  \/  ___/
//      /        \|  |  |  | \// __ \|  |  / __ \_/ /_/  >  |  /\___ |
//     /_______  /|__|  |__|  (____  /__| (____  /\___  /|____//____  >
//             \/                  \/          \//_____/            \/
//  ______________________                           ______________________
//                        T H E   W A R   B E G I N S
//         Stratagus - A free fantasy real time strategy game engine
//
//
//      (c) Copyright 2000-2006 by Andreas Arens and Jimmy Salmon
//
//      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; only version 2 of the License.
//
//      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, write to the Free Software
//      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
//      02111-1307, USA.
//
 
#ifndef __SETTINGS_H__
#define __SETTINGS_H__
 
/*
 * This header file defines all the structures that need to be consistent for replays, savegame loading, and
 * multiplayer games.
 */
 
 
#include <bitset>
#include <stdint.h>
#include <string>
#include <vector>
#include <functional>
#include <variant>
 
/*----------------------------------------------------------------------------
--  TODO: Remove this once we move off of tolua++ and can properly support strongly typed enums
----------------------------------------------------------------------------*/
#define USING_TOLUAPP 1
#if USING_TOLUAPP
// using tolua++
#define ENUM_CLASS enum
#else
#define ENUM_CLASS enum class
#endif
 
/*----------------------------------------------------------------------------
--  Some limits
----------------------------------------------------------------------------*/
 
constexpr unsigned char PlayerMax = 16;        
constexpr unsigned short UnitTypeMax = 2048;                
constexpr unsigned short UpgradeMax = 2048;                
constexpr unsigned char MAX_RACES = 8;
constexpr unsigned char PlayerNumNeutral = PlayerMax - 1;  
 
constexpr unsigned char FRAMES_PER_SECOND = 30; // 1/30s
constexpr unsigned char CYCLES_PER_SECOND = 30;  // 1/30s 0.33ms
 
/*----------------------------------------------------------------------------
--  Settings
----------------------------------------------------------------------------*/
 
constexpr int8_t SettingsPresetMapDefault = -1;  
 
ENUM_CLASS PlayerTypes : int8_t {
        MapDefault = SettingsPresetMapDefault, 
        PlayerUnset = 0,                       
        PlayerNeutral = 2,                     
        PlayerNobody  = 3,                     
        PlayerComputer = 4,                    
        PlayerPerson = 5,                      
        PlayerRescuePassive = 6,               
        PlayerRescueActive = 7                 
};
 
extern std::string PlayerTypeNames[static_cast<int>(PlayerTypes::PlayerRescueActive) + 1];
 
static_assert(MAX_RACES < 256, "Race selection needs to fit into 8 bits");
static_assert(PlayerMax < 256, "Team number must fit into 8 bits");
 
struct SettingsPresets {
        int8_t PlayerColor;       
        std::string AIScript;     
        int8_t Race;              
        int8_t Team;              
        PlayerTypes Type;         
 
        void Save(const std::function <void (std::string)>& f) {
                f(std::string("PlayerColor = ") + std::to_string(PlayerColor));
                f(std::string("AIScript = \"") + AIScript + "\"");
                f(std::string("Race = ") + std::to_string(Race));
                f(std::string("Team = ") + std::to_string(Team));
                f(std::string("Type = ") + std::to_string(static_cast<int>(Type)));
        }
 
        void Init() {
                PlayerColor = 0;
                AIScript = "ai-passive";
                Race = SettingsPresetMapDefault;
                Team = SettingsPresetMapDefault;
                Type = PlayerTypes::MapDefault;
        }
 
        bool operator==(const SettingsPresets &other) const {
                return PlayerColor == other.PlayerColor &&
                        AIScript == other.AIScript &&
                        Race == other.Race &&
                        Team == other.Team &&
                        Type == other.Type;
        }
};
 
ENUM_CLASS RevealTypes : uint8_t { 
        cNoRevelation, 
        cAllUnits, 
        cBuildingsOnly 
}; 
 
ENUM_CLASS NetGameTypes : uint8_t {
        SettingsSinglePlayerGame,
        SettingsMultiPlayerGame,
        Unset
};
 
ENUM_CLASS GameTypes : int8_t {
        SettingsGameTypeMapDefault = SettingsPresetMapDefault,
        SettingsGameTypeMelee = 0,
        SettingsGameTypeFreeForAll,
        SettingsGameTypeTopVsBottom,
        SettingsGameTypeLeftVsRight,
        SettingsGameTypeManVsMachine,
        SettingsGameTypeManTeamVsMachine,
        SettingsGameTypeMachineVsMachine,
        SettingsGameTypeMachineVsMachineTraining
 
        // Future game type ideas
#if 0
        SettingsGameTypeOneOnOne,
        SettingsGameTypeCaptureTheFlag,
        SettingsGameTypeGreed,
        SettingsGameTypeSlaughter,
        SettingsGameTypeSuddenDeath,
        SettingsGameTypeTeamMelee,
        SettingsGameTypeTeamCaptureTheFlag
#endif
};
 
ENUM_CLASS MapRevealModes : uint8_t {
        cHidden = 0,
        cKnown,
        cExplored,
        cNumOfModes
};
 
ENUM_CLASS FieldOfViewTypes : uint8_t {
        cShadowCasting,
        cSimpleRadial,
        NumOfTypes
};
 
struct Settings {
        NetGameTypes NetGameType;   
 
        //  Individual presets:
        //  For single-player game only Presets[0] will be used..
        SettingsPresets Presets[PlayerMax];
 
        //  Common settings:
        int8_t Resources;          
        int8_t NumUnits;           
        int8_t Opponents;          
        int8_t Difficulty;         
        GameTypes GameType;        
        FieldOfViewTypes FoV;      
        MapRevealModes RevealMap;  
        RevealTypes DefeatReveal;
        union {
                struct {
                        unsigned NoFogOfWar:1;        
                        unsigned Inside:1;            
                        unsigned AiExplores:1;        
                        unsigned SimplifiedAutoTargeting:1; 
                        unsigned AiChecksDependencies:1; 
                        unsigned UserGameSettings:27; 
                };
                uint32_t _Bitfield;
        };
 
        bool GetUserGameSetting(int i) {
                return std::bitset<27>(UserGameSettings).test(i);
        }
 
        void SetUserGameSetting(int i, bool v) {
                std::bitset<27> bs(UserGameSettings);
                bs.set(i, v);
                UserGameSettings = bs.to_ulong();
        }
 
        bool operator==(const Settings &other) const {
                for (int i = 0; i < PlayerMax; i++) {
                        if (Presets[i] == other.Presets[i]) {
                                continue;
                        } else {
                                return false;
                        }
                }
                return NetGameType == other.NetGameType &&
                        Resources == other.Resources &&
                        NumUnits == other.NumUnits &&
                        Opponents == other.Opponents &&
                        Difficulty == other.Difficulty &&
                        GameType == other.GameType &&
                        FoV == other.FoV &&
                        RevealMap == other.RevealMap &&
                        DefeatReveal == other.DefeatReveal &&
                        _Bitfield == other._Bitfield;
        }
 
        void Save(const std::function <void (std::string)>& f, bool withPlayers = true) {
                f(std::string("NetGameType = ") + std::to_string(static_cast<int>(NetGameType)));
                if (withPlayers) {
                        for (int i = 0; i < PlayerMax; ++i) {
                                Presets[i].Save([&] (std::string field) {
                                        f(std::string("Presets[") + std::to_string(i) + "]." + field);
                                });
                        }
                }
                f(std::string("Resources = ") + std::to_string(Resources));
                f(std::string("NumUnits = ") + std::to_string(NumUnits));
                f(std::string("Opponents = ") + std::to_string(Opponents));
                f(std::string("Difficulty = ") + std::to_string(Difficulty));
                f(std::string("GameType = ") + std::to_string(static_cast<int>(GameType)));
                f(std::string("FoV = ") + std::to_string(static_cast<int>(FoV)));
                f(std::string("RevealMap = ") + std::to_string(static_cast<int>(RevealMap)));
                f(std::string("DefeatReveal = ") + std::to_string(static_cast<int>(DefeatReveal)));
                f(std::string("Flags = ") + std::to_string(_Bitfield));
        }
 
        bool SetField(std::string field, int value) {
                if (field == "NetGameType") {
                        NetGameType = static_cast<NetGameTypes>(value);
                } else if (field == "Resources") {
                        Resources = value;
                } else if (field == "NumUnits") {
                        NumUnits = value;
                } else if (field == "Opponents") {
                        Opponents = value;
                } else if (field == "Difficulty") {
                        Difficulty = value;
                } else if (field == "GameType") {
                        GameType = static_cast<GameTypes>(value);
                } else if (field == "FoV") {
                        FoV = static_cast<FieldOfViewTypes>(value);
                } else if (field == "RevealMap") {
                        RevealMap = static_cast<MapRevealModes>(value);
                } else if (field == "DefeatReveal") {
                        DefeatReveal = static_cast<RevealTypes>(value);
                } else if (field == "Flags") {
                        _Bitfield = value;
                } else {
                        return false;
                }
                return true;
        }
 
        void Init() {
                NetGameType = NetGameTypes::SettingsSinglePlayerGame;
                for (int i = 0; i < PlayerMax; ++i) {
                        Presets[i].Init();
                        Presets[i].PlayerColor = i;
                }
                Resources = SettingsPresetMapDefault;
                NumUnits = SettingsPresetMapDefault;
                Opponents = SettingsPresetMapDefault;
                Difficulty = SettingsPresetMapDefault;
                GameType = GameTypes::SettingsGameTypeMapDefault;
                FoV = FieldOfViewTypes::cSimpleRadial;
                RevealMap = MapRevealModes::cHidden;
                DefeatReveal = RevealTypes::cAllUnits;
                NoFogOfWar = 0;
                Inside = 0;
                AiExplores = 1;
                AiChecksDependencies = 0;
                SimplifiedAutoTargeting = 0;
                UserGameSettings = 0;
        }
};
 
/*----------------------------------------------------------------------------
--  Variables
----------------------------------------------------------------------------*/
 
extern Settings GameSettings;  
 
/*----------------------------------------------------------------------------
--  Functions
----------------------------------------------------------------------------*/
 
extern void InitSettings();
 
 
#endif // !__SETTINGS_H__