¿Cómo verifico Collision en un juego basado en mosaicos para Android?

¿Cómo puedo verificar la colisión en un juego basado en fichas? He mirado los ejemplos que tiene el SDK de Android, pero no puedo entenderlos porque soy nuevo en la programación de Android.

Estas son mis clases de mapas y fichas que mi héroe toma para poder moverlo por el mundo

 class Map{
    int X = 0;
    int Y = 0; 
    int tileSize = 30;

    int [][]map= {
            //0 = empty tile
            //1 = wall
            //2 = player
            {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
            {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
            {1,0,0,0,0,0,1,1,2,1,1,0,0,0,0,0,1},
            {1,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,1},
            {1,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,1},
            {1,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,1},
            {1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1},
            {1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1},
            {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
            {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            };



    ArrayList<Tile> tiles = new ArrayList<Tile>();;

    public Map(){
        loadArray();
    }

    public void loadArray(){

        for(int xTiles = 0; xTiles< map.length; xTiles++ ){
            for(int yTiles = 0; yTiles< map[xTiles].length; yTiles++){
                if(map[xTiles][yTiles]==1){//Wall
                tiles.add(new Tile(X, Y, tileSize, map[xTiles][yTiles]));
                tiles.get(tiles.size()-1).setColor(Color.GRAY);
                tiles.get(tiles.size()-1).walkable = false;
                X+=tileSize;
                }else if(map[xTiles][yTiles]==0){//Empty Tile
                    tiles.add(new Tile(X, Y, tileSize, map[xTiles]      [yTiles]));
                X+=tileSize;
                }else if(map[xTiles][yTiles]==2){//Player 
                    tiles.add(new Tile(X, Y, tileSize, map[xTiles][yTiles]));
                X+=tileSize;    
                }
            }
            Y+=tileSize;
            X=0;
            }
        }

    public void drawMap(Canvas canvas){
    for(int index = 0; index < tiles.size(); index++){
        tiles.get(index).drawTile(canvas);
    }
}

}

    class Tile{
    private int type;
    int X;
    int Y;
    int size;
    boolean walkable = true;
    Paint color = new Paint();;
    //rect for the bounds
    Rect bounds = new Rect();

    public Tile(){
        type = 0;
        X = 0;
        Y = 0;
        size = 0;
        color.setColor(Color.TRANSPARENT);
        bounds.set(X, Y, X+size, Y+size);

    }



    public Tile(int X, int Y , int tileSize, int type){
        this.type = type;
        this.X = X;
        this.Y = Y;
        size = tileSize;
        color.setColor(Color.TRANSPARENT);
        bounds.set(X, Y, X+size, Y+size);
    }



    public int getX() {
        return X;
    }



    public int getY() {
        return Y;
    }



    public void setX(int x) {
        X = x;
    }



    public void setY(int y) {
        Y = y;
    }



    public int getType() {
        // TODO Auto-generated method stub
        return type;
    }
    public Paint getColor() {
        return color;
    }

    public void setColor(int color) {
        this.color.setColor(color);
    }

    public void drawTile(Canvas canvas){
        canvas.drawRect(bounds, color);
    }
}

esta es mi clase de heroe

 class Hero{
    private static final int SIZE = 30;
    //Coordinates 
    int X = 60;
    int Y = 60;
    int sx=30, sy=30;
    private Paint paint = new Paint();
    public Rect Bounds = new Rect(X,Y,X+30,Y+30);
    boolean solid = true;

    //Map Things
    Map map;

    public Hero(Map map){
        this.map = map;
        paint.setColor(Color.RED);
        paint.setStyle(Style.FILL_AND_STROKE);

        location();
    }




    private void location() {

        for(int index = 0; index<map.tiles.size(); index++){
            if(map.tiles.get(index).getType() == 2){
                this.X = map.tiles.get(index).getX();
                this.Y = map.tiles.get(index).getY();

            }
        }

    }




    public void move(int KeyCode) {
        switch(KeyCode){

        case KeyEvent.KEYCODE_DPAD_DOWN:
            {if(Collision()){Y+=sy;} break;}
        case KeyEvent.KEYCODE_DPAD_UP:
            {Y-=sy; break;}
        case KeyEvent.KEYCODE_DPAD_LEFT:
            {X-=sx; break;}
        case KeyEvent.KEYCODE_DPAD_RIGHT:
            {X+=sx; break;}
        }

    }







    private boolean Collision() {
        for(int index = 0; index< map.tiles.size(); index++){
            if(Rect.intersects(map.tiles.get(index).bounds, this.Bounds)){
                return map.tiles.get(index).walkable;}  
        }
        return false;
    }




    public int getX() {
        return X;
    }



    public int getY() {
        return Y;
    }



    public void setX(int x) {
        X = x;
    }



    public void setY(int y) {
        Y = y;
    }


    public void position(int x, int y){
        X = x;
        Y = y;

    }

    public void update(){
        Bounds.set(X, Y, (X+SIZE), (Y+SIZE));

    }


    public void Draw(Canvas canvas){
        canvas.drawRect(Bounds, paint);
        canvas.drawText("Player", Bounds.left, Bounds.top-5, paint);
    }
}

¿Cómo puedo verificar la colisión? ¿Debería simplemente recorrer cada mosaico y luego verificar si las nuevas coordenadas del Jugador colisionarán?

Esto podría no ser la forma correcta, pero funcionó. Agregué métodos para cada dirección de movimiento Derecha, Izquierda, Arriba y Abajo de esta manera

private void moveLeft() {
    for(int index = 0 ; index < map.tiles.size();index++){
        if(yCoord-1 == map.tiles.get(index).yCoord && xCoord == map.tiles.get(index).xCoord){
            if(map.tiles.get(index).walkable){  
            X-=SIZE;
                //My coordinates are flipped for some reason my Xs are Ys and Ys are Xs
                yCoord-=1;
                break;
            }
        }
    }

}
Respuesta 1

Debes registrar la última posición del héroe. En cada evento de movimiento, puedes marcar la siguiente casilla en la dirección relativa al héroe. Como implementaste en una matriz bidimensional, entonces, si la posición del héroe es decir mapa [0] [0] y el jugador bajó una posición a la vez, entonces Posición relativa en el mapa, es decir, mapa [1] [0]. de esta manera puedes minimizar la comparación. Cada dirección tiene peso en dos dimensiones comoup movement can have [CurrentPosition.x-1] [CurrentPosition.y-1], Left can have [CurrentPosition.x] [CurrentPosition.y+1] etc....

Respuesta: 2

Se supone que mi API me dará una lista de ropa / móviles / etc. Pero, hay pocos elementos adicionales en cada una de la lista. Por ejemplo: Abrigos Chaquetas Pantalones Vaqueros ... Trajes tipos de ropa testing_1 ...

Entonces, para una tarea en la escuela, debo hacer un programa en Java que administre a algunos estudiantes en una universidad, el usuario puede invocar una serie de funciones, pero comencé probando 'agregar'. Mi prof ...

Este código es para una de mis tareas (conectar cuatro). Necesito hacer que este código tenga menos de 25 líneas y también hacer que las declaraciones 'if' sean más cortas. Además, el tablero tiene 6 filas y 7 columnas. Mi código es ...

Recientemente tuve una pregunta de diseño de objeto / clase. El problema era este: "Tienes una universidad y tiene empleados, que pueden ser estudiantes o maestros". Me pidieron que diseñara solo el ...