#include <SDL.h>
#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
// Constants
const int SCREEN_WIDTH = 640;
const int SCREEN_HEIGHT = 480;
const int CELL_SIZE = 20;
const int GRID_WIDTH = SCREEN_WIDTH / CELL_SIZE;
const int GRID_HEIGHT = SCREEN_HEIGHT / CELL_SIZE;
// Struct for representing a point on the grid
struct Point {
int x, y;
};
// Enumeration for different game states
enum GameState {
PLAY,
GAME_OVER
};
// Function prototypes
void initializeSDL();
SDL_Window* createWindow();
SDL_Renderer* createRenderer(SDL_Window* window);
void handleInput(SDL_Event& event, bool& quit, GameState& gameState);
void generateObstacle(std::vector<Point>& obstacles, Point& food);
void drawGrid(SDL_Renderer* renderer);
void drawSnake(SDL_Renderer* renderer, const std::vector<Point>& snake);
void drawObstacles(SDL_Renderer* renderer, const std::vector<Point>& obstacles);
void drawFood(SDL_Renderer* renderer, const Point& food);
bool checkCollision(const Point& p1, const Point& p2);
bool checkSelfCollision(const std::vector<Point>& snake);
bool checkObstacleCollision(const Point& head, const std::vector<Point>& obstacles);
int main() {
initializeSDL();
SDL_Window* window = createWindow();
SDL_Renderer* renderer = createRenderer(window);
// Initialize game variables
std::vector<Point> snake = {{GRID_WIDTH / 2, GRID_HEIGHT / 2}};
std::vector<Point> obstacles;
Point food;
GameState gameState = PLAY;
srand(time(nullptr));
bool quit = false;
while (!quit) {
SDL_Event event;
while (SDL_PollEvent(&event)) {
handleInput(event, quit, gameState);
}
if (gameState == PLAY) {
// Move the snake
Point head = snake.front();
Point newHead = head;
switch (rand() % 4) {
case 0:
newHead.x += 1;
break;
case 1:
newHead.x -= 1;
break;
case 2:
newHead.y += 1;
break;
case 3:
newHead.y -= 1;
break;
}
// Check for collisions
if (checkCollision(newHead, food)) {
snake.push_back(newHead);
generateObstacle(obstacles, food);
} else {
snake.insert(snake.begin(), newHead);
snake.pop_back();
}
if (checkSelfCollision(snake) || checkObstacleCollision(newHead, obstacles) ||
newHead.x < 0 || newHead.x >= GRID_WIDTH || newHead.y < 0 || newHead.y >= GRID_HEIGHT) {
gameState = GAME_OVER;
}
// Clear the screen
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
SDL_RenderClear(renderer);
// Draw game elements
drawGrid(renderer);
drawSnake(renderer, snake);
drawObstacles(renderer, obstacles);
drawFood(renderer, food);
// Update the screen
SDL_RenderPresent(renderer);
// Add a delay to control the speed of the game
SDL_Delay(100);
} else if (gameState == GAME_OVER) {
std::cout << "Game Over!\n";
quit = true;
}
}
// Cleanup and close the SDL window
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();
return 0;
}
void initializeSDL() {
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
std::cerr << "SDL initialization failed: " << SDL_GetError() << std::endl;
exit(1);
}
}
SDL_Window* createWindow() {
SDL_Window* window = SDL_CreateWindow("Snake Game", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
if (!window) {
std::cerr << "Window creation failed: " << SDL_GetError() << std::endl;
exit(1);
}
return window;
}
SDL_Renderer* createRenderer(SDL_Window* window) {
SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
if (!renderer) {
std::cerr << "Renderer creation failed: " << SDL_GetError() << std::endl;
exit(1);
}
return renderer;
}
void handleInput(SDL_Event& event, bool& quit, GameState& gameState) {
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_QUIT:
quit = true;
break;
case SDL_KEYDOWN:
switch (event.key.keysym.sym) {
case SDLK_ESCAPE:
quit = true;
break;
case SDLK_q:
quit = true;
break;
}
break;
}
}
}
void generateObstacle(std::vector<Point>& obstacles, Point& food) {
Point obstacle;
do {
obstacle = {rand() % GRID_WIDTH, rand() % GRID_HEIGHT};
} while (checkCollision(obstacle, food) || checkCollision(obstacle, {GRID_WIDTH / 2, GRID_HEIGHT / 2}));
obstacles.push_back(obstacle);
}
void drawGrid(SDL_Renderer* renderer) {
SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
for (int i = 0; i < SCREEN_WIDTH; i += CELL_SIZE) {
SDL_RenderDrawLine(renderer, i, 0, i, SCREEN_HEIGHT);
}
for (int i = 0; i < SCREEN_HEIGHT; i += CELL_SIZE) {
SDL_RenderDrawLine(renderer, 0, i, SCREEN_WIDTH, i);
}
}
void drawSnake(SDL_Renderer* renderer, const std::vector<Point>& snake) {
SDL_SetRenderDrawColor(renderer, 0, 255, 0, 255);
for (const auto& point : snake) {
SDL_Rect rect = {point.x * CELL_SIZE, point.y * CELL_SIZE, CELL_SIZE, CELL_SIZE};
SDL_RenderFillRect(renderer, &rect);
}
}
void drawObstacles(SDL_Renderer* renderer, const std::vector<Point>& obstacles) {
SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
for (const auto& point : obstacles) {
SDL_Rect rect = {point.x * CELL_SIZE, point.y * CELL_SIZE, CELL_SIZE, CELL_SIZE};
SDL_RenderFillRect(renderer, &rect);
}
}
void drawFood(SDL_Renderer* renderer, const Point& food) {
SDL_SetRenderDrawColor(renderer, 0, 0, 255, 255);
SDL_Rect rect = {food.x * CELL_SIZE, food.y * CELL_SIZE, CELL_SIZE, CELL_SIZE};
SDL_RenderFillRect(renderer, &rect);
}
bool checkCollision(const Point& p1, const Point& p2) {
return p1.x == p2.x && p1.y == p2.y;
}
bool checkSelfCollision(const std::vector<Point>& snake) {
Point head = snake.front();
for (auto it = snake.begin() + 1; it != snake.end(); ++it) {
if (checkCollision(head, *it)) {
return true;
}
}
return false;
}
bool checkObstacleCollision(const Point& head, const std::vector<Point>& obstacles) {
for (const auto& obstacle : obstacles) {
if (checkCollision(head, obstacle)) {
return true;
}
}
return false;
}
Write, Run & Share C++ code online using OneCompiler's C++ online compiler for free. It's one of the robust, feature-rich online compilers for C++ language, running on the latest version 17. Getting started with the OneCompiler's C++ compiler is simple and pretty fast. The editor shows sample boilerplate code when you choose language as C++ and start coding!
OneCompiler's C++ online compiler supports stdin and users can give inputs to programs using the STDIN textbox under the I/O tab. Following is a sample program which takes name as input and print your name with hello.
#include <iostream>
#include <string>
using namespace std;
int main()
{
string name;
cout << "Enter name:";
getline (cin, name);
cout << "Hello " << name;
return 0;
}
C++ is a widely used middle-level programming language.
When ever you want to perform a set of operations based on a condition If-Else is used.
if(conditional-expression) {
//code
}
else {
//code
}
You can also use if-else for nested Ifs and If-Else-If ladder when multiple conditions are to be performed on a single variable.
Switch is an alternative to If-Else-If ladder.
switch(conditional-expression){
case value1:
// code
break; // optional
case value2:
// code
break; // optional
......
default:
code to be executed when all the above cases are not matched;
}
For loop is used to iterate a set of statements based on a condition.
for(Initialization; Condition; Increment/decrement){
//code
}
While is also used to iterate a set of statements based on a condition. Usually while is preferred when number of iterations are not known in advance.
while (condition) {
// code
}
Do-while is also used to iterate a set of statements based on a condition. It is mostly used when you need to execute the statements atleast once.
do {
// code
} while (condition);
Function is a sub-routine which contains set of statements. Usually functions are written when multiple calls are required to same set of statements which increases re-usuability and modularity. Function gets run only when it is called.
return_type function_name(parameters);
function_name (parameters)
return_type function_name(parameters) {
// code
}