FSML - komisches Verhalten

[Mr X]

Hallo,
Mein Programm(geschrieben in C++ mit FSML und vc++), es sollte derzeit eine Isometrische Karte anzeigen können, funktioniert nicht, da alle Tiles entweder garnicht, oder falsch angezeigt werden.
1. Sie sind alle weiß
2. Sie erscheinen an Stellen, wo sie nicht erscheinen sollten
3. Per Debugger habe ich festgestellt, das der Inhalt besagter Sprites sich an einer bestimmten Stelle ändert(siehe Quellcode in main.cpp, bzw. Karteladen.h).

Warum, bzw. was mache ich falsch?

Hier der relevante Code:

Main.cpp:

#include "Anzeigen.h"

int main() {
	lade(); //beim zurückspringen aus dieser Funktion passiert es...

	iHauptmenü.LoadFromFile("Hauptmenü.jpg");
	sHauptmenü.SetImage(iHauptmenü);

	while(Running) {
		eingeben();
		anzeigen();
	}

	return EXIT_SUCCESS;
}

Anzeigen.h

#include "Eingeben.h"

void anzeigen() {
	if(!SpielGestartet) {
		App.Draw(sHauptmenü);
	}
	else {
		for (int y = 0; y < Karte::SizeY; y++) {
			for (int x = 0; x < Karte::SizeX; x++) {
				//Neue Reihe der Tiles kommen nach 1/2 Breite eines Tiles
				y_px = y * (Karte::TileY / 2);

				//Jede zweite Reihe der Tiles um 1/2 Länge versetzt
				//-> wenn y ungerade, dann 1/2 Länge zu Tilepostion hinzuaddieren
				if(y % 2 == 1)	{
					x_px = (x * Karte::TileX + (Karte::TileX / 2));
				}
				else {
					x_px = (x * Karte::TileX);
				}

				x_px -= CameraX;
				y_px -= CameraY;

				Map.Tiles[x][y].setSpritePosition(x_px, y_px);
				if(y_px >= -1 * Karte::TileY && y_px < 550 + Karte::TileY && x_px >= -1 * Karte::TileX && x_px < 700 + Karte::TileX) {
					App.Draw(Map.Tiles[x][y].getSprite());
				}
			}
		}
	}
	// Display window contents on screen
	App.Display();
}

Eingeben.h

#include "Karteladen.h"

void eingeben() {/*irrelevantes*/}

Karteladen.h

#include "defdekl.h"

void lade() {
	Terrain[0].LoadFromFile("Tiles//Gras.bmp");
	Terrain[1].LoadFromFile("Tiles//Wasser.bmp");
	Terrain[2].LoadFromFile("Tiles//Fels.bmp");

	Ressourcen[0].LoadFromFile("Tiles//Baum1.bmp");

	char *Bauwerk[1];
	char *Zeit[5];
	char *Spieler[1];

	Bauwerk[0] = "Dorfzentrum";
	Zeit[0] = "Eiszeit";
	Zeit[1] = "Steinzeit";
	Zeit[2] = "Kupferzeit";
	Zeit[3] = "Bronzezeit";
	Zeit[4] = "Eisenzeit";
	Spieler[0] = "Rot";

	char buffer[200];

	for(int i = 0; i < 1; i++) { //Bauwerke
		for(int j = 0; j < 5; j++) { //Zeit
			for(int k = 0; k < 1; k++) { //Spieler
				sprintf_s(buffer, "Tiles//%s//%s//%s.bmp\0", Zeit[j], Spieler[k], Bauwerk[i]);
				Gebäude[i][j][k].LoadFromFile(buffer);
				Gebäude[i][j][k].CreateMaskFromColor(sf::Color::White);
			}
		}
	}

	std::ifstream einleser("StdMap.UTM");

	einleser.get(buffer,100,'=');
	einleser.get();
	for(int j = 0; j < Karte::SizeY; j++) {
		for(int i = 0; i < Karte::SizeX; i++) {
			int a;
			einleser >> a;
			einleser.get();
			int b;
			einleser >> b;
			einleser.get();
			if(a == 0) {
				Map.Tiles[i][j].setSpriteImg(Terrain[b]);
			}
			if(a == 1) {
				Map.Tiles[i][j].setSpriteImg(Ressourcen[b]);
			}

			if(a == 2) {
				int c;
				int d;
				einleser >> c;
				einleser.get();
				einleser >> d;
				einleser.get();

				Map.Tiles[i][j].setSpriteImg(Gebäude[b][c][d]);
			}
		}
	} //selbst nach diesen Schleifen ist noch nichts negatives passiert...
}

defdekl.h

#include "IsoGame.h"
#include <fstream>

using namespace IsoGame;

Karte Map;

int CameraX = (Karte::SizeX * Karte::TileX) / 2 - 450;
int	CameraY = (Karte::SizeY / 2 * Karte::TileY) / 2 - 300;

int x_px;
int y_px;

bool Running = true;
bool SpielGestartet = false;

// Create the main rendering window
sf::RenderWindow App(sf::VideoMode(1024, 768, 32), "URzeit 1.00");

sf::Sprite sHauptmenü;
sf::Image iHauptmenü;

const sf::Input& Input = App.GetInput();

// Process events
sf::Event Event;

sf::Image Terrain[3];
sf::Image Ressourcen[1];
sf::Image Gebäude[1][5][1]; //Bauart, Zeitalter, Farbe

IsoGame.h

#pragma once

#include "Element.h"
#include "Einheiten.h"

namespace IsoGame {
	class Karte {
	public:
		static const int SizeX = 4;
		static const int SizeY = 4;
		static const int TileX = 128;
		static const int TileY = 64;
		static const int Einheitenanzahl = 20;
		Element Tiles[SizeX][SizeY];
		Einheit Einheiten[Einheitenanzahl];
	private:
	public:
		Karte() {}
	};
}

Element.h

#pragma once

#include <SFML/Graphics.hpp>

namespace IsoGame {
	class Element {
	private:
		bool Begehbar;
		bool Befahrbar;
		int TerrainId;
		int AufbauId;
		sf::Sprite Sprite;
	public:
		Element() {}
		void setSpriteImg(sf::Image Img1);
		int getTerrainId();
		int getAufbauId();
		bool getBegehbar();
		bool getBefahrbar();
		sf::Sprite getSprite();
		void setTerrainId(int i);
		void setAufbauId(int i);
		void setSpritePosition(int i, int j);
		void setBegehbar(bool b);
		void setBefahrbar(bool b);
	};
}

Element.cpp

#pragma once
#include "Element.h"

void IsoGame::Element::setSpriteImg(sf::Image Img1) {
	Img1.CreateMaskFromColor(sf::Color::White);
	Sprite.SetImage(Img1);
}
int IsoGame::Element::getTerrainId() {
	return(TerrainId);
}
int IsoGame::Element::getAufbauId() {
	return(AufbauId);
}
bool IsoGame::Element::getBegehbar() {
	return(Begehbar);
}
bool IsoGame::Element::getBefahrbar() {
	return(Befahrbar);
}
sf::Sprite IsoGame::Element::getSprite() {
	return(Sprite);
}
void IsoGame::Element::setTerrainId(int i) {
	TerrainId = i;
}
void IsoGame::Element::setAufbauId(int i) {
	AufbauId = i;
}
void IsoGame::Element::setBegehbar(bool b) {
	Begehbar = b;
}
void IsoGame::Element::setBefahrbar(bool b) {
	Befahrbar = b;
}
void IsoGame::Element::setSpritePosition(int i, int j) {
	Sprite.SetPosition(i, j);
}

Sorry für diese Code-Masse...

Danke schon im Voraus!
mfg
Mr. X