/* IMPORTANT: This code is seperated in classes, because sl doesn't support multiple files, all classes will be here, because of that, sl compiler won't work. This little program was tested on Ubuntu, compiling from the terminal: g++ main.cpp Game.hpp Game.cpp SnakeGame.hpp SnakeGame.cpp Snake.hpp Snake.cpp -Wall -Wextra -std=c++11 -lSDL2 -lSDL2_mixer -lSDL2_image -o main Because this snake demo game uses SDL 2, is important to have SDL 2 installed if you want to compile. DOESN'T WORK ON WINDOWS 10, or at least I don't know how to make it work on Windows 10, throws the next error: 16 BIT APPLICATION NON COMPATIBLE. If you see this code (without seeing the post) and you know how to solve this problem and make it work on windows 10, please, visit the post and let your answer. https://www.sololearn.com/Discuss/1728761/is-there-a-way-to-make-this-c-snake-game-demo-functional-on-windows-10 THIS IS A LITTLE DEMO, BUT IT HAS EVERYTHING NECESSARY TO MAKE A FUNCTIONAL SNAKE GAME. THERE IS A LOT OF WORK TO DO YET. BECAUSE THIS SNAKE IMPLEMENTS 1 IMAGE .BMP, AND TWO .WAV FILES, FEEL FREE TO DOWNLOAD YOUR .BMP FILE AND .WAV FILES AND IMPLEMENT IT IN THE CODE. THE .BMP IT HAS AN SPECIFIC WIDTH (259) AND HEIGHT (194), CHECK YOUR IMAGE RESOLUTION AND CHANGE THE LINES 651 AND 652 TO FIT YOUR IMAGE RESOLUTION. ALSO THE .WAV THAT IS USED FOR MUSIC, IT DOESN'T HAS TO BE SO LONG. */ /* AUTHOR: EDUARDO PEREZ REGIN, SESACION ECHAURI. ORGANIZATION: CUCEI, DATE: 18/03/2019 */ /*************************** main.cpp **************************************************/ #include #include "SnakeGame.hpp" int main(){ SnakeGame snakeGame; return 0; } /************************** Game.hpp ***************************************************/ #ifndef GAME_HPP #define GAME_HPP #include #include #include #include class Game{ private: bool isRunning; // To know if the game is running. SDL_Window* window; // Holds all info about the window itself: size, position, full screen etc. SDL_Renderer* renderer; // Handles all rendering, it can only render within that SDL_Window. Contains the rendering state. protected: SDL_Surface* surface; SDL_Window* windowGameOver; // Will display the window that say game over. SDL_Surface* gameOverImage; // Game Over Image. private: /* Width and height of the window. */ int width; int height; Mix_Chunk* effectEat; // Used to be the sound effect. Mix_Music* music; // Used for the music. int channel; // What channel the sound is going to be played. Mix_Chunk* gameOver; // Used to be the sound effect when the game is over. public: Game(); // Setters. void setIsRunning(const bool&); void setWindow(SDL_Window*&); void setWindowGameOver(SDL_Window*); void setRender(SDL_Renderer*); void setSurface(SDL_Surface*); void setGameOverImage(SDL_Surface*); void setWidth(int&); void setHeight(int&); void setEffectEat(Mix_Chunk*); void setChannel(const int&); void setMusic(Mix_Music*); void setGameOver(Mix_Chunk*); // Getters. bool getIsRunning() const; SDL_Window* getWindow() const; SDL_Window* getWindowGameOver() const; SDL_Renderer* getRenderer() const; SDL_Surface* getSurface() const; SDL_Surface* getGameOverImage() const; int getWidth() const; int getHeight() const; Mix_Chunk* getEffectEat() const; int getChannel() const; Mix_Music* getMusic() const; Mix_Chunk* getGameOver() const; void init(const char* title, int w, int h, bool fullScreen); virtual void run() = 0; virtual void handleEvents() = 0; virtual void update() = 0; virtual void render() = 0; virtual void clean() = 0; virtual void loadEffectEat() = 0; virtual void loadMusic() = 0; virtual void loadGameOverEffect() = 0; virtual void loadGameOverImage() = 0; virtual void loadWindowGameOver() = 0; }; #endif /***************************** Game.cpp ***************************************************/ #include "Game.hpp" Game::Game() : isRunning(false), effectEat(nullptr), music(nullptr), gameOver(nullptr) { } // Setters. void Game::setIsRunning(const bool& r){ isRunning = r; } void Game::setWindow(SDL_Window*& w){ window = w; } void Game::setRender(SDL_Renderer* r){ renderer = r; } void Game::setWidth(int& w){ width = w; } void Game::setHeight(int& h){ height = h; } void Game::setEffectEat(Mix_Chunk* c){ effectEat = c; } void Game::setChannel(const int& c) { channel = c; } void Game::setMusic(Mix_Music* m) { music = m; } void Game::setGameOver(Mix_Chunk* g) { gameOver = g; } void Game::setWindowGameOver(SDL_Window* w) { windowGameOver = w; } void Game::setGameOverImage(SDL_Surface* g) { gameOverImage = g; } void Game::setSurface(SDL_Surface* s) { surface = s; } // Getters. bool Game::getIsRunning() const { return isRunning; } SDL_Window* Game::getWindow() const { return window; } SDL_Renderer* Game::getRenderer() const { return renderer; } int Game::getWidth() const { return width; } int Game::getHeight() const { return height; } Mix_Chunk* Game::getEffectEat() const { return effectEat; } int Game::getChannel() const { return channel; } Mix_Music* Game::getMusic() const { return music; } Mix_Chunk* Game::getGameOver() const { return gameOver; } SDL_Window* Game::getWindowGameOver() const { return windowGameOver; } SDL_Surface* Game::getGameOverImage() const { return gameOverImage; } SDL_Surface* Game::getSurface() const { return surface; } // const char* title because SDL_CreateWindow, recieve as parameter a const char* (string C style). void Game::init(const char* title, int w, int h, bool fullScreen){ int flags(0); width = w; height = h; if(fullScreen){ flags = SDL_WINDOW_FULLSCREEN; } // Inicializar todo el motor de SDL, regresa 0 si todo se inicializo correctamente. if(SDL_Init(SDL_INIT_VIDEO) == 0){ // SDL_CreateWindow(titulo, posicion en x, posicion en y, ancho, alto, banderas) // Creates a 2D rendering context for a window. window = SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, flags); // Se encargara en dibuar, el -1 es un indice para que lo tome por default, 0 es ninguna bandera. renderer = SDL_CreateRenderer(window, -1, 0); if(renderer){ // Poner la pantalla negra en formate RGB, el ultimo valor es que tan transparente es la ventana, valor // alpha. // renderer is the rendering context. SDL_SetRenderDrawColor(renderer, 0, 0, 0, 100); } else { std::cout << "Couldn't initialize render: " << SDL_GetError() << std::endl; } if(Mix_OpenAudio(22050, AUDIO_S16SYS, 2, 4096) != 0){ std::cout << "Couldn't initialize audio effectEat: " << Mix_GetError(); } else { // Load our Sound effectEat. effectEat = Mix_LoadWAV("pacman_eatfruit.wav"); setEffectEat(effectEat); if(effectEat == nullptr){ std::cout << "Error loading sound effectEat: " << Mix_GetError(); } // Load our sound effect gameOver. gameOver = Mix_LoadWAV("game_over.wav"); setGameOver(gameOver); if(gameOver == nullptr) { std::cout << "Error loading sound effectEat: " << Mix_GetError(); } // Load our music. music = Mix_LoadMUS("test.wav"); setMusic(music); if(music == nullptr) { std::cout << "Error loading music: " << Mix_GetError(); } loadMusic(); } // The window now is running. isRunning = true; } } /************************************* Snake.hpp ********************************************/ #include #include class Snake{ private: SDL_Renderer* renderer; std::vector body; int xDir; int yDir; public: static const int BLOCK_WIDTH = 10; static const int BLOCK_HEIGHT = 10; Snake(int x, int y, SDL_Renderer* r); void update(); void draw(); bool bodyColission(); void grow(); void setDirection(int x, int y); SDL_Rect head(); }; /******************************** Snake.cpp ***********************************************/ #include "Snake.hpp" Snake::Snake(int x, int y, SDL_Renderer* r){ renderer = r; // La frente del snake. SDL_Rect head; // Crear nuestro snake, tendra por el momento un elemento. head.x = x; head.y = y; head.w = BLOCK_WIDTH; head.h = BLOCK_HEIGHT; xDir = 0; yDir = 0; body.push_back(head); } void Snake::draw(){ // Poner un color verde en nuestro en render, verde solido. SDL_SetRenderDrawColor(renderer, 0, 255, 0, 100); // Cada uno de nuestros elementos de nuestro vector, vamos a dibujar. for(SDL_Rect rect : body){ SDL_RenderDrawRect(renderer, &rect); // Dibujar con puro marco. //SDL_RenderFillRect(renderer, &rect); // Dibujar con relleno. } } void Snake::grow(){ // Agregar un bloque al final tomando la cola del snake y creando una copia de ella. // Esta la agregamos, en el siguiente frame se desplazara el snake y ya se va a ver mas grande. SDL_Rect tail = body.back(); SDL_Rect newBlock = tail; body.push_back(newBlock); } bool Snake::bodyColission(){ for(unsigned int i(1); i < body.size(); i++){ // body[i] es la seccion del cuerpo qu estamos revisando. if(body[0].x == body[i].x and body[0].y == body[i].y){ return true; } } return false; } SDL_Rect Snake::head(){ return body.front(); // Regresa el frente del vector. } void Snake::update(){ // Nos quedamos con el frente, para ver que le quitamos o agregamos. SDL_Rect front = body.front(); SDL_Rect r; // La posicion en x sera la posicion en x actual que tiene en frente. r.x = front.x + xDir * BLOCK_WIDTH; // En y deberia haber 1 porque nos movemos hacia arriba. r.y = front.y + yDir * BLOCK_HEIGHT; r.w = BLOCK_WIDTH; r.h = BLOCK_HEIGHT; // Borrar en el final, e insertar en el principio. // el punto end de un vector te regresa una posicion despues de tu ultimo elemento. //body.erase(body.end() - 1); // Eliminando el snake crecera. body.erase(body.end() - 1); body.insert(body.begin(), r); } void Snake::setDirection(int x, int y){ xDir = x; yDir = y; } /************************************* SnakeGame.hpp ***************************************************/ #ifndef SNAKEGAME_HPP #define SNAKEGAME_HPP // en la revursividad hay un pasode mas. #include "Game.hpp" #include "Snake.hpp" class SnakeGame : public Game{ private: // Ser mas eficiente en la memoria, y poder dar parametros. Snake* snake; SDL_Rect food; // Cuadrito para la comida. void createFood(); bool frameCollision(); public: SnakeGame(); //virtual ~SnakeGame() { } void run(); void handleEvents(); void update(); void render(); void clean(); void loadEffectEat(); void loadMusic(); void loadGameOverEffect(); void loadGameOverImage(); void loadWindowGameOver(); }; #endif /***************************************** SnakeGame.cpp ************************************************/ #include "SnakeGame.hpp" #include SnakeGame::SnakeGame(){ // Agregar una semilla nueva cada vez que se ejecute nuestro programa. // Generando diferentes posiciones para la comida. srand(time(NULL)); // Inicializa el juego. init("Snake", 640, 480, false); // Usadas para darle una posicion aleatorio al snake. int x = rand() % (getWidth() / Snake::BLOCK_WIDTH) * Snake::BLOCK_WIDTH; int y = rand() % (getHeight() / Snake::BLOCK_HEIGHT) * Snake::BLOCK_HEIGHT; // Creando un snake con una posicion inicial y un renderer. // Poniendolo en una posicion aleatorio del snake. snake = new Snake(x, y, getRenderer()); // Crear la comida. createFood(); // Ejecutar el juego. run(); } void SnakeGame::run(){ const int FPS = 30; const int FRAME_DELAY = 1000 / FPS; // 1 segundo sobre los 30 frames. unsigned int frameStart; // Cuando inicio el frame. unsigned int frameTime; // CUando termino el frame. // Esta corriendo si la variable es verdadera. while(getIsRunning()){ // Tomamos el tiempo de inicio del frame. frameStart = SDL_GetTicks(); handleEvents(); update(); // Actualize con la informacion que tenga. render(); // Dibujar lo actualizado. frameTime = SDL_GetTicks() - frameStart; // Cuanto se tardo en manejar los evento, actualizar los eventos y dibujar. Se hace esto para saber cuanto hay que esperar para el siguiente frame. // Si las operaciones fueron muy rapidas espero, sino, lanza el siguiente frame. if(FRAME_DELAY > frameTime){ SDL_Delay(FRAME_DELAY - frameTime); } } clean(); } void SnakeGame::render(){ // Limpia el render, lo que habia en el frame anterior lo borramos. SDL_RenderClear(getRenderer()); // DIbujar la comida en rojo. SDL_SetRenderDrawColor(getRenderer(), 255, 0, 0, 255); // Dibujarlo. SDL_RenderFillRect(getRenderer(), &food); snake->draw(); // Ponemos un color para que dibuje. SDL_SetRenderDrawColor(getRenderer(), 0, 0, 0, 255); // Dibujamos en el renderer. SDL_RenderPresent(getRenderer()); //snake->draw(); // PONDRA TODA LA PANTALLA EN VERDE. } void SnakeGame::clean(){ // Destruye los objetos que hemos creado, la ventana y el render. SDL_DestroyWindow(getWindow()); //SDL_DestroyWindow(getWindowGameOver()); //SDL_FreeSurface(getGameOverImage()); SDL_DestroyRenderer(getRenderer()); Mix_FreeMusic(getMusic()); Mix_FreeChunk(getEffectEat()); Mix_CloseAudio(); SDL_Quit(); std::cout << "Cleaned." << std::endl; } // Reconocer los eventos que sucedan en nuestro juego. void SnakeGame::handleEvents(){ SDL_Event event; // Instancia. SDL_PollEvent(&event); // Guarda en event todo lo que sucedio. // Type es el tipo de elemento que sucedio. switch(event.type){ // Si el usuario esta intentando quitar el juego. case SDL_QUIT: // Al siguiente frame se quita el juego. setIsRunning(false); break; // Reconocer si se presiono una tecla. case SDL_KEYDOWN:{ // Fue un evento del teclado (key), despues saber cual es el smbolo (keysym) y obtiene el simbolo (sym) // -1 para subir y 1 para bajar, debido a la posicion en donde se encuentra y en las imagenes. switch(event.key.keysym.sym){ case SDLK_UP: std::cout << "UP" << std::endl; snake->setDirection(0, -1); break; case SDLK_DOWN: std::cout << "DOWN" << std::endl; snake->setDirection(0, 1); break; case SDLK_LEFT: std::cout << "LEFT" << std::endl; snake->setDirection(-1,0); break; case SDLK_RIGHT: std::cout << "RIGHT" << std::endl; snake->setDirection(1,0); break; default: break; } } default: break; } } void SnakeGame::createFood(){ // Expresiones para crear un punto aleatorio en la pantalla y hacer que la comida // tenga una posicion valida. int x = rand() % (getWidth() / Snake::BLOCK_WIDTH) * Snake::BLOCK_WIDTH; int y = rand() % (getHeight() / Snake::BLOCK_WIDTH) * Snake::BLOCK_WIDTH; food.x = x; food.y = y; food.w = Snake::BLOCK_WIDTH; food.h = Snake::BLOCK_HEIGHT; } bool SnakeGame::frameCollision(){ SDL_Rect head = snake->head(); // SI la coordenada de x es mayor a la coordenada de la pantala o tambien la coordenada de y, // entonces hubo una colision con el marco. if(head.x > getWidth() or head.x < 0 or head.y > getHeight() || head.y < 0){ return true; } return false; } void SnakeGame::update(){ SDL_Rect head = snake -> head(); // When crash with its own body. if(snake->bodyColission() || frameCollision()){ //loadGameOverImage(); // Apply the image. //SDL_BlitSurface(getGameOverImage(), nullptr, getSurface(), nullptr); // Update the surface. //SDL_UpdateWindowSurface(getWindowGameOver()); setIsRunning(false); loadGameOverEffect(); loadWindowGameOver(); } if(head.x == food.x and head.y == food.y){ loadEffectEat(); // Crezca el snake y crear una nueva comida. snake->grow(); createFood(); } snake->update(); } void SnakeGame::loadMusic() { // To play the music since the game is initialized. if(Mix_PlayMusic(getMusic(), -1) == -1){ std::cout << "Error to play main music: " << Mix_GetError(); } } void SnakeGame::loadGameOverEffect() { // To play the gameOver sound effect. if(Mix_PlayChannel(-1, getGameOver(), 0) == -1) { std::cout << "Error playing game over sound effect: " << Mix_GetError(); } } void SnakeGame::loadEffectEat() { // To play the sound effect eat. if(Mix_PlayChannel(-1, getEffectEat(), 0) == -1){ std::cout << "Error playing eat sound effect: " << Mix_GetError(); } //while(Mix_Playing(getChannel()) != -1); } void SnakeGame::loadGameOverImage() { // Loading the game over image. gameOverImage = SDL_LoadBMP("game_over.bmp"); if(gameOverImage == nullptr) { std::cout << "Error loading gameOverImage: " << SDL_GetError() << std::endl; } setGameOverImage(gameOverImage); } void SnakeGame::loadWindowGameOver() { // Create the window that will display gameOver; windowGameOver = SDL_CreateWindow("GAME OVER", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 259, 194, SDL_WINDOW_SHOWN); setWindowGameOver(windowGameOver); if(windowGameOver == nullptr) { std::cout << "Coudln't create windowGameOver: " << SDL_GetError() << std::endl; } else { // Get windowGameOver surface. surface = SDL_GetWindowSurface(windowGameOver); setSurface(surface); } if(surface == nullptr) { std::cout << "Couldn't initialize surface for gameOverImage: " << SDL_GetError() << std::endl; } loadGameOverImage(); // Apply the image. SDL_BlitSurface(gameOverImage, nullptr, surface, nullptr); // Perform a fast suface copy to a destination surface. // Update the surface. SDL_UpdateWindowSurface(windowGameOver); // Copy the window surface to the screen. Reflect any changes to the surface on the screen. // Wait two seconds. SDL_Delay(1100); }

snakeGame beta