final/src/Player.java

/* Eric Li, ICS4U, Completed 5/29/2022

Paddle class defines behaviours for the left and right player-controlled paddles */

import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.UnsupportedAudioFileException;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.image.BufferedImage;
import java.awt.image.ImageObserver;
import java.io.IOException;

public class Player extends GenericSprite {
  public final int SPEED = 5;
  public static final int PLAYER_WIDTH = 52;
  public static final int PLAYER_HEIGHT = 94;
  public int lastXDirection, lastYDirection, lastFrame;
  public int upKey, downKey, rightKey, leftKey;

  public static final int walkSpeedCap = 5;
  public boolean alive;
  private final Sound jump;

  public static int mouseX;
  public static int mouseY;

  public boolean leftMouseDown;

  public boolean rightMouseDown;
  boolean holdingSteel;


  // sA[0] is -x, -y
  // sA[1] is x, -y
  // sA[2] is -x, y
  // sA[3] is x, y
  public BufferedImage[][][] spriteArray;
  public Player(int x, int y, int upKey, int downKey, int leftKey, int rightKey, BufferedImage[][][] sprites) throws UnsupportedAudioFileException, LineUnavailableException, IOException {
    super(x, y, PLAYER_HEIGHT, PLAYER_WIDTH);
    jump = new Sound("sound/jump.wav");
    this.upKey = upKey;
    this.downKey = downKey;
    this.leftKey = leftKey;
    this.rightKey = rightKey;
    spriteArray = sprites;
    alive = true;
    isPlayer = true;
    leftMouseDown = false;
    holdingSteel = false;
  }



  // moves paddle when key is pressed
  public void keyPressed(KeyEvent e) {
    if(e.getKeyCode() == KeyEvent.VK_D){
      rightPressed = true;
    }
    if(e.getKeyCode() == KeyEvent.VK_A){
      leftPressed = true;
    }
    if(e.getKeyCode() == KeyEvent.VK_W){
      upPressed = true;
    }
    if(e.getKeyCode() == KeyEvent.VK_S){
      downPressed = true;
    }
  }

  // stops moving paddle when key is released
  public void keyReleased(KeyEvent e) {
    if(e.getKeyCode() == KeyEvent.VK_D){
      rightPressed = false;
    }
    if(e.getKeyCode() == KeyEvent.VK_A){
      leftPressed = false;
    }
    if(e.getKeyCode() == KeyEvent.VK_W){
      upPressed = false;
    }
    if(e.getKeyCode() == KeyEvent.VK_S){
      downPressed = false;
    }
  }

  public boolean collide(Tile tile, double x, double y){
    if(tile==null){return false;}
    if(!tile.collision){
      return false;
    }
    if(x+WIDTH>tile.realX&&x<tile.realX+Tile.length&&y-tile.y<Tile.length&&tile.y-y<HEIGHT){
      return true;
    }
    return false;
  }
  // calls parent

  public boolean canUpdate(double x, double y){
    boolean canUpdate = true;
    int lowX = Math.max(0, ((GamePanel.camera.x+GamePanel.GAME_WIDTH)/Tile.length)-4);
    int highX = Math.min(lowX + 8, GamePanel.map.length);
    int lowY = Math.max(0,(this.y/Tile.length)-6);
    int highY = Math.min(lowY + 12, GamePanel.map[0].length);
    for(int i=lowX; i<highX; i++) {
      for (int j = lowY; j < highY; j++) {
        if (GamePanel.map != null) {
          if (collide(GamePanel.map[i][j], this.x + x, this.y + y)) {
            if (GamePanel.map[i][j].isFinish) {
              LevelManager.nextLevel();
              GamePanel.player.reset();
              return true;
            }
            if (GamePanel.map[i][j].kills) {
              GamePanel.player.reset();
              return true;
            }
            canUpdate = false;
            break;
          }
        }
      }
    }
    return canUpdate;
  }
  public void move() throws IOException {
//    mouseX = MouseInfo.getPointerInfo().getLocation().x;
//    mouseY = MouseInfo.getPointerInfo().getLocation().y;
    if(canUpdate(xVelocity, 0)&&canUpdate(0, yVelocity)&&!canUpdate(xVelocity, yVelocity)){
      GamePanel.camera.x += -Math.signum(xVelocity);
    }
    if(!canUpdate(xVelocity, 0)){
      int updateAmount = 0;
      if(xVelocity>0){
        while(canUpdate(updateAmount, 0)){
          updateAmount++;
        }
        GamePanel.camera.x+=updateAmount-1;
      } else if(xVelocity<0){
        while(canUpdate(updateAmount, 0)){
          updateAmount--;
        }
        GamePanel.camera.x+=updateAmount+1;
      }
      //xVelocity = 0;
    }
     if(!canUpdate(0, yVelocity)){
      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)) {
      y = y + (int) yVelocity;
      GamePanel.camera.x = GamePanel.camera.x + (int) xVelocity;
    } else if(canUpdate(0,yVelocity)){
      y = y + (int) yVelocity;
      xVelocity*=0.75;
    } else if(canUpdate(xVelocity,0)){
      GamePanel.camera.x = GamePanel.camera.x + (int) xVelocity;

    }

    if(rightPressed){
      if(isGrounded){
       addParticle(-1);
      }
      if(xVelocity<5) {
        xVelocity += 1;
      }
    }
    if(leftPressed) {
      if(isGrounded){
        addParticle(1);
      }
      if(xVelocity>-5) {
        xVelocity -= 1;
      }
    }
    if(upPressed&isGrounded){
      y-=1;
      isGrounded = false;
      if(canUpdate(0,-8)) {
        jump.start();
      }
      yVelocity = -10;
    }
    xVelocity *= 0.93;

    if(!isGrounded) {
      yVelocity += 0.3;
      if(downPressed){
        yVelocity+=1;
      }
    }

    if(!alive){
      alive = true;
      reset();
    }
    capSpeed();
  }

  public void reset(){
    LevelManager.setLevel(LevelManager.level);
    GamePanel.camera.x = LevelManager.xSpawn;
    y = LevelManager.ySpawn;
  }

  public void mousePressed(MouseEvent e) throws SpriteException, IOException {
    mouseX = e.getX();
    mouseY = e.getY();
    if(e.getButton()==MouseEvent.BUTTON1) {
      leftMouseDown = true;
    }
    if(e.getButton()==MouseEvent.BUTTON3) {
      int x = (mouseX + GamePanel.camera.x + GamePanel.GAME_WIDTH / 2) / Tile.length;
      int y = (mouseY / Tile.length);
      if (GamePanel.map[x][y] != null) {
        if (!holdingSteel) {
          rightMouseDown = true;
          if (GamePanel.map[x][y].movable) {
            holdingSteel = true;
            GamePanel.map[x][y] = null;
          }
        } else {
          holdingSteel = false;
          MapReader.TileX = x;
          MapReader.TileY = y;
          MapReader.newTile("img/tiles/boxes/steel.png");
          GamePanel.map[x][y].movable = true;
        }
      }
    }
  }

  public void mouseDragged(MouseEvent e) {

    mouseX = e.getX();
    mouseY = e.getY();
  }
  public void mouseReleased(MouseEvent e) {
    mouseX = e.getX();
    mouseY = e.getY();
    if(e.getButton()==MouseEvent.BUTTON1) {
      leftMouseDown = false;
      if (GamePanel.bombs.size() < 3 && LevelManager.bombs>0) {
        LevelManager.bombs--;
        GamePanel.bombs.add(new StickyBomb(GamePanel.player.x + GamePanel.camera.x + WIDTH/2, GamePanel.player.y+HEIGHT/2,
                (mouseX - GamePanel.player.x) / 20, (mouseY - GamePanel.player.y) / 10, GamePanel.bomb, GamePanel.explosionArray));
      }
    }
    if(e.getButton()==MouseEvent.BUTTON3){
      rightMouseDown = false;
    }
  }
  public void addParticle(int x) throws IOException {
    if(GlobalState.randInt(1,3)==3) {
      GamePanel.particles.add(new Particle(this.x + GamePanel.camera.x + WIDTH / 2 + GlobalState.randInt(-PLAYER_WIDTH / 2, PLAYER_WIDTH / 2)
              , (int) (y + HEIGHT * 0.95), GlobalState.randInt(-2, 2) + x, GlobalState.randInt(-4, 1), GlobalState.randInt(1, 7), "img/particles/GrassParticle.png"));
    }
    }
  public int draw(Graphics g, int frame) {
    //g.drawString(mouseX+" "+mouseY, 300, 300);
    frame %= spriteArray[0][0].length;
    if(rightMouseDown){
      g.drawRect(mouseX,mouseY,35,35);
    }
    if (!upPressed && !downPressed && !leftPressed && !rightPressed) {
      g.drawImage(spriteArray[lastXDirection][lastYDirection][0], x-10, y, null);
      return 0;
    } else {
      lastXDirection = (int)(Math.signum(xVelocity) + 1) / 2;
      lastYDirection = (int)(Math.signum(yVelocity) + 1) / 2;
      lastFrame = frame;
      g.drawImage(spriteArray[lastXDirection][lastYDirection][frame], x-10, y, null);
      return 1;
    }


  }
}