bool Spring::Run(const IBattlePtr battle ) { BF::path path = sett().GetCurrentUsedDataDir(); path /= "script.txt"; try { BF::ofstream f( path ); if ( !f.is_open() ) { LslError( "Access denied to script.txt at %s", path.string().c_str() ); } battle->DisableHostStatusInProxyMode( true ); f << WriteScriptTxt(battle); battle->DisableHostStatusInProxyMode( false ); f.close(); } catch ( std::exception& e ) { LslError( "Couldn't write script.txt, exception caught:\n %s", e.what() ); return false; } catch (...) { LslError( "Couldn't write script.txt" ); return false; } std::string cmd; //! TODO // if ( battle->GetAutoHost().GetEnabled() ) // { // // -m, --minimise Start minimised // // -q [T], --quit=[T] Quit immediately on game over or after T seconds // cmd = "--minimise"; // } cmd += std::string(" \"" + path.string() + "\""); return LaunchSpring( cmd ); }
bool SpringBundle::GetBundleVersion() { if (!version.empty()) //get version only once return true; if (!Util::FileExists(unitsync)) { return false; } void* temphandle = _LoadLibrary(unitsync); if (temphandle == nullptr) return false; std::string functionname = "GetSpringVersion"; GetSpringVersionPtr getspringversion = (GetSpringVersionPtr)GetLibFuncPtr(temphandle, functionname); if (!getspringversion) { _FreeLibrary(temphandle); LslError("getspringversion: function not found %s", unitsync.c_str()); return false; } functionname = "IsSpringReleaseVersion"; IsSpringReleaseVersionPtr isspringreleaseversion = (IsSpringReleaseVersionPtr)GetLibFuncPtr(temphandle, functionname); functionname = "GetSpringVersionPatchset"; GetSpringVersionPatchsetPtr getspringversionpatcheset = (GetSpringVersionPatchsetPtr)GetLibFuncPtr(temphandle, functionname); version = getspringversion(); if (isspringreleaseversion && getspringversionpatcheset && isspringreleaseversion()) { version += "."; version += getspringversionpatcheset(); } _FreeLibrary(temphandle); return !version.empty(); }
bool OptionsWrapper::loadOptions(Enum::GameOption modmapFlag, const std::string& name) { unLoadOptions(modmapFlag); GameOptions opt; switch (modmapFlag) { default: break; case Enum::MapOption: try { opt = usync().GetMapOptions(name); } catch (...) { LslError("Could not load map options"); usync().FetchUnitsyncErrors(name); return false; } break; case Enum::ModOption: try { opt = usync().GetGameOptions(name); } catch (...) { LslError("Could not load game options"); usync().FetchUnitsyncErrors(name); return false; } break; case Enum::EngineOption: { //TODO Fixed,random and so forth are intls mmOptionList startpos("Start Position Type", "startpostype", "How players will select where to be spawned in the map\n0: fixed map positions\n1: random map positions\n2: choose in game\n3: choose in the lobby before starting", "0"); startpos.addItem("0", "Fixed", "Use the start positions defined in the map, the positions will be assigned incrementally from the team with lowest number to highest"); startpos.addItem("1", "Random", "Use the start positions defined in the map, the positions will be assigned randomly"); startpos.addItem("2", "Choose in-game", "Players will be able to pick their own starting point right before the game starts, optionally limited by a bounding box defined by the host"); startpos.addItem("3", "Choose before game", "The host will place each player's start position in the map preview before the game is launched"); opt.list_map["startpostype"] = startpos; break; } case Enum::PrivateOptions: { opt.string_map["restrictions"] = mmOptionString("List of restricted units", "restrictedunits", "Units in this list won't be available in game", "", 0); // tab separated list opt.string_map["mapname"] = mmOptionString("Map name", "mapname", "Map name", "", 0); break; } } m_opts[modmapFlag] = opt; return true; }
void TDFWriter::Close() { while (m_depth > 0) LeaveSection(); if (m_depth < 0) { LslError("error in TDFWriter usage: more LeaveSection() calls than EnterSection(). Please contact springlobby developers"); } }
bool Spring::Run(const std::string& script) { BF::path path = sett().GetCurrentUsedDataDir(); path /= "script.txt"; std::string cmd = std::string(" \"" + path.string() + "\""); try { BF::ofstream f( path ); if ( !f.is_open() ) { LslError( "Access denied to script.txt at %s", path.string().c_str() ); } f << script; f.close(); } catch ( std::exception& e ) { LslError( "Couldn't write script.txt, exception caught:\n %s", e.what() ); return false; } catch (...) { LslError( "Couldn't write script.txt" ); return false; } return LaunchSpring( cmd ); }
bool Spring::LaunchSpring( const std::string& params ) { if ( m_running ) { LslError( "Spring already running!" ); return false; } if ( !Util::FileExists( sett().GetCurrentUsedSpringBinary() ) ) { LslError( "spring binary not found at set location: %s", sett().GetCurrentUsedSpringBinary().c_str() ); return false; } std::string configfileflags = sett().GetCurrentUsedSpringConfigFilePath(); if ( !configfileflags.empty() ) { configfileflags = "--config=\"" + configfileflags + "\" "; } std::string cmd = "\"" + sett().GetCurrentUsedSpringBinary(); #ifdef __WXMAC__ wxChar sep = wxFileName::GetPathSeparator(); if ( sett().GetCurrentUsedSpringBinary().AfterLast('.') == "app" ) cmd += sep + std::string("Contents") + sep + std::string("MacOS") + sep + std::string("spring"); // append app bundle inner path #endif cmd += "\" " + configfileflags + params; LslDebug( "spring call params: %s", cmd.c_str() ); if ( m_process == 0 ) m_process = new SpringProcess( *this ); m_process->Create(); m_process->SetCommand( cmd ); m_process->Run(); m_running = true; return true; }
void* GetLibFuncPtr(void* libhandle, const std::string& name) { if (libhandle == NULL) return NULL; #if defined _WIN32 void* p = (void*)GetProcAddress((HMODULE)libhandle, name.c_str()); #else // defined _WIN32 void* p = dlsym(libhandle, name.c_str()); #endif // else defined _WIN32 if (p == NULL) { LslError("Couldn't load %s from unitsync library", name.c_str()); } return p; }
void DataList::InsertRenameAt(PNode node, PNode where) { // rename if such entry already exists. str contains new name. if (!node.Ok()) return; if (!where->list_prev) return; if (!InsertAt(node, where)) { for (int n = 0; n < 10000; ++n) { std::ostringstream os; os << node->Name() << rename_prefix << n; node->name = os.str(); if (InsertAt(node, where)) { return; } } LslError("insertRename: iterated over 10 000 names, way too many"); } }
void DataList::InsertRename(PNode node) { /// rename if such entry already exists. str contains new name. if (!node.Ok()) return; if (!Insert(node)) { std::string original_name = node->Name(); for (int n = 0; n < 10000; ++n) { //std::string tmp=str+std::string(rename_prefix); std::ostringstream os; os << original_name << rename_prefix << n; node->name = os.str(); if (Insert(node)) { return; } } LslError("insertRename: iterated over 10 000 names, way too many"); } }
void Tokenizer::ReportError(const Token& t, const std::string& err) { LslError("TDF parsing error at (%s), on token \"%s\" : %s", t.pos_string.c_str(), t.value_s.c_str(), err.c_str()); errors++; }