#include <SFML/Graphics.
hpp>
#include <SFML/Window.hpp>
#include <SFML/System.hpp>
#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
// ============================================================================
// Constants - Game Configuration
// ============================================================================
const int WINDOW_WIDTH = 800;
const int WINDOW_HEIGHT = 600;
const float GRAVITY = 1000.0f; // Downward acceleration (pixels/second^2)
const float JUMP_VELOCITY = -400.0f; // Initial upward velocity when the bird
jumps (pixels/second)
const float PIPE_SPEED = 200.0f; // Speed at which pipes move horizontally
(pixels/second)
const float PIPE_WIDTH = 70.0f; // Width of the pipes (pixels)
const float PIPE_GAP_SIZE = 200.0f; // Vertical gap between the top and
bottom pipes (pixels)
const float PIPE_SPAWN_INTERVAL = 1.5f; // Time interval between spawning new
pipe pairs (seconds)
// ============================================================================
// Structures - Data Representation
// ============================================================================
// Represents the bird
struct Bird {
sf::Sprite sprite; // Sprite for the bird
float velocity; // Vertical velocity of the bird
};
// Represents a pipe (top or bottom)
struct Pipe {
sf::Sprite sprite; // Sprite for the pipe
};
// ============================================================================
// Function Declarations
// ============================================================================
void updateBird(Bird& bird, float deltaTime);
std::pair<Pipe, Pipe> createPipePair(sf::Texture& pipeTexture);
void updatePipes(std::vector<std::pair<Pipe,Pipe>>& pipes, float deltaTime); //Pass
vector as pair of pipes
bool checkCollision(const Bird& bird, const std::vector<std::pair<Pipe,Pipe>>&
pipes); //Pass vector as pair of pipes
void resetGame(Bird& bird, std::vector<std::pair<Pipe,Pipe>>& pipes); //Pass vector
as pair of pipes
// ============================================================================
// Main Function - Entry Point
// ============================================================================
int main() {
// Seed the random number generator
std::srand(static_cast<unsigned int>(std::time(nullptr)));
// Create the game window
sf::RenderWindow window(sf::VideoMode(WINDOW_WIDTH, WINDOW_HEIGHT), "Flappy
Bird");
window.setFramerateLimit(60);
// ========================================================================
// Load Textures - Load game assets from files
// ========================================================================
sf::Texture birdTexture;
if (!birdTexture.loadFromFile("bird.png")) { // Replace with your bird image
file
std::cerr << "Error loading bird texture!" << std::endl;
return -1;
}
sf::Texture pipeTexture;
if (!pipeTexture.loadFromFile("pipe.png")) { // Replace with your pipe image
file
std::cerr << "Error loading pipe texture!" << std::endl;
return -1;
}
sf::Texture backgroundTexture;
if (!backgroundTexture.loadFromFile("background.png")) { // Replace with your
background image
std::cerr << "Error loading background texture!" << std::endl;
return -1;
}
sf::Sprite backgroundSprite(backgroundTexture);
// ========================================================================
// Initialize Game Objects
// ========================================================================
// Bird Initialization
Bird bird;
bird.sprite.setTexture(birdTexture);
bird.sprite.setPosition(100, WINDOW_HEIGHT / 2);
bird.velocity = 0.0f;
bird.sprite.setOrigin(birdTexture.getSize().x / 2.0f, birdTexture.getSize().y /
2.0f); // Set origin to center for rotation
// Pipes Initialization
std::vector<std::pair<Pipe,Pipe>> pipePairs; // Vector to store pairs of top
and bottom pipes
float pipeSpawnTimer = 0.0f;
// ========================================================================
// Game State Variables
// ========================================================================
bool isGameOver = false;
int score = 0;
// ========================================================================
// Load Font - Load a font for displaying text
// ========================================================================
sf::Font font;
if (!font.loadFromFile("arial.ttf")) {
std::cerr << "Error loading font!" << std::endl;
return -1;
}
// ========================================================================
// Initialize Text - Initialize the score and game over text
// ========================================================================
sf::Text scoreText;
scoreText.setFont(font);
scoreText.setString("Score: " + std::to_string(score));
scoreText.setCharacterSize(24);
scoreText.setFillColor(sf::Color::White);
scoreText.setPosition(10, 10);
sf::Text gameOverText;
gameOverText.setFont(font);
gameOverText.setString("Game Over! Press Space to Restart!");
gameOverText.setCharacterSize(30);
gameOverText.setFillColor(sf::Color::Red);
gameOverText.setPosition(WINDOW_WIDTH / 2 - gameOverText.getLocalBounds().width
/ 2,
WINDOW_HEIGHT / 2 - gameOverText.getLocalBounds().height
/ 2);
// ========================================================================
// Game Loop - Main game loop
// ========================================================================
sf::Clock clock; // Used to calculate elapsed time
while (window.isOpen()) {
float deltaTime = clock.restart().asSeconds(); // Time elapsed since last
frame
// ====================================================================
// Event Handling - Process user input and window events
// ====================================================================
sf::Event event;
while (window.pollEvent(event)) {
if (event.type == sf::Event::Closed) {
window.close();
}
if (event.type == sf::Event::KeyPressed && event.key.code ==
sf::Keyboard::Space) {
if (isGameOver) {
// Restart the game if it's game over
resetGame(bird, pipePairs);
isGameOver = false;
score = 0;
scoreText.setString("Score: " + std::to_string(score));
} else {
// Make the bird jump
bird.velocity = JUMP_VELOCITY;
}
}
}
// ====================================================================
// Update - Update game logic only if the game is not over
// ====================================================================
if (!isGameOver) {
// Update the bird's position
updateBird(bird, deltaTime);
// Spawn new pipes
pipeSpawnTimer += deltaTime;
if (pipeSpawnTimer >= PIPE_SPAWN_INTERVAL) {
std::pair<Pipe,Pipe> newPipePair = createPipePair(pipeTexture);
pipePairs.push_back(newPipePair);
pipeSpawnTimer = 0.0f;
}
// Update the pipes' positions
updatePipes(pipePairs, deltaTime);
// Check for collisions
if (checkCollision(bird, pipePairs)) {
isGameOver = true;
}
//Check if bird is out of bound
if (bird.sprite.getPosition().y < 0 || bird.sprite.getPosition().y >
WINDOW_HEIGHT)
{
isGameOver = true;
}
// Score increment (very basic)
for (auto& pipePair : pipePairs) { // Use auto& to get a reference to
the pair
Pipe& topPipe = pipePair.first; // Reference to the top pipe
if (topPipe.sprite.getPosition().x + PIPE_WIDTH <
bird.sprite.getPosition().x &&
topPipe.sprite.getPosition().x + PIPE_WIDTH + PIPE_SPEED *
deltaTime >= bird.sprite.getPosition().x) {
score++;
scoreText.setString("Score: " + std::to_string(score));
break;
}
}
}
// ====================================================================
// Render - Draw everything to the screen
// ====================================================================
window.clear(); // Clear the window
// Draw the background
window.draw(backgroundSprite);
// Draw the bird
window.draw(bird.sprite);
// Draw the pipes
for (auto& pipePair : pipePairs) {
window.draw(pipePair.first.sprite);
window.draw(pipePair.second.sprite);
}
// Draw the score
window.draw(scoreText);
// Draw the game over text if the game is over
if (isGameOver) {
window.draw(gameOverText);
}
window.display(); // Display the rendered frame
}
return 0;
}
// ============================================================================
// Function Implementations
// ============================================================================
// Updates the bird's position and rotation
void updateBird(Bird& bird, float deltaTime) {
// Apply gravity
bird.velocity += GRAVITY * deltaTime;
bird.sprite.move(0, bird.velocity * deltaTime);
// Rotate the bird based on the velocity
float rotationAngle = bird.velocity * 0.05; // Adjust multiplier to your
liking
rotationAngle = std::max(-45.0f, std::min(45.0f, rotationAngle)); // Limit
rotation
bird.sprite.setRotation(rotationAngle);
}
// Creates a pair of top and bottom pipes with a random gap position
std::pair<Pipe, Pipe> createPipePair(sf::Texture& pipeTexture) {
Pipe topPipe, bottomPipe;
float gapPosition = (float)(std::rand() % (int)(WINDOW_HEIGHT - PIPE_GAP_SIZE -
100)) + 50; // Ensure gap is within bounds
// Top Pipe
topPipe.sprite.setTexture(pipeTexture);
topPipe.sprite.setPosition(WINDOW_WIDTH, gapPosition -
pipeTexture.getSize().y);
topPipe.sprite.setRotation(180); // Rotate top pipe to face down
// Bottom Pipe
bottomPipe.sprite.setTexture(pipeTexture);
bottomPipe.sprite.setPosition(WINDOW_WIDTH, gapPosition + PIPE_GAP_SIZE);
return std::make_pair(topPipe, bottomPipe);
}
// Updates the position of the pipes, moving them to the left
void updatePipes(std::vector<std::pair<Pipe,Pipe>>& pipePairs, float deltaTime) {
for (size_t i = 0; i < pipePairs.size(); ++i) {
pipePairs[i].first.sprite.move(-PIPE_SPEED * deltaTime, 0); // Move top
pipe
pipePairs[i].second.sprite.move(-PIPE_SPEED * deltaTime, 0); // Move bottom
pipe
// Remove pipes that have gone off-screen
if (pipePairs[i].first.sprite.getPosition().x < -PIPE_WIDTH) {
pipePairs.erase(pipePairs.begin() + i); //Erase the pipe
break;
}
}
}
// Checks for collisions between the bird and the pipes
bool checkCollision(const Bird& bird, const std::vector<std::pair<Pipe,Pipe>>&
pipePairs) {
sf::FloatRect birdBounds = bird.sprite.getGlobalBounds();
for (const auto& pipePair : pipePairs) {
if (birdBounds.intersects(pipePair.first.sprite.getGlobalBounds()) ||
birdBounds.intersects(pipePair.second.sprite.getGlobalBounds())) {
return true;
}
}
return false;
}
// Resets the game state
void resetGame(Bird& bird, std::vector<std::pair<Pipe,Pipe>>& pipePairs) {
bird.sprite.setPosition(100, WINDOW_HEIGHT / 2);
bird.velocity = 0.0f;
pipePairs.clear(); // Remove all pipes
}
