final/src/StickyBomb.java

import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.image.BufferedImage;

public class StickyBomb extends GenericSprite{

    public static final int spriteLength = 35;

    public static final int length = 25;
    public int xVelocity;
    public int yVelocity;
    public boolean isMove;
    public int realX;
    public BufferedImage sprite ;
    public BufferedImage[] explosionSpriteArray;

    public int fuse;
    public int explosionPixel = 0;
    public int explosionCounter = 0;

    public boolean alive;

    public boolean erase;



    public StickyBomb(int x, int y,  int xVelocity, int yVelocity, BufferedImage sprite, BufferedImage[] explosionSpriteArray){
        super(x,y,length,length);
        this.xVelocity = xVelocity;
        this.yVelocity = yVelocity;
        this.sprite = sprite;
        this.explosionSpriteArray = explosionSpriteArray;
        fuse = GlobalState.second*5;
        isMove = true;
        alive = true;
        erase = false;
    }



    public void update(){
        realX = x - GamePanel.camera.x;
    }

    public void explode(){
        double yDis = GamePanel.player.y+Player.PLAYER_HEIGHT/2-(y+(double)length/2);
        double xDis = GamePanel.player.x+Player.PLAYER_WIDTH/2-(realX+(double)length/2);
        double hypo = Math.sqrt(yDis*yDis+xDis*xDis);
        if(hypo<300) {
            if (yDis != 0) {
                GamePanel.player.yVelocity += 10 * (yDis) / (hypo);
            }
            if (xDis != 0) {
                GamePanel.player.xVelocity += 10 * (xDis) / (hypo);
            }
        }
        GamePanel.player.capSpeed();
    alive = false;
    for(int i=0; i<GamePanel.enemy.size(); i++){
        double disX = GamePanel.enemy.get(i).x+GamePanel.enemy.get(i).npcWidth/2 - (x+length/2);
        double disY = GamePanel.enemy.get(i).y+GamePanel.enemy.get(i).npcHeight/2 - (y+length/2);
        double eHypo = Math.sqrt(disX*disX+disY*disY);
        if(eHypo<200){
            GamePanel.enemy.get(i).isDead = true;
        }
        if(GamePanel.enemy.get(i).isDead){
            GamePanel.enemy.get(i).fadeCounter--;
            if(GamePanel.enemy.get(i).fadeCounter<=0){
                GamePanel.enemy.remove(i);
            }
        }
    }
    }

    public boolean collide(Tile tile, double x, double y){
        if(!tile.collision||tile.nonBombCollide){
            return false;
        }
        if(x+WIDTH>tile.x&&x<tile.x+Tile.length&&y-tile.y<Tile.length&&tile.y-y<HEIGHT){


            return true;
        }
        return false;
    }
    public void move(){
        boolean checked = false;
        if(yVelocity>50){yVelocity=50;}
        update();
        if(fuse>0) {
            fuse-=1;
            if(fuse == 0) {
                explode();
            }
        }
        if(isMove) {
            if(canUpdate(xVelocity, 0)&&canUpdate(0, yVelocity)&&!canUpdate(xVelocity, yVelocity)){
                checked = true;
                x += -Math.signum(xVelocity);
                isMove = false;
                int updateAmount = 0;
                if(xVelocity>0&&yVelocity>0){
                    while(canUpdate(updateAmount, updateAmount)){
                        updateAmount++;
                    }
                    x+=updateAmount;
                    y+=updateAmount;
                } else if(xVelocity<0&&yVelocity>0){
                    while(canUpdate(-updateAmount, updateAmount)){
                        updateAmount++;
                    }
                    x-=updateAmount;
                    y+=updateAmount;
                } else if(xVelocity>0&&yVelocity<0){
                    while(canUpdate(updateAmount, -updateAmount)){
                        updateAmount++;
                    }
                    x+=updateAmount;
                    y-=updateAmount;
                } else if(xVelocity<0&&yVelocity<0){
                    while(canUpdate(-updateAmount, -updateAmount)){
                        updateAmount++;
                    }
                    x-=updateAmount;
                    y-=updateAmount;
                }
                xVelocity = 0;
                yVelocity = 0;
            }
            if(!canUpdate(xVelocity, 0)){
                checked = true;
                isMove = false;
                int updateAmount = 0;
                if(xVelocity>0){
                    while(canUpdate(updateAmount, 0)){
                        updateAmount++;
                    }
                    x+=updateAmount-1;
                } else if(xVelocity<0){
                    while(canUpdate(updateAmount, 0)){
                        updateAmount--;
                    }
                    x+=updateAmount+1;
                }
                xVelocity = 0;
            }
            if(!canUpdate(0, yVelocity)){
                checked = true;
                isMove = false;
                if(yVelocity>0){
                    while(canUpdate(0,1)){
                        y+=1;
                    }
                    isGrounded = true;
                } else if(yVelocity<0){
                    while(canUpdate(0,-1)){
                        y-=1;
                    }
                }
                yVelocity = 0;
            }
            if(canUpdate(xVelocity, yVelocity)&&!checked) {
                y = y + (int) yVelocity;
                x = x + (int) xVelocity;
            } else {
                isMove = false;
            }
            yVelocity+=3;
        }

    }




    public void draw(Graphics g){
        if (explosionCounter >= 2) {
            explosionPixel += 1;
            explosionCounter -= 2;
        }
        if(alive) {
            g.drawImage(sprite, x - GamePanel.camera.x - (spriteLength-length)/2, y - (spriteLength-length)/2, spriteLength, spriteLength, null);
            //g.drawRect(x-GamePanel.camera.x,y,length,length);
        } else if (explosionPixel < explosionSpriteArray.length - 1) {
            g.drawImage(explosionSpriteArray[explosionPixel], x - GamePanel.camera.x - 10*explosionPixel,
                    y-10*explosionPixel, spriteLength+10*explosionPixel, spriteLength+10*explosionPixel, null);
            explosionCounter += 1;
        }  else {
            erase = true;
        }
    }
}