/* * * AUTHOR: SENCION ECHAURI, FELIPE * ORGANIZATION: UDG - CUCEI. * * Because it uses classes, it cannot work in solo learn, it has to be compiled in an IDE. * Also, the SDL library have to be installed. * */ /*************************************** main.cpp *************************************************/ #include #include "SnakeGame.hpp" int main(){ SnakeGame snakeGame; return 0; } /*********************************** Game.hpp ********************************************************/ #ifndef GAME_HPP #define GAME_HPP #include #include #include class Game{ private: bool isRunning; SDL_Window* window; SDL_Renderer* renderer; int width; int height; public: Game(); // Setters. void setIsRunning(bool); void setWindow(SDL_Window*); void setRender(SDL_Renderer*); void setWidth(int&); void setHeight(int&); // Getters. bool getIsRunning() const; SDL_Window* getWindow() const; SDL_Renderer* getRenderer() const; int getWidth() const; int getHeight() 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; }; #endif /************************************************ Game.cpp ***********************************************/ #include "Game.hpp" Game::Game() : isRunning(false) { } // Setters. void Game::setIsRunning(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; } // 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; } 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. if(SDL_Init(SDL_INIT_EVERYTHING) == 0){ // SDL_CreateWindow(titulo, posicion en x, posicion en y, ancho, alto, banderas) 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. SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255); } else { std::cout << "Couldn't initialize render: " << SDL_GetError() << std::endl; } 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, 255); // 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 #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(); }; #endif /************************************************ SnakeGame.cpp**************************************************/ #include "SnakeGame.hpp" #include // rand() 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. snake = new Snake(x, y, getRenderer()); // Crear la comida. createFood(); // Ejecutar el juego. run(); } void SnakeGame::run(){ const int FPS = 10; 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_DestroyRenderer(getRenderer()); 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. 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(); if(snake->bodyColission() || frameCollision()){ setIsRunning(false); } if(head.x == food.x and head.y == food.y){ // Crezca el snake y crear una nueva comida. snake->grow(); createFood(); } snake->update(); }

SimpleSnakeGame.