Enemy.java

import greenfoot.*;
import java.util.List;

/**
 * Kelas dasar untuk semua musuh (Enemy).
 * Musuh akan mengejar Player.
 * Musuh juga tidak bisa menembus tembok (Wall01–Wall09).
 */
public class Enemy extends Actor {
    protected int baseHealth = 200; 
    protected int baseSpeed = 2;   
    
    protected int health;
    protected int damage = 15;
    protected int speed;
    private Actor target;

    public Enemy() {
        adjustStatsByLevel();
    }

    private void adjustStatsByLevel() {
        int currentLevel = 1;
        
        World world = getWorld();
        if (world != null) {
            if (world instanceof Level3) {
                currentLevel = 3;
            } else if (world instanceof Level2) {
                currentLevel = 2;
            } else if (world instanceof Level1) {
                currentLevel = 1;
            }
        }
        
    }
    
    @Override
    protected void addedToWorld(World world) {
        adjustStatsByLevelAtRuntime(world);
    }
    
    private void adjustStatsByLevelAtRuntime(World world) {
        int levelMultiplier = 1; 
        double speedMultiplier = 1.0;

        if (world instanceof Level3) {
            levelMultiplier = 3;
            speedMultiplier = 1.5; 
        } else if (world instanceof Level2) {
            levelMultiplier = 2;
            speedMultiplier = 1.25; 
        }
        
        this.health = baseHealth + ((levelMultiplier - 1) * (baseHealth / 2));
        this.speed = (int) Math.round(baseSpeed * speedMultiplier);
        if (this.speed == 0) this.speed = 1; 
    }

    public void act() {
        if (getWorld() == null) return;
        chaseTarget();
        checkWallCollision();
        checkHitTarget();
    }
    
   
    private boolean willHitWall(int x, int y) {
    for (Class<? extends Actor> wallClass : new Class[]{Wall01.class, Wall02.class, Wall03.class,
                                                 Wall04.class, Wall05.class, Wall06.class,
                                                 Wall07.class, Wall08.class, Wall09.class}) {
        List<? extends Actor> walls = getWorld().getObjects(wallClass);
        for (Actor wall : walls) {
            if (wall != null) {
                int dx = x - wall.getX();
                int dy = y - wall.getY();
                double distance = Math.hypot(dx, dy);
                if (distance < (getImage().getWidth() + wall.getImage().getWidth()) / 2) {
                    return true;
                }
            }
        }
    }
    return false;
    }

    protected void chaseTarget() {
        World world = getWorld();
        if (world == null) return;

        Player player = (Player) findNearestTarget(Player.class);

        if (player != null && !player.isDead()) {
            target = player;
        } else {
            target = null;
        }

        if (target != null) {
            turnTowards(target.getX(), target.getY());

            int nextX = getX() + (int)(Math.cos(Math.toRadians(getRotation())) * speed);
            int nextY = getY() + (int)(Math.sin(Math.toRadians(getRotation())) * speed);

            if (!willHitWall(nextX, nextY)) {
                move(speed);
            }
        }
    }

    protected void checkWallCollision() {
        if (isTouching(Wall01.class) || isTouching(Wall02.class) || isTouching(Wall03.class) ||
            isTouching(Wall04.class) || isTouching(Wall05.class) || isTouching(Wall06.class) ||
            isTouching(Wall07.class) || isTouching(Wall08.class) || isTouching(Wall09.class)) {
            move(-speed);
        }
    }

    protected Actor findNearestTarget(Class<? extends Actor> cls) {
        if (getWorld() == null) return null;

        List<? extends Actor> objects = getWorld().getObjects(cls);
        if (objects.isEmpty()) return null;

        Actor nearest = null;
        double nearestDistance = Double.MAX_VALUE;

        for (Actor obj : objects) {
            double distance = Math.hypot(getX() - obj.getX(), getY() - obj.getY());
            if (distance < nearestDistance) {
                nearest = obj;
                nearestDistance = distance;
            }
        }
        return nearest;
    }

    protected void checkHitTarget() {
        if (target instanceof Player) {
            Player p = (Player) getOneIntersectingObject(Player.class);
            if (p != null && !p.isDead()) {
                p.takeDamage(damage); 
            }
        }
    }

    public void takeDamage(int amount) {
        health -= amount;
        if (health <= 0) {
            die();
        }
    }

    public void die() {
        World world = getWorld();
        if (world != null) {
            world.removeObject(this);
        }
    }

    public boolean isDead() {
        return health <= 0;
    }

    public int getHealth() {
        return health;
    }
}