static void DisplayLoop()
{
#if defined(USE_OPENGL) || defined(USE_GLES)
if (UseOpenGL) {
/* update only if screen changed */
ValidateOpenGLScreen();
}
#endif
/* update only if viewmode changed */
CheckViewportMode();
/*
* update only if Update flag is set
* FIXME: still not secure
*/
if (UI.Minimap.UpdateCache) {
UI.Minimap.Update();
UI.Minimap.UpdateCache = false;
}
//
// Map scrolling
//
DoScrollArea(MouseScrollState | KeyScrollState, (KeyModifiers & ModifierControl) != 0, MouseScrollState == 0 && KeyScrollState > 0);
ColorCycle();
#ifdef REALVIDEO
if (FastForwardCycle > GameCycle && RealVideoSyncSpeed != VideoSyncSpeed) {
RealVideoSyncSpeed = VideoSyncSpeed;
VideoSyncSpeed = 3000;
}
#endif
if (FastForwardCycle <= GameCycle || GameCycle <= 10 || !(GameCycle & 0x3f)) {
//FIXME: this might be better placed somewhere at front of the
// program, as we now still have a game on the background and
// need to go through the game-menu or supply a map file
UpdateDisplay();
//
// If double-buffered mode, we will display the contains of
// VideoMemory. If direct mode this does nothing. In X11 it does
// XFlush
//
RealizeVideoMemory();
}
#ifdef REALVIDEO
if (FastForwardCycle == GameCycle) {
VideoSyncSpeed = RealVideoSyncSpeed;
}
#endif
}
/**
** Show load progress.
**
** @param fmt printf format string.
*/
void ShowLoadProgress(const char *fmt, ...)
{
static unsigned int lastProgressUpdate = SDL_GetTicks();
if (SDL_GetTicks() < lastProgressUpdate + 16) {
// Only show progress updates every c. 1/60th of a second, otherwise we're waiting for the screen too much
return;
}
lastProgressUpdate = SDL_GetTicks();
UpdateLoadProgress();
va_list va;
char temp[4096];
va_start(va, fmt);
vsnprintf(temp, sizeof(temp) - 1, fmt, va);
temp[sizeof(temp) - 1] = '\0';
va_end(va);
if (Video.Depth && IsGameFontReady() && GetGameFont().IsLoaded()) {
// Remove non printable chars
for (unsigned char *s = (unsigned char *)temp; *s; ++s) {
if (*s < 32) {
*s = ' ';
}
}
//Wyrmgus start
// Video.FillRectangle(ColorBlack, 5, Video.Height - 18, Video.Width - 10, 18);
if (loadingBackground == nullptr) {
Video.FillRectangle(ColorBlack, 0, Video.Height - 18, Video.Width, 18);
}
//Wyrmgus end
CLabel(GetGameFont()).DrawCentered(Video.Width / 2, Video.Height - 16, temp);
//Wyrmgus start
// InvalidateArea(5, Video.Height - 18, Video.Width - 10, 18);
if (loadingBackground == nullptr) {
InvalidateArea(0, Video.Height - 18, Video.Width, 18);
} else {
InvalidateArea(0, 0, Video.Width, Video.Height);
}
//Wyrmgus end
RealizeVideoMemory();
} else {
DebugPrint("!!!!%s\n" _C_ temp);
}
PollEvents();
}
/**
** Show a title image
*/
void TitleScreen::ShowTitleImage()
{
const EventCallback *old_callbacks = GetCallbacks();
EventCallback callbacks;
WaitNoEvent = true;
callbacks.ButtonPressed = WaitCallbackButtonPressed;
callbacks.ButtonReleased = WaitCallbackButtonReleased;
callbacks.MouseMoved = WaitCallbackMouse;
callbacks.MouseExit = WaitCallbackExit;
callbacks.KeyPressed = WaitCallbackKeyPressed;
callbacks.KeyReleased = WaitCallbackKeyReleased;
callbacks.KeyRepeated = WaitCallbackKeyRepeated;
//callbacks.NetworkEvent = NetworkEvent;
callbacks.NetworkEvent = nullptr;
SetCallbacks(&callbacks);
CGraphic *g = CGraphic::New(this->File);
g->Load();
if (this->StretchImage) {
g->Resize(Video.Width, Video.Height);
}
int timeout = this->Timeout ? this->Timeout * CYCLES_PER_SECOND : -1;
while (timeout-- && WaitNoEvent) {
g->DrawClip((Video.Width - g->Width) / 2, (Video.Height - g->Height) / 2);
this->ShowLabels();
Invalidate();
RealizeVideoMemory();
WaitEventsOneFrame();
}
SetCallbacks(old_callbacks);
CGraphic::Free(g);
}
/**
** Play a video file.
**
** @param name Filename of movie file.
**
** @return Non-zero if file isn't a supported movie.
*/
int PlayMovie(const std::string &name)
{
OggData data;
CFile f;
SDL_Rect rect;
SDL_Overlay *yuv_overlay;
CSample *sample;
const EventCallback *old_callbacks;
EventCallback callbacks;
unsigned int start_ticks;
int need_data;
int diff;
char buffer[PATH_MAX];
LibraryFileName(name.c_str(), buffer, sizeof(buffer));
if (f.open(buffer, CL_OPEN_READ) == -1) {
fprintf(stderr, "Can't open file `%s'\n", name.c_str());
return -1;
}
memset(&data, 0, sizeof(data));
if (OggInit(&f, &data) || !data.video) {
OggFree(&data);
f.close();
return -1;
}
data.File = &f;
if (data.tinfo.frame_width * 300 / 4 > data.tinfo.frame_height * 100) {
rect.w = Video.Width;
rect.h = Video.Width * data.tinfo.frame_height / data.tinfo.frame_width;
rect.x = 0;
rect.y = (Video.Height - rect.h) / 2;
} else {
rect.w = Video.Height * data.tinfo.frame_width / data.tinfo.frame_height;
rect.h = Video.Height;
rect.x = (Video.Width - rect.w) / 2;
rect.y = 0;
}
yuv_overlay = SDL_CreateYUVOverlay(data.tinfo.frame_width,
data.tinfo.frame_height, SDL_YV12_OVERLAY, TheScreen);
if (yuv_overlay == NULL) {
fprintf(stderr, "SDL_CreateYUVOverlay: %s\n", SDL_GetError());
OggFree(&data);
f.close();
return 0;
}
StopMusic();
if ((sample = LoadVorbis(buffer, PlayAudioStream))) {
if ((sample->Channels != 1 && sample->Channels != 2) ||
sample->SampleSize != 16) {
fprintf(stderr, "Unsupported sound format in movie\n");
delete sample;
SDL_FreeYUVOverlay(yuv_overlay);
OggFree(&data);
f.close();
return 0;
}
PlayMusic(sample);
}
callbacks.ButtonPressed = MovieCallbackButtonPressed;
callbacks.ButtonReleased = MovieCallbackButtonReleased;
callbacks.MouseMoved = MovieCallbackMouseMove;
callbacks.MouseExit = MovieCallbackMouseExit;
callbacks.KeyPressed = MovieCallbackKeyPressed;
callbacks.KeyReleased = MovieCallbackKeyReleased;
callbacks.KeyRepeated = MovieCallbackKeyRepeated;
callbacks.NetworkEvent = NetworkEvent;
old_callbacks = GetCallbacks();
SetCallbacks(&callbacks);
Invalidate();
RealizeVideoMemory();
MovieStop = false;
start_ticks = SDL_GetTicks();
need_data = 1;
while (!MovieStop) {
if (need_data) {
if (TheoraProcessData(&data)) {
break;
}
need_data = 0;
}
diff = SDL_GetTicks() - start_ticks - static_cast<int>(
theora_granule_time(&data.tstate, data.tstate.granulepos) * 1000);
if (diff > 100) {
// too far behind, skip some frames
need_data = 1;
continue;
}
if (diff > 0) {
OutputTheora(&data, yuv_overlay, &rect);
need_data = 1;
}
WaitEventsOneFrame();
}
StopMusic();
SDL_FreeYUVOverlay(yuv_overlay);
OggFree(&data);
f.close();
SetCallbacks(old_callbacks);
return 0;
}
/**
** Game main loop.
**
** Unit actions.
** Missile actions.
** Players (AI).
** Cyclic events (color cycle,...)
** Display update.
** Input/Network/Sound.
*/
void GameMainLoop(void)
{
int player;
const EventCallback *old_callbacks;
InitGameCallbacks();
old_callbacks = GetCallbacks();
SetCallbacks(&GameCallbacks);
SetVideoSync();
GameCursor = UI.Point.Cursor;
GameRunning = true;
CParticleManager::init();
MultiPlayerReplayEachCycle();
CclCommand("GameStarting()");
std::ofstream output;
std::wstring templ;
firstClock = std::clock();
templateClock = 0;
int messageNumber = 1;
std::ofstream outputEventsPerSec;
std::ofstream outputNT;
outputEventsPerSec.open("/tmp/boswarseventspersec.csv",std::ios::out);
outputNT.open("/tmp/boswarsclocksperevents.csv",std::ios::out);
output.open("/tmp/beepbeep.fifo",std::ios::out);
templ = templ = L"<message>\n"
L" <units>\n"
L"{% for unit in units.tabunits %}"
L" <unit>\n"
L" <id>{$unit.id}</id>\n"
L" <type>{$unit.type}</type>\n"
L" <isbuilding>{$unit.isbuilding}</isbuilding>\n"
L" <player>{$unit.player}</player>\n"
L" <order>\n"
L" <action>{$unit.action}</action>\n"
L" <goal>{$unit.goal}</goal>\n"
L" </order>\n"
L" <neworder>\n"
L" <action>{$unit.neworder}</action>\n"
L" <goal>{$unit.newgoal}</goal>\n"
L" </neworder>\n"
L" </unit>\n"
L"{% endfor %}"
L" </units>\n"
L"<overhead>{$overhead}</overhead>\n"
L"</message>\n";
while (GameRunning) {
// Can't find a better place.
SaveGameLoading = false;
//
// Game logic part
//
if (!GamePaused && NetworkInSync && !SkipGameCycle) {
SinglePlayerReplayEachCycle();
++GameCycle;
MultiPlayerReplayEachCycle();
NetworkCommands(); // Get network commands
UnitActions(); // handle units
MissileActions(); // handle missiles
PlayersEachCycle(); // handle players
UpdateTimer(); // update game timer
//
// Work todo each second.
// Split into different frames, to reduce cpu time.
// Increment mana of magic units.
// Update mini-map.
// Update map fog of war.
// Call AI.
// Check game goals.
// Check rescue of units.
//
switch (GameCycle % CYCLES_PER_SECOND) {
case 0: // At cycle 0, start all ai players...
if (GameCycle == 0) {
for (player = 0; player < NumPlayers; ++player) {
PlayersEachSecond(player);
}
}
break;
case 1:
break;
case 2:
break;
case 3: // minimap update
UI.Minimap.Update();
break;
case 4:
break;
case 5:
break;
case 6: // overtaking units
RescueUnits();
break;
default:
// FIXME: assume that NumPlayers < (CYCLES_PER_SECOND - 7)
player = (GameCycle % CYCLES_PER_SECOND) - 7;
Assert(player >= 0);
if (player < NumPlayers) {
PlayersEachSecond(player);
}
}
////////////GET INFORMATION FOR MONITORING!!!////////////////////
if(NumUnits > 0)
{
std::clock_t littleClock = std::clock();
cpptempl::data_list theUnits;
std::stringstream ss;
for(int i = 0; i < NumUnits; i++)
{
cpptempl::data_map uni;
/////////ID/////////
ss.str("");
ss << Units[i]->Slot;
std::string theID = ss.str();
std::wstring wTheID;
wTheID.assign(theID.begin(),theID.end());
uni[L"id"] = cpptempl::make_data(wTheID);
//////UNITTYPE//////
ss.str("");
ss << Units[i]->Type->Name;
std::string theType = ss.str();
std::wstring wTheType;
wTheType.assign(theType.begin(),theType.end());
uni[L"type"] = cpptempl::make_data(wTheType);
//////ISBUILDING//////
ss.str("");
if (Units[i]->Type->Building == 1)
ss << "true";
else
ss << "false";
std::string theIsBuilding = ss.str();
std::wstring wTheIsBuilding;
wTheIsBuilding.assign(theIsBuilding.begin(),theIsBuilding.end());
uni[L"isbuilding"] = cpptempl::make_data(wTheIsBuilding);
//////PLAYER//////
ss.str("");
ss << Units[i]->Player;
std::string thePlayer = ss.str();
std::wstring wThePlayer;
wThePlayer.assign(thePlayer.begin(),thePlayer.end());
uni[L"player"] = cpptempl::make_data(wThePlayer);
//////UnitAction//////
ss.str("");
switch(Units[i]->Orders[0]->Action)
{
case UnitActionNone: ss << "UnitActionNone"; break;
case UnitActionStill: ss << "UnitActionStill"; break;
case UnitActionStandGround: ss << "UnitActionStandGround"; break;
case UnitActionFollow: ss << "UnitActionFollow"; break;
case UnitActionMove: ss << "UnitActionMove"; break;
case UnitActionAttack: ss << "UnitActionAttack"; break;
case UnitActionAttackGround: ss << "UnitActionAttackGround"; break;
case UnitActionDie: ss << "UnitActionDie"; break;
case UnitActionSpellCast: ss << "UnitActionSpellCast"; break;
case UnitActionTrain: ss << "UnitActionTrain"; break;
case UnitActionBuilt: ss << "UnitActionBuilt"; break;
case UnitActionBoard: ss << "UnitActionBoard"; break;
case UnitActionUnload: ss << "UnitActionUnload"; break;
case UnitActionPatrol: ss << "UnitActionPatrol"; break;
case UnitActionBuild: ss << "UnitActionBuild"; break;
case UnitActionRepair: ss << "UnitActionRepair"; break;
case UnitActionResource: ss << "UnitActionResource"; break;
default: ss << "None";
}
std::string theAction = ss.str();
std::wstring wTheAction;
wTheAction.assign(theAction.begin(),theAction.end());
uni[L"action"] = cpptempl::make_data(wTheAction);
//////UnitGoal//////
ss.str("");
if(Units[i]->Orders[0]->Goal != NULL)
ss << Units[i]->Orders[0]->Goal->Slot;
else
ss << "None";
std::string theGoal = ss.str();
std::wstring wTheGoal;
wTheGoal.assign(theGoal.begin(),theGoal.end());
uni[L"goal"] = cpptempl::make_data(wTheGoal);
///////NEW ORDER/////////
ss.str("");
switch(Units[i]->NewOrder.Action)
{
case UnitActionNone: ss << "UnitActionNone"; break;
case UnitActionStill: ss << "UnitActionStill"; break;
case UnitActionStandGround: ss << "UnitActionStandGround"; break;
case UnitActionFollow: ss << "UnitActionFollow"; break;
case UnitActionMove: ss << "UnitActionMove"; break;
case UnitActionAttack: ss << "UnitActionAttack"; break;
case UnitActionAttackGround: ss << "UnitActionAttackGround"; break;
case UnitActionDie: ss << "UnitActionDie"; break;
case UnitActionSpellCast: ss << "UnitActionSpellCast"; break;
case UnitActionTrain: ss << "UnitActionTrain"; break;
case UnitActionBuilt: ss << "UnitActionBuilt"; break;
case UnitActionBoard: ss << "UnitActionBoard"; break;
case UnitActionUnload: ss << "UnitActionUnload"; break;
case UnitActionPatrol: ss << "UnitActionPatrol"; break;
case UnitActionBuild: ss << "UnitActionBuild"; break;
case UnitActionRepair: ss << "UnitActionRepair"; break;
case UnitActionResource: ss << "UnitActionResource"; break;
default: ss << "None";
}
std::string theNewOrder = ss.str();
std::wstring wTheNewOrder;
wTheNewOrder.assign(theNewOrder.begin(),theNewOrder.end());
uni[L"neworder"] = cpptempl::make_data(wTheNewOrder);
//////NEW GOAL//////
ss.str("");
if(Units[i]->NewOrder.Goal != NULL)
ss << Units[i]->NewOrder.Goal->Slot;
else
ss << "None";
std::string theNewGoal = ss.str();
std::wstring wTheNewGoal;
wTheNewGoal.assign(theNewGoal.begin(),theNewGoal.end());
uni[L"newgoal"] = cpptempl::make_data(wTheNewGoal);
theUnits.push_back((cpptempl::make_data(uni)));
}
cpptempl::data_map lesUnits;
lesUnits[L"tabunits"] = cpptempl::make_data(theUnits);
// Now set this in the data map
cpptempl::data_map data;
data[L"units"] = cpptempl::make_data(lesUnits);
//////////////////TIMESTAMP/////////////////////////
std::clock_t t = std::clock() - firstClock;
double timeStamp = ((double)t/(double)CLOCKS_PER_SEC);
ss.str("");
ss << std::setprecision(8) << timeStamp;
std::string sTimeStamp = ss.str();
std::string gnuPlotStringT = ss.str();
std::wstring wTimeStamp;
wTimeStamp.assign(sTimeStamp.begin(),sTimeStamp.end());
data[L"timestamp"] = cpptempl::make_data(wTimeStamp);
///OVERHEAD/////
templateClock += std::clock()-littleClock;
long double overhead = (long double)templateClock / ((long double)std::clock()-(long double)firstClock)*(long double)100.0;
ss.str("");
ss << std::setprecision(10) << overhead;
std::string sOverhead = ss.str();
std::wstring wOverhead;
wOverhead.assign(sOverhead.begin(),sOverhead.end());
data[L"overhead"] = cpptempl::make_data(wOverhead);
std::cout << overhead << "% overhead\n";
//std::cout << std::clock() << " clocl\n";
/////////////////MESSAGENUMBER/////////////////////////<
ss.str("");
ss << messageNumber;
std::string gnuPlotStringN = ss.str();
std::string sMessageNumber = ss.str();
std::wstring wMessageNumber;
wMessageNumber.assign(sMessageNumber.begin(),sMessageNumber.end());
data[L"messagenumber"] = cpptempl::make_data(wMessageNumber);
std::wstring result = cpptempl::parse(templ, data);
ss.str("");
double templateTime = ((double)templateClock/(double)CLOCKS_PER_SEC)*(double)1000;
ss << std::setprecision(8) << templateTime;
std::string templTime = ss.str();
double totalT = ((std::clock()-firstClock)/(double)CLOCKS_PER_SEC);
std::cout << totalT << "totaltime\n";
std::cout << CYCLES_PER_SECOND << "cycles\n";
std::string s;
s.assign(result.begin(), result.end());
if (messageNumber == 1)
{
std::ofstream traceoutput;
traceoutput.open("/tmp/traceout.xml",std::ios::out);
traceoutput << s;
traceoutput.close();
}
messageNumber++;
/////STATS/////
output << s;
std::string out = gnuPlotStringN + "," + gnuPlotStringT + "\n";
outputEventsPerSec << out;
//OutputNT
//std::string theT;
out = "";
//ss.str("");
//ss << templTime;
//theT = ss.str();
out = templTime + "," + gnuPlotStringN + "\n";
outputNT << out;
}
/////////////////////////////////////////////////////////////////
}
TriggersEachCycle(); // handle triggers
UpdateMessages(); // update messages
ParticleManager.update(); // handle particles
CheckMusicFinished(); // Check for next song
//
// Map scrolling
//
DoScrollArea(MouseScrollState | KeyScrollState, (KeyModifiers & ModifierControl) != 0);
if (FastForwardCycle <= GameCycle || GameCycle <= 10 || !(GameCycle & 0x3f)) {
//FIXME: this might be better placed somewhere at front of the
// program, as we now still have a game on the background and
// need to go through the game-menu or supply a map file
UpdateDisplay();
//
// If double-buffered mode, we will display the contains of
// VideoMemory. If direct mode this does nothing. In X11 it does
// XFlush
//
RealizeVideoMemory();
}
if (FastForwardCycle <= GameCycle || !(GameCycle & 0x3f)) {
WaitEventsOneFrame();
}
if (!NetworkInSync) {
NetworkRecover(); // recover network
}
}
output.close();
outputNT.close();
outputEventsPerSec.close();
//
// Game over
//
NetworkQuit();
EndReplayLog();
CParticleManager::exit();
FlagRevealMap = 0;
ReplayRevealMap = 0;
GamePaused = false;
GodMode = false;
SetCallbacks(old_callbacks);
}
/**
** Play a video file.
**
** @param name Filename of movie file.
**
** @return Non-zero if file isn't a supported movie.
*/
int PlayMovie(const std::string &name)
{
int videoWidth, videoHeight;
#if defined(USE_OPENGL) || defined(USE_GLES)
videoWidth = Video.ViewportWidth;
videoHeight = Video.ViewportHeight;
#else
videoWidth = Video.Width;
videoHeight = Video.Height;
#endif
const std::string filename = LibraryFileName(name.c_str());
CFile f;
if (f.open(filename.c_str(), CL_OPEN_READ) == -1) {
fprintf(stderr, "Can't open file '%s'\n", name.c_str());
return 0;
}
OggData data;
memset(&data, 0, sizeof(data));
if (OggInit(&f, &data) || !data.video) {
OggFree(&data);
f.close();
return -1;
}
data.File = &f;
SDL_Rect rect;
if (data.tinfo.frame_width * 300 / 4 > data.tinfo.frame_height * 100) {
rect.w = videoWidth;
rect.h = videoWidth * data.tinfo.frame_height / data.tinfo.frame_width;
rect.x = 0;
rect.y = (videoHeight - rect.h) / 2;
} else {
rect.w = videoHeight * data.tinfo.frame_width / data.tinfo.frame_height;
rect.h = videoHeight;
rect.x = (videoWidth - rect.w) / 2;
rect.y = 0;
}
#ifdef USE_OPENGL
// When SDL_OPENGL is used, it is not possible to call SDL_CreateYUVOverlay, so turn temporary OpenGL off
// With GLES is all ok
if (UseOpenGL) {
SDL_SetVideoMode(Video.ViewportWidth, Video.ViewportHeight, Video.Depth, SDL_GetVideoSurface()->flags & ~SDL_OPENGL);
}
#endif
SDL_FillRect(SDL_GetVideoSurface(), NULL, 0);
Video.ClearScreen();
SDL_Overlay *yuv_overlay = SDL_CreateYUVOverlay(data.tinfo.frame_width, data.tinfo.frame_height, SDL_YV12_OVERLAY, TheScreen);
if (yuv_overlay == NULL) {
fprintf(stderr, "SDL_CreateYUVOverlay: %s\n", SDL_GetError());
OggFree(&data);
f.close();
return 0;
}
StopMusic();
CSample *sample = LoadVorbis(filename.c_str(), PlayAudioStream);
if (sample) {
if ((sample->Channels != 1 && sample->Channels != 2) || sample->SampleSize != 16) {
fprintf(stderr, "Unsupported sound format in movie\n");
delete sample;
SDL_FreeYUVOverlay(yuv_overlay);
OggFree(&data);
f.close();
return 0;
}
PlayMusic(sample);
}
EventCallback callbacks;
callbacks.ButtonPressed = MovieCallbackButtonPressed;
callbacks.ButtonReleased = MovieCallbackButtonReleased;
callbacks.MouseMoved = MovieCallbackMouseMove;
callbacks.MouseExit = MovieCallbackMouseExit;
callbacks.KeyPressed = MovieCallbackKeyPressed;
callbacks.KeyReleased = MovieCallbackKeyReleased;
callbacks.KeyRepeated = MovieCallbackKeyRepeated;
callbacks.NetworkEvent = NetworkEvent;
const EventCallback *old_callbacks = GetCallbacks();
SetCallbacks(&callbacks);
Invalidate();
RealizeVideoMemory();
MovieStop = false;
const unsigned int start_ticks = SDL_GetTicks();
bool need_data = true;
while (!MovieStop) {
if (need_data) {
if (TheoraProcessData(&data)) {
break;
}
need_data = false;
}
const int diff = SDL_GetTicks() - start_ticks
- static_cast<int>(theora_granule_time(&data.tstate, data.tstate.granulepos) * 1000);
if (diff > 100) {
// too far behind, skip some frames
need_data = true;
continue;
}
if (diff > 0) {
OutputTheora(&data, yuv_overlay, &rect);
need_data = true;
}
WaitEventsOneFrame();
}
StopMusic();
SDL_FreeYUVOverlay(yuv_overlay);
OggFree(&data);
f.close();
#ifdef USE_OPENGL
if (UseOpenGL) {
SDL_SetVideoMode(Video.ViewportWidth, Video.ViewportHeight, Video.Depth, SDL_GetVideoSurface()->flags | SDL_OPENGL);
ReloadOpenGL();
}
#endif
SetCallbacks(old_callbacks);
return 0;
}
/**
** Game main loop.
**
** Unit actions.
** Missile actions.
** Players (AI).
** Cyclic events (color cycle,...)
** Display update.
** Input/Network/Sound.
*/
void GameMainLoop(void)
{
#ifdef DEBUG // removes the setjmp warnings
static bool showtip;
#else
bool showtip;
#endif
int player;
int RealVideoSyncSpeed;
const EventCallback *old_callbacks;
InitGameCallbacks();
old_callbacks = GetCallbacks();
SetCallbacks(&GameCallbacks);
SetVideoSync();
GameCursor = UI.Point.Cursor;
GameRunning = true;
showtip = false;
RealVideoSyncSpeed = VideoSyncSpeed;
MultiPlayerReplayEachCycle();
// StratagusAI MOD
GamePaused = true;
// Minimap.Update();
while (GameRunning) {
// StratagusAI MOD
if ((GameCycle - socketInterface->lastPausedCycle) %
socketInterface->cyclesPerTransition == 0) {
socketInterface->handleInterface();
if (socketInterface->warpSpeed)
FastForwardCycle = GameCycle +
socketInterface->cyclesPerTransition + 1;
}
// Can't find a better place.
SaveGameLoading = 0;
//
// Game logic part
//
if (!GamePaused && NetworkInSync && !SkipGameCycle) {
SinglePlayerReplayEachCycle();
++GameCycle;
MultiPlayerReplayEachCycle();
NetworkCommands(); // Get network commands
UnitActions(); // handle units
MissileActions(); // handle missiles
PlayersEachCycle(); // handle players
UpdateTimer(); // update game timer
//
// Work todo each second.
// Split into different frames, to reduce cpu time.
// Increment mana of magic units.
// Update mini-map.
// Update map fog of war.
// Call AI.
// Check game goals.
// Check rescue of units.
//
switch (GameCycle % CYCLES_PER_SECOND) {
case 0: // At cycle 0, start all ai players...
if (GameCycle == 0) {
for (player = 0; player < NumPlayers; ++player) {
PlayersEachSecond(player);
}
}
break;
case 1:
break;
case 2:
break;
case 3: // minimap update
UI.Minimap.Update();
break;
case 4:
break;
case 5:
break;
case 6: // overtaking units
RescueUnits();
break;
default:
// FIXME: assume that NumPlayers < (CYCLES_PER_SECOND - 7)
player = (GameCycle % CYCLES_PER_SECOND) - 7;
Assert(player >= 0);
if (player < NumPlayers) {
PlayersEachSecond(player);
}
}
}
TriggersEachCycle(); // handle triggers
UpdateMessages(); // update messages
CheckMusicFinished(); // Check for next song
//
// Map scrolling
//
DoScrollArea(MouseScrollState | KeyScrollState, (KeyModifiers & ModifierControl) != 0);
if (FastForwardCycle > GameCycle &&
RealVideoSyncSpeed != VideoSyncSpeed) {
RealVideoSyncSpeed = VideoSyncSpeed;
VideoSyncSpeed = 3000;
}
// MOD
if (socketInterface->cyclesPerVideoUpdate != -1 &&
(GameCycle % socketInterface->cyclesPerVideoUpdate == 0 || GamePaused))
{
if (FastForwardCycle <= GameCycle || GameCycle <= 10 || !(GameCycle & 0x3f)) {
//FIXME: this might be better placed somewhere at front of the
// program, as we now still have a game on the background and
// need to go through the game-menu or supply a map file
UpdateDisplay();
//
// If double-buffered mode, we will display the contains of
// VideoMemory. If direct mode this does nothing. In X11 it does
// XFlush
//
RealizeVideoMemory();
}
}
if (FastForwardCycle == GameCycle) {
VideoSyncSpeed = RealVideoSyncSpeed;
}
if (FastForwardCycle <= GameCycle || !(GameCycle & 0x3f)) {
WaitEventsOneFrame();
}
if (!NetworkInSync) {
NetworkRecover(); // recover network
}
}
//
// Game over
//
if (FastForwardCycle > GameCycle) {
VideoSyncSpeed = RealVideoSyncSpeed;
}
NetworkQuit();
EndReplayLog();
FlagRevealMap = 0;
ReplayRevealMap = 0;
GamePaused = false;
GodMode = false;
SetCallbacks(old_callbacks);
}
static void DisplayLoop()
{
#if defined(USE_OPENGL) || defined(USE_GLES)
if (UseOpenGL) {
/* update only if screen changed */
ValidateOpenGLScreen();
}
#endif
/* update only if viewmode changed */
CheckViewportMode();
/*
* update only if Update flag is set
* FIXME: still not secure
*/
if (UI.Minimap.UpdateCache) {
UI.Minimap.Update();
UI.Minimap.UpdateCache = false;
}
//
// Map scrolling
//
DoScrollArea(MouseScrollState | KeyScrollState, (KeyModifiers & ModifierControl) != 0, MouseScrollState == 0 && KeyScrollState > 0);
ColorCycle();
//Wyrmgus start
//do tile animation
if (!GamePaused && GameCycle != 0 && GameCycle && GameCycle % (CYCLES_PER_SECOND / 4) == 0) { // same speed as color-cycling
for (size_t z = 0; z < Map.Fields.size(); ++z) {
for (int i = 0; i < Map.Info.MapWidths[z] * Map.Info.MapHeights[z]; ++i) {
CMapField &mf = Map.Fields[z][i];
if (mf.Terrain && mf.Terrain->SolidAnimationFrames > 0) {
mf.AnimationFrame += 1;
if (mf.AnimationFrame >= mf.Terrain->SolidAnimationFrames) {
mf.AnimationFrame = 0;
}
}
if (mf.OverlayTerrain && mf.Terrain->SolidAnimationFrames > 0) {
mf.OverlayAnimationFrame += 1;
if (mf.OverlayAnimationFrame >= mf.Terrain->SolidAnimationFrames) {
mf.OverlayAnimationFrame = 0;
}
}
}
}
}
//Wyrmgus end
#ifdef REALVIDEO
if (FastForwardCycle > GameCycle && RealVideoSyncSpeed != VideoSyncSpeed) {
RealVideoSyncSpeed = VideoSyncSpeed;
VideoSyncSpeed = 3000;
}
#endif
if (FastForwardCycle <= GameCycle || GameCycle <= 10 || !(GameCycle & 0x3f)) {
//FIXME: this might be better placed somewhere at front of the
// program, as we now still have a game on the background and
// need to go through the game-menu or supply a map file
UpdateDisplay();
//
// If double-buffered mode, we will display the contains of
// VideoMemory. If direct mode this does nothing. In X11 it does
// XFlush
//
RealizeVideoMemory();
}
#ifdef REALVIDEO
if (FastForwardCycle == GameCycle) {
VideoSyncSpeed = RealVideoSyncSpeed;
}
#endif
}
