No OneTemporary
Actions

Size

32 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/Backend.h b/src/Backend.h
	index 7f49862..3950841 100644
	--- a/src/Backend.h
	+++ b/src/Backend.h
	@@ -1,77 +1,77 @@
	/***************************************************************************
	Backend.h - description
	-------------------
	begin : Sun Dec 8 2002
	copyright : (C) 2002 by upi
	email : upi@apocalypse.rulez.org
	***************************************************************************/


	#ifndef BACKEND_H
	#define BACKEND_H

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

	class RlePack;


	#define MAXDOODADS 20
	#define MAXSOUNDS 20


	class Backend
	{
	public:

	// Lifecycle

	Backend();
	~Backend();
	bool Construct();

	// Miscellaneous

	const char* PerlEvalF( const char* a_pcFormat, ... );
	- const char* GetPerlString( const char* acScalarName );
	- int GetPerlInt( const char* acScalarName );
	+ const char* GetPerlString( const char* a_pcScalarName );
	+ int GetPerlInt( const char* a_pcScalarName );

	// Game data

	void AdvancePerl();
	void ReadFromPerl();
	void PlaySounds();
	void WriteToString( std::string& a_rsOutString );
	void ReadFromString( const std::string& a_rsString );


	public:
	int m_iGameTime;
	int m_iGameOver;
	bool m_bKO;
	int m_iBgX, m_iBgY;
	int m_iNumDoodads;
	int m_iNumSounds;

	struct SPlayer
	{
	int m_iX, m_iY, m_iFrame, m_iHitPoints;
	} m_aoPlayers[2];

	struct SDoodad
	{
	int m_iX, m_iY, m_iType, m_iFrame;
	std::string m_sText;
	} m_aoDoodads[ MAXDOODADS ];

	std::string m_asSounds[ MAXSOUNDS ];
	};

	extern Backend g_oBackend;




	int DoGame( char* replay, bool isReplay, bool bDebug );

	#endif
	diff --git a/src/Game.cpp b/src/Game.cpp
	index 1d523a0..8426cd0 100644
	--- a/src/Game.cpp
	+++ b/src/Game.cpp
	@@ -1,761 +1,766 @@
	/***************************************************************************
	Game.cpp - description
	-------------------
	begin : Mon Sep 24 2001
	copyright : (C) 2001 by upi
	email : upi@apocalypse.rulez.org
	***************************************************************************/

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

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


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


	extern PerlInterpreter* my_perl;


	/*

	GAME PALETTE

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

	*/

	#define MAXFRAMESKIP 5



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

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

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

	} oFpsCounter;








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

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

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

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


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


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

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

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


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


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


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

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

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

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

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

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

	// "Won" icon for Player 1
	src.x = 0; src.y = 276; src.w = 32; src.h = 32;
	if ( m_aiRoundsWonByPlayer[0] > 0 )
	{
	dst.x = 4; dst.y = 11;
	SDL_BlitSurface( m_poDoodads, &src, gamescreen, &dst );
	}
	if ( m_aiRoundsWonByPlayer[1] > 0 )
	{
	dst.x = 604; dst.y = 11;
	SDL_BlitSurface( m_poDoodads, &src, gamescreen, &dst );
	}
	+
	+ sge_BF_textout( gamescreen, fastFont, g_oPlayerSelect.GetFighterName(0),
	+ 230 - g_oPlayerSelect.GetFighterNameWidth(0), 38 );
	+ sge_BF_textout( gamescreen, fastFont, g_oPlayerSelect.GetFighterName(1),
	+ 410, 38 );
	}



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



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

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

	n = av_len( iList ) + 1;

	if ( n< 2 )
	{
	return;
	}

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

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

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




	void Game::DrawDoodads()
	{
	for ( int i=0; i<g_oBackend.m_iNumDoodads; ++i )
	{
	Backend::SDoodad& roDoodad = g_oBackend.m_aoDoodads[i];
	if ( 0 == roDoodad.m_iType )
	{
	// Handle text doodads
	const char *s = roDoodad.m_sText.c_str();

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

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

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

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


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

	for ( int i=0; i<2; ++i )
	{
	int iFrame = g_oBackend.m_aoPlayers[i].m_iFrame;
	if ( 0 != iFrame )
	{
	g_oPlayerSelect.GetPlayerInfo(i).m_poPack->Draw(
	ABS(iFrame)-1,
	g_oBackend.m_aoPlayers[i].m_iX,
	g_oBackend.m_aoPlayers[i].m_iY,
	iFrame<0 );
	}
	}

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

	DrawDoodads();
	DrawHitPointDisplay();

	if ( Ph_NORMAL == m_enGamePhase )
	{
	char s[100];
	sprintf( s, "%d", g_oBackend.m_iGameTime );
	DrawTextMSZ( s, inkFont, 320, 10, AlignHCenter, C_LIGHTCYAN, gamescreen );
	}
	else if ( Ph_START == m_enGamePhase )
	{
	char s[100];
	sprintf( s, "Round %d", m_iNumberOfRounds+1 );
	DrawTextMSZ( s, inkFont, 320, 200, AlignHCenter, C_WHITE, gamescreen );
	}
	else if ( Ph_REWIND == m_enGamePhase )
	{
	DrawTextMSZ( "REW", inkFont, 320, 10, AlignHCenter, C_WHITE, gamescreen );
	}
	else if ( Ph_SLOWFORWARD == m_enGamePhase )
	{
	DrawTextMSZ( "REPLAY", inkFont, 320, 10, AlignHCenter, C_WHITE, gamescreen );
	}
	else if ( Ph_REPLAY == m_enGamePhase )
	{
	DrawTextMSZ( "DEMO", inkFont, 320, 10, AlignHCenter, C_WHITE, gamescreen );
	}

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

	SDL_Flip( gamescreen );
	}



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



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

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

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

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

	g_oBackend.ReadFromString( sFrameDesc );
	return;
	}

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

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



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

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

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

	int Game::ProcessEvents()
	{
	SDL_Event event;
	while (SDL_PollEvent(&event))
	{
	switch (event.type)
	{
	case SDL_QUIT:
	g_oState.m_bQuitFlag = true;
	return 1;

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

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

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

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

	break;
	}

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

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

	return 0;
	}



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


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


	void Game::InstantReplay( int a_iKoAt )
	{
	int iCurrentFrame = m_aReplayOffsets.size() - 200;
	int iThisTick, iLastTick, iGameSpeed;

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

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

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

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

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

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

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

	g_oBackend.ReadFromString( sFrameDesc );

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

	// 3. Draw the next game screen..

	Draw();

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

	}


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

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

	int iKoFrame = -1;
	double dGameTime = 2 * 1000;
	int iThisTick, iLastTick, iGameSpeed;
	bool bHurryUp = false;
	bool bReplayAfter = true;

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

	oFpsCounter.Reset();

	// 1. DO THE NORMAL GAME ROUND and HURRYUP

	while ( dGameTime > 0 )
	{

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

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

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

	if ( Ph_START == m_enGamePhase )
	{
	if ( dGameTime < 0 )
	{
	m_enGamePhase = Ph_NORMAL;
	dGameTime = g_oState.m_iGameTime * 1000;
	}
	}
	else if ( Ph_NORMAL == m_enGamePhase )
	{
	if ( dGameTime < 10 * 1000
	&& !bHurryUp )
	{
	bHurryUp = true;
	HurryUp();
	iGameSpeed = iGameSpeed * 3 / 4;
	}
	if ( g_oBackend.m_bKO )
	{
	m_enGamePhase = Ph_KO;
	dGameTime = 10 * 1000;
	iKoFrame = m_aReplayOffsets.size();
	}
	else if ( dGameTime < 0 )
	{
	m_enGamePhase = Ph_TIMEUP;
	TimeUp();
	break;
	}
	}

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

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

	oFpsCounter.Tick();

	// 3. Draw the next game screen..

	Draw();

	if ( g_oBackend.m_iGameOver )
	{
	break;
	}
	}

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

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

	// 4. END OF ROUND


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

	if ( p1h > p2h ) ++m_aiRoundsWonByPlayer[0];
	if ( p2h > p1h ) ++m_aiRoundsWonByPlayer[1];
	++m_iNumberOfRounds;
	}



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

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

	int iThisTick, iLastTick, iGameSpeed;

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

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

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

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

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

	iLastTick = iThisTick;

	g_oBackend.ReadFromString( sLine );

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

	// 3. Draw the next game screen..

	Draw();

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



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

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


	diff --git a/src/PlayerSelect.cpp b/src/PlayerSelect.cpp
	index c0d9bf7..a613d58 100644
	--- a/src/PlayerSelect.cpp
	+++ b/src/PlayerSelect.cpp
	@@ -1,473 +1,494 @@
	/***************************************************************************
	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 "common.h"
	#include "Audio.h"
	+#include "sge_bm_text.h"
	#include "gfx.h"
	#include "RlePack.h"
	#include "Backend.h"
	#include "State.h"


	#define CHOOSERLEFT 158
	#define CHOOSERTOP 98
	#define CHOOSERHEIGHT 80
	#define CHOOSERWIDTH 80
	#define CHOOSERROWS 4
	#define CHOOSERCOLS 4

	#ifndef NULL
	#define NULL 0
	#endif


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


	PlayerSelect g_oPlayerSelect;


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

	/*
	int p1 = 0;
	int p2 = 3;
	bool done1 = false;
	bool done2 = false;
	*/


	FighterEnum ChooserCells[CHOOSERROWS][CHOOSERCOLS] = {
	{ ZOLI, UPI, CUMI, SIRPI },
	{ ULMAR, MACI, BENCE, GRIZLI },
	{ AMBRUS, DESCANT, SURBA, DANI },
	{ UNKNOWN, KINGA, MISI, UNKNOWN },
	};



	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 = CHOOSERCOLS-1;
	}


	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 )
	{
	static bool g_abFighterAvailable[ LASTFIGHTER ] =
	{
	false,
	true, true, true, true,
	true, true, true, true,
	true, false, false, false,
	false, false
	};

	if ( a_enFighter < UNKNOWN
	\|\| a_enFighter >= LASTFIGHTER )
	{
	return false;
	}

	return g_abFighterAvailable[ a_enFighter ];
	}



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

	switch (m_enFighter)
	{
	case ZOLI: s = "ZOLIDATA.DAT"; break;
	case UPI: s = "UPIDATA.DAT"; break;
	case ULMAR: s = "ULMARDATA.DAT"; break;
	case CUMI: s = "CUMIDATA.DAT"; break;
	case SIRPI: s = "SIRPIDATA.DAT"; break;
	case MACI: s = "MACIDATA.DAT"; break;
	case BENCE: s = "BENCEDATA.DAT"; break;
	case DESCANT: s = "DESCANTDATA.DAT"; break;
	case GRIZLI: s = "GRIZLIDATA.DAT"; break;
	default: return NULL; break;
	}

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

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




	void PlayerSelect::HandleKey( int a_iPlayer, int a_iKey )
	{
	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 >= CHOOSERCOLS ) riP -= CHOOSERCOLS;
	break;
	case 1: // down
	if ( (riP/CHOOSERCOLS) < (CHOOSERROWS-1) ) riP += CHOOSERCOLS;
	break;
	case 2: // left
	if ( (riP % CHOOSERCOLS) > 0 ) riP--;
	break;
	case 3: // right
	if ( (riP % CHOOSERCOLS) < (CHOOSERCOLS-1) ) riP++;
	break;
	default:
	if ( ChooserCells[riP/4][riP%4] )
	{
	rbDone = true;

	g_oBackend.PerlEvalF( "PlayerSelected(%d);", a_iPlayer );
	Audio->PlaySample("magic.voc");
	return;
	}
	}

	if ( !IsFighterAvailable( ChooserCells[riP/CHOOSERCOLS][riP%CHOOSERCOLS] ) )
	{
	riP = iOldP;
	}

	if ( iOldP != riP )
	{
	Audio->PlaySample("strange_quack.voc");
	SetPlayer( a_iPlayer, ChooserCells[riP/CHOOSERCOLS][riP%CHOOSERCOLS] );
	}
	}


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

	r.x = CHOOSERLEFT + iCol * CHOOSERWIDTH;
	r.y = CHOOSERTOP + iRow * CHOOSERHEIGHT;
	r.w = CHOOSERWIDTH + 5;
	r.h = 5;
	r1 = r;
	SDL_FillRect( gamescreen, &r1, a_iColor );

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

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

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


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

	x1 = CHOOSERLEFT + a_iCol * CHOOSERWIDTH +5;
	y1 = CHOOSERTOP + a_iRow * CHOOSERHEIGHT +5;

	sge_Line(a_poBackground, x1+5, y1+5, x1 + CHOOSERWIDTH-10, y1 + CHOOSERHEIGHT-10, 252);
	sge_Line(a_poBackground, x1 + CHOOSERWIDTH-10, y1+5, x1+5, y1 + CHOOSERHEIGHT-10, 252);
	x1++;
	sge_Line(a_poBackground, x1+5, y1+5, x1 + CHOOSERWIDTH-10, y1 + CHOOSERHEIGHT-10, 252);
	sge_Line(a_poBackground, x1 + CHOOSERWIDTH-10, y1+5, x1+5, y1 + CHOOSERHEIGHT-10, 252);
	y1++;
	sge_Line(a_poBackground, x1+5, y1+5, x1 + CHOOSERWIDTH-10, y1 + CHOOSERHEIGHT-10, 252);
	sge_Line(a_poBackground, x1 + CHOOSERWIDTH-10, y1+5, x1+5, y1 + CHOOSERHEIGHT-10, 252);
	x1--;
	sge_Line(a_poBackground, x1+5, y1+5, x1 + CHOOSERWIDTH-10, y1 + CHOOSERHEIGHT-10, 252);
	sge_Line(a_poBackground, x1 + CHOOSERWIDTH-10, y1+5, x1+5, y1 + CHOOSERHEIGHT-10, 252);
	}


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

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

	SDL_Surface* poBackground = LoadBackground( "PlayerSelect.png", 111 );

	DrawGradientText( "Choose A Fighter Dammit", titleFont, 10, poBackground );

	int i, j;
	for ( i=0; i<CHOOSERROWS; ++i )
	{
	for ( int j=0; j<CHOOSERCOLS; ++j )
	{
	if ( !IsFighterAvailable(ChooserCells[i][j]) &&
	UNKNOWN != ChooserCells[i][j] )
	{
	CheckPlayer( poBackground, i, j );
	}
	}
	}

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

	SetPlayer( 0, ChooserCells[m_iP1/CHOOSERCOLS][m_iP1%CHOOSERCOLS] );
	SetPlayer( 1, ChooserCells[m_iP2/CHOOSERCOLS][m_iP2%CHOOSERCOLS] );

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

	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))
	{
	switch (event.type)
	{
	case SDL_QUIT:
	g_oState.m_bQuitFlag = true;
	break;
	case SDL_KEYDOWN:
	{
	if ( event.key.keysym.sym == SDLK_ESCAPE )
	{
	DoMenu( false );
	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

	g_oBackend.ReadFromPerl();

	over = g_oBackend.m_iGameOver;

	SDL_BlitSurface( poBackground, NULL, gamescreen, NULL );

	for ( i=0; i<2; ++i )
	{
	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,
	g_oBackend.m_aoPlayers[i].m_iFrame < 0 );
	}
	+ int x = ( CHOOSERLEFT - 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, gamescreen->h - 30 );
	}

	if ( !m_bDone1) DrawRect( m_iP1, 250 );
	if ( !m_bDone2) DrawRect( m_iP2, 253 );
	SDL_Flip( gamescreen );

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

	SDL_FreeSurface( poBackground );
	SDL_SetClipRect( gamescreen, NULL );
	return;
	}

	diff --git a/src/PlayerSelect.h b/src/PlayerSelect.h
	index f8819a6..81dec57 100644
	--- a/src/PlayerSelect.h
	+++ b/src/PlayerSelect.h
	@@ -1,77 +1,82 @@
	/***************************************************************************
	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;

	/** 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 player is available, and
	+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. */
	+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 );

	protected:

	void HandleKey( int a_iPlayer, int a_iKey );
	void DrawRect( int a_iPos, int a_iColor );
	void CheckPlayer( SDL_Surface* a_poBackground, int a_iRow, int a_iCol );
	static RlePack* LoadFighter( FighterEnum m_enFighter );

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

	};


	extern PlayerSelect g_oPlayerSelect;

	#endif // PLAYERSELECT_H

File Metadata

Mime Type: text/x-diff
Expires: Wed, Feb 4, 2:14 PM (6 h, 47 m ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 55646
Default Alt Text: (32 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions