Mundo Maker
¡Bienvenid@ a Mundo Maker!

¿Quieres aprender todo sobre el RPG Maker?



Regístrate y forma parte de Mundo Maker.

[XP] Lunatic Battle Damage Effects

Ver el tema anterior Ver el tema siguiente Ir abajo

RPG Maker XP [XP] Lunatic Battle Damage Effects

Mensaje por Wecoc el 2017-11-05, 15:01

Por defecto los métodos responsables de los efectos de ataque, magia e item en batalla son poco modificables.
Con este script se reescriben de modo que se pueda modificar cada parte sin tantos problemas.
Es una herramienta de scripter. Permite muchas mejoras al sistema que hay por defecto, pero se necesita una base de RGSS para poder aplicarlas.

ATENCIÓN: Requiere el script Data File Save. Si usáis scripts del topic Tips & Tricks de Wecoc estos deben quedar debajo de éste. Alguno puede presentar alguna incompatibilidad así que id con cuidado.

Código:

Código:
#==============================================================================
# ** [XP] Lunatic Battle Damage Effects v1.0
#------------------------------------------------------------------------------
# Por defecto los métodos responsables de los efectos de ataque, magia e item
# en batalla son poco modificables. Con este script se reescriben de modo
# que se pueda modificar cada parte sin tantos problemas.
# Es una herramienta de scripter.
#------------------------------------------------------------------------------
# Nota: Requiere el script Data File Save
# Autor: Wecoc (créditos opcionales)
#==============================================================================

class Scene_Title
  alias critical_flag_new command_new_game unless $@
  def command_new_game
    #------------------------------------------------
    # Aquí se definiran todos los valores personalizados
    # Podéis ver un ejemplo a continuación
    
    
    $data_skills[4].critical_flag = true
    
    
    #------------------------------------------------
    critical_flag_new
  end
end

#==============================================================================

for Klass in [RPG::Skill, RPG::Item]
  class Klass
    # Default Critical Flag
    define_method(:critical_flag) { false }
    # Default Critical Hit Ratio
    define_method(:critical_hit) { "4 * user.dex / self.agi" }  
    # Default Critical Multiplier
    define_method(:critical_mult) { 2.0 }
    # Default Guard Flag
    define_method(:guard_flag) { false }
    # Default Guard Multiplier
    define_method(:guard_mult) { 0.5 }
  end
end

#==============================================================================

class Game_Battler
  #----------------------------------------------------------------------------
  attr_accessor :critical_flag
  attr_accessor :critical_hit
  attr_accessor :critical_mult
  attr_accessor :guard_flag
  attr_accessor :guard_mult
  attr_accessor :sp_damage
  #----------------------------------------------------------------------------
  # * Initialize
  #----------------------------------------------------------------------------
  alias eff_cond_ini initialize unless $@
  def initialize(*args)
    eff_cond_ini(*args)
    # Attack Critical Flag
    @critical_flag = true
    # Attack Critical Hit Ratio
    @critical_hit = "4 * attacker.dex / self.agi"
    # Attack Critical Multiplier
    @critical_mult = 2.0
    # Attack Guard Flag
    @guard_flag = true
    # Attack Guard Multiplier
    @guard_mult = 0.5
    # SP Damage Flag [ No editar ]
    @sp_damage = nil
  end
  #----------------------------------------------------------------------------
  # * Attack Effect - Main Method
  #----------------------------------------------------------------------------
  # > Este es el método principal donde se estan estructuradas todas las
  # subpartes. Solo habrá que editarlo en casos donde cierto ataque no tiene
  # nada que ver con su efecto normal
  #----------------------------------------------------------------------------
  def attack_effect(attacker)
    self.critical = false
    hit_result = (rand(100) < attacker.hit)
    if hit_result == true
      atk = [attacker.atk - self.pdef / 2, 0].max
      get_attack_damage(attacker, atk)
      if self.damage > 0
        get_attack_critical_effect(attacker) if @critical_flag
        get_attack_guard_effect(attacker) if @guard_flag
      end
      get_attack_damage_dispersion(attacker)
      hit_result = get_attack_hit_result(attacker)
    end
    if hit_result == true
      get_attack_hit_effect(attacker)
    else
      get_attack_miss_effect(attacker)
    end
    return true
  end
  #----------------------------------------------------------------------------
  # * Get Attack Damage
  #----------------------------------------------------------------------------
  # > Aquí se define la fórmula básica de ataque
  #----------------------------------------------------------------------------
  def get_attack_damage(attacker, atk)
    self.damage = atk * (20 + attacker.str) / 20
    self.damage *= elements_correct(attacker.element_set)
    self.damage /= 100
  end
  #----------------------------------------------------------------------------
  # * Get Attack Critical Damage
  #----------------------------------------------------------------------------
  # > Aquí se aplican cambios en damage usando las nuevas variables Critical
  #----------------------------------------------------------------------------
  def get_attack_critical_effect(attacker)
    var = "attacker = #{attacker}"
    critical_hit = instance_eval("#{var} ; #{@critical_hit}")
    if rand(100) < critical_hit
      damage = (self.damage * @critical_mult).to_i
      self.damage = damage
      self.critical = true
    end
  end
  #----------------------------------------------------------------------------
  # * Get Attack Guarding Damage
  #----------------------------------------------------------------------------
  # > Aquí se aplican cambios en damage usando las nuevas variables Guard
  #----------------------------------------------------------------------------
  def get_attack_guard_effect(attacker)
    if self.guarding?
      damage = (self.damage * @guard_mult).to_i
      self.damage = damage
    end
  end
  #----------------------------------------------------------------------------
  # * Get Attack Damage Dispersion
  #----------------------------------------------------------------------------
  # > Aquí se añade variabilidad al daño causado
  #----------------------------------------------------------------------------
  def get_attack_damage_dispersion(attacker)
    if self.damage.abs > 0
      amp = [self.damage.abs * 15 / 100, 1].max
      self.damage += rand(amp+1) + rand(amp+1) - amp
    end
  end
  #----------------------------------------------------------------------------
  # * Get Attack Hit Result
  #----------------------------------------------------------------------------
  # > Aquí se obtiene si el ataque es evadido o no
  #----------------------------------------------------------------------------
  def get_attack_hit_result(attacker)
    eva = 8 * self.agi / attacker.dex + self.eva
    hit = self.damage < 0 ? 100 : 100 - eva
    hit = self.cant_evade? ? 100 : hit
    return (rand(100) < hit)    
  end
  #----------------------------------------------------------------------------
  # * Get Attack Hit Effect
  #----------------------------------------------------------------------------
  # > Aquí se definen los efectos principales del ataque cuando este ocurre
  #----------------------------------------------------------------------------
  def get_attack_hit_effect(attacker)
    remove_states_shock
    self.hp -= self.damage
    @state_changed = false
    states_plus(attacker.plus_state_set)
    states_minus(attacker.minus_state_set)
  end
  #----------------------------------------------------------------------------
  # * Get Attack Miss Effect
  #----------------------------------------------------------------------------
  # > Aquí se definen los efectos principales del ataque cuando este falla
  #----------------------------------------------------------------------------
  def get_attack_miss_effect(attacker)
    self.damage = "Miss"
    self.critical = false
  end
  #----------------------------------------------------------------------------
  # * Skill Effect - Main Method
  #----------------------------------------------------------------------------
  # > Este es el método principal donde se estan estructuradas todas las
  # subpartes. Solo habrá que editarlo en casos donde cierta skill no tiene
  # nada que ver con su efecto normal
  #----------------------------------------------------------------------------
  def skill_effect(user, skill)
    self.critical = false
    if ((skill.scope == 3 or skill.scope == 4) and self.hp == 0) or
       ((skill.scope == 5 or skill.scope == 6) and self.hp >= 1)
      return false
    end
    effective = false
    effective |= skill.common_event_id > 0
    hit = skill.hit
    hit_result = get_skill_hit_result(user, skill)
    effective |= hit < 100
    if hit_result == true
      get_skill_damage(user, skill)
      if self.damage > 0
        get_skill_critical_effect(user, skill) if skill.critical_flag
        get_skill_guard_effect(user, skill) if skill.guard_flag
      end
      get_skill_damage_dispersion(user, skill)
      hit = get_skill_second_hit_result(user, skill)
      hit_result = (rand(100) < hit)
      effective |= hit < 100
    end
    if hit_result == true
      effective |= get_skill_hit_effect(user, skill, effective)
    else
      get_skill_miss_effect(user, skill)
    end
    self.damage = nil unless $game_temp.in_battle
    return effective
  end
  #----------------------------------------------------------------------------
  # * Get Skill First Hit Result
  #----------------------------------------------------------------------------
  # > Aquí se obtiene si la skill es efectuada o falla
  #----------------------------------------------------------------------------
  def get_skill_hit_result(user, skill)
    hit = skill.hit
    hit *= user.hit / 100 if skill.atk_f > 0
    return (rand(100) < hit)
  end
  #----------------------------------------------------------------------------
  # * Get Skill Second Hit Result
  #----------------------------------------------------------------------------
  # > Aquí se obtiene si la skill es efectuada o es evadida
  #----------------------------------------------------------------------------
  def get_skill_second_hit_result(user, skill)
    eva = 8 * self.agi / user.dex + self.eva
    hit = self.damage < 0 ? 100 : 100 - eva * skill.eva_f / 100
    hit = self.cant_evade? ? 100 : hit
    return hit
  end
  #----------------------------------------------------------------------------
  # * Get Skill Damage
  #----------------------------------------------------------------------------
  # > Aquí se define la fórmula de daño de la skill
  #----------------------------------------------------------------------------
  def get_skill_damage(user, skill)
    power = skill.power + user.atk * skill.atk_f / 100
    if power > 0
      power -= self.pdef * skill.pdef_f / 200
      power -= self.mdef * skill.mdef_f / 200
      power = [power, 0].max
    end
    rate = 20
    rate += (user.str * skill.str_f / 100)
    rate += (user.dex * skill.dex_f / 100)
    rate += (user.agi * skill.agi_f / 100)
    rate += (user.int * skill.int_f / 100)
    self.damage = power * rate / 20
    self.damage *= elements_correct(skill.element_set)
    self.damage /= 100
  end
  #----------------------------------------------------------------------------
  # * Get Skill Critical Damage
  #----------------------------------------------------------------------------
  # > Aquí se aplican cambios en damage usando las nuevas variables Critical
  #----------------------------------------------------------------------------
  def get_skill_critical_effect(user, skill)
    var = "user = #{user} ; skill = #{skill}"
    critical_hit = instance_eval("#{var} ; #{skill.critical_hit}")
    if rand(100) < critical_hit
      damage = (self.damage * skill.critical_mult).to_i
      self.damage = damage
      self.critical = true
    end
  end
  #----------------------------------------------------------------------------
  # * Get Skill Guard Damage
  #----------------------------------------------------------------------------
  # > Aquí se aplican cambios en damage usando las nuevas variables Guard
  #----------------------------------------------------------------------------
  def get_skill_guard_effect(user, skill)
    if self.guarding?
      damage = (self.damage * skill.guard_mult).to_i
      self.damage = damage
    end
  end
  #----------------------------------------------------------------------------
  # * Get Skill Damage Dispersion
  #----------------------------------------------------------------------------
  # > Aquí se añade variabilidad al daño causado
  #----------------------------------------------------------------------------
  def get_skill_damage_dispersion(user, skill)
    if skill.variance > 0 and self.damage.abs > 0
      amp = [self.damage.abs * skill.variance / 100, 1].max
      self.damage += rand(amp+1) + rand(amp+1) - amp
    end
  end
  #----------------------------------------------------------------------------
  # * Get Skill Hit Effect
  #----------------------------------------------------------------------------
  # > Aquí se definen los efectos principales de la skill cuando esta ocurre
  #----------------------------------------------------------------------------
  def get_skill_hit_effect(user, skill, effective=false)
    if skill.power != 0 and skill.atk_f > 0
      remove_states_shock
      effective = true
    end
    last_hp = self.hp
    self.hp -= self.damage
    effective |= self.hp != last_hp
    @state_changed = false
    effective |= states_plus(skill.plus_state_set)
    effective |= states_minus(skill.minus_state_set)
    if skill.power == 0
      self.damage = ""
      unless @state_changed
        self.damage = "Miss"
      end
    end
    return effective
  end
  #----------------------------------------------------------------------------
  # * Get Skill Miss Effect
  #----------------------------------------------------------------------------
  # > Aquí se definen los efectos principales de la skill cuando esta falla
  #----------------------------------------------------------------------------
  def get_skill_miss_effect(user, skill)
    self.damage = "Miss"
  end
  #----------------------------------------------------------------------------
  # * Item Effect - Main Method
  #----------------------------------------------------------------------------
  # > Este es el método principal donde se estan estructuradas todas las
  # subpartes. Solo habrá que editarlo en casos donde cierto item no tiene
  # nada que ver con su efecto normal
  #----------------------------------------------------------------------------
  def item_effect(*args)
    user = case args.size
      when 1 then self
      when 2 then args[0]
    end
    item = args[-1]
    self.critical = false
    if ((item.scope == 3 or item.scope == 4) and self.hp == 0) or
       ((item.scope == 5 or item.scope == 6) and self.hp >= 1)
      return false
    end
    effective = false
    effective |= item.common_event_id > 0
    hit = item.hit
    hit_result = get_item_hit_result(user, item)
    effective |= hit < 100
    if hit_result == true
      get_item_damage(user, item)
      if self.damage > 0
        get_item_critical_effect(user, item) if item.critical_flag
        get_item_guard_effect(user, item) if item.guard_flag
      end
      get_item_damage_dispersion(user, item)
      hit = get_item_second_hit_result(user, item)
      hit_result = (rand(100) < hit)
      effective |= hit < 100
    end
    if hit_result == true
      effective |= get_item_hit_effect(user, item, effective)
    else
      get_item_miss_effect(user, item)
    end
    self.damage = nil unless $game_temp.in_battle
    return effective
  end
  #----------------------------------------------------------------------------
  # * Get Item First Hit Result
  #----------------------------------------------------------------------------
  # > Aquí se obtiene si el item es efectuado o falla
  #----------------------------------------------------------------------------
  def get_item_hit_result(user, item)
    return (rand(100) < item.hit)
  end
  #----------------------------------------------------------------------------
  # * Get Item Second Hit Result
  #----------------------------------------------------------------------------
  # > Aquí se obtiene si el item es efectuado o es evadido
  # (por defecto no puede evadirse nunca)
  #----------------------------------------------------------------------------
  def get_item_second_hit_result(user, item)
    return 100
  end
  #----------------------------------------------------------------------------
  # * Get Item Damage
  #----------------------------------------------------------------------------
  # > Aquí se definen la fórmulas de daño del Item
  # En este caso hay dos: HP y SP, separadamente
  #----------------------------------------------------------------------------
  def get_item_damage(user, item)
    recover_hp = maxhp * item.recover_hp_rate / 100 + item.recover_hp
    if recover_hp < 0
      recover_hp += self.pdef * item.pdef_f / 20
      recover_hp += self.mdef * item.mdef_f / 20
      recover_hp = [recover_hp, 0].min
    end
    self.damage = -recover_hp
    self.damage *= elements_correct(item.element_set)
    self.damage /= 100
    recover_sp = maxsp * item.recover_sp_rate / 100 + item.recover_sp
    self.sp_damage = -recover_sp
    self.sp_damage *= elements_correct(item.element_set)
    self.sp_damage /= 100
  end
  #----------------------------------------------------------------------------
  # * Get Item Critical Damage
  #----------------------------------------------------------------------------
  # > Aquí se aplican cambios en damage usando las nuevas variables Critical
  #----------------------------------------------------------------------------
  def get_item_critical_effect(user, item)
    var = "user = #{user} ; skill = #{item}"
    critical_hit = instance_eval("#{var} ; #{item.critical_hit}")
    if rand(100) < critical_hit
      damage = (self.damage * item.critical_mult).to_i
      self.damage = damage
      self.critical = true
    end
  end
  #----------------------------------------------------------------------------
  # * Get Item Guard Damage
  #----------------------------------------------------------------------------
  # > Aquí se aplican cambios en damage usando las nuevas variables Guard
  #----------------------------------------------------------------------------
  def get_item_guard_effect(user, item)
    if self.guarding?
      damage = (self.damage * item.guard_mult).to_i
      self.damage = damage
    end
  end
  #----------------------------------------------------------------------------
  # * Get Item Damage Dispersion
  #----------------------------------------------------------------------------
  # > Aquí se añade variabilidad al daño causado, tanto HP como SP separadamente
  #----------------------------------------------------------------------------
  def get_item_damage_dispersion(user, item)
    if item.variance > 0 and self.damage.abs > 0
      amp = [self.damage.abs * item.variance / 100, 1].max
      self.damage += rand(amp+1) + rand(amp+1) - amp
    end
    if item.variance > 0 and self.sp_damage.abs > 0
      amp = [self.sp_damage.abs * item.variance / 100, 1].max
      self.sp_damage += rand(amp+1) + rand(amp+1) - amp
    end
  end
  #----------------------------------------------------------------------------
  # * Get Item Hit Effect
  #----------------------------------------------------------------------------
  # > Aquí se definen los efectos principales del item cuando este ocurre
  #----------------------------------------------------------------------------
  def get_item_hit_effect(user, item, effective=false)
    last_hp = self.hp
    last_sp = self.sp
    self.hp -= self.damage
    self.sp -= self.sp_damage
    effective |= self.hp != last_hp
    effective |= self.sp != last_sp
    @state_changed = false
    effective |= states_plus(item.plus_state_set)
    effective |= states_minus(item.minus_state_set)
    if item.parameter_type > 0 and item.parameter_points != 0
      case item.parameter_type
      when 1  # Max HP
        @maxhp_plus += item.parameter_points
      when 2  # Max SP
        @maxsp_plus += item.parameter_points
      when 3  # Strength
        @str_plus += item.parameter_points
      when 4  # Dexterity
        @dex_plus += item.parameter_points
      when 5  # Agility
        @agi_plus += item.parameter_points
      when 6  # Intelligence
        @int_plus += item.parameter_points
      end
      effective = true
    end
    if item.recover_hp_rate == 0 and item.recover_hp == 0
      self.damage = ""
      if item.recover_sp_rate == 0 and item.recover_sp == 0 and
         (item.parameter_type == 0 or item.parameter_points == 0)
        unless @state_changed
          self.damage = "Miss"
        end
      end
    end
    return effective
  end
  #----------------------------------------------------------------------------
  # * Get Item Miss Effect
  #----------------------------------------------------------------------------
  # > Aquí se definen los efectos principales del item cuando este falla
  #----------------------------------------------------------------------------
  def get_item_miss_effect(user, item)
    self.damage = "Miss"
  end
end

Más adelante explicaré algunas ampliaciones que se pueden llegar a hacer (recomendaría hacerlo usando alias de los nuevos métodos en un script a parte tal como normalmente se hacen ese tipo de cambios), pero por ahora explico la configuración básica del script sin necesidad de crearle añadidos.

1) Definir Skills e Items que tengan efecto Crítico (en el maker por defecto solo aparece en Ataque)
Para hacerlo se define al principio del script, donde puse un ejemplo de cómo hacerlo. Se usaría esta estructura:

$data_skills[ID].critical_flag = true
$data_items[ID].critical_flag = true


Su valor por defecto es false lo que significa que no pueden tener Crítico.
Además de definirlo ahí al principio se puede alterar esa propiedad donde se quiera del juego, usando exactamente lo mismo.

Pero no solo eso, además se puede modificar la probabilidad de crítico usando una fórmula y el multiplicador de crítico usando un float.

$data_skills[ID].critical_hit = "4 * user.dex / self.agi"
$data_skills[ID].critical_mult =2.0


Los valores por defecto son los que he puesto en este ejemplo.
Para la fórmula podéis usar los parámetros:
self - Target
user - El que efectúa la skill o item
skill - Skill efectuada (en caso de ser una skill)
item - Item efectuado (en caso de ser un item)

2) Definir Skills e Items que tengan efecto Guarding (en el maker por defecto siempre lo tienen)
Va similar al anterior pero con esta llamada de script:

$data_skills[ID].guard_flag = true

Por defecto en este caso vale true, si pones false aunque se esté defendiendo esa skill o item le hará todo el daño.
Además puedes modificar el multiplicador, que en ese caso por defecto vale 0.5

$data_skills[ID].guard_mult = 0.5

3) Definir todas esas propiedades en Ataque como si fuera una Skill

Puede interesar que al Ataque también se le puedan modificar todos esos parámetros comentados.
Se hace exactamente igual pero en vez de $data_skills[ID] se usará $game_actors[ID] para el actor o $game_troop.enemies[ID] para el enemigo. En el primer caso la ID es la posición del actor en la Base de Datos, en el segundo la posición del enemigo en la tropa enemiga actual (y por lo tanto esos cambios se recomendaría aplicarlos en el Evento de Tropa al iniciar batalla).

Por ahora ya está. Quizá os parezca algo agobiante de manejar pero no hay para tanto en realidad.
avatar
Wecoc
Administrador
Administrador



Créditos 12283

Gracias : 645

Volver arriba Ir abajo

RPG Maker XP Re: [XP] Lunatic Battle Damage Effects

Mensaje por orochii el 2017-11-05, 16:42

Este script está bastante guay. Se me ocurren varios efectos de skill más para hacer, cosas que he implementado en Dreki y otras pruebas random a partir de añadir líneas en esos métodos de skill_effect y tal.

También me interesó ver lo de for Klass in [RPG::Skill, RPG::Item], nunca había visto eso xD. Ruby es bastante peculiar en muchas cosas jajaja.

Salut!
avatar
orochii
Reportero

0/3

Créditos 7791

Gracias : 461

Volver arriba Ir abajo

RPG Maker XP Re: [XP] Lunatic Battle Damage Effects

Mensaje por Wecoc el 2017-11-05, 17:05

Eso de Klass lo he usado varias veces, es bastante útil. LittleDrago hace muchas cosas de esas, viene bien ojear sus scripts para aprender ese tipo de atajos xD

Bueno, voy a explicar algunas cosas que se pueden hacer con esto.

Introducción

Este script básicamente hace submétodos de los métodos attack_effect, skill_effect e item_effect.

En cada uno de esos submétodos podemos aplicarle cambios extra sin tener que pelearse con toda la estructuración extra, algo engorrosa, que tienen esos tres métodos.

Pongamos de ejemplo get_skill_damage (método que obtiene el daño de la skill usando la fórmula por defecto)

Código:
Código:
class Game_Battler
  alias altformula_damage get_skill_damage unless $@
  def get_skill_damage(user, skill)
    #---------------------------------------------------------------
    if skill.id == 17 # Si la skill tiene ID 17
      # Fórmula alternativa
      self.damage = (skill.str_f + user.str_f) / self.dex
      return
    end
    #---------------------------------------------------------------
    altformula_damage(user, skill)
  end
end

Viene a ser como los scripts que puse en el topic de tips & tricks pero mucho más conciso en solo los cambios que te interesan (y con algunas opciones nuevas).

Submétodos nuevos

Podéis mirar en el script para más detalles, pero resumidamente es lo siguiente.

Separa el método Attack Effect en los siguientes:
Spoiler:
- Get Attack Damage
- Get Attack Critical Damage
- Get Attack Guarding Damage
- Get Attack Damage Dispersion
- Get Attack Hit Result
- Get Attack Hit Effect
- Get Attack Miss Effect

Separa el método Skill Effect en los siguientes:
Spoiler:
- Get Skill First Hit Result
- Get Skill Second Hit Result
- Get Skill Damage
- Get Skill Critical Damage
- Get Skill Guard Damage
- Get Skill Damage Dispersion
- Get Skill Hit Effect
- Get Skill Miss Effect

Nota: First Hit corresponde a si el usuario al intentar hacer la skill acierta o falla (según esa propia skill)
Second Hit corresponde a una vez efectuada si ésta es evadida por el target o no. Por defecto no se ve la diferencia (siempre aparece "Miss") pero ahora puede ampliarse.

Separa el método Item Effect en los siguientes:
Spoiler:
- Get Item First Hit Result
- Get Item Second Hit Result
- Get Item Damage
- Get Item Critical Damage
- Get Item Guard Damage
- Get Item Damage Dispersion
- Get Item Hit Effect
- Get Item Miss Effect

Nota: En items, Second Hit siempre vale 100 porque los items por defecto no pueden evadirse nunca, pero ahora al poder ampliarlo se pueden definir algunos que sí.

Ampliaciones

Solo son algunos ejemplos de uso.

Aclaración:
El 1 puede hacerse sin el script pero de modo algo más largo y menos optimizado.
El 3A sirve sin el script exactamente igual...
El 3B, 4 y el 5 solo pueden hacerse sin el script reescribiendo todo el método, no con alias, cosa que es muy poco compatible.
El 2 directamente no puede hacerse sin el script.

1 - Añadir efecto especial a una skill cuando mata al target

Código:
Código:
class Game_Battler
  alias skill_kill_effect get_skill_hit_effect unless $@
  def get_skill_hit_effect(user, skill, effective=false)
    effective = skill_kill_effect(user, skill, effective)
    if skill.id == 17 # ID de la skill
      if self.dead?
        #---------------------------------------------------------------
        # Aquí se añaden los efectos extra al matar al target
        user.sp += 20
        effective = true
        #---------------------------------------------------------------
      end
    end
    return effective
  end
end

2 - Añadir efecto especial a una skill cuando haces Crítico

Código:
Código:
class Game_Battler
  alias skill_critical_ex get_skill_critical_effect unless $@
  def get_skill_critical_effect(user, skill)
    skill_critical_ex(user, skill)
    if skill.id == 17 # ID de la skill
      if self.critical
        #---------------------------------------------------------------
        # Aquí se añaden los efectos extra al hacer daño crítico
        add_state(8)
        #---------------------------------------------------------------
      end
    end
  end
end

3A - Rebotar la skill si el target se está defendiendo
Ocurre como si el target la aplicara al usuario.

Código:
Código:
class Game_Battler
  attr_accessor :skill_rebound_guard
  alias skill_rebound_ini initialize unless $@
  def initialize
    skill_rebound_ini
    @skill_rebound_guard = false
  end
  alias skill_rebound_effect skill_effect unless $@
  def skill_effect(user, skill)
    if skill.id == 17 # ID de la skill
      if self.guarding? && user.skill_rebound_guard == false
        self.skill_rebound_guard = true
        self.damage = "Miss"
        self.critical = false
        user.skill_effect(self, skill)
        user.damage_pop = true
        return false
      end
    end
    user.skill_rebound_guard = false
    self.skill_rebound_guard = false
    return skill_rebound_effect(user, skill)
  end
end

3B - Rebotar la skill si el target se está defendiendo
Se conservan los parámetros, cambia solo el target del daño.

Código:
Código:
class Game_Battler
  alias skill_rebound_damage get_skill_damage unless $@
  def get_skill_damage(user, skill)
    skill_rebound_damage(user, skill)
    if skill.id == 17 # ID de la skill
      if self.guarding? && self.damage.abs > 0
        user.damage = self.damage
        if skill.variance > 0
          amp = [user.damage.abs * skill.variance / 100, 1].max
          user.damage += rand(amp+1) + rand(amp+1) - amp
        end
        user.damage = damage
        user.hp -= user.damage
        user.damage_pop = true
        self.damage = "Miss"
        self.critical = false
      end
    end
  end
end

4 - Rebotar la skill si es evadida por el target
Solo ocurre si es evadida, no si el usuario falla al aplicarla.
Ocurre como si el target la aplicara al usuario.

Código:
Código:
class Game_Battler
  #------------------------------------------------------------------------
  # Estado que se añade automáticamente al usuario para que no pueda evadir
  # el rebote. Ese estado debe tener la opción "Sin Evasión" activada
  #------------------------------------------------------------------------
    CANT_EVADE_STATE = 7
  #------------------------------------------------------------------------
  alias get_rebound_evade get_skill_second_hit_result unless $@
  def get_skill_second_hit_result(user, skill)
    hit = get_rebound_evade(user, skill)
    if skill.id == 17 # ID de la skill
      if hit == false
        has_state = user.state?(CANT_EVADE_STATE)
        user.add_state(CANT_EVADE_STATE) unless has_state
        user.skill_effect(self, skill)
        user.damage_pop = true
        user.remove_state(CANT_EVADE_STATE) unless has_state
      end
    end
  end
end

5 - Añadir efecto especial si el target es muy débil al elemento de la habilidad

Código:
Código:
class Game_Battler
  alias weakness_skill_damage get_skill_damage unless $@
  def get_skill_damage(user, skill)
    weakness_skill_damage(user, skill)
    fire_skills = [4, 5, 6] # IDs de las skills de fuego
    if fire_skills.include?(skill.id)
      if self.element_rate(1) == -100 # MUY débil al elemento Fuego
        self.damage *= 10 # El daño se multiplica por 10
      end
    end
  end
end

Si tenéis dudas comentadlas.
avatar
Wecoc
Administrador
Administrador



Créditos 12283

Gracias : 645

Volver arriba Ir abajo

RPG Maker XP Re: [XP] Lunatic Battle Damage Effects

Mensaje por xXIsrael0499Xx el 2017-11-06, 10:32

O_o Oh Dios mio, esta de lujo, me gusta mucho, esta re útil el script, ahora veamos cuantas personas lo van a utilizar (?) xD, bueno si esta genial, me gusta eso de modificar la batalla por defecto del maker XP, para que no sea tan aburrida.

Un gracias y eso.
avatar
xXIsrael0499Xx
Veterano
Veterano

0/3

Créditos 2047

Gracias : 113

Volver arriba Ir abajo

RPG Maker XP Re: [XP] Lunatic Battle Damage Effects

Mensaje por Contenido patrocinado


Contenido patrocinado


Volver arriba Ir abajo

Ver el tema anterior Ver el tema siguiente Volver arriba


Permisos de este foro:
No puedes responder a temas en este foro.