Snake code review request

[Gaius]

I've recently finished programming a clone of the popular "Snake" game in C++ with SFML and Visual Studio 12 and I would like to know if there is anything about the code or it's structure that I could improve. This is the second post I've made on this forum, the first was a Pong review request.
 
Game:
 

 
 
Files:
 


 
Code:
 
main.cpp
 

(click to show/hide)

#include <iostream>
#include <string>
#include <vector>
#include <SFML/Graphics.hpp>
#include <SFML/Audio.hpp>
#include "globals.h"
#include "Snake.h"
#include "Food.h"
#include "SoundEffect.h"

void doEvents(sf::RenderWindow & window, bool & up, bool & down, bool & left, bool & right, bool & pressed);
void move(Snake & snake, bool up, bool down, bool left, bool right);
bool intersect(const Snake & snake);
bool intersect(const Snake & snake, const Food & food, size_t & i);
bool borderIntersect(const Snake & snake, const sf::RenderWindow & window);

int main(){
        srand(time(0));
        sf::RenderWindow window(sf::VideoMode(SCRSIZE, SCRSIZE), "Snake");

        float volume = 50;
        SoundEffect moveSound("sounds/move.wav", volume);
        SoundEffect foodSound("sounds/food.wav", volume);
        SoundEffect extraSound("sounds/extra.wav", volume);
        SoundEffect deathSound("sounds/death.wav", volume);

        sf::Color foodColor(0, 123, 123);
        Snake snake(sf::Vector2f(SIZE, SIZE), sf::Vector2f(GRIDSIZE/2, GRIDSIZE/2), 3, sf::Color::White, OUTLINE);
        Food food(1, foodColor);
        Food extra(2, RAND_COL);
        food.spawn(snake, extra, foodColor);

        bool gameOver = false;
        bool up = true;
        bool down = false;
        bool left = false;
        bool right = false;
        bool pressed = false;
        int collectedItems = 0;
        int level = 1;
        int score = 0;
        int lives = LIVES;

        // Fixed time step loop setup
        sf::Clock clock;
        double skippedTime = 0;
        double secondsElapsed = 0;
        double interval = INTERVAL;
        int updates = 0;

        // Game loop
        while (window.isOpen()){
                const double elapsedTime = clock.getElapsedTime().asMicroseconds() / 1000.0;
                skippedTime += elapsedTime;
                secondsElapsed += elapsedTime;
                extra.clock(elapsedTime);
                clock.restart();
                pressed = false;
                if (snake.getLength() <= 20)
                        interval = INTERVAL * 2;
                else if (snake.getLength() <= 40)
                        interval = INTERVAL / 2.0;
                else if (snake.getLength() <= 60)
                        interval = INTERVAL / 1.2;
                else if (snake.getLength() <= 80)
                        interval = INTERVAL;
                while (skippedTime >= interval){
                        //Second timer
                        updates++;
                        while (secondsElapsed >= 1000){
                                //system("cls");
                                std::cout << updates << "       Updates,        " << secondsElapsed / updates << "      Average Interval\n";
                                std::cout << "Score: " << score << '\n';
                                std::cout << "Level: " << level << '\n';
                                std::cout << "Lives: " << lives << '\n';
                                updates = 0;
                                secondsElapsed -= 1000;
                        }
                        //Events
                        doEvents(window, up, down, left, right, pressed);

                        //Update
                        size_t pos = 0;
                        move(snake, up, down, left, right);
                        if (interval < 300 && (updates == 3 || updates == 6 || updates == 9))
                                moveSound.play();
                        else if (interval >= 300)
                                moveSound.play();

                        if (rand() % 1000 <= 5){
                                extra.spawn(snake, food, RAND_COL, interval * 40);
                        }
                        if (intersect(snake) || borderIntersect(snake, window)){
                                deathSound.play();
                                gameOver = true;
                        }
                        if (intersect(snake, food, pos)){
                                foodSound.play();
                                food.remove();
                                food.spawn(snake, extra, foodColor);
                                collectedItems++;
                                score += food.getPoints();
                                snake.grow();
                        }
                        if (intersect(snake, extra, pos)){
                                extraSound.play();
                                extra.remove(pos);
                                collectedItems++;
                                score += extra.getPoints();
                                snake.grow();
                        }
                        if (collectedItems >= 10){
                                level++;
                                collectedItems = 0;
                                extra.setPoints(level * level);
                                food.setPoints(level);
                        }
                        if (gameOver){
                                lives--;
                                if (lives < 0)
                                        window.close();
                                snake = Snake(sf::Vector2f(SIZE, SIZE), sf::Vector2f(GRIDSIZE / 2, GRIDSIZE / 2), 3, sf::Color::White, OUTLINE);
                                food = Food(level, sf::Color(0, 123, 123));
                                food.spawn(snake, extra, foodColor);
                                extra = Food(level*level, RAND_COL);
                                interval = INTERVAL;
                                collectedItems = 0;
                                if (score >= 100)
                                        score -= score / 3;
                                else
                                        score = 0;
                                gameOver = false;
                                up = true;
                                down = false;
                                left = false;
                                right = false;
                        }

                        //Subtract time
                        skippedTime -= interval;
                }

                // Render
                window.clear();
                snake.draw(window);
                food.draw(window);
                extra.draw(window);
                window.display();
        }

        return 0;
}

void doEvents(sf::RenderWindow & window, bool & up, bool & down, bool & left, bool & right, bool & pressed){
        sf::Event event;
        while (window.pollEvent(event)){
                if (event.type == sf::Event::Closed){
                        window.close();
                }
                if (event.type == sf::Event::KeyPressed){
                        sf::Keyboard k;
                        if (event.key.code == k.Escape){
                                window.close();
                        }
                        if (event.key.code == k.Up && !down && !pressed){
                                up = true;
                                down = false;
                                left = false;
                                right = false;
                                pressed = true;
                        }
                        else if (event.key.code == k.Down && !up && !pressed){
                                up = false;
                                down = true;
                                left = false;
                                right = false;
                                pressed = true;
                        }
                        else if (event.key.code == k.Left && !right && !pressed){
                                up = false;
                                down = false;
                                left = true;
                                right = false;
                                pressed = true;
                        }
                        else if (event.key.code == k.Right && !left && !pressed){
                                up = false;
                                down = false;
                                left = false;
                                right = true;
                                pressed = true;
                        }
                }
        }
}

void move(Snake & snake, bool up, bool down, bool left, bool right){
        if (up){
                snake.moveUp();
        }
        else if (down){
                snake.moveDown();
        }
        else if (left){
                snake.moveLeft();
        }
        else if (right){
                snake.moveRight();
        }
}

bool intersect(const Snake & snake){
        for (int i = 1; i < snake.getLength(); i++){
                if (snake.getGridPos() == snake.getGridPos(i)){
                        return true;
                }
        }
        return false;
}

bool intersect(const Snake & snake, const Food & food, size_t & item){
        for (int i = 0; i < food.getLength(); i++){
                if (snake.getGridPos() == food.getGridPos(i)){
                        item = i;
                        return true;
                }
        }
        return false;
}

bool borderIntersect(const Snake & snake, const sf::RenderWindow & window){
        if (snake.getPos().x >= window.getSize().x)
                return true;
        if (snake.getPos().x < 0)
                return true;
        if (snake.getPos().y >= window.getSize().y)
                return true;
        if (snake.getPos().y < 0)
                return true;
        return false;
}
 

Snake.h

(click to show/hide)

#pragma once
#include "Entity.h"

class Snake : public Entity
{
public:
        Snake(const sf::Vector2f & size = sf::Vector2f(SIZE, SIZE), const sf::Vector2f & gridPos = sf::Vector2f(GRIDSIZE / 2, GRIDSIZE / 2),
                size_t length = 3, const sf::Color & color = sf::Color::White, float outline = OUTLINE) : Entity(size, gridPos * SIZE, color, length){
                setOutline(outline, sf::Color(color.r / 1.5f, color.g / 1.5f, color.b / 1.5f));
        }       // inline constructor

        void moveUp();
        void moveDown();
        void moveLeft();
        void moveRight();
        void setGridPos(const sf::Vector2f & gridPos);
        void grow();

};
 

Snake.cpp

(click to show/hide)

#include "Entity.h"
#include <SFML/Graphics.hpp>
#include "globals.h"
#include "Snake.h"

void Snake::moveUp(){
        for (int i = entity.size() - 1; i > 0; i--){
                entity[i].setPosition(entity[i - 1].getPosition());
        }
        entity[0].setPosition(entity[0].getPosition() - sf::Vector2f(0, getSize().y));
}

void Snake::moveDown(){
        for (int i = entity.size() - 1; i > 0; i--){
                entity[i].setPosition(entity[i - 1].getPosition());
        }
        entity[0].setPosition(entity[0].getPosition() + sf::Vector2f(0, getSize().y));
}

void Snake::moveLeft(){
        for (int i = entity.size() - 1; i > 0; i--){
                entity[i].setPosition(entity[i - 1].getPosition());
        }
        entity[0].setPosition(entity[0].getPosition() - sf::Vector2f(getSize().x, 0));
}

void Snake::moveRight(){
        for (int i = entity.size() - 1; i > 0; i--){
                entity[i].setPosition(entity[i - 1].getPosition());
        }
        entity[0].setPosition(entity[0].getPosition() + sf::Vector2f(getSize().x, 0));
}

void Snake::grow(){
        setLength(getLength() + 1);
        setSize(getSize());
        setColor(getColor());
        setOutline(getOutlineThickness(), getOutlineColor());
        entity[entity.size() - 1].setPosition(entity[entity.size() - 2].getPosition());
}
 

Food.h

(click to show/hide)

#pragma once
#include "Entity.h"
class Snake;

class Food: public Entity
{
        std::vector<double> timer;
        int points;
        float outline;
        sf::Color fillColor;
        sf::Color outlineColor;
        sf::Vector2f size;
public:
        Food(int points, const sf::Color & color = sf::Color(0,123,123), const sf::Vector2f & size = sf::Vector2f(SIZE, SIZE),
                float outline = OUTLINE) : Entity(size, color, 0){
                this->outline = outline;
                this->size = size;
                fillColor = color;
                setColor(fillColor);
                outlineColor = sf::Color(color.r / 1.5f, color.g / 1.5f, color.b / 1.5f);
                this->points = points;
                setOutline(outline, outlineColor);
        }       // inline constructor

        int getPoints(){ return points; }                                               // inline definition
        void setPoints(int points){ this->points = points; }    // inline definition

        void clock(double elapsed);
        void spawn(const Snake & snake, const Food & other, sf::Color color = sf::Color::White, double time = 10000);
        void remove(size_t i = 0);
};


 

Food.cpp

(click to show/hide)

#include "Food.h"
#include "Snake.h"
#include <iostream>

void Food::clock(double elapsed){
        for (size_t i = 0; i < timer.size(); i++){
                timer[i] -= elapsed;
                if (timer[i] <= 0){
                        remove(i);
                        i = 0;
                }
        }
}

void Food::spawn(const Snake & snake, const Food & other, sf::Color color, double time){
        setLength(getLength() + 1);
        sf::Vector2f pos(rand() % GRIDSIZE, rand() % GRIDSIZE);
        int counter = 0;
        bool done = false;
        while (!done){
                done = true;
                for (int i = 0; i < snake.getLength(); i++){
                        if (pos == snake.getGridPos(i)){
                                pos = sf::Vector2f(rand() % GRIDSIZE, rand() % GRIDSIZE);
                                done = false;
                                break;
                        }
                }
                for (int i = 0; i < other.getLength(); i++){
                        if (pos == other.getGridPos(i)){
                                pos = sf::Vector2f(rand() % GRIDSIZE, rand() % GRIDSIZE);
                                done = false;
                                break;
                        }
                }
                for (int i = 0; i < getLength() - 1; i++){
                        if (pos == getGridPos(i)){
                                pos = sf::Vector2f(rand() % GRIDSIZE, rand() % GRIDSIZE);
                                done = false;
                                break;
                        }
                }
                counter++;
                if (getLength() >= GRIDSIZE * GRIDSIZE - snake.getLength())
                        break;
                else if (other.getLength() >= GRIDSIZE * GRIDSIZE - snake.getLength())
                        break;
        }

        if (done){
                timer.resize(getLength());
                timer[timer.size() - 1] = time;

                outlineColor = sf::Color(color.r / 1.5f, color.g / 1.5f, color.b / 1.5f);
                fillColor = color;

                setSize(size);
                setOutline(outline, outlineColor);
                entity[getLength() - 1].setFillColor(fillColor);
                entity[getLength() - 1].setOutlineColor(outlineColor);
                entity[getLength() - 1].setOutlineThickness(outline);
                entity[getLength() - 1].setPosition(sf::Vector2f(pos.x * size.x, pos.y * size.y));
        }
        else{
                setLength(getLength() - 1);
        }
}

void Food::remove(size_t i){
        timer.erase(timer.begin() + i);
        entity.erase(entity.begin() + i);
}
 

Entity.h

(click to show/hide)

#pragma once
#include <SFML/Graphics.hpp>
#include <vector>
#include "globals.h"
class Entity
{
        sf::Uint8 r;
        sf::Uint8 g;
        sf::Uint8 b;
        sf::Uint8 a;
        void setRGBA(sf::Uint8 r, sf::Uint8 g, sf::Uint8 b, sf::Uint8 a){
                this->r = r; this->g = g; this->b = b; this->a = a;
        }
protected:
        std::vector<sf::RectangleShape> entity;
public:
        Entity(const sf::Vector2f & size = sf::Vector2f(SIZE, SIZE), const sf::Color & color = sf::Color::White, size_t length = 1);
        Entity(const sf::Vector2f & size = sf::Vector2f(SIZE, SIZE), const sf::Vector2f & pos = sf::Vector2f(0, 0), const sf::Color & color = sf::Color::White, size_t length = 1);
        std::vector<sf::RectangleShape> get() const;
        sf::Vector2f getSize(size_t i = 0) const;
        sf::Vector2f getPos(size_t i = 0) const;
        sf::Vector2f getGridPos(size_t i = 0) const;
        sf::Color getColor(size_t i = 0) const;
        size_t getLength() const;
        float getOutlineThickness(size_t i = 0) const;
        sf::Color getOutlineColor(size_t i = 0) const;
        void draw(sf::RenderWindow & window) const;

        void set(const sf::Vector2f & size = sf::Vector2f(SIZE, SIZE), const sf::Color & color = sf::Color::White, size_t length = 1);
        void set(const sf::Vector2f & size = sf::Vector2f(SIZE, SIZE), const sf::Vector2f & pos = sf::Vector2f(0, 0), const sf::Color & color = sf::Color::White, size_t length = 1);
        void setSize(const sf::Vector2f & size = sf::Vector2f(SIZE, SIZE));
        void setSize(float x = SIZE, float y = SIZE);
        void setPos(const sf::Vector2f & pos = sf::Vector2f(0, 0));
        void setPos(float x, float y);
        void setPos(const Entity & entity, size_t i);
        void setColor(const sf::Color & color = sf::Color::White);
        void setColor(sf::Uint8 r = 255, sf::Uint8 g = 255, sf::Uint8 b = 255, sf::Uint8 a = 255);
        void setColor(sf::Uint8 r = 255, sf::Uint8 g = 255, sf::Uint8 b = 255);
        void setColorR(sf::Uint8 val = 255);
        void setColorG(sf::Uint8 val = 255);
        void setColorB(sf::Uint8 val = 255);
        void setColorA(sf::Uint8 val = 255);
        void setOutline(float thickness, const sf::Color & color);
        void setLength(size_t length);
};
 

Entity.cpp

(click to show/hide)

#include <SFML/Graphics.hpp>
#include "globals.h"
#include <vector>
#include <iostream>
#include "Entity.h"

Entity::Entity(const sf::Vector2f & size, const sf::Color & color, size_t length){
        set(size, color, length);
}

Entity::Entity(const sf::Vector2f & size, const sf::Vector2f & pos, const sf::Color & color, size_t length){
        set(size, pos, color, length);
}

std::vector<sf::RectangleShape> Entity::get() const{
        return entity;
}

sf::Vector2f Entity::getSize(size_t i) const{
        return entity[i].getSize();
}

sf::Vector2f Entity::getPos(size_t i) const{
        return entity[i].getPosition();
}

sf::Vector2f Entity::getGridPos(size_t i) const{
        sf::Vector2f size = entity[i].getSize();
        sf::Vector2f pos = entity[i].getPosition();
        return sf::Vector2f(pos.x / size.x, pos.y / size.y);
}

sf::Color Entity::getColor(size_t i) const{
        return entity[i].getFillColor();
}

size_t Entity::getLength() const{
        return entity.size();
}

float Entity::getOutlineThickness(size_t i) const{
        return entity[i].getOutlineThickness();
}

sf::Color Entity::getOutlineColor(size_t i) const{
        return entity[i].getOutlineColor();
}

void Entity::draw(sf::RenderWindow & window) const{
        for (auto item : entity)
                window.draw(item);
}

void Entity::set(const sf::Vector2f & size, const sf::Color & color, size_t length){
        setLength(length);
        setSize(size);
        setColor(color);
}

void Entity::set(const sf::Vector2f & size, const sf::Vector2f & pos, const sf::Color & color, size_t length){
        setLength(length);
        setSize(size);
        setPos(pos);
        setColor(color);
}

void Entity::setSize(const sf::Vector2f & size){
        for (size_t i = 0; i < entity.size(); i++){
                entity[i].setSize(size);
        }
}

void Entity::setSize(float x, float y){
        for (size_t i = 0; i < entity.size(); i++){
                entity[i].setSize(sf::Vector2f(x, y));
        }
}

void Entity::setPos(const sf::Vector2f & pos){
        entity[0].setPosition(pos);
        for (size_t i = 1; i < entity.size(); i++){
                entity[i].setPosition(entity[i - 1].getPosition() + sf::Vector2f(0, getSize().y));
        }
}

void Entity::setPos(float x, float y){
        for (size_t i = 0; i < entity.size(); i++){
                entity[i].setPosition(x, y);
        }
}

void Entity::setPos(const Entity & entity, size_t i){
        for (size_t i = 0; i < this->entity.size(); i++){
                this->entity[i].setPosition(entity.getPos(i));
        }
}

void Entity::setColor(const sf::Color & color){
        setColor(color.r, color.g, color.b, color.a);
}

void Entity::setColor(sf::Uint8 r, sf::Uint8 g, sf::Uint8 b, sf::Uint8 a){
        setRGBA(r, g, b, a);
        for (size_t i = 0; i < entity.size(); i++){
                entity[i].setFillColor(sf::Color(this->r, this->g, this->b, this->a));
        }

}

void Entity::setColor(sf::Uint8 r, sf::Uint8 g, sf::Uint8 b){
        setColor(r, g, b, a);
}

void Entity::setColorR(sf::Uint8 val){
        setColor(val, g, b, a);
}

void Entity::setColorG(sf::Uint8 val){
        setColor(r, val, b, a);
}

void Entity::setColorB(sf::Uint8 val){
        setColor(r, g, val, a);
}

void Entity::setColorA(sf::Uint8 val){
        setColor(r, g, b, val);
}

void Entity::setOutline(float thickness, const sf::Color & color){
        for (size_t i = 0; i < this->entity.size(); i++){
                entity[i].setOutlineThickness(thickness);
                entity[i].setOutlineColor(color);
        }
}

void Entity::setLength(size_t length){
        entity.resize(length);
}
 

SoundEffect.h

(click to show/hide)

#pragma once

class SoundEffect
{
        sf::SoundBuffer buffer;
        sf::Sound sound;
        std::string path;
public:
        SoundEffect(){};
        SoundEffect(std::string file, float volume);
        float getVolume() const;
        std::string getPath() const;
        sf::Sound getSound() const;
        sf::Sound::Status getStatus() const;

        void set(std::string file, float volume);
        void play();
        void pause();
        void stop();
        void setVolume(float volume);
        void setPath(std::string path);
};

 

SoundEffect.cpp

(click to show/hide)

#include <SFML/Audio.hpp>
#include "SoundEffect.h"

SoundEffect::SoundEffect(std::string file, float volume){
        set(file, volume);
}

float SoundEffect::getVolume() const{
        return sound.getVolume();
}

std::string SoundEffect::getPath() const{
        return path;
}

sf::Sound SoundEffect::getSound() const{
        return sound;
}

sf::Sound::Status SoundEffect::getStatus() const{
        return sound.getStatus();
}

void SoundEffect::set(std::string file, float volume){
        setPath(file);
        setVolume(volume);
}

void SoundEffect::play(){
        sound.play();
}

void SoundEffect::pause(){
        sound.pause();
}

void SoundEffect::stop(){
        sound.stop();
}

void SoundEffect::setVolume(float volume){
        sound.setVolume(volume);
}

void SoundEffect::setPath(std::string path){
        if (!buffer.loadFromFile(path))
                std::exit(-1);
        sound.setBuffer(buffer);
}
 

globals.h

(click to show/hide)

#ifndef H_GLBLS
#define H_GLBLS

const float                     SIZE            = 30;                                   // Snake/Food width and height
const int                       GRIDSIZE        = 20;                                   // Grid size x and y
const int                       SCRSIZE         = GRIDSIZE * (int)SIZE; // Screen width and height perfectly adjusted to the snake and grid size
const std::string       FONT            = "segoeuil.ttf";               // Preffered font
const float                     OUTLINE         = -2;                                   // Should be negativve value in order for outline to be inside snake body
const int                       INTERVAL        = 300;                                  // Origin interval
const int                       LIVES           = 3;                                    // Origin lives
#define                         RAND_COL        sf::Color(rand() % 256, rand() % 256, rand() % 256)

#endif
 

[Hapax]

Just glanced over main.cpp. I think I'm too tired to give out style tips 

I did noticed that you seem to have forgotten to change the if to an else if in the keypress tests, after the test for Escape.
Also, the section of code that follows //Update should probably be in its own function to make main() a lot more easy to read.