410 lines
11 KiB
C++
410 lines
11 KiB
C++
// ==============================================================
|
|
// This file is part of Glest (www.glest.org)
|
|
//
|
|
// Copyright (C) 2001-2008 Martiño Figueroa
|
|
//
|
|
// You can redistribute this code and/or modify it under
|
|
// the terms of the GNU General Public License as published
|
|
// by the Free Software Foundation; either version 2 of the
|
|
// License, or (at your option) any later version
|
|
// ==============================================================
|
|
|
|
#include "game_util.h"
|
|
|
|
#include "util.h"
|
|
#include "lang.h"
|
|
#include "game_constants.h"
|
|
#include "config.h"
|
|
#include <stdlib.h>
|
|
#include "platform_util.h"
|
|
#include "conversion.h"
|
|
#include "cache_manager.h"
|
|
#include "errno.h"
|
|
#include "leak_dumper.h"
|
|
|
|
using namespace Shared::Util;
|
|
using namespace Shared::Platform;
|
|
|
|
namespace Glest { namespace Game {
|
|
|
|
const char *mailString = " http://bugs.megaglest.org";
|
|
|
|
// !! Use minor versions !! Only major and minor version control compatibility!
|
|
// typical version numbers look like this: v3.13-beta1.0 v3.12-dev v3.12.1
|
|
// don't forget to update file: source/version.txt
|
|
const string glestVersionString = "v3.13-dev";
|
|
const string lastCompatibleSaveGameVersionString = "v3.11.1";
|
|
|
|
#if defined(GITVERSIONHEADER)
|
|
#include "gitversion.h"
|
|
#endif
|
|
#if defined(GITVERSION) || defined(GITVERSIONHEADER)
|
|
const string GIT_RawRev = string(GITVERSION);
|
|
#else
|
|
const string GIT_RawRev = "$5608.a3c8464$";
|
|
#endif
|
|
const string GIT_Rev = string("Rev: ") + string(GIT_RawRev);
|
|
|
|
string getRAWGITRevisionString() {
|
|
return GIT_RawRev;
|
|
}
|
|
string getCrashDumpFileName(){
|
|
return "megaglest" + glestVersionString + ".dmp";
|
|
}
|
|
|
|
string getPlatformTypeNameString() {
|
|
static string platform;
|
|
if(platform == "") {
|
|
#if defined(WIN32)
|
|
|
|
#if defined(__MINGW32__)
|
|
platform = "W-Ming32";
|
|
#else
|
|
platform = "Windows";
|
|
#endif
|
|
|
|
#elif defined(__FreeBSD__)
|
|
platform = "FreeBSD";
|
|
#elif defined(__NetBSD__)
|
|
platform = "NetBSD";
|
|
#elif defined(__OpenBSD__)
|
|
platform = "OpenBSD";
|
|
|
|
#elif defined(__APPLE__)
|
|
platform = "MacOS";
|
|
#elif defined(_AIX)
|
|
platform = "AIX";
|
|
#elif defined(__ANDROID__)
|
|
platform = "Android";
|
|
#elif defined(__BEOS__)
|
|
platform = "BEOS";
|
|
#elif defined(__gnu_linux__)
|
|
platform = "Linux";
|
|
#elif defined(__sun)
|
|
platform = "Solaris";
|
|
|
|
#elif defined(__GNUC__)
|
|
|
|
#if defined(__MINGW32__)
|
|
platform = "L-Ming32";
|
|
#else
|
|
platform = "GNU";
|
|
#endif
|
|
|
|
#else
|
|
platform = "???";
|
|
#endif
|
|
}
|
|
return platform;
|
|
}
|
|
|
|
string getPlatformArchTypeNameString() {
|
|
static string platform;
|
|
if(platform == "") {
|
|
|
|
#if defined(_M_X64) || defined(_M_AMD64) || defined(__x86_64__) || defined(_WIN64)
|
|
platform = "-X64";
|
|
#elif defined(_M_ALPHA) || defined(__alpha__)
|
|
platform = "-ALPHA";
|
|
#elif defined(_M_IA64) || defined(__ia64__)
|
|
platform = "-IA64";
|
|
#elif defined(_M_MRX000) || defined(__mips__)
|
|
platform = "-MIPS";
|
|
#elif defined(_M_PPC) || defined(__powerpc__)
|
|
platform = "-POWERPC";
|
|
#elif defined(__sparc__)
|
|
platform = "-SPARC";
|
|
#elif defined(_M_ARM_FP) || defined(__arm__) || defined(_M_ARM)
|
|
platform = "-ARM";
|
|
|
|
#endif
|
|
}
|
|
return platform;
|
|
}
|
|
|
|
string getPlatformNameString() {
|
|
static string platform;
|
|
if(platform == "") {
|
|
platform = getPlatformTypeNameString() + getPlatformArchTypeNameString();
|
|
}
|
|
return platform;
|
|
}
|
|
|
|
string getGITRevisionString() {
|
|
return GIT_Rev;
|
|
}
|
|
|
|
string getCompilerNameString() {
|
|
static string version = "";
|
|
if(version == "") {
|
|
#if defined(WIN32) && defined(_MSC_VER)
|
|
version = "VC++: " + intToStr(_MSC_VER);
|
|
|
|
|
|
#elif defined(__clang__)
|
|
version = "Clang: " + intToStr(__clang_major__) + "." + intToStr(__clang_minor__) + "." + intToStr(__clang_patchlevel__);
|
|
|
|
#elif defined(__GNUC__)
|
|
#if defined(__GNUC__)
|
|
# if defined(__GNUC_PATCHLEVEL__)
|
|
# define __GNUC_VERSION__ (__GNUC__ * 10000 \
|
|
+ __GNUC_MINOR__ * 100 \
|
|
+ __GNUC_PATCHLEVEL__)
|
|
# else
|
|
# define __GNUC_VERSION__ (__GNUC__ * 10000 \
|
|
+ __GNUC_MINOR__ * 100)
|
|
# endif
|
|
#endif
|
|
version = "GNUC";
|
|
|
|
#if defined(__MINGW32__)
|
|
version += "-MINGW";
|
|
#endif
|
|
|
|
version += ": " + intToStr(__GNUC_VERSION__);
|
|
|
|
#else
|
|
version = "???";
|
|
#endif
|
|
|
|
#if defined(DEBUG) || defined(_DEBUG)
|
|
version += " [DEBUG]";
|
|
#endif
|
|
|
|
#if defined(_M_X64) || defined(_M_IA64) || defined(_M_AMD64) || defined(__x86_64__) || defined(_WIN64)
|
|
version += " [64bit]";
|
|
#endif
|
|
}
|
|
return version;
|
|
}
|
|
|
|
string getNetworkVersionString() {
|
|
static string version = "";
|
|
if(version == "") {
|
|
version = glestVersionString+"-"+getCompilerNameString()+"-"+getCompileDateTime();
|
|
}
|
|
return version;
|
|
}
|
|
|
|
string getNetworkVersionGITString() {
|
|
static string version = "";
|
|
if(version == "") {
|
|
version = glestVersionString + "-" + getGITRevisionString() + "-" + getCompilerNameString();
|
|
}
|
|
return version;
|
|
}
|
|
|
|
string getCompileDateTime() {
|
|
static string result = "";
|
|
// if(result == "") {
|
|
// result = string(__DATE__) + " " + string(__TIME__);
|
|
// }
|
|
return result;
|
|
}
|
|
|
|
string getNetworkPlatformFreeVersionString() {
|
|
return glestVersionString;
|
|
}
|
|
|
|
string getAboutString1(int i) {
|
|
//case 1: return "Built: " + string(__DATE__) + " " + GIT_Rev;
|
|
switch(i) {
|
|
case 0: return "MegaGlest " + glestVersionString + " (" + "Shared Library " + sharedLibVersionString + ")";
|
|
case 1: return GIT_Rev;
|
|
case 2: return "Copyright 2001-2010 The Glest Team";
|
|
case 3: return "Copyright 2010-2021 The MegaGlest Team";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
string getAboutString2(int i) {
|
|
switch(i) {
|
|
case 0: return "Web: https://megaglest.org";
|
|
case 1: return "Bug reports: " + string(mailString);
|
|
case 2: return "IRC: irc://irc.libera.chat/megaglest";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
string getTeammateName(int i) {
|
|
switch(i) {
|
|
case 0: return "Martiño Figueroa";
|
|
//case 0: return "Martino Figueroa";
|
|
case 1: return "José Luis González";
|
|
//case 1: return "Jose Luis Gonzalez";
|
|
case 2: return "Tucho Fernández";
|
|
//case 2: return "Tucho Fernandez";
|
|
case 3: return "José Zanni";
|
|
//case 3: return "Jose Zanni";
|
|
case 4: return "Félix Menéndez";
|
|
//case 4: return "Felix Menendez";
|
|
case 5: return "Marcos Caruncho";
|
|
case 6: return "Matthias Braun";
|
|
case 7: return "Titus Tscharntke";
|
|
case 8: return "Mark Vejvoda";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
string getTeammateRole(int i) {
|
|
Lang &lang = Lang::getInstance();
|
|
|
|
switch(i) {
|
|
case 0: return lang.getString("Programming");
|
|
case 1: return lang.getString("SoundAndMusic");
|
|
case 2: return lang.getString("3dAnd2dArt");
|
|
case 3: return lang.getString("2dArtAndWeb");
|
|
case 4: return lang.getString("Animation");
|
|
case 5: return lang.getString("3dArt");
|
|
case 6: return lang.getString("LinuxPort");
|
|
case 7: return lang.getString("Megaglest3d2dProgramming");
|
|
case 8: return lang.getString("MegaglestProgramming");
|
|
}
|
|
return "";
|
|
}
|
|
|
|
string formatString(string str) {
|
|
string outStr = str;
|
|
|
|
if(!outStr.empty()){
|
|
outStr[0]= toupper(outStr[0]);
|
|
}
|
|
|
|
bool afterSeparator= false;
|
|
for(int i= 0; i < (int)str.size(); ++i){
|
|
if(outStr[i]=='_'){
|
|
outStr[i]= ' ';
|
|
}
|
|
else if(afterSeparator){
|
|
outStr[i]= toupper(outStr[i]);
|
|
afterSeparator= false;
|
|
}
|
|
if(outStr[i]=='\n' || outStr[i]=='(' || outStr[i]==' '){
|
|
afterSeparator= true;
|
|
}
|
|
}
|
|
return outStr;
|
|
}
|
|
|
|
string getGameCustomCoreDataPath(string originalBasePath, string uniqueFilePath) {
|
|
// original file path setup
|
|
if(originalBasePath != "") {
|
|
endPathWithSlash(originalBasePath);
|
|
}
|
|
//
|
|
|
|
// mydata user data override
|
|
Config &config = Config::getInstance();
|
|
string data_path = config.getString("UserData_Root","");
|
|
if(data_path != "") {
|
|
endPathWithSlash(data_path);
|
|
}
|
|
//
|
|
|
|
// if set this is the current active mod
|
|
string custom_mod_path = config.getCustomRuntimeProperty(Config::ACTIVE_MOD_PROPERTY_NAME);
|
|
if(custom_mod_path != "") {
|
|
endPathWithSlash(custom_mod_path);
|
|
}
|
|
//
|
|
|
|
// decide which file to use
|
|
string result = "";
|
|
|
|
if (SystemFlags::VERBOSE_MODE_ENABLED) printf("Looking for [%s] in\n#1: [%s]\n#2: [%s]\n#3: [%s]\n",uniqueFilePath.c_str(),custom_mod_path.c_str(),data_path.c_str(),originalBasePath.c_str());
|
|
|
|
if(custom_mod_path != "" &&
|
|
(uniqueFilePath == "" || fileExists(custom_mod_path + uniqueFilePath) == true)) {
|
|
result = custom_mod_path + uniqueFilePath;
|
|
}
|
|
else if(data_path != "" &&
|
|
(uniqueFilePath == "" || fileExists(data_path + uniqueFilePath) == true)) {
|
|
result = data_path + uniqueFilePath;
|
|
}
|
|
else {
|
|
result = originalBasePath + uniqueFilePath;
|
|
}
|
|
|
|
if (SystemFlags::VERBOSE_MODE_ENABLED) printf("result [%s]\n",result.c_str());
|
|
|
|
return result;
|
|
}
|
|
|
|
string getGameReadWritePath(const string &lookupKey) {
|
|
string path = "";
|
|
|
|
if(lookupKey != "") {
|
|
std::map<string,string> &pathCache = CacheManager::getCachedItem< std::map<string,string> >(GameConstants::pathCacheLookupKey);
|
|
std::map<string,string>::const_iterator iterFind = pathCache.find(lookupKey);
|
|
if(iterFind != pathCache.end()) {
|
|
path = iterFind->second;
|
|
|
|
if(path != "" && EndsWith(path, "/") == false && EndsWith(path, "\\") == false) {
|
|
path += "/";
|
|
}
|
|
|
|
//SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d] path to be used for [%s] files [%s]\n",__FILE__,__FUNCTION__,__LINE__,lookupKey.c_str(),path.c_str());
|
|
}
|
|
}
|
|
|
|
if(path == "") {
|
|
path = safeCharPtrCopy(getenv("GLESTHOME"),8095);
|
|
if(path != "" && EndsWith(path, "/") == false && EndsWith(path, "\\") == false) {
|
|
path += "/";
|
|
}
|
|
|
|
//SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d] path to be used for read/write files [%s]\n",__FILE__,__FUNCTION__,__LINE__,path.c_str());
|
|
}
|
|
|
|
return path;
|
|
}
|
|
|
|
void initSpecialStrings() {
|
|
getCrashDumpFileName();
|
|
getPlatformNameString();
|
|
getGITRevisionString();
|
|
getCompilerNameString();
|
|
getNetworkVersionString();
|
|
getNetworkVersionGITString();
|
|
getNetworkPlatformFreeVersionString();
|
|
getCompileDateTime();
|
|
}
|
|
|
|
bool upgradeFilesInTemp() {
|
|
// Get path to temp files
|
|
string tempFilePath = "temp/";
|
|
if(getGameReadWritePath(GameConstants::path_logs_CacheLookupKey) != "") {
|
|
tempFilePath = getGameReadWritePath(GameConstants::path_logs_CacheLookupKey) + tempFilePath;
|
|
}
|
|
else {
|
|
Config &config = Config::getInstance();
|
|
string userData = config.getString("UserData_Root","");
|
|
if(userData != "") {
|
|
endPathWithSlash(userData);
|
|
}
|
|
tempFilePath = userData + tempFilePath;
|
|
}
|
|
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("Temp files path [%s]\n",tempFilePath.c_str());
|
|
|
|
// Move all files into binary folder
|
|
bool anyFailures = false;
|
|
vector<string> fileList = getFolderTreeContentsListRecursively(tempFilePath, "", false, NULL);
|
|
for(unsigned int index = 0; index < fileList.size(); ++index) {
|
|
string fileName = fileList[index];
|
|
string newFileName = Properties::getApplicationPath() + extractFileFromDirectoryPath(fileName);
|
|
bool result = renameFile(fileName,newFileName);
|
|
if(result == false) {
|
|
printf("FAILED Rename: [%s] to [%s] result = %d errno = %d\n",fileName.c_str(),newFileName.c_str(),result,errno);
|
|
|
|
anyFailures = true;
|
|
}
|
|
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("Rename: [%s] to [%s] result = %d\n",fileName.c_str(),newFileName.c_str(),result);
|
|
}
|
|
|
|
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("Successfully updated!\n");
|
|
|
|
return (fileList.size() > 0 && anyFailures == false);
|
|
}
|
|
|
|
}}//end namespace
|