No OneTemporary
Actions

Size

112 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/Game.cpp b/src/Game.cpp
	index d15c5d3..1e56fc6 100644
	--- a/src/Game.cpp
	+++ b/src/Game.cpp
	@@ -1,981 +1,990 @@
	/***************************************************************************
	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 "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



	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_enInitialGameMode = g_oState.m_enGameMode;

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


	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),
	- 230 - g_oPlayerSelect.GetFighterNameWidth(0), 38 );
	+ iTextX, 38 );
	+ iTextX = g_oPlayerSelect.GetFighterNameWidth(1);
	+ iTextX = iTextX < (635-410) ? 410 : 635-iTextX;
	sge_BF_textout( gamescreen, fastFont, g_oPlayerSelect.GetFighterName(1),
	- 410, 38 );
	+ 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()
	{
	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", 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;
	}

	if ( IsNetworkGame() )
	{
	bool bMaster = g_poNetwork->IsMaster();
	g_poNetwork->Update();
	if (!bMaster)
	{
	// We don't run our own backend, just pull the data from the network.
	const char* pcRemoteBackend = g_poNetwork->GetLatestGameData();
	g_oBackend.ReadFromString( pcRemoteBackend );
	return;
	}
	}

	static std::string sFrameDesc;

	while ( a_iNumFrames > 0 )
	{
	-- a_iNumFrames;
	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() );
	}

	if ( IsNetworkGame() && sFrameDesc.size() )
	{
	g_poNetwork->SendGameData( sFrameDesc.c_str() );
	g_oBackend.PlaySounds();
	}

	}



	/** A helper method of ProcessEvents; it manages keypresses and releases of
	players.
	*/

	void Game::HandleKey( int a_iPlayer, int a_iKey, bool a_bDown )
	{
	if ( IsMaster() )
	{
	if ( IsNetworkGame() )
	{
	a_iPlayer = 0;
	}
	g_oBackend.PerlEvalF( a_bDown ? "KeyDown(%d,%d);" : "KeyUp(%d,%d);", a_iPlayer, a_iKey );
	}
	else
	{
	g_poNetwork->SendKeystroke( 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()
	{
	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 /&& !IsNetworkGame()/ )
	+ if ( event.key.keysym.sym == SDLK_ESCAPE && !IsNetworkGame() )
	{
	SState::TGameMode enMode = g_oState.m_enGameMode;
	::DoMenu( true );
	return g_oState.m_enGameMode == enMode ? 0 : 1;
	}
	if ( event.key.keysym.sym == SDLK_F1 /&& !IsNetworkGame()/ )
	{
	// 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;
	}
	HandleKey( i, j, true );
	//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)
	{
	HandleKey( i, j, false );
	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 );
	}


	/** 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);", g_oState.m_iHitPoints, m_bDebug );

	if ( IsNetworkGame() )
	{
	g_poNetwork->SynchStartRound();
	}

	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 = g_oState.m_iGameSpeed;
	iThisTick = SDL_GetTicks() / iGameSpeed;
	iLastTick = iThisTick - 1;

	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 ( !IsNetworkGame()
	- \|\| (IsNetworkGame() && g_poNetwork->IsMaster()) )
	+ if ( IsMaster() )
	{
	if ( Ph_START == m_enGamePhase ) // Check for the end of the START phase
	{
	if ( dGameTime <= 0 )
	{
	m_enGamePhase = Ph_NORMAL;
	dGameTime = g_oState.m_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);

	if ( IsNetworkGame() )
	{
	g_poNetwork->SendGameTime( m_iGameTime, m_enGamePhase );
	}
	}
	else
	{
	m_iGameTime = g_poNetwork->GetGameTime();
	- TGamePhaseEnum enOldPhase = m_enGamePhase;
	m_enGamePhase = (TGamePhaseEnum) g_poNetwork->GetGamePhase();
	dGameTime = 1000.0; // ignored.
	+ switch (g_poNetwork->GetHurryup() )
	+ {
	+ case 1: HurryUp(); break;
	+ case 2: TimeUp(); break;
	+ }
	}

	iLastTick = iThisTick;

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

	if ( IsNetworkGame() && IsMaster() )
	{
	int iKey;
	bool bPressed;
	while ( g_poNetwork->GetKeystroke( iKey, bPressed ) )
	{
	debug( "Got GetKeystroke: %d, %d\n", iKey, bPressed );
	g_oBackend.PerlEvalF( bPressed ? "KeyDown(%d,%d);" : "KeyUp(%d,%d);", 1, iKey );
	}
	}

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






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


	diff --git a/src/MortalNetwork.h b/src/MortalNetwork.h
	index 058b238..43ec4a0 100644
	--- a/src/MortalNetwork.h
	+++ b/src/MortalNetwork.h
	@@ -1,127 +1,138 @@
	/***************************************************************************
	MortalNetwork.h - description
	-------------------
	begin : Sun Jan 25 2004
	copyright : (C) 2004 by upi
	email : upi@feel
	***************************************************************************/


	#ifndef MORTALNETWORK_H
	#define MORTALNETWORK_H

	#include "FighterEnum.h"


	/** Mortal Network messages:


	TYPICAL MESSAGE FLOW:

	<connection is established>
	Introduction messages are sent (version checking, usernames)

	<players go to the character selection screen>
	1. F <number> messages go both ways as players choose their characters.
	2. R message goes in both direction when players have finished choosing.

	<both sides go to the game screen>
	In odd rounds, the "server" if the "master" and the "client" is the "slave"
	In even rounds, the "client" if the "master" and the "server" is the "slave"

	Both the master and the slave send an S message to synchronize the game start.

	The master sends G <text> messages to update the backend on the slave side.
	The slave sends K <number> <bool> messages to communicate keystrokes to the master side.
	The master sends O <number> <bool> message when the round is over.

	Back to game start synchronization.

	<both sides go to final judgement - may disconnect the game>

	<both sides go back to the character selection screen>


	OTHERS:

	Msgs can be send on the character selection screen with M <text>.
	The connection can be broken at any time. IsConnectionAlive() must be called
	periodically.

	The "server" is always appears as player 1, the "client" is always player 2.
	However, they both use the "Player 1" keys.


	SUMMARY OF MESSAGES:

	I <version> <username> - Introduction sent both ways on connection.
	+M <text> - Incoming Msg text.
	+
	+S - Ready for the next round (synch).
	G <text> - Update on the game backend data.
	+T <number> <number> - Update the game time and game phase.
	K <number> <bool> - Key # up/down
	-M <text> - Incoming Msg text.
	+H <number> - Hurryup and other special messages
	+O <number> <bool> - The round is over (who won, are there more rounds).
	+
	F <number> - I have switched to fighter X.
	R - I have chosen a fighter.
	-S - Ready for the next round (synch).
	-O <number> <bool> - The round is over (who won, are there more rounds).
	-T <number> <number> - Update the game time and game phase.
	+Q <number> - Is fighter X available?
	+A <number> - Fighter A is available.
	+P <number> x3 - Game parameters

	*/






	class CMortalNetwork
	{
	public:

	static void Create();

	// Connection's lifecycle

	virtual bool Start( const char* a_pcServerName ) = 0; // Accept connection, or connect to given server
	virtual void Stop() = 0; // Disconnect
	virtual bool IsConnectionAlive() = 0; // Is the connection still good?
	virtual void Update() = 0; // Read network traffic. Might get disconnected...
	virtual const char* GetLastError() = 0;
	virtual bool IsMaster() = 0; // Am I Master or Slave?

	// Msg related methods

	virtual const char* GetRemoteUsername() = 0; // This is the name that is passed upon connection.
	virtual void SendMsg( const char* a_rsMsg ) = 0; // Prompt the user for a line of chat text
	virtual bool IsMsgAvailable() = 0; // Returns true is a chatline has arrived
	virtual const char* GetMsg() = 0; // The next chatline, or NULL if there are no more.

	// Charater Selection methods

	virtual bool IsRemoteFighterAvailable( FighterEnum a_enFighter ) = 0; // Does the other computer have fighter X installed?
	virtual FighterEnum GetRemoteFighter() = 0; // Returns the latest fighter chosen by the remote side.
	virtual bool IsRemoteSideReady() = 0; // The other player is finished choosing.

	virtual void SendFighter( FighterEnum a_enFighter ) = 0; // Let the other side know that I switched to fighter X.
	virtual void SendReady() = 0; // Let the other side know that I am ready.
	+ virtual void SendGameParams( int a_iGameSpeed, int a_iGameTime, int a_iHitPoints ) = 0;

	// Game methods

	- virtual void SynchStartRound() = 0;
	+ virtual bool SynchStartRound() = 0;
	virtual void SendGameData( const char* a_pcGameData ) = 0;
	virtual const char* GetLatestGameData() = 0;
	+
	virtual void SendKeystroke( int a_iKey, bool a_bPressed ) = 0;
	virtual bool GetKeystroke( int& a_riOutKey, bool& a_rbPressed ) = 0;
	+
	virtual void SendGameTime( int a_iGameTime, int a_iGamePhase ) = 0;
	virtual int GetGameTime() = 0;
	virtual int GetGamePhase() = 0;

	+ virtual void SendHurryup( int a_iHurryUpCode ) = 0;
	+ virtual int GetHurryup() = 0;

	virtual void SendRoundOver( int a_iWhoWon, bool a_bGameOver ) = 0;
	virtual bool IsRoundOver() = 0;
	virtual bool IsGameOver() = 0;
	virtual int GetWhoWon() = 0;
	};


	extern CMortalNetwork* g_poNetwork;


	#endif // MORTALNETWORK_H
	diff --git a/src/MortalNetworkImpl.cpp b/src/MortalNetworkImpl.cpp
	index 2f15b04..4a04ef0 100644
	--- a/src/MortalNetworkImpl.cpp
	+++ b/src/MortalNetworkImpl.cpp
	@@ -1,726 +1,902 @@
	/***************************************************************************
	MortalNetworkImpl.cpp - description
	-------------------
	begin : Sun Jan 25 2004
	copyright : (C) 2004 by upi
	email : upi@feel
	***************************************************************************/

	#include "MortalNetworkImpl.h"
	#include "State.h"
	+#include "PlayerSelect.h"
	#include "common.h"
	#include "config.h"


	#define MORTALNETWORKPORT 0x3A22


	+// Some graphics routines, defined in menu.cpp
	+
	+void MortalNetworkResetMessages( bool a_bClear );
	void MortalNetworkMessage( const char* format, ... );
	bool MortalNetworkCheckKey();
	+const char* GetGameTimeString( int a_iValue );
	+const char* GetGameSpeedString( int a_iValue );
	+const char* GetHitPointsString( int a_iValue );




	CMortalNetwork* g_poNetwork = NULL;




	void CMortalNetwork::Create() // static
	{
	if ( NULL == g_poNetwork )
	{
	g_poNetwork = new CMortalNetworkImpl;
	}
	}



	CMortalNetworkImpl::CMortalNetworkImpl()
	{
	m_enState = NS_DISCONNECTED;
	m_bServer = false;
	m_bMaster = false;
	m_poSocket = NULL;

	m_enRemoteFighter = UNKNOWN;
	m_bRemoteReady = false;
	m_bRoundOver = false;
	m_iWhoWon = -1;
	m_bGameOver = false;
	m_iGameTime = 0;
	m_iGamePhase = 0;
	+ m_iHurryupCode = 0;
	+ m_iIncomingBufferSize = 0;

	if(SDLNet_Init()==-1)
	{
	m_bNetworkAvailable = false;
	m_sLastError = SDLNet_GetError();
	debug ( "Error opening SDLNet: %s\n", m_sLastError.c_str() );
	}

	m_bNetworkAvailable = true;
	}


	CMortalNetworkImpl::~CMortalNetworkImpl()
	{
	Stop();
	}


	bool CMortalNetworkImpl::Start( const char* a_pcServerName )
	{
	#define RETURNNOERROR { \
	debug( "%s\n", m_sLastError.c_str() ); \
	return false; }
	#define RETURNWITHERROR { \
	m_sLastError = SDLNet_GetError(); \
	debug( "%s\n", m_sLastError.c_str() ); \
	return false; }
	#define RETURNWITHADDITIONALERROR { \
	m_sLastError += SDLNet_GetError(); \
	debug( "%s\n", m_sLastError.c_str() ); \
	return false; }

	if ( !m_bNetworkAvailable )
	{
	return false;
	}

	debug( "CMortalNetworkImpl::Start( %s )\n", a_pcServerName ? a_pcServerName : "NULL" );
	IPaddress oAddress;

	if ( a_pcServerName )
	{
	MortalNetworkMessage( Translate("Resolving hostname...") );
	}

	int iResult = SDLNet_ResolveHost( &oAddress, a_pcServerName, MORTALNETWORKPORT );
	if ( iResult )
	{
	m_sLastError = Translate( "Couldn't resolve host." );
	RETURNNOERROR;
	}
	debug( "IP Address of server is 0x%x\n", oAddress.host );

	if ( a_pcServerName )
	{
	Uint32 ipaddr=SDL_SwapBE32(oAddress.host);
	MortalNetworkMessage("Connecting to %d.%d.%d.%d port %d",
	ipaddr>>24, (ipaddr>>16)&0xff, (ipaddr>>8)&0xff, ipaddr&0xff, oAddress.port);
	}

	if ( !a_pcServerName )
	{
	// SERVER-MODE CONNECTION

	m_poSocket = SDLNet_TCP_Open( &oAddress );

	// Wait for connection ...
	MortalNetworkMessage ( Translate("Waiting for connection... (press any key to abort)") );
	TCPsocket poClient;
	while ( 1 )
	{
	poClient = SDLNet_TCP_Accept( m_poSocket );
	if ( poClient ) break;

	if (MortalNetworkCheckKey()) break;;
	SDL_Delay( 100 );
	}

	SDLNet_TCP_Close( m_poSocket );

	if ( NULL == poClient )
	{
	m_sLastError = "No connection.";
	return false;
	}

	IPaddress* poRemoteAddress = SDLNet_TCP_GetPeerAddress(poClient);

	if ( !poRemoteAddress )
	{
	RETURNWITHERROR;
	}
	Uint32 ipaddr=SDL_SwapBE32(poRemoteAddress->host);
	MortalNetworkMessage("Accepted connection from %d.%d.%d.%d port %d",
	ipaddr>>24, (ipaddr>>16)&0xff, (ipaddr>>8)&0xff, ipaddr&0xff, oAddress.port);

	// Set the client socket as our socket, and drop the server socket.

	m_poSocket = poClient;
	}
	else
	{
	// CLIENT-MODE CONNECTION

	MortalNetworkMessage ( Translate("Waiting for connection... (press any key to abort)") );

	while (1)
	{
	m_poSocket = SDLNet_TCP_Open( &oAddress );
	if ( m_poSocket ) break;
	if ( MortalNetworkCheckKey() ) break;
	SDL_Delay( 100 );
	}
	if ( NULL == m_poSocket )
	{
	RETURNWITHERROR;
	}
	}

	// CONNECTION ESTABLISHED. SEND INTRO PACKETS

	MortalNetworkMessage( Translate("Connection established.") );

	struct SIntroPackage
	{
	char cID;
	char acVersion[10];
	} oIntroPackage, oRemotePackage;

	oIntroPackage.cID = 'I';
	strncpy( oIntroPackage.acVersion, VERSION, 10 );
	oIntroPackage.acVersion[9] = 0;

	debug( "Sending intro package... " );

	int iRetval = SDLNet_TCP_Send( m_poSocket, &oIntroPackage, sizeof( oIntroPackage ) );

	if ( iRetval < (int) sizeof( oIntroPackage ) )
	{
	RETURNWITHERROR;
	}

	iRetval = SDLNet_TCP_Recv( m_poSocket, &oRemotePackage, sizeof( oRemotePackage ) );
	if ( iRetval <= 0 )
	{
	RETURNWITHERROR;
	}
	if ( iRetval < (int) sizeof( oRemotePackage )
	\|\| oRemotePackage.cID != 'I'
	\|\| strncmp( oRemotePackage.acVersion, VERSION, 9 ) )
	{
	m_sLastError = Translate( "The remote side has a different version of OpenMortal running." );
	RETURNNOERROR;
	}

	MortalNetworkMessage( Translate("Life is good.") );

	m_enState = NS_CHARACTER_SELECTION;
	m_bServer = NULL == a_pcServerName;
	m_bMaster = m_bServer;
	m_sLastError = "";
	m_asMsgs.clear();
	m_enRemoteFighter = UNKNOWN;
	m_bRemoteReady = false;
	m_sLatestGameData = "";
	m_aiKeystrokes.clear();
	m_abKeystrokes.clear();
	m_iGameTime = 0;
	m_iGamePhase = 0;
	+ m_iHurryupCode = 0;
	m_iIncomingBufferSize = 0;
	+ m_aiAvailableRemoteFighters.clear();
	+ m_oGameParams.iGameTime = m_oGameParams.iGameSpeed = m_oGameParams.iHitPoints = -1;

	m_poSocketSet = SDLNet_AllocSocketSet( 1 );
	SDLNet_TCP_AddSocket( m_poSocketSet, m_poSocket ); // Check for errors?

	return true;
	}


	void CMortalNetworkImpl::Stop()
	{
	if ( NS_DISCONNECTED == m_enState )
	{
	return;
	}

	g_oState.m_enGameMode = SState::IN_DEMO;
	m_enState = NS_DISCONNECTED;
	SDLNet_FreeSocketSet( m_poSocketSet );
	SDLNet_TCP_Close( m_poSocket );
	}


	bool CMortalNetworkImpl::IsConnectionAlive()
	{
	return ( NS_DISCONNECTED != m_enState );
	}



	#define DISCONNECTONCOMMUNICATIONERROR { \
	m_sLastError = Translate("Communication error. Disconnecting."); \
	Stop(); \
	return; }
	#define DISCONNECTWITH(A) { \
	m_sLastError = Translate("Communication error. Disconnecting."); \
	Stop(); \
	return(A); }

	#define CHECKCONNECTION if ( NS_DISCONNECTED == m_enState ) return;


	void CMortalNetworkImpl::Update()
	{
	CHECKCONNECTION;

	// 1. CHECK FOR STUFF TO READ

	int iRetval = SDLNet_CheckSockets( m_poSocketSet, 0 );
	if ( iRetval <= 0 )
	{
	return;
	}

	// 2. APPEND AT MOST 1024 bytes TO THE END OF THE INCOMING BUFFER

	iRetval = SDLNet_TCP_Recv( m_poSocket, m_acIncomingBuffer + m_iIncomingBufferSize, 1024 );
	if ( iRetval <= 0 )
	{
	m_sLastError = SDLNet_GetError();
	Stop();
	return;
	}
	m_iIncomingBufferSize += iRetval;

	// 3. CONSUME THE INCOMING BUFFER.
	// We always make sure the incoming buffer starts with a package header.

	int iOffset = 0;

	while ( iOffset < m_iIncomingBufferSize )
	{
	// 3.1. Check if we have enough data to receive the package.

	if ( m_iIncomingBufferSize - iOffset < 4 )
	{
	// Not enough space left for a full header.
	debug( "Not enough space left for a full header (%d).\n", m_iIncomingBufferSize-iOffset );
	break;
	}

	unsigned int iLengthOfPackage = SDL_SwapBE16(((Uint16)(m_acIncomingBuffer + iOffset + 1)));
	if ( iLengthOfPackage > 1000 )
	{
	debug( "Maximum package size exceeded.\n" );
	DISCONNECTONCOMMUNICATIONERROR;
	}
	debug( "Receiving stuff.. %c type, %d package length, offset %d in buffer, %d bytes in buffer\n",
	m_acIncomingBuffer[iOffset], iLengthOfPackage, iOffset, m_iIncomingBufferSize );

	if ( iOffset + 4 + (int)iLengthOfPackage > m_iIncomingBufferSize )
	{
	// Not enough space left for the actual package.
	debug( "Not enough space left for the actual package.\n" );
	break;
	}

	// 3.2. Receive the data.

	switch ( m_acIncomingBuffer[iOffset] )
	{
	case 'M': ReceiveMsg( m_acIncomingBuffer+iOffset+4, iLengthOfPackage ); break;
	case 'F': ReceiveFighter( m_acIncomingBuffer+iOffset+4, iLengthOfPackage ); break;
	case 'R': ReceiveReady( m_acIncomingBuffer+iOffset+4, iLengthOfPackage ); break;
	case 'S': m_bSynchQueryResponse=true; break;
	case 'G': ReceiveGameData( m_acIncomingBuffer+iOffset+4, iLengthOfPackage ); break;
	case 'K': ReceiveKeystroke( m_acIncomingBuffer+iOffset+4, iLengthOfPackage ); break;
	case 'O': ReceiveRoundOver( m_acIncomingBuffer+iOffset+4, iLengthOfPackage ); break;
	case 'T': ReceiveGameTime( m_acIncomingBuffer+iOffset+4, iLengthOfPackage ); break;
	+ case 'H': ReceiveHurryup( m_acIncomingBuffer+iOffset+4, iLengthOfPackage ); break;
	+ case 'A': ReceiveRemoteFighterAvailable( m_acIncomingBuffer+iOffset+4, iLengthOfPackage ); break;
	+ case 'Q': ReceiveRemoteFighterQuery( m_acIncomingBuffer+iOffset+4, iLengthOfPackage ); break;
	+ case 'P': ReceiveGameParams( m_acIncomingBuffer+iOffset+4, iLengthOfPackage ); break;
	default:
	{
	debug( "Bad ID: %c (%d)\n", m_acIncomingBuffer[iOffset], m_acIncomingBuffer[iOffset] );
	DISCONNECTONCOMMUNICATIONERROR;
	}
	}

	if ( !IsConnectionAlive() )
	{
	return;
	}

	iOffset += iLengthOfPackage + 4;
	}

	// 4. MOVE LEFTOVER DATA TO THE BEGINNING OF THE INCOMING BUFFER
	// The leftover data starts at iOffset, and is (m_iIncomingBufferSize-iOffset) long.

	memmove( m_acIncomingBuffer, m_acIncomingBuffer + iOffset, m_iIncomingBufferSize-iOffset );
	m_iIncomingBufferSize -= iOffset;
	}


	const char* CMortalNetworkImpl::GetLastError()
	{
	return m_sLastError.c_str();
	}


	bool CMortalNetworkImpl::IsMaster()
	{
	return m_bMaster;
	}


	const char* CMortalNetworkImpl::GetRemoteUsername()
	{
	return "upi";
	}



	/*************************************************************************
	MSG RELATED METHODS
	*************************************************************************/



	/** All sent data must go through this method. It ensures the well-formed
	header for the data.
	The header itself looks like this:
	ID char
	Length Uint16
	Reserved char
	This is followed by as many bytes as the Length is.
	*/
	void CMortalNetworkImpl::SendRawData( char a_cID, const void* a_pData, int a_iLength )
	{
	+ CHECKCONNECTION;
	+
	char acBuffer[4];
	acBuffer[0] = a_cID;
	((Uint16)(acBuffer+1)) = SDL_SwapBE16( a_iLength );
	acBuffer[3] = 0;

	int iRetval = SDLNet_TCP_Send( m_poSocket, &acBuffer, 4 );
	if ( iRetval != 4 ) DISCONNECTONCOMMUNICATIONERROR;

	if ( a_iLength )
	{
	iRetval = SDLNet_TCP_Send( m_poSocket, (void*) a_pData, a_iLength );
	if (iRetval != a_iLength ) DISCONNECTONCOMMUNICATIONERROR;
	}
	}


	#define MAXSTRINGLENGTH 900





	void CMortalNetworkImpl::SendMsg( const char* a_pcMsg )
	{
	CHECKCONNECTION;

	int iMsgLen = strlen( a_pcMsg ) + 1;
	if ( iMsgLen > MAXSTRINGLENGTH )
	{
	// Will not be 0 terminated if exceeds length!
	iMsgLen = MAXSTRINGLENGTH;
	}
	SendRawData( 'M', a_pcMsg, iMsgLen );
	}

	void CMortalNetworkImpl::ReceiveMsg( void* a_pData, int a_iLength )
	{
	if ( a_iLength < 1 \|\| a_iLength > MAXSTRINGLENGTH ) DISCONNECTONCOMMUNICATIONERROR;

	char* acData = (char*) a_pData;
	acData[ a_iLength-1 ] = 0; // Last char should be 0, just making sure..

	m_asMsgs.push_back( acData );
	}


	bool CMortalNetworkImpl::IsMsgAvailable()
	{
	return m_asMsgs.size() > 0;
	}

	const char* CMortalNetworkImpl::GetMsg()
	{
	static std::string sLastMsg;
	if ( IsMsgAvailable() )
	{
	sLastMsg = m_asMsgs.front();
	m_asMsgs.pop_front();
	return sLastMsg.c_str();
	}
	return NULL;
	}




	/*************************************************************************
	CHARACTER SELECTION RELATED METHODS
	*************************************************************************/




	bool CMortalNetworkImpl::IsRemoteFighterAvailable( FighterEnum a_enFighter )
	{
	- return true;
	+ if ( 0 == a_enFighter )
	+ {
	+ return false;
	+ }
	+
	+ // Check if we already have it cached.
	+ if ( std::find( m_aiAvailableRemoteFighters.begin(), m_aiAvailableRemoteFighters.end(), a_enFighter ) != m_aiAvailableRemoteFighters.end() )
	+ {
	+ return true;
	+ }
	+ if ( std::find( m_aiAvailableRemoteFighters.begin(), m_aiAvailableRemoteFighters.end(), -a_enFighter ) != m_aiAvailableRemoteFighters.end() )
	+ {
	+ return false;
	+ }
	+
	+ Uint32 iFighter = SDL_SwapBE32( a_enFighter );
	+ SendRawData( 'Q', &iFighter, sizeof(Uint32) );
	+
	+ for ( int i=0; i<100; ++i )
	+ {
	+ SDL_Delay(10);
	+ Update();
	+ if ( std::find( m_aiAvailableRemoteFighters.begin(), m_aiAvailableRemoteFighters.end(), a_enFighter ) != m_aiAvailableRemoteFighters.end() )
	+ {
	+ return true;
	+ }
	+ if ( std::find( m_aiAvailableRemoteFighters.begin(), m_aiAvailableRemoteFighters.end(), -a_enFighter ) != m_aiAvailableRemoteFighters.end() )
	+ {
	+ return false;
	+ }
	+ }
	+
	+ m_aiAvailableRemoteFighters.push_front( -a_enFighter );
	+ return false;
	+}
	+
	+void CMortalNetworkImpl::ReceiveRemoteFighterQuery( void* a_pData, int a_iLength )
	+{
	+ if ( a_iLength != sizeof(Uint32) ) DISCONNECTONCOMMUNICATIONERROR;
	+ FighterEnum iFighter = (FighterEnum) SDL_SwapBE32( ((Uint32)a_pData) );
	+
	+ bool bAvailable = g_oPlayerSelect.IsLocalFighterAvailable( iFighter );
	+ Uint32 iResponse = bAvailable ? iFighter : iFighter + 100000;
	+ debug( "ReceiveRemoteFighterQuery: %d -> %d\n", iFighter, iResponse );
	+ iResponse = SDL_SwapBE32( iResponse );
	+
	+ SendRawData( 'A', &iResponse, sizeof(Uint32) );
	+}
	+
	+void CMortalNetworkImpl::ReceiveRemoteFighterAvailable( void* a_pData, int a_iLength )
	+{
	+ if ( a_iLength != sizeof(Uint32) ) DISCONNECTONCOMMUNICATIONERROR;
	+ Uint32 iFighter = SDL_SwapBE32( ((Uint32)a_pData) );
	+ debug( "ReceiveRemoteFighterAvailable: %d\n", iFighter );
	+ if ( iFighter >= 100000 )
	+ {
	+ m_aiAvailableRemoteFighters.push_front( -(iFighter-100000) );
	+ }
	+ else
	+ {
	+ m_aiAvailableRemoteFighters.push_front( iFighter );
	+ }
	}




	+
	+
	void CMortalNetworkImpl::SendFighter( FighterEnum a_enFighter )
	{
	CHECKCONNECTION;

	Uint32 iFighter = SDL_SwapBE32( a_enFighter );
	SendRawData( 'F', &iFighter, sizeof (iFighter) );
	}

	void CMortalNetworkImpl::ReceiveFighter( void* a_pcData, int a_iLength )
	{
	Uint32 iFighter;
	if ( a_iLength != sizeof(iFighter) ) DISCONNECTONCOMMUNICATIONERROR;
	iFighter = ((Uint32)a_pcData);

	m_enRemoteFighter = (FighterEnum) SDL_SwapBE32( iFighter );
	debug( "ReceiveFighter: %d\n", m_enRemoteFighter );
	}

	FighterEnum CMortalNetworkImpl::GetRemoteFighter()
	{
	return m_enRemoteFighter;
	}




	void CMortalNetworkImpl::SendReady()
	{
	CHECKCONNECTION;

	SendRawData( 'R', NULL, 0 );
	}

	void CMortalNetworkImpl::ReceiveReady( void* a_pData, int a_iLength )
	{
	if ( a_iLength != 0 ) DISCONNECTONCOMMUNICATIONERROR;
	m_bRemoteReady = true;
	}

	bool CMortalNetworkImpl::IsRemoteSideReady()
	{
	return m_bRemoteReady;
	}



	+void CMortalNetworkImpl::SendGameParams( int a_iGameSpeed, int a_iGameTime, int a_iHitPoints )
	+{
	+ CHECKCONNECTION;
	+ if ( (int)m_oGameParams.iGameSpeed == a_iGameSpeed
	+ && (int)m_oGameParams.iGameTime == a_iGameTime
	+ && (int)m_oGameParams.iHitPoints == a_iHitPoints )
	+ {
	+ // Nothing to update.
	+ return;
	+ }
	+
	+ m_oGameParams.iGameSpeed = a_iGameSpeed;
	+ m_oGameParams.iGameTime = a_iGameTime;
	+ m_oGameParams.iHitPoints = a_iHitPoints;
	+
	+ SGameParams oPackage;
	+ oPackage.iGameSpeed = SDL_SwapBE32( a_iGameSpeed );
	+ oPackage.iGameTime = SDL_SwapBE32( a_iGameTime );
	+ oPackage.iHitPoints = SDL_SwapBE32( a_iHitPoints );
	+ SendRawData( 'P', &oPackage, sizeof(SGameParams) );
	+}
	+
	+void CMortalNetworkImpl::ReceiveGameParams( void* a_pData, int a_iLength )
	+{
	+ if ( a_iLength != sizeof(SGameParams) ) DISCONNECTONCOMMUNICATIONERROR;
	+
	+ SGameParams* poPackage = (SGameParams*) a_pData;
	+ if ( m_oGameParams.iGameSpeed != SDL_SwapBE32( poPackage->iGameSpeed ) )
	+ {
	+ m_oGameParams.iGameSpeed = SDL_SwapBE32( poPackage->iGameSpeed );
	+ m_asMsgs.push_back( GetGameSpeedString( m_oGameParams.iGameSpeed ) );
	+ }
	+ if ( m_oGameParams.iGameTime != SDL_SwapBE32( poPackage->iGameTime ) )
	+ {
	+ m_oGameParams.iGameTime = SDL_SwapBE32( poPackage->iGameTime );
	+ m_asMsgs.push_back( GetGameTimeString( m_oGameParams.iGameTime) );
	+ }
	+ if ( m_oGameParams.iHitPoints != SDL_SwapBE32( poPackage->iHitPoints ) )
	+ {
	+ m_oGameParams.iHitPoints = SDL_SwapBE32( poPackage->iHitPoints );
	+ m_asMsgs.push_back( GetHitPointsString( m_oGameParams.iHitPoints ) );
	+ }
	+}
	+
	+
	+

	/*************************************************************************
	GAME RELATED METHODS
	*************************************************************************/





	-void CMortalNetworkImpl::SynchStartRound()
	+bool CMortalNetworkImpl::SynchStartRound()
	{
	debug( "SynchStartRound STARTED.\n" );

	m_bSynchQueryResponse = false;

	// run until both sides manage to get a SYNCH

	+ int i=0;
	+
	while ( !m_bSynchQueryResponse )
	{
	- CHECKCONNECTION;
	SendRawData('S', NULL, 0);
	if ( !IsConnectionAlive() ) break;
	Update();
	- SDL_Delay(200);
	+ SDL_Delay(100);
	if ( !IsConnectionAlive() ) break;
	+ ++i;
	+
	+ if ( i == 10 )
	+ {
	+ debug( "Synch is slow...\n" );
	+ MortalNetworkResetMessages( true );
	+ MortalNetworkMessage( "Synching with remote side..." );
	+ MortalNetworkMessage( "Press any key to disconnect." );
	+ }
	+ if ( i > 10
	+ && MortalNetworkCheckKey() )
	+ {
	+ Stop();
	+ return false;
	+ }
	}

	if ( IsConnectionAlive() )
	{
	m_enState = NS_IN_GAME;
	m_bRoundOver = false;
	m_bGameOver = false;
	m_bRemoteReady = false;
	m_bSynchQueryResponse = false;
	+ m_iHurryupCode = -1;
	}

	+ return IsConnectionAlive();
	+
	debug( "SynchStartRound FINISHED.\n" );
	}










	void CMortalNetworkImpl::SendGameData( const char* a_pcGameData )
	{
	+ CHECKCONNECTION;
	+
	int iMsgLen = strlen( a_pcGameData ) + 1;
	if ( iMsgLen > MAXSTRINGLENGTH )
	{
	// Will not be 0 terminated if exceeds length!
	iMsgLen = MAXSTRINGLENGTH;
	}
	SendRawData( 'G', a_pcGameData, iMsgLen );
	}

	void CMortalNetworkImpl::ReceiveGameData( void* a_pData, int a_iLength )
	{
	if ( a_iLength < 1 \|\| a_iLength > MAXSTRINGLENGTH ) DISCONNECTONCOMMUNICATIONERROR;

	char* pcData = (char*) a_pData;
	pcData[ a_iLength-1 ] = 0; // Last char should be 0, just making sure..

	if ( pcData[0] )
	{
	m_sLatestGameData = pcData;
	}
	}

	const char* CMortalNetworkImpl::GetLatestGameData()
	{
	return m_sLatestGameData.c_str();
	}




	struct SKeystrokePackage
	{
	char cKey;
	bool bPressed;
	};

	void CMortalNetworkImpl::SendKeystroke( int a_iKey, bool a_bPressed )
	{
	+ CHECKCONNECTION;
	+
	SKeystrokePackage oPackage;
	oPackage.cKey = a_iKey;
	oPackage.bPressed = a_bPressed;

	SendRawData( 'K', &oPackage, sizeof( oPackage) );
	}

	void CMortalNetworkImpl::ReceiveKeystroke( void* a_pData, int a_iLength )
	{
	if ( a_iLength != (int)sizeof(SKeystrokePackage) ) DISCONNECTONCOMMUNICATIONERROR;
	SKeystrokePackage* poPackage = (SKeystrokePackage*) a_pData;

	m_aiKeystrokes.push_back( poPackage->cKey );
	m_abKeystrokes.push_back( poPackage->bPressed );
	}

	bool CMortalNetworkImpl::GetKeystroke( int& a_riOutKey, bool& a_rbOutPressed )
	{
	if ( m_aiKeystrokes.size() == 0 )
	{
	return false;
	}
	a_riOutKey = m_aiKeystrokes.front();
	a_rbOutPressed = m_abKeystrokes.front();
	m_aiKeystrokes.pop_front();
	m_abKeystrokes.pop_front();

	debug( "GetKeystroke: %d, %d\n", a_riOutKey, a_rbOutPressed );
	return true;
	}



	struct SGameTimePackage
	{
	int iGameTime;
	int iGamePhase;
	};

	void CMortalNetworkImpl::SendGameTime( int a_iGameTime, int a_iGamePhase )
	{
	+ CHECKCONNECTION;
	+
	if ( a_iGameTime == m_iGameTime
	&& a_iGamePhase == m_iGamePhase )
	{
	return; // Nothing to update, the other side already knows.
	}

	SGameTimePackage oPackage;
	m_iGameTime = a_iGameTime;
	m_iGamePhase = a_iGamePhase;
	oPackage.iGameTime = SDL_SwapBE32( a_iGameTime );
	oPackage.iGamePhase = SDL_SwapBE32( a_iGamePhase );

	SendRawData( 'T', &oPackage, sizeof(SGameTimePackage) );
	}

	void CMortalNetworkImpl::ReceiveGameTime( void* a_pData, int a_iLength )
	{
	if ( a_iLength != sizeof(SGameTimePackage) ) DISCONNECTONCOMMUNICATIONERROR;
	SGameTimePackage* poPackage = (SGameTimePackage*) a_pData;

	m_iGameTime = SDL_SwapBE32( poPackage->iGameTime );
	m_iGamePhase = SDL_SwapBE32( poPackage->iGamePhase );
	}

	int CMortalNetworkImpl::GetGameTime()
	{
	return m_iGameTime;
	}

	int CMortalNetworkImpl::GetGamePhase()
	{
	return m_iGamePhase;
	}




	+void CMortalNetworkImpl::SendHurryup( int a_iHurryUpCode )
	+{
	+ CHECKCONNECTION;
	+ int iPackage = SDL_SwapBE32( a_iHurryUpCode );
	+ SendRawData( 'H', &iPackage, sizeof(int) );
	+}
	+
	+void CMortalNetworkImpl::ReceiveHurryup( void* a_pData, int a_iLength )
	+{
	+ if ( a_iLength != sizeof(int) ) DISCONNECTONCOMMUNICATIONERROR;
	+ m_iHurryupCode = SDL_SwapBE32( ((int)a_pData) );
	+}
	+
	+int CMortalNetworkImpl::GetHurryup()
	+{
	+ int iRetval = m_iHurryupCode;
	+ m_iHurryupCode = -1;
	+ return iRetval;
	+}
	+
	+
	+
	+
	struct SRoundOrder
	{
	int iWhoWon;
	bool bGameOver;
	};

	void CMortalNetworkImpl::SendRoundOver( int a_iWhoWon, bool a_bGameOver )
	{
	+ CHECKCONNECTION;
	SRoundOrder oPackage;

	oPackage.iWhoWon = a_iWhoWon;
	oPackage.bGameOver = a_bGameOver;
	SendRawData( 'O', &oPackage, sizeof(SRoundOrder) );

	if ( a_bGameOver )
	{
	m_enState = NS_CHARACTER_SELECTION;
	}
	}

	void CMortalNetworkImpl::ReceiveRoundOver( void* a_pData, int a_iLength )
	{
	if ( a_iLength != sizeof(SRoundOrder) ) DISCONNECTONCOMMUNICATIONERROR;
	SRoundOrder* poPackage = (SRoundOrder*) a_pData;
	m_iWhoWon = poPackage->iWhoWon;
	m_bGameOver = poPackage->bGameOver;
	m_bRoundOver = true;
	}

	bool CMortalNetworkImpl::IsRoundOver()
	{
	return m_bRoundOver;
	}

	bool CMortalNetworkImpl::IsGameOver()
	{
	return m_bGameOver;
	}

	int CMortalNetworkImpl::GetWhoWon()
	{
	return m_iWhoWon;
	}


	diff --git a/src/MortalNetworkImpl.h b/src/MortalNetworkImpl.h
	index 8e50745..e1fe4ee 100644
	--- a/src/MortalNetworkImpl.h
	+++ b/src/MortalNetworkImpl.h
	@@ -1,126 +1,144 @@
	/***************************************************************************
	MortalNetworkImpl.h - description
	-------------------
	begin : Sun Jan 25 2004
	copyright : (C) 2004 by upi
	email : upi@feel
	***************************************************************************/

	#ifndef MORTALNETWORKIMPL_H
	#define MORTALNETWORKIMPL_H


	#include "MortalNetwork.h"
	#include "SDL_net.h"
	#include <string>
	#include <list>

	+
	+typedef std::list<int> TIntList;
	+typedef std::list<std::string> TStringList;
	+

	class CMortalNetworkImpl: public CMortalNetwork
	{
	public:
	CMortalNetworkImpl();
	virtual ~CMortalNetworkImpl();

	// Connection's lifecycle

	bool Start( const char* a_pcServerName );
	void Stop(); // Disconnect
	bool IsConnectionAlive(); // Is the connection still good?
	void Update(); // Read network traffic. Might get disconnected...
	const char* GetLastError();
	bool IsMaster(); // Am I Master or Slave?

	// Msg related methods

	const char* GetRemoteUsername(); // This is the name that is passed upon connection.
	void SendMsg( const char* a_pcMsg ); // Prompt the user for a line of chat text
	bool IsMsgAvailable(); // Returns true is a chatline has arrived
	const char* GetMsg(); // The next chatline, or NULL if there are no more.

	// Charater Selection methods

	bool IsRemoteFighterAvailable( FighterEnum a_enFighter ); // Does the other computer have fighter X installed?
	FighterEnum GetRemoteFighter(); // Returns the latest fighter chosen by the remote side.
	bool IsRemoteSideReady(); // The other player is finished choosing.

	void SendFighter( FighterEnum a_enFighter ); // Let the other side know that I switched to fighter X.
	void SendReady(); // Let the other side know that I am ready.
	+ void SendGameParams( int a_iGameSpeed, int a_iGameTime, int a_iHitPoints );

	// Game methods

	- void SynchStartRound();
	+ bool SynchStartRound();
	void SendGameData( const char* a_pcGameData );
	const char* GetLatestGameData();
	+
	void SendKeystroke( int a_iKey, bool a_bPressed );
	bool GetKeystroke( int& a_riOutKey, bool& a_rbPressed );

	void SendGameTime( int a_iGameTime, int a_iGamePhase );
	int GetGameTime();
	int GetGamePhase();

	+ void SendHurryup( int a_iHurryUpCode );
	+ int GetHurryup() ;
	+
	void SendRoundOver( int a_iWhoWon, bool a_bGameOver );
	int GetWhoWon();
	bool IsRoundOver();
	bool IsGameOver();

	protected:
	void SendRawData( char a_cID, const void* a_pData, int a_iLength );

	- //void InternalSendString( const char* a_pcText, char a_cID );
	- //char* InternalReceiveString( void* a_pData, int a_iLength, int& a_riOutLength );
	-
	void ReceiveMsg( void* a_pData, int a_iLength );
	void ReceiveGameData( void* a_pData, int a_iLength );
	void ReceiveKeystroke( void* a_pData, int a_iLength );
	void ReceiveFighter( void* a_pData, int a_iLength );
	void ReceiveReady( void* a_pData, int a_iLength );
	void ReceiveRoundOver( void* a_pData, int a_iLength );
	void ReceiveGameTime( void* a_pData, int a_iLength );
	-
	+ void ReceiveHurryup( void* a_pData, int a_iLength );
	+ void ReceiveRemoteFighterAvailable( void* a_pData, int a_iLength );
	+ void ReceiveRemoteFighterQuery( void* a_pData, int a_iLength );
	+ void ReceiveGameParams( void* a_pData, int a_iLength );
	+
	protected:
	bool m_bNetworkAvailable;

	enum TNetworkState
	{
	NS_DISCONNECTED,
	NS_CHARACTER_SELECTION,
	NS_IN_GAME,
	};
	-
	+
	TNetworkState m_enState;
	bool m_bServer;
	bool m_bMaster;
	TCPsocket m_poSocket;
	SDLNet_SocketSet m_poSocketSet;

	char m_acIncomingBuffer[2048];
	int m_iIncomingBufferSize;

	std::string m_sLastError;

	- std::list<std::string> m_asMsgs;
	+ TStringList m_asMsgs;

	// GAME DATA

	+ TIntList m_aiAvailableRemoteFighters;
	FighterEnum m_enRemoteFighter;
	bool m_bRemoteReady;
	+ struct SGameParams
	+ {
	+ Uint32 iGameTime;
	+ Uint32 iGameSpeed;
	+ Uint32 iHitPoints;
	+ } m_oGameParams;

	std::string m_sLatestGameData;
	- std::list<int> m_aiKeystrokes;
	- std::list<int> m_abKeystrokes;
	+ TIntList m_aiKeystrokes;
	+ TIntList m_abKeystrokes;

	bool m_bRoundOver;
	int m_iWhoWon;
	bool m_bGameOver;
	int m_iGameTime;
	int m_iGamePhase;
	+ int m_iHurryupCode;

	// REMOTE QUERY RESPONSES

	bool m_bSynchQueryResponse;
	};


	#endif // MORTALNETWORKIMPL_H

	diff --git a/src/PlayerSelect.cpp b/src/PlayerSelect.cpp
	index e939a5d..253243d 100644
	--- a/src/PlayerSelect.cpp
	+++ b/src/PlayerSelect.cpp
	@@ -1,668 +1,702 @@
	/***************************************************************************
	PlayerSelect.cpp - description
	-------------------
	begin : Sun Dec 8 2002
	copyright : (C) 2002 by upi
	email : upi@apocalypse.rulez.org
	***************************************************************************/

	#include <stdio.h>

	#include "PlayerSelect.h"

	#include "SDL.h"
	#include "SDL_video.h"
	#include "SDL_image.h"
	#include "sge_primitives.h"
	#include "sge_surface.h"

	#include "common.h"
	#include "Audio.h"
	#include "sge_bm_text.h"
	#include "gfx.h"
	#include "RlePack.h"
	#include "Backend.h"
	#include "State.h"
	#include "MortalNetwork.h"
	#include "Chooser.h"
	#include "sge_tt_text.h"
	#include "TextArea.h"


	#ifndef NULL
	#define NULL 0
	#endif


	/***************************************************************************
	PUBLIC EXPORTED VARIABLES
	***************************************************************************/


	PlayerSelect g_oPlayerSelect;


	/***************************************************************************
	PRIVATE VARIABLES (perl variable space)
	***************************************************************************/


	FighterEnum ChooserCells[5][4] = {
	{ ZOLI, UPI, CUMI, SIRPI },
	{ ULMAR, MACI, GRIZLI, DESCANT },
	{ DANI, AMBRUS, BENCE, SURBA },
	{ (FighterEnum)100, (FighterEnum)101, (FighterEnum)102, (FighterEnum)103 },
	{ (FighterEnum)104, (FighterEnum)105, KINGA, MISI }
	};

	FighterEnum ChooserCellsChat[4][5] = {
	{ ZOLI, UPI, CUMI, SIRPI, ULMAR },
	{ MACI, BENCE, GRIZLI, DESCANT, SURBA },
	{ DANI, AMBRUS, (FighterEnum)100, (FighterEnum)102, KINGA },
	{ (FighterEnum)104, (FighterEnum)105, (FighterEnum)103, (FighterEnum)101, MISI },
	};



	PlayerSelect::PlayerSelect()
	{
	for ( int i=0; i<2; ++i )
	{
	m_aoPlayers[i].m_enFighter = UNKNOWN;
	m_aoPlayers[i].m_enTint = NO_TINT;
	m_aoPlayers[i].m_poPack = NULL;
	}

	m_iP1 = 0;
	m_iP2 = 3;
	}


	const PlayerInfo& PlayerSelect::GetPlayerInfo( int a_iPlayer )
	{
	return m_aoPlayers[ a_iPlayer ? 1 : 0 ];
	}


	const char* PlayerSelect::GetFighterName( int a_iPlayer )
	{
	return m_aoPlayers[ a_iPlayer ? 1 : 0 ].m_sFighterName.c_str();
	}


	int PlayerSelect::GetFighterNameWidth( int a_iPlayer )
	{
	return m_aiFighterNameWidth[ a_iPlayer ? 1 : 0 ];
	}


	bool PlayerSelect::IsFighterAvailable( FighterEnum a_enFighter )
	+{
	+ if ( a_enFighter <= UNKNOWN )
	+ {
	+ return false;
	+ }
	+
	+ bool bLocalAvailable = IsLocalFighterAvailable( a_enFighter );
	+
	+ if ( !IsNetworkGame() \|\| !bLocalAvailable )
	+ {
	+ return bLocalAvailable;
	+ }
	+
	+ // Check the remote site
	+ return g_poNetwork->IsRemoteFighterAvailable( a_enFighter );
	+}
	+
	+
	+bool PlayerSelect::IsLocalFighterAvailable( FighterEnum a_enFighter )
	{
	if ( a_enFighter <= UNKNOWN )
	{
	return false;
	}

	g_oBackend.PerlEvalF("GetFighterStats(%d);", a_enFighter);
	const char* pcDatafile = g_oBackend.GetPerlString("Datafile");
	- return ( pcDatafile && *pcDatafile );
	+ return pcDatafile && *pcDatafile;
	}



	/** LoadFighter simply looks up the filename associated with the given
	fighter, loads it, and returns the RlePack.

	\return The freshly loaded RlePack, or NULL if it could not be loaded.
	*/

	RlePack* PlayerSelect::LoadFighter( FighterEnum m_enFighter ) // static
	{
	char a_pcFilename[FILENAME_MAX+1];
	const char* s;

	g_oBackend.PerlEvalF( "GetFighterStats(%d);", m_enFighter );
	s = g_oBackend.GetPerlString( "Datafile" );

	strcpy( a_pcFilename, DATADIR );
	strcat( a_pcFilename, "/characters/" );
	strcat( a_pcFilename, s );

	RlePack* pack = new RlePack( a_pcFilename, COLORSPERPLAYER );
	if ( pack->Count() <= 0 )
	{
	debug( "Couldn't load RlePack: '%s'\n", a_pcFilename );
	delete pack;
	return NULL;
	}

	return pack;
	}



	/** SetPlayer loads the given fighter for the given player.

	The RlePack is loaded first. If that succeeds, then the perl backend is
	set too. The tint and palette of both players are set. */

	void PlayerSelect::SetPlayer( int a_iPlayer, FighterEnum a_enFighter )
	{
	if ( a_iPlayer ) a_iPlayer = 1; // It's 0 or 1.

	if ( m_aoPlayers[a_iPlayer].m_enFighter == a_enFighter )
	{
	return;
	}
	if ( !IsFighterAvailable( a_enFighter ) )
	{
	return;
	}

	int iOffset = a_iPlayer ? COLOROFFSETPLAYER2 : COLOROFFSETPLAYER1;
	RlePack* poPack = LoadFighter( a_enFighter );
	poPack->OffsetSprites( iOffset );

	if ( NULL == poPack )
	{
	debug( "SetPlayer(%d,%d): Couldn't load RlePack\n", a_iPlayer, a_enFighter );
	return;
	}

	delete m_aoPlayers[a_iPlayer].m_poPack;
	m_aoPlayers[a_iPlayer].m_poPack = poPack;
	m_aoPlayers[a_iPlayer].m_enFighter = a_enFighter;

	g_oBackend.PerlEvalF( "SetPlayerNumber(%d,%d);", a_iPlayer, a_enFighter );
	m_aoPlayers[a_iPlayer].m_sFighterName = g_oBackend.GetPerlString( "PlayerName" );
	m_aiFighterNameWidth[a_iPlayer] = sge_BF_TextSize( fastFont, GetFighterName(a_iPlayer) ).w;

	TintEnum enTint = NO_TINT;

	if ( m_aoPlayers[0].m_enFighter == m_aoPlayers[1].m_enFighter )
	{
	enTint = TintEnum( (rand() % 4) + 1 );
	}
	SetTint( 1, enTint );
	m_aoPlayers[a_iPlayer].m_poPack->ApplyPalette();
	}



	void PlayerSelect::SetTint( int a_iPlayer, TintEnum a_enTint )
	{
	m_aoPlayers[a_iPlayer].m_enTint = a_enTint;
	if ( m_aoPlayers[a_iPlayer].m_poPack )
	{
	m_aoPlayers[a_iPlayer].m_poPack->SetTint( a_enTint );
	m_aoPlayers[a_iPlayer].m_poPack->ApplyPalette();
	}
	}



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



	FighterEnum PlayerSelect::GetFighterCell( int a_iIndex )
	{
	if ( IsNetworkGame() )
	{
	return ChooserCellsChat[a_iIndex/m_iChooserCols][a_iIndex%m_iChooserCols];
	}
	else
	{
	return ChooserCells[a_iIndex/m_iChooserCols][a_iIndex%m_iChooserCols];
	}
	}



	void PlayerSelect::HandleKey( int a_iPlayer, int a_iKey )
	{
	// If we are in network mode, all keys count as the local player's...
	if ( IsNetworkGame() )
	{
	a_iPlayer = g_poNetwork->IsMaster() ? 0 : 1;
	}

	int& riP = a_iPlayer ? m_iP2 : m_iP1;
	int iOldP = riP;

	bool& rbDone = a_iPlayer ? m_bDone2 : m_bDone1;
	if ( rbDone )
	{
	return;
	}

	switch ( a_iKey )
	{
	case 0: // up
	if ( riP >= m_iChooserCols ) riP -= m_iChooserCols;
	break;
	case 1: // down
	if ( (riP/m_iChooserCols) < (m_iChooserRows-1) ) riP += m_iChooserCols;
	break;
	case 2: // left
	if ( (riP % m_iChooserCols) > 0 ) riP--;
	break;
	case 3: // right
	if ( (riP % m_iChooserCols) < (m_iChooserCols-1) ) riP++;
	break;
	default:
	if ( IsFighterAvailable( GetFighterCell(riP) ) )
	{
	Audio->PlaySample("magic.voc");

	rbDone = true;
	g_oBackend.PerlEvalF( "PlayerSelected(%d);", a_iPlayer );
	if ( IsNetworkGame() )
	{
	g_poNetwork->SendFighter( GetFighterCell(riP) );
	g_poNetwork->SendReady();
	}
	return;
	}
	}

	if ( iOldP != riP )
	{
	Audio->PlaySample("strange_quack.voc");
	if ( IsFighterAvailable( GetFighterCell(riP) ) )
	{
	if ( IsNetworkGame() )
	{
	g_poNetwork->SendFighter( GetFighterCell(riP) );
	}
	SetPlayer( a_iPlayer, GetFighterCell(riP) );
	}
	}
	}


	void PlayerSelect::HandleNetwork()
	{
	g_poNetwork->Update();

	bool bUpdateText = false;
	while ( g_poNetwork->IsMsgAvailable() )
	{
	m_poTextArea->AddString( g_poNetwork->GetMsg(), C_YELLOW );
	bUpdateText = true;
	}
	if ( bUpdateText )
	{
	+ Audio->PlaySample("pop.wav");
	m_poTextArea->Redraw();
	}

	bool bMaster = g_poNetwork->IsMaster();
	int iPlayer = bMaster ? 1 : 0;
	int& riP = bMaster ? m_iP2 : m_iP1;
	bool& rbDone = bMaster ? m_bDone2 : m_bDone1;

	if ( rbDone )
	{
	return;
	}

	int iOldP = riP;
	FighterEnum enOldFighter = GetFighterCell(iOldP);
	FighterEnum enRemoteFighter = g_poNetwork->GetRemoteFighter();

	if ( enOldFighter != enRemoteFighter
	&& enRemoteFighter != UNKNOWN )
	{
	Audio->PlaySample("strange_quack.voc");
	SetPlayer( iPlayer, enRemoteFighter );
	int i, j;
	for ( i=0; i<m_iChooserRows; ++i )
	{
	for ( int j=0; j<m_iChooserCols; ++j )
	{
	if ( ChooserCellsChat[i][j] == enRemoteFighter )
	{
	riP = i * m_iChooserCols + j;
	break;
	}
	}
	}
	}

	bool bDone = g_poNetwork->IsRemoteSideReady();
	if ( bDone )
	{
	rbDone = true;
	Audio->PlaySample("magic.voc");
	g_oBackend.PerlEvalF( "PlayerSelected(%d);", iPlayer );
	}
	}


	void PlayerSelect::DrawRect( int a_iPos, int a_iColor )
	{
	int iRow = a_iPos / m_iChooserCols;
	int iCol = a_iPos % m_iChooserCols;
	SDL_Rect r, r1;

	r.x = m_iChooserLeft + iCol * m_iChooserWidth;
	r.y = m_iChooserTop + iRow * m_iChooserHeight;
	r.w = m_iChooserWidth + 5;
	r.h = 5;
	r1 = r;
	SDL_FillRect( gamescreen, &r1, a_iColor );

	r.y += m_iChooserHeight;
	r1 = r;
	SDL_FillRect( gamescreen, &r1, a_iColor );

	r.y -= m_iChooserHeight;
	r.w = 5;
	r.h = m_iChooserHeight + 5;
	r1 = r;
	SDL_FillRect( gamescreen, &r1, a_iColor );

	r.x += m_iChooserWidth;
	r1 = r;
	SDL_FillRect( gamescreen, &r1, a_iColor );
	}


	-void PlayerSelect::CheckPlayer( SDL_Surface* a_poBackground, int a_iRow, int a_iCol )
	+void PlayerSelect::CheckPlayer( SDL_Surface* a_poBackground, int a_iRow, int a_iCol, int a_iColor )
	{
	int x1, y1;

	x1 = m_iChooserLeft + a_iCol * m_iChooserWidth +5;
	y1 = m_iChooserTop + a_iRow * m_iChooserHeight +5;

	- sge_Line(a_poBackground, x1+5, y1+5, x1 + m_iChooserWidth-10, y1 + m_iChooserHeight-10, 252);
	- sge_Line(a_poBackground, x1 + m_iChooserWidth-10, y1+5, x1+5, y1 + m_iChooserHeight-10, 252);
	+ sge_Line(a_poBackground, x1+5, y1+5, x1 + m_iChooserWidth-10, y1 + m_iChooserHeight-10, a_iColor);
	+ sge_Line(a_poBackground, x1 + m_iChooserWidth-10, y1+5, x1+5, y1 + m_iChooserHeight-10, a_iColor);
	x1++;
	- sge_Line(a_poBackground, x1+5, y1+5, x1 + m_iChooserWidth-10, y1 + m_iChooserHeight-10, 252);
	- sge_Line(a_poBackground, x1 + m_iChooserWidth-10, y1+5, x1+5, y1 + m_iChooserHeight-10, 252);
	+ sge_Line(a_poBackground, x1+5, y1+5, x1 + m_iChooserWidth-10, y1 + m_iChooserHeight-10, a_iColor);
	+ sge_Line(a_poBackground, x1 + m_iChooserWidth-10, y1+5, x1+5, y1 + m_iChooserHeight-10, a_iColor);
	y1++;
	- sge_Line(a_poBackground, x1+5, y1+5, x1 + m_iChooserWidth-10, y1 + m_iChooserHeight-10, 252);
	- sge_Line(a_poBackground, x1 + m_iChooserWidth-10, y1+5, x1+5, y1 + m_iChooserHeight-10, 252);
	+ sge_Line(a_poBackground, x1+5, y1+5, x1 + m_iChooserWidth-10, y1 + m_iChooserHeight-10, a_iColor);
	+ sge_Line(a_poBackground, x1 + m_iChooserWidth-10, y1+5, x1+5, y1 + m_iChooserHeight-10, a_iColor);
	x1--;
	- sge_Line(a_poBackground, x1+5, y1+5, x1 + m_iChooserWidth-10, y1 + m_iChooserHeight-10, 252);
	- sge_Line(a_poBackground, x1 + m_iChooserWidth-10, y1+5, x1+5, y1 + m_iChooserHeight-10, 252);
	+ sge_Line(a_poBackground, x1+5, y1+5, x1 + m_iChooserWidth-10, y1 + m_iChooserHeight-10, a_iColor);
	+ sge_Line(a_poBackground, x1 + m_iChooserWidth-10, y1+5, x1+5, y1 + m_iChooserHeight-10, a_iColor);
	}


	void PlayerSelect::DoPlayerSelect()
	{
	// 1. Set up: Load background, mark unavailable fighters

	bool bNetworkMode = IsNetworkGame();

	if ( IsNetworkGame() )
	{
	m_iChooserLeft = 158;
	m_iChooserTop = 74;
	m_iChooserHeight = 64;
	m_iChooserWidth = 64;
	m_iChooserRows = 4;
	m_iChooserCols = 5;
	}
	else
	{
	m_iChooserLeft = 158;
	m_iChooserTop = 74;
	m_iChooserHeight = 80;
	m_iChooserWidth = 80;
	m_iChooserRows = 5;
	m_iChooserCols = 4;
	}

	SDL_FillRect( gamescreen, NULL, C_BLACK );
	SDL_Flip( gamescreen );

	SDL_Surface* poBackground = LoadBackground( IsNetworkGame() ? "PlayerSelect_chat.png" : "PlayerSelect.png", 111 );

	DrawGradientText( "Choose A Fighter Dammit", titleFont, 10, poBackground );
	//g_oChooser.Draw( poBackground );
	-
	+
	int i, j;
	for ( i=0; i<m_iChooserRows; ++i )
	{
	for ( int j=0; j<m_iChooserCols; ++j )
	{
	if ( IsNetworkGame() )
	{
	- if ( !IsFighterAvailable(ChooserCellsChat[i][j]) &&
	+ if ( !IsLocalFighterAvailable(ChooserCellsChat[i][j]) &&
	+ UNKNOWN != ChooserCellsChat[i][j] )
	+ {
	+ CheckPlayer( poBackground, i, j, C_LIGHTRED );
	+ }
	+ else if ( !IsFighterAvailable(ChooserCellsChat[i][j]) &&
	UNKNOWN != ChooserCellsChat[i][j] )
	{
	- CheckPlayer( poBackground, i, j );
	+ CheckPlayer( poBackground, i, j, C_LIGHTBLUE );
	}
	}
	else
	{
	if ( !IsFighterAvailable(ChooserCells[i][j]) &&
	UNKNOWN != ChooserCells[i][j] )
	{
	- CheckPlayer( poBackground, i, j );
	+ CheckPlayer( poBackground, i, j, C_LIGHTRED );
	}
	}
	}
	}

	for ( i=0; i<2; ++i )
	{
	if ( m_aoPlayers[i].m_poPack ) m_aoPlayers[i].m_poPack->ApplyPalette();
	}

	SetPlayer( 0, GetFighterCell(m_iP1) );
	SetPlayer( 1, GetFighterCell(m_iP2) );

	+ if ( IsNetworkGame() && g_poNetwork->IsMaster() )
	+ {
	+ g_poNetwork->SendGameParams( g_oState.m_iGameSpeed, g_oState.m_iGameTime, g_oState.m_iHitPoints );
	+ }
	+
	// 2. Run selection screen

	g_oBackend.PerlEvalF( "SelectStart();" );

	m_bDone1 = m_bDone2 = false;

	int thisTick, lastTick, gameSpeed;

	gameSpeed = 12 ;
	thisTick = SDL_GetTicks() / gameSpeed;
	lastTick = thisTick - 1;

	i = 0;
	int over = 0;

	int iCourtain = 0;
	int iCourtainSpeed = 0;
	int iCourtainTime = 80;

	SDL_Event event;

	// Chat is 165:350 - 470:470
	char acMsg[256];
	sprintf( acMsg, "Press Enter to chat..." );
	bool bDoingChat = false;

	if ( IsNetworkGame() )
	{
	m_poReadline = new CReadline( IsNetworkGame() ? poBackground : NULL, impactFont,
	acMsg, strlen(acMsg), 256, 15, 465, 610, C_LIGHTCYAN, C_BLACK, 255 );
	m_poTextArea = new CTextArea( poBackground, impactFont, 15, 350, 610, 32*3 );
	}
	else
	{
	m_poReadline = NULL;
	m_poTextArea = NULL;
	}

	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. Advance as many ticks as necessary..

	if ( iCourtainTime > 0 )
	{
	int iAdvance = thisTick - lastTick;
	if ( iAdvance > 5 ) iAdvance = 5;

	if ( iCourtain + iCourtainSpeed * iCourtainTime /2 < 320 * 4 )
	iCourtainSpeed += iAdvance;
	else
	iCourtainSpeed -= iAdvance;

	iCourtain += iCourtainSpeed * iAdvance;
	iCourtainTime -= iAdvance;

	if ( iCourtainTime > 0 )
	{
	SDL_Rect oRect;
	oRect.x = 320 - iCourtain/4; oRect.y = 0;
	oRect.w = iCourtain / 2; oRect.h = gamescreen->h;
	if ( oRect.x < 0 ) oRect.x = 0;
	if ( oRect.w > gamescreen->w ) oRect.w = gamescreen->w;
	SDL_SetClipRect( gamescreen, &oRect );
	}
	else
	{
	SDL_SetClipRect( gamescreen, NULL );
	}
	}

	int iNumFrames = thisTick - lastTick;
	if ( iNumFrames>5 ) iNumFrames = 5;
	for ( i=0; i<iNumFrames; ++i )
	{
	g_oBackend.AdvancePerl();
	}
	lastTick = thisTick;

	while (SDL_PollEvent(&event))
	{
	if ( SDL_QUIT == event.type )
	{
	g_oState.m_bQuitFlag = true;
	break;
	}

	if ( bDoingChat )
	{
	// The chat thingy will handle this event.
	m_poReadline->HandleKeyEvent( event );
	int iResult = m_poReadline->GetResult();
	if ( iResult < 0 )
	{
	// Escape was pressed?
	m_poReadline->Clear();
	bDoingChat = false;
	}
	if ( iResult > 0 )
	{
	if ( strlen( acMsg ) )
	{
	g_poNetwork->SendMsg( acMsg );
	m_poTextArea->AddString( acMsg, C_WHITE );
	m_poTextArea->Redraw();
	m_poReadline->Clear();
	acMsg[0] = 0;
	m_poReadline->Restart( acMsg, strlen(acMsg), 256, C_LIGHTCYAN, C_BLACK, 255 );
	}
	else
	{
	m_poReadline->Clear();
	bDoingChat = false;
	}
	}
	continue;
	}

	switch (event.type)
	{
	case SDL_KEYDOWN:
	{
	if ( event.key.keysym.sym == SDLK_ESCAPE )
	{
	DoMenu( false );
	+ if ( IsNetworkGame() && g_poNetwork->IsMaster() )
	+ {
	+ g_poNetwork->SendGameParams( g_oState.m_iGameSpeed, g_oState.m_iGameTime, g_oState.m_iHitPoints );
	+ }
	break;
	}
	if ( IsNetworkGame() && bDoingChat == false &&
	(event.key.keysym.sym == SDLK_RETURN
	\|\| event.key.keysym.sym==SDLK_KP_ENTER) )
	{
	bDoingChat = true;
	acMsg[0] = 0;
	m_poReadline->Clear();
	m_poReadline->Restart( acMsg, strlen(acMsg), 256, C_LIGHTCYAN, C_BLACK, 255 );
	break;
	}
	for ( i=0; i<2; i++ )
	{
	for ( j=0; j<9; j++ )
	{
	if (g_oState.m_aiPlayerKeys[i][j] == event.key.keysym.sym)
	{
	DrawRect( m_iP1, 240 );
	DrawRect( m_iP2, 240 );
	HandleKey( i, j );
	}
	}
	}
	}
	break;
	} // switch statement
	} // Polling events

	if ( IsNetworkGame() )
	{
	HandleNetwork();
	}

	g_oBackend.ReadFromPerl();
	over = g_oBackend.m_iGameOver;

	SDL_BlitSurface( poBackground, NULL, gamescreen, NULL );
	if ( !m_bDone1) DrawRect( m_iP1, 250 );
	if ( !m_bDone2) DrawRect( m_iP2, 253 );

	for ( i=0; i<2; ++i )
	{
	- int iYOffset = bNetworkMode ? -120 : 0;
	+ int iYOffset = bNetworkMode ? -130 : 0;
	if ( g_oBackend.m_aoPlayers[i].m_iFrame )
	{
	m_aoPlayers[i].m_poPack->Draw(
	ABS(g_oBackend.m_aoPlayers[i].m_iFrame)-1,
	g_oBackend.m_aoPlayers[i].m_iX, g_oBackend.m_aoPlayers[i].m_iY + iYOffset,
	g_oBackend.m_aoPlayers[i].m_iFrame < 0 );
	}
	int x = ( m_iChooserLeft - m_aiFighterNameWidth[i] ) / 2;
	if ( x<10 ) x = 10;
	if ( i ) x = gamescreen->w - x - m_aiFighterNameWidth[i];

	sge_BF_textout( gamescreen, fastFont, GetFighterName(i),
	- x, IsNetworkGame() ? 10 : gamescreen->h - 30 + iYOffset );
	+ x, gamescreen->h - 30 + iYOffset );
	}
	-
	+
	SDL_Flip( gamescreen );
	-
	+
	if (over \|\| g_oState.m_bQuitFlag \|\| SState::IN_DEMO == g_oState.m_enGameMode) break;
	}

	delete m_poReadline;
	delete m_poTextArea;
	SDL_FreeSurface( poBackground );
	SDL_SetClipRect( gamescreen, NULL );
	return;
	}

	diff --git a/src/PlayerSelect.h b/src/PlayerSelect.h
	index 5da23aa..e74e8fd 100644
	--- a/src/PlayerSelect.h
	+++ b/src/PlayerSelect.h
	@@ -1,96 +1,97 @@
	/***************************************************************************
	PlayerSelect.h - description
	-------------------
	begin : 2003-09-05
	copyright : (C) 2003 by upi
	email : upi@apocalypse.rulez.org
	***************************************************************************/


	#ifndef PLAYERSELECT_H
	#define PLAYERSELECT_H

	#define COLORSPERPLAYER 64
	#define COLOROFFSETPLAYER1 112
	#define COLOROFFSETPLAYER2 (COLOROFFSETPLAYER1+64)



	#include "FighterEnum.h"
	#include <string>

	class RlePack;
	struct SDL_Surface;
	class CTextArea;
	class CReadline;

	/** PlayerInfo structure stores information about a PLAYER.

	In OpenMortal, the term PLAYER refers to one of the two guys playing the
	game, as opposed to FIGHTER, which refers to one of the many playable
	characters.

	PlayerInfo stores: the player's selected fighter, the fighters tint and
	RlePack. */

	struct PlayerInfo
	{
	FighterEnum m_enFighter;
	TintEnum m_enTint;
	RlePack* m_poPack;
	std::string m_sFighterName;
	};



	/** This class implements services that allows players to select their
	fighters. It also stores info about which fighter is available, and
	allows other parts of the program to programmatically assign a fighter
	to a player, and set fighter tints (this is used by e.g. the "frozen"
	effect.) */

	class PlayerSelect
	{
	public:
	PlayerSelect();

	const PlayerInfo& GetPlayerInfo( int a_iPlayer );
	const char* GetFighterName( int a_iPlayer );
	int GetFighterNameWidth( int a_iPlayer );

	void DoPlayerSelect();
	void SetPlayer( int a_iPlayer, FighterEnum a_enFighter );
	void SetTint( int a_iPlayer, TintEnum a_enFighter );
	bool IsFighterAvailable( FighterEnum a_enFighter );
	+ bool IsLocalFighterAvailable( FighterEnum a_enFighter );

	protected:

	void HandleKey( int a_iPlayer, int a_iKey );
	void HandleNetwork();
	void DrawRect( int a_iPos, int a_iColor );
	- void CheckPlayer( SDL_Surface* a_poBackground, int a_iRow, int a_iCol );
	+ void CheckPlayer( SDL_Surface* a_poBackground, int a_iRow, int a_iCol, int a_iColor );
	static RlePack* LoadFighter( FighterEnum m_enFighter );
	bool IsNetworkGame();
	FighterEnum GetFighterCell( int a_iIndex );

	protected:
	PlayerInfo m_aoPlayers[2];
	int m_iP1, m_iP2; // Chooser cells for player 1 and 2
	bool m_bDone1, m_bDone2; // Has player n chosen a player?
	int m_aiFighterNameWidth[2];

	int m_iChooserLeft;
	int m_iChooserTop;
	int m_iChooserWidth;
	int m_iChooserHeight;
	int m_iChooserRows;
	int m_iChooserCols;

	CTextArea* m_poTextArea;
	CReadline* m_poReadline;
	};


	extern PlayerSelect g_oPlayerSelect;

	#endif // PLAYERSELECT_H
	diff --git a/src/main.cpp b/src/main.cpp
	index 3e92278..2c90f9c 100644
	--- a/src/main.cpp
	+++ b/src/main.cpp
	@@ -1,383 +1,383 @@
	/***************************************************************************
	main.cpp - description
	-------------------
	begin : Wed Aug 22 10:18:47 CEST 2001
	copyright : (C) 2001 by upi
	email : upi@apocalypse.rulez.org
	***************************************************************************/


	#ifdef HAVE_CONFIG_H
	#include <config.h>
	#endif

	#include "PlayerSelect.h"

	#include "SDL_video.h"
	#include "sge_tt_text.h"
	#include "sge_bm_text.h"
	#include "sge_surface.h"
	#include "SDL.h"
	#include "SDL_image.h"

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

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


	#ifdef _WINDOWS

	#undef DATADIR // GRRR.. windows keyword...
	#include <windows.h>
	#define DATADIR "../data"

	#endif

	_sge_TTFont* inkFont;
	_sge_TTFont* impactFont;
	_sge_TTFont* titleFont;
	sge_bmpFont* fastFont;
	sge_bmpFont* creditsFont;
	sge_bmpFont* storyFont;

	SDL_Color Colors[] =
	{
	{ 0, 0, 0, 0 }, { 0, 0, 42, 0 }, { 0, 42, 0, 0 }, { 0, 42, 42, 0 },
	{ 42, 0, 0, 0 }, { 42, 0, 42, 0 }, { 63, 42, 0, 0 }, { 42, 42, 42, 0 },
	{ 21, 21, 21, 0 }, { 21, 21, 63, 0 }, { 21, 63, 21, 0 }, { 21, 63, 63, 0 },
	{ 63, 21, 21, 0 }, { 63, 21, 63, 0 }, { 63, 63, 21, 0 }, { 63, 63, 63, 0 }
	};


	void Complain( const char* a_pcError )
	{
	#ifdef _WINDOWS
	::MessageBoxA( 0, a_pcError, "OpenMortal", MB_ICONEXCLAMATION );
	#else
	fprintf( stderr, "%s", a_pcError );
	#endif
	}


	_sge_TTFont* LoadTTF( const char* a_pcFilename, int a_iSize )
	{
	std::string sPath = std::string(DATADIR) + "/fonts/" + a_pcFilename;
	_sge_TTFont* poFont = sge_TTF_OpenFont( sPath.c_str(), a_iSize );

	if ( NULL == poFont )
	{
	Complain( ("Couldn't load font: " + sPath).c_str() );
	}






	return poFont;
	}


	sge_bmpFont* LoadBMPFont( const char* a_pcFilename )
	{
	std::string sPath = std::string(DATADIR) + "/fonts/" + a_pcFilename;
	sge_bmpFont* poFont = sge_BF_OpenFont( sPath.c_str(), SGE_BFSFONT \| SGE_BFTRANSP );
	if ( NULL == poFont )
	{
	Complain( ("Couldn't load font: " + sPath).c_str() );
	}
	return poFont;
	}


	int init( int iFlags )
	{
	if (SDL_Init(SDL_INIT_VIDEO /\| SDL_INIT_AUDIO/) < 0)
	{
	fprintf(stderr, "Failed to initialize SDL: %s\n", SDL_GetError());
	return -1;
	}
	atexit(SDL_Quit);

	int d = SDL_VideoModeOK(640, 480, 8, iFlags);
	if (d == 0)
	{
	fprintf(stderr, "requested video mode not available\n");
	// return -1;
	}

	gamescreen = SDL_SetVideoMode(640, 480, 8, iFlags);
	if (gamescreen == NULL)
	{
	fprintf(stderr, "failed to set video mode: %s\n", SDL_GetError());
	return -1;
	}

	SDL_WM_SetCaption( "OpenMortal", "OpenMortal" );
	std::string sPath = std::string(DATADIR) + "/gfx/icon.png";
	SDL_WM_SetIcon(IMG_Load(sPath.c_str()), NULL);
	SDL_ShowCursor( SDL_DISABLE );

	for ( int i=0; i<16; ++i ) { Colors[i].r =4; Colors[i].g =4; Colors[i].b *=4; }
	SDL_SetColors( gamescreen, Colors, 256-16, 16 );

	if ( sge_TTF_Init() )
	{
	fprintf(stderr, "couldn't start ttf engine: %s\n", SDL_GetError());
	return -1;
	}

	sge_TTF_AAOff();

	inkFont = LoadTTF( "aardvark.ttf", 20 );
	if ( !inkFont ) return -1;
	impactFont = LoadTTF( "bradybun.ttf", 20 ); // gooddogc.ttf, 20
	if ( !impactFont ) return -1;
	titleFont = LoadTTF( "deadgrit.ttf", 48 ); // deadgrit.ttf, 48
	if ( !titleFont ) return -1;

	fastFont = LoadBMPFont( "brandybun3.png" );
	if ( !fastFont ) return -1;
	creditsFont = LoadBMPFont( "CreditsFont2.png" );//"fangfont.png" );
	if ( !creditsFont ) return -1;
	storyFont = LoadBMPFont( "glossyfont.png" );
	if ( !storyFont ) return -1;

	return 0;
	}


	int init2()
	{
	if ( !g_oBackend.Construct() )
	{

	fprintf(stderr, "couldn't start backend.\n" );
	return -1;
	}
	return 0;
	}





	int DrawMainScreen()
	{
	SDL_Surface* background = LoadBackground( "Mortal.png", 240 );
	SDL_Rect r;
	r.x = r.y = 0;

	std::string sStaffFilename = DATADIR;
	sStaffFilename += "/characters/STAFF.DAT";
	RlePack pack( sStaffFilename.c_str(), 240 );
	pack.ApplyPalette();
	//SDL_SetColors( gamescreen, pack.getPalette(), 0, 240 );
	SDL_BlitSurface( background, NULL, gamescreen, &r );
	SDL_Flip( gamescreen );

	char* filename[15] = {
	"Jacint.pl", "Jozsi.pl", "Agent.pl", "Mrsmith.pl",
	"Sleepy.pl", "Tejszin.pl",
	"UPi.pl", "Zoli.pl", "Ulmar.pl", "Bence.pl",
	"Descant.pl", "Grizli.pl", "Sirpi.pl", "Macy.pl", "Cumi.pl" };
	int x[14] = {
	0, 26, 67, 125, 159, 209,
	249, 289, 358, 397, 451, 489, 532, 161 };
	int y[14] = {
	5, 4, 5, 5, 5, 7,
	4, 0, 7, 5, 5, 6, 5, 243 };

	int i;

	g_oBackend.PerlEvalF( "eval( \"require '%s/characters/Ambrus.pl';\" )", DATADIR );
	g_oBackend.PerlEvalF( "eval( \"require '%s/characters/Dani.pl';\" )", DATADIR );

	for ( i=0; i<15; ++i )
	{
	pack.Draw( i, x[i], y[i], false );
	SDL_Flip( gamescreen );
	if ( filename[i] != NULL )
	{
	debug( "Loading fighter %s", filename[i] );
	g_oBackend.PerlEvalF( "eval( \"require '%s/characters/%s';\" )", DATADIR, filename[i] );
	}
	}

	int retval = 0;
	i = 0;

	SDL_FreeSurface( background );
	return retval;

	}



	int main(int argc, char *argv[])
	{
	srand( (unsigned int)time(NULL) );
	if ( 0 != init2() )
	{
	fprintf( stderr, "init2() failed." );
	return -1;
	}

	g_oState.m_pcArgv0 = argv[0];
	g_oState.Load();
	CMortalNetwork::Create();

	bool bDebug = false;

	int iFlags = SDL_SWSURFACE \| SDL_HWPALETTE;
	if ( g_oState.m_bFullscreen )
	{
	iFlags \|= SDL_FULLSCREEN;
	}

	int i;
	for ( i=1; i<argc; ++i )
	{
	if ( !strcmp(argv[i], "-debug") )
	{
	bDebug = true;
	}
	else if ( !strcmp(argv[i], "-fullscreen") )
	{
	iFlags \|= SDL_FULLSCREEN;
	}
	else if ( !strcmp(argv[i], "-hwsurface") )
	{
	iFlags \|= SDL_HWSURFACE;
	}
	else if ( !strcmp(argv[i], "-doublebuf") )
	{
	iFlags \|= SDL_DOUBLEBUF;
	}
	else if ( !strcmp(argv[i], "-anyformat") )
	{
	iFlags \|= SDL_ANYFORMAT;
	}
	else
	{
	printf( "Usage: %s [-debug] [-fullscreen] [-hwsurface] [-doublebuf] [-anyformat]\n", argv[0] );
	return 0;
	}
	}

	if (init( iFlags )<0)
	{
	return -1;
	}

	g_oState.SetLanguage( g_oState.m_acLanguage );

	new MszAudio;
	// Audio->LoadMusic( "Last_Ninja_-_The_Wilderness.mid", "DemoMusic" );
	- Audio->LoadMusic( "VUJICS.IT", "DemoMusic" );
	+ Audio->LoadMusic( "ride.mod", "DemoMusic" );
	Audio->PlayMusic( "DemoMusic" );
	Audio->LoadMusic( "2nd_pm.s3m", "GameMusic" );

	DrawMainScreen();

	g_oPlayerSelect.SetPlayer( 0, ZOLI );
	g_oPlayerSelect.SetPlayer( 1, SIRPI );

	/*
	int nextFighter = 0;
	int describeOrder[ (int)LASTFIGHTER ];

	for ( i=0; i<(int)LASTFIGHTER; ++i ) describeOrder[i] = i;
	for ( i=0; i<100; ++i )
	{
	int j = rand() % (int)LASTFIGHTER;
	int k = rand() % (int)LASTFIGHTER;
	int l;
	l = describeOrder[j];
	describeOrder[j] = describeOrder[k];
	describeOrder[k] = l;
	}
	*/

	/*
	{
	int iGameNumber=0;
	char acReplayFile[1024];

	for ( i=0; i<15; ++i )
	{
	sprintf( acReplayFile, DATADIR "/msz%i.replay", i );
	DrawTextMSZ( acReplayFile, impactFont, 10, 10, 0, C_WHITE, gamescreen );
	SDL_Delay(5000 );

	DoGame( acReplayFile, true, bDebug );
	}
	}
	*/
	bool bNetworkGame = false;

	while ( 1 )
	{
	if ( g_oState.m_bQuitFlag ) break;
	DoDemos();
	if ( g_oState.m_bQuitFlag ) break;

	Audio->PlaySample( "car_start.voc" );
	Audio->PlayMusic( "GameMusic" );

	bNetworkGame = false;

	while ( g_oState.m_enGameMode != SState::IN_DEMO
	&& !g_oState.m_bQuitFlag )
	{
	bNetworkGame = SState::IN_NETWORK == g_oState.m_enGameMode;

	g_oPlayerSelect.DoPlayerSelect();
	if ( g_oState.m_bQuitFlag \|\| g_oState.m_enGameMode == SState::IN_DEMO ) break;

	//sprintf( acReplayFile, "/tmp/msz%d.replay", ++iGameNumber );

	int iGameResult = DoGame( NULL, false, bDebug );
	//int iGameResult = DoGame( acReplayFile, false, bDebug );
	//DoGame( acReplayFile, true, bDebug );
	if ( g_oState.m_bQuitFlag \|\| g_oState.m_enGameMode == SState::IN_DEMO ) break;

	debug ( "iGameResult = %d\n", iGameResult );

	- if ( iGameResult >= 0 )
	+ if ( iGameResult >= 0 && bNetworkGame )
	{
	GameOver( iGameResult );
	FighterStatsDemo oDemo( g_oPlayerSelect.GetPlayerInfo( iGameResult ).m_enFighter );
	oDemo.Run();
	}
	if ( g_oState.m_bQuitFlag \|\| g_oState.m_enGameMode == SState::IN_DEMO ) break;
	}

	if ( bNetworkGame && !g_oState.m_bQuitFlag )
	{
	DrawTextMSZ( "Connection closed.", inkFont, 320, 210, AlignHCenter \| UseShadow, C_WHITE, gamescreen );
	DrawTextMSZ( g_poNetwork->GetLastError(), impactFont, 320, 250, AlignHCenter \| UseShadow, C_WHITE, gamescreen );
	GetKey();
	}

	if ( g_oState.m_bQuitFlag ) break;
	Audio->PlayMusic( "DemoMusic" );
	}

	g_oState.Save();

	SDL_Quit();

	return EXIT_SUCCESS;
	}
	diff --git a/src/menu.cpp b/src/menu.cpp
	index 3b58e74..93bf17f 100644
	--- a/src/menu.cpp
	+++ b/src/menu.cpp
	@@ -1,1075 +1,1150 @@
	/***************************************************************************
	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"
	#include "sge_tt_text.h"
	#include "MortalNetwork.h"

	#include <stdarg.h>


	enum
	{
	/* Master menu structure:
	MAIN MENU
	*/
	MENU_UNKNOWN,
	MENU_SURRENDER,
	MENU_SINGLE_PLAYER,
	MENU_EASY,
	MENU_MEDIUM,
	MENU_HARD,
	MENU_MULTI_PLAYER,
	MENU_NETWORK_GAME,
	MENU_SERVER,
	MENU_HOSTNAME,
	MENU_CONNECT,
	MENU_CANCEL,
	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_LANGUAGE,
	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 };

	const char* g_ppcLanguage[] = { "English", "Spanish", "Francais", "Magyar", NULL };
	const int g_piLanguage[] = { 0, 1, 2, 3 };
	const char* g_ppcLanguageCodes[] = { "en", "es", "fr", "hu" };

	const char* g_ppcServer[] = { "Connect to game", "Create game", NULL };
	int g_piServer[] = { 0, 1 };


	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,
	Translate("%s player-'%s'?"),
	Translate(a_iPlayerNumber ? "Left" : "Right"),
	Translate(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 );
	}




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

	static int g_iMessageY;
	+static char g_acMessageBuffer[1024];
	+
	+
	+void MortalNetworkResetMessages( bool a_bClear )
	+{
	+ if ( a_bClear )
	+ {
	+ SDL_FillRect( gamescreen, NULL, C_BLACK );
	+ SDL_Flip( gamescreen );
	+ g_iMessageY = 185;
	+ }
	+ else
	+ {
	+ g_iMessageY = 260;
	+ }
	+}

	void MortalNetworkMessage( const char* format, ... )
	{
	char acBuffer[1024];
	va_list ap;
	va_start( ap, format );
	vsnprintf( acBuffer, 1023, format, ap );
	va_end( ap );
	DrawTextMSZ( acBuffer, impactFont, 20, g_iMessageY, 0, C_LIGHTGRAY, gamescreen );
	g_iMessageY += 25;
	}


	bool MortalNetworkCheckKey()
	{
	SDL_Event event;
	while (SDL_PollEvent(&event))
	{
	switch (event.type)
	{
	case SDL_QUIT:
	g_oState.m_bQuitFlag = true;
	return true;

	case SDL_KEYDOWN:
	{
	return true;
	}
	break;
	} // switch statement
	} // Polling events

	return false;
	}


	+const char* FindString( const char* a_ppcNames[], const int a_piValues[], int a_iValue )
	+{
	+ for ( int i=0; NULL != a_ppcNames[i]; ++i )
	+ {
	+ if ( a_iValue == a_piValues[i] )
	+ {
	+ return a_ppcNames[i];
	+ }
	+ }
	+ return "(unknown)";
	+}
	+
	+
	+
	+const char* GetGameTimeString( int a_iValue )
	+{
	+ strcpy( g_acMessageBuffer, Translate("GAME TIME: ") );
	+ strcat( g_acMessageBuffer, Translate(FindString( g_ppcGameTime, g_piGameTime, a_iValue)) );
	+ return g_acMessageBuffer;
	+}
	+
	+const char* GetGameSpeedString( int a_iValue )
	+{
	+ strcpy( g_acMessageBuffer, Translate("GAME SPEED: ") );
	+ strcat( g_acMessageBuffer, Translate(FindString( g_ppcGameSpeed, g_piGameSpeed, a_iValue)) );
	+ return g_acMessageBuffer;
	+}
	+
	+const char* GetHitPointsString( int a_iValue )
	+{
	+ strcpy( g_acMessageBuffer, Translate("STAMINA: ") );
	+ strcat( g_acMessageBuffer, Translate(FindString( g_ppcHitPoints, g_piHitPoints, a_iValue) ) );
	+ return g_acMessageBuffer;
	+}
	+
	+
	+
	+

	class CNetworkMenu: public Menu
	{
	public:
	CNetworkMenu(): Menu( "Network Play Setup" )
	{
	m_bOK = false;
	m_bServer = g_oState.m_bServer;
	m_sHostname = g_oState.m_acLatestServer;

	AddMenuItem( "START NETWORK GAME!", SDLK_UNKNOWN, MENU_CONNECT );
	AddEnumMenuItem( "Network mode: ", m_bServer ? 1 : 0, g_ppcServer, g_piServer, MENU_SERVER );
	m_poServerMenuItem = AddTextMenuItem( "Connect to: ", m_sHostname.c_str(), MENU_HOSTNAME );
	m_poServerMenuItem->SetEnabled(!m_bServer);

	MenuItem* poItem = AddMenuItem( "Cancel", SDLK_UNKNOWN, MENU_CANCEL );
	SDL_Rect oRect;
	oRect.x = gamescreen->w - 150; oRect.w = 150;
	oRect.y = gamescreen->h - 50; oRect.h = 30;
	poItem->SetPosition( oRect );
	}

	~CNetworkMenu() {}

	+ void Connect()
	+ {
	+ Clear();
	+ Draw();
	+
	+ MortalNetworkResetMessages( false );
	+ m_bOK = g_poNetwork->Start( m_bServer ? NULL : m_sHostname.c_str() );
	+
	+ if ( m_bOK )
	+ {
	+ g_oState.SetServer( m_bServer ? NULL : m_sHostname.c_str() );
	+ g_oState.m_enGameMode = SState::IN_NETWORK;
	+ m_bDone = true;
	+ m_iReturnCode = 100;
	+ }
	+ else
	+ {
	+ const char* acError = g_poNetwork->GetLastError();
	+ DrawTextMSZ( "Couldn't connect", inkFont, 320, g_iMessageY, AlignHCenter\|UseShadow, C_LIGHTRED, gamescreen );
	+ DrawTextMSZ( acError, impactFont, 320, g_iMessageY + 40, AlignHCenter\|UseShadow, C_LIGHTRED, gamescreen, false );
	+ }
	+
	+ if ( !g_oState.m_bQuitFlag )
	+ {
	+ if ( m_bOK )
	+ {
	+ // Wait for 1 sec, or keystroke.
	+ for ( int i=0; i<10; ++i )
	+ {
	+ if ( MortalNetworkCheckKey() ) break;
	+ SDL_Delay( 100 );
	+ }
	+ }
	+ else
	+ {
	+ GetKey();
	+ }
	+ Clear();
	+ Draw();
	+ }
	+
	+ if ( g_oState.m_bQuitFlag )
	+ {
	+ m_bDone = true;
	+ m_iReturnCode = 100;
	+ }
	+ }
	+
	+ void EnterHostname()
	+ {
	+ Clear();
	+ Draw();
	+
	+ char acBuffer[256];
	+ strncpy( acBuffer, m_sHostname.c_str(), 255 );
	+ acBuffer[255] = 0;
	+
	+ int x = DrawTextMSZ( "Server name: ", impactFont, 20, 270, 0, C_WHITE, gamescreen );
	+
	+ int iRetval;
	+ {
	+ SDL_EnableKeyRepeat( SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL );
	+ CReadline oReadline( gamescreen, impactFont, acBuffer, strlen(acBuffer), 255,
	+ 20+x, 270 + sge_TTF_FontAscent(impactFont), 600, C_LIGHTCYAN, C_BLACK, 255 );
	+ iRetval = oReadline.Execute();
	+ }
	+
	+ if ( iRetval == -1 )
	+ {
	+ m_bDone = true;
	+ m_iReturnCode = 100;
	+ g_oState.m_bQuitFlag = true;
	+ }
	+ if ( iRetval > 0 )
	+ {
	+ m_sHostname = acBuffer;
	+ m_poServerMenuItem->SetValue( acBuffer );
	+ }
	+ Clear();
	+ Draw();
	+ }
	+
	void ItemActivated( int a_iItemCode, MenuItem* a_poMenuItem )
	{
	switch ( a_iItemCode )
	{
	case MENU_SERVER:
	{
	EnumMenuItem* poItem = (EnumMenuItem*) a_poMenuItem;
	if ( m_bServer )
	{
	poItem->Decrement();
	}
	else
	{
	poItem->Increment();
	}
	break;
	}

	case MENU_CONNECT:
	- {
	- Clear();
	- Draw();
	-
	- g_iMessageY = 260;
	- m_bOK = g_poNetwork->Start( m_bServer ? NULL : m_sHostname.c_str() );
	-
	- if ( m_bOK )
	- {
	- g_oState.SetServer( m_bServer ? NULL : m_sHostname.c_str() );
	- g_oState.m_enGameMode = SState::IN_NETWORK;
	- m_bDone = true;
	- m_iReturnCode = 100;
	- }
	- else
	- {
	- const char* acError = g_poNetwork->GetLastError();
	- DrawTextMSZ( "Couldn't connect", inkFont, 320, g_iMessageY, AlignHCenter\|UseShadow, C_LIGHTRED, gamescreen );
	- DrawTextMSZ( acError, impactFont, 320, g_iMessageY + 40, AlignHCenter\|UseShadow, C_LIGHTRED, gamescreen, false );
	- }
	-
	- if ( !g_oState.m_bQuitFlag )
	- {
	- if ( m_bOK )
	- {
	- for ( int i=0; i<10; ++i ) if ( MortalNetworkCheckKey() ) break;
	- }
	- else
	- {
	- GetKey();
	- }
	- Clear();
	- Draw();
	- }
	-
	- if ( g_oState.m_bQuitFlag )
	- {
	- m_bDone = true;
	- m_iReturnCode = 100;
	- }
	+ Connect();
	break;
	- }

	case MENU_CANCEL:
	m_bOK = false;
	m_bDone = true;
	m_iReturnCode = -1;
	break;

	case MENU_HOSTNAME:
	- Clear();
	- Draw();
	-
	- char acBuffer[256];
	- strncpy( acBuffer, m_sHostname.c_str(), 255 );
	- acBuffer[255] = 0;
	-
	- int x = DrawTextMSZ( "Server name: ", impactFont, 20, 270, 0, C_WHITE, gamescreen );
	-
	- int iRetval;
	- {
	- SDL_EnableKeyRepeat( SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL );
	- CReadline oReadline( gamescreen, impactFont, acBuffer, strlen(acBuffer), 255,
	- 20+x, 270 + sge_TTF_FontAscent(impactFont), 600, C_LIGHTCYAN, C_BLACK, 255 );
	- iRetval = oReadline.Execute();
	- }
	-
	- if ( iRetval == -1 )
	- {
	- m_bDone = true;
	- m_iReturnCode = 100;
	- g_oState.m_bQuitFlag = true;
	- }
	- if ( iRetval > 0 )
	- {
	- m_sHostname = acBuffer;
	- m_poServerMenuItem->SetValue( acBuffer );
	- }
	- Clear();
	- Draw();
	+ EnterHostname();
	break;
	}
	}

	void ItemChanged( int a_iItemCode, int a_iValue, MenuItem* a_poMenuItem )
	{
	switch ( a_iItemCode )
	{
	case MENU_SERVER:
	m_bServer = a_iValue;
	m_poServerMenuItem->SetEnabled(!m_bServer);
	break;
	}
	}


	protected:
	bool m_bOK;
	bool m_bServer;
	std::string m_sHostname;

	TextMenuItem* m_poServerMenuItem;
	};




	/***************************************************************************
	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 = Translate( m_sUtf8Title.c_str() );
	if ( m_iValue <= m_iMax )
	{
	m_sUtf8Text += Translate(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;
	}






	/***************************************************************************
	TextMenuItem DEFINITION
	***************************************************************************/



	TextMenuItem::TextMenuItem( Menu* a_poMenu, const char* a_pcInitialValue, const char* a_pcUtf8Title, int a_iCode )
	: MenuItem( a_poMenu, a_pcUtf8Title, a_iCode )

	{
	m_sTitle = a_pcUtf8Title;
	m_sValue = a_pcInitialValue;
	}


	TextMenuItem::~TextMenuItem()
	{
	}


	void TextMenuItem::Draw()
	{
	m_sUtf8Text = Translate( m_sTitle.c_str() );
	m_sUtf8Text += m_sValue;

	MenuItem::Draw();
	}


	void TextMenuItem::SetValue( const char* a_pcValue )
	{
	m_sValue = a_pcValue;
	Draw();
	}









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


	TextMenuItem* Menu::AddTextMenuItem( const char* a_pcTitle, const char* a_pcValue, int a_iCode )
	{
	TextMenuItem* poItem = new TextMenuItem( this, a_pcValue, a_pcTitle, a_iCode );
	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() * 40 + 100;
	oRect.h = 43;

	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 ( g_oState.m_bQuitFlag )
	{
	m_iReturnCode = 100;
	m_bDone = true;
	}

	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;
	+ if ( SState::IN_NETWORK == g_oState.m_enGameMode )
	+ {
	+ g_poNetwork->Stop();
	+ }
	g_oState.m_enGameMode = SState::IN_DEMO;
	break;

	case MENU_NETWORK_GAME:
	{
	Menu* poMenu = new CNetworkMenu();
	InvokeSubmenu( poMenu );
	delete poMenu;
	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::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;

	case MENU_LANGUAGE:
	g_oState.SetLanguage( g_ppcLanguageCodes[ a_iValue ] );
	Clear();
	Draw();
	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( "~NETWORK GAME", SDLK_n, MENU_NETWORK_GAME );
	oMenu.AddMenuItem( "~MULTI PLAYER GAME", SDLK_m, MENU_MULTI_PLAYER );
	}
	else
	{
	oMenu.AddMenuItem( "~SURRENDER GAME", SDLK_s, MENU_SURRENDER );
	}
	oMenu.AddEnumMenuItem( "~LANGUAGE: ", g_oState.m_iLanguageCode, g_ppcLanguage, g_piLanguage, MENU_LANGUAGE );

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

	if ( !g_oState.m_bQuitFlag )
	{
	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:10 PM (14 h, 43 m ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 55618
Default Alt Text: (112 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions