So sieht die klasse TileMap aus :
[SPOILER=""][code=Java]
package dev.eflow.game.tileMap;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import javax.imageio.ImageIO;
import dev.eflow.game.drawable.Drawable;
public class TileMap implements Drawable{
public static String DELIMITER = "\\s+";
private int x;
private int y;
private int mapHeight;
private int mapWidth;
private int[][] map;
private Tile[][] tiles;
private BufferedImage tileSet;
private String path;
private int tileSize;
public TileMap(String path, int tileSize) {
this.path = path;
this.tileSize = tileSize;
InputStreamReader in;
BufferedReader reader;
try {
in = new InputStreamReader(getClass().getResourceAsStream(path));
reader = new BufferedReader(in);
mapHeight = Integer.parseInt(reader.readLine());
mapWidth = Integer.parseInt(reader.readLine());
map = new int[mapHeight][mapWidth];
for (int row = 0; row < mapHeight; row++) {
String line = reader.readLine();
String[] tokens = line.split(DELIMITER);
for (int col = 0; col < mapWidth; col++) {
map[row][col] = Integer.parseInt(tokens[col]);
}
}
} catch (IOException | NullPointerException ex) {
ex.printStackTrace();
}
}
public void loadTiles(String path){
try {
tileSet = ImageIO.read(getClass().getResourceAsStream(path));
int numTilesAcross = tileSet.getWidth() / tileSize;
BufferedImage subImage;
tiles = new Tile[2][numTilesAcross];
for (int col = 0; col < numTilesAcross - 1; col++) {
subImage = tileSet.getSubimage(col * tileSize, 0, tileSize, tileSize);
tiles[0][col] = new Tile(subImage, false);
subImage = tileSet.getSubimage(col * tileSize, tileSize, tileSize, tileSize);
tiles[1][col] = new Tile(subImage, true);
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
@Override
public void update() {
}
@Override
public void draw(Graphics g) {
for (int row = 0; row < mapHeight; row++) {
for (int col = 0; col < mapWidth; col++) {
//aktueller Wert der Position in der Map
int rc = map[row][col];
//aktuellen wert in position des tiles umrechnen
int c = rc / tiles[0].length;
int r = rc % tiles[0].length;
//tile an stelle c,r zeichen
g.drawImage(tiles[c][r].getImage(),col * tileSize - x,row * tileSize - y, tileSize, tileSize, null);
//raster zur besseren übersicht der Position
g.setColor(Color.LIGHT_GRAY);
g.drawRect(col * tileSize - x, row * tileSize - y, tileSize, tileSize);
}
}
}
public int getColTile(int x){
return x / tileSize;
}
public int getRowTile(int y){
return y / tileSize;
}
public int getTile(int row, int col){
return map[row][col];
}
public boolean isBlocked(int row, int col){
int rc = map[row][col];
int r = rc / tiles[0].length;
int c = rc % tiles[0].length;
return tiles[r][c].isBlocked();
}
public void setX(int x){
this.x = x;
}
public void setY(int y){
this.y = y;
}
public int getX() {return this.x;}
public int getY() {return this.y;}
public int getWidth() {return this.mapWidth;}
public int getHeight() {return this.mapHeight;}
public String getPath() {return this.path;}
public int getTileSize() {return this.tileSize;}
}
[/code][/SPOILER]
die X und Y Werte werden in der Update Methode der Klasse Player gesetzt :
[code=Java]
@Override
public void update() {
if (Direction.RIGHT) {
dx += moveSpeed;
}
else if (Direction.LEFT) {
dx -= moveSpeed;
}
if (Direction.UP) {
dy -= moveSpeed;
}
else if (Direction.DOWN) {
dy += moveSpeed;
}
map.setX(dx); // <<<
map.setY(dy); // <<<
if (Direction.DOWN && map.isBlocked(map.getRowTile(map.getY() + height), map.getColTile(map.getX()))) {
System.out.println("Collide " + map.getX() + " " + map.getY());
}
}
[/code]
wenn ich nun also den player bewege , wird die map entsprechend an diese koordinaten gezeichnet :
[code=Java]g.drawImage(tiles[c][r].getImage(),col * tileSize - x, row * tileSize - y, tileSize, tileSize, null);[/code]
also werden die tiles , wenn sich der player nach rechts bewegt, dementsprechend nach links bewegt und den Wert um welchen sich die Position des players nach rechts erhöht hat, dies schien mir logisch , kann natürlich durchaus sein das ich da irgendwo einen Denkfehler habe, aber ich war der Meinung das es so ablaufen muss :
Spieler bewegt sich nach rechts (Direction.RIGHT) :
Player -> (x++)
Map <- (x--)
Spieler bewegt sich nach links (Direction.LEFT):
Player <- (x--)
Map -> (x++)
ebenso für UP and DOWN.
Falls es nicht so sein sollte helft mir doch mal auf die Sprünge 
