No OneTemporary
Actions

Size

42 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/Game.cpp b/src/Game.cpp
	index 4a932c3..8c2346d 100644
	--- a/src/Game.cpp
	+++ b/src/Game.cpp
	@@ -1,775 +1,785 @@
	/***************************************************************************
	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 "PlayerSelect.h"
	#include "common.h"
	#include "gfx.h"
	#include "Backend.h"
	#include "RlePack.h"
	#include "State.h"
	#include "Game.h"
	#include "Audio.h"


	#include <EXTERN.h>
	#include <perl.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



	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;








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

	Game::Game( bool a_bIsReplay, bool a_bDebug)
	{
	m_bIsReplay = a_bIsReplay;
	m_bDebug = a_bDebug;

	- m_poBackground = LoadBackground( "level1.png", 64 );
	+ char acFilename[1024];
	+ sprintf( acFilename, "level%d.png", mg_iBackgroundNumber++ );
	+ m_poBackground = LoadBackground( acFilename, 64 );
	+ if ( NULL == m_poBackground )
	+ {
	+ mg_iBackgroundNumber = 1;
	+ m_poBackground = LoadBackground( "level1.png", 64 );
	+ }
	+
	m_poDoodads = LoadBackground( "Doodads.png", 48, 64 );

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


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


	int Game::Run()
	{
	do
	{
	m_sReplayString.clear();
	m_aReplayOffsets.clear();
	DoOneRound();

	if ( g_oState.m_bQuitFlag
	\|\| SState::IN_DEMO == 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;
	}


	std::string& Game::GetReplay()
	{
	return m_sReplayString;
	}


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


	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 );
	}

	sge_BF_textout( gamescreen, fastFont, g_oPlayerSelect.GetFighterName(0),
	230 - g_oPlayerSelect.GetFighterNameWidth(0), 38 );
	sge_BF_textout( gamescreen, fastFont, g_oPlayerSelect.GetFighterName(1),
	410, 38 );
	}



	void Game::DrawBackground()
	{
	sge_Blit( m_poBackground, gamescreen,
	g_oBackend.m_iBgX, g_oBackend.m_iBgY,
	0, 0, SCREENWIDTH, SCREENHEIGHT );
	}



	void Game::DrawPoly( const char* sName, int color )
	{
	AV *iList;
	int n;

	iList = get_av( sName, FALSE );
	if ( iList == NULL )
	{
	return;
	}

	n = av_len( iList ) + 1;

	if ( n< 2 )
	{
	return;
	}

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

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

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




	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 );
	}
	}


	void Game::Draw()
	{
	DrawBackground();

	for ( int i=0; i<2; ++i )
	{
	int iFrame = g_oBackend.m_aoPlayers[i].m_iFrame;
	if ( 0 != iFrame )
	{
	g_oPlayerSelect.GetPlayerInfo(i).m_poPack->Draw(
	ABS(iFrame)-1,
	g_oBackend.m_aoPlayers[i].m_iX,
	g_oBackend.m_aoPlayers[i].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", g_oBackend.m_iGameTime );
	DrawTextMSZ( s, inkFont, 320, 10, AlignHCenter, C_LIGHTCYAN, gamescreen );
	}
	else if ( Ph_START == m_enGamePhase )
	{
	char s[100];
	sprintf( s, "Round %d", m_iNumberOfRounds+1 );
	DrawTextMSZ( s, inkFont, 320, 200, AlignHCenter, C_WHITE, gamescreen );
	}
	else if ( Ph_REWIND == m_enGamePhase )
	{
	DrawTextMSZ( "REW", inkFont, 320, 10, AlignHCenter, C_WHITE, gamescreen );
	sge_BF_textout( gamescreen, fastFont, "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, "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
	***************************************************************************/



	/**
	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.
	*/

	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;
	}

	while ( a_iNumFrames > 0 )
	{
	-- a_iNumFrames;
	std::string sFrameDesc;
	g_oBackend.AdvancePerl();
	g_oBackend.ReadFromPerl();
	g_oBackend.PlaySounds();

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



	/** 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()
	{
	SDL_Event event;
	while (SDL_PollEvent(&event))
	{
	switch (event.type)
	{
	case SDL_QUIT:
	g_oState.m_bQuitFlag = true;
	return 1;

	case SDL_KEYDOWN:
	{
	if ( event.key.keysym.sym == SDLK_ESCAPE )
	{
	SState::TGameMode enMode = g_oState.m_enGameMode;
	::DoMenu( true );
	return g_oState.m_enGameMode == enMode ? 0 : 1;
	}
	if ( event.key.keysym.sym == SDLK_F1 )
	{
	// shortcut: abort the current round. This shall is here
	// to ease testing, and will be removed from the final
	// version.
	return 1;
	}

	if ( Ph_NORMAL != m_enGamePhase &&
	Ph_REPLAY != m_enGamePhase )
	break;

	for (int i=0; i<2; i++)
	{
	for (int j=0; j<9; j++ )
	{
	if (g_oState.m_aiPlayerKeys[i][j] == event.key.keysym.sym)
	{
	if (g_oState.m_enGameMode == SState::IN_DEMO)
	{
	g_oState.m_enGameMode = SState::IN_MULTI;
	return 1;
	}

	g_oBackend.PerlEvalF( "KeyDown(%d,%d);", i, j );
	return 0;
	}
	}
	}

	break;
	}

	case SDL_KEYUP:
	{
	if ( Ph_NORMAL != m_enGamePhase )
	break;

	for (int i=0; i<2; i++)
	{
	for (int j=0; j<9; j++ )
	{
	if (g_oState.m_aiPlayerKeys[i][j] == event.key.keysym.sym)
	{
	g_oBackend.PerlEvalF( "KeyUp(%d,%d);", i, j );
	return 0;
	}
	}
	}
	break;
	}
	} // End of switch
	} // End of while SDL_PollEvent;

	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 );
	}


	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;
	}
	}

	}


	void Game::DoOneRound()
	{
	m_enGamePhase = Ph_START;

	g_oBackend.PerlEvalF( "GameStart(%d,%d);", g_oState.m_iHitPoints, m_bDebug );

	int iKoFrame = -1;
	- double dGameTime = 2 * 1000;
	+ 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 = 12;
	+ iGameSpeed = g_oState.m_iGameSpeed;
	iThisTick = SDL_GetTicks() / iGameSpeed;
	iLastTick = iThisTick - 1;

	oFpsCounter.Reset();

	// 1. DO THE NORMAL GAME ROUND and HURRYUP

	- while ( dGameTime > 0 )
	+ while ( dGameTime >= 0 )
	{

	// 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;

	if ( Ph_START == m_enGamePhase )
	{
	- if ( dGameTime < 0 )
	+ if ( dGameTime <= 0 )
	{
	m_enGamePhase = Ph_NORMAL;
	dGameTime = g_oState.m_iGameTime * 1000;
	}
	}
	else if ( Ph_NORMAL == m_enGamePhase )
	{
	if ( dGameTime < 10 * 1000
	&& !bHurryUp )
	{
	bHurryUp = true;
	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 )
	+ else if ( dGameTime <= 0 )
	{
	m_enGamePhase = Ph_TIMEUP;
	TimeUp();
	break;
	}
	}

	g_oBackend.m_iGameTime = (int) ((dGameTime + 500.0) / 1000.0);
	iLastTick = iThisTick;

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

	oFpsCounter.Tick();

	// 3. Draw the next game screen..

	Draw();

	if ( g_oBackend.m_iGameOver )
	{
	break;
	}
	}

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

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

	// 4. END OF ROUND


	int p1h = g_oBackend.m_aoPlayers[0].m_iHitPoints;
	int p2h = g_oBackend.m_aoPlayers[1].m_iHitPoints;
	debug( "Game over; p1h = %d; p2h = %d\n", p1h, p2h );

	if ( p1h > p2h ) ++m_aiRoundsWonByPlayer[0];
	if ( p2h > p1h ) ++m_aiRoundsWonByPlayer[1];
	++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 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;
	}
	}


	diff --git a/src/Game.h b/src/Game.h
	index 55b7285..8d41dd3 100644
	--- a/src/Game.h
	+++ b/src/Game.h
	@@ -1,70 +1,73 @@
	/***************************************************************************
	Game.h - description
	-------------------
	begin : Mon Aug 27 2003
	copyright : (C) 2003 by upi
	email : upi@apocalypse.rulez.org
	***************************************************************************/


	#ifndef GAME_H
	#define GAME_H

	#include <string>
	#include <vector>

	struct SDL_Surface;



	class Game
	{
	public:
	Game( bool a_bIsReplay, bool a_bDebug );
	~Game();
	int Run();
	std::string& GetReplay();
	void DoReplay( const char* a_pcReplayFile );

	protected:
	void Draw();
	void DrawHitPointDisplay();
	void DrawBackground();
	void DrawDoodads();
	void DrawPoly( const char* a_pcName, int a_iColor );

	void DoOneRound();

	void Advance( int a_iNumFrames );
	int ProcessEvents();
	void HurryUp();
	void TimeUp();
	void InstantReplay( int a_iKoAt );

	protected:
	+
	+ static int mg_iBackgroundNumber;
	+
	bool m_bIsReplay;
	bool m_bDebug;
	SDL_Surface* m_poBackground;
	SDL_Surface* m_poDoodads;

	int m_aiRoundsWonByPlayer[2];
	int m_iNumberOfRounds;
	int m_iFrame;

	std::string m_sReplayString;
	std::vector<int> m_aReplayOffsets;

	enum // This enum assumes its values during DoOneRound
	{
	Ph_START, // "Round X" displayed, fighters getting ready
	Ph_NORMAL, // During the fight
	Ph_TIMEUP, // Time is up, no KO, no replay.
	Ph_KO, // There is a KO, forward until the guy is down
	Ph_REWIND, // There was a KO, rewinding until before the KO
	Ph_SLOWFORWARD, // Playing back the KO

	Ph_REPLAY, // Replay mode
	} m_enGamePhase;
	};

	#endif
	diff --git a/src/State.cpp b/src/State.cpp
	index 0a802d0..1dbf4b8 100644
	--- a/src/State.cpp
	+++ b/src/State.cpp
	@@ -1,143 +1,145 @@
	/***************************************************************************
	State.cpp - description
	-------------------
	begin : Mon Aug 12 2003
	copyright : (C) 2003 by upi
	email : upi@apocalypse.rulez.org
	***************************************************************************/

	#include "../config.h"
	#include "SDL.h"
	#include "common.h"
	#include "State.h"

	#include <string>
	#include <fstream>

	#include "Backend.h"

	#include <EXTERN.h>
	#include <perl.h>

	extern PerlInterpreter* my_perl;

	SState g_oState;



	std::string GetConfigHeader()
	{
	std::string sHeader( "Simple config file " );
	sHeader += PACKAGE " " VERSION;
	return sHeader;
	}


	std::string GetConfigFilename()
	{
	#ifdef _WINDOWS
	if ( NULL != g_oState.m_pcArgv0 )
	{
	return std::string(g_oState.m_pcArgv0) + ".ini";
	}
	return "c:\\openmortal.ini";
	#else
	return std::string(getenv("HOME")) + "/.openmortalrc";
	#endif
	}



	void SState::ToggleFullscreen()
	{
	m_bFullscreen = !m_bFullscreen;

	bool bPaletted = ( gamescreen->format->BitsPerPixel <= 8 );
	SDL_Color aoPalette[256];
	int iNumColors = 0;

	if ( bPaletted )
	{
	iNumColors = gamescreen->format->palette->ncolors;
	if ( iNumColors > 256 ) iNumColors = 256;
	for ( int i=0; i<iNumColors; ++i )
	{
	aoPalette[i].r = gamescreen->format->palette->colors[i].r;
	aoPalette[i].g = gamescreen->format->palette->colors[i].g;
	aoPalette[i].b = gamescreen->format->palette->colors[i].b;
	aoPalette[i].unused = 0;
	}
	}

	gamescreen = SDL_SetVideoMode( gamescreen->w, gamescreen->h,
	gamescreen->format->BitsPerPixel,
	m_bFullscreen ? SDL_FULLSCREEN : SDL_SWSURFACE );

	if ( bPaletted )
	{
	SDL_SetPalette( gamescreen, SDL_LOGPAL \| SDL_PHYSPAL, aoPalette, 0, iNumColors );
	}
	}



	void SState::Load()
	{
	std::string sFilename = GetConfigFilename();
	g_oBackend.PerlEvalF( "ParseConfig('%s');", sFilename.c_str() );

	SV* poSv;
	poSv = get_sv("GAMETIME", FALSE); if (poSv) m_iGameTime = SvIV( poSv );
	poSv = get_sv("HITPOINTS", FALSE); if (poSv) m_iHitPoints = SvIV( poSv );
	+ poSv = get_sv("GAMESPEED", FALSE); if (poSv) m_iGameSpeed = SvIV( poSv );
	poSv = get_sv("FULLSCREEN", FALSE); if (poSv) m_bFullscreen = SvIV( poSv );
	poSv = get_sv("CHANNELS", FALSE); if (poSv) m_iChannels = SvIV( poSv );
	poSv = get_sv("MIXINGRATE", FALSE); if (poSv) m_iMixingRate = SvIV( poSv );
	poSv = get_sv("MIXINGBITS", FALSE); if (poSv) m_iMixingBits = SvIV( poSv );
	poSv = get_sv("MUSICVOLUME", FALSE); if (poSv) m_iMusicVolume = SvIV( poSv );
	poSv = get_sv("SOUNDVOLUME", FALSE); if (poSv) m_iSoundVolume = SvIV( poSv );

	char pcBuffer[1024];
	for ( int i=0; i<2; ++i )
	{
	for ( int j=0; j<9; ++j )
	{
	sprintf( pcBuffer, "PLAYER%dKEY%d", i, j );
	poSv = get_sv(pcBuffer, FALSE); if (poSv) m_aiPlayerKeys[i][j] = SvIV( poSv );
	}
	}
	}


	void SState::Save()
	{
	std::string sFilename = GetConfigFilename();
	std::ofstream oStream( sFilename.c_str(), std::ios_base::out \| std::ios_base::trunc );
	if ( oStream.rdstate() & std::ios::failbit )
	{
	debug( "Unable to open config file: %s\n", sFilename.c_str() );
	return;
	}

	oStream << GetConfigHeader() << '\n';
	oStream << "GAMETIME=" << m_iGameTime << '\n';
	oStream << "HITPOINTS=" << m_iHitPoints << '\n';
	+ oStream << "GAMESPEED=" << m_iGameSpeed << '\n';
	oStream << "FULLSCREEN=" << m_bFullscreen << '\n';
	oStream << "CHANNELS=" << m_iChannels << '\n';
	oStream << "MIXINGRATE=" << m_iMixingRate << '\n';
	oStream << "MIXINGBITS=" << m_iMixingBits << '\n';
	oStream << "MUSICVOLUME=" << m_iMusicVolume << '\n';
	oStream << "SOUNDVOLUME=" << m_iSoundVolume << '\n';

	for ( int i=0; i<2; ++i )
	{
	for ( int j=0; j<9; ++j )
	{
	oStream << "PLAYER" <<i<< "KEY" <<j<< '=' << m_aiPlayerKeys[i][j] << '\n';
	}
	}

	oStream.flush();
	oStream.close();
	}


	diff --git a/src/State.h b/src/State.h
	index 9e29218..67c8150 100644
	--- a/src/State.h
	+++ b/src/State.h
	@@ -1,91 +1,93 @@
	/***************************************************************************
	State.h - description
	-------------------
	begin : Mon Aug 12 2003
	copyright : (C) 2003 by upi
	email : upi@apocalypse.rulez.org
	***************************************************************************/


	#ifndef STATE_H
	#define STATE_H

	#include "SDL_mixer.h"
	#include "SDL_keysym.h"

	struct SState
	{
	enum TGameMode {
	IN_DEMO,
	IN_SINGLE,
	IN_MULTI,
	} m_enGameMode;


	bool m_bQuitFlag; // true if quit event came
	const char* m_pcArgv0; // Set by main to argv[0]


	// CONFIGURATION VARIABLES

	int m_iGameTime; // Time of rounds in seconds.
	int m_iHitPoints; // The initial number of hit points.
	+ int m_iGameSpeed; // The speed of the game (fps = 1000/GameSpeed)

	bool m_bFullscreen; // True in fullscreen mode.

	int m_iChannels; // 1: mono, 2: stereo
	int m_iMixingRate; // The mixing rate, in kHz
	int m_iMixingBits; // 1: 8bit, 2: 16bit
	int m_iMusicVolume; // Volume of music; 0: off, 100: max
	int m_iSoundVolume; // Volume of sound effects; 0: off, 100: max

	int m_aiPlayerKeys[2][9]; // Player keysyms

	SState()
	{
	m_enGameMode = IN_DEMO;

	m_bQuitFlag = false;
	m_pcArgv0 = NULL;

	m_iGameTime = 60;
	m_iHitPoints = 100;
	+ m_iGameSpeed = 12;

	#ifdef _WINDOWS
	#ifdef _DEBUG
	m_bFullScreen = false;
	#else
	m_bFullscreen = true;
	#endif
	#else
	m_bFullscreen = false;
	#endif

	m_iChannels = 2;
	m_iMixingRate = MIX_DEFAULT_FREQUENCY;
	m_iMixingBits = 2;
	m_iMusicVolume = 50;
	m_iSoundVolume = 100;

	static const int aiDefaultKeys[2][9] = {
	{ SDLK_UP, SDLK_DOWN, SDLK_LEFT, SDLK_RIGHT, SDLK_PAGEDOWN,
	SDLK_DELETE, SDLK_INSERT, SDLK_END, SDLK_HOME },
	{ SDLK_w, SDLK_s, SDLK_a, SDLK_d, SDLK_x,
	SDLK_f, SDLK_r, SDLK_g, SDLK_t }
	};

	for ( int i=0; i<2; ++i )
	for ( int j=0; j<9; ++j )
	m_aiPlayerKeys[i][j] = aiDefaultKeys[i][j];

	};

	void Load();
	void Save();
	void ToggleFullscreen();
	};


	extern SState g_oState;

	#endif
	diff --git a/src/menu.cpp b/src/menu.cpp
	index b84ecec..8224833 100644
	--- a/src/menu.cpp
	+++ b/src/menu.cpp
	@@ -1,751 +1,759 @@
	/***************************************************************************
	menu.cpp - description
	-------------------
	begin : Sun Aug 3 2003
	copyright : (C) 2003 by upi
	email : upi@apocalypse.rulez.org
	***************************************************************************/

	#include "SDL.h"
	#include "SDL_video.h"

	#include "menu.h"
	#include "gfx.h"
	#include "State.h"
	#include "common.h"
	#include "Audio.h"
	#include "Backend.h"


	enum
	{
	/* Master menu structure:
	MAIN MENU
	*/
	MENU_UNKNOWN,
	MENU_SURRENDER,
	MENU_SINGLE_PLAYER,
	MENU_EASY,
	MENU_MEDIUM,
	MENU_HARD,
	MENU_MULTI_PLAYER,
	MENU_OPTIONS,
	+ MENU_GAME_SPEED,
	MENU_GAME_TIME, // ( :30 - 5:00 )
	MENU_TOTAL_HIT_POINTS, // ( 25 - 1000 )
	MENU_SOUND,
	MENU_CHANNELS, // MONO / STEREO
	MENU_MIXING_RATE, // 11kHz / 22kHz / 44.1 kHz
	MENU_BITS, // 8 bit / 16 bit
	MENU_MUSIC_VOLUME, // (0% - 100%)
	MENU_SOUND_VOLUME, // (0% - 100%)
	MENU_SOUND_OK,
	MENU_FULLSCREEN,
	MENU_KEYS_RIGHT,
	MENU_KEYS_LEFT,
	MENU_OPTIONS_OK,
	MENU_INFO,
	MENU_QUIT, // (confirm)
	};


	const char* g_ppcGameTime[] = { "0:30", "0:45", "1:00", "1:15", "1:30", "1:45", "2:00", "3:00", "5:00", NULL };
	const int g_piGameTime[] = { 30, 45, 60, 75, 90, 105, 120, 180, 300 };
	const char* g_ppcHitPoints[] = { "BABY", "VERY LOW", "LOW", "NORMAL", "HIGH", "VERY HIGH", "NEAR IMMORTAL", NULL };
	const int g_piHitPoints[] = { 1, 10, 50, 100, 150, 200, 500 };
	+const char* g_ppcGameSpeed[] = { "SNAIL RACE", "SLOW", "NORMAL", "TURBO", "KUNG-FU MOVIE", NULL };
	+const int g_piGameSpeed[] = { 16, 14, 12, 10, 8 };
	const char* g_ppcChannels[] = { "MONO", "STEREO", NULL };
	const int g_piChannels[] = { 1, 2 };
	const char* g_ppcMixingRate[] = { "LOW", "MEDIUM", "HIGH", NULL };
	const int g_piMixingRate[] = { 1, 2, 3 };
	const char* g_ppcMixingBits[] = { "8 bit", "16 bit", NULL };
	const int g_piMixingBits[] = { 1, 2 };
	const char* g_ppcVolume[] = { "OFF", "10%", "20%", "30%", "40%", "50%", "60%", "70%", "80%", "90%", "100%", NULL };
	const int g_piVolume[] = { 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };



	SDL_Surface* poBackground = NULL;



	void InputKeys( int a_iPlayerNumber )
	{
	SDL_BlitSurface( poBackground, NULL, gamescreen, NULL );
	DrawGradientText( "Input keys", titleFont, 20, gamescreen );
	SDL_Flip( gamescreen );

	static const char* apcKeyNames[9] = { "up", "down", "left", "right", "block",
	"low punch", "high punch", "low kick", "high kick" };
	char acBuffer[1024];
	int iY = 70;

	for ( int i=0; i<9; ++i )
	{
	sprintf( acBuffer, "%s player-'%s'?", a_iPlayerNumber ? "Left" : "Right", apcKeyNames[i] );
	DrawTextMSZ( acBuffer, inkFont, 10, iY, UseShadow, C_WHITE, gamescreen );

	SDLKey enKey = GetKey();

	if ( SDLK_ESCAPE == enKey )
	{
	SDL_BlitSurface( poBackground, NULL, gamescreen, NULL );
	SDL_Flip( gamescreen );
	return;
	}
	g_oBackend.PerlEvalF( "GetKeysym(%d);", enKey );
	DrawTextMSZ( g_oBackend.GetPerlString("keysym"), inkFont, 530, iY, UseShadow, C_WHITE, gamescreen );
	g_oState.m_aiPlayerKeys[a_iPlayerNumber][i] = enKey;
	iY += 35;
	}

	DrawTextMSZ( "Thanks!", inkFont, 320, iY + 20, UseShadow \| AlignCenter, C_WHITE, gamescreen );
	GetKey();
	SDL_BlitSurface( poBackground, NULL, gamescreen, NULL );
	SDL_Flip( gamescreen );
	}



	/***************************************************************************
	MENUITEM DEFINITION
	***************************************************************************/



	MenuItem::MenuItem( Menu* a_poMenu, const char* a_pcUtf8Text, int a_iCode )
	: m_sUtf8Text( a_pcUtf8Text )
	{
	m_poMenu = a_poMenu;
	m_iCode = a_iCode;

	m_oPosition.x = m_oPosition.y = 100;
	m_oPosition.w = m_oPosition.h = 100;
	m_bCenter = true;
	m_iHighColor = C_WHITE;
	m_iLowColor = C_LIGHTGRAY;
	m_iInactiveColor = C_DARKGRAY;
	m_iBackgroundColor = C_BLACK;
	m_bActive = false;
	m_bEnabled = true;
	}


	MenuItem::~MenuItem()
	{
	}

	void MenuItem::Draw()
	{
	if ( NULL != poBackground )
	{
	SDL_BlitSurface( poBackground, &m_oPosition, gamescreen, &m_oPosition );
	}
	else
	{
	SDL_FillRect( gamescreen, &m_oPosition, 0 );
	}

	int iX = m_oPosition.x;
	int iY = m_oPosition.y;

	if ( m_bCenter )
	{
	iX += m_oPosition.w / 2;
	}

	DrawTextMSZ( m_sUtf8Text.c_str(), inkFont, iX, iY,
	UseTilde \| UseShadow \| (m_bCenter ? AlignHCenter : 0),
	m_bEnabled ? (m_bActive ? m_iHighColor : m_iLowColor) : m_iInactiveColor,
	gamescreen );

	SDL_UpdateRect( gamescreen, m_oPosition.x, m_oPosition.y, m_oPosition.w, m_oPosition.h );
	}


	void MenuItem::Clear()
	{
	// debug( "Clear: %d:%d %dx%d\n", m_oPosition.x, m_oPosition.y, m_oPosition.w, m_oPosition.h );
	if (poBackground )
	{
	SDL_Rect oDest = m_oPosition;
	SDL_BlitSurface( poBackground, &m_oPosition, gamescreen, &oDest );
	}
	else
	{
	SDL_FillRect( gamescreen, &m_oPosition, C_WHITE );
	}

	SDL_UpdateRect( gamescreen, m_oPosition.x, m_oPosition.y, m_oPosition.w, m_oPosition.h );
	}


	void MenuItem::Activate()
	{
	if ( m_poMenu )
	{
	m_poMenu->ItemActivated( m_iCode, this );
	}
	}


	void MenuItem::SetText( const char* a_pcUtf8Text, bool a_bCenter )
	{
	m_sUtf8Text = a_pcUtf8Text;
	m_bCenter = a_bCenter;
	Draw();
	}

	void MenuItem::SetPosition( const SDL_Rect& a_roPosition )
	{
	m_oPosition = a_roPosition;
	}

	void MenuItem::SetActive( bool a_bActive )
	{
	if ( m_bActive == a_bActive )
	{
	return;
	}
	m_bActive = a_bActive;
	Draw();
	}

	void MenuItem::SetEnabled( bool a_bEnabled )
	{
	if ( m_bEnabled == a_bEnabled )
	{
	return;
	}
	m_bEnabled = a_bEnabled;
	Draw();
	}




	/***************************************************************************
	ENUMMENUITEM DEFINITION
	***************************************************************************/



	EnumMenuItem::EnumMenuItem( Menu* a_poMenu, int a_iInitialValue, const char* a_pcUtf8Text, int a_iCode )
	: MenuItem( a_poMenu, a_pcUtf8Text, a_iCode )
	{
	m_sUtf8Title = a_pcUtf8Text;
	m_iMax = -1;
	m_iValue = a_iInitialValue;
	}

	EnumMenuItem::~EnumMenuItem()
	{
	}


	void EnumMenuItem::Draw()
	{
	m_sUtf8Text = m_sUtf8Title;
	if ( m_iValue <= m_iMax )
	{
	m_sUtf8Text += m_ppcNames[m_iValue];
	}
	if ( m_iValue > 0 )
	{
	m_sUtf8Text = "< " + m_sUtf8Text;
	}
	if ( m_iValue < m_iMax )
	{
	m_sUtf8Text += " >";
	}

	MenuItem::Draw();
	}


	void EnumMenuItem::Increment()
	{
	if ( m_iValue < m_iMax )
	{
	++m_iValue;
	Draw();
	m_poMenu->ItemChanged( m_iCode, m_piValues[m_iValue], this );
	Audio->PlaySample( "ding.voc" );
	}
	}


	void EnumMenuItem::Decrement()
	{
	if ( m_iValue > 0 )
	{
	--m_iValue;
	Draw();
	m_poMenu->ItemChanged( m_iCode, m_piValues[m_iValue], this );
	Audio->PlaySample( "ding.voc" );
	}
	}


	void EnumMenuItem::SetEnumValues( const char ** a_ppcNames, const int * a_piValues )
	{
	m_ppcNames = a_ppcNames;
	m_piValues = a_piValues;

	int i;
	bool bFoundValue = false;

	for ( i=0; NULL != a_ppcNames[i]; ++i )
	{
	if ( !bFoundValue &&
	m_iValue == a_piValues[i] )
	{
	bFoundValue = true;
	m_iValue = i;
	}
	}

	if ( !bFoundValue )
	{
	m_iValue = 0;
	}

	m_iMax = i-1;
	}






	/***************************************************************************
	MENU DEFINITION
	***************************************************************************/


	Menu::Menu( const char* a_pcTitle )
	: m_sTitle( a_pcTitle )
	{
	m_iCurrentItem = 0;
	m_iReturnCode = -1;
	m_bDone = false;
	}


	Menu::~Menu()
	{
	ItemIterator it;
	for ( it = m_oItems.begin(); it != m_oItems.end(); ++it )
	{
	delete *it;
	}
	}


	MenuItem* Menu::AddMenuItem( const char* a_pcUtf8Text, SDLKey a_tShortcut, int a_iCode )
	{
	MenuItem* poItem = new MenuItem( this, a_pcUtf8Text, a_iCode );
	return AddMenuItem( poItem );
	}



	EnumMenuItem* Menu::AddEnumMenuItem( const char* a_pcUtf8Text, int a_iInitialValue,
	const char** a_ppcNames, const int* a_piValues, int a_iCode )
	{
	EnumMenuItem* poItem = new EnumMenuItem( this, a_iInitialValue, a_pcUtf8Text, a_iCode );
	poItem->SetEnumValues( a_ppcNames, a_piValues );

	AddMenuItem( poItem );
	return poItem;
	}



	MenuItem* Menu::AddMenuItem( MenuItem* a_poItem )
	{
	m_oItems.push_back( a_poItem );

	SDL_Rect oRect;
	oRect.x = 0; oRect.w = gamescreen->w;
	oRect.y = m_oItems.size() * 45 + 100;
	oRect.h = 45;

	a_poItem->SetPosition( oRect );

	return a_poItem;
	}


	void Menu::AddOkCancel( int a_iOkCode )
	{
	SDL_Rect oRect;
	oRect.x = 0; oRect.w = 150;
	oRect.y = gamescreen->h - 50; oRect.h = 30;

	MenuItem* poItem = AddMenuItem( "~OK", SDLK_o, a_iOkCode );
	poItem->SetPosition( oRect );

	// poItem = AddMenuItem( "Cancel", SDLK_UNKNOWN, 0 );
	oRect.x = gamescreen->w - 150;
	poItem->SetPosition( oRect );
	}


	void Menu::InvokeSubmenu( Menu* a_poMenu )
	{
	Audio->PlaySample( "strange_button.voc" );
	Clear();
	m_iReturnCode = a_poMenu->Run();
	if ( m_iReturnCode < 0 )
	{
	Audio->PlaySample( "pop.voc" );
	Draw();
	}
	else
	{
	m_iReturnCode --;
	m_bDone = true;
	}
	}


	void Menu::ItemActivated( int a_iItemCode, MenuItem* a_poMenuItem )
	{
	debug( "Menu::ItemActivated( %d )\n", a_iItemCode );

	switch ( a_iItemCode )
	{
	case MENU_QUIT:
	m_bDone = true;
	m_iReturnCode = 100;
	g_oState.m_bQuitFlag = true;
	break;

	case MENU_SURRENDER:
	m_bDone = true;
	m_iReturnCode = 100;
	g_oState.m_enGameMode = SState::IN_DEMO;
	break;

	case MENU_MULTI_PLAYER:
	m_bDone = true;
	m_iReturnCode = 100;
	g_oState.m_enGameMode = SState::IN_MULTI;
	break;

	case MENU_FULLSCREEN:
	Audio->PlaySample( "strange_button.voc" );
	g_oState.ToggleFullscreen();
	if ( NULL != poBackground )
	{
	SDL_BlitSurface( poBackground, NULL, gamescreen, NULL );
	}
	else
	{
	SDL_FillRect( gamescreen, NULL, 0 );
	}
	a_poMenuItem->SetText( g_oState.m_bFullscreen ? "~FULLSCREEN ON" : "~FULLSCREEN OFF", true );
	Draw();
	break;

	case MENU_OPTIONS_OK:
	m_bDone = true;
	m_iReturnCode = -1;
	break;

	case MENU_OPTIONS:
	{
	Menu* poMenu = new Menu( "Options" );
	+ poMenu->AddEnumMenuItem( "GAME SPEED: ", g_oState.m_iGameSpeed, g_ppcGameSpeed, g_piGameSpeed, MENU_GAME_SPEED );
	poMenu->AddEnumMenuItem( "GAME TIME: ", g_oState.m_iGameTime, g_ppcGameTime, g_piGameTime, MENU_GAME_TIME );
	poMenu->AddEnumMenuItem( "STAMINA: ", g_oState.m_iHitPoints, g_ppcHitPoints, g_piHitPoints, MENU_TOTAL_HIT_POINTS );
	poMenu->AddMenuItem( "~SOUND", SDLK_s, MENU_SOUND );
	poMenu->AddMenuItem( g_oState.m_bFullscreen ? "~FULLSCREEN ON" : "~FULLSCREEN OFF", SDLK_f, MENU_FULLSCREEN );
	poMenu->AddMenuItem( "~RIGHT PLAYER KEYS", SDLK_r, MENU_KEYS_RIGHT );
	poMenu->AddMenuItem( "~LEFT PLAYER KEYS", SDLK_l, MENU_KEYS_LEFT );
	poMenu->AddOkCancel( MENU_OPTIONS_OK );

	InvokeSubmenu( poMenu );
	delete poMenu;
	break;
	}

	case MENU_SOUND:
	{
	Menu* poMenu = new Menu( "Sound" );
	poMenu->AddEnumMenuItem( "CHANNELS: ", 1, g_ppcChannels, g_piChannels, MENU_CHANNELS )->SetEnabled(false);
	poMenu->AddEnumMenuItem( "SOUND QUALITY: ", 2, g_ppcMixingRate, g_piMixingRate, MENU_MIXING_RATE )->SetEnabled(false);
	poMenu->AddEnumMenuItem( "SOUND FIDELITY: ", 2, g_ppcMixingBits, g_piMixingBits, MENU_BITS )->SetEnabled(false);
	poMenu->AddEnumMenuItem( "MUSIC VOLUME: ", g_oState.m_iMusicVolume, g_ppcVolume, g_piVolume, MENU_MUSIC_VOLUME );
	poMenu->AddEnumMenuItem( "EFFECTS VOLUME: ", g_oState.m_iSoundVolume, g_ppcVolume, g_piVolume, MENU_SOUND_VOLUME );
	poMenu->AddOkCancel( MENU_SOUND_OK );

	InvokeSubmenu( poMenu );
	delete poMenu;
	break;
	}

	case MENU_SOUND_OK:
	m_bDone = true;
	m_iReturnCode = -1;
	break;

	case MENU_KEYS_LEFT:
	InputKeys(1);
	Draw();
	break;

	case MENU_KEYS_RIGHT:
	InputKeys(0);
	Draw();
	break;

	default:
	break;
	}
	}



	void Menu::ItemChanged( int a_iItemCode, int a_iValue, MenuItem* a_poMenuItem )
	{
	- debug( "Menu::ItemActivated( %d )\n", a_iItemCode );
	+ debug( "Menu::ItemChanged( %d, %d )\n", a_iItemCode, a_iValue );

	switch ( a_iItemCode )
	{
	case MENU_MUSIC_VOLUME:
	g_oState.m_iMusicVolume = a_iValue;
	Audio->SetMusicVolume( a_iValue );
	break;

	case MENU_SOUND_VOLUME:
	g_oState.m_iSoundVolume = a_iValue;
	break;

	case MENU_GAME_TIME:
	g_oState.m_iGameTime = a_iValue;
	break;

	+ case MENU_GAME_SPEED:
	+ g_oState.m_iGameSpeed = a_iValue;
	+ break;
	+
	case MENU_TOTAL_HIT_POINTS:
	g_oState.m_iHitPoints = a_iValue;
	break;
	} // end of switch a_iItemCode
	}


	/** Run executes the menus, maybe invoking submenus as well. The
	menus modify the global game state.

	Returns 0, or the number of parent menus that should be cleared. */

	int Menu::Run()
	{
	if ( m_oItems[m_iCurrentItem]->GetEnabled() )
	{
	m_oItems[m_iCurrentItem]->SetActive(true);
	}
	else
	{
	FocusNext();
	}

	Draw();

	while ( !m_bDone )
	{
	SDLKey enKey = GetKey();

	if ( g_oState.m_bQuitFlag \|\|
	SDLK_ESCAPE == enKey )
	{
	m_bDone = true;
	m_iReturnCode = -1;
	break;
	}

	switch ( enKey )
	{
	case SDLK_UP:
	{
	FocusPrev();
	break;
	} // end of SDLK_UP


	case SDLK_DOWN:
	{
	FocusNext();
	break;
	} // end of SDLK_DOWN

	case SDLK_LEFT:
	{
	MenuItem* poItem = m_oItems[m_iCurrentItem];
	poItem->Decrement();
	break;
	}

	case SDLK_RIGHT:
	{
	MenuItem* poItem = m_oItems[m_iCurrentItem];
	poItem->Increment();
	break;
	}

	case SDLK_RETURN:
	{
	MenuItem* poItem = m_oItems[m_iCurrentItem];
	if ( poItem->GetEnabled() )
	{
	poItem->Activate();
	}
	}

	default:
	break;
	} // end of switch
	}

	Clear();

	return m_iReturnCode;
	}


	void Menu::Draw()
	{
	DrawGradientText( m_sTitle.c_str(), titleFont, 20, gamescreen );

	for ( ItemIterator it=m_oItems.begin(); it!=m_oItems.end(); ++it )
	{
	(*it)->Draw();
	}

	SDL_Flip( gamescreen );

	}



	void Menu::FocusNext()
	{
	MenuItem* poItem = NULL;
	int iNextItem;

	for ( iNextItem = m_iCurrentItem+1; iNextItem < (int) m_oItems.size(); ++iNextItem )
	{
	poItem = m_oItems[iNextItem];
	if ( poItem->GetEnabled() )
	{
	break;
	}
	poItem = NULL;
	}

	if ( NULL != poItem )
	{
	Audio->PlaySample("strange_quack.voc");
	m_oItems[m_iCurrentItem]->SetActive(false);
	m_oItems[iNextItem]->SetActive(true);
	m_iCurrentItem = iNextItem;
	}
	}



	void Menu::FocusPrev()
	{
	MenuItem* poItem = NULL;
	int iPrevItem;

	for ( iPrevItem = m_iCurrentItem-1; iPrevItem >= 0; --iPrevItem )
	{
	poItem = m_oItems[iPrevItem];
	if ( poItem->GetEnabled() )
	{
	break;
	}
	poItem = NULL;
	}

	if ( NULL != poItem )
	{
	Audio->PlaySample("strange_quack.voc");
	m_oItems[m_iCurrentItem]->SetActive(false);
	m_oItems[iPrevItem]->SetActive(true);
	m_iCurrentItem = iPrevItem;
	}
	}



	void Menu::Clear()
	{
	if (poBackground)
	{
	SDL_BlitSurface( poBackground, 0, gamescreen, 0 );
	}
	else
	{
	SDL_FillRect( gamescreen, NULL, 0 );
	}
	}


	void DoMenu( bool a_bDrawBackground )
	{
	Audio->PlaySample( "crashhh.voc" );

	poBackground = SDL_ConvertSurface( gamescreen, gamescreen->format, SDL_SWSURFACE );
	if ( NULL == poBackground )
	{
	debug( "DoMenu: Couldn't allocate background.\n" );
	}
	else
	{
	int i;
	SDL_Rect oRect;
	oRect.x = 0; oRect.w = poBackground->w; oRect.h = 1;

	for ( i=0; i<poBackground->h; i += 2 )
	{
	oRect.y = i;
	SDL_FillRect( poBackground, &oRect, C_BLACK );
	}

	oRect.w = 1; oRect.y = 0; oRect.h = poBackground->h;

	for ( i=0; i<poBackground->w; i+=2 )
	{
	oRect.x = i;
	SDL_FillRect(poBackground, &oRect, C_BLACK );
	}

	SDL_BlitSurface( poBackground, 0, gamescreen, 0 );
	SDL_Flip( gamescreen );
	}

	Menu oMenu( "Main Menu" );

	if ( SState::IN_DEMO == g_oState.m_enGameMode )
	{
	oMenu.AddMenuItem( "~SINGLE PLAYER GAME", SDLK_s, MENU_SINGLE_PLAYER )->SetEnabled(false);
	oMenu.AddMenuItem( "~MULTI PLAYER GAME", SDLK_m, MENU_MULTI_PLAYER );
	}
	else
	{
	oMenu.AddMenuItem( "~SURRENDER GAME", SDLK_s, MENU_SURRENDER );
	}
	oMenu.AddMenuItem( "~OPTIONS", SDLK_o, MENU_OPTIONS );
	oMenu.AddMenuItem( "~INFO", SDLK_i, MENU_INFO )->SetEnabled(false);
	oMenu.AddMenuItem( "QUIT", SDLK_UNKNOWN, MENU_QUIT );

	oMenu.Run();

	Audio->PlaySample("shades_rollup.voc");

	//SDL_BlitSurface( poBackground, 0, gamescreen, 0 );
	//SDL_Flip( gamescreen );
	SDL_FreeSurface( poBackground );
	poBackground = NULL;
	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, Feb 4, 2:13 PM (1 h, 59 m ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 55641
Default Alt Text: (42 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions