Jump to content

  • Log In with Google      Sign In   
  • Create Account


Musikai

Member Since 09 Apr 2013
Offline Last Active May 25 2013 01:35 PM

Topics I've Started

Moving with delta time.

22 May 2013 - 12:32 AM

So im making a pong clone and i have a silly problem.

 

I have a Paddle class with HandleInput(), Update(), and Draw() functions. The HandleIput and Update functions look like this at the moment.

 

void Paddle::HandleInput( Keyboard& keyboard )
{
    if( keyboard.KeyIsHeld( m_upKey ) )
	m_position.y -= m_moveSpeed;

    if( keyboard.KeyIsHeld( m_downKey ) )
	m_position.y += m_moveSpeed;
}

void Paddle::Update( float deltaTime )
{

}

 

The problem is that i want the position to be changed over time but at the moment the "Update" function is the one who is passed the delta time. It's a stupid problem but i can't figure out a nice way around it.

 

I want to avoid passing the delta time to the "HandleInput" function because it wouldn't really make sense, and also these function are actually an interface to a game object so it would mean passing it to every "HandleInput" function, whether it needed it or not. I could add a couple booleans to track whether either of the keys were pressed during "HandleInput" but that is essentially testing the same thing twice. I'm leaning towards the idea of adding a "delta position" variable to track the change in position, so the code would look something like this.

 

void Paddle::HandleInput( Keyboard& keyboard )
{
    if( keyboard.KeyIsHeld( m_upKey ) )
	m_deltaY -= m_moveSpeed;

    if( keyboard.KeyIsHeld( m_downKey ) )
	m_deltaY += m_moveSpeed;
}

void Paddle::Update( float deltaTime )
{
    m_position.y += (m_deltaY * deltaTime);
    m_deltaY = 0;
}

 

What do you guys think is the best solution?


Game state communication.

05 May 2013 - 03:14 PM

So i've been trying to make a game using a state machine/state pattern and im having trouble. So I have each state in its own class being managed by a state machine class (which is inherited by any class that needs multiple states). I've read many examples and tutorials on state machines but none of them seem to explain how the states communicate and share data.

 

I'l give some hypothetical game situations. What if, when playing an rpg you're in the "gameplay state" and you hit "M" to change to a "map view state", the map state is giong to need to know the players position in the world. What if you're in a "menu state" and change the games difficulty, then the "gampley state" would also need to know the new difficulty setting. If you're in an "inventory state" and you equip items then the "gameplay state" would need to know so it can display these new items on the player.

 

I dont know where this data should be stored and how it should be shared. If anyone knows a solution i would realy appreciate it.smile.png

 


Code Review: Pong

02 May 2013 - 02:34 PM

I've just finished making a pong clone written in C++ using SFML and would really appreciate some feedback and criticism on the game logic and/or coding style. One thing i really don't like is that my game states are just big switch staments. I've read about state machines and even tried implementing one but i just couldn't figure out how everything fits together, if anyone could help me with a state machine, that would be awesome.

 

The executable with DLL's and audio files.

Attached File  Pong.rar   5.2MB   76 downloads

 

Main.cpp

#include <Windows.h>
#include <SFML\Graphics.hpp>
#include "Game.h"
#include "Keyboard.h"

int WINAPI WinMain( HINSTANCE hinstance, HINSTANCE prevInstance, LPSTR lpCmdLine, int nCmdShow)
{
	sf::RenderWindow window( sf::VideoMode(900, 700), "Pong", sf::Style::Close );
	window.setVerticalSyncEnabled( true );

	MyGame game( window );
	Keyboard keyboard;

    while (window.isOpen())
    {
        sf::Event event;
        while (window.pollEvent(event))
        {
            if (event.type == sf::Event::Closed)
                window.close();
			else if (event.type == sf::Event::KeyPressed)
				keyboard.KeyDown( event.key.code );
			else if (event.type == sf::Event::KeyReleased)
				keyboard.KeyUp( event.key.code );
        }

		game.Update( keyboard );
		keyboard.Update();

        window.clear();
		game.Draw();
        window.display();
    }

	return 0;
}

 

Game.h

#ifndef GAME_H
#define GAME_H
#include <SFML\Graphics.hpp>
#include <SFML\Audio.hpp>
#include "Paddle.h"
#include "Ball.h"
#include "Scores.h"

enum ScreenState
{
	SS_TITLE,
	SS_INGAME
};

enum InGameState
{
	GS_INIT,
	GS_ONE,
	GS_TWO,
	GS_THREE,
	GS_RUN,
	GS_PAUSED,
	GS_GAMEOVER
};

enum MenuState
{
	MS_YES,
	MS_NO
};

class MyGame
{
public:
	MyGame( sf::RenderWindow& window );
	void Update( Keyboard& keyboard );
	void Draw();

private:
	void InitText();
	void InitSounds();

	bool TestCollision( Paddle paddle, Ball ball );
	void RestartGame();
	void Reset();

private:
	sf::RenderWindow& m_window;
	sf::Clock m_clock;
	sf::Clock m_eventClock;
	float m_eventTime;

	Paddle m_player1;
	Paddle m_player2;
	Ball m_ball;
	Scores m_scores;

	// States
	ScreenState m_screenState;
	InGameState m_inGameState;
	MenuState m_menuState;

	// Font and Text
	sf::Font m_sqPixFont;

	sf::Text txtTitle;
	sf::Text txtPressEnt;
	sf::Text txtThree;
	sf::Text txtTwo;
	sf::Text txtOne;
	sf::Text txtWinner;
	sf::Text txtPaused;
	sf::Text txtQuitGame;
	sf::Text txtPlayAgain;
	sf::Text txtYes;
	sf::Text txtNo;

	sf::Color m_blue;
	sf::Color m_yellow;
	sf::Color m_grey;

	// Sounds
	sf::Music m_fearOfDark;

	sf::SoundBuffer m_blip1Buffer;
	sf::Sound m_blip1;
	sf::SoundBuffer m_blip2Buffer;
	sf::Sound m_blip2;
	sf::SoundBuffer m_blopBuffer;
	sf::Sound m_blop;
};

#endif

 

Game.cpp

#include "Game.h"
using std::to_string;

MyGame::MyGame( sf::RenderWindow& window )
:       m_window( window ),
	m_player1( 75.0f, window.getSize().x, window.getSize().y ),
	m_player2( 815.0f, window.getSize().x, window.getSize().y ),
	m_ball( window.getSize().x, window.getSize().y )
{
	m_screenState = SS_TITLE;
	m_inGameState = GS_INIT;
	m_menuState	  = MS_YES;

	m_blue = sf::Color( 0, 100, 200, 255 );
	m_yellow = sf::Color( 255, 200, 0, 255 );
	m_grey = sf::Color( 20, 20, 20, 255 );

	InitText();
	InitSounds();
	m_scores.Init( m_sqPixFont, m_window );

	m_fearOfDark.play();
}

void MyGame::Update( Keyboard& keyboard )
{
	float frameTime = m_clock.getElapsedTime().asSeconds();
	m_clock.restart();

	m_eventTime = m_eventClock.getElapsedTime().asSeconds();

	switch( m_screenState )
	{
	case SS_TITLE:
		if( keyboard.KeyIsPressed( sf::Keyboard::Escape ) )
			m_window.close();
		if( keyboard.KeyIsPressed( sf::Keyboard::Return ) )
		{
			m_screenState = SS_INGAME;
			m_fearOfDark.stop();
			m_eventClock.restart();
		}
		break;

	case SS_INGAME:
		switch( m_inGameState )
		{
		case GS_INIT:
			{
				if( m_eventTime > 1.0f )
				{
					m_blip1.play();
					m_inGameState = GS_THREE;
					m_eventTime = 0;
					m_eventClock.restart();
				}

				break;
			}

		case GS_THREE:
			{
				if( m_eventTime > 1.0f )
				{
					m_blip1.play();
					m_inGameState = GS_TWO;
					m_eventTime = 0;
					m_eventClock.restart();
				}

				break;
			}

		case GS_TWO:
			{
				if( m_eventTime > 1.0f )
				{
					m_blip1.play();
					m_inGameState = GS_ONE;
					m_eventTime = 0;
					m_eventClock.restart();
				}

				break;
			}

		case GS_ONE:
			{
				if( m_eventTime > 1.0f )
				{
					m_blip2.play();
					m_inGameState = GS_RUN;
					m_eventTime = 0;
					m_eventClock.restart();
				}

				break;
			}

		case GS_RUN:
			{
				if( m_scores.Winner() )
				{
					m_inGameState = GS_GAMEOVER;
					break;
				}

				if( keyboard.KeyIsPressed( sf::Keyboard::Escape ) ||
					keyboard.KeyIsPressed( sf::Keyboard::P ) )
					m_inGameState = GS_PAUSED;

				// Player one controls
				if( keyboard.KeyIsHeld( sf::Keyboard::W ) )
					m_player1.MoveUp( frameTime );
				if( keyboard.KeyIsHeld( sf::Keyboard::S ) )
					m_player1.MoveDown( frameTime );

				// Player two controls
				if( keyboard.KeyIsHeld( sf::Keyboard::Up ) )
					m_player2.MoveUp( frameTime );
				if( keyboard.KeyIsHeld( sf::Keyboard::Down ) )
					m_player2.MoveDown( frameTime );

				// World collision
				if( m_ball.GetPosition().x < 0 )
				{
					m_ball.SetXPosition( 0 );
					if( m_ball.GetSpeed().x < 0 )
					{
						m_ball.BounceX();
						m_ball.IncreaseSpeed();
						m_scores.Player2Scored();
					}
				}
				if( m_ball.GetPosition().x + m_ball.GetSize().x >= m_window.getSize().x )
				{
					m_ball.SetXPosition( m_window.getSize().x - m_ball.GetSize().x );
					if( m_ball.GetSpeed().x > 0 )
					{
						m_ball.BounceX();
						m_ball.IncreaseSpeed();
						m_scores.Player1Scored();
					}
				}
				if( m_ball.GetPosition().y < 0 )
				{
					m_ball.SetYPosition( 0 );
					if( m_ball.GetSpeed().y < 0 )
					{
						m_ball.BounceY();
					}
				}
				if( m_ball.GetPosition().y + m_ball.GetSize().y >= m_window.getSize().y )
				{
					m_ball.SetYPosition( m_window.getSize().y - m_ball.GetSize().y );
					if( m_ball.GetSpeed().y > 0 )
					{
						m_ball.BounceY();
					}
				}

				// Paddle collision
				if( TestCollision( m_player1, m_ball ) )
				{
					if( m_ball.GetSpeed().x < 0 )
					{
						m_blop.play();
						m_ball.BouncePaddle( m_player1 );
						m_ball.IncreaseSpeed();
					}
				}
				if( TestCollision( m_player2, m_ball ) )
				{
					if( m_ball.GetSpeed().x > 0 )
					{
						m_blop.play();
						m_ball.BouncePaddle( m_player2 );
						m_ball.IncreaseSpeed();
					}
				}

				m_player1.Update();
				m_player2.Update();
				m_ball.Update( frameTime );
				m_scores.Update();

				break;
			}
		case GS_PAUSED:
			{
				if( keyboard.KeyIsPressed( sf::Keyboard::Escape ) ||
					keyboard.KeyIsPressed( sf::Keyboard::P ) )
					m_inGameState = GS_RUN;

				if( keyboard.KeyIsPressed( sf::Keyboard::Left ) ||
					keyboard.KeyIsPressed( sf::Keyboard::A    ) )
					m_menuState = MS_YES;

				if( keyboard.KeyIsPressed( sf::Keyboard::Right ) ||
					keyboard.KeyIsPressed( sf::Keyboard::D   ) )
					m_menuState = MS_NO;

				if( keyboard.KeyIsPressed( sf::Keyboard::Return ) )
				{
					if( m_menuState == MS_YES )
						Reset();
					else
						m_inGameState = GS_RUN;
				}

				if( m_menuState == MS_YES )
				{
					txtYes.setColor( m_blue );
					txtNo.setColor( m_grey );
				}
				else if( m_menuState == MS_NO )
				{
					txtYes.setColor( m_grey );
					txtNo.setColor( m_blue );
				}

				break;
			}
		case GS_GAMEOVER:
			{
				if( keyboard.KeyIsPressed( sf::Keyboard::Left ) ||
					keyboard.KeyIsPressed( sf::Keyboard::A    ) )
					m_menuState = MS_YES;

				if( keyboard.KeyIsPressed( sf::Keyboard::Right ) ||
					keyboard.KeyIsPressed( sf::Keyboard::D   ) )
					m_menuState = MS_NO;

				if( keyboard.KeyIsPressed( sf::Keyboard::Return ) )
				{
					if( m_menuState == MS_YES )
						RestartGame();
					if( m_menuState == MS_NO )
						Reset();
				}

				if( m_menuState == MS_YES )
				{
					txtYes.setColor( m_blue );
					txtNo.setColor( m_grey );
				}
				else if( m_menuState == MS_NO )
				{
					txtYes.setColor( m_grey );
					txtNo.setColor( m_blue );
				}


				break;
			}
		}
		break;
	}
}

void MyGame::Draw()
{
	m_eventTime = m_eventClock.getElapsedTime().asSeconds();

	switch( m_screenState )
	{
	case SS_TITLE:
		m_window.draw( txtTitle );

		if( m_eventTime < 0.5f )
			m_window.draw( txtPressEnt );
		else if( m_eventTime > 1.0f )
			m_eventClock.restart();

		break;

	case SS_INGAME:
		{
			switch( m_inGameState )
			{
			case GS_INIT:
				break;

			case GS_THREE:
				m_window.draw( txtThree );
				break;

			case GS_TWO:
				m_window.draw( txtTwo );
				break;

			case GS_ONE:
				m_window.draw( txtOne );
				break;

			case GS_RUN:
				break;

			case GS_PAUSED:
				m_window.draw( txtPaused );
				m_window.draw( txtQuitGame );
				m_window.draw( txtYes );
				m_window.draw( txtNo );
				break;

			case GS_GAMEOVER:
				m_window.draw( txtWinner );
				m_window.draw( txtPlayAgain );
				m_window.draw( txtYes );
				m_window.draw( txtNo );
				break;
			}

			m_scores.Draw( m_window );
			m_player1.Draw( m_window );
			m_player2.Draw( m_window );
			m_ball.Draw( m_window );

			break;
		}
	}
}

void MyGame::InitText()
{
	int centerX = m_window.getSize().x / 2;
	int centerY = m_window.getSize().y / 2;

	m_sqPixFont.loadFromFile( "squarePixel7.ttf" );

	txtTitle = sf::Text( "PONG", m_sqPixFont, 100);
	txtTitle.setColor( m_blue );
	txtTitle.setPosition( centerX - (txtTitle.getLocalBounds().width / 2), 100.0f );

	txtPressEnt = sf::Text( "Press Enter", m_sqPixFont, 30 );
	txtPressEnt.setColor( m_blue );
	txtPressEnt.setPosition( centerX - (txtPressEnt.getLocalBounds().width / 2), 500 );

	txtOne = sf::Text( "1", m_sqPixFont, 100 );
	txtOne.setColor( m_blue );
	txtOne.setPosition( centerX - (txtOne.getLocalBounds().width / 2) - 5, 400 );

	txtTwo = sf::Text( "2", m_sqPixFont, 100 );
	txtTwo.setColor( m_blue );
	txtTwo.setPosition( centerX - (txtTwo.getLocalBounds().width / 2), 400 );

	txtThree = sf::Text( "3", m_sqPixFont, 100 );
	txtThree.setColor( m_blue );
	txtThree.setPosition( centerX - (txtThree.getLocalBounds().width / 2), 400 );

	txtWinner = sf::Text( "Winner", m_sqPixFont, 100 );
	txtWinner.setColor( m_yellow );
	txtWinner.setPosition( centerX - (txtWinner.getLocalBounds().width / 2), 100 );

	txtPaused = sf::Text( "Paused", m_sqPixFont, 100 );
	txtPaused.setColor( m_blue );
	txtPaused.setPosition( centerX - (txtPaused.getLocalBounds().width / 2), 100 );

	txtQuitGame = sf::Text( "Quit game?", m_sqPixFont, 30 );
	txtQuitGame.setColor( m_blue );
	txtQuitGame.setPosition( centerX - (txtQuitGame.getLocalBounds().width / 2), 450 );

	txtPlayAgain = sf::Text( "Play Again?", m_sqPixFont, 30 );
	txtPlayAgain.setColor( m_blue );
	txtPlayAgain.setPosition( centerX - (txtPlayAgain.getLocalBounds().width / 2), 450 );

	txtYes = sf::Text( "Yes", m_sqPixFont, 30 );
	txtYes.setColor( m_grey );
	txtYes.setPosition( centerX - txtYes.getLocalBounds().width - 50, 510);

	txtNo = sf::Text( "No", m_sqPixFont, 30 );
	txtNo.setColor( m_grey );
	txtNo.setPosition( centerX + 50, 510);
}

void MyGame::InitSounds()
{
	m_fearOfDark.openFromFile( "fearofdark.wav" );

	m_blip1Buffer.loadFromFile( "Blip1.wav" );
	m_blip1.setBuffer( m_blip1Buffer );

	m_blip2Buffer.loadFromFile( "Blip2.wav" );
	m_blip2.setBuffer( m_blip2Buffer );

	m_blopBuffer.loadFromFile( "Blop.wav" );
	m_blop.setBuffer( m_blopBuffer );
}

bool MyGame::TestCollision( Paddle paddle, Ball ball )
{
	float padX = paddle.GetPosition().x;
	float padY = paddle.GetPosition().y;
	float padW = paddle.GetSize().x;
	float padH = paddle.GetSize().y;

	float ballX = ball.GetPosition().x;
	float ballY = ball.GetPosition().y;
	float ballW = ball.GetSize().x;
	float ballH = ball.GetSize().y;

	if( padX + padW < ballX || ballX + ballW < padX ) return false;
	if( padY + padH < ballY || ballY + ballH < padY ) return false;

	return true;
}

void MyGame::RestartGame()
{
	m_inGameState = GS_INIT;
	m_menuState = MS_YES;

	m_clock.restart();
	m_eventClock.restart();

	m_player1.Reset();
	m_player2.Reset();
	m_ball.Reset();
	m_scores.Reset();
}

void MyGame::Reset()
{
	m_screenState = SS_TITLE;
	RestartGame();
}

 

Paddle.h

#ifndef PADDLE_H
#define PADDLE_H

#include <SFML\Graphics.hpp>

class Paddle
{
public:
	Paddle();
	Paddle( float posX, int screenHeight, int screenWidth );
	void Update();
	void Draw( sf::RenderWindow& window );

	void MoveUp( float frameTime );
	void MoveDown( float frameTime );
	void Reset();

	sf::Vector2f GetPosition();
	sf::Vector2f GetSize();

private:
	int m_screenWidth, m_screenHeight;

	sf::RectangleShape m_rectangle;
	sf::Vector2f m_position;
	int m_width, m_height;
	float m_moveSpeed;

	// Stored variables for reset.
	float m_initX, m_initY;
};

#endif 

 

Paddle.cpp

#include "Paddle.h"
#include "Keyboard.h"

Paddle::Paddle()
{}

Paddle::Paddle( float posX, int screenWidth, int screenHeight )
:	m_screenWidth( screenWidth ),
	m_screenHeight( screenHeight ),
	m_width( 15 ),
	m_height( 100 ),
	m_moveSpeed( 500 )
{
	m_initX = m_position.x = posX;
	m_initY = m_position.y = ((float)screenHeight / 2.0f) - ((float)m_height / 2.0f);

	m_rectangle = sf::RectangleShape( sf::Vector2f( (float)m_width, (float)m_height ) );
	m_rectangle.setPosition( m_position.x, m_position.y );
	m_rectangle.setFillColor( sf::Color( 0, 100, 200, 255 ) );
}

void Paddle::Update()
{
	// Clamp to screen
	if( m_position.y < 0 )
		m_position.y = 0;
	if( m_position.y + m_height >= m_screenHeight )
		m_position.y = (float)m_screenHeight - (float)m_height;

	m_rectangle.setPosition( m_position.x, m_position.y );
}

void Paddle::Draw( sf::RenderWindow& window )
{
	window.draw( m_rectangle );
}

void Paddle::MoveUp( float frameTime )
{
	m_position.y -= m_moveSpeed * frameTime;
}

void Paddle::MoveDown( float frameTime )
{
	m_position.y += m_moveSpeed * frameTime;
}

sf::Vector2f Paddle::GetPosition()
{
	return m_position;
}

sf::Vector2f  Paddle::GetSize()
{
	sf::Vector2f size;
	size.x = (float)m_width;
	size.y = (float)m_height;
	return size;
}

void Paddle::Reset()
{
	m_position.x = m_initX;
	m_position.y = m_initY;
	m_rectangle.setPosition( m_position.x, m_position.y );
}

 

Ball.h

#ifndef BALL_H
#define BALL_H

#include <SFML\Graphics.hpp>
#include <SFML\Audio.hpp>
#include "Paddle.h"

class Ball
{
public:
	Ball( int screenWidth, int screenHeight );
	void Update( float frameTime );
	void Draw( sf::RenderWindow& window );

	void BounceX();
	void BounceY();
	void BouncePaddle( Paddle paddle );
	void SetXPosition( float x );
	void SetYPosition( float y );
	void IncreaseSpeed();
	void Reset();

	sf::Vector2f GetPosition();
	sf::Vector2f GetSize();
	sf::Vector2f GetSpeed();

private:
	sf::RectangleShape m_rectangle;
	sf::Vector2f m_position;
	int m_width, m_height;
	float m_speedX, m_speedY, m_maxYSpeed;

	// Store variables for reset
	float m_initX, m_initY;
	float m_initYspeed;
};

#endif

 

Ball.cpp

#include "Ball.h"
#include <random>
#include <time.h>

Ball::Ball( int screenWidth, int screenHeight )
:	m_maxYSpeed( 650 ),
	m_initYspeed( 650 )
{
	// Randomize the initial direction.
	srand( (unsigned int)time(NULL) );
	int xDirection = rand() % 2;
	if( xDirection == 0 )
		xDirection = -1;
	m_speedX = xDirection * 600;
	m_speedY = 0;

	m_width = m_height = 10;
	m_initX = m_position.x = (screenWidth / 2) - (m_width / 2);
	m_initY = m_position.y = (screenHeight / 2) - (m_height / 2);

	m_rectangle = sf::RectangleShape( sf::Vector2f( (float)m_width, (float)m_height ) );
	m_rectangle.setPosition( m_position.x, m_position.y );
	m_rectangle.setFillColor( sf::Color( 0, 100, 200, 255 ) );
}

void Ball::Update( float frameTime )
{
	m_position.x += m_speedX * frameTime;
	m_position.y += m_speedY * frameTime;

	m_rectangle.setPosition( m_position.x, m_position.y );
}

void Ball::Draw( sf::RenderWindow& window )
{
	window.draw( m_rectangle );
}

sf::Vector2f Ball::GetPosition()
{
	return m_position;
}

sf::Vector2f Ball::GetSize()
{
	sf::Vector2f size;
	size.x = (float)m_width;
	size.y = (float)m_height;
	return size;
}

sf::Vector2f Ball::GetSpeed()
{
	sf::Vector2f speed;
	speed.x = m_speedX;
	speed.y = m_speedY;
	return speed;
}

void Ball::BounceX()
{
	m_speedX *= -1;
}

void Ball::BounceY()
{
	m_speedY *= -1;
}

void Ball::BouncePaddle( Paddle paddle )
{
	BounceX();

	float paddleY = paddle.GetPosition().y + (paddle.GetSize().y / 2.0f);
	float ballY = m_position.y + (m_height / 2.0f);

	m_speedY = (ballY - paddleY) / (paddle.GetSize().y / 2.0f) * m_maxYSpeed;
}

void Ball::SetXPosition( float x )
{
	m_position.x = x;
}

void Ball::SetYPosition( float y )
{
	m_position.y = y;
}

void Ball::IncreaseSpeed()
{
	if( m_speedX < 0 )
		m_speedX -= 1;
	if( m_speedX > 0 )
		m_speedX += 1;

	m_maxYSpeed += 1;
}

void Ball::Reset()
{
	m_position.x = m_initX;
	m_position.y = m_initY;
	m_maxYSpeed = m_initYspeed;
	m_rectangle.setPosition( m_position.x, m_position.y );

	int xDirection = rand() % 2;
	if( xDirection == 0 )
		xDirection = -1;
	m_speedX = xDirection * 500;
	m_speedY = 0;
}

 

Scores.h

#ifndef SCORES_H
#define SCORES_H

#include <SFML\Graphics.hpp>

class Scores
{
public:
	Scores();
	void Init( sf::Font& font, sf::RenderWindow& window );
	void Update();
	void Draw( sf::RenderWindow& window );

	void Player1Scored();
	void Player2Scored();
	void SetMaxScore( int maxScore );

	bool Winner();

	void Reset();

private:
	int m_player1Score, m_player2Score, m_maxScore;
	sf::Text m_txtScore1, m_txtScore2;

	sf::Color m_grey;
	sf::Color m_yellow;

	bool m_winner;
};

#endif

 

Scores.cpp

#include "Scores.h"

Scores::Scores()
{}

void Scores::Init( sf::Font& font, sf::RenderWindow& window )
{
	m_yellow = sf::Color( 255, 200, 0, 255 );
	m_grey = sf::Color( 20, 20, 20, 255 );

	m_player1Score = 0;
	m_player2Score = 0;
	m_maxScore = 10;
	m_winner = false;
	
	int centerY = window.getSize().y / 2;

	m_txtScore1 = sf::Text( "00", font, 100 );
	m_txtScore1.setColor( m_grey );
	m_txtScore1.setPosition( 350 - m_txtScore1.getLocalBounds().width, centerY - (m_txtScore1.getLocalBounds().height / 2) - m_txtScore1.getLocalBounds().top );

	m_txtScore2 = sf::Text( "00", font, 100 );
	m_txtScore2.setColor( m_grey );
	m_txtScore2.setPosition( 550, centerY - (m_txtScore2.getLocalBounds().height / 2) - m_txtScore2.getLocalBounds().top );
}

void Scores::Update()
{
	if( m_player1Score >= m_maxScore )
	{
		m_player1Score = m_maxScore;
		m_txtScore1.setColor( m_yellow );
		m_winner = true;
	}

	if( m_player2Score >= m_maxScore )
	{
		m_player2Score = m_maxScore;
		m_txtScore2.setColor( m_yellow );
		m_winner = true;
	}

	std::string score1 = std::to_string( (_Longlong)m_player1Score );
	if( m_player1Score < 10 )
		score1 = std::string( "0" ).append( score1 );
	m_txtScore1.setString( score1 );

	std::string score2 = std::to_string( (_Longlong)m_player2Score );
	if( m_player2Score < 10 )
		score2 = std::string( "0" ).append( score2 );
	m_txtScore2.setString( score2 );
}

void Scores::Draw( sf::RenderWindow& window )
{
	window.draw( m_txtScore1 );
	window.draw( m_txtScore2 );
}

void Scores::Player1Scored()
{
	m_player1Score += 1;
}

void Scores::Player2Scored()
{
	m_player2Score += 1;
}

void Scores::SetMaxScore( int maxScore )
{
	m_maxScore = maxScore;
}

bool Scores::Winner()
{
	return m_winner;
}

void Scores::Reset()
{
	m_player1Score = 0;
	m_player2Score = 0;
	m_winner = false;
	m_txtScore1.setColor( m_grey );
	m_txtScore1.setString( "00" );
	m_txtScore2.setColor( m_grey );
	m_txtScore2.setString( "00" );

}

 

 


Loading textures without D3DX?

14 April 2013 - 11:42 AM

I'm trying to learn texture mapping but every tutorial or sample i've seen uses D3DX functions like D3D11XCreateResourceViewFromFile();. Since D3DX is now depricated, how do i load a texture?


Making the final executable.

14 April 2013 - 03:46 AM

How do you make a final build of your program that runs on other computers? I've read different things and im a bit confused. Is the release build the executable that you distribute? I've read somewhere that you need the retail version of Visual studio if you want to create some sort of release version.

 

Also, just using the release build executable alone produces errors such as missing dll's etc. How do i know what dll's i need to include with the executable and is this the right way to share your program?

 

Thanks you.


PARTNERS