Leviathan::AppDef Class Reference

#include <AppDefine.h>

Public Member Functions
DLLEXPORT	AppDef (const bool &isdef=false)
virtual DLLEXPORT	~AppDef ()
DLLEXPORT NamedVars *	GetValues ()
DLLEXPORT AppDef &	SetWindowDetails (const WindowDataDetails &det)
DLLEXPORT AppDef &	SetMasterServerParameters (const MasterServerInformation &info)
DLLEXPORT AppDef &	SetApplicationIdentification (const std::string &userreadable, const std::string &gamename, const std::string &gameversion)
DLLEXPORT WindowDataDetails &	GetWindowDetails ()
DLLEXPORT MasterServerInformation &	GetMasterServerInfo ()
DLLEXPORT auto *	GetGameConfiguration ()
DLLEXPORT auto *	GetKeyConfiguration ()
DLLEXPORT void	StoreWindowDetails (const std::string &title, const bool &windowborder, LeviathanApplication *appvirtualptr)
DLLEXPORT void	GetGameIdentificationData (std::string &userreadable, std::string &gamename, std::string &gameversion)
virtual DLLEXPORT bool	FillDefaultEngineConf (NamedVars &variables)
	This is called then the engine config file isn't found to fill the options with default values. More...
DLLEXPORT void	ReplaceGameAndKeyConfigInMemory (std::function< void(Lock &guard, GameConfiguration *configobj)> configchecker=nullptr, std::function< void(Lock &guard, KeyConfiguration *keysobject)> keychecker=nullptr)
	Creates game and key configurations without file backing that are empty. More...

Static Public Member Functions
static DLLEXPORT AppDef *	GetDefault ()
static DLLEXPORT AppDef *	GenerateAppdefine (const std::string &engineconfigfile, const std::string &gameconfig, const std::string &keyconfig, std::function< void(Lock &guard, GameConfiguration *configobj)> configchecker, std::function< void(Lock &guard, KeyConfiguration *keysobject)> keychecker)

Protected Attributes
std::unique_ptr< NamedVars >	ConfigurationValues
int	HInstance
MasterServerInformation	MasterServerInfo
std::shared_ptr< NetworkInterface >	_NetworkInterface
WindowDataDetails	WDetails
GameConfiguration *	_GameConfiguration = nullptr
KeyConfiguration *	_KeyConfiguration = nullptr
Logger *	Mainlog = nullptr
bool	DeleteLog = false
std::string	LeviathanVersion
std::string	GameVersion
std::string	Game
std::string	UserReadableGame

Static Protected Attributes
static AppDef *	Defaultconf = nullptr

Detailed Description

Definition at line 48 of file AppDefine.h.

Constructor & Destructor Documentation

AppDef()

DLLEXPORT Leviathan::AppDef::AppDef

(

const bool &

isdef = false

)

Definition at line 15 of file AppDefine.cpp.

                                                     :
    ConfigurationValues(new NamedVars()),
#ifdef _WIN32
    HInstance(NULL)
#else
    HInstance(0)
#endif //_WIN32
{
    // If this is the default configuration set as the static access one //
    if(isdef)
        Defaultconf = this;
}

~AppDef()

AppDef::~AppDef ( )

virtual

Definition at line 28 of file AppDefine.cpp.

{
    // reset static access if this is it //
    if(Defaultconf == this)
        Defaultconf = nullptr;

    SAFE_RELEASEDEL(_GameConfiguration);
    SAFE_RELEASEDEL(_KeyConfiguration);
}

Member Function Documentation

FillDefaultEngineConf()

DLLEXPORT bool AppDef::FillDefaultEngineConf ( NamedVars &  variables )

virtual

This is called then the engine config file isn't found to fill the options with default values.

This is also used to fill existing configs with missing values

Returns

True if options need to be saved (changes were made)

Definition at line 193 of file AppDefine.cpp.

{
    bool changed = false;

    if(variables.ShouldAddValueIfNotFoundOrWrongType<bool>("Vsync")) {
        changed = true;
        variables.Add(std::make_shared<NamedVariableList>("Vsync", false));
    }

    if(variables.ShouldAddValueIfNotFoundOrWrongType<std::string>("FullScreen")) {
        changed = true;
        variables.Add(
            std::make_shared<NamedVariableList>("FullScreen", new StringBlock("no")));
    }

    if(variables.ShouldAddValueIfNotFoundOrWrongType<int>("DisplayNumber")) {
        changed = true;
        variables.Add(std::make_shared<NamedVariableList>("DisplayNumber", 0));
    }

    if(variables.ShouldAddValueIfNotFoundOrWrongType<int>("Width")) {
        changed = true;
        variables.Add(std::make_shared<NamedVariableList>("Width", 1280));
    }

    if(variables.ShouldAddValueIfNotFoundOrWrongType<int>("Height")) {
        changed = true;
        variables.Add(std::make_shared<NamedVariableList>("Height", 720));
    }

    if(variables.ShouldAddValueIfNotFoundOrWrongType<int>("MaxFPS")) {
        changed = true;
        variables.Add(std::make_shared<NamedVariableList>("MaxFPS", 144));
    }

    if(variables.ShouldAddValueIfNotFoundOrWrongType<std::string>("AudioDevice")) {

        changed = true;
        variables.Add(
            std::make_shared<NamedVariableList>("AudioDevice", new StringBlock("default")));
    }

    return changed;
}

GenerateAppdefine()

DLLEXPORT AppDef * Leviathan::AppDef::GenerateAppdefine ( const std::string &  engineconfigfile, const std::string &  gameconfig, const std::string &  keyconfig, std::function< void(Lock &guard, GameConfiguration *configobj)>  configchecker, std::function< void(Lock &guard, KeyConfiguration *keysobject)>  keychecker  )

static

Definition at line 45 of file AppDefine.cpp.

{
    auto tmpptr = std::make_unique<AppDef>(true);

    // We created a new one //
    tmpptr->DeleteLog = true;

    if(!Logger::Get()) {

        std::cout << "Error: main log hasn't been created before AppDef: GenerateAppdefine"
                  << std::endl;
        return nullptr;
    }

    // load variables from configuration file //
    // TODO: refactor this duplicated code
    if(!tmpptr->ConfigurationValues->LoadVarsFromFile(engineconfigfile, Logger::Get())) {

        // Set default values //
        tmpptr->FillDefaultEngineConf(*tmpptr->ConfigurationValues);

        // Write it to the file for next time //
        if(!FileSystem::WriteToFile(
               tmpptr->ConfigurationValues->Serialize(), engineconfigfile)) {

            LOG_ERROR(
                "AppDef: failed to write default engine config to file: " + engineconfigfile);
        }
    } else {
        // Fill missing values //
        if(tmpptr->FillDefaultEngineConf(*tmpptr->ConfigurationValues)) {

            // Save changes
            if(!FileSystem::WriteToFile(
                   tmpptr->ConfigurationValues->Serialize(), engineconfigfile)) {

                LOG_ERROR("AppDef: failed to write amended engine config to file: " +
                          engineconfigfile);
            }
        }
    }

    // Load game configuration //
    tmpptr->_GameConfiguration = new GameConfiguration(gameconfig);

    if(!tmpptr->_GameConfiguration->Init(configchecker)) {

        return nullptr;
    }

    // Load key configuration //
    tmpptr->_KeyConfiguration = new KeyConfiguration(keyconfig);

    if(!tmpptr->_KeyConfiguration->Init(keychecker)) {

        return nullptr;
    }

    return tmpptr.release();
}

GetDefault()

static DLLEXPORT AppDef* Leviathan::AppDef::GetDefault ( )

inlinestatic

Definition at line 112 of file AppDefine.h.

    {
        return Defaultconf;
    }

GetGameConfiguration()

DLLEXPORT auto* Leviathan::AppDef::GetGameConfiguration ( )

inline

Definition at line 102 of file AppDefine.h.

    {
        return _GameConfiguration;
    }

GetGameIdentificationData()

DLLEXPORT void Leviathan::AppDef::GetGameIdentificationData	(	std::string &	userreadable,
		std::string &	gamename,
		std::string &	gameversion
	)

Definition at line 185 of file AppDefine.cpp.

{
    userreadable = UserReadableGame;
    gamename = Game;
    gameversion = GameVersion;
}

GetKeyConfiguration()

DLLEXPORT auto* Leviathan::AppDef::GetKeyConfiguration ( )

inline

Definition at line 107 of file AppDefine.h.

    {
        return _KeyConfiguration;
    }

GetMasterServerInfo()

DLLEXPORT MasterServerInformation& Leviathan::AppDef::GetMasterServerInfo ( )

inline

Definition at line 97 of file AppDefine.h.

    {
        return MasterServerInfo;
    }

GetValues()

NamedVars * Leviathan::AppDef::GetValues

(

)

Definition at line 40 of file AppDefine.cpp.

{
    return ConfigurationValues.get();
}

GetWindowDetails()

DLLEXPORT WindowDataDetails& Leviathan::AppDef::GetWindowDetails ( )

inline

Definition at line 93 of file AppDefine.h.

    {
        return WDetails;
    }

ReplaceGameAndKeyConfigInMemory()

DLLEXPORT void AppDef::ReplaceGameAndKeyConfigInMemory	(	std::function< void(Lock &guard, GameConfiguration *configobj)>	configchecker = nullptr,
		std::function< void(Lock &guard, KeyConfiguration *keysobject)>	keychecker = nullptr
	)

Creates game and key configurations without file backing that are empty.

Definition at line 109 of file AppDefine.cpp.

{
    if(_GameConfiguration)
        delete _GameConfiguration;

    _GameConfiguration = new GameConfiguration();

    if(!_GameConfiguration->Init(configchecker)) {

        LOG_ERROR("AppDef: failed to init new in-memory game configuration");
    }

    // Load key configuration //
    _KeyConfiguration = new KeyConfiguration();

    if(!_KeyConfiguration->Init(keychecker)) {

        LOG_ERROR("AppDef: failed to init new in-memory key configuration");
    }
}

SetApplicationIdentification()

DLLEXPORT AppDef & Leviathan::AppDef::SetApplicationIdentification	(	const std::string &	userreadable,
		const std::string &	gamename,
		const std::string &	gameversion
	)

Definition at line 173 of file AppDefine.cpp.

{
    UserReadableGame = userreadable;
    Game = gamename;
    GameVersion = gameversion;
    LeviathanVersion = LEVIATHAN_VERSION_ANSIS;

    return *this;
}

SetMasterServerParameters()

DLLEXPORT AppDef& Leviathan::AppDef::SetMasterServerParameters ( const MasterServerInformation &  info )

inline

Definition at line 82 of file AppDefine.h.

    {

        MasterServerInfo = info;
        return *this;
    }

SetWindowDetails()

DLLEXPORT AppDef& Leviathan::AppDef::SetWindowDetails ( const WindowDataDetails &  det )

inline

Definition at line 75 of file AppDefine.h.

    {

        WDetails = det;
        return *this;
    }

StoreWindowDetails()

DLLEXPORT void Leviathan::AppDef::StoreWindowDetails	(	const std::string &	title,
		const bool &	windowborder,
		LeviathanApplication *	appvirtualptr
	)

Definition at line 139 of file AppDefine.cpp.

{
#endif
    // store the parameters to be used for window creation //
    int width;
    int height;
    std::string fullscreen;
    int FSAA;
    int displayNumber;
    bool vsync;

    ObjectFileProcessor::LoadValueFromNamedVars(
        ConfigurationValues.get(), "Width", width, 1280, Logger::Get(), "Create window: ");
    ObjectFileProcessor::LoadValueFromNamedVars(
        ConfigurationValues.get(), "Height", height, 720, Logger::Get(), "Create window: ");
    ObjectFileProcessor::LoadValueFromNamedVars<std::string>(ConfigurationValues.get(),
        "FullScreen", fullscreen, "no", Logger::Get(), "Create window: ");
    ObjectFileProcessor::LoadValueFromNamedVars<int>(
        ConfigurationValues.get(), "WindowMultiSampleCount", FSAA, 1);
    ObjectFileProcessor::LoadValueFromNamedVars<int>(ConfigurationValues.get(),
        "DisplayNumber", displayNumber, 0, Logger::Get(), "Create window: ");
    ObjectFileProcessor::LoadValueFromNamedVars<bool>(
        *ConfigurationValues, "Vsync", vsync, false, Logger::Get(), "Create window: ");

#ifdef _WIN32
    this->SetWindowDetails(WindowDataDetails(title, width, height, fullscreen, vsync,
        displayNumber, FSAA, windowborder, icon, appvirtualptr));
#else
    this->SetWindowDetails(WindowDataDetails(title, width, height, fullscreen, vsync,
        displayNumber, FSAA, windowborder, appvirtualptr));
#endif
}

Member Data Documentation

_GameConfiguration

GameConfiguration* Leviathan::AppDef::_GameConfiguration = nullptr

protected

Definition at line 161 of file AppDefine.h.

_KeyConfiguration

KeyConfiguration* Leviathan::AppDef::_KeyConfiguration = nullptr

protected

Definition at line 162 of file AppDefine.h.

_NetworkInterface

std::shared_ptr<NetworkInterface> Leviathan::AppDef::_NetworkInterface

protected

Definition at line 155 of file AppDefine.h.

ConfigurationValues

std::unique_ptr<NamedVars> Leviathan::AppDef::ConfigurationValues

protected

Definition at line 147 of file AppDefine.h.

Defaultconf

AppDef * Leviathan::AppDef::Defaultconf = nullptr

staticprotected

Definition at line 177 of file AppDefine.h.

DeleteLog

bool Leviathan::AppDef::DeleteLog = false

protected

Controls whether the destructor deletes Mainlog

Note

Used to not delete loggers that weren't created by this instance

Definition at line 169 of file AppDefine.h.

Game

std::string Leviathan::AppDef::Game

protected

Definition at line 173 of file AppDefine.h.

GameVersion

std::string Leviathan::AppDef::GameVersion

protected

Definition at line 172 of file AppDefine.h.

HInstance

int Leviathan::AppDef::HInstance

protected

Definition at line 151 of file AppDefine.h.

LeviathanVersion

std::string Leviathan::AppDef::LeviathanVersion

protected

Definition at line 171 of file AppDefine.h.

Mainlog

Logger* Leviathan::AppDef::Mainlog = nullptr

protected

Definition at line 164 of file AppDefine.h.

MasterServerInfo

MasterServerInformation Leviathan::AppDef::MasterServerInfo

protected

Definition at line 153 of file AppDefine.h.

UserReadableGame

std::string Leviathan::AppDef::UserReadableGame

protected

Definition at line 174 of file AppDefine.h.

WDetails

WindowDataDetails Leviathan::AppDef::WDetails

protected

Definition at line 158 of file AppDefine.h.

---

The documentation for this class was generated from the following files:

• AppDefine.h
• AppDefine.cpp