spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

//Tilemap und Tile Header//
#include <SFML\Graphics.hpp>
#include <vector>
#include <iostream>
class Tile
{
public:
// Attribute
    int GroundLayer;
    bool Collision;
       // Konstruktor
    Tile()
    {
        GroundLayer = 0;
        Collision = false;
    }
};

class Tilemap
{
public:

    // Konstruktor und Destruktor
    Tilemap();
    ~Tilemap();

    // map laden
    bool Load(const char* path);

    // map zeichnen
    void Draw(sf::RenderWindow &window);

    // die map größe in tiles-anzahl zurückgeben
    unsigned int GetWidth() const { return m_map_width; }
    unsigned int GetHeight() const { return m_map_height; }

    // Gibt Anzahl der Sprites zurück, die in der Map verwendet werden
    size_t GetSpriteCount() const { return vSprite.size(); }

    // Gibt ein Tile zurück
    Tile GetTile(unsigned int x, unsigned int y) const { return vMap.at(y).at(x); }

private:

    //  map größe in tiles anzahl
    unsigned int m_map_width;
    unsigned int m_map_height;

    // tile größe
    unsigned int m_tile_width;
    unsigned int m_tile_height;

    // 2-Dimensionales Feld mit Tiles
    std::vector< std::vector< Tile > > vMap;

    // Vector für Texturen
    std::vector<sf::Texture* > vTexture;

    // Feld mit Sprite-Zeigern
    std::vector< sf::Sprite* > vSprite;
};

C-/C++-Quelltext

//Tilemap Source//
#include "Tile.h"
#include <fstream>
#include <iostream>


// Konstruktor
Tilemap::Tilemap()
{
    m_map_width = 0;
    m_map_height = 0;

    m_tile_width = 0;
    m_tile_height = 0;

    vMap.clear();
}


// Destruktor - alle Sprites löschen, da diese dynamisch erstellt wurden
Tilemap::~Tilemap()
{
    std::vector< sf::Sprite* >::iterator it;
    for(it = vSprite.begin(); it != vSprite.end(); it++)
    {
        delete *it;
        it = vSprite.erase(it);
    }
}

// Map laden
bool Tilemap::Load(const char* path)
{   
    std::ifstream in;
    
    in.open(path);
    
    if(in.is_open()){
        char buffer[256];
        
         // Höhe einlesen
        in.getline(buffer, 8, '\n');
        m_map_height = atoi(buffer);

        // Breite einlesen
        in.getline(buffer, 8, '\n');
        m_map_width = atoi(buffer);

        // Tile-Höhe einlesen
        in.getline(buffer, 8, '\n');
        m_tile_height = atoi(buffer);

        // Tile-Breite einlesen
        in.getline(buffer, 8, '\n');
        m_tile_width = atoi(buffer);

        // Anzahl der Sprites einlesen
        in.getline(buffer, 8, '\n');
        unsigned int sprite_anzahl = atoi(buffer);

        // Alle Pfade zu den Sprites einlesen und die Sprites erstellen
        for(unsigned int i = 0; i < sprite_anzahl; i++)
        {
            // Pfad einlesen
            in.getline(buffer, 255, '\n');
            std::cout << buffer << std::endl;
            // Sprite erstellen
            sf::Sprite *sp   = new sf::Sprite;
            //Texture erstellen
            sf::Texture *tex = new sf::Texture;
            // Textur laden
            if(!tex->loadFromFile(buffer))
                return EXIT_FAILURE;
            //Sprite laden
            sp->setTexture(*tex);
        
            vSprite.push_back(sp);
        }

        // Alle SpriteIDs und Collisionwerte einlesen
        // Dazu alle Spalten und alle Zeilen der Map durchlaufen
        for(unsigned int i = 0; i < m_map_height; i++)
        {
            // Neue Zeile erstellen
            std::vector< Tile > zeile;

            // Alle Werte für eine Zeile einlesen
            for(unsigned int j = 0; j < m_map_width; j++)
            {
                Tile tile;

                // erster Wert bedeutet spriteID
                in.getline(buffer, 8, ',');
                tile.GroundLayer = atoi(buffer);
                std::cout << buffer << std::endl;
                // zweiter Wert sagt aus ob das Tile begehbar ist
                in.getline(buffer, 8, '|');
                tile.Collision = (atoi(buffer)==1) ? true : false;
                std::cout << buffer << std::endl;
                // Tile in die Zeile einfügen
                zeile.push_back(tile);
                }

            // Die Zeile in Vector einfügen
            vMap.push_back(zeile);
        }
    }
    else // Datei wurde nicht geöffnet
        return false;

    // Datei schließen
    in.close();

    return true;
    
}


// Map zeichnen
void Tilemap::Draw(sf::RenderWindow &window)
{
    // map zeichnen  
    // alle spalten durchlaufen
    for( unsigned int i = 0; i < m_map_height; i++)
    {
        // alle zeilen durchlaufen
        for( unsigned int j = 0; j < m_map_width; j++)
        {

            // zuerst das aktuelle Tile holen
            Tile tile = vMap.at(i).at(j);
            // und dann die Sprite-Nr aus dem Tile auslesen
            int ground_sprite_nr = tile.GroundLayer;
            
            // wenn kleiner null (-1), dann wird kein Sprite gezeichnet
            if(ground_sprite_nr < 0 && ground_sprite_nr < GetSpriteCount())
                continue;
            
            // Grundlayer zeichnen
            vSprite[ ground_sprite_nr ]->setPosition(j*m_tile_width, i*m_tile_height);
            window.draw(*vSprite[ground_sprite_nr]);                        
            
        }
    }
}

C-/C++-Quelltext

//Und die unvollständige Main//
#include <SFML\Graphics.hpp>
#include <SFML\Window.hpp>
#include <iostream>
#include <conio.h>
#include <vector>
#include <fstream>
#include <string>
#include <sstream>
#include <stdio.h>
#include "Tile.h"

int main()
{
    sf::RenderWindow window(sf::VideoMode(800,600,32),"MonkeyStyleGames");  
    window.setFramerateLimit(60);
    sf::Clock deltaClock;
    Tilemap map;    

    while (window.isOpen())
    {       
        window.clear();

        sf::Event event;
        sf::Time dt = deltaClock.restart();

        while (window.pollEvent(event))
        {
            if (event.type == sf::Event::Closed||sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))
                window.close();
        }

        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left))
            ;
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right))
            ;
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up))
            ;
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down))
            ;
        
        map.Load("Level\Level 1 - Map");
        
        map.Draw(window);
        
        window.display();
    }

    return 0;
}

C-/C++-Quelltext

in.getline(buffer,8,'\n');
m_map_height = atoi(buffer);

C-/C++-Quelltext

if(!tex->loadFromFile(buffer))
   return EXIT_FAILURE;

C-/C++-Quelltext

if(in.is_open())

C-/C++-Quelltext

in >> m_map_height;

C-/C++-Quelltext

in.getline(buffer,8,'\n');
m_map_height = atoi(buffer);

C-/C++-Quelltext

 std::vector< sf::Sprite* >::iterator it;
    for(it = vSprite.begin(); it != vSprite.end(); it++)
    {
        delete *it;
        it = vSprite.erase(it);
    }

C-/C++-Quelltext

std::fstream in;
    
in.open(path);
if(in.is_open()){
        char buffer[256];

        // Höhe einlesen
        in >> m_map_height;
      
        // Breite einlesen
        in >> m_map_width;

        // Tile-Höhe einlesen
        in >> m_tile_height;

        // Tile-Breite einlesen
        in >> m_tile_width;

        // Anzahl der Sprites einlesen
        in >> sprite_anzahl;

        // Alle Pfade zu den Sprites einlesen und die Sprites erstellen
        for(unsigned int i = 0; i < sprite_anzahl; i++)
        {
            // Pfad einlesen
            in.getline(buffer, 255, '\n');

            // Sprite erstellen
            sf::Sprite *sp   = new sf::Sprite;

            //Texture erstellen
            sf::Texture *tex = new sf::Texture;

            // Textur laden
            if(!tex->loadFromFile(buffer))
                return EXIT_FAILURE;

            //Texture-Vector füllen
            vTexture.push_back(tex);

            //Sprite textuieren
            sp->setTexture(*tex);

            //Sprite-Vector mit texturierten Sprites füllen
            vSprite.push_back(sp);
        }