Canvas.java

package genericzombieshooter;

import genericzombieshooter.actors.Player;
import genericzombieshooter.structures.Particle;
import genericzombieshooter.structures.Vector2D;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import javax.imageio.ImageIO;
import javax.swing.JPanel;

/**
 *
 * @author packetpirate
 */
public class Canvas extends JPanel implements Runnable {
    // Static variables.
    private static final int pWIDTH = 800; // The width of the panel.
    private static final int pHEIGHT = 640; // The height of the panel.
    private static final int SLEEP_TIME = 20; // The length of each tick in the animation thread.
    // Member variables.
    private Thread animation;
    private volatile boolean running;

    private boolean [] keys;
    private boolean [] buttons;
    private Point mousePos;

    private Player player;

    private ArrayList<Particle> projectiles;
    // Image variables.
    private BufferedImage background;

    public Canvas() {
        // Set the appearance of the canvas.
        setBackground(Color.WHITE);
        setPreferredSize(new Dimension(pWIDTH, pHEIGHT));
        setFocusable(true);
        requestFocus();

        // Initialize member variables.
        keys = new boolean[4];
        for(boolean b : keys) b = false;
        buttons = new boolean[2];
        for(boolean b : buttons) b = false;
        mousePos = new Point(0,0);
        player = new Player(((pWIDTH / 2) - 20), ((pHEIGHT / 2) - 20), 40, 40);

        projectiles = new ArrayList<>();

        // Load images.
        try {
            background = ImageIO.read(new File("images/GZS_Background.PNG"));
        } catch(IOException io) {
        }

        // Add key and mouse adapters.
        addKeyListener(new KeyAdapter() {
            @Override
            public void keyPressed(KeyEvent k) {
                int keyCode = k.getKeyCode();
                if(keyCode == KeyEvent.VK_W) keys[0] = true;
                if(keyCode == KeyEvent.VK_D) keys[1] = true;
                if(keyCode == KeyEvent.VK_S) keys[2] = true;
                if(keyCode == KeyEvent.VK_A) keys[3] = true;
            }

            @Override
            public void keyReleased(KeyEvent k) {
                int keyCode = k.getKeyCode();
                if(keyCode == KeyEvent.VK_W) keys[0] = false;
                if(keyCode == KeyEvent.VK_D) keys[1] = false;
                if(keyCode == KeyEvent.VK_S) keys[2] = false;
                if(keyCode == KeyEvent.VK_A) keys[3] = false;
            }
        });

        addMouseListener(new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent m) {
                if(m.getButton() == MouseEvent.BUTTON1) buttons[0] = true;
                if(m.getButton() == MouseEvent.BUTTON3) buttons[1] = true;
            }

            @Override
            public void mouseReleased(MouseEvent m) {
                if(m.getButton() == MouseEvent.BUTTON1) buttons[0] = false;
                if(m.getButton() == MouseEvent.BUTTON3) buttons[1] = false;
            }
        });

        addMouseMotionListener(new MouseAdapter() {
            @Override
            public void mouseMoved(MouseEvent m) {
                mousePos.x = m.getX();
                mousePos.y = m.getY();
            }

            @Override
            public void mouseDragged(MouseEvent m) {
                mousePos.x = m.getX();
                mousePos.y = m.getY();
            }
        });
    }

    @Override
    public void addNotify() {
        super.addNotify();
        start();
    }

    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D)g;

        AffineTransform save = g2d.getTransform();

        g2d.drawImage(background, 0, 0, null);

        for(Particle p : projectiles) {
            g2d.setTransform(p.getTransform());
            g2d.drawImage(p.getImage(), (int)p.x, (int)p.y, null);
        }

        g2d.setPaint(Color.RED);
        g2d.setTransform(player.getTransform());
        g2d.drawImage(player.getImage(), (int)player.x, (int)player.y, null);

        g2d.setTransform(save);

        // Draw text showing the player's current coordinates.
        g2d.setPaint(Color.WHITE);
        g2d.drawString(("Player Position - X: " + player.getCenterX() + " Y: " + player.getCenterY()), 5, 15);
        g2d.drawString(("Health: " + player.getHealth()), 5, 30);
        g2d.drawString(("Weapon CD: " + player.getCooldown()), 5, 45);

        // Draw crosshair. Used to visualize whether something is centered or not.
        //g2d.setPaint(Color.BLACK);
        //g2d.drawLine(0, (pHEIGHT / 2), pWIDTH, (pHEIGHT / 2));
        //g2d.drawLine((pWIDTH / 2), 0, (pWIDTH / 2), pHEIGHT);
    }

    public void update() {
        double centerX = player.getCenterX();
        double centerY = player.getCenterY();
        double angle = Math.atan2(centerY - mousePos.y, centerX - mousePos.x) - Math.PI / 2;
        player.rotate(angle);

        if(keys[0]) player.move(0);
        if(keys[1]) player.move(1);
        if(keys[2]) player.move(2);
        if(keys[3]) player.move(3);

        if(buttons[0]) {
            if(!player.isOnCooldown()) createParticle(angle);
            else player.decCooldown();
        } else player.decCooldown();

        // Handle the bullets. Update their positions. If any have reached their targets, delete them.
        if(!projectiles.isEmpty()) {
            for(int i = 0;i < projectiles.size();i++) {
                Particle p = projectiles.get(i);
                if((p.getCenterX() == p.getTarget().x)&&(p.getCenterY() == p.getTarget().y)) {
                    projectiles.remove(i);
                } else if((p.getCenterX() < 0)||(p.getCenterX() > pWIDTH)||(p.getCenterY() < 0)||(p.getCenterY() > pHEIGHT)) {
                    projectiles.remove(i);
                } else {
                    Vector2D v_ = new Vector2D((p.getTarget().x - p.getCenterX()), (p.getTarget().y - p.getCenterY()));
                    Vector2D n_ = v_.normalize();
                    if(n_ != null) {
                        p.x += n_.x * 10;
                        p.y += n_.y * 10;
                    } else {
                        projectiles.remove(i);
                    }
                }
            }
        }
    }

    private void createParticle(double angle_) {
        double x_ = player.x + 28;
        double y_ = player.y - 8;
        double w_ = 2;
        double h_ = 10;
        Point target_ = new Point(mousePos.x, mousePos.y);
        String fileName_ = "images/GZS_Bullet.png";
        Particle p = new Particle(x_, y_, w_, h_, target_, fileName_);
        p.rotate(angle_, player.getCenterX(), player.getCenterY());
        projectiles.add(p);
    }

    private void start() {
        if((animation == null)||(!running)) {
            animation = new Thread(this);
            animation.start();
        }
    }

    @Override
    public void run() {
        running = true;
        while(running) {
            update();
            repaint();

            try {
                Thread.sleep(SLEEP_TIME);
            } catch(InterruptedException ex) {}
        }
        System.exit(0);
    }

    public void stop() {
        running = false;
    }
}