spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#ifndef TILEMAP_HPP
#define TILEMAP_HPP

#define _USE_MATH_DEFINES

#include <SFML\Graphics.hpp>
#include <iostream>
#include <fstream>
#include <cmath>
#include <vector>

#include "ConvertString.hpp"

class Tilemap : public sf::Drawable, public sf::Transformable
{

public:

    struct rectangle {
        sf::Vector2f vertex[4];
    };

    Tilemap (){}

    bool load(const std::string& tileset, sf::Vector2u tileSize, std::vector<int> tiles, unsigned int width, unsigned int height);
    bool load(const std::string& tileset, sf::Vector2u tileSize, std::string filePath);
    bool refresh (std::vector<int> tiles);
    bool refresh (int tileNumber, int x, int y);

    bool CheckCollision (sf::Sprite *Sprite);
    bool CheckCollision (sf::Sprite *Sprite, int x, int y);
    bool CheckCollision (sf::Sprite *Sprite, int tileNumber);
    bool CheckCollision (sf::Sprite *Sprite, int tileNumber, sf::Vector2f AlternateHitboxSize, sf::Vector2f Offset);
    bool CheckCollision (float x, float y, int width, int height);
    bool CheckCollision (float x, float y, int width, int height, int xTile, int yTile);
    bool CheckCollision (float x, float y, int width, int height, int tileNumber);

    const unsigned int GetWidth    () {return m_width;};
    const unsigned int GetHeight   () {return m_height;};
    const sf::Vector2u GetTileSize () {return m_tileSize;};

private:

    virtual void draw (sf::RenderTarget& target, sf::RenderStates states) const
    {
    
         // apply the transform
        states.transform *= getTransform();

        // apply the tileset texture
        states.texture = &m_tileset;

        // draw the vertex array
        target.draw(m_vertices, states); 

    }

    void normalize (sf::Vector2f& vector) 
    {
        const float length = sqrt(vector.x * vector.x + vector.y * vector.y); 
        if(length==0)
            return;
        vector.x = vector.x / length;
        vector.y = vector.y / length;
    }

    float dot(sf::Vector2f& vector1, sf::Vector2f& vector2)
    {
        return vector1.x*vector2.x + vector1.y*vector2.y;
    }

    void  project(sf::Vector2f& axis, rectangle* _rectangle, float &min, float &max)
    {
        float _dot = dot(axis, _rectangle->vertex[0]);

        min=_dot;
        max=_dot;

        for(short i=1; i<4; i++)
        {
            _dot = dot(_rectangle->vertex[i], axis);

            if(_dot<min)
                min=_dot;
             else if(_dot>max)
                max=_dot;
        }
    }

    float distance(float minA, float maxA, float minB, float maxB) // Positive return = no hit
    {
        if(minB > maxA) return minB-maxA;
        else return minA-maxB;
    }

    bool CheckCollision (rectangle *one, rectangle *two);

        sf::VertexArray m_vertices;
        sf::Texture m_tileset;
    sf::Vector2u m_tileSize;
    unsigned int m_width, m_height;
    std::vector<int> m_tiles;

};

#endif