Tilemaps (Array)

[Hansi (Gast)]

Hallo zusammen,

hab ein Problem und zwar habe ich einen Punkt, der sich wie in einem 
PacMan spiel steuern lassen soll. Funktioniert alles auch. Nur bei der 
Map habe ich Probleme.

Hier der Codeausschnitt:

#include "Game.hpp"

// Tiles - Konstanten
const unsigned int TILE_WIDTH = 80;
const unsigned int TILE_HEIGHT = 80;
const int TOTAL_TILES = 64;
const int TILES_SPRITES = 4;
  
// Map Größe
const unsigned int map_breite = 16;
const unsigned int map_hoehe = 4;

// Map selbst
unsigned int level_1[map_breite*map_hoehe] =  
  { 0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,
  3,2,1,0,0,1,2,3,0,1,2,3,0,1,2,3,
  0,0,0,0,0,1,2,3,0,1,2,3,0,1,2,3,
  3,3,3,3,0,1,2,3,0,1,2,3,0,1,2,3
};
unsigned int tilemap[map_breite][map_hoehe];
// Konstruktor
//
// Aufgabe: Allgemeine Initialisierungen
//
CGame::CGame ()
{
  m_pPlayer = NULL;
  p_Spritemap = NULL;

} // Konstruktor


// Run
//
// Aufgabe: Hauptschleife des Spiels
//
void CGame::Run ()
{
  // Hauptschleife des Spiels durchlaufen
  //
  while (m_bGameRun == true)
  {
  
    // Events bearbeiten
    ProcessEvents ();
    
    // Framework updaten und Buffer löschen
    g_pFramework->Update ();
    g_pFramework->Clear ();

    int byte_nr = 0;
    for (int j = 0; j<map_hoehe; j++)
    {
      for (int k = 0; k<map_breite; k++)
      {
        tilemap[j][k] = level_1[byte_nr];
        p_Spritemap[tilemap[j][k]].SetPos(k*TILE_HEIGHT, j*TILE_WIDTH);
        p_Spritemap[tilemap[j][k]].Render();
        
        byte_nr++;
      }
    }

    // Spieler updaten und rendern
    m_pPlayer->Update ();
    m_pPlayer->Render ();
    
    CheckCollisions();

    // Buffer flippen
    g_pFramework->Flip ();
     
  }


} // Run


// CheckCollisions
//
// Aufgabe: Kollisionen überprüfen
//
void CGame::CheckCollisions ()
{
    SDL_Rect Player;
    SDL_Rect Tile[map_breite][map_hoehe];
    Player = m_pPlayer->GetRect();
    
      for (int j = 0; j<map_hoehe; j++)
    {
      for (int k = 0; k<map_breite; k++)
      {
        
        Tile[j][k] = p_Spritemap[tilemap[j][k]].GetRect();
        if (tilemap[j][k] == 0)
        {
        if (Tile[j][k].y < Player.y + Player.h &&
          Tile[j][k].y + Tile[j][k].h > Player.y &&
          Tile[j][k].x < Player.x + Player.w &&
          Tile[j][k].x + Tile[j][k].w > Player.x)
        {
          m_bGameRun = false;
        }
        }
        
      }
      }


} // CheckCollisions

Sobald ich mit dem Punkt das Feld mit 0, in dem Fall mit der Farbe rot, 
berühre, soll das Spiel beendet werden. Problem ist, es tut sich nichts. 
Kopiere ich den Code aus CHECKCOLLISION oben in die ersten beiden 
Schleifen rein, funktioniert es. Hat jemand eine Idee?

Danke vorab!

[Max T. (charmquark)]

Hi!

Wie ist m_bGameRun deklariert? Mit volatile?
Warum schreibst du die Rückgabe von CheckCollisions in eine Globale 
Variable, statt einen Rückgabewert zu benutzen?
Ausserdem frage ich mich, warum du bei jedem Aufruf das komplette 
Tile[j][k]-Array füllst, wenn du bei jeder iteration nur einen einzelnen 
Wert brauchst. Genau so in der haupt-Schleife.

Ich glaube du machst das viel zu umständlich mit der Kollisions-Abfrage. 
Warum fragst du nicht einfach ab, auf welchem tile sich der Spieler 
befindet und schaust dann, ob in der tilemap an der Stelle ein tile ist? 
Oder habe ich das Prinzip falsch verstanden?

[Hansi (Gast)]

Hi,

bGameRun habe ich nur zu Testzwecken benutzt. Laut Debugger liegt der 
Fehler hier:

Tile[j][k] = p_Spritemap[tilemap[j][k]].GetRect();

GetRect gibt mir ja den aktuellen Wert des Rects zurück. Aber aus irgend 
einem Grund habe ich für alle Felder immer den ein und den selben Wert x 
= -131... und y = 92...

Du hast ja recht, ich fülle bei jedem Durchgang das komplette Array neu. 
Es liegt daran, dass ich erst einmal selbst das Ganze auf meine Art 
versuchen möchte. Optimieren kann ich es dann immer noch. Möchte aber, 
dass der grobe Ablauf stimmt ...