The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Building a Simple Game

Next ►
►

In this section, we will walk through the process of building a simple game using OpenGL. This will help you apply the concepts you've learned throughout the course in a practical and engaging way. We will create a basic 2D game where a player controls a character to avoid obstacles.

Objectives

  • Understand the structure of a simple game.
  • Learn how to handle user input.
  • Implement basic game mechanics.
  • Render game objects and handle collisions.

  1. Game Structure

1.1. Game Loop

A game loop is the core of any game. It continuously updates the game state and renders the game scene.

while (!glfwWindowShouldClose(window)) {
    // Process input
    processInput(window);

    // Update game state
    update(deltaTime);

    // Render the game
    render();

    // Swap buffers and poll IO events
    glfwSwapBuffers(window);
    glfwPollEvents();
}

1.2. Initial Setup

Before diving into the game logic, ensure you have a basic OpenGL setup ready. This includes initializing GLFW, creating a window, and setting up GLEW.

if (!glfwInit()) {
    std::cerr << "Failed to initialize GLFW" << std::endl;
    return -1;
}

GLFWwindow* window = glfwCreateWindow(800, 600, "Simple Game", nullptr, nullptr);
if (!window) {
    std::cerr << "Failed to create GLFW window" << std::endl;
    glfwTerminate();
    return -1;
}

glfwMakeContextCurrent(window);
if (glewInit() != GLEW_OK) {
    std::cerr << "Failed to initialize GLEW" << std::endl;
    return -1;
}

  1. Handling User Input

2.1. Keyboard Input

We will use GLFW's input handling functions to process keyboard input.

void processInput(GLFWwindow* window) {
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
        glfwSetWindowShouldClose(window, true);

    if (glfwGetKey(window, GLFW_KEY_LEFT) == GLFW_PRESS)
        player.moveLeft();
    if (glfwGetKey(window, GLFW_KEY_RIGHT) == GLFW_PRESS)
        player.moveRight();
}

2.2. Player Movement

Define a Player class to handle the player's position and movement.

class Player {
public:
    float x, y;
    float speed;

    Player() : x(0.0f), y(-0.8f), speed(0.05f) {}

    void moveLeft() {
        x -= speed;
    }

    void moveRight() {
        x += speed;
    }

    void draw() {
        // Render the player as a simple rectangle
        glBegin(GL_QUADS);
        glVertex2f(x - 0.1f, y - 0.1f);
        glVertex2f(x + 0.1f, y - 0.1f);
        glVertex2f(x + 0.1f, y + 0.1f);
        glVertex2f(x - 0.1f, y + 0.1f);
        glEnd();
    }
};

  1. Game Mechanics

3.1. Obstacles

Create a class for obstacles that the player needs to avoid.

class Obstacle {
public:
    float x, y;
    float speed;

    Obstacle(float startX, float startY, float obstacleSpeed) : x(startX), y(startY), speed(obstacleSpeed) {}

    void update(float deltaTime) {
        y -= speed * deltaTime;
        if (y < -1.0f) {
            y = 1.0f; // Reset position
            x = static_cast<float>(rand() % 200 - 100) / 100.0f; // Randomize x position
        }
    }

    void draw() {
        // Render the obstacle as a simple rectangle
        glBegin(GL_QUADS);
        glVertex2f(x - 0.1f, y - 0.1f);
        glVertex2f(x + 0.1f, y - 0.1f);
        glVertex2f(x + 0.1f, y + 0.1f);
        glVertex2f(x - 0.1f, y + 0.1f);
        glEnd();
    }
};

3.2. Collision Detection

Implement a simple collision detection mechanism.

bool checkCollision(Player& player, Obstacle& obstacle) {
    return (abs(player.x - obstacle.x) < 0.2f && abs(player.y - obstacle.y) < 0.2f);
}

  1. Rendering

4.1. Rendering the Scene

In the render function, clear the screen and draw the player and obstacles.

void render(Player& player, std::vector<Obstacle>& obstacles) {
    glClear(GL_COLOR_BUFFER_BIT);

    player.draw();
    for (auto& obstacle : obstacles) {
        obstacle.draw();
    }
}

4.2. Updating the Game State

Update the game state by moving the obstacles and checking for collisions.

void update(float deltaTime, Player& player, std::vector<Obstacle>& obstacles) {
    for (auto& obstacle : obstacles) {
        obstacle.update(deltaTime);
        if (checkCollision(player, obstacle)) {
            std::cout << "Game Over!" << std::endl;
            glfwSetWindowShouldClose(window, true);
        }
    }
}

  1. Putting It All Together

5.1. Main Function

Combine all the components in the main function.

int main() {
    // Initialize GLFW and GLEW, create window (code omitted for brevity)

    Player player;
    std::vector<Obstacle> obstacles = {
        Obstacle(0.0f, 1.0f, 0.5f),
        Obstacle(-0.5f, 1.5f, 0.3f),
        Obstacle(0.5f, 2.0f, 0.4f)
    };

    while (!glfwWindowShouldClose(window)) {
        float currentFrame = glfwGetTime();
        deltaTime = currentFrame - lastFrame;
        lastFrame = currentFrame;

        processInput(window);
        update(deltaTime, player, obstacles);
        render(player, obstacles);

        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glfwTerminate();
    return 0;
}

Conclusion

In this section, we built a simple 2D game using OpenGL. We covered the game loop, handling user input, implementing game mechanics, and rendering the game scene. This project serves as a foundation for more complex games and applications. Continue experimenting and adding features to enhance your game development skills.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved