No OneTemporary
Actions

Authored By

Unknown

Size

46 KB

Referenced Files

None

Subscribers

None

View Options

This document is not UTF8. It was detected as JIS and converted to UTF8 for display.

	diff --git a/src/Demo.cpp b/src/Demo.cpp
	index 8822a3e..c302fbb 100644
	--- a/src/Demo.cpp
	+++ b/src/Demo.cpp
	@@ -1,438 +1,451 @@
	/***************************************************************************
	Demo.cpp - description
	-------------------
	begin : Wed Aug 16 22:18:47 CEST 2003
	copyright : (C) 2003 by upi
	email : upi@apocalypse.rulez.org
	***************************************************************************/


	#include "FlyingChars.h"
	#include "SDL.h"


	#include "State.h"
	#include "gfx.h"
	#include "common.h"
	#include "Backend.h"
	#include "RlePack.h"
	#include "FighterStats.h" // #includes Demo.h
	#include "Event.h"
	#include "config.h"





	Demo::Demo()
	{
	m_poFlyingChars = NULL;
	m_bAdvanceGame = false;
	}


	Demo::~Demo()
	{
	delete m_poFlyingChars;
	m_poFlyingChars = NULL;
	}


	int Demo::Advance( int a_iNumFrames, bool a_bFlip )
	{
	int iRetVal = 1;

	if ( a_iNumFrames > 5 )
	a_iNumFrames = 5;

	if ( m_poBackground )
	{
	SDL_BlitSurface( m_poBackground, NULL, gamescreen, NULL );
	}

	if ( m_poFlyingChars )
	{
	iRetVal &= AdvanceFlyingChars( a_iNumFrames );
	m_poFlyingChars->Draw();
	}
	if ( m_bAdvanceGame )
	{
	iRetVal &= AdvanceGame( a_iNumFrames );
	//@ DRAW GAME?
	}

	if ( a_bFlip )
	{
	SDL_Flip( gamescreen );
	}

	return iRetVal;
	}


	int Demo::AdvanceFlyingChars( int a_iNumFrames )
	{
	m_poFlyingChars->Advance( a_iNumFrames );
	return ( m_poFlyingChars->IsDone() ? 1 : 0 );
	}




	int Demo::AdvanceGame( int a_iNumFrames )
	{
	for ( int i=0; i<a_iNumFrames; ++i )
	{
	g_oBackend.AdvancePerl();
	}
	return 0;
	}


	int Demo::Run()
	{
	SState::TGameMode enOriginalGameMode = g_oState.m_enGameMode;

	int thisTick, lastTick, firstTick, gameSpeed;
	gameSpeed = 12;

	/*
	if ( m_poBackground )
	{
	DrawTextMSZ( "Press Escape for the menu", impactFont, 10, 450, UseShadow, C_WHITE, m_poBackground );
	}
	*/

	thisTick = SDL_GetTicks() / gameSpeed;
	lastTick = thisTick - 1;
	firstTick = SDL_GetTicks() / gameSpeed;
	while ( 1 )
	{
	// 1. Wait for the next tick (on extremely fast machines..)
	while (1)
	{
	thisTick = SDL_GetTicks() / gameSpeed;
	if ( thisTick==lastTick )
	{
	SDL_Delay(1);
	}
	else
	{
	break;
	}
	}

	// 2. Call ADVANCE.

	int iRetVal = Advance(thisTick-lastTick, true);
	lastTick = thisTick;

	if ( iRetVal )
	{
	return 0;
	}

	// 3. Handle events.

	SMortalEvent oEvent;

	while ( MortalPollEvent(oEvent) )
	{
	switch (oEvent.m_enType)
	{
	case Me_QUIT:
	g_oState.m_bQuitFlag = true;
	break;

	case Me_MENU:
	- case Me_PLAYERKEYDOWN:
	OnMenu();
	break;
	+
	+ case Me_PLAYERKEYDOWN:
	+ if ( oEvent.m_iKey < 4 )
	+ break;
	+
	+ if ( SState::IN_DEMO == g_oState.m_enGameMode )
	+ {
	+ OnMenu();
	+ }
	+ else
	+ {
	+ return 0;
	+ }
	+ break;

	case Me_SKIP:
	return 0;

	case Me_NOTHING:
	case Me_PLAYERKEYUP:
	break;

	} // switch
	} // while MortalPollEvent

	if ( g_oState.m_enGameMode != enOriginalGameMode
	\|\| g_oState.m_bQuitFlag )
	{
	return 1;
	}

	} // while 1;
	}




	void Demo::OnMenu()
	{
	::DoMenu();
	}




	class CreditsDemo: public Demo
	{
	public:
	CreditsDemo()
	{
	m_poBackground = LoadBackground( "Credits.png", 240 );
	SDL_UnlockSurface( m_poBackground );
	DrawGradientText( "Credits", titleFont, 20, m_poBackground );
	SDL_Flip( m_poBackground );

	SDL_Rect oRect;
	oRect.x = 110; oRect.w = gamescreen->w - 220;
	oRect.y = 100; oRect.h = 350;

	m_poFlyingChars = new FlyingChars( creditsFont, oRect );

	m_sText1 = Translate( "CreditsText1" );
	m_sText2 = Translate( "CreditsText2" );
	m_sText3 = Translate( "CreditsText3" );

	m_poFlyingChars->AddText( m_sText1.c_str(), FlyingChars::FC_AlignCenter, true );
	m_poFlyingChars->AddText( m_sText2.c_str(), FlyingChars::FC_AlignJustify, true );
	m_poFlyingChars->AddText( m_sText3.c_str(), FlyingChars::FC_AlignCenter, true );

	m_poFlyingChars->AddText( "\n\n\n\n\n\n:)", FlyingChars::FC_AlignRight, true );
	}
	protected:
	std::string m_sText1;
	std::string m_sText2;
	std::string m_sText3;
	};



	class Story1Demo: public Demo
	{
	public:
	Story1Demo()
	{
	m_poBackground = LoadBackground( "Story1.png", 240 );
	SDL_UnlockSurface( m_poBackground );

	SDL_Rect oRect;
	oRect.x = 50; oRect.w = gamescreen->w - 100;
	oRect.y = 50; oRect.h = gamescreen->h - 100;

	m_poFlyingChars = new FlyingChars( storyFont, oRect, -1 );
	m_sText1 = Translate( "Story1Text" );
	m_poFlyingChars->AddText( m_sText1.c_str(), FlyingChars::FC_AlignJustify, true );
	}
	protected:
	std::string m_sText1;
	};


	class Story2Demo: public Demo
	{
	public:
	Story2Demo()
	{
	m_poBackground = LoadBackground( "Story2.png", 240 );
	SDL_UnlockSurface( m_poBackground );

	SDL_Rect oRect;
	oRect.x = 50; oRect.w = gamescreen->w - 100;
	oRect.y = 50; oRect.h = gamescreen->h - 100;

	m_poFlyingChars = new FlyingChars( storyFont, oRect, -1 );
	m_sText1 = Translate( "Story2Text" );
	m_poFlyingChars->AddText( m_sText1.c_str(), FlyingChars::FC_AlignJustify, true );
	}
	protected:
	std::string m_sText1;
	};



	class MainScreenDemo: public Demo
	{
	public:
	MainScreenDemo()
	{
	i = 0;
	m_iTimeLeft = 50;
	m_poBackground = LoadBackground( "Mortal.png", 240 );

	DrawTextMSZ( "Version " VERSION " ｩ 2003-2004 by UPi", inkFont, 320, 430, UseShadow \| AlignHCenter, C_WHITE, m_poBackground, false );

	std::string sStaffFilename = DATADIR;
	sStaffFilename += "/characters/STAFF.DAT";
	m_poPack = new RlePack( sStaffFilename.c_str(), 240 );
	m_poPack->ApplyPalette();
	SDL_BlitSurface( m_poBackground, NULL, gamescreen, NULL );
	SDL_Flip( gamescreen );

	int j, k, l;
	for ( j=0; j<14; ++j )
	{
	m_aiOrder[j] = j;
	m_bShown[j] = false;
	}
	for ( j=0; j<14; ++j )
	{
	k = rand() % 14;
	l = m_aiOrder[j]; m_aiOrder[j] = m_aiOrder[k]; m_aiOrder[k] = l;
	}
	}

	~MainScreenDemo()
	{
	delete m_poPack;
	m_poPack = NULL;
	}

	int Advance( int a_iNumFrames, bool a_bFlip )
	{
	static int x[14] = {
	0, 26, 67, 125, 159, 209,
	249, 289, 358, 397, 451, 489, 532, 161 };
	static int y[14] = {
	5, 4, 5, 5, 5, 7,
	4, 0, 7, 5, 5, 6, 5, 243 };

	m_iTimeLeft -= a_iNumFrames;

	if ( m_iTimeLeft <= 0
	&& i >= 14 )
	{
	return 1;
	}

	if ( m_iTimeLeft <= 0 )
	{
	m_bShown[ m_aiOrder[i] ] = true;
	for ( int j=0; j<=14; ++j )
	{
	if ( m_bShown[j] )
	{
	m_poPack->Draw( j, x[j], y[j], false );
	}
	}
	SDL_Flip( gamescreen );
	++i;
	m_iTimeLeft += 20;
	if ( i >= 14 )
	{
	m_iTimeLeft += 50;
	}
	}

	return 0;
	}

	protected:
	RlePack* m_poPack;
	int m_iTimeLeft;
	int i;
	int m_aiOrder[14];
	bool m_bShown[14];
	};




	void DoReplayDemo()
	{
	static int aiOrder[6] = {-1, -1, -1, -1, -1, -1};
	static int iNext = 0;

	if ( aiOrder[0]<0 )
	{
	// shuffle
	int i, j, k;
	for ( i=0; i<6; ++i ) aiOrder[i]=i;
	for ( i=0; i<6; ++i )
	{
	j = rand() % 6;
	k = aiOrder[i];
	aiOrder[i] = aiOrder[j];
	aiOrder[j] = k;
	}
	iNext = 0;
	}

	char acFilename[1024];
	sprintf( acFilename, DATADIR "/demo%d.om", aiOrder[iNext] );
	// DoGame( acFilename, true, false );

	iNext = ( iNext + 1 ) % 6;
	}



	static bool g_bFirstTime = true;


	void DoDemos()
	{
	#define DoDemos_BREAKONEND \
	if ( g_oState.m_enGameMode != SState::IN_DEMO \
	\|\| g_oState.m_bQuitFlag ) \
	return;

	if ( g_bFirstTime )
	{
	g_bFirstTime = false;
	}
	else
	{
	MainScreenDemo oDemo;
	oDemo.Run();
	}

	while (1)
	{
	DoDemos_BREAKONEND;
	DoReplayDemo();
	DoDemos_BREAKONEND;
	{
	Story1Demo oDemo;
	oDemo.Run();
	}
	DoDemos_BREAKONEND;
	DoReplayDemo();
	DoDemos_BREAKONEND;
	{
	FighterStatsDemo oDemo;
	oDemo.Run();
	}
	DoDemos_BREAKONEND;
	DoReplayDemo();
	DoDemos_BREAKONEND;
	{
	Story2Demo oDemo;
	oDemo.Run();
	}
	DoDemos_BREAKONEND;
	{
	FighterStatsDemo oDemo;
	oDemo.Run();
	}
	DoDemos_BREAKONEND;
	DoReplayDemo();
	DoDemos_BREAKONEND;
	{
	CreditsDemo oDemo;
	oDemo.Run();
	}
	DoDemos_BREAKONEND;
	{
	MainScreenDemo oDemo;
	oDemo.Run();
	}
	DoDemos_BREAKONEND;

	}
	}
	diff --git a/src/FighterStats.cpp b/src/FighterStats.cpp
	index 3ea9ec9..5b83a58 100644
	--- a/src/FighterStats.cpp
	+++ b/src/FighterStats.cpp
	@@ -1,255 +1,255 @@
	/***************************************************************************
	FighterStats.cpp - description
	-------------------
	begin : Tue Dec 10 2002
	copyright : (C) 2002 by upi
	email : upi@apocalypse.rulez.org
	***************************************************************************/

	#include <stdio.h>
	#include <string>

	#include "PlayerSelect.h"
	#include "FlyingChars.h"
	#include "SDL.h"
	#include "SDL_video.h"
	#include "SDL_image.h"
	#include "sge_tt_text.h"

	#include "common.h"
	#include "gfx.h"
	#include "RlePack.h"
	#include "Backend.h"
	#include "State.h"
	#include "FighterStats.h"

	#include "MszPerl.h"


	extern PerlInterpreter* my_perl;





	#define LEFTMARGIN 160
	#define TOPMARGIN 70
	#define RIGHTMARGIN 630
	#define LINEHEIGHT 35
	#define GAPWIDTH 20
	#define DESCMARGIN 50


	#define LEFTMARGIN2 ((LEFTMARGIN+RIGHTMARGIN+GAPWIDTH)/2)

	/*
	void DrawMultiLineText( const char* text, _sge_TTFont* font, int x, int y,
	int fg, SDL_Surface* target )
	{
	const char* s1, * s2;
	char line[1024];

	s1 = s2 = text;
	while (1)
	{
	while ( isspace(*s2) ) s2++;
	if ( !*s2 )
	break;

	s1 = s2; // s1: start of line.
	while ( (s2 != '\n') && s2 ) s2++;
	strncpy( line, s1, s2-s1 );
	line[s2-s1] = 0;
	DrawTextMSZ( line, font, x, y, 0, fg, target );
	y += sge_TTF_FontLineSkip( font );
	}
	}
	*/





	int FighterStatsDemo::mg_iLastFighter = -1;
	FighterEnum FighterStatsDemo::mg_aenFighterOrder[LASTFIGHTER-1];


	FighterStatsDemo::FighterStatsDemo( FighterEnum a_iFighter )
	{
	m_iTimeLeft = 500;
	m_poStaff = NULL;

	m_poBackground = LoadBackground( "FighterStats.png", 64 );
	DrawGradientText( "Fighter Stats", titleFont, 10, m_poBackground );

	SDL_BlitSurface( m_poBackground, NULL, gamescreen, NULL );
	SDL_Flip( gamescreen );

	if ( mg_iLastFighter < 0 )
	{
	// First run; create shuffled array of fighters.
	mg_iLastFighter = 0;

	int i, j;
	FighterEnum k;
	for ( i=0; i<LASTFIGHTER-1; ++i )
	{
	mg_aenFighterOrder[i] = (FighterEnum)(i+1);
	}
	for ( i=0; i<LASTFIGHTER-1; ++i )
	{
	j = rand() % (LASTFIGHTER-1);
	k = mg_aenFighterOrder[i];
	mg_aenFighterOrder[i] = mg_aenFighterOrder[j];
	mg_aenFighterOrder[j] = k;
	}
	}

	if ( a_iFighter <= UNKNOWN )
	{
	mg_iLastFighter = (mg_iLastFighter+1) % (LASTFIGHTER-1);
	m_enFighter = mg_aenFighterOrder[mg_iLastFighter];
	}
	else
	{
	m_enFighter = a_iFighter;
	}

	if ( g_oPlayerSelect.IsFighterAvailable( m_enFighter ) )
	{
	g_oPlayerSelect.SetPlayer( 0, m_enFighter );
	g_oBackend.PerlEvalF( "SelectStart();" );
	}
	else
	{
	std::string sStaffFilename = DATADIR;
	sStaffFilename += "/characters/STAFF.DAT";
	m_poStaff = new RlePack( sStaffFilename.c_str(), 240 );
	}

	g_oBackend.PerlEvalF("GetFighterStats(%d);", m_enFighter );
	_sge_TTFont* font = impactFont;
	int y = TOPMARGIN;


	AV *StatTags = get_av( "StatTags", FALSE );

	char s, sTag;

	s = SvPV_nolen(get_sv("Name", FALSE));
	DrawTextMSZ( s, inkFont, (LEFTMARGIN + RIGHTMARGIN)/2, y, AlignHCenter, C_WHITE, m_poBackground );
	y+= 10;

	s = SvPV_nolen(get_sv("Team", FALSE ));
	sTag = SvPV_nolen( *av_fetch( StatTags, 1, false ) );
	int i = DrawTextMSZ( sTag, font, LEFTMARGIN, y+=LINEHEIGHT, 0, C_YELLOW, m_poBackground );
	DrawTextMSZ( s, font, LEFTMARGIN+i, y, 0, C_ORANGE, m_poBackground, false );

	s = SvPV_nolen(get_sv("Style", FALSE ));
	sTag = SvPV_nolen( *av_fetch( StatTags, 2, false ) );
	i = DrawTextMSZ( sTag, font, LEFTMARGIN2, y, 0, C_YELLOW, m_poBackground );
	DrawTextMSZ( s, font, LEFTMARGIN2+i, y, 0, C_ORANGE, m_poBackground, false );

	s = SvPV_nolen(get_sv("Age", FALSE ));
	sTag = SvPV_nolen( *av_fetch( StatTags, 3, false ) );
	i = DrawTextMSZ( sTag, font, LEFTMARGIN, y+=LINEHEIGHT, 0, C_YELLOW, m_poBackground );
	DrawTextMSZ( s, font, LEFTMARGIN+i, y, 0, C_ORANGE, m_poBackground, false );

	s = SvPV_nolen(get_sv("Weight", FALSE ));
	sTag = SvPV_nolen( *av_fetch( StatTags, 4, false ) );
	i = DrawTextMSZ( sTag, font, LEFTMARGIN2, y, 0, C_YELLOW, m_poBackground );
	DrawTextMSZ( s, font, LEFTMARGIN2+i, y, 0, C_ORANGE, m_poBackground, false );

	s = SvPV_nolen(get_sv("Height", FALSE ));
	sTag = SvPV_nolen( *av_fetch( StatTags, 5, false ) );
	i = DrawTextMSZ( sTag, font, LEFTMARGIN, y+=LINEHEIGHT, 0, C_YELLOW, m_poBackground );
	DrawTextMSZ( s, font, LEFTMARGIN+i, y, 0, C_ORANGE, m_poBackground, false );

	s = SvPV_nolen(get_sv("Shoe", FALSE ));
	sTag = SvPV_nolen( *av_fetch( StatTags, 6, false ) );
	i = DrawTextMSZ( sTag, font, LEFTMARGIN2, y, 0, C_YELLOW, m_poBackground );
	DrawTextMSZ( s, font, LEFTMARGIN2+i, y, 0, C_ORANGE, m_poBackground, false );

	m_sStory = SvPV_nolen(get_sv("Story", FALSE ));
	SDL_Rect oFlyingRect;
	oFlyingRect.x = LEFTMARGIN;
	oFlyingRect.y = y+DESCMARGIN;
	oFlyingRect.w = gamescreen->w - oFlyingRect.x - 20;
	oFlyingRect.h = gamescreen->h - oFlyingRect.y - 10;
	m_poFlyingChars = new FlyingChars( creditsFont, oFlyingRect );
	m_poFlyingChars->AddText( m_sStory.c_str(), FlyingChars::FC_AlignJustify, false );

	if ( g_oPlayerSelect.IsFighterAvailable( m_enFighter ) )
	{
	m_sKeys = SvPV_nolen(get_sv("Keys", TRUE ));
	- m_poFlyingChars->AddText( "\nKEYS\n", FlyingChars::FC_AlignCenter, true );
	+ m_poFlyingChars->AddText( "\n\nKEYS\n", FlyingChars::FC_AlignCenter, true );
	m_poFlyingChars->AddText( m_sKeys.c_str(), FlyingChars::FC_AlignCenter, true );
	}
	else
	{
	m_sKeys = Translate("Unfortunately this fighter is not yet playable.");
	m_poFlyingChars->AddText( m_sKeys.c_str(), FlyingChars::FC_AlignLeft, true );
	}
	}



	FighterStatsDemo::~FighterStatsDemo()
	{
	delete m_poStaff;
	}



	int FighterStatsDemo::Advance( int a_iNumFrames, bool a_bFlip )
	{
	if ( a_iNumFrames > 5 ) a_iNumFrames = 5;

	if ( m_poFlyingChars->IsDone() )
	{
	m_iTimeLeft -= a_iNumFrames;
	}

	AdvanceFlyingChars( a_iNumFrames );
	SDL_BlitSurface( m_poBackground, NULL, gamescreen, NULL );
	m_poFlyingChars->Draw();

	// 2. Advance as many ticks as necessary..

	if ( g_oPlayerSelect.IsFighterAvailable( m_enFighter ) )
	{
	for (int i=0; i<a_iNumFrames; ++i )
	{
	g_oBackend.AdvancePerl();
	}
	int p1x = SvIV(get_sv("p1x", TRUE));
	int p1y = SvIV(get_sv("p1y", TRUE));
	int p1f = SvIV(get_sv("p1f", TRUE));
	if (p1f) g_oPlayerSelect.GetPlayerInfo(0).m_poPack->Draw( ABS(p1f)-1, p1x, p1y, p1f<0 );
	}
	else
	{
	static FighterEnum f[14] = {
	UPI, ZOLI, SURBA, ULMAR, MISI, BENCE,
	DESCANT, KINGA, GRIZLI, SIRPI, MACI, DANI, CUMI,
	AMBRUS };
	for ( int i=0; i<14; ++i )
	{
	if ( m_enFighter == f[i] )
	{
	//m_poStaff->draw( i, 10, 120 );
	break;
	}
	}
	}

	if ( SState::IN_DEMO != g_oState.m_enGameMode )
	{
	sge_BF_textout( gamescreen, fastFont, Translate("Press F1 to skip..."), 230, 450 );
	}

	SDL_Flip( gamescreen );

	return (m_iTimeLeft > 0) ? 0 : 1;
	}

	diff --git a/src/Game.cpp b/src/Game.cpp
	index efd289c..bce2d16 100644
	--- a/src/Game.cpp
	+++ b/src/Game.cpp
	@@ -1,1080 +1,1082 @@
	/***************************************************************************
	Game.cpp - description
	-------------------
	begin : Mon Sep 24 2001
	copyright : (C) 2001 by upi
	email : upi@apocalypse.rulez.org
	***************************************************************************/

	#include <string.h>
	#include <stdio.h>
	#include "SDL_image.h"
	#include "sge_surface.h"
	#include "sge_primitives.h"
	#include "sge_bm_text.h"
	#include "SDL_events.h"
	#include "SDL_keysym.h"
	#include <fstream>

	#include "Event.h"
	#include "PlayerSelect.h"
	#include "Background.h"
	#include "common.h"
	#include "gfx.h"
	#include "Backend.h"
	#include "RlePack.h"
	#include "State.h"
	#include "Game.h"
	#include "Audio.h"
	#include "MortalNetwork.h"


	#include "MszPerl.h"


	extern PerlInterpreter* my_perl;


	int Game::mg_iBackgroundNumber = 1;

	/*

	GAME PALETTE

	From To Num Desc
	---------------------------------------
	0 .. 63 64 Background
	64 .. 111 48 Doodads
	112 .. 175 64 1st Fighter
	176 .. 239 64 2nd Fighter
	240 .. 255 16 basic colors

	*/

	#define MAXFRAMESKIP 5



	/***************************************************************************
	SFpsCounter CLASS
	***************************************************************************/



	struct SFpsCounter
	{
	int m_iLastCheck; // Last second then Tick() was called
	int m_iFrames; // The number of frames in this second so far
	int m_iFps; // The number of frames in the last second

	void Reset()
	{
	m_iLastCheck = m_iFrames = m_iFps = 0;
	}

	void Tick()
	{
	int iSecond = SDL_GetTicks() / 1000;
	if ( iSecond > m_iLastCheck )
	{
	m_iLastCheck = iSecond;
	m_iFps = m_iFrames;
	m_iFrames = 0;
	// fprintf( stderr, "%d ", m_iFps);
	}
	++m_iFrames;
	}

	} oFpsCounter;




	/***************************************************************************
	CKeyQueue CLASS
	***************************************************************************/


	CKeyQueue::CKeyQueue()
	{
	Reset();
	}


	CKeyQueue::~CKeyQueue() {}


	void CKeyQueue::Reset()
	{
	m_oKeys.clear();
	}


	void CKeyQueue::EnqueueKey( int a_iAtTime, int a_iPlayer, int a_iKey, bool a_bDown )
	{
	debug( "EnqueueKey( %d, %d, %d, %d ) at %d\n", a_iAtTime, a_iPlayer, a_iKey, a_bDown, g_oBackend.m_iGameTick );
	SEnqueuedKey oKey;
	oKey.iTime = a_iAtTime;
	oKey.iPlayer = a_iPlayer;
	oKey.iKey = a_iKey;
	oKey.bDown = a_bDown;

	if ( m_oKeys.size() == 0 )
	{
	m_oKeys.push_front( oKey );
	return;
	}

	// Try to find the appropriate time in the list
	// We maintain the list so that it is sorted in a descending time
	// order. This means that usually we enqueue keys at the front and
	// dequeue them at the end, but sometimes a key is inserted in mid-queue.

	TEnqueuedKeyList::iterator it;
	for ( it=m_oKeys.begin(); it!=m_oKeys.end(); ++it )
	{
	if ( it->iTime <= a_iAtTime )
	{
	m_oKeys.insert( it, oKey );
	return;
	}
	}

	// a_iAtTime is smaller than any time in the queue, so it goes to the end.

	m_oKeys.push_back( oKey );
	}


	/**
	If
	*/
	void CKeyQueue::DequeueKeys( int a_iToTime )
	{
	while ( m_oKeys.size() > 0
	&& m_oKeys.back().iTime <= a_iToTime )
	{
	SEnqueuedKey& roKey = m_oKeys.back();
	debug( "Dequeued key at %d tick: %d time, %d player, %d key, %d down\n", a_iToTime, roKey.iTime, roKey.iPlayer, roKey.iKey, roKey.bDown );
	g_oBackend.PerlEvalF( roKey.bDown ? "KeyDown(%d,%d);" : "KeyUp(%d,%d);", roKey.iPlayer, roKey.iKey );
	m_oKeys.pop_back();
	}
	}




	/***************************************************************************
	GAME PUBLIC METHODS
	***************************************************************************/

	Game::Game( bool a_bIsReplay, bool a_bDebug)
	{
	m_bIsReplay = a_bIsReplay;
	m_bDebug = a_bDebug;
	m_enInitialGameMode = g_oState.m_enGameMode;

	if ( IsNetworkGame() )
	{
	mg_iBackgroundNumber = g_poNetwork->GetGameParams().iBackgroundNumber;
	}

	m_poBackground = new Background();
	m_poBackground->Load(mg_iBackgroundNumber++);
	if ( !m_poBackground->IsOK() )
	{
	m_poBackground->Load(1);
	mg_iBackgroundNumber = 1;
	}

	m_poDoodads = LoadBackground( "Doodads.png", 48, 64 );

	m_aiRoundsWonByPlayer[0] = m_aiRoundsWonByPlayer[1] = 0;
	m_iNumberOfRounds = 0;

	SDL_EnableUNICODE( 0 );
	m_iEnqueueDelay = 10;
	}


	Game::~Game()
	{
	delete m_poBackground;
	m_poBackground = NULL;
	SDL_FreeSurface( m_poDoodads );
	m_poDoodads = NULL;
	}


	/** Runs a whole game, with two or three rounds.

	\retval 0 if player 1 has won.
	\retval 1 if player 2 has won.
	\retval -1 if the game was a draw.
	*/
	int Game::Run()
	{
	do
	{
	m_sReplayString = "";
	m_aReplayOffsets.clear();
	DoOneRound();

	if ( g_oState.m_bQuitFlag
	\|\| m_enInitialGameMode != g_oState.m_enGameMode )
	{
	return -1;
	}
	} while ( m_aiRoundsWonByPlayer[0] < 2
	&& m_aiRoundsWonByPlayer[1] < 2
	&& m_iNumberOfRounds < 3 );

	if ( m_aiRoundsWonByPlayer[1] > m_aiRoundsWonByPlayer[0] ) return 1;
	if ( m_aiRoundsWonByPlayer[1] < m_aiRoundsWonByPlayer[0] ) return 0;
	return -1;
	}


	/** Returns the replay string of the last round.
	*/
	std::string& Game::GetReplay()
	{
	return m_sReplayString;
	}


	/***************************************************************************
	GAME DRAWING METHODS
	***************************************************************************/


	/** Draws the hitpoint bars that are displayed on the top of the screen.
	Also draws the fighter names below the bars.

	Input variables:
	\li g_oBackend.m_aoPlayers[x].m_iHitPoints
	\li g_oPlayerSelect.GetFighterName
	*/
	void Game::DrawHitPointDisplay()
	{
	int hp1 = g_oBackend.m_aoPlayers[0].m_iHitPoints;// * 100 / g_oState.m_iHitPoints;
	int hp2 = g_oBackend.m_aoPlayers[1].m_iHitPoints;// * 100 / g_oState.m_iHitPoints;
	SDL_Rect src, dst;

	src.y = 154;
	src.h = 20;
	dst.y = 15;

	// Player 1, green part.
	dst.x = 40;
	src.x = 0;
	src.w = hp1*2;
	SDL_BlitSurface( m_poDoodads, &src, gamescreen, &dst );

	// Player 1, red part.
	dst.x += hp1*2;
	src.x = (100 + hp1)*2;
	src.w = (100-hp1)*2;
	SDL_BlitSurface( m_poDoodads, &src, gamescreen, &dst );

	// Player 2, red part.
	dst.x = 400;
	src.x = 200;
	src.w = (100-hp2)*2;
	SDL_BlitSurface( m_poDoodads, &src, gamescreen, &dst );

	// Player 2, green part.
	dst.x = 400 + (100-hp2)*2;
	src.x = (100-hp2)*2;
	src.w = hp2*2;
	SDL_BlitSurface( m_poDoodads, &src, gamescreen, &dst );

	// "Won" icon for Player 1
	src.x = 0; src.y = 276; src.w = 32; src.h = 32;
	if ( m_aiRoundsWonByPlayer[0] > 0 )
	{
	dst.x = 4; dst.y = 11;
	SDL_BlitSurface( m_poDoodads, &src, gamescreen, &dst );
	}
	if ( m_aiRoundsWonByPlayer[1] > 0 )
	{
	dst.x = 604; dst.y = 11;
	SDL_BlitSurface( m_poDoodads, &src, gamescreen, &dst );
	}

	int iTextX = 230 - g_oPlayerSelect.GetFighterNameWidth(0);
	if ( iTextX < 5 ) iTextX = 5;
	sge_BF_textout( gamescreen, fastFont, g_oPlayerSelect.GetFighterName(0),
	iTextX, 38 );
	iTextX = g_oPlayerSelect.GetFighterNameWidth(1);
	iTextX = iTextX < (635-410) ? 410 : 635-iTextX;
	sge_BF_textout( gamescreen, fastFont, g_oPlayerSelect.GetFighterName(1),
	iTextX, 38 );
	}



	/** Draws the background, using the m_poBackground object.
	*/
	void Game::DrawBackground()
	{
	m_poBackground->Draw( g_oBackend.m_iBgX, g_oBackend.m_iBgY );
	}


	/** In debug mode, this method is used to draw the frame of the fighters.

	\param a_sName The name of the polygon (in the perl namespace)
	\param a_iColor The game color to draw the polygon with.
	*/
	void Game::DrawPoly( const char* a_pcName, int a_iColor )
	{
	AV *poList;
	int n;

	poList = get_av( a_pcName, FALSE );
	if ( poList == NULL )
	{
	return;
	}

	n = av_len( poList ) + 1;

	if ( n< 2 )
	{
	return;
	}

	for ( int i=0; i<n; i += 2 )
	{
	int j = (i+2) % n;

	int x1 = SvIV( *av_fetch( poList, i, false) );
	int y1 = SvIV( *av_fetch( poList, i+1, false) );
	int x2 = SvIV( *av_fetch( poList, j, false) );
	int y2 = SvIV( *av_fetch( poList, j+1, false) );

	sge_Line( gamescreen, x1, y1, x2, y2, a_iColor ) ;
	}
	}




	/** Draws every doodad that is currently defined in the backend.
	*/
	void Game::DrawDoodads()
	{
	for ( int i=0; i<g_oBackend.m_iNumDoodads; ++i )
	{
	Backend::SDoodad& roDoodad = g_oBackend.m_aoDoodads[i];
	if ( 0 == roDoodad.m_iType )
	{
	// Handle text doodads
	const char *s = roDoodad.m_sText.c_str();

	int iWidth = sge_BF_TextSize(fastFont, s).w;
	int iDoodadX = roDoodad.m_iX - iWidth/2;
	if ( iDoodadX + iWidth > 640 ) iDoodadX = 640 - iWidth;
	if ( iDoodadX < 0 ) iDoodadX = 0;
	int iDoodadY = roDoodad.m_iY;

	sge_BF_textout( gamescreen, fastFont, s, iDoodadX, iDoodadY );
	continue;
	}

	if ( roDoodad.m_iGfxOwner < 2 )
	{
	g_oPlayerSelect.GetPlayerInfo(roDoodad.m_iGfxOwner).m_poPack->Draw(
	roDoodad.m_iFrame, roDoodad.m_iX, roDoodad.m_iY, roDoodad.m_iDir < 1 );
	continue;
	}

	SDL_Rect rsrc, rdst;
	rdst.x = roDoodad.m_iX;
	rdst.y = roDoodad.m_iY;
	rsrc.x = 64 * roDoodad.m_iFrame;
	rsrc.y = 0;
	rsrc.w = 64;
	rsrc.h = 64;

	SDL_BlitSurface( m_poDoodads, &rsrc, gamescreen, &rdst );
	//debug( "Doodad x: %d, y: %d, t: %d, f: %d\n", dx, dy, dt, df );
	}
	}


	/** Draws the entire game screen:

	\li First, the background.
	\li The players.
	\li The debug wireframes (if debugging is turned on)
	\li The doodads.
	\li The hitpoint display.
	\li The gametime display.
	\li The FPS display.
	\li The "Round x" text during Ph_Start

	Input:
	\li m_enGamePhase
	\li g_oBackend.m_iGameTime
	\li m_iNumberOfRounds
	\li oFpsCounter
	*/
	void Game::Draw()
	{
	#define GROUNDZERO 440

	DrawBackground();

	// DRAW THE SHADOWS

	int i;

	for ( i=0; i<2; ++i )
	{
	Backend::SPlayer& roPlayer = g_oBackend.m_aoPlayers[i];
	int iFrame = roPlayer.m_iFrame;
	if ( iFrame == 0 )
	continue;

	RlePack* poPack = g_oPlayerSelect.GetPlayerInfo(i).m_poPack;
	int w = poPack->GetWidth( ABS(iFrame)-1 );
	int h = poPack->GetHeight( ABS(iFrame)-1 );

	h = GROUNDZERO - ( h + roPlayer.m_iY ); // Distance of feet from ground
	if ( h < 0 ) h = 0;
	if ( h > 500 ) h = 500;
	h = 500 - h;
	int h2 = 15 * h / 500;
	h = ( w / 2 ) * h / 500;

	sge_FilledEllipse( gamescreen,
	g_oBackend.m_aoPlayers[i].m_iX + w/2, GROUNDZERO,
	h, h2, C_BLACK );
	}

	for ( i=0; i<2; ++i )
	{
	Backend::SPlayer& roPlayer = g_oBackend.m_aoPlayers[i];
	int iFrame = roPlayer.m_iFrame;
	if ( iFrame == 0 )
	continue;

	RlePack* poPack = g_oPlayerSelect.GetPlayerInfo(i).m_poPack;
	poPack->Draw( ABS(iFrame)-1, roPlayer.m_iX, roPlayer.m_iY, iFrame<0 );
	}

	if ( m_bDebug )
	{
	DrawPoly( "p1head", C_LIGHTRED );
	DrawPoly( "p1body", C_LIGHTGREEN );
	DrawPoly( "p1legs", C_LIGHTBLUE );
	DrawPoly( "p1hit", C_YELLOW );
	DrawPoly( "p2head", C_LIGHTRED );
	DrawPoly( "p2body", C_LIGHTGREEN );
	DrawPoly( "p2legs", C_LIGHTBLUE );
	DrawPoly( "p2hit", C_YELLOW );
	}

	DrawDoodads();
	DrawHitPointDisplay();

	if ( Ph_NORMAL == m_enGamePhase )
	{
	char s[100];
	sprintf( s, "%d", m_iGameTime ); // m_iGameTime is maintained by DoGame
	DrawTextMSZ( s, inkFont, 320, 10, AlignHCenter, C_LIGHTCYAN, gamescreen, false );
	}
	else if ( Ph_START == m_enGamePhase )
	{
	char s[100];
	const char* format = Translate( "Round %d" );
	sprintf( s, format, m_iNumberOfRounds+1 );
	DrawTextMSZ( s, inkFont, 320, 200, AlignHCenter, C_WHITE, gamescreen, false );
	}
	else if ( Ph_REWIND == m_enGamePhase )
	{
	DrawTextMSZ( "REW", inkFont, 320, 10, AlignHCenter, C_WHITE, gamescreen );
	sge_BF_textout( gamescreen, fastFont, Translate("Press F1 to skip..."), 230, 450 );
	}
	else if ( Ph_SLOWFORWARD == m_enGamePhase )
	{
	DrawTextMSZ( "REPLAY", inkFont, 320, 10, AlignHCenter, C_WHITE, gamescreen );
	sge_BF_textout( gamescreen, fastFont, Translate("Press F1 to skip..."), 230, 450 );
	}
	else if ( Ph_REPLAY == m_enGamePhase )
	{
	DrawTextMSZ( "DEMO", inkFont, 320, 10, AlignHCenter, C_WHITE, gamescreen );
	}

	if ( oFpsCounter.m_iFps > 0 )
	{
	sge_BF_textoutf( gamescreen, fastFont, 2, 2, "%d fps", oFpsCounter.m_iFps );
	}

	SDL_Flip( gamescreen );
	}



	/***************************************************************************
	GAME PROTECTED METHODS
	***************************************************************************/



	bool Game::IsNetworkGame()
	{
	return SState::IN_NETWORK == g_oState.m_enGameMode;
	}


	/** Returns true if we control our own data, or false if the network supplies
	us with game data. */
	bool Game::IsMaster()
	{
	return !IsNetworkGame() \|\| g_poNetwork->IsMaster();
	}


	/**
	This method reads and updates the game's variables. In replay mode,
	this is done by parsing the replay string. Otherwise the perl
	backend is advanced the given number of steps.

	Whichever the case, the variables will be available in g_oBackend.

	Only the backend-driven variables are modified, the GamePhase and
	GameTime remain unchanged; these are up for DoOneRound and friends
	to modify.
	*/

	void Game::Advance( int a_iNumFrames )
	{
	if ( m_bIsReplay )
	{
	// Replay mode...

	m_iFrame += a_iNumFrames;
	if ( m_iFrame >= ((int)m_aReplayOffsets.size())-1 ) m_iFrame = m_aReplayOffsets.size() - 2;
	if ( m_iFrame <= 0 ) m_iFrame = 0;
	std::string sFrameDesc = m_sReplayString.substr(
	m_aReplayOffsets[m_iFrame],
	m_aReplayOffsets[m_iFrame+1] - m_aReplayOffsets[m_iFrame] );

	g_oBackend.ReadFromString( sFrameDesc );
	return;
	}

	static std::string sFrameDesc;
	int i;

	if ( IsNetworkGame() )
	{
	g_poNetwork->SendGameTick( g_oBackend.m_iGameTick );
	g_poNetwork->Update();

	int i = 0;

	while ( g_poNetwork->GetGameTick() + m_iEnqueueDelay < g_oBackend.m_iGameTick + a_iNumFrames )
	{
	++i;
	if ( i > 300 ) {
	// Waited for too long..
	g_poNetwork->Stop();
	}
	// The remote side is lagging behind.. Wait for it.
	SDL_Delay( 10 );
	g_poNetwork->Update();
	if ( m_enInitialGameMode != g_oState.m_enGameMode ) {
	return;
	}
	}

	int iTime;
	int iKey;
	bool bPressed;
	while ( g_poNetwork->GetKeystroke( iTime, iKey, bPressed ) )
	{
	debug( "Got GetKeystroke: %d, %d, %d at %d\n", iTime, iKey, bPressed, g_oBackend.m_iGameTick );
	// g_oBackend.PerlEvalF( bPressed ? "KeyDown(%d,%d);" : "KeyUp(%d,%d);", 1, iKey );
	m_oKeyQueue.EnqueueKey( iTime, IsMaster() ? 1 : 0, iKey, bPressed );
	if ( iTime <= g_oBackend.m_iGameTick )
	{
	debug( "KEY ARRIVED TOO LATE!!!\n" );
	}
	}
	}

	while ( a_iNumFrames > 0 )
	{
	-- a_iNumFrames;
	g_oBackend.AdvancePerl();
	g_oBackend.ReadFromPerl();
	g_oBackend.PlaySounds();
	m_oKeyQueue.DequeueKeys( g_oBackend.m_iGameTick );

	g_oBackend.WriteToString( sFrameDesc );
	m_sReplayString += sFrameDesc;
	m_sReplayString += '\n';
	m_aReplayOffsets.push_back( m_sReplayString.size() );
	}
	}



	/** A helper method of ProcessEvents; it manages keypresses and releases of
	players. It is only called when keypresses are actually relevant for the
	backend (not during instant replay, etc).
	*/

	void Game::HandleKey( int a_iPlayer, int a_iKey, bool a_bDown )
	{
	int iCurrentTick = g_oBackend.m_iGameTick + m_iEnqueueDelay;

	if ( IsNetworkGame() )
	{
	a_iPlayer = IsMaster() ? 0 : 1;

	g_poNetwork->SendKeystroke( iCurrentTick, a_iKey, a_bDown );
	}

	m_oKeyQueue.EnqueueKey( iCurrentTick, a_iPlayer, a_iKey, a_bDown );
	}


	/** ProcessEvents reads events from the SDL event system.

	Relevant key events are fed to the backend.
	Esc brings up the menu.

	Returns 1 on quit event (e.g. if the current game or replay should be aborted), 0 otherwise.
	*/

	int Game::ProcessEvents()
	{
	SMortalEvent oEvent;

	while (MortalPollEvent(oEvent))
	{
	switch (oEvent.m_enType)
	{
	case Me_QUIT:
	g_oState.m_bQuitFlag = true;
	return 1;

	case Me_MENU:
	if ( Ph_REWIND == m_enGamePhase
	\|\| Ph_SLOWFORWARD == m_enGamePhase )
	{
	// Menu counts as 'skip' during instant replay
	return 1;
	}

	if ( !IsNetworkGame() )
	{
	SState::TGameMode enMode = g_oState.m_enGameMode;
	::DoMenu();
	return g_oState.m_enGameMode == enMode ? 0 : 1;
	}
	+ break;

	case Me_SKIP:
	return 1;

	case Me_PLAYERKEYDOWN:
	case Me_PLAYERKEYUP:
	{
	if ( Ph_NORMAL != m_enGamePhase &&
	Ph_REPLAY != m_enGamePhase )
	break;

	HandleKey( oEvent.m_iPlayer, oEvent.m_iKey, Me_PLAYERKEYDOWN == oEvent.m_enType );
	+ break;
	}

	case Me_NOTHING:
	break;

	} // End of switch
	} // End of while polling events;

	return 0;
	}



	void Game::HurryUp()
	{
	Audio->PlaySample( "aroooga.voc" );
	DrawGradientText( "HURRY UP!", titleFont, 200, gamescreen );
	SDL_Delay( 1000 );
	Audio->PlaySample( "machine_start.voc" );
	}


	void Game::TimeUp()
	{
	DrawGradientText( "TIME IS UP!", titleFont, 200, gamescreen );
	SDL_Delay( 1000 );
	}


	/** This methods starts and runs the "instant replay" mode that is done
	at the end of a game round. This means doing phases Ph_REWIND and Ph_SLOWFORWARD.

	Rewind will go back in time 200 ticks before the parameter a_iKoAt.
	*/
	void Game::InstantReplay( int a_iKoAt )
	{
	int iCurrentFrame = m_aReplayOffsets.size() - 200;
	int iThisTick, iLastTick, iGameSpeed;

	m_enGamePhase = Ph_REWIND;
	iGameSpeed = 8;
	iThisTick = SDL_GetTicks() / iGameSpeed;
	iLastTick = iThisTick - 1;

	while ( iCurrentFrame < (int)m_aReplayOffsets.size() - 150 )
	{
	// 1. Wait for the next tick (on extremely fast machines..)
	while (iThisTick == iLastTick)
	{
	iThisTick = SDL_GetTicks() / iGameSpeed;
	if ( iThisTick==iLastTick ) SDL_Delay(1);
	}

	// 2. Advance as many ticks as necessary..

	int iNumTicks = iThisTick - iLastTick;
	if ( iNumTicks > 10 ) iNumTicks = 10;
	if ( iNumTicks < 0 ) iNumTicks = 0;
	iCurrentFrame += ( Ph_REWIND == m_enGamePhase ) ? -iNumTicks : +iNumTicks ;

	if ( Ph_REWIND == m_enGamePhase
	&& ( iCurrentFrame < a_iKoAt - 200 \|\| iCurrentFrame <= 0 )
	)
	{
	m_enGamePhase = Ph_SLOWFORWARD;
	iGameSpeed = 16;
	SDL_Delay(500);
	}
	iLastTick = iThisTick;
	if ( iCurrentFrame < 0 ) iCurrentFrame = 0;

	m_iFrame = iCurrentFrame;
	if ( m_iFrame >= ((int)m_aReplayOffsets.size())-1 ) m_iFrame = m_aReplayOffsets.size() - 2;
	if ( m_iFrame <= 0 ) m_iFrame = 0;
	std::string sFrameDesc = m_sReplayString.substr(
	m_aReplayOffsets[m_iFrame],
	m_aReplayOffsets[m_iFrame+1] - m_aReplayOffsets[m_iFrame] );

	//debug( "PB: Frame %d ofs %d-%d; data: '%s'\n", m_iFrame,
	// m_aReplayOffsets[m_iFrame], m_aReplayOffsets[m_iFrame+1], sFrameDesc.c_str() );

	g_oBackend.ReadFromString( sFrameDesc );

	if ( ProcessEvents() )
	{
	break;
	}
	oFpsCounter.Tick();

	// 3. Draw the next game screen..

	Draw();

	if ( g_oState.m_bQuitFlag
	\|\| SState::IN_DEMO == g_oState.m_enGameMode )
	{
	break;
	}
	}

	}


	/** This methods executes one round of gameplay.

	The game progresses through phases Ph_START, Ph_NORMAL, and
	Ph_KO. If a KO happened, it will invoke InstantReplay. At the end of
	the round m_aiRoundsWonByPlayer[x] will be incremented depending on the
	outcome. m_iNumberOfRounds will also increase by 1.
	*/
	void Game::DoOneRound()
	{
	m_enGamePhase = Ph_START;

	g_oBackend.PerlEvalF( "GameStart(%d,%d);",
	IsMaster() ? g_oState.m_iHitPoints : g_poNetwork->GetGameParams().iHitPoints,
	m_bDebug );
	g_oBackend.ReadFromPerl();

	if ( IsNetworkGame() )
	{
	g_poNetwork->SynchStartRound();
	g_poNetwork->SendGameTick( g_oBackend.m_iGameTick-1 );
	}

	int iKoFrame = -1;
	double dGameTime = 2 * 1000; // Only for the "greeting phase", the real gametime will be set after.
	int iThisTick, iLastTick, iGameSpeed;
	bool bHurryUp = false;
	bool bReplayAfter = true;

	iGameSpeed = IsMaster() ? g_oState.m_iGameSpeed : g_poNetwork->GetGameParams().iGameSpeed;
	iThisTick = SDL_GetTicks() / iGameSpeed;
	iLastTick = iThisTick - 1;
	m_oKeyQueue.Reset();

	oFpsCounter.Reset();

	// 1. DO THE NORMAL GAME ROUND (START, NORMAL, KO, TIMEUP)

	while ( dGameTime >= 0 )
	{
	if ( m_enInitialGameMode != g_oState.m_enGameMode )
	{
	return;
	}

	// 1. Wait for the next tick (on extremely fast machines..)
	while (iThisTick == iLastTick)
	{
	iThisTick = SDL_GetTicks() / iGameSpeed;
	if ( iThisTick==iLastTick ) SDL_Delay(1);
	}

	// 2. Advance as many ticks as necessary..

	int iNumTicks = iThisTick - iLastTick;
	if ( iNumTicks > MAXFRAMESKIP ) iNumTicks = MAXFRAMESKIP;
	Advance( iNumTicks );
	dGameTime -= iNumTicks * iGameSpeed;

	// 3. Check for state transitions and game time.
	// START -> NORMAL
	// NORMAL -> KO
	// NORMAL -> TIMEUP
	// bHurryUp flag can be set during NORMAL phase

	if ( Ph_START == m_enGamePhase ) // Check for the end of the START phase
	{
	if ( dGameTime <= 0 )
	{
	m_enGamePhase = Ph_NORMAL;
	dGameTime = (IsMaster() ? g_oState.m_iGameTime : g_poNetwork->GetGameParams().iGameTime) * 1000;
	}
	}
	else if ( Ph_NORMAL == m_enGamePhase ) // Check for the end of the NORMAL phase
	{
	if ( dGameTime < 10 * 1000
	&& !bHurryUp )
	{
	bHurryUp = true;
	g_poNetwork->SendHurryup( 1 );
	HurryUp();
	iGameSpeed = iGameSpeed * 3 / 4;
	}
	if ( g_oBackend.m_bKO )
	{
	m_enGamePhase = Ph_KO;
	dGameTime = 10 * 1000;
	iKoFrame = m_aReplayOffsets.size();
	}
	else if ( dGameTime <= 0 )
	{
	m_enGamePhase = Ph_TIMEUP;
	g_poNetwork->SendHurryup( 2 );
	TimeUp();
	break;
	}
	}

	m_iGameTime = (int) ((dGameTime + 500.0) / 1000.0);

	iLastTick = iThisTick;

	// ProcessEvents will read keyboard/gamepad input
	// It will also transmit them to the remote side in a network game.

	if ( ProcessEvents() \|\| g_oState.m_bQuitFlag )
	{
	bReplayAfter = false;
	break;
	}

	oFpsCounter.Tick();

	// 3. Draw the next game screen..

	Draw();

	// 4. Check 'end of round' condition.

	if ( !IsMaster() )
	{
	if ( g_poNetwork->IsRoundOver() )
	{
	break;
	}
	}
	else if ( g_oBackend.m_iGameOver )
	{
	break;
	}
	}

	int p1h = g_oBackend.m_aoPlayers[0].m_iHitPoints;
	int p2h = g_oBackend.m_aoPlayers[1].m_iHitPoints;

	// 3. DO THE REPLAY (IF THERE WAS A KO)

	if ( iKoFrame>0 && bReplayAfter && !IsNetworkGame() )
	{
	InstantReplay( iKoFrame );
	}

	// 4. END OF ROUND

	debug( "Game over; p1h = %d; p2h = %d\n", p1h, p2h );

	if ( IsMaster() )
	{
	int iWhoWon = -1;
	if ( p1h > p2h ) { ++m_aiRoundsWonByPlayer[0]; iWhoWon = 0; }
	if ( p2h > p1h ) { ++m_aiRoundsWonByPlayer[1]; iWhoWon = 1; }

	if ( IsNetworkGame() )
	{
	g_poNetwork->SendGameTick( g_oBackend.m_iGameTick + m_iEnqueueDelay * 100 );
	g_poNetwork->SendRoundOver( iWhoWon, m_iNumberOfRounds > 0 );
	}
	}
	else
	{
	int iWhoWon = g_poNetwork->GetWhoWon();
	if ( iWhoWon>=0 )
	{
	++m_aiRoundsWonByPlayer[iWhoWon];
	}
	}

	++m_iNumberOfRounds;
	}



	void Game::DoReplay( const char* a_pcReplayFile )
	{
	std::ifstream oInput( a_pcReplayFile );
	int iPlayer1, iPlayer2;
	oInput >> iPlayer1 >> iPlayer2;

	std::string sLine;
	std::getline( oInput, sLine );
	g_oPlayerSelect.SetPlayer( 0, (FighterEnum) iPlayer1 );
	g_oPlayerSelect.SetPlayer( 1, (FighterEnum) iPlayer2 );

	int iThisTick, iLastTick, iGameSpeed;

	m_enGamePhase = Ph_REPLAY;
	iGameSpeed = 12;
	iThisTick = SDL_GetTicks() / iGameSpeed;
	iLastTick = iThisTick - 1;

	while ( !oInput.eof() )
	{
	// 1. Wait for the next tick (on extremely fast machines..)
	while (iThisTick == iLastTick)
	{
	iThisTick = SDL_GetTicks() / iGameSpeed;
	if ( iThisTick==iLastTick ) SDL_Delay(1);
	}

	// 2. Advance as many ticks as necessary..

	int iNumTicks = iThisTick - iLastTick;
	if ( iNumTicks > 5 ) iNumTicks = 5;

	for ( int i=0; i< iNumTicks; ++i )
	{
	std::getline( oInput, sLine );
	}
	if ( 0 == sLine.size() )
	{
	break;
	}

	iLastTick = iThisTick;

	g_oBackend.ReadFromString( sLine );

	if ( ProcessEvents() )
	{
	break;
	}
	oFpsCounter.Tick();

	// 3. Draw the next game screen..

	Draw();

	if ( g_oState.m_bQuitFlag )
	{
	break;
	}
	}
	}



	int Game::GetBackgroundNumber() //static
	{
	return mg_iBackgroundNumber;
	}




	/** Public static function.

	Other parts of OpenMortal need not include "Game.h" so long as they have
	the definition of this method (defined in "common.h"). The method runs
	a cycle of the game (either a normal game, or replay).

	In replay mode, DoReplay() is called, and the replay file is required.
	In normal mode, Run() is called. The replay file is recorded, if it is not NULL.
	*/

	int DoGame( char* a_pcReplayFile, bool a_bIsReplay, bool a_bDebug )
	{
	Game oGame( a_bIsReplay, a_bDebug );

	if ( a_bIsReplay )
	{
	if ( NULL == a_pcReplayFile )
	{
	return 0;
	}
	oGame.DoReplay( a_pcReplayFile );
	return 0;
	}
	else
	{
	int iRetval = oGame.Run();
	if ( NULL != a_pcReplayFile )
	{
	std::ofstream oOutput( a_pcReplayFile );
	oOutput <<
	g_oPlayerSelect.GetPlayerInfo(0).m_enFighter << ' ' <<
	g_oPlayerSelect.GetPlayerInfo(1).m_enFighter << '\n' << oGame.GetReplay();
	}
	return iRetval;
	}
	}


	int GetBackgroundNumber()
	{
	return Game::GetBackgroundNumber();
	}
	diff --git a/src/Joystick.cpp b/src/Joystick.cpp
	index ca30805..5df6f3f 100644
	--- a/src/Joystick.cpp
	+++ b/src/Joystick.cpp
	@@ -1,255 +1,256 @@
	/***************************************************************************
	Joystick.cpp - description
	-------------------
	begin : Sat Feb 14 2004
	copyright : (C) 2004 by upi
	email : upi@feel
	***************************************************************************/


	#include "SDL/SDL.h"
	#include "Event.h"
	#include "common.h"
	#include "Joystick.h"

	#include <string.h>

	CJoystick g_oJoystick;



	CJoystick::CJoystick()
	{
	m_iNumJoysticks = 0;
	}


	CJoystick::~CJoystick()
	{
	}


	int InitJoystick()
	{
	return g_oJoystick.Init();
	}



	int CJoystick::Init()
	{
	m_iNumJoysticks = 0;
	int iResult = SDL_InitSubSystem(SDL_INIT_JOYSTICK);

	if ( iResult < 0 )
	{
	debug( "CJoystick::Init() failed: %s\n", SDL_GetError() );
	return 0;
	}

	int iNumJoysticks = SDL_NumJoysticks();
	debug( "CJoystick::Init(): Number of joysticks is %d\n", iNumJoysticks );

	int i;
	for ( i=0; i<iNumJoysticks; ++i )
	{
	const char* poName = SDL_JoystickName(i);
	debug( "CJoystick::Init(): Joystick #%d is '%s'\n", i, poName );

	SDL_Joystick* poJoystick = SDL_JoystickOpen(i);
	if ( NULL == poJoystick )
	{
	continue;
	}

	m_apoJoysticks[m_iNumJoysticks] = poJoystick;
	m_apcJoystickNames[m_iNumJoysticks] = poName;
	m_abWorkaround[m_iNumJoysticks] = false;
	m_aiHorizontalAxis[m_iNumJoysticks] = 0;
	m_aiVerticalAxis[m_iNumJoysticks] = 0;

	debug( "CJoystick::Init(): Joystick #%d has %d axes, %d buttons, %d balls, %d hats\n",
	+ i,
	SDL_JoystickNumAxes( poJoystick ),
	SDL_JoystickNumButtons( poJoystick ),
	SDL_JoystickNumBalls( poJoystick ),
	SDL_JoystickNumHats( poJoystick ) );

	if ( strstr( poName, "SIGHT FIGHTER ACTION USB" ) )
	{
	m_abWorkaround[m_iNumJoysticks] = true;
	debug( "CJoystick::Init(): Infuriatingly stupid joystick detected.\n" );
	}
	++m_iNumJoysticks;
	}

	if ( m_iNumJoysticks )
	{
	SDL_JoystickEventState( SDL_ENABLE );
	}

	return m_iNumJoysticks;
	}



	const char* CJoystick::GetJoystickName( int a_iJoystickNumber )
	{
	if ( a_iJoystickNumber >= m_iNumJoysticks
	\|\| a_iJoystickNumber < 0 )
	{
	return NULL;
	}

	return m_apcJoystickNames[a_iJoystickNumber];
	}



	bool CJoystick::TranslateEvent( const SDL_Event* a_poInEvent, SMortalEvent* a_poOutEvent )
	{
	a_poOutEvent->m_enType = Me_NOTHING;

	switch ( a_poInEvent->type )
	{
	case SDL_JOYAXISMOTION:
	{
	int iJoyNumber = a_poInEvent->jaxis.which;
	int iAxisNumber = a_poInEvent->jaxis.axis;
	int iValue = a_poInEvent->jaxis.value;

	if ( iAxisNumber > 1 )
	{
	// Only translate axis 0 and 1.
	return false;
	}

	if ( m_abWorkaround[iJoyNumber] )
	{
	iValue = AxisWorkaround( a_poInEvent->jaxis );
	debug( "Translated %d to %d\n", a_poInEvent->jaxis.value, iValue );
	}

	// Try the new value into motion.
	int& riOldValue = iAxisNumber ? m_aiVerticalAxis[iJoyNumber] : m_aiHorizontalAxis[iJoyNumber];

	if ( -1 == riOldValue )
	{
	if ( iValue < -3200 )
	{
	return false;
	}
	riOldValue = 0;
	a_poOutEvent->m_enType = Me_PLAYERKEYUP;
	a_poOutEvent->m_iPlayer = iJoyNumber;
	a_poOutEvent->m_iKey = iAxisNumber ? Mk_UP : Mk_LEFT;
	return true;
	}

	if ( 0 == riOldValue )
	{
	if ( iValue < -6400 )
	{
	riOldValue = -1;
	a_poOutEvent->m_enType = Me_PLAYERKEYDOWN;
	a_poOutEvent->m_iPlayer = iJoyNumber;
	a_poOutEvent->m_iKey = iAxisNumber ? Mk_UP : Mk_LEFT;
	return true;
	}
	if ( iValue > 6400 )
	{
	riOldValue = 1;
	a_poOutEvent->m_enType = Me_PLAYERKEYDOWN;
	a_poOutEvent->m_iPlayer = iJoyNumber;
	a_poOutEvent->m_iKey = iAxisNumber ? Mk_DOWN : Mk_RIGHT;
	return true;
	}
	return false;
	}
	if ( 1 == riOldValue )
	{
	if ( iValue > 3200 )
	{
	return false;
	}
	riOldValue = 0;
	a_poOutEvent->m_enType = Me_PLAYERKEYUP;
	a_poOutEvent->m_iPlayer = iJoyNumber;
	a_poOutEvent->m_iKey = iAxisNumber ? Mk_DOWN : Mk_RIGHT;
	return true;
	}

	riOldValue = 0;
	return false;
	}

	case SDL_JOYBUTTONDOWN:
	case SDL_JOYBUTTONUP:
	{
	int iJoyNumber = a_poInEvent->jbutton.which;
	int iButton = a_poInEvent->jbutton.button;
	int iPressed = a_poInEvent->jbutton.state == SDL_PRESSED;

	debug( "Button down: joy %d, button %d, state %d\n", iJoyNumber, iButton, iPressed );

	if ( iButton > 4 )
	{
	if ( iButton == SDL_JoystickNumButtons(m_apoJoysticks[iJoyNumber]) - 1
	&& iPressed )
	{
	a_poOutEvent->m_enType = Me_MENU;
	return true;
	}
	return false;
	}

	if ( iJoyNumber > 1 )
	{
	return false;
	}

	a_poOutEvent->m_enType = iPressed ? Me_PLAYERKEYDOWN : Me_PLAYERKEYUP;
	a_poOutEvent->m_iPlayer = iJoyNumber;
	a_poOutEvent->m_iKey = iButton + 4;

	return true;
	}

	case SDL_JOYBALLMOTION:
	if( a_poInEvent->jball.ball == 0 )
	{
	// Nothing for now.
	}
	break;

	case SDL_JOYHATMOTION:
	if ( a_poInEvent->jhat.hat & SDL_HAT_UP )
	{
	// Nothing for now.
	}
	if ( a_poInEvent->jhat.hat & SDL_HAT_LEFT )
	{
	// Nothing for now.
	}
	if ( a_poInEvent->jhat.hat & SDL_HAT_RIGHTDOWN )
	{
	// Nothing for now.
	}
	break;

	} // end of switch statement

	return false;
	}


	int CJoystick::AxisWorkaround( const SDL_JoyAxisEvent& a_roEvent )
	{
	if ( 0 == a_roEvent.value ) return -32768;
	if ( 127 == a_roEvent.value ) return 0;
	if ( -1 == a_roEvent.value ) return 32768;

	return 0;
	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 15, 8:10 PM (1 d, 10 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 151399
Default Alt Text: (46 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions