[XP Script] KExtra XP WAS - Printable Version

Code:
# * KExtra XP WAS Version

#   Scripter : Kyonides-Arkanthos

#   2018-01-12



#  Primer Paso del Llamado a Script - Obtener al Héroe del Equipo...

#    a = $game_party.actors[Indice_Actor]

#  O a un Héroe que no forma parte del grupo

#    a = $game_actors[ID_Actor]



#  Y justo debajo de esa línea agreguen alguna de las siguientes.



#  Para devolver algo del poder a una técnica embrujada

#    a.increase_skill_power(ID_Tecnica)



#  Para desbloquear por completo una técnica embrujada (con éxito del 100%)

#    a.unblock_skill(ID_Tecnica)



#  Para aumentar el número de usos de una técnica embrujada

#    a.add_skill_uses(ID_Tecnica) # usando un objeto

#    a.add_skill_uses(ID_Tecnica, Usos_Extras) # sin objeto



#  Para remover el embrujo al consumir un objeto preseleccionado, no fallará.

#    a.lift_skill_curse(ID_Tecnica)



#  Para dejar que un clérigo o evento remueva el embrujo de la técnica

#    a.priest_lift_skill_curse(Nivel_Clerigo, ID_Tecnica)



#  Para remover el embrujo por la fuerza (con éxito del 100%)

#    a.force_lift_curse(ID_Tecnica)



#  Para verificar si una técnica está embrujada (1 de 2 opciones)

#  ¡Necesitará incluir los datos del miembro o héroe!

#    $game_party.actors[Indice_Actor].skill_cursed?(ID_Tecnica)

#    $game_actors[ID_Actor].skill_cursed?(ID_Tecnica)



#  Para devolver algo del poder a una arma embrujada

#    a.increase_weapon_power(ID_Arma)

#    a.increase_armor_resist(ID_Armadura)



#  Para dejar que un herrero o evento reforje el arma o la armadura rota

#    a.reforge_weapon(Nivel_Herrero, ID_Arma)

#    a.reforge_armor(Nivel_Herrero, ID_Armadura)



#  Para dejar que un "clérigo" remueva el embrujo del arma o de la armadura

#    a.lift_weapon_curse(Persona, Nivel, ID_Arma)

#    a.lift_armor_curse(Persona, Nivel, ID_Armadura)



#  Abreviaturas o Siglas

#    Persona - Puede ser :clerigo o :herrero o :tecnico

#    RP - Reducción de Poder, IP - Incremento de Poder, CF - Costo de Forja

#    NE - Nivel del Embrujo, PF - Prob. de Fracasar en Forja

#    CRE - Costo de Remoción del Empbrujo

#    ID_Obj - objeto removedor de embrujo, 0 para ninguno

module KExtra

  DEFAULT_USES = 5 # Valor Típico de Usos que se sumarán a la t. embrujada

  SKILL_USES_ITEM_ID = 28 # ID del Objeto que incrementa los Usos

  SEAL_SKILL_ID = 81 # Técnica de algún Enemigo

  BREAK_WEAPONS = {}

  BREAK_ARMORS = {}

  # [ID_Arma] = [Usos, ¿Rota?, ¿Embrujada?, NE, PF, PR, PI, ID_Obj, CF, CRE]

  BREAK_WEAPONS[1] = [3, nil, nil, 1, 5, 90, 15, 34, 250, 300]

  BREAK_WEAPONS[2] = [2, nil, nil, 2, 10, 90, 10, 34, 500, 600]

  BREAK_WEAPONS[3] = [1, nil, true, 2, 15, 95, 5, 34, 750, 900]

  # [ID_Armadura] = [Usos, ¿Rota?, ¿Embrujada?, NE, PF, PR, PI, ID_Obj, CF, CRE]

  BREAK_ARMORS[1] = [2, nil, nil, 1, 5, 90, 15, 34, 350, 400]

  # Agregue ID_Actor => {}, incluye la coma excepto en el último valor

  # Le permite agregar limitaciones a las técnicas de un héroe específico

  ACTOR_HANDICAPS = { 1 => {} }

  # [ID_Actor][ID_Tecnica] = [Usos, ¿Bloqueada?, Nivel_Embrujo, RP, IP, ID_Obj]

  ACTOR_HANDICAPS[1][57] = [3, nil, 1, 90, 10, 0]

  SKILL_HANDICAPS = {}

  # [ID_Tecnica] = [Usos, ¿Bloqueada?, Nivel_Embrujo, RP, IP, ID_Obj]

  SKILL_HANDICAPS[57] = [2, nil, 1, 70, 10, 0]

  # [Usos, ¿Bloqueada?, Nivel_Embrujo, RP, IP, ID_Obj]

  SEALED_SKILL_HANDICAP = [0, true, 2, 95, 5, 33]

  class ItemBase

    attr_accessor :kind, :uses, :level, :power_reduction, :power_increase

    attr_accessor :remover_item_id

    def initialize

      @uses = DEFAULT_USES

      @level = 1

      @power_reduction = 0

      @power_increase = 0

      @remover_item_id = 0

    end

  end



  class Equipment < ItemBase

    attr_accessor :broken, :cursed, :failure_rate, :cost

    def initialize

      super

      @broken = @cursed = nil

      @failure_rate = 0

      @cost = {}

    end

  end



  class Skill < ItemBase

    attr_accessor :blocked

    def initialize

      super

      @kind = :skill

      @blocked = nil

    end

  end

end



class Game_Battler

  alias kyon_kextra_was_gm_battler_attack_effect attack_effect

  alias kyon_kextra_was_gm_battler_skill_effect skill_effect

  def attack_effect(attacker)

    foe = attacker

    effective = kyon_kextra_was_gm_battler_attack_effect(foe)

    if effective

      if foe.respond_to?(:weapon_id) and foe.weapon_id > 0

        return effective unless breakable = foe.break_weapons[foe.weapon_id]

        breakable.uses -= 1 if breakable.uses > 0

        if breakable.uses == 0

          breakable.broken = true

          foe.equip(0, 0)

        end

      end

      if self.respond_to?(:armor1_id)

        ids = [@armor1_id, @armor2_id, @armor3_id, @armor4_id]

        ids.each do |aid| next if aid == 0

          next unless (breakable = @break_armors[aid])

          breakable.uses -= 1 if breakable.uses > 0

          next if breakable.uses > 0

          breakable.broken = true

          equip(ids.index(aid), 0)

        end

      end

    end

    return effective

  end



  def skill_effect(user, skill)

    sid = skill.id

    if user.respond_to?(:troop_id) and sid == KExtra::SEAL_SKILL_ID and

      self.respond_to?(:skill_handicaps)

      if @skills.size > 0

        cursed = self.skill_cursed?(sid)

        @skill_hit = @skills[rand(@skills.size)] if !@skill_hit

        self.add_skill_handicaps(@skill_hit, KExtra::SEALED_SKILL_HANDICAP)

        return (!cursed and self.skill_cursed?(sid))

      end

      return false

    elsif user.respond_to?(:skill_handicaps) and user.skill_handicaps[sid]

      sh = user.skill_handicaps[sid]

      sh.uses -= 1

      skill = $data_skills[sid].dup

      skill.power -= skill.power * sh.power_reduction / 100

      skill.str_f -= skill.str_f * sh.power_reduction / 100

      skill.dex_f -= skill.dex_f * sh.power_reduction / 100

      skill.agi_f -= skill.agi_f * sh.power_reduction / 100

      skill.int_f -= skill.int_f * sh.power_reduction / 100

    end

    effective = kyon_kextra_was_gm_battler_skill_effect(user, skill)

    @skill_hit = sid if effective and self.respond_to?(:troop_id)

    return effective

  end

end



class Game_Actor

  attr_reader :break_weapons, :break_armors, :skill_handicaps

  alias kyon_kextra_was_gm_actor_setup setup

  alias kyon_kextra_was_gm_actor_base_atk base_atk

  alias kyon_kextra_was_gm_actor_base_pdef base_pdef

  alias kyon_kextra_was_gm_actor_base_mdef base_mdef

  alias kyon_kextra_was_gm_actor_equip equip

  alias kyon_kextra_was_gm_actor_learn_skill learn_skill

  def setup(actor_id)

    @levels = { :priest => 0, :smith => 0, :tech => 0 }

    @break_weapons = {}

    @break_armors = {}

    @skill_handicaps = {}

    kyon_kextra_was_gm_actor_setup(actor_id)

    add_break_weapon(@weapon_id)

    ids = [@armor1_id, @armor2_id, @armor3_id, @armor4_id]

    ids.each {|aid| add_break_armor(aid) }

    if (handicaps = KExtra::ACTOR_HANDICAPS[actor_id])

      handicaps.each {|sid, data| add_skill_handicaps(sid, data) }

    end

  end



  def base_atk

    old_atk = kyon_kextra_was_gm_actor_base_atk

    weapon = @break_weapons[@weapon_id]

    old_atk -= old_atk * weapon.power_reduction / 100 if weapon

    return old_atk

  end



  def base_pdef

    old_pdef = kyon_kextra_was_gm_actor_base_pdef

    armors = [@break_armors[@armor1_id], @break_armors[@armor2_id]]

    armors += [@break_armors[@armor3_id], @break_armors[@armor4_id]]

    armors.compact.each {|a| old_pdef -= old_pdef * a.power_reduction / 100 }

    return old_pdef

  end



  def base_mdef

    old_mdef = kyon_kextra_was_gm_actor_base_mdef

    armors = [@break_armors[@armor1_id], @break_armors[@armor2_id]]

    armors += [@break_armors[@armor3_id], @break_armors[@armor4_id]]

    armors.compact.each {|a| old_mdef -= old_mdef * a.power_reduction / 100 }

    return old_mdef

  end



  def equip_fix?(equip_type)

    actor = $data_actors[@actor_id]

    case equip_type

    when 0

      cursed = @break_weapons[@weapon_id].cursed rescue false

      return (actor.weapon_fix or cursed)

    when 1

      cursed = @break_armors[@armor1_id].cursed rescue false

      return (actor.armor1_fix or cursed)

    when 2

      cursed = @break_armors[@armor2_id].cursed rescue false

      return (actor.armor12_fix or cursed)

    when 3

      cursed = @break_armors[@armor3_id].cursed rescue false

      return (actor.armor3_fix or cursed)

    when 4

      cursed = @break_armors[@armor4_id].cursed rescue false

      return (actor.armor4_fix or cursed)

    else false

    end

  end



  def equip(equip_type, id)

    if equip_type == 0 and id > 0

      if (none = @break_weapons[id] == nil)

        add_break_weapon(id)

      elsif !none and @break_weapons[id].broken

        return

      end

    end

    kyon_kextra_was_gm_actor_equip(equip_type, id)

  end



  def add_break_weapon(wid)

    source = KExtra::BREAK_WEAPONS[wid]

    return if !source or @break_weapons[wid]

    @break_weapons[wid] = weapon = KExtra::Equipment.new

    weapon.kind = :weapon

    breakable_setup(weapon, source)

  end



  def add_break_armor(aid)

    source = KExtra::BREAK_ARMORS[aid]

    return if !source or @break_armors[aid]

    @break_armors[aid] = armor = KExtra::Equipment.new

    armor.kind = :armor

    breakable_setup(armor, source)

  end



  def breakable_setup(thing, source)

    thing.uses = source[0]

    thing.broken = source[1]

    thing.cursed = source[2]

    thing.level = source[3]

    thing.failure_rate = source[4]

    thing.power_reduction = source[5]

    thing.power_increase = source[6]

    thing.remover_item_id = source[7]

    thing.cost = { :broken => source[8], :cursed => source[9] }

  end



  def increase_weapon_power(weapon_id)

    return unless (weapon = @break_weapons[weapon_id])

    reduction = [weapon.power_reduction - weapon.power_increase, 0].max

    weapon.power_reduction = reduction

  end



  def increase_armor_resist(armor_id)

    return unless (armor = @break_armors[armor_id])

    reduction = [armor.power_reduction - armor.power_increase, 0].max

    armor.power_reduction = reduction

  end



  def reforge_weapon(smith_level, weapon_id)

    weapon = @break_weapons[weapon_id]

    return unless weapon and weapon.broken

    return reforge_equip(smith_level, weapon)

  end



  def reforge_armor(smith_level, armor_id)

    armor = @break_armors[armor_id]

    return unless armor and armor.broken

    return reforge_equip(smith_level, armor)

  end



  def reforge_equip(smith_level, eq)

    repair = (rand(100) > eq.failure_rate and eq.level <= smith_level)

    eq.broken = !repair

    eq.uses = KExtra::DEFAULT_USES * smith_level if repair and eq.uses == 0

    return repair

  end



  def lift_weapon_curse(caster, level, weapon_id)

    lift_equip_curse(caster, level, @break_weapons[weapon_id])

  end



  def lift_armor_curse(caster, level, armor_id)

    lift_equip_curse(caster, level, @break_armors[armor_id])

  end



  def lift_equip_curse(caster, level, thing)

    return if thing == nil

    thing.cursed = cursed = case caster

    when :priest, :clerigo then thing.level > level

    when :smith, :herrero then thing.level + 1 > level

    when :tech, :tecnico then thing.level + 2 > level

    end

    return !cursed

  end



  def add_skill_handicaps(skill_id, source)

    return if @skill_handicaps[skill_id]

    @skill_handicaps[skill_id] = skill = KExtra::Skill.new

    skill.uses = source[0]

    skill.blocked = source[1]

    skill.level = source[2]

    skill.power_reduction = source[3]

    skill.power_increase = source[4]

    skill.remover_item_id = source[5]

  end



  def increase_skill_power(skill_id)

    return unless (handicap = @skill_handicaps[skill_id])

    reduction = [handicap.power_reduction - handicap.power_increase, 0].max

    handicap.power_reduction = reduction

  end



  def add_skill_uses(skill_id, extra_uses=0)

    if extra_uses == 0

      item_id = KExtra::SKILL_USES_ITEM_ID

      return unless item_number(item_id) > 0

      $game_party.lose_item(item_id)

      extra_uses = KExtra::DEFAULT_USES

    end

    @skill_handicaps[skill_id].uses += extra_uses

  end



  def lift_skill_curse(skill_id)

    return unless (handicap = @skill_handicaps[skill_id])

    item_id = handicap.remover_item_id

    return unless item_number(item_id) > 0

    $game_party.lose_item(item_id)

    @skill_handicaps.delete(skill_id)

  end



  def priest_lift_skill_curse(priest_level, skill_id)

    return unless (skill = @skill_handicaps[skill_id])

    @skill_handicaps.delete(skill_id) if skill.level <= priest_level

  end



  def broken_weapons?() @break_weapons.select{|wid,w| w.broken }.size > 0 end

  def cursed_weapons?() @break_weapons.select{|wid,w| w.cursed }.size > 0 end

  def broken_armors?() @break_armors.select{|aid,w| w.broken }.size > 0 end

  def cursed_armors?() @break_armors.select{|aid,w| w.cursed }.size > 0 end

  def force_lift_curse(skill_id) @skill_handicaps.delete(skill_id) end

  def skill_cursed?(skill_id) @skill_handicaps[skill_id] end

  def unblock_skill(skill_id) @skill_handicaps[skill_id].blocked = nil end

  def priest_level() @levels[:priest] end

  def smith_level() @levels[:smith] end

  def tech_level() @levels[:tech] end



  def learn_skill(skill_id)

    already_learned = @skills.include?(skill_id)

    kyon_kextra_was_gm_actor_learn_skill(skill_id)

    recently_learned = @skills.include?(skill_id)

    return unless !already_learned and recently_learned

    return if @skill_handicaps[skill_id]

    return unless (skill = KExtra::SKILL_HANDICAPS[skill_id])

    add_skill_handicaps(skill_id, skill)

  end



  def skill_can_use?(skill_id)

    if (skill = @skill_handicaps[skill_id])

      return if skill.uses == 0 or skill.blocked or skill.power_reduction == 100

    end

    super

  end

end



class Game_Enemy

  attr_reader :troop_id

end



class Game_Party

  def broken_weapons?() @actors.select{|a| a.broken_weapons? }.size > 0 end

  def cursed_weapons?() @actors.select{|a| a.cursed_weapons? }.size > 0 end

  def broken_armors?() @actors.select{|a| a.broken_armors? }.size > 0 end

  def cursed_armors?() @actors.select{|a| a.cursed_armors? }.size > 0 end

end