CosmicCataclysm.java

/*
* Authors: Jerry Li & Victor Jiang
* Date: June 13, 2025
* Description: This class represents the super skill Cosmic Cataclysm, managing visuals and damager for meteors that
* shoot toward the players mouse
*/

import java.awt.*;
import java.awt.geom.Point2D;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ThreadLocalRandom;

public class CosmicCataclysm {
    // Time between use
    public static final float COOLDOWN = 4f;

    // # of meteors chosen per storm
    public static final int MIN_METEORS = 20;
    public static final int MAX_METEORS = 35;

    // How wide area in which meteors can land
    public static final float ZONE_HALF_SIZE = 250f;

    // Min or max speed of falling meteors
    public static final float MIN_SPEED = 720f; // px/s
    public static final float MAX_SPEED = 1200f; // px/s

    // Where meteors can deal damage
    public static final float IMPACT_RADIUS = 90f;

    // Enemy knockback
    public static final float KNOCKBACK = 7f;

    // Gives access to mouse + enemy location
    public GamePanel panel;

    // List of meteors
    public CopyOnWriteArrayList<Meteor> meteors = new CopyOnWriteArrayList<>();

    // Track next meteor
    public float cooldownTimer = 0f;

    // Check if currently showering meteors
    public boolean active = false;

    // Damage each meteor deals
    public int damage;

    // Constructor
    public CosmicCataclysm(GamePanel panel, int damage) {
        this.panel = panel;
        this.damage = damage;
    }

    // Change damage amount
    public void setDamage(int dmg) {
        this.damage = dmg;
    }

    // Continuously call to update state of meteors
    public void update(float dt) {
        int i = 0;
        Meteor m = null;

        // If ability not active, start countdown
        if (!active) {
            cooldownTimer += dt;

            // Create new meteor storm when cooldown over
            if (cooldownTimer >= COOLDOWN) {
                cooldownTimer -= COOLDOWN;
                spawnStorm();
            }
        }

        // Update meteros
        for (i = meteors.size() - 1; i >= 0; i--) {
            m = meteors.get(i);
            m.update(dt);
            if (m.finished()) {
                meteors.remove(i);
            }
        }

        // If meteors gone, end storm
        if (active && meteors.isEmpty()) {
            active = false;
        }
    }

    // Draw meteors to screen
    public void draw(Graphics2D g) {
        Meteor m = null;
        int i = 0;
        for (i = 0; i < meteors.size(); i++) {
            m = meteors.get(i);
            m.draw(g);
        }
    }

    // Create random # meteors that fall toward mouse
    public void spawnStorm() {
        Point p = null;
        float cx = 0f;
        float cy = 0f;
        int count = 0;
        int i = 0;
        float tx = 0f;
        float ty = 0f;
        float speed = 0f;

        p = panel.mousePos;
        cx = p.x;
        cy = p.y;

        // Randomize # meteors
        count = ThreadLocalRandom.current().nextInt(MIN_METEORS, MAX_METEORS + 1);

        // Random position within mouse area
        for (i = 0; i < count; i++) {
            tx = cx + ThreadLocalRandom.current().nextFloat() * ZONE_HALF_SIZE * 2 - ZONE_HALF_SIZE;
            ty = cy + ThreadLocalRandom.current().nextFloat() * ZONE_HALF_SIZE * 2 - ZONE_HALF_SIZE;

            // Random speed for falling meteors
            speed = MIN_SPEED + ThreadLocalRandom.current().nextFloat() * (MAX_SPEED - MIN_SPEED);

            // Create and add meteor to list
            meteors.add(new Meteor(tx, ty, speed));
        }
        active = true;
    }

    // Class that represents individual meteor
    public class Meteor {
        private float x, y;
        private float targetX, targetY; // Where meteor is to hit
        private float vy; //Vertical speed
        private boolean impacting = false; // is the meteor going KABOOM?
        private float impactAlpha = 1f; // Used to fade kaboom

        // Construct meteor with properties
        public Meteor(float targetX, float targetY, float speed) {
            this.targetX = targetX;
            this.targetY = targetY;
            this.x = targetX;
            this.y = -300f;
            this.vy = speed;
        }

        // Continously update meteor movement and action
        public void update(float dt) {
            if (impacting) {
                impactAlpha -= dt * 2f;
                return;
            }
            y += vy * dt;
            // When hits target y, EXPLODE!
            if (y >= targetY) {
                impact();
            }
        }

        // Handles meteor explosion
        public void impact() {
            Enemy eTemp = null;
            float dx = 0f;
            float dy = 0f;
            float distSq = 0f;
            float dist = 0f;
            int i = 0;

            impacting = true;

            // Damage all enemies in impact area
            for (i = 0; i < panel.enemies.size(); i++) {
                eTemp = panel.enemies.get(i);
                if (eTemp.isDead())
                    continue;
                dx = (float) eTemp.getCenterX() - targetX;
                dy = (float) eTemp.getCenterY() - targetY;
                distSq = dx * dx + dy * dy;

                // Check if can hit enemy
                if (distSq <= IMPACT_RADIUS * IMPACT_RADIUS) {
                    eTemp.takeDamage(damage);

                    // Knockback
                    dist = (float) Math.sqrt(distSq);
                    if (dist == 0f)
                        dist = 1f;
                    eTemp.applyKnockback(dx / dist * KNOCKBACK, dy / dist * KNOCKBACK);
                }
            }
        }

        // Check if explosion done
        public boolean finished() {
            return impacting && impactAlpha <= 0f;
        }

        // Draw meteor
        public void draw(Graphics2D g) {
            if (!impacting) {
                // Glowing line with a dot 
                g.setColor(new Color(255, 230, 200));
                g.drawLine((int) x, (int) y - 10, (int) x, (int) y + 4);
                g.fillOval((int) x - 3, (int) y - 3, 6, 6);
            } else {
                // Circular explosion and gradient
                float progress = 1f - impactAlpha;
                int r = (int) (IMPACT_RADIUS * (0.6f + progress));
                int a = (int) (impactAlpha * 255);
                RadialGradientPaint paint = new RadialGradientPaint(
                        new Point2D.Float(targetX, targetY), r,
                        new float[] {0f, 1f},
                        new Color[] { new Color(255, 240, 200, a), new Color(255, 120, 80, 0)});
                Paint old = g.getPaint();
                g.setPaint(paint);
                g.fillOval((int) (targetX - r), (int) (targetY - r), r * 2, r * 2);
                g.setPaint(old);
            }
        }
    }
}