Skill System

public void castSkill(Creature caster, WorldObject target, Skill skill) {
    // Check MP
    if (caster.getCurrentMp() < skill.getMpConsume()) {
        caster.sendPacket(SystemMessageId.NOT_ENOUGH_MP);
        return;
    }
    
    // Check range
    if (!caster.isInsideRadius3D(target, skill.getCastRange())) {
        caster.sendPacket(SystemMessageId.TARGET_IS_OUT_OF_RANGE);
        return;
    }
    
    // Check reuse
    if (caster.isSkillDisabled(skill)) {
        caster.sendPacket(SystemMessageId.SKILL_NOT_AVAILABLE);
        return;
    }
    
    // Cast skill
    caster.doCast(skill);
}

// Add buff to player
public void applyBuff(Player player, Skill skill) {
    // Create buff info
    BuffInfo buffInfo = new BuffInfo(player, player, skill);
    
    // Check for existing buff of same type
    BuffInfo existing = player.getEffectList()
        .getBuffInfoByAbnormalType(skill.getAbnormalType());
    
    if (existing != null) {
        // Compare levels
        if (skill.getAbnormalLevel() > existing.getSkill().getAbnormalLevel()) {
            // Remove old buff
            existing.getEffected().getEffectList().remove(existing);
        } else {
            player.sendMessage("A better buff is already active.");
            return;
        }
    }
    
    // Apply new buff
    buffInfo.initializeEffects();
}

// Remove specific buff
public void removeBuff(Creature creature, AbnormalType type) {
    BuffInfo buff = creature.getEffectList().getBuffInfoByAbnormalType(type);
    if (buff != null) {
        creature.getEffectList().remove(buff);
    }
}

// Remove all buffs
public void removeAllBuffs(Creature creature) {
    creature.getEffectList().stopAllEffects();
}

// Learn skill
public boolean learnSkill(Player player, int skillId, int skillLevel) {
    // Get skill
    Skill skill = SkillData.getInstance().getSkill(skillId, skillLevel);
    if (skill == null) {
        return false;
    }
    
    // Check requirements
    SkillLearn learn = SkillTreeData.getInstance()
        .getSkillLearn(player.getClassId(), skillId, skillLevel);
    
    if (learn == null) {
        player.sendMessage("You cannot learn this skill.");
        return false;
    }
    
    // Check level requirement
    if (player.getLevel() < learn.getGetLevel()) {
        player.sendMessage("Level too low.");
        return false;
    }
    
    // Check SP cost
    if (player.getSp() < learn.getLevelUpSp()) {
        player.sendMessage("Not enough SP.");
        return false;
    }
    
    // Learn skill
    player.addSkill(skill, true);
    player.getStat().addSp(-learn.getLevelUpSp());
    
    return true;
}

// Damage skill
public void applyDamageSkill(Creature attacker, Creature target, Skill skill) {
    // Calculate damage
    boolean isPvP = attacker.isPlayer() && target.isPlayer();
    boolean isPvE = !isPvP;
    double power = skill.getPower(attacker, target, isPvP, isPvE);
    
    // Apply formulas
    double damage = Formulas.calcMagicDam(attacker, target, skill, power);
    
    // Apply damage
    target.reduceCurrentHp(damage, attacker, skill);
    
    // Apply effects
    skill.applyEffects(attacker, target);
}

// Heal skill
public void applyHealSkill(Creature caster, Creature target, Skill skill) {
    // Calculate heal amount
    double power = skill.getPower();
    double heal = power + (caster.getPAtk() * 0.05);
    
    // Apply heal
    double newHp = Math.min(target.getMaxHp(), 
                           target.getCurrentHp() + heal);
    target.setCurrentHp(newHp);
    
    // Visual effect
    target.broadcastPacket(new MagicSkillUse(caster, target, 
                          skill.getId(), skill.getLevel(), 0, 0));
}

// Disable skill
public void disableSkill(Player player, Skill skill) {
    int reuseDelay = skill.getReuseDelay();
    if (reuseDelay > 0) {
        player.addTimeStamp(skill, reuseDelay);
        player.disableSkill(skill, reuseDelay);
    }
}

// Check if skill is disabled
public boolean isSkillDisabled(Player player, Skill skill) {
    return player.isSkillDisabled(skill);
}

// Get remaining reuse time
public long getRemainingReuse(Player player, Skill skill) {
    TimeStamp ts = player.getSkillReuseTimeStamp(skill.getReuseHashCode());
    if (ts == null) {
        return 0;
    }
    return ts.getRemaining();
}

// Reset skill reuse
public void resetSkillReuse(Player player, Skill skill) {
    player.removeTimeStamp(skill);
    player.enableSkill(skill);
}

// Check skill conditions
public boolean checkConditions(Creature caster, WorldObject target, Skill skill) {
    // Check if skill can be used
    if (skill.getOperateType() == SkillOperateType.PASSIVE) {
        return false;
    }
    
    // Check target
    if (target == null && skill.getTargetType() == TargetType.TARGET) {
        caster.sendPacket(SystemMessageId.TARGET_CANT_FOUND);
        return false;
    }
    
    // Check HP cost
    if (caster.getCurrentHp() <= skill.getHpConsume()) {
        caster.sendPacket(SystemMessageId.NOT_ENOUGH_HP);
        return false;
    }
    
    // Check items
    if (skill.getItemConsumeId() > 0) {
        if (caster.isPlayer()) {
            Player player = caster.getActingPlayer();
            if (player.getInventory().getInventoryItemCount(
                    skill.getItemConsumeId(), -1) < skill.getItemConsumeCount()) {
                player.sendPacket(SystemMessageId.THERE_ARE_NOT_ENOUGH_NECESSARY_ITEMS_TO_USE_THE_SKILL);
                return false;
            }
        }
    }
    
    return true;
}

// Toggle skill on/off
public void toggleSkill(Player player, Skill skill) {
    if (skill.getOperateType() != SkillOperateType.TOGGLE) {
        return;
    }
    
    // Check if already active
    BuffInfo existing = player.getEffectList()
        .getBuffInfoBySkillId(skill.getId());
    
    if (existing != null) {
        // Deactivate
        existing.getEffected().getEffectList().remove(existing);
        player.sendMessage(skill.getName() + " deactivated.");
    } else {
        // Activate
        if (checkConditions(player, player, skill)) {
            skill.applyEffects(player, player);
            player.sendMessage(skill.getName() + " activated.");
        }
    }
}