StarfallRitual.java

/*
* Authors: Jerry Li & Victor Jiang
* Date: June 13, 2025
* Description: This class handles the Starfall Ritual skill visuals and damage
*/

import java.awt.*;
import java.util.List;
import java.util.Random;
import java.util.concurrent.CopyOnWriteArrayList;
public class StarfallRitual extends Skill {
    // Colours
    public static final Color STAR_CORE_COLOR = new Color(255, 255, 200, 255);
    public static final Color STAR_GLOW_COLOR = new Color(200, 200, 255, 180);
    public static final Color IMPACT_COLOR = new Color(230, 240, 255, 220);

    // Timer for firing spacing
    public float fireTimer = 0;

    // Random number gen for effects
    public final Random rng = new Random();

    // Projectiles fired per attack
    public int projectileCount = 4;
    public CosmicCataclysm cosmicCataclysm;

    public final List<StarProjectile> projectiles = new CopyOnWriteArrayList<>();
    public final List<ImpactEffect> impactEffects = new CopyOnWriteArrayList<>();
    // Pool of reusable projectiles to avoid frequent allocations
    public final List<StarProjectile> projectilePool = new CopyOnWriteArrayList<>();

    // Skill properties
    public int damage;
    public float cooldown;
    public float radius;
    public float speed;
    public int level = 0;

    // Constructor
    public StarfallRitual(Player owner) {
        super("starfall_ritual", owner);
    }

    // Skill upgrade to next level
    public void levelUp() {
        level++;
        SkillLevel data = levels.get(level - 1);
        this.damage = data.getDamage();
        this.cooldown = data.getCooldown() / 1000.0f;
        this.projectileCount = data.getCount();
        this.radius = 8;
        this.speed = 3;
        if (level >= 4) {
            if (cosmicCataclysm == null) {
                cosmicCataclysm = new CosmicCataclysm(owner.parent, damage);
            }
            cosmicCataclysm.setDamage(damage);
        }
    }

    // Continuously called to update skill
    @Override
    public void update(float dt, List<Enemy> enemies) {

        if (level == 0) {
            return;
        }

        fireTimer += dt;

        if (fireTimer >= cooldown) {
            fireProjectiles();
            fireTimer = 0;
        }

        if (level >= 4 && cosmicCataclysm != null) {
            cosmicCataclysm.update(dt);
        }

        updateProjectiles(dt, enemies);

        updateEffects(dt);
        cleanupEffects();
    }

    // Projectiles fired in circular spread
    public void fireProjectiles() {
        int i = 0;
        double angle = 0.0;
        float offsetX = 0f;
        float offsetY = 0f;
        StarProjectile p = null;

        for (i = 0; i < projectileCount; i++) {
            angle = 2 * Math.PI * i / projectileCount;

            offsetX = (float) (Math.cos(angle) * 30);
            offsetY = (float) (Math.sin(angle) * 30);

            p = obtainProjectile(
                    (float) (owner.getCenterX() + offsetX),
                    (float) (owner.getCenterY() + offsetY),
                    angle);
            projectiles.add(p);
        }
    }

    /**
     * Obtains a projectile from the pool or creates a new one.
     */
    public StarProjectile obtainProjectile(float x, float y, double angle) {
        if (!projectilePool.isEmpty()) {
            StarProjectile p = projectilePool.remove(projectilePool.size() - 1);
            p.reset(x, y, angle, speed);
            return p;
        }
        return new StarProjectile(x, y, angle, speed);
    }

    public void updateProjectiles(float dt, List<Enemy> enemies) {
        List<StarProjectile> toRemove = new java.util.ArrayList<>();
        int projIndex = 0;
        StarProjectile projectile = null;

        for (projIndex = 0; projIndex < projectiles.size(); projIndex++) {
            projectile = projectiles.get(projIndex);
            projectile.update(dt);

            boolean remove = checkCollisions(projectile, enemies);
            if (!remove && isOutOfBounds(projectile)) {
                remove = true;
            }

            if (remove) {
                toRemove.add(projectile);
            }
        }
        
        for (projIndex = 0; projIndex < toRemove.size(); projIndex++) {
            projectile = toRemove.get(projIndex);
            projectiles.remove(projectile);
            projectilePool.add(projectile);
        }
    }

    // Check if projectile has left screen
    public boolean isOutOfBounds(StarProjectile projectile) {
        return projectile.x < -radius ||
                projectile.x > GamePanel.GAME_WIDTH + radius ||
                projectile.y < -radius ||
                projectile.y > GamePanel.GAME_HEIGHT + radius;
    }

    public boolean checkCollisions(StarProjectile projectile, List<Enemy> enemies) {
        int enemyIndex = 0;
        Enemy enemy = null;
        for (enemyIndex = 0; enemyIndex < enemies.size(); enemyIndex++) {
            enemy = enemies.get(enemyIndex);

            if (enemy.isDead() || enemy.isIntangible())
                continue;

            float distX = (float) (projectile.x - enemy.getCenterX());
            float distY = (float) (projectile.y - enemy.getCenterY());
            float distance = (float) Math.sqrt(distX * distX + distY * distY);

            if (distance < radius + enemy.getWidth() / 2) {

                enemy.takeDamage(damage);

                createImpactEffect(projectile.x, projectile.y);

                float knockbackStrength = 3.0f;
                float knockbackX = distX / distance * knockbackStrength;
                float knockbackY = distY / distance * knockbackStrength;
                enemy.applyKnockback(knockbackX, knockbackY);
                return true;
            }
        }
        return false;
    }

    // Sparkle effect when projectiles hit
    public void createImpactEffect(float x, float y) {
        impactEffects.add(new ImpactEffect(x, y));
    }

    // Update sparkle and impact effects
    public void updateEffects(float dt) {

        int impactIndex = 0;
        ImpactEffect impact = null;
        for (impactIndex = 0; impactIndex < impactEffects.size(); impactIndex++) {
            impact = impactEffects.get(impactIndex);
            impact.update(dt);
        }
    }

    // Remove effects
    public void cleanupEffects() {
        impactEffects.removeIf(impact -> impact.isDone());
    }

    // Drawing visuals
    @Override
    public void draw(Graphics2D g2d) {
        int projIndex = 0;
        StarProjectile projectile = null;
        int impactIndex = 0;
        ImpactEffect impact = null;
        for (projIndex = 0; projIndex < projectiles.size(); projIndex++) {
            projectile = projectiles.get(projIndex);
            projectile.draw(g2d);
        }

        for (impactIndex = 0; impactIndex < impactEffects.size(); impactIndex++) {
            impact = impactEffects.get(impactIndex);
            impact.draw(g2d);
        }

        if (level >= 4 && cosmicCataclysm != null) {
            cosmicCataclysm.draw(g2d);
        }
    }

    // Represents each star projectile
    public class StarProjectile {
        float x, y;
        float velocityX, velocityY;

        // Constructor
        public StarProjectile(float x, float y, double angle, float speed) {
            this.x = x;
            this.y = y;
            this.velocityX = (float) (Math.cos(angle) * speed);
            this.velocityY = (float) (Math.sin(angle) * speed);
        }

        public void reset(float x, float y, double angle, float speed) {
            this.x = x;
            this.y = y;
            this.velocityX = (float) (Math.cos(angle) * speed);
            this.velocityY = (float) (Math.sin(angle) * speed);
        }

        public void update(float dt) {

            x += velocityX * dt * 60;
            y += velocityY * dt * 60;
        }

        // Draw
        public void draw(Graphics2D g2d) {

            int size = (int) (radius * 2);

            // Glow
            g2d.setColor(STAR_GLOW_COLOR);
            g2d.fillOval((int) (x - radius * 1.5), (int) (y - radius * 1.5),
                    (int) (size * 1.5), (int) (size * 1.5));

            // Core
            g2d.setColor(STAR_CORE_COLOR);
            g2d.fillOval((int) (x - radius), (int) (y - radius), size, size);

            // White centre
            g2d.setColor(Color.WHITE);
            int centerSize = (int) (radius * 0.6);
            g2d.fillOval((int) (x - centerSize / 2), (int) (y - centerSize / 2), centerSize, centerSize);

            // Sparkle
            drawSparkle(g2d, x, y, size);
        }

        // Draw sparkles
        public void drawSparkle(Graphics2D g2d, float x, float y, int size) {

            Composite originalComposite = g2d.getComposite();

            g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.7f));

            g2d.setColor(Color.WHITE);
            int sparkleSize = size;

            g2d.drawLine((int) (x - sparkleSize), (int) y, (int) (x + sparkleSize), (int) y);

            g2d.drawLine((int) x, (int) (y - sparkleSize), (int) x, (int) (y + sparkleSize));

            int diagSize = sparkleSize / 2;
            g2d.drawLine((int) (x - diagSize), (int) (y - diagSize), (int) (x + diagSize), (int) (y + diagSize));
            g2d.drawLine((int) (x - diagSize), (int) (y + diagSize), (int) (x + diagSize), (int) (y - diagSize));

            g2d.setComposite(originalComposite);
        }
    }

    // Represents each small explosion impact
    public class ImpactEffect {
        float x, y;
        int frame = 0;
        static final int TOTAL_FRAMES = 8;
        float size = radius * 3;

        // Constructor
        public ImpactEffect(float x, float y) {
            this.x = x;
            this.y = y;
        }

        // Update frame
        public void update(float dt) {
            frame++;
        }

        // Check if explosion complete
        public boolean isDone() {
            return frame >= TOTAL_FRAMES;
        }

        // Draw visuals
        public void draw(Graphics2D g2d) {
            Composite originalComposite = null;
            float alpha = 0f;
            float currentSize = 0f;
            int i = 0;
            double angle = 0.0;
            float particleX = 0f;
            float particleY = 0f;
            float particleSize = 0f;

            originalComposite = g2d.getComposite();

            alpha = 1.0f - (float) frame / TOTAL_FRAMES;
            g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));

            currentSize = size * (1.0f + frame * 0.3f);
            g2d.setColor(IMPACT_COLOR);
            g2d.setStroke(new BasicStroke(3f * (1.0f - alpha)));
            g2d.drawOval(
                    (int) (x - currentSize / 2),
                    (int) (y - currentSize / 2),
                    (int) currentSize,
                    (int) currentSize);

            if (frame < TOTAL_FRAMES / 2) {
                for (i = 0; i < 4; i++) {
                    angle = i * Math.PI / 2 + frame * 0.2;
                    particleX = x + (float) (Math.cos(angle) * currentSize * 0.5f);
                    particleY = y + (float) (Math.sin(angle) * currentSize * 0.5f);
                    particleSize = 5f * (1.0f - alpha);

                    g2d.setColor(Color.WHITE);
                    g2d.fillOval(
                            (int) (particleX - particleSize / 2),
                            (int) (particleY - particleSize / 2),
                            (int) particleSize,
                            (int) particleSize);
                }
            }

            g2d.setComposite(originalComposite);
        }
    }
}