bionickatana/starruler-linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
3dacda75221c7c5874437fc68344741201b618a3
starruler-linux/source/game/main.cpp
T
Lucas de Vries cc307720ff Open source Star Ruler 2 source code!
2018-07-17 14:15:37 +02:00

892 lines
23 KiB
C++
Raw Blame History

#ifdef _MSC_VER
#include <Windows.h>
#include <DbgHelp.h>
#endif
#include "main/input_handling.h"
#include "main/initialization.h"
#include "main/tick.h"
#include "main/logging.h"
#include "main/version.h"
#include "main/save_load.h"
#include "main/game_platform.h"
#include "util/format.h"
#include "util/save_file.h"
#include "main/references.h"
#include "scripts/script_bind.h"
#include "scripts/context_cache.h"
#include "obj/lock.h"
#include "files.h"
#include "processing.h"
#include "threads.h"
#include "network/network_manager.h"
#include "util/locked_type.h"
#include "util/lockless_type.h"
#include "network/init.h"
#include "main/version.h"
#include "render/vertexBuffer.h"
#include <stdint.h>
#ifdef __GNUC__
#include <unistd.h>
#endif
bool launchPatcher = false;
namespace scripts {
void updateGame();
};
unsigned reportVersion = 2;
#ifdef _MSC_VER
MINIDUMP_TYPE mdumpType = (MINIDUMP_TYPE)(MiniDumpWithProcessThreadData | MiniDumpWithIndirectlyReferencedMemory);
LONG WINAPI CrashCallback( LPEXCEPTION_POINTERS pException ) {
print("Unhandled exception in thread %d", threads::getThreadID());
flushLog();
SYSTEMTIME timeStamp;
GetLocalTime(&timeStamp);
char buffer[512];
sprintf_s(buffer, 512, "%.420s\\SR2_%i-%i-%i_%i-%i-%i.mdmp", getProfileRoot().c_str(), timeStamp.wYear, timeStamp.wMonth, timeStamp.wDay, timeStamp.wHour, timeStamp.wMinute, timeStamp.wSecond);
HANDLE file = CreateFile(buffer, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
if(file != INVALID_HANDLE_VALUE) {
print("Building minidump %s", buffer);
MINIDUMP_EXCEPTION_INFORMATION exception;
exception.ClientPointers = FALSE;
exception.ExceptionPointers = pException;
exception.ThreadId = GetCurrentThreadId();
if(MiniDumpWriteDump( GetCurrentProcess(), GetCurrentProcessId(), file, mdumpType, (pException != 0) ? &exception : 0, 0, 0) == FALSE) {
DWORD err = GetLastError();
LPVOID lpMsgBuf;
DWORD dw = GetLastError();
FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &lpMsgBuf, 0, NULL );
appendToErrorLog("Failed to generate Minidump:", true, false);
appendToErrorLog((char*)lpMsgBuf, false);
print("Failed to generate Minidump: %s", (char*)lpMsgBuf);
LocalFree(lpMsgBuf);
}
CloseHandle(file);
}
else {
DWORD err = GetLastError();
print("Could not write out minidump '%' (%d)", buffer, err);
appendToErrorLog(std::string("Could not open minidump file: ") + toString(err));
}
auto* ctx = asGetActiveContext();
char cloudBuffer[512];
if(ctx) {
if(ctx->GetState() == asEXECUTION_EXCEPTION) {
const char* pSection = nullptr;
int column = 0;
int line = ctx->GetExceptionLineNumber(&column,&pSection);
sprintf_s(cloudBuffer, 512, "%s Script Exception: %.400s (%i:%i)", getSectionName(), pSection, line, column);
}
else if(ctx->GetState() == asEXECUTION_ACTIVE) {
auto* f = ctx->GetFunction();
if(f) {
const char* pSection = nullptr;
int column = 0;
int line = ctx->GetLineNumber(0, &column, &pSection);
sprintf_s(cloudBuffer, 512, "%s Script Active: %.400s (%i:%i)", getSectionName(), pSection, line, column);
}
else {
sprintf_s(cloudBuffer, 512, "%s Script Active, Unknown state",getSectionName());
}
}
}
else if(threads::getThreadID() != 0 || !scene::renderingNode) {
sprintf_s(cloudBuffer, 512, "Native: %s", getSectionName());
}
else {
sprintf_s(cloudBuffer, 512, "Native: %s\nRendering %s", getSectionName(), scene::renderingNode->getName());
}
print("%s", cloudBuffer);
if(devices.cloud) {
devices.cloud->logException(pException->ExceptionRecord->ExceptionCode, pException, reportVersion, cloudBuffer);
print("Attempted to upload exception to the cloud");
}
if(ctx) {
print("Exception occurred inner to script execution:");
flushLog();
scripts::logException();
}
storeLog(std::string(buffer) + ".txt");
return EXCEPTION_CONTINUE_SEARCH;
}
void initCrashDump() {
SetUnhandledExceptionFilter(CrashCallback);
}
#else
#include "dump_lin.h"
#endif
#include "util/formula.h"
#include "main/console.h"
#include "render/render_mesh.h"
#include "ISoundDevice.h"
#include "SLoadError.h"
#include "scripts/context_cache.h"
#include "../as_addons/include/scripthelper.h"
#include <unordered_map>
#ifdef PROFILE_LOCKS
extern bool printLockProfile, requireObserved;
#endif
#ifdef PROFILE_EXECUTION
namespace scripts {
void logScriptProfile(asIScriptEngine* engine);
};
#endif
#ifdef _MSC_VER
extern "C" {
__declspec(dllexport) DWORD NvOptimusEnablement = 0x00000001;
}
#endif
namespace scripts {
void takeScreenshot(const std::string& fname, bool increment = true);
};
std::unordered_map<std::string, double> formulaTestVars;
double formulaTest(void*,const std::string* var) {
auto v = formulaTestVars.find(*var);
if(v != formulaTestVars.end())
return v->second;
else
return 0;
}
void netErrorMessage(const char* err, int code) {
error("Network Error: %s (%i)", err, code);
}
int main(int argc, char** argv) {
std::string launchConnect, launchPassword, launchLobby;
//Create profile directories
{
std::vector<std::string> paths;
path_split(getProfileRoot(), paths);
std::string path;
for(auto i = paths.begin(), end = paths.end(); i != end; ++i) {
path += *i + "/";
makeDirectory(path);
}
}
createLog();
logDate();
enterSection(NS_Startup);
net::setErrorCallback(netErrorMessage);
console.addCommand("volume", [](argList& args) {
if(!devices.sound)
return;
if(args.empty())
console.printLn(format("Volume: $1", devices.sound->getVolume()));
else
devices.sound->setVolume(toNumber<float>(args[0].c_str()));
} );
console.addCommand("quit", [](argList&) {
game_state = GS_Quit;
} );
console.addCommand("menu", [](argList&) {
game_state = GS_Menu;
} );
console.addCommand("crash", [](argList&) {
//Legit.
*(volatile int*)nullptr = 42;
} );
console.addCommand("game", [](argList&) {
game_state = GS_Game;
} );
console.addCommand("update", [](argList&) {
scripts::updateGame();
} );
console.addCommand("host", [](argList&) {
devices.network->host("", 2048, 0, true);
if(game_running)
devices.network->signalServerReady();
} );
console.addCommand("connect", [](argList& args) {
if(args.size() == 0)
devices.network->connect("127.0.0.1", 2048);
else if(args.size() == 2)
devices.network->connect(args[0], toNumber<int>(args[1]));
else
devices.network->connect(args[0], 2048);
} );
console.addCommand("bw_monitor", [](argList& args) {
if(args.size() == 0)
devices.network->monitorBandwidth = true;
else
devices.network->monitorBandwidth = toBool(args[0]);
});
console.addCommand("bw_incoming", [](argList&) {
devices.network->dumpIncomingMonitor();
});
console.addCommand("bw_outgoing", [](argList&) {
devices.network->dumpOutgoingMonitor();
});
console.addCommand("bw_incoming_total", [](argList&) {
devices.network->dumpIncomingTotals();
});
console.addCommand("bw_outgoing_total", [](argList&) {
devices.network->dumpOutgoingTotals();
});
console.addCommand("clear_cloud", [](argList&) {
if(devices.cloud)
devices.cloud->flushCloud();
});
console.addCommand("full_gc", [](argList&) {
extern bool fullGC;
fullGC = true;
});
console.addCommand("async_times", [](argList&) {
void logAsyncLoad();
logAsyncLoad();
});
#ifdef PROFILE_LOCKS
console.addCommand("print_locks", [](argList& args) {
requireObserved = args.size() > 0 && toBool(args[0]);
printLockProfile = true;
});
#endif
#ifdef PROFILE_PROCESSING
console.addCommand("print_processing", [](argList& args) {
processing::printProcessingProfile();
});
#endif
#ifdef PROFILE_SCRIPT_CALLBACKS
console.addCommand("print_script_cb", [](argList& args) {
print("Server:");
if(devices.scripts.server)
devices.scripts.server->printProfile();
print("Client:");
if(devices.scripts.client)
devices.scripts.client->printProfile();
print("Menu:");
if(devices.scripts.menu)
devices.scripts.menu->printProfile();
});
#endif
#ifdef PROFILE_EXECUTION
console.addCommand("log_script_profile", [](argList& args) {
std::string engine;
if(args.size() != 0)
engine = args[0];
if(devices.scripts.menu && (engine.empty() || engine == "menu")) {
print("Menu Script Profile:");
scripts::logScriptProfile(devices.scripts.menu->engine);
}
if(devices.scripts.client && (engine.empty() || engine == "client")) {
print("Client Script Profile:");
scripts::logScriptProfile(devices.scripts.client->engine);
}
if(devices.scripts.server && (engine.empty() || engine == "server")) {
print("Server Script Profile:");
scripts::logScriptProfile(devices.scripts.server->engine);
}
});
#endif
console.addCommand("print_groups", [](argList& args) {
printLockStats();
});
console.addCommand("export_bindings", [](argList& args) {
if(args.size() == 0)
console.printLn("Please specify an engine: menu, client, or server");
else if(args[0] == "menu") {
if(devices.scripts.menu)
WriteConfigToFile(devices.scripts.menu->engine, "menu_config.txt");
}
else if(args[0] == "client") {
if(devices.scripts.client)
WriteConfigToFile(devices.scripts.client->engine, "client_config.txt");
}
else if(args[0] == "server") {
if(devices.scripts.server)
WriteConfigToFile(devices.scripts.server->engine, "server_config.txt");
}
else {
console.printLn("Please specify an engine: menu, client, or server");
}
});
console.addCommand("gc_types", [](argList& args) {
if(args.empty()) {
console.printLn("Please specify an engine: menu, client, or server");
return;
}
unsigned threshold = 5;
scripts::Manager* manager = 0;
if(args[0] == "menu")
manager = devices.scripts.menu;
else if(args[0] == "client")
manager = devices.scripts.client;
else if(args[0] == "server")
manager = devices.scripts.server;
if(manager == 0) {
console.printLn("Engine is not active or is invalid");
return;
}
if(args.size() >= 2)
threshold = toNumber<unsigned>(args[1]);
std::map<asITypeInfo*,unsigned> counts;
asUINT index = 0;
asITypeInfo* type = 0;
asUINT end = ~0;
if(args.size() >= 3 && args[2] == "new") {
asUINT dummy;
manager->engine->GetGCStatistics(&dummy,
nullptr, nullptr, &end);
}
while(index < end && manager->engine->GetObjectInGC(index++, 0, 0, &type) == asSUCCESS) {
if(type != 0)
counts[type] += 1;
}
//Use a multimap to sort the data by count
std::multimap<unsigned,asITypeInfo*> results;
for(auto i = counts.begin(), end = counts.end(); i != end; ++i)
if(i->second >= threshold)
results.insert(std::pair<unsigned,asITypeInfo*>(i->second, i->first));
for(auto i = results.rbegin(), end = results.rend(); i != end; ++i) {
auto* subtype = i->second->GetSubType();
std::string line = i->second->GetName();
if(subtype) {
line += "<";
line += subtype->GetName();
line += ">";
}
line += ": ";
line += toString(i->first,0);
console.printLn(line);
}
});
console.addCommand("formula_var", [](argList& args) {
if(args.size() == 2) {
double value = toNumber<double>(args[1]);
formulaTestVars[args[0]] = value;
console.printLn(args[0] + " = " + toString(value,5));
}
});
console.addCommand("formula", [](argList& args) {
try {
if(!args.empty()) {
std::string content;
for(auto i = args.begin(), end = args.end(); i != end; ++i) {
if(!content.empty())
content += " ";
content += *i;
}
Formula* formula = Formula::fromInfix(content.c_str());
console.printLn(std::string(" = ") + toString(formula->evaluate(formulaTest, 0),5));
}
}
catch(FormulaError err) {
console.printLn(err.msg);
}
});
console.addCommand("screenshot", [](argList& args) {
scripts::takeScreenshot(args.empty() ? "screenshot" : args[0]);
});
console.addCommand("spherize", [](argList& args) {
if(args.empty()) {
console.printLn("Need image path and optional output path");
return;
}
Image* source = loadImage(args[0].c_str());
if(!source) {
console.printLn("Could not locate file");
return;
}
Image* out = source->sphereDistort();
try {
if(!saveImage(out,args.size() > 1 ? args[1].c_str() : args[0].c_str()))
throw 0;
console.printLn("Spherized image");
}
catch(...) {
console.printLn("Could not write image");
}
delete out;
});
console.addCommand("rand_image", [](argList& args) {
if(args.size() < 3) {
console.printLn("Need width, height, and output path");
return;
}
Image* out = Image::random(vec2u(toNumber<unsigned>(args[0]),toNumber<unsigned>(args[1])), randomi);
try {
if(!saveImage(out,args[2].c_str()))
throw 0;
console.printLn("Output image");
}
catch(...) {
console.printLn("Could not write image");
}
delete out;
});
/*console.addCommand("genetica_planet", [](argList& args) {
if(args.empty()) {
console.printLn("Need image path and optional output path");
return;
}
Image* source = loadImage(args[0].c_str());
if(!source) {
console.printLn("Could not locate file");
return;
}
//Hack: We need the image to be twice as wide as tall, so we completely violate all sense of sanity to do it easily
source->height = source->width / 2;
Image* out = source->sphereDistort();
try {
if(!saveImage(out,args.size() > 1 ? args[1].c_str() : args[0].c_str()))
throw 0;
console.printLn("Exported spherized genetica planet");
}
catch(...) {
console.printLn("Could not write image");
}
delete out;
});*/
console.addCommand("save", [](argList& args) {
if(game_state != GS_Game) {
error("No game to save.");
return;
}
if(devices.network->isClient) {
error("Cannot save game from multiplayer clients.");
return;
}
std::string savePath = devices.mods.getGlobalProfile("saves");
std::string filename = path_join(savePath, args.empty() ? "quicksave.sr2" : args[0]);
if(!match(filename.c_str(),"*.sr2"))
filename += ".sr2";
double start = devices.driver->getAccurateTime();
processing::pause();
bool success = saveGame(filename);
processing::resume();
if(success) {
double end = devices.driver->getAccurateTime();
console.printLn(format("Saved '$1' (Took $2ms)", filename, (end - start) * 1000.0));
}
});
console.addCommand("3d_scale", [](argList& args) {
extern double scale_3d;
if(!args.empty()) {
double scale = toNumber<double>(args[0]);
if(scale > 0 && scale <= 2.0) {
scale_3d = scale;
}
else {
console.printLn("3D Render scale must be within (0,2]");
return;
}
}
console.printLn(format("3D Scale: $1", toString(scale_3d, 2)));
});
console.addCommand("gpu_mem", [](argList& args) {
unsigned long long texMem = 0, meshMem = 0;
auto& textures = devices.library.textures;
for(size_t i = 0; i < textures.size(); ++i)
texMem += textures[i]->getTextureBytes();
auto& meshes = devices.library.meshes;
for(auto i = meshes.begin(), end = meshes.end(); i != end; ++i)
meshMem += i->second->getMeshBytes();
unsigned long long MB_Bytes = 1024 * 1024;
console.printLn(format(" GPU Total Mem Estimate: $1MB", (unsigned)((texMem + meshMem) / MB_Bytes)));
console.printLn(format(" GPU Tex Mem Estimate: $1MB", (unsigned)(texMem / MB_Bytes)));
console.printLn(format(" GPU Mesh Mem Estimate: $1MB", (unsigned)(meshMem / MB_Bytes)));
});
console.addCommand("vb_float_limit", [](argList& args) {
if(!args.empty())
render::vbFloatLimit = toNumber<unsigned>(args.front());
console.printLn(toString(render::vbFloatLimit));
});
console.addCommand("vb_step_limit", [](argList& args) {
if(!args.empty())
render::vbMaxSteps = toNumber<unsigned>(args.front());
console.printLn(toString(render::vbMaxSteps));
});
console.addCommand("reload_gui", [](argList& args) {
reload_gui = true;
});
//Get command line arguments
std::vector<std::string> mods;
std::string localeName = "";
bool loadGraphics = true;
bool createWindow = true;
bool handleCrashes = true;
for(int argi = 1; argi < argc; ++argi) {
std::string arg = argv[argi];
if(arg.size() == 1) {
error("Found '%c', accidental space?", arg[0]);
continue;
}
//Compatibility for switches
if(arg[0] == '-' && arg[1] == '-')
arg = arg.substr(2, arg.size() - 2);
else if(arg[0] == '-' || arg[0] == '+' || arg[0] == '/')
arg = arg.substr(1, arg.size() - 1);
//Options
if(arg == "mod") {
++argi;
if(argi < argc)
mods.push_back(argv[argi]);
else
error("Error: mod option requires a mod name.");
}
else if(arg == "locale") {
++argi;
if(argi < argc)
localeName = argv[argi];
else
error("Error: locale option requires a locale name.");
}
else if(arg == "load") {
++argi;
if(argi < argc) {
std::string fname = devices.mods.getGlobalProfile("saves");
fname = path_join(fname, argv[argi]);
if(!match(fname.c_str(),"*.sr2"))
fname += ".sr2";
SaveFileInfo info;
if(getSaveFileInfo(fname, info)) {
mods.clear();
for(auto i = info.mods.begin(), end = info.mods.end(); i != end; ++i) {
auto* m = devices.mods.getMod(i->id);
if(m) m = m->getFallback(i->version);
mods.push_back(m ? m->ident : i->id);
}
loadSaveName = fname;
}
game_state = GS_Game;
}
else
error("Error: load option requires a save name.");
}
else if(arg == "quickstart") {
game_state = GS_Game;
}
else if(arg == "watch-resources") {
watch_resources = true;
}
else if(arg == "reload-gui") {
reload_gui = true;
}
else if(arg == "test-scripts") {
game_state = GS_Test_Scripts;
loadGraphics = false;
}
else if(arg == "monitor-scripts") {
game_state = GS_Monitor_Scripts;
loadGraphics = false;
monitor_files = true;
}
else if(arg == "no-window") {
createWindow = false;
}
else if(arg == "no-sound") {
use_sound = false;
}
else if(arg == "no-steam") {
use_steam = false;
}
else if(arg == "verbose") {
setLogLevel(LL_Info);
}
else if(arg == "chatty") {
extern bool LOG_CHATTY;
LOG_CHATTY = true;
}
else if(arg == "no-errorlog") {
extern bool LOG_ERRORLOG;
LOG_ERRORLOG = false;
}
else if(arg == "fullscreen") {
fullscreen = true;
}
else if(arg == "nojit") {
useJIT = false;
}
else if(arg == "nodump") {
handleCrashes = false;
}
else if(arg == "nomodelcache") {
extern bool useModelCache;
useModelCache = false;
}
else if(arg == "connect") {
//NOTE: Added by steam if the player connected through steam
++argi;
if(argi < argc)
launchConnect = argv[argi];
}
else if(arg == "password") {
//NOTE: Added by steam if the player connected through steam to a passworded server
++argi;
if(argi < argc)
launchPassword = argv[argi];
}
else if(arg == "connect_lobby") {
//NOTE: Added by steam if the player connected on a steam lobby
++argi;
if(argi < argc)
launchLobby = argv[argi];
}
else if(arg == "version") {
printf(
"-- Star Ruler 2 v%s --\nEngine Build: %d\n"
"Server Script Build: %d\nClient Script Build: %d\n"
"Menu Script Build: %d\n",
GAME_VERSION_NAME, ENGINE_BUILD, SERVER_SCRIPT_BUILD,
CLIENT_SCRIPT_BUILD, MENU_SCRIPT_BUILD);
return 0;
}
else if(arg == "help") {
printf("Usage: %s [OPTIONS]\n\n"
"--mod [MOD] Start the game with a specific mod active.\n"
"--locale [LANGUAGE] Start the game in a specific language.\n"
"--load [SAVEGAME] Load the specified savegame on start.\n"
"--quickstart Immediately start a new game, skipping the menu.\n"
"--watch-resources Automatically reload certain data files if changed.\n"
"--test-scripts Compile scripts, then exit, logging any errors.\n"
"--monitor-scripts Monitor scripts and run --test-scripts if changed.\n"
"--no-window Run --test/monitor-scripts in console mode.\n"
"--no-sound Disable the sound system from ever running.\n"
"--no-steam Disable all steam functionality from running.\n"
"--verbose Log more information about the game's state.\n"
"--fullscreen Run the game in full screen mode.\n"
"--version Display version information of the binary.\n"
"--help Display this help message.\n"
, argv[0]);
return 0;
}
else {
error("Unhandled argument: '%s'", arg.c_str());
}
}
//Initialize dumping crash data
if(handleCrashes)
initCrashDump();
//Initialize global stuff
if(!initGlobal(loadGraphics, createWindow))
return 1;
//Initialize threaded variables for this thread
initNewThread();
//Use the default locale
if(!localeName.empty()) {
game_locale = localeName;
}
else {
auto* loc = devices.settings.engine.getSetting("sLocale");
if(loc)
game_locale = loc->toString();
}
//Run the default mod
print("Loading mod(s)");
initMods(mods);
//Check for initialization options
switch(game_state) {
case GS_Game:
initGame();
break;
case GS_Test_Scripts:
if(createWindow) {
game_state = GS_Console_Wait;
}
else {
finishPreload();
game_state = GS_Quit;
}
case GS_Monitor_Scripts:
processing::end();
processing::clear();
break;
}
threads::setThreadPriority(threads::TP_High);
//NOTE: Only supports ipv4 address:port or domain names with implied port; ipv6 will break
if(!launchLobby.empty()) {
if(devices.cloud)
launchConnect = devices.cloud->getLobbyConnectAddress(launchLobby, &launchPassword);
if(launchConnect.empty())
error("Error: could not find lobby with id '%s'\n", launchLobby.c_str());
else
info("Connecting to lobby '%s'...\n", launchLobby.c_str());
}
if(!launchConnect.empty()) {
unsigned short port = 2048;
auto portIndex = launchConnect.find_last_of(':');
if(portIndex != std::string::npos)
port = toNumber<unsigned>(launchConnect.substr(portIndex+1));
devices.network->connect(launchConnect.substr(0, portIndex), port, launchPassword, true);
}
devices.render->reportErrors("Pre-init");
//Run the main loop
while(game_state != GS_Quit) {
//Render whichever state we're in
switch(game_state) {
case GS_Menu:
tickMenu();
break;
case GS_Game:
if(!game_running)
initGame();
tickGame();
break;
case GS_Monitor_Scripts:
if(tickMonitor()) {
finishPreload();
destroyMod();
if(createWindow)
console.clear();
else
printf("\n\n--Reloading--\n\n\n");
initMods(mods);
}
if(!createWindow) {
threads::sleep(100);
break;
}
case GS_Console_Wait:
console.show();
tickConsole();
break;
case GS_Load_Prep:
extern bool loadPrep(const std::string& fname);
if(!loadPrep(loadSaveName)) {
loadSaveName.clear();
if(game_running)
game_state = GS_Game;
else
game_state = GS_Menu;
}
break;
default:
break;
}
}
destroyMod();
destroyGlobal();
if(launchPatcher) {
#ifdef _MSC_VER
char buffer[1024];
sprintf_s(buffer, "start \"Star Ruler 2 Patcher\" patcher.exe \"%s\"", getAbsolutePath(".").c_str());
system(buffer);
#else
if(fork() == 0) {
#ifdef __amd64__
execlp("./bin/lin64/Patcher.bin", "./bin/lin64/Patcher.bin", (char*)nullptr);
#else
execlp("./bin/lin32/Patcher.bin", "./bin/lin32/Patcher.bin", (char*)nullptr);
#endif
exit(1);
}
#endif
}
}
Reference in New Issue View Git Blame Copy Permalink