Messages

1

Graphics / Re: Drawing Text Access Violation

« on: August 14, 2014, 07:50:15 pm »

Thanks, That helped me solve the issue.

2

Graphics / Re: Drawing Text Access Violation

« on: August 14, 2014, 06:35:24 pm »

I'm fairly new to SFML, so the problem most likely lies with my code.
Minimal working example:

#include <SFML/Graphics.hpp>
class Text : public sf::Drawable
{
        sf::Font font;
        sf::Text text;
public:
        Text(std::string string){
                if (!font.loadFromFile("segoeuil.ttf")) // Nothing wrong with loading the font
                        std::exit(-1);
                text = sf::Text(string, font, 30);
        }
        Text(){ }

        virtual void draw(sf::RenderTarget & target, sf::RenderStates states) const{
                target.draw(text);
        }
};

int main(){
        sf::RenderWindow window(sf::VideoMode(800, 600), "Text test");

        Text text("Text");
    //Text text; -> same result

        // Error (on draw) -> Access Violation
        // Commenting this line out, solves the problem
        text = Text("Text");
       

        while (window.isOpen()){
                window.clear();
                window.draw(text);
                window.display();
        }

        return 0;
}

3

Graphics / Re: Drawing Text Access Violation

« on: August 14, 2014, 04:37:55 am »

I am using Visual Studio 2013 Ultimate. I compiled SFML with cmake and I have been using that version for a few months now.

I changed my code now so that I don't use my Text class anymore but I am still getting the same error.

Button.cpp seems to be causing it now with it's derived draw method:

#include "init.h"


ui::Button::Button(std::string text, size_t textSize, sf::Vector2f pos, sf::Color textColor, sf::Color buttonFaceColor, std::string font){
        this->font.loadFromFile(font);
        this->text.setFont(this->font);
        setString(text);
        setPosition(pos);
        setTextColor(textColor);
        setButtonFaceColor(buttonFaceColor);
}

std::string ui::Button::getString() const{
        return text.getString();
}

EntityR ui::Button::getButtonFaceObj() const{
        return buttonFace;
}

sf::Vector2f ui::Button::getPosition() const{
        return buttonFace.getPosition();
}

sf::Vector2f ui::Button::getButtonFaceSize() const{
        return buttonFace.getSize();
}

size_t ui::Button::getTextSize() const{
        return text.getCharacterSize();
}

sf::Color ui::Button::getTextColor() const{
        return text.getColor();
}

sf::Color ui::Button::getButtonFaceColor() const{
        return buttonFace.getColor();
}

void ui::Button::setString(std::string text){
        this->text.setString(text);
        setTextSize(getTextSize());
}

void ui::Button::setPosition(sf::Vector2f pos){
        buttonFace.setPosition(pos);
        text.setPosition(pos + sf::Vector2f(10, 10));
}

void ui::Button::setTextSize(size_t textSize){
        text.setCharacterSize(textSize);
        float width = 100;//text.getLocalBounds().width;
        float height = 50;//text.getLocalBounds().height;
        buttonFace.setSize(width + 20, height + 20);
}

void ui::Button::setTextColor(sf::Color color){
        text.setColor(color);
}

void ui::Button::setButtonFaceColor(sf::Color color){
        buttonFace.setColor(color);
}

bool ui::Button::isPressed(sf::Event event){
        if (event.type == sf::Event::MouseButtonPressed){
                if (event.mouseButton.button == sf::Mouse::Button::Left){
                        sf::Vector2f mouseLoc(event.mouseButton.x, event.mouseButton.y);
                        if (cd::doesIntersect(mouseLoc, buttonFace))
                                return true;
                }
        }
        return false;
}

bool ui::Button::isHovering(sf::Mouse mouse){
        if (cd::doesIntersect((sf::Vector2f)mouse.getPosition(), buttonFace))
                return true;
        return false;
}

void ui::Button::draw(sf::RenderTarget & target, sf::RenderStates states) const{
        target.draw(buttonFace);
        target.draw(text);
}

Here's Button.h as well:

#pragma once

namespace ui{

        class Button : public sf::Drawable
        {
                EntityR buttonFace;
                sf::Font font;
                sf::Text text;
        public:
                Button(std::string text, size_t textSize, sf::Vector2f pos, sf::Color textColor, sf::Color buttonFaceColor, std::string font);
                Button(){}

                std::string getString() const;
                EntityR getButtonFaceObj() const;
                sf::Vector2f getPosition() const;
                sf::Vector2f getButtonFaceSize() const;
                size_t getTextSize() const;
                sf::Color getTextColor() const;
                sf::Color getButtonFaceColor() const;

                void setString(std::string text);
                void setPosition(sf::Vector2f pos);
                void setTextSize(size_t textSize);
                void setTextColor(sf::Color color);
                void setButtonFaceColor(sf::Color color);

                bool isPressed(sf::Event event);
                bool isHovering(sf::Mouse mouse);

                virtual void draw(sf::RenderTarget & target, sf::RenderStates states) const;
        };
}
 

And here is where it is called from (Missile_Command.cpp):

void Missile_Command::init(){
//...
        _quit = ui::Button("Quit", 32, sf::Vector2f(200, 200), sf::Color::Black, sf::Color(255, 255, 255, 128), "fonts/segoeuil.ttf");
        _start = ui::Button("Start", 32, sf::Vector2f(200, 300), sf::Color::Black, sf::Color(255, 255, 255, 128), "fonts/segoeuil.ttf");
}

void Missile_Command::run(){
        while (_window.isOpen()){
                //...
                _window.draw(_quit);
         _window.draw(_start);
//...
        }
}

4

Graphics / Drawing Text Access Violation

« on: August 14, 2014, 02:00:38 am »

call stack:

>   sfml-graphics-d-2.dll!std::_Tree<std::_Tmap_traits<unsigned int,sf::Font::Page,std::less<unsigned int>,std::allocator<std::pair<unsigned int const ,sf::Font::Page> >,0> >::_Lbound(const unsigned int & _Keyval) Line 2109   C++
    sfml-graphics-d-2.dll!std::_Tree<std::_Tmap_traits<unsigned int,sf::Font::Page,std::less<unsigned int>,std::allocator<std::pair<unsigned int const ,sf::Font::Page> >,0> >::lower_bound(const unsigned int & _Keyval) Line 1575   C++
    sfml-graphics-d-2.dll!std::map<unsigned int,sf::Font::Page,std::less<unsigned int>,std::allocator<std::pair<unsigned int const ,sf::Font::Page> > >::operator[](const unsigned int & _Keyval) Line 226   C++
    sfml-graphics-d-2.dll!sf::Font::getGlyph(unsigned int codePoint, unsigned int characterSize, bool bold) Line 295   C++
    sfml-graphics-d-2.dll!sf::Text::ensureGeometryUpdate() Line 269   C++
    sfml-graphics-d-2.dll!sf::Text::getLocalBounds() Line 214   C++
    Engine.exe!Text::getLocalBounds() Line 41   C++
    Engine.exe!Button::setTextSize(unsigned int textSize) Line 56   C++
    Engine.exe!Button::setString(std::basic_string<char,std::char_traits<char>,std::allocator<char> > text) Line 47   C++
    Engine.exe!Button::Button(std::basic_string<char,std::char_traits<char>,std::allocator<char> > text, unsigned int textSize, sf::Vector2<float> pos, sf::Color textColor, sf::Color buttonFaceColor) Line 7   C++
    Engine.exe!Missile_Command::initButtons() Line 56   C++
    Engine.exe!Missile_Command::init() Line 29   C++
    Engine.exe!Missile_Command::Missile_Command() Line 6   C++
    Engine.exe!main() Line 4   C++
    [External Code]   
    [Frames below may be incorrect and/or missing, no symbols loaded for kernel32.dll]

code:

void Text::draw(sf::RenderTarget & target, sf::RenderStates states) const{
        target.draw(text);
}

which was called by:

void Button::draw(sf::RenderTarget & target, sf::RenderStates states) const{
        target.draw(buttonFace);
        target.draw(text);
}

No pointers were used to my knowledge.

The exact error is as follows:

Unhandled exception at 0x0F21F95C (sfml-graphics-d-2.dll) in Engine.exe: 0xC0000005: Access violation reading location 0x0000000D.

I've been trying to solve this for quite some time now. I think it has something to do with my sf::Text object not being properly initialized or something, but I couldn't find anything.

Here's the my Text class if anyone's interested:

(click to show/hide)

#include "init.h"

Text::Text(sf::Vector2f pos, size_t size, sf::Color color, std::string text, std::string font){
        setPosition(pos);
        setSize(size);
        setColor(color);
        setText(text);
        setFont(font);
}

Text::Text(std::string font, std::string text){
        setText(text);
        setFont(font);
}

std::string Text::getString() const{
        return text.getString();
}

sf::Text Text::getText() const{
        return text;
}

sf::Color Text::getColor() const{
        return text.getColor();
}

int Text::getSize() const{
        return text.getCharacterSize();
}

sf::Vector2f Text::getPosition() const{
        return text.getPosition();
}

sf::Font Text::getFont() const{
        return font;
}

sf::FloatRect Text::getLocalBounds() const{
        return text.getLocalBounds();
}

void Text::setText(std::string text){
        if (text != "" && text != " ")
                this->text.setString(text);
}

void Text::setColor(sf::Color color){
        text.setColor(color);
}

void Text::setSize(size_t size){
        text.setCharacterSize(size);
}

void Text::setPosition(sf::Vector2f pos){
        text.setPosition(pos);
}

void Text::setFont(std::string file){
        if (!font.loadFromFile(file)){
                std::exit(-1);
        }
        text.setFont(font);
}

void Text::draw(sf::RenderTarget & target, sf::RenderStates states) const{
        target.draw(text);
}

"text" and "font" are private class members.

5

Graphics / Re: How to make Class drawable?

« on: August 11, 2014, 05:16:24 pm »

Don't forget the documentation, it contains an exemple of what you want to achieve in its detailed description. http://www.sfml-dev.org/documentation/2.1/classsf_1_1Drawable.php

That's what I meant by tutorial .

6

Graphics / Re: How to make Class drawable?

« on: August 11, 2014, 05:15:14 pm »

Now I guess that you wonder what to put in the draw function. It's simple: draw all the drawable SFML objects that your class has (VertexArray, Sprite, Text, Shape).

void MyEntity::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
    target.draw(m_sprite, states);
    target.draw(m_text, states);
    ....
}

Yeah, that was what I was stuck at. Thanks, I think I get it now.

7

Graphics / How to make Class drawable?

« on: August 11, 2014, 04:48:33 pm »

I'd like to make a class I wrote in C++ drawable by typing:

Class class;
window.draw(class);

instead of:

class.draw(window);

I read through the tutorial on how to do this, but I don't really understand how to implement it into my code.
It would really help me out if someone could briefly explain what is meant in the tutorial or could possibly give me an example of how to do this.

8

General / Snake code review request

« on: July 31, 2014, 07:12:23 pm »

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
 

9

General / Re: Pong code review request

« on: July 26, 2014, 12:35:48 am »

I'd strongly advise you to take the code you have here, and improve it with a design using classes.

Will do.

Speaking of loops, I'd read this article and see if you can implement a fixed-timestep game loop. It improves your game immensely.

I tried to implement that, but I can't seem to find a default high resolution timer for c++.
Edit: It looks like sf::Time could be what I'm looking for.

Careful mixing real-time input (sf::Mouse::getPosition()) and events. Personally, I would check for the MouseMove event and move the paddle with those values.

Was I mixing? I'll check out the MouseMove event.

• Do you really need <Windows.h> and the ClipCursor? If so, you could put it in a separate file and compile conditionally, to keep portability

How would I compile a file conditionally?

10

General / Re: Pong code review request

« on: July 25, 2014, 08:06:01 pm »

• You don't use classes
• You use global variables

I thought, since this is a relatively small scale game, I could use global variables and one .cpp file without much consequence. Wouldn't it just over complicate the code to separate it into different files if there are only near 300 lines?

11

General / Pong code review request

« on: July 25, 2014, 07:21:33 pm »

So, I wrote a simple Pong game in C++ with SFML and Visual Studio 2013 and was wondering if somebody could tell me if there is anything I could improve upon in the code.
 
Noteworthy:
    - The collision between the ball and the top and bottom of the player panel seems to be slightly bugged
    - The full solution for visual studio can be found here: https://www.dropbox.com/s/558as04io6jr2b5/Pong.zip
    - To quit the game, press escape
 
Game:
 

 
 
Files:
 

 
Code: (main.cpp)

#include <iostream>
#include <string>
#include <vector>
#include <SFML\Graphics.hpp>
#include <SFML\Audio.hpp>
#include <Windows.h>
#pragma warning(disable: 4244)

#define SCRW    1000    // Screen width
#define SCRH    600             // Screen height
#define BALLW   20              // Ball width
#define BALLH   20              // Ball height 
#define PADDLEW 20              // Paddle width
#define PADDLEH 100             // Paddle height
#define BSPEED  -0.1f   // Ball origin speed
#define ESPEED  0.08f   // Enemy origin speed (player is mouse controlled)

sf::RenderWindow window(sf::VideoMode(SCRW, SCRH), "Pong");
sf::RectangleShape ball(sf::Vector2f(BALLW, BALLH));
sf::RectangleShape player(sf::Vector2f(PADDLEW, PADDLEH));
sf::RectangleShape enemy(sf::Vector2f(PADDLEW, PADDLEH));
float ballSpeedX = BSPEED;
float ballSpeedY = BSPEED;
float enemySpeed = ESPEED;
bool gameOver = false;
int playerPoints = 0;
int enemyPoints = 0;
sf::Font font;
sf::Text plScoreTxt;
sf::Text enScoreTxt;

void draw();
void moveBall();
void enemyAI();
bool intersect(sf::Vector2f, sf::Vector2f, sf::Vector2f);
float intersectPos(float, sf::RectangleShape);
void reset();

int main(){
        // Font and text stuff
        std::string fontname = "segoeuil.ttf";
        if (!font.loadFromFile(fontname))
        {
                std::cerr << "Font " << "\"" << fontname << "\" couldn't be/wasn't loaded. Please try again.\n";
        }
        plScoreTxt.setFont(font);
        plScoreTxt.setCharacterSize(200);
        plScoreTxt.setPosition(sf::Vector2f(window.getSize().x / 2 - 250, window.getSize().y / 2 - 150));
        enScoreTxt.setFont(font);
        enScoreTxt.setColor(sf::Color(255, 255, 255, 32));
        enScoreTxt.setCharacterSize(200);
        enScoreTxt.setPosition(sf::Vector2f(window.getSize().x / 2 + 150, window.getSize().y / 2 - 150));

        // Setting up the window ant entities
        window.setMouseCursorVisible(false);
        ball.setPosition(sf::Vector2f(window.getSize().x / 2 - BALLW / 2, window.getSize().y / 2 - BALLH / 2));
        enemy.setPosition(sf::Vector2f(window.getSize().x - PADDLEW, window.getSize().y / 2 - PADDLEH / 2));

        // Mouse confinement stuff
        RECT rect;
        rect.bottom = window.getPosition().y + window.getSize().y + 32 - PADDLEH / 2;
        rect.top = window.getPosition().y + 31 + PADDLEH / 2;
        rect.left = window.getPosition().x + 50;
        rect.right = window.getPosition().x + window.getSize().x - 42;

        ClipCursor(&rect);

        // Game loop
        while (window.isOpen()){
                sf::Event event;
                while (window.pollEvent(event)){
                        if (event.type == sf::Event::Closed){
                                window.close();
                        }
                        if (event.type == sf::Event::KeyPressed){
                                // Press escape to close the window
                                if (event.key.code == sf::Keyboard::Escape)
                                        window.close();
                        }
                }

                moveBall(); // Move the ball and test for collision
                player.setPosition(sf::Vector2f(player.getPosition().x, sf::Mouse::getPosition(window).y - PADDLEH / 2)); // Move the player paddle to mouse position
                if (ballSpeedX > 0) // Perform enemy AI stuff when the ball is heading in it's direction
                        enemyAI();
                if (gameOver){ // if someone scored, reset the game
                        reset();
                }

                // Text stuff
                plScoreTxt.setString(std::to_string(playerPoints));
                enScoreTxt.setString(std::to_string(enemyPoints));
                plScoreTxt.setColor(sf::Color(ball.getFillColor().r, ball.getFillColor().g, ball.getFillColor().b, 32));
                enScoreTxt.setColor(sf::Color(ball.getFillColor().r, ball.getFillColor().g, ball.getFillColor().b, 32));
                player.setFillColor(ball.getFillColor());
                enemy.setFillColor(ball.getFillColor());

                draw(); // draw everything to the screen

                // If somebody wins, the window closes (the window can also be closed by pressing escape)
                if (playerPoints > 9 || enemyPoints > 9)
                        window.close();
        }
        return 0;
}

void reset(){
        ball.setPosition(sf::Vector2f(window.getSize().x / 2 - BALLW / 2, window.getSize().y / 2 - BALLH / 2));
        enemy.setPosition(sf::Vector2f(window.getSize().x - PADDLEW, window.getSize().y / 2 - PADDLEH / 2));
        if (ballSpeedX < 0)
                ballSpeedX = BSPEED;
        else
                ballSpeedX = BSPEED * -1;
        ballSpeedY = BSPEED;
        enemySpeed = ESPEED;
        gameOver = false;
}

void draw(){
        window.clear();
        window.draw(plScoreTxt);
        window.draw(enScoreTxt);
        window.draw(player);
        window.draw(enemy);
        window.draw(ball);
        window.display();
}

void increaseSpeed(){
        if (ballSpeedY > 0)
                ballSpeedY += (rand() % 15 + 1) / 1000.0;
        else
                ballSpeedY -= (rand() % 15 + 1) / 1000.0;
        if (ballSpeedX > 0)
                ballSpeedX += (rand() % 20 + 1) / 1000.0;
        else
                ballSpeedX -= (rand() % 20 + 1) / 1000.0;
}

void moveBall(){
        ball.setPosition(sf::Vector2f(ball.getPosition().x + ballSpeedX, ball.getPosition().y + ballSpeedY));

        // Ball -> Wall
        if (ball.getPosition().x < 0){
                enemyPoints++;
                gameOver = true;
                return;
        }
        if (ball.getPosition().x + BALLW > window.getSize().x){
                playerPoints++;
                gameOver = true;
                return;
        }
        if (ball.getPosition().y < 0 || ball.getPosition().y + BALLH > window.getSize().y){
                ballSpeedY *= -1;
                return;
        }

        // Ball -> Both paddles (Side)
        if (intersect(sf::Vector2f(ballSpeedX, ballSpeedY), sf::Vector2f(player.getPosition().x + PADDLEW, player.getPosition().y),
                sf::Vector2f(player.getPosition().x + PADDLEW, player.getPosition().y + PADDLEH)) ||
                intersect(sf::Vector2f(ballSpeedX, ballSpeedY), enemy.getPosition(),
                sf::Vector2f(enemy.getPosition().x, enemy.getPosition().y + PADDLEH)))
        {
                ballSpeedX *= -1;
                ball.setFillColor(sf::Color(rand() % 156 + 100, rand() % 156 + 100, rand() % 156 + 100));
                increaseSpeed();
                return;
        }

        // Player - Top
        if (intersect(sf::Vector2f(ballSpeedX, ballSpeedY), player.getPosition(),
                sf::Vector2f(player.getPosition().x + PADDLEW, player.getPosition().y)))
        {
                ballSpeedY += 0.02f;
                if (ballSpeedX < 0)
                        ballSpeedX *= -1;
                if (ballSpeedY > 0)
                        ballSpeedY *= -1;
                return;
        }

        // Player - Bottom
        if (intersect(sf::Vector2f(ballSpeedX, ballSpeedY),
                sf::Vector2f(player.getPosition().x, player.getPosition().y + PADDLEH),
                sf::Vector2f(player.getPosition().x + PADDLEW, player.getPosition().y + PADDLEH)))
        {
                if (ballSpeedX < 0)
                        ballSpeedX *= -1;
                if (ballSpeedY < 0)
                        ballSpeedY *= -1;
                ballSpeedY += 0.02f;
        }
}

void enemyAI(){
        float Ypos = intersectPos(ballSpeedY, ball);
        // Move enemy to optimal location
        if (enemy.getPosition().y + PADDLEH / 2 > Ypos){
                enemy.setPosition(sf::Vector2f(enemy.getPosition().x, enemy.getPosition().y - enemySpeed));
        }
        else if (enemy.getPosition().y + PADDLEH / 2 < Ypos){
                enemy.setPosition(sf::Vector2f(enemy.getPosition().x, enemy.getPosition().y + enemySpeed));
        }
        // Check if enemy collided with the walls
        if (enemy.getPosition().y < 0)
                enemy.setPosition(enemy.getPosition().x, 0);
        else if (enemy.getPosition().y + PADDLEH > window.getSize().y)
                enemy.setPosition(enemy.getPosition().x, window.getSize().y - PADDLEH);
}

bool lineIntersect(sf::Vector2f LinePointA, sf::Vector2f LinePointB, sf::Vector2f pointMoving, float diam){
        if (LinePointA.x == LinePointB.x && pointMoving.x >= LinePointA.x - diam / 2 && pointMoving.x <= LinePointA.x + diam / 2 &&
                pointMoving.y >= LinePointA.y && pointMoving.y <= LinePointB.y)
                return true;
        if (LinePointA.y == LinePointB.y && pointMoving.y >= LinePointA.y - diam / 2 && pointMoving.y <= LinePointA.y + diam / 2 &&
                pointMoving.x >= LinePointA.x && pointMoving.x <= LinePointB.x)
                return true;
        return false;
}

bool intersect(sf::Vector2f vel, sf::Vector2f LinePointA, sf::Vector2f LinePointB){
        double m, b;
        m = ((ball.getPosition().y + ball.getSize().y / 2.0 + vel.y) - (ball.getPosition().y + ball.getSize().y / 2.0)) /
                ((ball.getPosition().x + ball.getSize().x / 2.0 + vel.x) - (ball.getPosition().x + ball.getSize().x / 2.0));
        b = (ball.getPosition().y + ball.getSize().y / 2.0 + vel.y) - m * (ball.getPosition().x + ball.getSize().x / 2.0 + vel.x);

        // If the line is on the y axis, solve for y in order to have highest accuracy rate
        if (vel.x > 0 && LinePointA.x == LinePointB.x){
                for (double x = 0; x <= vel.x; x += 0.1){
                        if (lineIntersect(LinePointA, LinePointB, sf::Vector2f(x + ball.getPosition().x + ball.getSize().x / 2, (int)(m * (x + ball.getPosition().x + ball.getSize().x / 2.0) + b)), ball.getSize().x))
                                return true;
                }
        }
        else if (vel.x < 0 && LinePointA.x == LinePointB.x){
                for (double x = 0; x >= vel.x; x -= 0.1){
                        if (lineIntersect(LinePointA, LinePointB, sf::Vector2f(x + ball.getPosition().x + ball.getSize().x / 2, (int)(m * (x + ball.getPosition().x + ball.getSize().x / 2.0) + b)), ball.getSize().x))
                                return true;
                }
        }

        // if the line is on the x axis, solve for x in order to have highest accuracy rate
        else if (vel.y > 0 && LinePointA.y == LinePointB.y){
                for (double y = 0; y <= vel.y; y += 0.1){
                        if (lineIntersect(LinePointA, LinePointB, sf::Vector2f((int)((y + ball.getPosition().y + ball.getSize().y / 2.0 - b) / m), y + ball.getPosition().y + ball.getSize().y / 2.0), ball.getSize().y))
                                return true;
                }
        }
        else if (vel.y < 0 && LinePointA.y == LinePointB.y){
                for (double y = 0; y >= vel.y; y -= 0.1){
                        if (lineIntersect(LinePointA, LinePointB, sf::Vector2f((int)((y + ball.getPosition().y + ball.getSize().y / 2.0 - b) / m), y + ball.getPosition().y + ball.getSize().y / 2.0), ball.getSize().y))
                                return true;
                }
        }
        return false;
}

// This function is for the enemy to determine where it has to go
// It basically returns a 'y' coordinate of where the ball is going to end up for the enemy's 'x' coordinate
// If the ball hits either the ceiling or the floor before it reaches it's goal, the function is called recursively until the ball stays within bounds
float intersectPos(float tmpBallSpeedY, sf::RectangleShape tmpBall){
        float x = window.getSize().x - PADDLEW;
        float m = (((tmpBall.getPosition().y + BALLH / 2) + tmpBallSpeedY) - (tmpBall.getPosition().y + BALLH / 2)) /
                (((tmpBall.getPosition().x + BALLW / 2) + ballSpeedX) - (tmpBall.getPosition().x + BALLW / 2));
        float b = (tmpBall.getPosition().y) - m * (tmpBall.getPosition().x);
        float y = m * x + b;

        if (y <= 0){
                tmpBall.setPosition(sf::Vector2f((0 - b) / m, 0));
                y = intersectPos(tmpBallSpeedY*-1, tmpBall);
        }
        else if (y >= window.getSize().y - BALLH){
                tmpBall.setPosition(sf::Vector2f(((window.getSize().y - BALLH) - b) / m, window.getSize().y - BALLH));
                y = intersectPos(tmpBallSpeedY*-1, tmpBall);
        }

        return y;
}