Gerüst der grafischen Oberfläche

public class MainActivity extends AppCompatActivity{
    public static Resources resources;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        resources = getResources();
        GameEngine view = new GameEngine(this);
        setContentView(view);
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                WindowManager.LayoutParams.FLAG_FULLSCREEN);
        getWindow().getDecorView().setSystemUiVisibility(
                View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                        | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                        | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                        | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
                        | View.SYSTEM_UI_FLAG_FULLSCREEN
                        | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY);
    }
}

/**
 * Created by Claan on 30.03.2016.
 */
public class GameEngine extends View
{
    boolean started = false;
    Canvas canvas;
    public static boolean running = true;
    private Handler handler = new Handler();
    View me = this;


    public GameEngine(final Context context) {
        super(context);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                if (canvas != null) {
                    GameHandler.onTick();
                    GameHandler.onRender(canvas);
                    me.invalidate();
                }
                handler.postDelayed(this, 1000/60);
            }
        };
        handler.post(runnable);


    }


    @Override
    protected void onDraw(Canvas canvas)
    {
        this.canvas = canvas;


        GameHandler.height = canvas.getHeight();
        GameHandler.width = canvas.getWidth();


        if(!started)
        {
            GameHandler.onInit();
            started = true;
        }
    }
}

/**
 * Created by Claan on 30.03.2016.
 */
public class GameHandler
{
    public static int height;
    public static int width;


    static TileMap tileMap;


    private static int tilesGröße = 64; 				//Größe der Tiles 64x64


    public static void onInit()
    {
        //Initialisieren


        tileMap = new TileMap(64);    //Größe der Tiles
        tileMap.loadTiles("/Tilesets/tilesetteil1_groß.gif", 1);
        tileMap.setPosition(0, 0);
        tileMap.setTween(1);
        tileMap.setWelt(0); // 0 == boden 1 != boden
        tileMap.loadMapIntegriert();


    }


    public static void onTick() 
    {


        tileMap.setPosition(
                GameHandler.width / 2 - player.getx(),
                GameHandler.height / 2 - player.gety()
        );


    }


    public static void onRender(Canvas canvas)
    {
        tileMap.draw(canvas);


        hud.draw(canvas);
    }


}

public class TileMap
{
	//Welt	0 = Boden 1 != boden
	private int welt = 0;
	// position
	private double x;
	private double y;
	// bounds
	private int xmin;
	private int ymin;
	private int xmax;
	private int ymax;
	private double tween;
	// map
	private int[][] map = {{zahlen..},
{zahlen..},
{zahlen..},
{zahlen..},
{zahlen..},
{zahlen..},
{zahlen..},
{zahlen..},
{zahlen..},
{zahlen..}}


			};
	private int[][] mapType;
	private int tileSize;
	private int numRows = map.length;   //Höhe
	private int numCols = map[0].length;   //Länge
	private int width;
	private int height;


	// tileset
	private Bitmap tileset;
	private int numTilesAcross;
	private Tile[][] tiles;
	// drawing
	private int rowOffset;
	private int colOffset;
	private int numRowsToDraw;
	private int numColsToDraw;
	public TileMap(int tileSize) 
	{
		this.tileSize = tileSize;
		numRowsToDraw = GameHandler.height / tileSize + 2;
		numColsToDraw = GameHandler.width / tileSize + 2;
		tween = 0.07;
	}
	public void loadTiles(String s, int welt)
		{
		try 
		{
			this.welt = welt;


            tileset = BitmapFactory.decodeResource(MainActivity.resources, R.drawable.tilesetteil);


			numTilesAcross = tileset.getWidth() / tileSize;
			tiles = new Tile[2][numTilesAcross];


			Bitmap subimage;
			for(int col = 0; col < numTilesAcross; col++)
			{
				subimage = Bitmap.createBitmap(tileset, col * tileSize, 0, tileSize, tileSize);


				tiles[0][col] = new Tile(subimage, Tile.NORMAL);


				subimage = Bitmap.createBitmap(tileset, col * tileSize, tileSize, tileSize, tileSize);


				tiles[1][col] = new Tile(subimage, Tile.BLOCKED);


				if(subimage == null)
					Log.d("asd", "Null");
				Log.d("asd", "Col" + col);
				Log.d("asd", "NumTileAcross" + numTilesAcross);
			}
		}
		catch(Exception e) 
		{
			e.printStackTrace();
		}
	}


	public void loadMapIntegriert()
	{
		width = numCols * tileSize;
		height = numRows * tileSize;


		xmin = GameHandler.width - width;
		xmax = 0;
		ymin = GameHandler.height - height;
		ymax = 0;
	}
	public int getTileSize() { return tileSize; }
	public double getx() { return x; }
	public double gety() { return y; }
	public int getWidth() { return width; }
	public int getHeight() { return height; }


    public void setWelt( int welt) { this.welt = welt; }


	public int getType(int row, int col) 
	{
		if(row >= 0 && row < 10 && col >= 0 && row < 10)
		{
			int rc = map[row][col];
			int r = rc / numTilesAcross;
			int c = rc % numTilesAcross;
			return tiles[r][c].getType();
		}
		return tiles[0][0].getType();
	}
	//v2
	public int istBlock(int y, int x)
	{
		if(map.length > y && map[0].length > x)
			return getType(y, x);		//oder mapType[y][x];
		else
			return 1;
	}
	public void setTween(double d) { tween = d; }
	public void setPosition(double x, double y) 
	{
		this.x += (x - this.x) * tween;
		this.y += (y - this.y) * tween;
		fixBounds();
		colOffset = (int)-this.x / tileSize;
		rowOffset = (int)-this.y / tileSize;
	}
	private void fixBounds() 
	{
		if(x < xmin) x = xmin;
		if(y < ymin) y = ymin;
		if(x > xmax) x = xmax;
		if(y > ymax) y = ymax;
	}
	public void draw(Canvas canvas)
	{


		for(int row = rowOffset; row < rowOffset + numRowsToDraw; row++)
		{
			if(row >= numRows) break;
			for(int col = colOffset; col < colOffset + numColsToDraw; col++) {
				if(col >= numCols) break;
				if(map[row][col] == 0 && welt != 0) continue;		//Wenn Tile 0 0 nicht verwendet werden soll also nicht da ist, aber ist der Boden
				int rc = map[row][col];
				int r = rc / numTilesAcross;
				int c = rc % numTilesAcross;


                try {
                    canvas.drawBitmap(tiles[r][c].getImage(), (int) x + col * tileSize, (int) y + row * tileSize, null);
                }catch(NullPointerException exe) {}




			}
		}
	}
}