Android Studio Project

XML:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".MainActivity">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_weight="0"
        android:orientation="vertical">

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:orientation="horizontal">

            <ImageButton
                android:id="@+id/enemy_up"
                android:layout_width="wrap_content"
                android:layout_height="40dp"
                android:layout_weight="1"
                android:background="#00000000"
                android:scaleType="centerInside"
                app:srcCompat="@drawable/enemy_arrow_up" />
        </LinearLayout>

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:orientation="horizontal">

            <ImageButton
                android:id="@+id/enemy_left"
                android:layout_width="wrap_content"
                android:layout_height="40dp"
                android:layout_weight="1"
                android:background="#00000000"
                android:scaleType="centerInside"
                app:srcCompat="@drawable/enemy_arrow_left" />

            <ImageButton
                android:id="@+id/enemy_right"
                android:layout_width="wrap_content"
                android:layout_height="40dp"
                android:layout_weight="1"
                android:background="#00000000"
                android:scaleType="centerInside"
                app:srcCompat="@drawable/enemy_arrow_right" />

        </LinearLayout>

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:orientation="horizontal">

            <ImageButton
                android:id="@+id/enemy_down"
                android:layout_width="wrap_content"
                android:layout_height="40dp"
                android:layout_weight="1"
                android:background="#00000000"
                android:scaleType="centerInside"
                app:srcCompat="@drawable/enemy_arrow_down" />
        </LinearLayout>
    </LinearLayout>

    <com.example.BallBrawl.PixelGridView
        android:id="@+id/pixelGridView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_weight="1" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_weight="0"
        android:orientation="vertical">

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:orientation="horizontal">

            <ImageButton
                android:id="@+id/player_up"
                style="@style/Widget.AppCompat.ImageButton"
                android:layout_width="wrap_content"
                android:layout_height="40dp"
                android:layout_weight="1"
                android:background="#00000000"
                android:scaleType="fitCenter"
                app:srcCompat="@drawable/player_arrow_up" />

        </LinearLayout>

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:orientation="horizontal">

            <ImageButton
                android:id="@+id/player_left"
                android:layout_width="wrap_content"
                android:layout_height="40dp"
                android:layout_weight="1"
                android:background="#00000000"
                android:scaleType="centerInside"
                app:srcCompat="@drawable/player_arrow_left" />

            <ImageButton
                android:id="@+id/player_right"
                android:layout_width="wrap_content"
                android:layout_height="40dp"
                android:layout_weight="1"
                android:background="#00000000"
                android:scaleType="centerInside"
                app:srcCompat="@drawable/player_arrow_right" />

        </LinearLayout>

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:orientation="horizontal">

            <ImageButton
                android:id="@+id/player_down"
                android:layout_width="wrap_content"
                android:layout_height="40dp"
                android:layout_weight="1"
                android:background="#00000000"
                android:scaleType="centerInside"
                app:srcCompat="@drawable/player_arrow_down" />

        </LinearLayout>

    </LinearLayout>

</LinearLayout>

MainActivity:
package com.example.BallBrawl;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;

import android.content.pm.ActivityInfo;
import android.content.res.Configuration;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.widget.ImageButton;

import static com.example.BallBrawl.PixelGridView.enemyDead;
import static com.example.BallBrawl.PixelGridView.playerDead;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    ImageButton player_up, player_down, player_left, player_right,
                enemy_up, enemy_down, enemy_left, enemy_right;
    PixelGridView pixelGridView;
    boolean turn = false;

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        MenuInflater inflater = getMenuInflater();
        inflater.inflate(R.menu.menu, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(@NonNull MenuItem item) {
        switch(item.getItemId()){
            case R.id.reset:
                pixelGridView.reset();
                turn = false;
                return true;
            case R.id.density1:
                pixelGridView.random(10);
                return true;
            case R.id.density2:
                pixelGridView.random(6);
                return true;
            case R.id.density3:
                pixelGridView.random(3);
                return true;
            default:
                return super.onOptionsItemSelected(item);
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        player_up = findViewById(R.id.player_up);
        player_down = findViewById(R.id.player_down);
        player_left = findViewById(R.id.player_left);
        player_right = findViewById(R.id.player_right);
        enemy_up = findViewById(R.id.enemy_up);
        enemy_down = findViewById(R.id.enemy_down);
        enemy_left = findViewById(R.id.enemy_left);
        enemy_right = findViewById(R.id.enemy_right);
        pixelGridView = findViewById(R.id.pixelGridView);
        pixelGridView.setDimensions(20, 20);
        pixelGridView.random(10);

        player_up.setOnClickListener(this);
        player_down.setOnClickListener(this);
        player_left.setOnClickListener(this);
        player_right.setOnClickListener(this);
        enemy_up.setOnClickListener(this);
        enemy_down.setOnClickListener(this);
        enemy_left.setOnClickListener(this);
        enemy_right.setOnClickListener(this);

    }

    @Override
    public void onClick(View view) {
        if(enemyDead){
            turn = false;
        }
        if(playerDead){
            turn = true;
        }
        if (view == player_right) {
            if(!turn) {
                pixelGridView.player_goRight();
                turn = !turn;
            }
            else{}
        }
        if (view == player_left) {
            if(!turn) {
                pixelGridView.player_goLeft();
                turn = !turn;
            }
            else{}
        }
        if (view == player_up) {
            if(!turn) {
                pixelGridView.player_goUp();
                turn = !turn;
            }
            else{}
        }
        if (view == player_down) {
            if(!turn) {
                pixelGridView.player_goDown();
                turn = !turn;
            }
            else{}
        }
        if (view == enemy_right) {
            if(turn) {
                pixelGridView.enemy_goRight();
                turn = !turn;
            }
            else{}
        }
        if (view == enemy_left) {
            if(turn) {
                pixelGridView.enemy_goLeft();
                turn = !turn;
            }
            else{}
        }
        if (view == enemy_up) {
            if(turn) {
                pixelGridView.enemy_goUp();
                turn = !turn;
            }
            else{}
        }
        if (view == enemy_down) {
            if(turn) {
                pixelGridView.enemy_goDown();
                turn = !turn;
            }
            else{}
        }
    }
    @Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
    }
}

PixelGridView:
package com.example.BallBrawl;

import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import android.widget.Toast;

import androidx.annotation.Nullable;
import androidx.annotation.RequiresApi;

import java.util.Random;

import static java.lang.Thread.sleep;

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
public class PixelGridView extends View {
    private int numColumns, numRows;
    private int cellWidth, cellHeight;
    private Paint clearPaint = new Paint();
    private Square[][] cellChecked;
    private int saveI, saveJ;
    private Player player;
    private Enemy enemy;
    private boolean init = false;
    public static boolean playerDead;
    public static boolean enemyDead;
    Drawable edge1 = getResources().getDrawable(R.drawable.edge_top, null);
    Drawable edge2 = getResources().getDrawable(R.drawable.edge_right, null);
    Drawable edge3 = getResources().getDrawable(R.drawable.edge_bottom, null);
    Drawable edge4 = getResources().getDrawable(R.drawable.edge_left, null);
    Drawable edge5 = getResources().getDrawable(R.drawable.edge_top_left, null);
    Drawable edge6 = getResources().getDrawable(R.drawable.edge_top_right, null);
    Drawable edge7 = getResources().getDrawable(R.drawable.edge_bottom_right, null);
    Drawable edge8 = getResources().getDrawable(R.drawable.edge_bottom_left, null);
    Drawable player_ball = getResources().getDrawable(R.drawable.player_ball, null);
    Drawable enemy_ball = getResources().getDrawable(R.drawable.enemy_ball, null);
    Drawable block = getResources().getDrawable(R.drawable.block,null);

    public PixelGridView(Context context) {
        this(context, null);
    }

    public PixelGridView(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        clearPaint.setStyle(Paint.Style.FILL_AND_STROKE);
        clearPaint.setColor(0);
        invalidate();
    }

    public void setDimensions(int numColumns, int numRows) {
        this.numColumns = numColumns;
        this.numRows = numRows;
        calculateDimensions();
    }

    public int getNumColumns() {
        return numColumns;
    }

    public int getNumRows() {
        return numRows;
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        calculateDimensions();
    }

    private void calculateDimensions() {
        if (numColumns < 1 || numRows < 1) {
            return;
        }

        cellWidth = getWidth() / numColumns;
        cellHeight = getWidth() / numColumns;
        player = new Player(0, 0);
        cellChecked = new Square[numRows][numColumns];
        for (int i = 0; i < numColumns; i++) {
            for (int j = 0; j < numRows; j++) {
                cellChecked[i][j] = new Square(false, i, j);
                if (i == 0 || j == 0 || i == numColumns - 1 || j == numRows - 1) {
                    cellChecked[i][j].setCollidable(true);
                }
            }
        }

        invalidate();
    }

    @Override
    protected void onDraw(Canvas canvas) {
        if (numColumns == 0 || numRows == 0) {
            return;
        }
        int width = getWidth();
        int height = getWidth();
        if (!init) {
            player_ball.setBounds(cellWidth, cellHeight,2*cellWidth,2*cellHeight);
            player_ball.draw(canvas);
            player = new Player(1, 1);
            cellChecked[player.getPosX()][player.getPosY()].setHasPlayer(true);

            enemy_ball.setBounds((numColumns-2)*cellWidth,(numRows-2)*cellHeight,(numColumns-1)*cellWidth,(numRows-1)*cellHeight);
            enemy_ball.draw(canvas);
            enemy = new Enemy(numColumns - 2, numRows - 2);
            cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(true);

            for (int i = 0; i < numColumns; i++) {
                for (int j = 0; j < numRows; j++) {
                    if (cellChecked[i][j].getCollidable()) {
                        if (!(i == 0 || j == 0 || i == numColumns - 1 || j == numRows - 1)) {
                            block.setBounds(i*cellWidth,j*cellHeight,(i+1)*cellWidth,(j+1)*cellHeight);
                            block.draw(canvas);
                        } else {
//                            canvas.drawRect(i * cellWidth, j * cellHeight,
//                                    (i + 1) * cellWidth, (j + 1) * cellHeight,
//                                    grayPaint);
                            if(i==0 && j==0){
                                edge5.setBounds(0,0,cellWidth,cellHeight);
                                edge5.draw(canvas);
                            }
                            if(i==numColumns-1 && j==0){
                                edge6.setBounds((numColumns-1)*cellWidth, 0,(numColumns)*cellWidth, cellHeight);
                                edge6.draw(canvas);
                            }
                            if(i==0 && j==numRows-1){
                                edge8.setBounds(0,(numRows-1)*cellHeight, cellWidth, numRows*cellHeight);
                                edge8.draw(canvas);
                            }
                            if(i==numColumns-1 && j==numColumns-1){
                                edge7.setBounds((numColumns-1)*cellWidth, (numRows-1)*cellHeight, numColumns*cellWidth, numRows*cellHeight);
                                edge7.draw(canvas);
                            }
                            if(i==1 && j==0){
                                edge1.setBounds(cellWidth, 0, (numColumns-1)*cellWidth,cellHeight);
                                edge1.draw(canvas);
                            }
                            if(i==0 && j==1) {
                                edge4.setBounds(0, cellHeight, cellWidth, (numRows - 1) * cellHeight);
                                edge4.draw(canvas);
                            }
                            if(i==numColumns-1 && j==0){
                                edge2.setBounds((numColumns-1)*cellWidth, cellHeight, numColumns*cellWidth,(numColumns-1)*cellHeight);
                                edge2.draw(canvas);
                            }
                            if(i==numRows-1 && j==1){
                                edge3.setBounds(cellWidth,(numRows-1)*cellHeight, (numColumns-1)*cellWidth, numRows*cellHeight);
                                edge3.draw(canvas);
                            }
                        }
                    }
                }
            }

//            for (int i = 0; i < numColumns + 1; i++) {
//                canvas.drawLine(i * cellWidth, 0, i * cellWidth, height, grayPaint);
//            }
//
//            for (int i = 0; i < numRows + 1; i++) {
//                canvas.drawLine(0, i * cellHeight, width, i * cellHeight, grayPaint);
//            }
            init = true;
        } else {

            for (int i = 0; i < numColumns; i++) {
                for (int j = 0; j < numRows; j++) {
                    if (cellChecked[i][j].getCollidable()) {
                        if (!(i == 0 || j == 0 || i == numColumns - 1 || j == numRows - 1)) {
                            block.setBounds(i*cellWidth,j*cellHeight,(i+1)*cellWidth,(j+1)*cellHeight);
                            block.draw(canvas);
                        }
                        else {
//                            canvas.drawRect(i * cellWidth, j * cellHeight,
//                                    (i + 1) * cellWidth, (j + 1) * cellHeight,
//                                    grayPaint);
                            if(i==0 && j==0){
                                edge5.setBounds(0,0,cellWidth,cellHeight);
                                edge5.draw(canvas);
                            }
                            if(i==numColumns-1 && j==0){
                                edge6.setBounds((numColumns-1)*cellWidth, 0,(numColumns)*cellWidth, cellHeight);
                                edge6.draw(canvas);
                            }
                            if(i==0 && j==numRows-1){
                                edge8.setBounds(0,(numRows-1)*cellHeight, cellWidth, numRows*cellHeight);
                                edge8.draw(canvas);
                            }
                            if(i==numColumns-1 && j==numColumns-1){
                                edge7.setBounds((numColumns-1)*cellWidth, (numRows-1)*cellHeight, numColumns*cellWidth, numRows*cellHeight);
                                edge7.draw(canvas);
                            }
                            if(i==1 && j==0){
                                edge1.setBounds(cellWidth, 0, (numColumns-1)*cellWidth,cellHeight);
                                edge1.draw(canvas);
                            }
                            if(i==0 && j==1) {
                                edge4.setBounds(0, cellHeight, cellWidth, (numRows - 1) * cellHeight);
                                edge4.draw(canvas);
                            }
                            if(i==numColumns-1 && j==0){
                                edge2.setBounds((numColumns-1)*cellWidth, cellHeight, numColumns*cellWidth,(numColumns-1)*cellHeight);
                                edge2.draw(canvas);
                            }
                            if(i==numRows-1 && j==1){
                                edge3.setBounds(cellWidth,(numRows-1)*cellHeight, (numColumns-1)*cellWidth, numRows*cellHeight);
                                edge3.draw(canvas);
                            }
                        }
                    } else {
                        canvas.drawRect(i * cellWidth, j * cellHeight,
                                (i + 1) * cellWidth, (j + 1) * cellHeight,
                                clearPaint);
                    }
                }
            }
            /*for(int i = 1; i < numColumns-2; i++){
                for(int j = 1; j < numRows-2; j++){
                    if(cellChecked[i][j].getHasPlayer()){
                        canvas.drawCircle(i, j, cellWidth / 2, playerPaint);
                    }
                }
            }
            for(int i = 1; i < numColumns-2; i++){
                for(int j = 1; j < numRows-2; j++){
                    if(cellChecked[i][j].getHasEnemy()){
                        canvas.drawCircle(i, j, cellWidth / 2, enemyPaint);
                    }
                }
            }*/

            player_ball.setBounds(player.getPosX()*cellWidth, player.getPosY()*cellHeight,(player.getPosX()+1)*cellWidth,(player.getPosY()+1)*cellHeight);
            player_ball.draw(canvas);

            enemy_ball.setBounds(enemy.getPosX()*cellWidth, enemy.getPosY()*cellHeight,(enemy.getPosX()+1)*cellWidth,(enemy.getPosY()+1)*cellHeight);
            enemy_ball.draw(canvas);
        }
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (event.getAction() == MotionEvent.ACTION_DOWN && event.getY() < numRows * cellHeight && event.getX() < numColumns * cellWidth && event.getY() > 0) {
            int column = (int) (event.getX() / cellWidth);
            saveI = column;
            int row = (int) (event.getY() / cellHeight);
            saveJ = row;
            if (!cellChecked[column][row].getHasPlayer() && !cellChecked[column][row].getHasEnemy()) {
                if (!(column == 0 || row == 0 || column == numColumns - 1 || row == numRows - 1)) {
                    cellChecked[column][row].setCollidable(!cellChecked[column][row].getCollidable());
                    invalidate();
                }
            }
        } else if (event.getAction() == MotionEvent.ACTION_MOVE && event.getY() < numRows * cellHeight && event.getX() < numColumns * cellWidth && event.getY() > 0) {
            int column = (int) (event.getX() / cellWidth);
            int row = (int) (event.getY() / cellHeight);
            if (column == saveI && row == saveJ) {
            } else {
                if (!cellChecked[column][row].getHasPlayer() && !cellChecked[column][row].getHasEnemy()) {
                    if (!(column == 0 || row == 0 || column == numColumns - 1 || row == numRows - 1)) {
                        cellChecked[column][row].setCollidable(cellChecked[saveI][saveJ].getCollidable());
                        invalidate();
                    }
                }
            }
        }
        return true;
    }

    public void random(int num) {
        for (int i = 0; i < numColumns; i++) {
            for (int j = 0; j < numRows; j++) {
                if (!(i == 0 || j == 0 || i == numColumns - 1 || j == numRows - 1)) {
                    cellChecked[i][j].setCollidable(false);
                }
            }
        }
        for (int i = 0; i < numColumns; i++) {
            for (int j = 0; j < numRows; j++) {
                if (!cellChecked[i][j].getHasPlayer() && !cellChecked[i][j].getHasEnemy()) {
                    if (!(i == 0 || j == 0 || i == numColumns - 1 || j == numRows - 1)) {
                        int random = new Random().nextInt(num) + 1;
                        if (random == 1) {
                            cellChecked[i][j].setCollidable(true);
                        }
                    }
                }
            }
        }
        invalidate();
    }

    public void reset() {
        for (int i = 0; i < numColumns; i++) {
            for (int j = 0; j < numRows; j++) {
                if (!(i == 0 || j == 0 || i == numColumns - 1 || j == numRows - 1)) {
                    cellChecked[i][j].setCollidable(false);
                }
            }
        }
        if(playerDead)
            revivePlayer(player);
        if(enemyDead)
            reviveEnemy(enemy);
        init = false;
        invalidate();
    }


    public void player_goRight() {
        if(!player_eat(2)) {
            cellChecked[player.getPosX()][player.getPosY()].setHasPlayer(false);
            while (!cellChecked[player.getPosX() + 1][player.getPosY()].getCollidable()) {
                player.setPosX(player.getPosX() + 1);
                eatEnemy();
                invalidate();
            }
            cellChecked[player.getPosX()][player.getPosY()].setHasPlayer(true);
        }
    }

    public void player_goLeft() {
        if(!player_eat(3)) {
            cellChecked[player.getPosX()][player.getPosY()].setHasPlayer(false);
            while (!cellChecked[player.getPosX() - 1][player.getPosY()].getCollidable()) {
                player.setPosX(player.getPosX() - 1);
                eatEnemy();
                invalidate();
            }
            cellChecked[player.getPosX()][player.getPosY()].setHasPlayer(true);
        }
    }

    public void player_goUp() {
        if(!player_eat(0)) {
            cellChecked[player.getPosX()][player.getPosY()].setHasPlayer(false);
            while (!cellChecked[player.getPosX()][player.getPosY() - 1].getCollidable()) {
                player.setPosY(player.getPosY() - 1);
                eatEnemy();
                invalidate();
            }
            cellChecked[player.getPosX()][player.getPosY()].setHasPlayer(true);
        }
    }

    public void player_goDown() {
        if(!player_eat(1)) {
            cellChecked[player.getPosX()][player.getPosY()].setHasPlayer(false);
            while (!cellChecked[player.getPosX()][player.getPosY() + 1].getCollidable()) {
                player.setPosY(player.getPosY() + 1);
                eatEnemy();
                invalidate();
            }
            cellChecked[player.getPosX()][player.getPosY()].setHasPlayer(true);
        }
    }

    public void enemy_goRight() {
        if(!enemy_eat(2)) {
            cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(false);
            while (!cellChecked[enemy.getPosX() + 1][enemy.getPosY()].getCollidable()) {
                enemy.setPosX(enemy.getPosX() + 1);
                eatPlayer();
                invalidate();
            }
            cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(true);
        }
    }

    public void enemy_goLeft() {
        if (!enemy_eat(3)) {
            cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(false);
            while (!cellChecked[enemy.getPosX() - 1][enemy.getPosY()].getCollidable()) {
                enemy.setPosX(enemy.getPosX() - 1);
                eatPlayer();
                invalidate();
            }
            cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(true);
        }
    }

    public void enemy_goUp() {
        if(!enemy_eat(0)) {
            cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(false);
            while (!cellChecked[enemy.getPosX()][enemy.getPosY() - 1].getCollidable()) {
                enemy.setPosY(enemy.getPosY() - 1);
                eatPlayer();
                invalidate();
            }
            cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(true);
        }
    }

    public void enemy_goDown() {
        if (!enemy_eat(1)) {
            cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(false);
            while (!cellChecked[enemy.getPosX()][enemy.getPosY() + 1].getCollidable()) {
                enemy.setPosY(enemy.getPosY() + 1);
                eatPlayer();
                invalidate();
            }
            cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(true);
        }
    }

    public boolean player_eat(int num) {
        if (num == 0) {
            if (cellChecked[player.getPosX()][player.getPosY() - 1].getsPosY() != 0 && cellChecked[player.getPosX()][player.getPosY() - 1].getCollidable()) {
                cellChecked[player.getPosX()][player.getPosY() - 1].setCollidable(false);
                invalidate();
                return true;
            }
        } else if (num == 1) {
            if (cellChecked[player.getPosX()][player.getPosY() + 1].getsPosY() != numRows - 1 && cellChecked[player.getPosX()][player.getPosY() + 1].getCollidable()) {
                cellChecked[player.getPosX()][player.getPosY() + 1].setCollidable(false);
                invalidate();
                return true;
            }
        } else if (num == 2) {
            if (cellChecked[player.getPosX() + 1][player.getPosY()].getsPosX() != numColumns - 1 && cellChecked[player.getPosX() + 1][player.getPosY()].getCollidable()) {
                cellChecked[player.getPosX() + 1][player.getPosY()].setCollidable(false);
                invalidate();
                return true;
            }
        } else if (num == 3) {
            if (cellChecked[player.getPosX() - 1][player.getPosY()].getsPosX() != 0 && cellChecked[player.getPosX() - 1][player.getPosY()].getCollidable()) {
                cellChecked[player.getPosX() - 1][player.getPosY()].setCollidable(false);
                invalidate();
                return true;
            }
        }
        return false;
    }

    public boolean enemy_eat(int num) {
        if (num == 0) {
            if (cellChecked[enemy.getPosX()][enemy.getPosY() - 1].getsPosY() != 0 && cellChecked[enemy.getPosX()][enemy.getPosY() - 1].getCollidable()) {
                cellChecked[enemy.getPosX()][enemy.getPosY() - 1].setCollidable(false);
                invalidate();
                return true;
            }
        } else if (num == 1) {
            if (cellChecked[enemy.getPosX()][enemy.getPosY() + 1].getsPosY() != numRows - 1 && cellChecked[enemy.getPosX()][enemy.getPosY() + 1].getCollidable()) {
                cellChecked[enemy.getPosX()][enemy.getPosY() + 1].setCollidable(false);
                invalidate();
                return true;
            }
        } else if (num == 2) {
            if (cellChecked[enemy.getPosX() + 1][enemy.getPosY()].getsPosX() != numColumns - 1 && cellChecked[enemy.getPosX() + 1][enemy.getPosY()].getCollidable()) {
                cellChecked[enemy.getPosX() + 1][enemy.getPosY()].setCollidable(false);
                invalidate();
                return true;
            }
        } else if (num == 3) {
            if (cellChecked[enemy.getPosX() - 1][enemy.getPosY()].getsPosX() != 0 && cellChecked[enemy.getPosX() - 1][enemy.getPosY()].getCollidable()) {
                cellChecked[enemy.getPosX() - 1][enemy.getPosY()].setCollidable(false);
                invalidate();
                return true;
            }
        }
        return false;
    }

    public void eatEnemy(){
        if(cellChecked[player.getPosX()][player.getPosY()] == cellChecked[enemy.getPosX()][enemy.getPosY()]){
            killEnemy(enemy);
        }
    }

    public void eatPlayer(){
        if(cellChecked[enemy.getPosX()][enemy.getPosY()] == cellChecked[player.getPosX()][player.getPosY()]){
            killPlayer(player);
        }
    }

    public void killEnemy(Enemy enemy){
        Toast.makeText(getContext(), "enemy ded lol", Toast.LENGTH_SHORT).show();
        cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(false);
        enemy_ball.setAlpha(0);
        enemy.setPosX(0);
        enemy.setPosY(0);
        enemyDead = true;
        invalidate();
    }

    public void killPlayer(Player player){
        Toast.makeText(getContext(), "player ded lol", Toast.LENGTH_SHORT).show();
        cellChecked[player.getPosX()][player.getPosY()].setHasPlayer(false);
        player_ball.setAlpha(0);
        player.setPosX(0);
        player.setPosY(0);
        playerDead = true;
        invalidate();
    }

    public void revivePlayer(Player player){
        Toast.makeText(getContext(), "player alive now", Toast.LENGTH_SHORT).show();
        player_ball.setAlpha(255);
        playerDead = false;
    }

    public void reviveEnemy(Enemy enemy){
        Toast.makeText(getContext(), "enemy alive now", Toast.LENGTH_SHORT).show();
        enemy_ball.setAlpha(255);
        enemyDead = false;
    }

    /*public void enemyMove(){
        int random = new Random().nextInt(4);
        //Toast.makeText(getContext(), random+"", Toast.LENGTH_SHORT).show();
        switch (random){
            case 0://up
                cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(false);
                while (!cellChecked[enemy.getPosX()][enemy.getPosY() - 1].getCollidable()) {
                    enemy.setPosY(enemy.getPosY() - 1);
                    invalidate();
                }
                cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(true);
                break;
            case 1: //down
                cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(false);
                while (!cellChecked[enemy.getPosX()][enemy.getPosY() + 1].getCollidable()) {
                    enemy.setPosY(enemy.getPosY() + 1);
                    invalidate();
                }
                cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(true);
                break;
            case 2: //right
                cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(false);
                while (!cellChecked[enemy.getPosX() + 1][enemy.getPosY()].getCollidable()) {
                    enemy.setPosY(enemy.getPosX() + 1);
                    invalidate();
                }
                cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(true);
                break;
            case 3: //left
                cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(false);
                while (!cellChecked[enemy.getPosX() - 1][enemy.getPosY()].getCollidable()) {
                    enemy.setPosY(enemy.getPosX() - 1);
                    invalidate();
                }
                cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(true);
                break;
            default:
                break;
            }
        }*/

    /*public void enemyMove(){
        int random = new Random().nextInt(4);
        //Toast.makeText(getContext(), random+"", Toast.LENGTH_SHORT).show();
        if(random == 0){ //up
            //Toast.makeText(getContext(), "up", Toast.LENGTH_SHORT).show();
            cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(false);
            while (!cellChecked[enemy.getPosX()][enemy.getPosY() - 1].getCollidable()) {
                enemy.setPosY(enemy.getPosY() - 1);
                invalidate();
            }
            cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(true);
        }
        else if(random == 1){ //down
            //Toast.makeText(getContext(), "down", Toast.LENGTH_SHORT).show();
            cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(false);
            while (!cellChecked[enemy.getPosX()][enemy.getPosY() + 1].getCollidable()) {
                enemy.setPosY(enemy.getPosY() + 1);
                invalidate();
            }
            cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(true);
        }
        else if(random == 2){ //right
            //Toast.makeText(getContext(), "right", Toast.LENGTH_SHORT).show();
            cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(false);
            while (!cellChecked[enemy.getPosX() + 1][enemy.getPosY()].getCollidable()) {
                enemy.setPosY(enemy.getPosX() + 1);
                invalidate();
            }
            cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(true);
        }
        else if(random == 3){ //left
            //Toast.makeText(getContext(), "left", Toast.LENGTH_SHORT).show();
            cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(false);
            while (!cellChecked[enemy.getPosX() - 1][enemy.getPosY()].getCollidable()) {
                enemy.setPosY(enemy.getPosX() - 1);
                invalidate();
            }
            cellChecked[enemy.getPosX()][enemy.getPosY()].setHasEnemy(true);
        }
        else{Toast.makeText(getContext(), "how", Toast.LENGTH_SHORT).show();}
    }*/
}