static void generate_tractors (void) { if (pSolarSysState->pOrbitalDesc->pPrevDesc != &pSolarSysState->PlanetDesc[2] || pSolarSysState->pOrbitalDesc != &pSolarSysState->MoonDesc[1]) pSolarSysState->CurNode = 0; else /* Earth Moon */ { COUNT i, which_node; DWORD old_rand, rand_val; old_rand = SeedRandom (pSolarSysState->SysInfo.PlanetInfo.ScanSeed[BIOLOGICAL_SCAN]); which_node = i = 0; do { rand_val = Random (); pSolarSysState->SysInfo.PlanetInfo.CurPt.x = (LOBYTE (LOWORD (rand_val)) % (MAP_WIDTH - (8 << 1))) + 8; pSolarSysState->SysInfo.PlanetInfo.CurPt.y = (HIBYTE (LOWORD (rand_val)) % (MAP_HEIGHT - (8 << 1))) + 8; pSolarSysState->SysInfo.PlanetInfo.CurType = NUM_CREATURE_TYPES + 1; if (which_node >= pSolarSysState->CurNode && !(pSolarSysState->SysInfo.PlanetInfo.ScanRetrieveMask[BIOLOGICAL_SCAN] & (1L << i))) break; ++which_node; } while (++i < 10); pSolarSysState->CurNode = which_node; SeedRandom (old_rand); } }
CMusikPlayer::CMusikPlayer() :wxEvtHandler() ,m_SndEngine(wxGetApp().Prefs.nSndRate,2,0) { m_Playing = false; m_Paused = false; m_Fading = false; m_BeginFade = false; m_StartingNext = false; m_Stopping = false; m_SongIndex = 0; m_CrossfadeType = 0; m_DSP = NULL; m_Playmode = MUSIK_PLAYMODE_NORMAL; m_NETSTREAM_read_percent = 0; m_NETSTREAM_bitrate = 0; m_NETSTREAM_status = -1; m_NETSTREAM_flags = 0; m_b_NETSTREAM_AbortConnect = false; m_p_NETSTREAM_Connecting = NULL; //--- initialize random playback ---// long RandomSeed = wxGetLocalTime(); SeedRandom( RandomSeed ); m_arrHistory.Alloc(wxGetApp().Prefs.nMaxShuffleHistory); //set stop watch into pause mode. m_bStreamIsWorkingStopWatchIsRunning = false ; m_NETSTREAM_last_read_percent = 0; m_nLastSongTime = 0; m_bSuppressAutomaticSongPicking = false; m_bPostPlayRestartInProgress = false; }
bool GpxDocument::LoadFile(const wxString &filename) { SeedRandom(); wxRegEx re; //We try to fix popularily broken GPX files. Unencoded '&' is an illegal character in XML, but seems higly popular amongst users (and perhaps even vendors not aware of what XML is...) //The same as above is true for '<' but it would be harder to solve - it's illegal just inside a value, not when it starts a tag int re_compile_flags = wxRE_ICASE; #ifdef wxHAS_REGEX_ADVANCED re_compile_flags |= wxRE_ADVANCED; #endif bool b = re.Compile(wxT("&(?!amp;|lt;|gt;|apos;|quot;|#[0-9]{1,};|#x[0-f]{1,};)"), re_compile_flags); //Should find all the non-XML entites to be encoded as text wxFFile file(filename); wxString s; if(file.IsOpened()) { file.ReadAll(&s, wxConvUTF8); file.Close(); } if(b) { //CDATA handling makes this task way too complex for regular expressions to handle, // so we do nothing and just let the possible damage happen... if (!s.Contains(wxT("![CDATA["))) { int cnt = re.ReplaceAll(&s, wxT("&")); if (cnt > 0) wxLogMessage(wxString::Format(wxT("File %s seems broken, %i occurences of '&' were replaced with '&' to try to fix it."), filename.c_str(), cnt)); } } wxFFile gpxfile; wxString gpxfilename = wxFileName::CreateTempFileName(wxT("gpx"), &gpxfile); gpxfile.Write(s); gpxfile.Close(); bool res = TiXmlDocument::LoadFile((const char*)gpxfilename.mb_str()); ::wxRemoveFile(gpxfilename); return res; }
void Test() { MemoryLimitKb(8000000); for(int sz = 0; sz < 2; sz++) { for(int pass = 0; pass < 2; pass++) { RLOG("--------------------"); DUMP(sz); DUMP(pass); { NanoStrings ns; Vector<dword> ws; ns.ZeroTerminated(sz); SeedRandom(); for(int i = 0; i < 140000000; i++) { if(i % 10000000 == 0) RLOG("Created " << i); String s = pass ? "x" : RandomString(Random(4) ? 5 : 50); ws.Add(ns.Add(s)); } // ns.DumpProfile(); RLOG("---- Strings " << MemoryUsedKb() << " KB used -------"); RLOG(MemoryProfile()); SeedRandom(); for(int i = 0; i < ws.GetCount(); i++) { if(i % 10000000 == 0) RLOG("Tested " << i); String s = pass ? "x" : RandomString(Random(4) ? 5 : 50); if((sz ? String(ns.GetPtr(ws[i])) : ns.Get(ws[i])) != s) { DUMP(i); DUMP(ns.Get(ws[i])); DUMP(s); NEVER(); } } RLOG("Test OK"); } RLOG("===== EMPTY " << MemoryUsedKb() << " KB used -------"); RLOG(MemoryProfile()); } } }
DWORD SeedRandomNumbers (void) { DWORD cur_time; SeedRandom (cur_time = GetTimeCounter ()); return (cur_time); }
void TRI_InitialiseRandom (void) { if (Initialised) { return; } TRI_srandom(SeedRandom()); Initialised = true; }
bool GpxDocument::LoadFile(const wxString &filename) { SeedRandom(); wxRegEx re; //We try to fix popularily broken GPX files. Unencoded '&' is an illegal character in XML, but seems higly popular amongst users (and perhaps even vendors not aware of what XML is...) //The same as above is true for '<' but it would be harder to solve - it's illegal just inside a value, not when it starts a tag int re_compile_flags = wxRE_ICASE; #ifdef wxHAS_REGEX_ADVANCED re_compile_flags |= wxRE_ADVANCED; #endif bool b = re.Compile(wxT("&(?!amp;|lt;|gt;|apos;|quot;|#[0-9]{1,};|#x[0-f]{1,};)"), re_compile_flags); //Should find all the non-XML entites to be encoded as text wxFFile file(filename); wxString s; if(file.IsOpened()) { file.ReadAll(&s, wxConvUTF8); //Fallback for not-well formed (non-UTF8) GPX files //the "garbage" characters are lost, but the important part of the information should survive... if (s == wxEmptyString) { file.Seek(0); file.ReadAll(&s, wxConvISO8859_1); wxLogMessage(wxString::Format(wxT("File %s seems not to be well-formed UTF-8 XML, used fallback ASCII format conversion - some text information might have not been imported."), filename.c_str())); } file.Close(); } if(b) { //CDATA handling makes this task way too complex for regular expressions to handle, // so we do nothing and just let the possible damage happen... if (!s.Contains(wxT("![CDATA["))) { int cnt = re.ReplaceAll(&s, wxT("&")); if (cnt > 0) wxLogMessage(wxString::Format(wxT("File %s seems broken, %i occurences of '&' were replaced with '&' to try to fix it."), filename.c_str(), cnt)); } } wxFFile gpxfile; wxString gpxfilename = wxFileName::CreateTempFileName(wxT("gpx"), &gpxfile); gpxfile.Write(s); gpxfile.Close(); bool res = TiXmlDocument::LoadFile((const char*)gpxfilename.mb_str()); if( ! res ) { wxString msg = _T("Failed to load "); msg << filename; msg << _T(": "); msg << wxString( TiXmlDocument::ErrorDesc(), wxConvUTF8 ); wxLogMessage( msg ); } ::wxRemoveFile(gpxfilename); return res; }
bool StationaryMixPointIrregular::SimulationBegin() { //Initializations SeedRandom(); Transmitter.x=GetRunVariableInteger("MixPointX"); Transmitter.y=GetRunVariableInteger("MixPointY"); Transmitter.Radius=GetRunVariableInteger("ZoneRadius"); Transmitter.Title="Stationary Mix Point"; RandDurationMin=GetRunVariableInteger("RandDurationMin"); RandDurationMax=GetRunVariableInteger("RandDurationMax"); NextSilentPeriod=0; return true; }
std::vector<unsigned int> UniqueRandomIndices(const unsigned int MAX, const unsigned int Number) { //generate Number unique random indices from 0 to MAX SeedRandom(); assert(Number <= MAX+1); //cannot generate more unique numbers than than the size of the set we are sampling std::set<unsigned int> S; while(S.size() < Number) S.insert(RandomInt(MAX)); std::vector<unsigned int> Indices; for(std::set<unsigned int>::iterator iter = S.begin(); iter != S.end(); iter++) Indices.push_back(*iter); return Indices; }
//Function set new game GameArray void Fifteen::SetGameArray() { if (!usedSolution) { points = 0; result.SetData(points); time = 0; timeresult.SetData(time); SeedRandom(GetSysTime().Get()); endOfGame = false; usedSolution = false; RandomGameArray(GameArray); //Saving GameArray for solution finder CopyTGameArray(GameStartArray, GameArray); } else { PromptOK(SOLUTIONMSG); } }
bool DummyEventProtocol::SimulationBegin() { PreSimulationVariableCheck("SilentPeriod"); PreSimulationVariableCheck("MaxVehiclesInSet"); PreSimulationVariableCheck("VehicleTransmissionRadius"); SeedRandom(); SilentPeriod=GetRunVariableInteger("SilentPeriod"); MaxVehiclesInSet=GetRunVariableInteger("MaxVehiclesInSet"); AnnouncerRadius=GetRunVariableInteger("VehicleTransmissionRadius"); int MinRandomDuration=0; int MaxRandomDuration=0; if(!OnTheFly) { PreSimulationVariableCheck("MixPointX"); PreSimulationVariableCheck("MixPointY"); MainTransmitter.x=GetRunVariableInteger("MixPointX"); MainTransmitter.y=GetRunVariableInteger("MixPointY"); } else { for(int i=0;i<VehicleMax;i++){Vehicles[i]->TransmissionRadius=AnnouncerRadius;} } if(Irregular) { PreSimulationVariableCheck("MinRandomDuration"); PreSimulationVariableCheck("MaxRandomDuration"); MinRandomDuration=GetRunVariableInteger("MinRandomDuration"); MaxRandomDuration=GetRunVariableInteger("MaxRandomDuration"); } MainTransmitter.TransmissionRadius=AnnouncerRadius; for(int i=0;i<TimeMax;i+=(Irregular?RandInt(MinRandomDuration,MaxRandomDuration):SilentPeriod)) { AnonymitySet* CurrentSet=new AnonymitySet(MainTransmitter.x,MainTransmitter.y,AnnouncerRadius,i,i,i+SilentPeriod,&MainTransmitter); AnonymitySets.PushObj(CurrentSet); } return true; }
GpxDocument::GpxDocument() { PopulateEmptyDocument(_T("OpenCPN")); AddCustomNamespace(_T("xmlns:opencpn"), _T("http://www.opencpn.org")); SeedRandom(); }
void GenerateSOL (BYTE control) { COUNT i; DWORD rand_val; PPLANET_DESC pCurDesc; switch (control) { case INIT_NPCS: init_probe (); break; case REINIT_NPCS: if (GET_GAME_STATE (CHMMR_BOMB_STATE) != 3) GenerateRandomIP (REINIT_NPCS); else { GLOBAL (BattleGroupRef) = 0; ReinitQueue (&GLOBAL (npc_built_ship_q)); } break; case GENERATE_ENERGY: generate_energy_nodes (); break; case GENERATE_LIFE: generate_tractors (); break; case GENERATE_ORBITAL: generate_orbital (); break; case GENERATE_NAME: i = pSolarSysState->pBaseDesc - pSolarSysState->PlanetDesc; wstrcpy (GLOBAL_SIS (PlanetName), GAME_STRING (PLANET_NUMBER_BASE + i)); SET_GAME_STATE (BATTLE_PLANET, pSolarSysState->PlanetDesc[i].data_index); break; case GENERATE_MOONS: { GenerateRandomIP (GENERATE_MOONS); i = pSolarSysState->pBaseDesc - pSolarSysState->PlanetDesc; switch (i) { case 2: /* moons of EARTH */ { COUNT angle; pSolarSysState->MoonDesc[0].data_index = (BYTE)~0; pSolarSysState->MoonDesc[0].radius = MIN_MOON_RADIUS; angle = HALF_CIRCLE + QUADRANT; pSolarSysState->MoonDesc[0].location.x = COSINE (angle, pSolarSysState->MoonDesc[0].radius); pSolarSysState->MoonDesc[0].location.y = SINE (angle, pSolarSysState->MoonDesc[0].radius); pSolarSysState->MoonDesc[1].data_index = SELENIC_WORLD; pSolarSysState->MoonDesc[1].radius = MIN_MOON_RADIUS + (MAX_MOONS - 1) * MOON_DELTA; rand_val = Random (); angle = NORMALIZE_ANGLE (LOWORD (rand_val)); pSolarSysState->MoonDesc[1].location.x = COSINE (angle, pSolarSysState->MoonDesc[1].radius); pSolarSysState->MoonDesc[1].location.y = SINE (angle, pSolarSysState->MoonDesc[1].radius); break; } case 4: /* moons of JUPITER */ pSolarSysState->MoonDesc[0].data_index = RADIOACTIVE_WORLD; pSolarSysState->MoonDesc[1].data_index = HALIDE_WORLD; pSolarSysState->MoonDesc[2].data_index = CYANIC_WORLD; pSolarSysState->MoonDesc[3].data_index = PELLUCID_WORLD; break; case 5: /* moons of SATURN */ pSolarSysState->MoonDesc[0].data_index = ALKALI_WORLD; break; case 7: /* moons of NEPTUNE */ pSolarSysState->MoonDesc[0].data_index = VINYLOGOUS_WORLD; break; } break; } case GENERATE_PLANETS: { #define SOL_SEED 334241042L SeedRandom (SOL_SEED); pSolarSysState->SunDesc[0].NumPlanets = 9; for (i = 0, pCurDesc = pSolarSysState->PlanetDesc; i < 9; ++i, ++pCurDesc) { COUNT angle; UWORD word_val; pCurDesc->rand_seed = rand_val = Random (); word_val = LOWORD (rand_val); angle = NORMALIZE_ANGLE ((COUNT)HIBYTE (word_val)); switch (i) { case 0: /* MERCURY */ pCurDesc->data_index = METAL_WORLD; pCurDesc->radius = EARTH_RADIUS * 39L / 100; pCurDesc->NumPlanets = 0; break; case 1: /* VENUS */ pCurDesc->data_index = PRIMORDIAL_WORLD; pCurDesc->radius = EARTH_RADIUS * 72L / 100; pCurDesc->NumPlanets = 0; angle = NORMALIZE_ANGLE (FULL_CIRCLE - angle); break; case 2: /* EARTH */ pCurDesc->data_index = WATER_WORLD | PLANET_SHIELDED; pCurDesc->radius = EARTH_RADIUS; pCurDesc->NumPlanets = 2; break; case 3: /* MARS */ pCurDesc->data_index = DUST_WORLD; pCurDesc->radius = EARTH_RADIUS * 152L / 100; pCurDesc->NumPlanets = 0; break; case 4: /* JUPITER */ pCurDesc->data_index = RED_GAS_GIANT; pCurDesc->radius = EARTH_RADIUS * 500L /* 520L */ / 100; pCurDesc->NumPlanets = 4; break; case 5: /* SATURN */ pCurDesc->data_index = ORA_GAS_GIANT; pCurDesc->radius = EARTH_RADIUS * 750L /* 952L */ / 100; pCurDesc->NumPlanets = 1; break; case 6: /* URANUS */ pCurDesc->data_index = GRN_GAS_GIANT; pCurDesc->radius = EARTH_RADIUS * 1000L /* 1916L */ / 100; pCurDesc->NumPlanets = 0; break; case 7: /* NEPTUNE */ pCurDesc->data_index = BLU_GAS_GIANT; pCurDesc->radius = EARTH_RADIUS * 1250L /* 2999L */ / 100; pCurDesc->NumPlanets = 1; break; case 8: /* PLUTO */ pCurDesc->data_index = PELLUCID_WORLD; pCurDesc->radius = EARTH_RADIUS * 1550L /* 3937L */ / 100; pCurDesc->NumPlanets = 0; angle = FULL_CIRCLE - OCTANT; break; } pCurDesc->location.x = COSINE (angle, pCurDesc->radius); pCurDesc->location.y = SINE (angle, pCurDesc->radius); } break; } default: GenerateRandomIP (control); break; } }
void GeneratePkunk (BYTE control) { switch (control) { case GENERATE_ENERGY: if (pSolarSysState->pOrbitalDesc == &pSolarSysState->PlanetDesc[0]) { COUNT i, which_node; DWORD rand_val, old_rand; old_rand = SeedRandom ( pSolarSysState->SysInfo.PlanetInfo.ScanSeed[ENERGY_SCAN] ); which_node = i = 0; do { rand_val = Random (); pSolarSysState->SysInfo.PlanetInfo.CurPt.x = (LOBYTE (LOWORD (rand_val)) % (MAP_WIDTH - (8 << 1))) + 8; pSolarSysState->SysInfo.PlanetInfo.CurPt.y = (HIBYTE (LOWORD (rand_val)) % (MAP_HEIGHT - (8 << 1))) + 8; if (!GET_GAME_STATE (CLEAR_SPINDLE)) pSolarSysState->SysInfo.PlanetInfo.CurType = 0; else pSolarSysState->SysInfo.PlanetInfo.CurType = 1; pSolarSysState->SysInfo.PlanetInfo.CurDensity = 0; if (pSolarSysState->SysInfo.PlanetInfo.ScanRetrieveMask[ENERGY_SCAN] & (1L << i)) { pSolarSysState->SysInfo.PlanetInfo.ScanRetrieveMask[ENERGY_SCAN] &= ~(1L << i); if (!GET_GAME_STATE (CLEAR_SPINDLE)) { ((PPLANETSIDE_DESC)pMenuState->ModuleFrame)->InTransit = TRUE; SET_GAME_STATE (CLEAR_SPINDLE, 1); SET_GAME_STATE (CLEAR_SPINDLE_ON_SHIP, 1); } } if (which_node >= pSolarSysState->CurNode && !(pSolarSysState->SysInfo.PlanetInfo.ScanRetrieveMask[ENERGY_SCAN] & (1L << i))) break; ++which_node; } while (++i < 16); pSolarSysState->CurNode = which_node; SeedRandom (old_rand); break; } pSolarSysState->CurNode = 0; break; case GENERATE_PLANETS: { COUNT angle; GenerateRandomIP (GENERATE_PLANETS); pSolarSysState->PlanetDesc[0].data_index = WATER_WORLD; pSolarSysState->PlanetDesc[0].NumPlanets = 1; pSolarSysState->PlanetDesc[0].radius = EARTH_RADIUS * 104L / 100; angle = ARCTAN ( pSolarSysState->PlanetDesc[0].location.x, pSolarSysState->PlanetDesc[0].location.y ); pSolarSysState->PlanetDesc[0].location.x = COSINE (angle, pSolarSysState->PlanetDesc[0].radius); pSolarSysState->PlanetDesc[0].location.y = SINE (angle, pSolarSysState->PlanetDesc[0].radius); break; } case GENERATE_ORBITAL: if (pSolarSysState->pOrbitalDesc == &pSolarSysState->PlanetDesc[0]) { if (ActivateStarShip (PKUNK_SHIP, SPHERE_TRACKING)) { NotifyOthers (PKUNK_SHIP, (BYTE)~0); PutGroupInfo (0L, (BYTE)~0); ReinitQueue (&GLOBAL (npc_built_ship_q)); CloneShipFragment (PKUNK_SHIP, &GLOBAL (npc_built_ship_q), (BYTE)~0); pSolarSysState->MenuState.Initialized += 2; GLOBAL (CurrentActivity) |= START_INTERPLANETARY; SET_GAME_STATE (GLOBAL_FLAGS_AND_DATA, 1 << 7); InitCommunication (PKUNK_CONVERSATION); pSolarSysState->MenuState.Initialized -= 2; if (!(GLOBAL (CurrentActivity) & (CHECK_ABORT | CHECK_LOAD))) { GLOBAL (CurrentActivity) &= ~START_INTERPLANETARY; ReinitQueue (&GLOBAL (npc_built_ship_q)); GetGroupInfo (0L, 0); } break; } else { pSolarSysState->SysInfo.PlanetInfo.LanderFont = CaptureFont ( LoadGraphic (LANDER_FONT) ); pSolarSysState->PlanetSideFrame[1] = CaptureDrawable ( LoadGraphic (RUINS_MASK_PMAP_ANIM) ); pSolarSysState->SysInfo.PlanetInfo.DiscoveryString = CaptureStringTable ( LoadStringTable (PKUNK_RUINS_STRTAB) ); if (GET_GAME_STATE (CLEAR_SPINDLE)) pSolarSysState->SysInfo.PlanetInfo.DiscoveryString = SetAbsStringTableIndex ( pSolarSysState->SysInfo.PlanetInfo.DiscoveryString, 1 ); } } default: GenerateRandomIP (control); break; } }
int main() { SeedRandom(); // Seeds random values for entire program. // Create weapon shops and load inventory. WeaponShop staveShop; std::ifstream staveInputFile("staves.txt"); staveShop.InitializeShop(staveInputFile); WeaponShop swordShop; std::ifstream swordInputFile("swords.txt"); swordShop.InitializeShop(swordInputFile); WeaponShop bowShop; std::ifstream bowInputFile("bows.txt"); bowShop.InitializeShop(bowInputFile); // Get user input to create a player character. std::cout << "\n----------------------------------" << std::endl; std::cout << "Welcome to Scott's Text Adventure!" << std::endl; std::cout << "----------------------------------" << std::endl; std::cout << "Enter your character's name: "; std::string characterName; getline(std::cin, characterName); std::cout << "\nChoose your class:" << std::endl; std::cout << "[1] Warrior -- High HP & high defense, low damage output" << std::endl << "[2] Mage -- Low HP & low defense, high damage output. " << std::endl << "[3] Archer -- Medium HP & medium defense, medium damage output." << std::endl; std::size_t jobChoicesCount = 3; int jobChoice = 0; std::cout << ">>"; // While input is valid and isn't out of range for the options. while(!(std::cin >> jobChoice) || 0 > jobChoice || jobChoice > jobChoicesCount) { HandleInvalidInput(std::cin); } // Use input to create the player character. Handle<PlayerCharacterBase> playerHandle(CreatePlayerCharacter(characterName, jobChoice)); //playerHandle->GainExp(3000); std::cout << "\nCharacter Information:" << std::endl; playerHandle->DisplayStats(); std::cout << "\nPress enter to begin the game!" << std::endl; std::cin.get(); std::cin.get(); // Create Battle object. Battle battleSystem; // Run main program loop while player isn't dead. while(!playerHandle->PlayerIsDead()) { if(playerHandle->ReturnLevel() % 3 == 0) { battleSystem.BossBattle(playerHandle); } else { battleSystem.RandomBattle(playerHandle); } if(!playerHandle->PlayerIsDead()) { enum MenuOptions {NextBattle = 1, WeaponShop = 2, DisplayStats = 3, QuitGame = 4}; int menuChoicesTotal = 4; int menuChoice = 0; while(menuChoice != NextBattle) { std::cout << "Menu: " << std::endl; std::cout << "[1] Next Battle" << std::endl; std::cout << "[2] Weapon Shop" << std::endl; std::cout << "[3] Display Stats" << std::endl; std::cout << "[4] Quit Game" << std::endl; std::cout << ">> "; // Take user input for menu choice, check for invalid input. while(!(std::cin >> menuChoice) || menuChoice < 0 || menuChoicesTotal < menuChoice) { // Clear std::cin and remove extra characters from istream. HandleInvalidInput(std::cin); } if(menuChoice == WeaponShop) { // Check the job type of the player. This is used to // determine which store the player needs to visit. std::string jobType = playerHandle->JobType(); if(jobType == "warrior") { swordShop.DisplayInventory(); swordShop.ProcessTransaction(playerHandle); } else if(jobType == "mage") { staveShop.DisplayInventory(); staveShop.ProcessTransaction(playerHandle); } else if(jobType == "archer") { bowShop.DisplayInventory(); bowShop.ProcessTransaction(playerHandle); } } else if(menuChoice == DisplayStats) { playerHandle->DisplayStats(); std::cout << "Press enter to continue."; std::cin.get(); std::cin.get(); } else if(menuChoice == QuitGame) { std::cout << "This isn't programmed yet." << std::endl; } std::cout << std::endl; } } } return 0; }
// TODO: Make a nice happy GUI thingie for making a user.cfg // This is ugly. :( void Engine::Startup(std::string& pathname) { CDEBUG("Startup"); std::string gamePathName; std::string cfgPathName; std::string logPathName; // Load game.ika-game. std::ifstream file; if(!pathname.empty()) { IkaPath::_game = pathname + "/"; } gamePathName = IkaPath::_game + "game.ika-game"; cfgPathName = IkaPath::_game + "user.cfg"; logPathName = IkaPath::_game + "ika.log"; file.open(gamePathName.c_str()); if (!file.is_open()) { // We should have a function for concatenating multiple char arrays. std::string fileError = "Game Startup: "; fileError += gamePathName; fileError += " does not exist.\n"; Sys_Error(fileError.c_str()); return; } aries::DataNode* document; file >> document; file.close(); std::string title; std::string currentNodeName = "<?>"; uint xres = 0; uint yres = 0; try { aries::DataNode* rootNode = document->getChild("ika-game"); currentNodeName = "ika-game"; // Load information node. { aries::DataNode* infoNode = rootNode->getChild("information"); currentNodeName = "information"; title = infoNode->getChild("title")->getString(); } // Load video node. { aries::DataNode* videoNode = rootNode->getChild("video"); currentNodeName = "video"; xres = (uint)std::atoi(videoNode->getChild("xres")->getString().c_str()); yres = (uint)std::atoi(videoNode->getChild("yres")->getString().c_str()); } // Load resources node (optional). { if(rootNode->hasChild("resources")) { aries::DataNode* resNode = rootNode->getChild("resources"); currentNodeName = "resources"; // Set map path. if(resNode->hasChild("maps")) IkaPath::_map = resNode->getChild("maps")->getString(); if(!IkaPath::_map.empty()) IkaPath::_map += "/"; } } } catch (std::runtime_error error) { std::string msg = "Game Startup: Error in game.ika-game, inside node '"; msg += currentNodeName + "': "; msg += error.what(); Sys_Error(msg.c_str()); return; } CConfigFile cfg(cfgPathName.c_str()); // init a few values _showFramerate = cfg.Int("showfps") != 0; _frameSkip = min(1, cfg.Int("frameskip")); // Now the tricky stuff. try { if (cfg.Int("log")) { Log::Init(logPathName.c_str()); } Log::Write("ika %s startup", IKA_VERSION); Log::Write("Built on " __DATE__); Log::Write("--------------------------"); Log::Write("Initializing SDL"); SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_JOYSTICK #ifndef _DEBUG | SDL_INIT_NOPARACHUTE #endif ); atexit(SDL_Quit); #if (!defined _DEBUG) SDL_WM_SetCaption(title.c_str(), 0); #else SDL_WM_SetCaption(va("%s (debug)", title), 0); #endif Log::Write("Initializing Video"); std::string driver = toLower(cfg["videodriver"]); #if 0 // disabled because it's unstable and scary. if (driver == "soft" || driver == "sdl") { Log::Write("Starting SDL video driver"); video = new Soft32::Driver( xres, yres, cfg.Int("bitdepth"), cfg.Int("fullscreen") != 0); } else if (driver == "opengl") #endif { Log::Write("Starting OpenGL video driver"); video = new OpenGL::Driver( xres, yres, cfg.Int("bitdepth"), cfg.Int("fullscreen") != 0, cfg.Int("doublesize") != 0, cfg.Long("filter") != 0); } #ifdef WIN32 { SDL_SysWMinfo info; SDL_VERSION(&info.version); HWND hWnd = SDL_GetWMInfo(&info) ? info.window : 0; if (hWnd) SetClassLong(hWnd, GCL_HICON, (long)LoadIcon(GetModuleHandle(0), "AppIcon")); } #endif Log::Write("Initializing Input"); SDL_JoystickEventState(SDL_ENABLE); Input::getInstance(); // force creation of the singleton instance. Log::Write("Initializing sound"); Sound::Init(cfg.Int("nosound") != 0); } catch (Video::Exception) { video = 0; Sys_Error("Unable to set the video mode.\nAre you sure your hardware can handle the chosen settings?"); } catch (Sound::Exception) { Log::Write("Sound initialization failed. Disabling audio."); } catch (...) { Sys_Error("An unknown error occurred during initialization."); } SeedRandom(); Log::Write("Initing Python"); script.Init(this); Log::Write("Executing system.py"); bool result = script.LoadSystemScripts(pathname); if (!result) { Script_Error(); } if (!_isMapLoaded) { Sys_Error(""); } Log::Write("Startup complete"); }
void GenerateUrquanWreck (BYTE control) { switch (control) { case GENERATE_ENERGY: if (pSolarSysState->pOrbitalDesc == &pSolarSysState->PlanetDesc[6]) { DWORD rand_val, old_rand; old_rand = SeedRandom ( pSolarSysState->SysInfo.PlanetInfo.ScanSeed[ENERGY_SCAN] ); rand_val = Random (); pSolarSysState->SysInfo.PlanetInfo.CurPt.x = (LOBYTE (LOWORD (rand_val)) % (MAP_WIDTH - (8 << 1))) + 8; pSolarSysState->SysInfo.PlanetInfo.CurPt.y = (HIBYTE (LOWORD (rand_val)) % (MAP_HEIGHT - (8 << 1))) + 8; pSolarSysState->SysInfo.PlanetInfo.CurDensity = 0; if (!GET_GAME_STATE (PORTAL_KEY)) pSolarSysState->SysInfo.PlanetInfo.CurType = 0; else pSolarSysState->SysInfo.PlanetInfo.CurType = 1; pSolarSysState->CurNode = 1; if (pSolarSysState->SysInfo.PlanetInfo.ScanRetrieveMask[ENERGY_SCAN] & (1L << 0)) { pSolarSysState->SysInfo.PlanetInfo.ScanRetrieveMask[ENERGY_SCAN] &= ~(1L << 0); if (!GET_GAME_STATE (PORTAL_KEY)) { ((PPLANETSIDE_DESC)pMenuState->ModuleFrame)->InTransit = TRUE; SET_GAME_STATE (PORTAL_KEY, 1); SET_GAME_STATE (PORTAL_KEY_ON_SHIP, 1); } } SeedRandom (old_rand); break; } pSolarSysState->CurNode = 0; break; case GENERATE_ORBITAL: if (pSolarSysState->pOrbitalDesc == &pSolarSysState->PlanetDesc[6]) { pSolarSysState->SysInfo.PlanetInfo.LanderFont = CaptureFont ( LoadGraphic (LANDER_FONT) ); pSolarSysState->PlanetSideFrame[1] = CaptureDrawable ( LoadGraphic (WRECK_MASK_PMAP_ANIM) ); pSolarSysState->SysInfo.PlanetInfo.DiscoveryString = CaptureStringTable ( LoadStringTable (WRECK_STRTAB) ); if (GET_GAME_STATE (PORTAL_KEY)) pSolarSysState->SysInfo.PlanetInfo.DiscoveryString = SetAbsStringTableIndex ( pSolarSysState->SysInfo.PlanetInfo.DiscoveryString, 1 ); } default: GenerateRandomIP (control); break; } }