int realmain(int argc, char *argv[])
{
wzMain(argc, argv);
int utfargc = argc;
const char** utfargv = (const char**)argv;
#ifdef WZ_OS_MAC
cocoaInit();
#endif
debug_init();
debug_register_callback( debug_callback_stderr, NULL, NULL, NULL );
#if defined(WZ_OS_WIN) && defined(DEBUG_INSANE)
debug_register_callback( debug_callback_win32debug, NULL, NULL, NULL );
#endif // WZ_OS_WIN && DEBUG_INSANE
// *****
// NOTE: Try *NOT* to use debug() output routines without some other method of informing the user. All this output is sent to /dev/nul at this point on some platforms!
// *****
if (!getUTF8CmdLine(&utfargc, &utfargv))
{
return EXIT_FAILURE;
}
QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8")); // make Qt treat all C strings in Warzone as UTF-8
setupExceptionHandler(utfargc, utfargv, version_getFormattedVersionString());
/*** Initialize PhysicsFS ***/
initialize_PhysicsFS(utfargv[0]);
/*** Initialize translations ***/
initI18n();
// find early boot info
if (!ParseCommandLineEarly(utfargc, utfargv))
{
return EXIT_FAILURE;
}
/* Initialize the write/config directory for PhysicsFS.
* This needs to be done __after__ the early commandline parsing,
* because the user might tell us to use an alternative configuration
* directory.
*/
initialize_ConfigDir();
/*** Initialize directory structure ***/
make_dir(ScreenDumpPath, "screenshots", NULL);
make_dir(SaveGamePath, "savegames", NULL);
PHYSFS_mkdir("savegames/campaign");
PHYSFS_mkdir("savegames/skirmish");
make_dir(MultiCustomMapsPath, "maps", NULL); // MUST have this to prevent crashes when getting map
PHYSFS_mkdir("music");
PHYSFS_mkdir("logs"); // a place to hold our netplay, mingw crash reports & WZ logs
PHYSFS_mkdir("userdata"); // a place to store per-mod data user generated data
memset(rulesettag, 0, sizeof(rulesettag)); // tag to add to userdata to find user generated stuff
make_dir(MultiPlayersPath, "multiplay", NULL);
make_dir(MultiPlayersPath, "multiplay", "players");
if (!customDebugfile)
{
// there was no custom debug file specified (--debug-file=blah)
// so we use our write directory to store our logs.
time_t aclock;
struct tm *newtime;
char buf[PATH_MAX];
time( &aclock ); // Get time in seconds
newtime = localtime( &aclock ); // Convert time to struct
// Note: We are using fopen(), and not physfs routines to open the file
// log name is logs/(or \)WZlog-MMDD_HHMMSS.txt
snprintf(buf, sizeof(buf), "%slogs%sWZlog-%02d%02d_%02d%02d%02d.txt", PHYSFS_getWriteDir(), PHYSFS_getDirSeparator(),
newtime->tm_mon + 1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec );
debug_register_callback( debug_callback_file, debug_callback_file_init, debug_callback_file_exit, buf );
// FIXME: Change this to LOG_WZ on next release
debug(LOG_INFO, "Using %s debug file", buf);
}
// NOTE: it is now safe to use debug() calls to make sure output gets captured.
check_Physfs();
debug(LOG_WZ, "Warzone 2100 - %s", version_getFormattedVersionString());
debug(LOG_WZ, "Using language: %s", getLanguage());
debug(LOG_WZ, "Backend: %s", BACKEND);
debug(LOG_MEMORY, "sizeof: SIMPLE_OBJECT=%ld, BASE_OBJECT=%ld, DROID=%ld, STRUCTURE=%ld, FEATURE=%ld, PROJECTILE=%ld",
(long)sizeof(SIMPLE_OBJECT), (long)sizeof(BASE_OBJECT), (long)sizeof(DROID), (long)sizeof(STRUCTURE), (long)sizeof(FEATURE), (long)sizeof(PROJECTILE));
/* Put in the writedir root */
sstrcpy(KeyMapPath, "keymap.map");
// initialise all the command line states
war_SetDefaultStates();
debug(LOG_MAIN, "initializing");
PhysicsEngineHandler engine; // register abstract physfs filesystem
loadConfig();
// parse the command line
if (!ParseCommandLine(utfargc, utfargv))
{
return EXIT_FAILURE;
}
// Save new (commandline) settings
saveConfig();
// Find out where to find the data
scanDataDirs();
// Now we check the mods to see if they exist or not (specified on the command line)
// They are all capped at 100 mods max(see clparse.c)
// FIX ME: I know this is a bit hackish, but better than nothing for now?
{
char *modname;
char modtocheck[256];
int i = 0;
int result = 0;
// check global mods
for(i=0; i < 100; i++)
{
modname = global_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/global/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The (global) mod (%s) you have specified doesn't exist!", modname);
}
else
{
info("(global) mod (%s) is enabled", modname);
}
}
// check campaign mods
for(i=0; i < 100; i++)
{
modname = campaign_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/campaign/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The mod_ca (%s) you have specified doesn't exist!", modname);
}
else
{
info("mod_ca (%s) is enabled", modname);
}
}
// check multiplay mods
for(i=0; i < 100; i++)
{
modname = multiplay_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/multiplay/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The mod_mp (%s) you have specified doesn't exist!", modname);
}
else
{
info("mod_mp (%s) is enabled", modname);
}
}
}
if (!wzMain2())
{
return EXIT_FAILURE;
}
int w = pie_GetVideoBufferWidth();
int h = pie_GetVideoBufferHeight();
char buf[256];
ssprintf(buf, "Video Mode %d x %d (%s)", w, h, war_getFullscreen() ? "fullscreen" : "window");
addDumpInfo(buf);
debug(LOG_MAIN, "Final initialization");
if (!frameInitialise())
{
return EXIT_FAILURE;
}
war_SetWidth(pie_GetVideoBufferWidth());
war_SetHeight(pie_GetVideoBufferHeight());
// Fix up settings from the config file
// And initialize shader usage setting
if (!pie_GetShaderAvailability())
{
war_SetShaders(FALLBACK);
pie_SetShaderUsage(false);
}
else
{
if (war_GetShaders() == FALLBACK)
{
war_SetShaders(SHADERS_OFF);
}
if (!pie_GetFallbackAvailability())
{
war_SetShaders(SHADERS_ONLY);
pie_SetShaderUsage(true);
}
else if (war_GetShaders() == SHADERS_ONLY || war_GetShaders() == SHADERS_ON)
{
war_SetShaders(SHADERS_ON);
pie_SetShaderUsage(true);
}
else // (war_GetShaders() == SHADERS_OFF)
{
pie_SetShaderUsage(false);
}
}
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);
pal_Init();
pie_LoadBackDrop(SCREEN_RANDOMBDROP);
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);
if (!systemInitialise())
{
return EXIT_FAILURE;
}
//set all the pause states to false
setAllPauseStates(false);
// Copy this info to be used by the crash handler for the dump file
ssprintf(buf,"Using Backend: %s", BACKEND);
addDumpInfo(buf);
ssprintf(buf,"Using language: %s", getLanguageName());
addDumpInfo(buf);
// Do the game mode specific initialisation.
switch(GetGameMode())
{
case GS_TITLE_SCREEN:
startTitleLoop();
break;
case GS_SAVEGAMELOAD:
initSaveGameLoad();
break;
case GS_NORMAL:
startGameLoop();
break;
default:
debug(LOG_ERROR, "Weirdy game status, I'm afraid!!");
break;
}
#if defined(WZ_CC_MSVC) && defined(DEBUG)
debug_MEMSTATS();
#endif
debug(LOG_MAIN, "Entering main loop");
wzMain3();
saveConfig();
systemShutdown();
#ifdef WZ_OS_WIN // clean up the memory allocated for the command line conversion
for (int i=0; i<argc; i++)
{
const char*** const utfargvF = &utfargv;
free((void *)(*utfargvF)[i]);
}
free(utfargv);
#endif
wzShutdown();
debug(LOG_MAIN, "Completed shutting down Warzone 2100");
return EXIT_SUCCESS;
}
// ///////////////// /////////////////////////////////////////////////
// Main Front end game loop.
TITLECODE titleLoop(void)
{
TITLECODE RetCode = TITLECODE_CONTINUE;
pie_SetDepthBufferStatus(DEPTH_CMP_ALWAYS_WRT_ON);
pie_SetFogStatus(false);
screen_RestartBackDrop();
wzShowMouse(true);
// When we first init the game, firstcall is true.
if (firstcall)
{
firstcall = false;
// First check to see if --host was given as a command line option, if not,
// then check --join and if neither, run the normal game menu.
if (hostlaunch)
{
NetPlay.bComms = true; // use network = true
NetPlay.isUPNP_CONFIGURED = false;
NetPlay.isUPNP_ERROR = false;
ingame.bHostSetup = true;
bMultiPlayer = true;
bMultiMessages = true;
NETinit(true);
NETdiscoverUPnPDevices();
game.type = SKIRMISH;
changeTitleMode(MULTIOPTION);
hostlaunch = false; // reset the bool to default state.
}
else if (strlen(iptoconnect))
{
NetPlay.bComms = true; // use network = true
NETinit(true);
joinGame(iptoconnect, 0);
}
else
{
changeTitleMode(TITLE); // normal game, run main title screen.
}
// Using software cursors (when on) for these menus due to a bug in SDL's SDL_ShowCursor()
wzSetCursor(CURSOR_DEFAULT);
}
if (titleMode != MULTIOPTION && titleMode != MULTILIMIT && titleMode != STARTGAME)
{
screen_disableMapPreview();
}
switch (titleMode) // run relevant title screen code.
{
// MULTIPLAYER screens
case PROTOCOL:
runConnectionScreen(); // multiplayer connection screen.
break;
case MULTIOPTION:
runMultiOptions();
break;
case GAMEFIND:
runGameFind();
break;
case MULTI:
runMultiPlayerMenu();
break;
case MULTILIMIT:
runLimitScreen();
break;
case KEYMAP:
runKeyMapEditor();
break;
case TITLE:
runTitleMenu();
break;
case CAMPAIGNS:
runCampaignSelector();
break;
case SINGLE:
runSinglePlayerMenu();
break;
case TUTORIAL:
runTutorialMenu();
break;
case CREDITS:
runCreditsScreen();
break;
case OPTIONS:
runOptionsMenu();
break;
case GAME:
runGameOptionsMenu();
break;
case GRAPHICS_OPTIONS:
runGraphicsOptionsMenu();
break;
case AUDIO_OPTIONS:
runAudioOptionsMenu();
break;
case VIDEO_OPTIONS:
runVideoOptionsMenu();
break;
case MOUSE_OPTIONS:
runMouseOptionsMenu();
break;
case QUIT:
RetCode = TITLECODE_QUITGAME;
break;
case STARTGAME:
case LOADSAVEGAME:
if (titleMode == LOADSAVEGAME)
{
RetCode = TITLECODE_SAVEGAMELOAD;
}
else
{
RetCode = TITLECODE_STARTGAME;
}
return RetCode; // don't flip!
case SHOWINTRO:
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);
changeTitleMode(TITLE);
RetCode = TITLECODE_SHOWINTRO;
break;
default:
debug(LOG_FATAL, "unknown title screen mode");
abort();
}
NETflush(); // Send any pending network data.
audio_Update();
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);//title loop
if ((keyDown(KEY_LALT) || keyDown(KEY_RALT)) && keyPressed(KEY_RETURN))
{
war_setFullscreen(!war_getFullscreen());
wzToggleFullscreen();
}
return RetCode;
}
// ////////////////////////////////////////////////////////////////////////////
bool saveConfig()
{
WzConfig ini(fileName);
if (ini.status() != QSettings::NoError)
{
debug(LOG_ERROR, "Could not open configuration file \"%s\"", fileName);
return false;
}
debug(LOG_WZ, "Writing prefs to registry \"%s\"", ini.fileName().toUtf8().constData());
// //////////////////////////
// voicevol, fxvol and cdvol
ini.setValue("voicevol", (int)(sound_GetUIVolume() * 100.0));
ini.setValue("fxvol", (int)(sound_GetEffectsVolume() * 100.0));
ini.setValue("cdvol", (int)(sound_GetMusicVolume() * 100.0));
ini.setValue("music_enabled", war_GetMusicEnabled());
ini.setValue("width", war_GetWidth());
ini.setValue("height", war_GetHeight());
ini.setValue("bpp", pie_GetVideoBufferDepth());
ini.setValue("fullscreen", war_getFullscreen());
ini.setValue("language", getLanguage());
// dont save out the cheat mode.
if (getDifficultyLevel() != DL_KILLER && getDifficultyLevel() != DL_TOUGH)
{
ini.setValue("difficulty", getDifficultyLevel()); // level
}
ini.setValue("framerate", (SDWORD)getFramerateLimit());
ini.setValue("showFPS", (SDWORD)showFPS);
ini.setValue("scroll",(SDWORD)scroll_speed_accel); // scroll
ini.setValue("visfog",(SDWORD)(!war_GetFog())); // fogtype
ini.setValue("shake",(SDWORD)(getShakeStatus())); // screenshake
ini.setValue("mouseflip",(SDWORD)(getInvertMouseStatus())); // flipmouse
ini.setValue("nomousewrap", (SDWORD)getMouseWarp()); // mouse wrap
ini.setValue("RightClickOrders",(SDWORD)(getRightClickOrders()));
ini.setValue("MiddleClickRotate",(SDWORD)(getMiddleClickRotate()));
ini.setValue("showFPS", (SDWORD)showFPS);
ini.setValue("shadows",(SDWORD)(getDrawShadows())); // shadows
ini.setValue("sound", (SDWORD)war_getSoundEnabled());
ini.setValue("FMVmode",(SDWORD)(war_GetFMVmode())); // sequences
ini.setValue("scanlines", (SDWORD)war_getScanlineMode());
ini.setValue("subtitles",(SDWORD)(seq_GetSubtitles())); // subtitles
ini.setValue("radarObjectMode",(SDWORD)bEnemyAllyRadarColor); // enemy/allies radar view
ini.setValue("radarTerrainMode",(SDWORD)radarDrawMode);
ini.setValue("trapCursor", war_GetTrapCursor());
ini.setValue("vsync", war_GetVsync());
ini.setValue("textureSize", getTextureSize());
ini.setValue("FSAA", war_getFSAA());
ini.setValue("UPnP", (SDWORD)NetPlay.isUPNP);
ini.setValue("rotateRadar", rotateRadar);
ini.setValue("PauseOnFocusLoss", war_GetPauseOnFocusLoss());
ini.setValue("masterserver_name", NETgetMasterserverName());
ini.setValue("masterserver_port", NETgetMasterserverPort());
ini.setValue("gameserver_port", NETgetGameserverPort());
if (!bMultiPlayer)
{
ini.setValue("colour", getPlayerColour(0)); // favourite colour.
}
else
{
if (NetPlay.isHost && ingame.localJoiningInProgress)
{
if (bMultiPlayer && NetPlay.bComms)
{
ini.setValue("gameName", game.name); // last hosted game
}
ini.setValue("mapName", game.map); // map name
ini.setValue("maxPlayers", game.maxPlayers); // maxPlayers
ini.setValue("power", game.power); // power
ini.setValue("base", game.base); // size of base
ini.setValue("fog", game.fog); // fog 'o war
ini.setValue("alliance", game.alliance); // allow alliances
}
ini.setValue("playerName", (char*)sPlayer); // player name
}
ini.sync();
return true;
}
// ////////////////////////////////////////////////////////////////////////////
bool saveConfig(void)
{
debug( LOG_WZ, "Writing prefs to registry\n" );
if(!openWarzoneKey())
{
return false;
}
// //////////////////////////
// voicevol, fxvol and cdvol
setWarzoneKeyNumeric("voicevol", (int)(sound_GetUIVolume() * 100.0));
setWarzoneKeyNumeric("fxvol", (int)(sound_GetEffectsVolume() * 100.0));
setWarzoneKeyNumeric("cdvol", (int)(sound_GetMusicVolume() * 100.0));
setWarzoneKeyNumeric("music_enabled", war_GetMusicEnabled());
setWarzoneKeyNumeric("width", war_GetWidth());
setWarzoneKeyNumeric("height", war_GetHeight());
setWarzoneKeyNumeric("bpp", pie_GetVideoBufferDepth());
setWarzoneKeyNumeric("fullscreen", war_getFullscreen());
setWarzoneKeyString("language", getLanguage());
// dont save out the cheat mode.
if(getDifficultyLevel()==DL_KILLER || getDifficultyLevel()== DL_TOUGH)
{
setDifficultyLevel(DL_NORMAL);
}
setWarzoneKeyNumeric("debugmode", bAllowDebugMode);
setWarzoneKeyNumeric("framerate", (SDWORD)getFramerateLimit());
setWarzoneKeyNumeric("showFPS", (SDWORD)showFPS);
setWarzoneKeyNumeric("scroll",(SDWORD)scroll_speed_accel); // scroll
setWarzoneKeyNumeric("difficulty", getDifficultyLevel()); // level
setWarzoneKeyNumeric("visfog",(SDWORD)(!war_GetFog())); // fogtype
setWarzoneKeyNumeric("shake",(SDWORD)(getShakeStatus())); // screenshake
setWarzoneKeyNumeric("mouseflip",(SDWORD)(getInvertMouseStatus())); // flipmouse
setWarzoneKeyNumeric("RightClickOrders",(SDWORD)(getRightClickOrders()));
setWarzoneKeyNumeric("MiddleClickRotate",(SDWORD)(getMiddleClickRotate()));
setWarzoneKeyNumeric("shadows",(SDWORD)(getDrawShadows())); // shadows
setWarzoneKeyNumeric("sound", (SDWORD)war_getSoundEnabled());
setWarzoneKeyNumeric("FMVmode",(SDWORD)(war_GetFMVmode())); // sequences
setWarzoneKeyNumeric("subtitles",(SDWORD)(seq_GetSubtitles())); // subtitles
setWarzoneKeyNumeric("radarObjectMode",(SDWORD)bEnemyAllyRadarColor); // enemy/allies radar view
setWarzoneKeyNumeric("radarTerrainMode",(SDWORD)radarDrawMode);
setWarzoneKeyNumeric("trapCursor", war_GetTrapCursor());
setWarzoneKeyNumeric("vsync", war_GetVsync());
setWarzoneKeyNumeric("textureSize", getTextureSize());
setWarzoneKeyNumeric("rotateRadar", rotateRadar);
setWarzoneKeyNumeric("PauseOnFocusLoss", war_GetPauseOnFocusLoss());
setWarzoneKeyNumeric("ColouredCursor", war_GetColouredCursor());
setWarzoneKeyString("masterserver_name", NETgetMasterserverName());
setWarzoneKeyNumeric("masterserver_port", NETgetMasterserverPort());
setWarzoneKeyNumeric("gameserver_port", NETgetGameserverPort());
if(!bMultiPlayer)
{
setWarzoneKeyNumeric("colour",(SDWORD)getPlayerColour(0)); // favourite colour.
}
else
{
debug( LOG_NEVER, "Writing multiplay prefs to registry\n" );
if (NetPlay.isHost && ingame.localJoiningInProgress)
{
if (bMultiPlayer && NetPlay.bComms)
{
setWarzoneKeyString("gameName", game.name); // last hosted game
}
setWarzoneKeyString("mapName", game.map); // map name
setWarzoneKeyNumeric("maxPlayers",game.maxPlayers); // maxPlayers
setWarzoneKeyNumeric("power", game.power); // power
setWarzoneKeyNumeric("base", game.base); // size of base
setWarzoneKeyNumeric("fog", game.fog); // fog 'o war
setWarzoneKeyNumeric("alliance", game.alliance); // allow alliances
}
setWarzoneKeyString("playerName",(char*)sPlayer); // player name
setWarzoneKeyString("phrase0", ingame.phrases[0]); // phrases
setWarzoneKeyString("phrase1", ingame.phrases[1]);
setWarzoneKeyString("phrase2", ingame.phrases[2]);
setWarzoneKeyString("phrase3", ingame.phrases[3]);
setWarzoneKeyString("phrase4", ingame.phrases[4]);
}
return closeWarzoneKey();
}
bool runVideoOptionsMenu(void)
{
SDL_Rect **modes = SDL_ListModes(NULL, SDL_FULLSCREEN | SDL_HWSURFACE);
UDWORD id = widgRunScreen(psWScreen);
switch (id)
{
case FRONTEND_WINDOWMODE:
case FRONTEND_WINDOWMODE_R:
if (war_getFullscreen())
{
war_setFullscreen(false);
widgSetString(psWScreen, FRONTEND_WINDOWMODE_R, _("Windowed"));
}
else
{
war_setFullscreen(true);
widgSetString(psWScreen, FRONTEND_WINDOWMODE_R, _("Fullscreen"));
}
break;
case FRONTEND_RESOLUTION:
case FRONTEND_RESOLUTION_R:
{
int current, count, oldcurrent;
// Get the current mode offset
for (count = 0, current = 0; modes[count]; count++)
{
if (war_GetWidth() == modes[count]->w
&& war_GetHeight() == modes[count]->h)
{
current = count;
}
}
// Increment and clip if required
// Hide resolutions lower than Warzone can support
oldcurrent = current;
do
{
if (!mouseReleased(MOUSE_RMB))
{
if (--current < 0)
current = count - 1;
}
else
{
if (++current == count)
current = 0;
}
} while ((modes[current]->w < 640 || modes[current]->h < 480)
&& current != oldcurrent);
// Set the new width and height (takes effect on restart)
war_SetWidth(modes[current]->w);
war_SetHeight(modes[current]->h);
// Generate the textual representation of the new width and height
snprintf(resolution, WIDG_MAXSTR, "%d x %d", modes[current]->w,
modes[current]->h);
// Update the widget
widgSetString(psWScreen, FRONTEND_RESOLUTION_R, resolution);
break;
}
case FRONTEND_TRAP:
case FRONTEND_TRAP_R:
if (war_GetTrapCursor())
{
war_SetTrapCursor(false);
widgSetString(psWScreen, FRONTEND_TRAP_R, _("Off"));
}
else
{
war_SetTrapCursor(true);
widgSetString(psWScreen, FRONTEND_TRAP_R, _("On"));
}
break;
case FRONTEND_TEXTURESZ:
case FRONTEND_TEXTURESZ_R:
{
int newTexSize = getTextureSize() * 2;
// Clip such that 128 <= size <= 2048
if (newTexSize > 2048)
{
newTexSize = 128;
}
// Set the new size
setTextureSize(newTexSize);
// Generate the string representation of the new size
snprintf(textureSize, WIDG_MAXSTR, "%d", newTexSize);
// Update the widget
widgSetString(psWScreen, FRONTEND_TEXTURESZ_R, textureSize);
break;
}
case FRONTEND_VSYNC:
case FRONTEND_VSYNC_R:
{
if (war_GetVsync())
{
war_SetVsync(false);
widgSetString(psWScreen, FRONTEND_VSYNC_R, _("Off"));
}
else
{
war_SetVsync(true);
widgSetString(psWScreen, FRONTEND_VSYNC_R, _("On"));
}
break;
}
case FRONTEND_QUIT:
changeTitleMode(OPTIONS);
break;
default:
break;
}
if (CancelPressed())
{
changeTitleMode(OPTIONS);
}
widgDisplayScreen(psWScreen);
return true;
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
int utfargc = argc;
const char** utfargv = (const char**)argv;
#ifdef WZ_OS_MAC
cocoaInit();
#endif
debug_init();
debug_register_callback( debug_callback_stderr, NULL, NULL, NULL );
#if defined(WZ_OS_WIN) && defined(DEBUG_INSANE)
debug_register_callback( debug_callback_win32debug, NULL, NULL, NULL );
#endif // WZ_OS_WIN && DEBUG_INSANE
// *****
// NOTE: Try *NOT* to use debug() output routines without some other method of informing the user. All this output is sent to /dev/nul at this point on some platforms!
// *****
if (!getUTF8CmdLine(&utfargc, &utfargv))
{
return EXIT_FAILURE;
}
QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8")); // make Qt treat all C strings in Warzone as UTF-8
setupExceptionHandler(utfargc, utfargv, version_getFormattedVersionString());
/*** Initialize PhysicsFS ***/
initialize_PhysicsFS(utfargv[0]);
/*** Initialize translations ***/
initI18n();
// find early boot info
if (!ParseCommandLineEarly(utfargc, utfargv))
{
return EXIT_FAILURE;
}
/* Initialize the write/config directory for PhysicsFS.
* This needs to be done __after__ the early commandline parsing,
* because the user might tell us to use an alternative configuration
* directory.
*/
initialize_ConfigDir();
/*** Initialize directory structure ***/
make_dir(ScreenDumpPath, "screenshots", NULL);
make_dir(SaveGamePath, "savegames", NULL);
make_dir(MultiCustomMapsPath, "maps", NULL); // MUST have this to prevent crashes when getting map
PHYSFS_mkdir("music");
PHYSFS_mkdir("logs"); // a place to hold our netplay, mingw crash reports & WZ logs
make_dir(MultiPlayersPath, "multiplay", NULL);
make_dir(MultiPlayersPath, "multiplay", "players");
if (!customDebugfile)
{
// there was no custom debug file specified (--debug-file=blah)
// so we use our write directory to store our logs.
time_t aclock;
struct tm *newtime;
char buf[PATH_MAX];
time( &aclock ); // Get time in seconds
newtime = localtime( &aclock ); // Convert time to struct
// Note: We are using fopen(), and not physfs routines to open the file
// log name is logs/(or \)WZlog-MMDD_HHMMSS.txt
snprintf(buf, sizeof(buf), "%slogs%sWZlog-%02d%02d_%02d%02d%02d.txt", PHYSFS_getWriteDir(), PHYSFS_getDirSeparator(),
newtime->tm_mon, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec );
debug_register_callback( debug_callback_file, debug_callback_file_init, debug_callback_file_exit, buf );
}
// NOTE: it is now safe to use debug() calls to make sure output gets captured.
check_Physfs();
debug(LOG_WZ, "Warzone 2100 - %s", version_getFormattedVersionString());
debug(LOG_WZ, "Using language: %s", getLanguage());
debug(LOG_MEMORY, "sizeof: SIMPLE_OBJECT=%ld, BASE_OBJECT=%ld, DROID=%ld, STRUCTURE=%ld, FEATURE=%ld, PROJECTILE=%ld",
(long)sizeof(SIMPLE_OBJECT), (long)sizeof(BASE_OBJECT), (long)sizeof(DROID), (long)sizeof(STRUCTURE), (long)sizeof(FEATURE), (long)sizeof(PROJECTILE));
/* Put in the writedir root */
sstrcpy(KeyMapPath, "keymap.map");
// initialise all the command line states
war_SetDefaultStates();
debug(LOG_MAIN, "initializing");
PhysicsEngineHandler engine; // register abstract physfs filesystem
loadConfig();
// parse the command line
if (!ParseCommandLine(utfargc, utfargv))
{
return EXIT_FAILURE;
}
// Save new (commandline) settings
saveConfig();
// Find out where to find the data
scanDataDirs();
// This needs to be done after "scanDataDirs"
// for the root cert from cacert.
NETinit(true);
// Must be run before OpenGL driver is properly initialized due to
// strange conflicts - Per
if (selfTest)
{
memset(enabled_debug, 0, sizeof(*enabled_debug) * LOG_LAST);
fprintf(stdout, "Carrying out self-test:\n");
playListTest();
audioTest();
soundTest();
}
// Now we check the mods to see if they exist or not (specified on the command line)
// They are all capped at 100 mods max(see clparse.c)
// FIX ME: I know this is a bit hackish, but better than nothing for now?
{
char *modname;
char modtocheck[256];
int i = 0;
int result = 0;
// check global mods
for(i=0; i < 100; i++)
{
modname = global_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/global/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The (global) mod (%s) you have specified doesn't exist!", modname);
}
else
{
info("(global) mod (%s) is enabled", modname);
}
}
// check campaign mods
for(i=0; i < 100; i++)
{
modname = campaign_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/campaign/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The mod_ca (%s) you have specified doesn't exist!", modname);
}
else
{
info("mod_ca (%s) is enabled", modname);
}
}
// check multiplay mods
for(i=0; i < 100; i++)
{
modname = multiplay_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/multiplay/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The mod_mp (%s) you have specified doesn't exist!", modname);
}
else
{
info("mod_mp (%s) is enabled", modname);
}
}
}
debug(LOG_MAIN, "Qt initialization");
QGL::setPreferredPaintEngine(QPaintEngine::OpenGL); // Workaround for incorrect text rendering on nany platforms.
// Setting up OpenGL
QGLFormat format;
format.setDoubleBuffer(true);
format.setAlpha(true);
int w = pie_GetVideoBufferWidth();
int h = pie_GetVideoBufferHeight();
if (war_getFSAA())
{
format.setSampleBuffers(true);
format.setSamples(war_getFSAA());
}
WzMainWindow mainwindow(QSize(w, h), format);
mainwindow.setMinimumResolution(QSize(800, 600));
if (!mainwindow.context()->isValid())
{
QMessageBox::critical(NULL, "Oops!", "Warzone2100 failed to create an OpenGL context. This probably means that your graphics drivers are out of date. Try updating them!");
return EXIT_FAILURE;
}
screenWidth = w;
screenHeight = h;
if (war_getFullscreen())
{
mainwindow.resize(w,h);
mainwindow.showFullScreen();
if(w>mainwindow.width()) {
w = mainwindow.width();
}
if(h>mainwindow.height()) {
h = mainwindow.height();
}
pie_SetVideoBufferWidth(w);
pie_SetVideoBufferHeight(h);
}
else
{
mainwindow.show();
mainwindow.setMinimumSize(w, h);
mainwindow.setMaximumSize(w, h);
}
mainwindow.setSwapInterval(war_GetVsync());
war_SetVsync(mainwindow.swapInterval() > 0);
mainwindow.setReadyToPaint();
char buf[256];
ssprintf(buf, "Video Mode %d x %d (%s)", w, h, war_getFullscreen() ? "fullscreen" : "window");
addDumpInfo(buf);
debug(LOG_MAIN, "Final initialization");
if (!frameInitialise())
{
return EXIT_FAILURE;
}
war_SetWidth(pie_GetVideoBufferWidth());
war_SetHeight(pie_GetVideoBufferHeight());
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);
pal_Init();
pie_LoadBackDrop(SCREEN_RANDOMBDROP);
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);
if (!systemInitialise())
{
return EXIT_FAILURE;
}
//set all the pause states to false
setAllPauseStates(false);
/* Runtime unit testing */
if (selfTest)
{
parseTest();
levTest();
mapTest();
fprintf(stdout, "All tests PASSED!\n");
exit(0);
}
// Copy this info to be used by the crash handler for the dump file
ssprintf(buf,"Using language: %s", getLanguageName());
addDumpInfo(buf);
// Do the game mode specific initialisation.
switch(GetGameMode())
{
case GS_TITLE_SCREEN:
startTitleLoop();
break;
case GS_SAVEGAMELOAD:
initSaveGameLoad();
break;
case GS_NORMAL:
startGameLoop();
break;
default:
debug(LOG_ERROR, "Weirdy game status, I'm afraid!!");
break;
}
#if defined(WZ_CC_MSVC) && defined(DEBUG)
debug_MEMSTATS();
#endif
debug(LOG_MAIN, "Entering main loop");
app.exec();
saveConfig();
systemShutdown();
debug(LOG_MAIN, "Completed shutting down Warzone 2100");
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
int utfargc = argc;
const char** utfargv = (const char**)argv;
#ifdef WZ_OS_MAC
cocoaInit();
#endif
debug_init();
debug_register_callback( debug_callback_stderr, NULL, NULL, NULL );
#if defined(WZ_OS_WIN) && defined(DEBUG_INSANE)
debug_register_callback( debug_callback_win32debug, NULL, NULL, NULL );
#endif // WZ_OS_WIN && DEBUG_INSANE
if (!getUTF8CmdLine(&utfargc, &utfargv))
{
return -1;
}
setupExceptionHandler(utfargc, utfargv);
/*** Initialize PhysicsFS ***/
initialize_PhysicsFS(utfargv[0]);
/*** Initialize translations ***/
initI18n();
// find early boot info
if ( !ParseCommandLineEarly(utfargc, utfargv) ) {
return -1;
}
debug(LOG_WZ, "Using language: %s", getLanguage());
debug(LOG_MEMORY, "sizeof: SIMPLE_OBJECT=%ld, BASE_OBJECT=%ld, DROID=%ld, STRUCTURE=%ld, FEATURE=%ld, PROJECTILE=%ld",
(long)sizeof(SIMPLE_OBJECT), (long)sizeof(BASE_OBJECT), (long)sizeof(DROID), (long)sizeof(STRUCTURE), (long)sizeof(FEATURE), (long)sizeof(PROJECTILE));
/* Initialize the write/config directory for PhysicsFS.
* This needs to be done __after__ the early commandline parsing,
* because the user might tell us to use an alternative configuration
* directory.
*/
initialize_ConfigDir();
/*** Initialize directory structure ***/
make_dir(ScreenDumpPath, "screenshots", NULL);
make_dir(SaveGamePath, "savegame", NULL);
make_dir(MultiCustomMapsPath, "maps", NULL); // MUST have this to prevent crashes when getting map
PHYSFS_mkdir("music");
PHYSFS_mkdir("logs"); // a place to hold our netplay, mingw crash reports & WZ logs
make_dir(MultiPlayersPath, "multiplay", NULL);
make_dir(MultiPlayersPath, "multiplay", "players");
if (!customDebugfile)
{
// there was no custom debug file specified (--debug-file=blah)
// so we use our write directory to store our logs.
time_t aclock;
struct tm *newtime;
char buf[PATH_MAX];
time( &aclock ); // Get time in seconds
newtime = localtime( &aclock ); // Convert time to struct
// Note: We are using fopen(), and not physfs routines to open the file
// log name is logs/(or \)WZlog-MMDD_HHMMSS.txt
snprintf(buf, sizeof(buf), "%slogs%sWZlog-%02d%02d_%02d%02d%02d.txt", PHYSFS_getWriteDir(), PHYSFS_getDirSeparator(),
newtime->tm_mon, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec );
debug_register_callback( debug_callback_file, debug_callback_file_init, debug_callback_file_exit, buf );
}
debug(LOG_WZ, "Warzone 2100 - %s", version_getFormattedVersionString());
/* Put these files in the writedir root */
setRegistryFilePath("config");
sstrcpy(KeyMapPath, "keymap.map");
// initialise all the command line states
war_SetDefaultStates();
debug(LOG_MAIN, "initializing");
loadConfig();
NETinit(true);
// parse the command line
if (!ParseCommandLine(utfargc, utfargv)) {
return -1;
}
// Save new (commandline) settings
saveConfig();
// Find out where to find the data
scanDataDirs();
// Must be run before OpenGL driver is properly initialized due to
// strange conflicts - Per
if (selfTest)
{
memset(enabled_debug, 0, sizeof(*enabled_debug) * LOG_LAST);
fprintf(stdout, "Carrying out self-test:\n");
playListTest();
audioTest();
soundTest();
}
// Now we check the mods to see if they exsist or not (specified on the command line)
// They are all capped at 100 mods max(see clparse.c)
// FIX ME: I know this is a bit hackish, but better than nothing for now?
{
char *modname;
char modtocheck[256];
int i = 0;
int result = 0;
// check global mods
for(i=0; i < 100; i++)
{
modname = global_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/global/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The (global) mod (%s) you have specified doesn't exist!", modname);
}
else
{
info("(global) mod (%s) is enabled", modname);
}
}
// check campaign mods
for(i=0; i < 100; i++)
{
modname = campaign_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/campaign/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The mod_ca (%s) you have specified doesn't exist!", modname);
}
else
{
info("mod_ca (%s) is enabled", modname);
}
}
// check multiplay mods
for(i=0; i < 100; i++)
{
modname = multiplay_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/multiplay/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The mod_mp (%s) you have specified doesn't exist!", modname);
}
else
{
info("mod_mp (%s) is enabled", modname);
}
}
}
if (!frameInitialise( "Warzone 2100", pie_GetVideoBufferWidth(), pie_GetVideoBufferHeight(), pie_GetVideoBufferDepth(), war_getFSAA(), war_getFullscreen(), war_GetVsync()))
{
return -1;
}
war_SetWidth(pie_GetVideoBufferWidth());
war_SetHeight(pie_GetVideoBufferHeight());
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);
pal_Init();
pie_LoadBackDrop(SCREEN_RANDOMBDROP);
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);
if (!systemInitialise())
{
return -1;
}
//set all the pause states to false
setAllPauseStates(false);
/* Runtime unit testing */
if (selfTest)
{
tagTest();
parseTest();
levTest();
mapTest();
fprintf(stdout, "All tests PASSED!\n");
exit(0);
}
{
// Copy this info to be used by the crash handler for the dump file
char buf[256];
ssprintf(buf,"Using language: %s", getLanguageName());
addDumpInfo(buf);
}
// Do the game mode specific initialisation.
switch(GetGameMode())
{
case GS_TITLE_SCREEN:
startTitleLoop();
break;
case GS_SAVEGAMELOAD:
initSaveGameLoad();
break;
case GS_NORMAL:
startGameLoop();
break;
default:
debug(LOG_ERROR, "Weirdy game status, I'm afraid!!");
break;
}
debug(LOG_MAIN, "Entering main loop");
// Enter the mainloop
mainLoop();
debug(LOG_MAIN, "Shutting down Warzone 2100");
#if defined(WZ_CC_MSVC) && defined(DEBUG)
debug_MEMSTATS();
#endif
atexit(systemShutdown);
return EXIT_SUCCESS;
}
