GPT-4 создала за несколько десятков секунд по короткому ТЗ рабочую версию Pong, Asteroids, Breakout и Pac-Man

#include <SDL.h>

#include <SDL_image.h>

#include <iostream>

// Constants
const int SCREEN_WIDTH = 640;
const int SCREEN_HEIGHT = 480;
const int BRICK_WIDTH = 60;
const int BRICK_HEIGHT = 20;
const int PADDLE_WIDTH = 80;
const int PADDLE_HEIGHT = 10;
const int BALL_RADIUS = 5;
const int BALL_SPEED = 5;

// Game object classes
class Ball {
  public: Ball(SDL_Texture * texture, int x, int y);
  void update();
  void render(SDL_Renderer * renderer);
  void reset();
  int getX() {
    return m_x;
  }
  int getY() {
    return m_y;
  }
  int getRadius() {
    return BALL_RADIUS;
  }
  private: int m_x,
  m_y;
  int m_vx,
  m_vy;
  SDL_Texture * m_texture;
};

class Paddle {
  public: Paddle(SDL_Texture * texture, int x, int y);
  void update();
  void render(SDL_Renderer * renderer);
  int getX() {
    return m_x;
  }
  int getY() {
    return m_y;
  }
  int getWidth() {
    return PADDLE_WIDTH;
  }
  private: int m_x,
  m_y;
  int m_vx;
  SDL_Texture * m_texture;
};

class Brick {
  public: Brick(SDL_Texture * texture, int x, int y);
  void render(SDL_Renderer * renderer);
  bool isDestroyed() {
    return m_destroyed;
  }
  void destroy() {
    m_destroyed = true;
  }
  int getX() {
    return m_x;
  }
  int getY() {
    return m_y;
  }
  int getWidth() {
    return BRICK_WIDTH;
  }
  int getHeight() {
    return BRICK_HEIGHT;
  }
  private: int m_x,
  m_y;
  bool m_destroyed;
  SDL_Texture * m_texture;
};

// Helper functions
bool checkCollision(Ball ball, Paddle paddle);
bool checkCollision(Ball ball, Brick brick);

// Main function
int main(int argc, char ** argv) {
  // Initialize SDL
  if (SDL_Init(SDL_INIT_VIDEO) != 0) {
    std::cout << "SDL_Init error: " << SDL_GetError() << std::endl;
    return 1;
  }
  // Create the window and renderer
  SDL_Window * window = SDL_CreateWindow("Arkanoid", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH, SCREEN_HEIGHT, 0);
  if (!window) {
    std::cout << "SDL_CreateWindow error: " << SDL_GetError() << std::endl;
    return 1;
  }
  SDL_Renderer * renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
  if (!renderer) {
    std::cout << "SDL_CreateRenderer error: " << SDL_GetError() << std::endl;
    return 1;
  }
  // Load textures
  SDL_Surface * ballSurface = IMG_Load("ball.png");
  SDL_Texture * ballTexture = SDL_CreateTextureFromSurface(renderer, ballSurface);
  SDL_FreeSurface(ballSurface);
  SDL_Surface * paddleSurface = IMG_Load("paddle.png");
  SDL_Texture * paddleTexture = SDL_CreateTextureFromSurface(renderer, paddleSurface);
  SDL_FreeSurface(paddleSurface);
  SDL_Surface * brickSurface = IMG_Load("brick.png");
  SDL_Texture * brickTexture = SDL_CreateTextureFromSurface(renderer, brickSurface);
  SDL_FreeSurface(brickSurface);
  // Initialize game objects
  Ball ball(ballTexture, SCREEN_WIDTH / 2, SCREEN_HEIGHT - PADDLE_HEIGHT - BALL_RADIUS);
  Paddle paddle(paddleTexture, SCREEN_WIDTH / 2 - PADDLE_WIDTH / 2, SCREEN_HEIGHT - PADDLE_HEIGHT);
  Brick bricks[6][10];
  for (int i = 0; i < 6; i++) {
    for (int j = 0; j < 10; j++) {
      bricks[i][j] = Brick(brickTexture, j * (BRICK_WIDTH + 2) + 1, i * (BRICK_HEIGHT + 2) + 1);
    }
  }
  // Game loop
  bool quit = false;
  while (!quit) {
    // Handle events
    SDL_Event event;
    while (SDL_PollEvent( & event)) {
      if (event.type == SDL_QUIT) {
        quit = true;
      } else if (event.type == SDL_KEYDOWN) {
        switch (event.key.keysym.sym) {
        case SDLK_LEFT:
          paddle.moveLeft();
          break;
        case SDLK_RIGHT:
          paddle.moveRight();
          break;
        }
      }
    }
    // Update game objects
    ball.update();
    paddle.update();
    for (int i = 0; i < 6; i++) {
      for (int j = 0; j < 10; j++) {
        if (checkCollision(ball, bricks[i][j]) && !bricks[i][j].isDestroyed()) {
          ball.reverseY();
          bricks[i][j].destroy();
        }
      }
    }
    if (checkCollision(ball, paddle)) {
      ball.reverseY();
    }
    // Render game objects
    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
    SDL_RenderClear(renderer);
    ball.render(renderer);
    paddle.render(renderer);
    for (int i = 0; i < 6; i++) {
      for (int j = 0; j < 10; j++) {
        if (!bricks[i][j].isDestroyed()) {
          bricks[i][j].render(renderer);
        }
      }
    }
    SDL_RenderPresent(renderer);
  }
  // Clean up
  SDL_DestroyTexture(ballTexture);
  SDL_DestroyTexture(paddleTexture);
  SDL_DestroyTexture(brickTexture);
  SDL_DestroyRenderer(renderer);
  SDL_DestroyWindow(window);
  SDL_Quit();
  return 0;

}

// Ball implementation
Ball::Ball(SDL_Texture * texture, int x, int y) {
  m_texture = texture;
  m_x = x;
  m_y = y;
  m_vx = BALL_SPEED;
  m_vy = -BALL_SPEED;
}

void Ball::update() {
  m_x += m_vx;
  m_y += m_vy;
  if (m_x < BALL_RADIUS || m_x > SCREEN_WIDTH - BALL_RADIUS) {
    reverseX();
  }
  if (m_y < BALL_RADIUS) {
    reverseY();
  }
  if (m_y > SCREEN_HEIGHT - PADDLE_HEIGHT - BALL_RADIUS) {
    if (m_x > paddle.getX() && m_x < paddle.getX() + PADDLE_WIDTH) {
      m_y = SCREEN_HEIGHT - PADDLE_HEIGHT - BALL_RADIUS;
      reverseY();
    } else {
      // Ball is out of bounds, reset position and velocity
      m_x = SCREEN_WIDTH / 2;
      m_y = SCREEN_HEIGHT - PADDLE_HEIGHT - BALL_RADIUS;
      m_vx = BALL_SPEED;
      m_vy = -BALL_SPEED;
    }
  }
}

void Ball::render(SDL_Renderer * renderer) {
  SDL_Rect rect = {
    m_x - BALL_RADIUS,
    m_y - BALL_RADIUS,
    BALL_RADIUS * 2,
    BALL_RADIUS * 2
  };
  SDL_RenderCopy(renderer, m_texture, NULL, & rect);
}

void Ball::reverseX() {
  m_vx = -m_vx;
}

void Ball::reverseY() {
  m_vy = -m_vy;
}

// Paddle implementation
Paddle::Paddle(SDL_Texture * texture, int x, int y) {
  m_texture = texture;
  m_x = x;
  m_y = y;
}

void Paddle::moveLeft() {
  m_x -= PADDLE_SPEED;
  if (m_x < 0) {
    m_x = 0;
  }
}

void Paddle::moveRight() {
  m_x += PADDLE_SPEED;
  if (m_x > SCREEN_WIDTH - PADDLE_WIDTH) {
    m_x = SCREEN_WIDTH - PADDLE_WIDTH;
  }
}

void Paddle::update() {

}

void Paddle::render(SDL_Renderer * renderer) {
  SDL_Rect rect = {
    m_x,
    m_y,
    PADDLE_WIDTH,
    PADDLE_HEIGHT
  };
  SDL_RenderCopy(renderer, m_texture, NULL, & rect);
}

// Brick implementation
Brick::Brick(SDL_Texture * texture, int x, int y) {
  m_texture = texture;
  m_x = x;
  m_y = y;
  m_destroyed = false;
}

void Brick::destroy() {
  m_destroyed = true;
}

bool Brick::isDestroyed() {
  return m_destroyed;
}

void Brick::render(SDL_Renderer * renderer) {
  SDL_Rect rect = {
    m_x,
    m_y,
    BRICK_WIDTH,
    BRICK_HEIGHT
  };
  SDL_RenderCopy(renderer, m_texture, NULL, & rect);
}

bool checkCollision(Ball ball, Paddle paddle) {
  int ballLeft = ball.getX() - BALL_RADIUS;
  int ballRight = ball.getX() + BALL_RADIUS;
  int ballTop = ball.getY() - BALL_RADIUS;
  int ballBottom = ball.getY() + BALL_RADIUS;
  int paddleLeft = paddle.getX();
  int paddleRight = paddle.getX() + PADDLE_WIDTH;
  int paddleTop = paddle.getY();
  int paddleBottom = paddle.getY() + PADDLE_HEIGHT;
  if (ballBottom >= paddleTop && ballTop <= paddleBottom && ballRight >= paddleLeft && ballLeft <= paddleRight) {
    return true;
  }
  return false;
}

bool checkCollision(Ball ball, Brick brick) {
  int ballLeft = ball.getX() - BALL_RADIUS;
  int ballRight = ball.getX() + BALL_RADIUS;
  int ballTop = ball.getY() - BALL_RADIUS;
  int ballBottom = ball.getY() + BALL_RADIUS;
  int brickLeft = brick.getX();
  int brickRight = brick.getX() + BRICK_WIDTH;
  int brickTop = brick.getY();
  int brickBottom = brick.getY() + BRICK_HEIGHT;
  if (ballBottom >= brickTop && ballTop <= brickBottom && ballRight >= brickLeft && ballLeft <= brickRight) {
    return true;
  }
  return false;
}

int main(int argc, char * argv[]) {
  // Initialize SDL
  SDL_Init(SDL_INIT_VIDEO);

  // Create a window
  SDL_Window * window = SDL_CreateWindow("Arkanoid", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, 0);

  // Create a renderer
  SDL_Renderer * renderer = SDL_CreateRenderer(window, -1, 0);

  // Load textures
  SDL_Surface * ballSurface = IMG_Load("ball.png");
  SDL_Texture * ballTexture = SDL_CreateTextureFromSurface(renderer, ballSurface);
  SDL_FreeSurface(ballSurface);

  SDL_Surface * paddleSurface = IMG_Load("paddle.png");
  SDL_Texture * paddleTexture = SDL_CreateTextureFromSurface(renderer, paddleSurface);
  SDL_FreeSurface(paddleSurface);

  SDL_Surface * brickSurface = IMG_Load("brick.png");
  SDL_Texture * brickTexture = SDL_CreateTextureFromSurface(renderer, brickSurface);
  SDL_FreeSurface(brickSurface);

  // Initialize game objects
  Ball ball(ballTexture, SCREEN_WIDTH / 2, SCREEN_HEIGHT - PADDLE_HEIGHT - BALL_RADIUS);
  Paddle paddle(paddleTexture, SCREEN_WIDTH / 2 - PADDLE_WIDTH / 2, SCREEN_HEIGHT - PADDLE_HEIGHT);
  std::vector < Brick > bricks;
  for (int i = 0; i < NUM_BRICKS; i++) {
    int x = (i % BRICKS_PER_ROW) * (BRICK_WIDTH + BRICK_GAP) + BRICK_OFFSET_X;
    int y = (i / BRICKS_PER_ROW) * (BRICK_HEIGHT + BRICK_GAP) + BRICK_OFFSET_Y;
    Brick brick(brickTexture, x, y);
    bricks.push_back(brick);
  }

  // Game loop
  bool running = true;
  while (running) {
    // Handle events
    SDL_Event event;
    while (SDL_PollEvent( & event)) {
      if (event.type == SDL_QUIT) {
        running = false;
      } else if (event.type == SDL_KEYDOWN) {
        switch (event.key.keysym.sym) {
        case SDLK_LEFT:
          paddle.moveLeft();
          break;
        case SDLK_RIGHT:
          paddle.moveRight();
          break;
        }
      }
    }

    // Update game objects
    ball.update();
    if (checkCollision(ball, paddle)) {
      ball.reverseY();
    }
    for (int i = 0; i < bricks.size(); i++) {
      if (!bricks[i].isDestroyed() && checkCollision(ball, bricks[i])) {
        bricks[i].destroy();
        ball.reverseY();
      }
    }

    // Clear screen
    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
    SDL_RenderClear(renderer);

    // Render game objects
    ball.render(renderer);
    paddle.render(renderer);
    for (int i = 0; i < bricks.size(); i++) {
      if (!bricks[i].isDestroyed()) {
        bricks[i].render(renderer);
      }
    }

    // Update screen
    SDL_RenderPresent(renderer);

    // Delay to control frame rate
    SDL_Delay(16);
  }

  // Clean up
  SDL_DestroyTexture(ballTexture);
  SDL_DestroyTexture(paddleTexture);
  SDL_DestroyTexture(brickTexture);
  SDL_DestroyRenderer(renderer);
  SDL_DestroyWindow(window);
  SDL_Quit();

  return 0;
}