Mundo Maker
¡Bienvenid@ a Mundo Maker!

¿Quieres aprender todo sobre el RPG Maker?



Regístrate y forma parte de Mundo Maker.

[XP][BETA] ZTL Advanced States

Ver el tema anterior Ver el tema siguiente Ir abajo

RPG Maker XP [XP][BETA] ZTL Advanced States

Mensaje por Wecoc el 2016-04-09, 12:59

Éste script lo hice hace mucho tiempo para un proyecto que fue abandonado, llamado Zankos The Legend.
No lo había subido antes porque no está completo, pero como no tengo interés en terminarlo he decidido subir lo que tiene hecho. Si alguien se anima a terminarlo es libre de hacerlo. Lo que hay hecho es funcional.

El script añade nuevos tipos de estados alterados, que hacen cosas que desde la base de datos no se pueden configurar.
Además añade la opción de configurar estados que se activen con cierta probabilidad al inicio del combate a un actor o enemigo concretos. Eso se controla en las globales ACTOR_START_STATES y ENEMY_START_STATES.
También permite configurar estados que se activen con cierta probabilidad a cada turno, de modo muy similar. Eso se controla en las globales ACTOR_SPONTANEOUS_STATES y ENEMY_SPONTANEOUS_STATES.

Los nuevos estados son:


• Curandero
• Bendito
• Maldito
• Furioso
• Poderoso
• Débil
• Protección
• Protección Mágica
• Odioso[BETA: Solo funciona con actors, no con enemies]
• Amigable[BETA: Solo funciona con actors, no con enemies]
• Sobrecargado[BETA: No funciona paralelamente con algún Weight System]
• Inofensivo[BETA: No está disponible]
• Desarmado[BETA: No está disponible]
• Indefenso[BETA: No está disponible]
• Piadoso

En el script se dan más detalles de qué hace cada uno.

Demo: ZTL Advanced States BETA

Script:

Código:
#==============================================================================
# ** [XP][BETA] Zankos The Legend Advanced States
#------------------------------------------------------------------------------
# Autor: Wecoc
#==============================================================================
#
# Éste script añade nuevos tipos de estado:
#
# - Curandero
#    Sus habilidades de curación son más potentes
#
# - Bendito
#    Las habilidades de curación son más efectivas en él
#
# - Maldito
#    Las habilidades de curación son menos efectivas en él
#
# - Furioso
#    Sus ataques físicos son más fuertes
#
# - Poderoso
#    Sus ataques mágicos son más fuertes
#
# - Débil
#    Sus ataques son más débiles y también sufre más daño
#
# - Protección
#    Los ataques físicos no le afectan
#
# - Protección Mágica
#    Los ataques mágicos no le afectan
#
# - Odioso
#    Siempre le atacan a él
#  [ ATENCIÓN: En la versión BETA solo funciona con actors, no con enemies ]
#
# - Amigable
#    Nunca le atacan a él
#  [ ATENCIÓN: En la versión BETA solo funciona con actors, no con enemies ]
#
# - Sobrecargado
#    No puede escapar y su agilidad es muy reducida
#  [ ATENCIÓN: En la versión BETA no funciona con ningún sistema de Weight ]
#
# - Inofensivo
#    No puede atacar, usar magia ni usar objetos
#  [ ATENCIÓN: No está disponible en la versión BETA ]
#
# - Desarmado
#    No puede atacar
#  [ ATENCIÓN: No está disponible en la versión BETA ]
#  [ ATENCIÓN: No se auto_updatea con el equipo en la versión BETA ]
#
# - Indefenso
#    No puede defenderse
#  [ ATENCIÓN: No está disponible en la versión BETA ]
#  [ ATENCIÓN: No se auto_updatea con el equipo en la versión BETA ]
#
# - Piadoso
#    El contrincante puede escapar más fácilmente
#
#==============================================================================

module ZTLA_States

  DEFINE_DESCRIPTION = false
 
  # Nuevos tipos de Estados
 
  USER_SKILL_CURE_EFFECT =  {2 => 1.5} # Curandero ##
 
  TARGET_SKILL_CURE_EFFECT = {3 => 1.5, # Bendito ##
                              4 => 0.5} # Maldito ##
 
  ATTACKER_POWER_ATTACK_EFFECT = {5 => 1.5, # Furioso ##
                                  7 => 0.5} # Débil ##
                                 
  ATTACKER_SKILL_ATTACK_EFFECT = {6 => 1.5, # Poderoso ##
                                  7 => 0.5} # Débil ##
                                 
  TARGET_POWER_ATTACK_EFFECT = {7 => 1.5, # Débil ##
                                8 => 0}  # Protección ##
 
  TARGET_SKILL_ATTACK_EFFECT = {7 => 1.5, # Débil ##
                                9 => 0}  # Protección Mágica ##
 
  TARGET_RATIO = {10 => 'ALWAYS', # Odioso ##
                  11 => 0}        # Amigable ##
 
  CANT_ESCAPE = [12] # Sobrecargado
 
  CANT_ATTACK    = [13, 14] # Inofensivo, Desarmado
  CANT_DEFEND    = [13, 15] # Inofensivo, Indefenso
  CANT_USE_MAGIC = [13]    # Inofensivo
  CANT_USE_ITEM  = [13]    # Inofensivo
 
  SPECIAL_NO_WEAPON = [14] # Desarmado
  SPECIAL_NO_SHIELD = [15] # Indefenso
 
  IGNORE_IN_ESCAPE_FORMULA = [16] # Piadoso

  # Actor ID => [[state, prob]....]
  ACTOR_START_STATES = {1 => [[10, 50], [16, 50]], # Odioso, Piadoso
                        2 => [[10, 50], [16, 50]], # Odioso, Piadoso
                        7 => [[10, 50], [16, 50]], # Odioso, Piadoso
                        8 => [[10, 50], [16, 50]]} # Odioso, Piadoso
 
  # Enemy ID => [[state, prob]....]                     
  ENEMY_START_STATES = {1 => [[6, 20], [7, 5]]}  # Poderoso, Débil
 
  # Actor ID => [[state, prob]....]
  ACTOR_SPONTANEOUS_STATES = {1 => [[15, 5]]} # Inofensivo
 
  # Enemy ID => [[state, prob]....]                     
  ENEMY_SPONTANEOUS_STATES = {1 => [[15, 5]]} # Inofensivo
end

#==============================================================================
# ** Game_Battler
#==============================================================================

class Game_Battler 
  #--------------------------------------------------------------------------
  # * Attack Effect
  #--------------------------------------------------------------------------
  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
      self.damage = atk * (20 + attacker.str) / 20
      self.damage *= elements_correct(attacker.element_set)
      self.damage /= 100
      for state in attacker.states
        if ZTLA_States::ATTACKER_POWER_ATTACK_EFFECT.keys.include?(state)
          self.damage *= ZTLA_States::ATTACKER_POWER_ATTACK_EFFECT[state]
        end
      end
      for state in @states
        if ZTLA_States::TARGET_POWER_ATTACK_EFFECT.keys.include?(state)
          self.damage *= ZTLA_States::TARGET_POWER_ATTACK_EFFECT[state]
        end
      end
      self.damage = self.damage.to_i
      if self.damage > 0
        if rand(100) < 4 * attacker.dex / self.agi
          self.damage *= 2
          self.critical = true
        end
        if self.guarding?
          self.damage /= 2
        end
      end
      if self.damage.abs > 0
        amp = [self.damage.abs * 15 / 100, 1].max
        self.damage += rand(amp+1) + rand(amp+1) - amp
      end
      eva = 8 * self.agi / attacker.dex + self.eva
      hit = self.damage < 0 ? 100 : 100 - eva
      hit = self.cant_evade? ? 100 : hit
      hit_result = (rand(100) < hit)
    end
    if self.damage == 0
      hit_result = false
    end
    if hit_result == true
      remove_states_shock
      self.hp -= self.damage
      @state_changed = false
      states_plus(attacker.plus_state_set)
      states_minus(attacker.minus_state_set)
    else
      self.damage = "Miss"
      self.critical = false
    end
    return true
  end
  #--------------------------------------------------------------------------
  # * Skill Effect
  #--------------------------------------------------------------------------
  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
    if skill.atk_f > 0
      hit *= user.hit / 100
    end
    hit_result = (rand(100) < hit)
    effective |= hit < 100
    if hit_result == true
      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
      if power < 0
        for state in user.states
          if ZTLA_States::USER_SKILL_CURE_EFFECT.keys.include?(state)
            power *= ZTLA_States::USER_SKILL_CURE_EFFECT[state]
          end
        end
        for state in @states
          if ZTLA_States::TARGET_SKILL_CURE_EFFECT.keys.include?(state)
            power *= ZTLA_States::TARGET_SKILL_CURE_EFFECT[state]
          end
        end
      end
      power = power.to_i
      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
      if self.damage > 0
        for state in user.states
          if ZTLA_States::ATTACKER_SKILL_ATTACK_EFFECT.keys.include?(state)
            self.damage *= ZTLA_States::ATTACKER_SKILL_ATTACK_EFFECT[state]
          end
        end
        for state in @states
          if ZTLA_States::TARGET_SKILL_ATTACK_EFFECT.keys.include?(state)
            self.damage *= ZTLA_States::TARGET_SKILL_ATTACK_EFFECT[state]
          end
        end
      end
      if self.damage > 0
        if self.guarding?
          self.damage /= 2
        end
      end
      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
      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
      hit_result = (rand(100) < hit)
      effective |= hit < 100
    end
    if hit_result == true
      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
    else
      self.damage = "Miss"
    end
    unless $game_temp.in_battle
      self.damage = nil
    end
    return effective
  end
end

#==============================================================================
# ** Game_Party
#==============================================================================

class Game_Party
  #--------------------------------------------------------------------------
  # * Random Selection of Target Actor
  #--------------------------------------------------------------------------
  def random_target_actor(hp0 = false)
    roulette = []
    for actor in @actors
      if (not hp0 and actor.exist?) or (hp0 and actor.hp0?)
        position = $data_classes[actor.class_id].position
        n = (4 - position) * 10
        for state in actor.states
          if ZTLA_States::TARGET_RATIO.include?(state)
            if ZTLA_States::TARGET_RATIO[state] == 'ALWAYS'
              return actor
            end
            n *= ZTLA_States::TARGET_RATIO[state]
          end
          n = n.to_i
        end
        n.times do
          roulette.push(actor)
        end
      end
    end
    if roulette.size == 0
      return nil
    end
    return roulette[rand(roulette.size)]
  end
end

#==============================================================================
# ** Scene_Battle
#==============================================================================

class Scene_Battle
  #--------------------------------------------------------------------------
  # * Start Pre-Battle Phase
  #--------------------------------------------------------------------------
  def start_phase1
    @phase = 1
    $game_party.clear_actions
    for actor in $game_party.actors
      if actor.exist?
        if ZTLA_States::ACTOR_START_STATES.keys.include?(actor.id)
          states_array = ZTLA_States::ACTOR_START_STATES[actor.id]
          for states in states_array
            if rand(100) < states[1]
              actor.add_state(states[0])
            end
          end
        end
      end
    end
    for enemy in $game_troop.enemies
      if enemy.exist?
        if ZTLA_States::ENEMY_START_STATES.keys.include?(enemy.id)
          states_array = ZTLA_States::ENEMY_START_STATES[enemy.id]
          for states in states_array
            if rand(100) < states[1]
              enemy.add_state(states[0])
            end
          end
        end
      end
    end
    @status_window.refresh
    setup_battle_event
  end
  #--------------------------------------------------------------------------
  # * Start Main Phase
  #--------------------------------------------------------------------------
  def start_phase4
    @phase = 4
    $game_temp.battle_turn += 1
    for actor in $game_party.actors
      if actor.exist?
        if ZTLA_States::ACTOR_SPONTANEOUS_STATES.keys.include?(actor.id)
          states_array = ZTLA_States::ACTOR_SPONTANEOUS_STATES[actor.id]
          for states in states_array
            if rand(100) < states[1]
              actor.add_state(states[0])
            end
          end
        end
      end
    end
    for enemy in $game_troop.enemies
      if enemy.exist?
        if ZTLA_States::ENEMY_SPONTANEOUS_STATES.keys.include?(enemy.id)
          states_array = ZTLA_States::ENEMY_SPONTANEOUS_STATES[enemy.id]
          for states in states_array
            if rand(100) < states[1]
              enemy.add_state(states[0])
            end
          end
        end
      end
    end
    @status_window.refresh
    for index in 0...$data_troops[@troop_id].pages.size
      page = $data_troops[@troop_id].pages[index]
      if page.span == 1
        $game_temp.battle_event_flags[index] = false
      end
    end
    @actor_index = -1
    @active_battler = nil
    @party_command_window.active = false
    @party_command_window.visible = false
    @actor_command_window.active = false
    @actor_command_window.visible = false
    $game_temp.battle_main_phase = true
    for enemy in $game_troop.enemies
      enemy.make_action
    end
    make_action_orders
    @phase4_step = 1
  end
  #--------------------------------------------------------------------------
  # * Frame Update (party command phase: escape)
  #--------------------------------------------------------------------------
  def update_phase2_escape
    for actor in $game_party.actors
      if actor.exist?
        for state in actor.states
          if ZTLA_States::CANT_ESCAPE.include?(state)
            $game_party.clear_actions
            start_phase4
            return
          end
        end
      end
    end
    enemies_agi = 0
    enemies_number = 0
    for enemy in $game_troop.enemies
      if enemy.exist?
        e_agi = enemy.agi
        for state in enemy.states
          if ZTLA_States::IGNORE_IN_ESCAPE_FORMULA.include?(state)
            e_agi = 0
          end
        end
        enemies_agi += e_agi
        enemies_number += 1
      end
    end
    if enemies_number > 0
      enemies_agi /= enemies_number
    end
    actors_agi = 0
    actors_number = 0
    for actor in $game_party.actors
      if actor.exist?
        actors_agi += actor.agi
        actors_number += 1
      end
    end
    if actors_number > 0
      actors_agi /= actors_number
    end
    success = rand(100) < 50 * actors_agi / enemies_agi
    if success
      $game_system.se_play($data_system.escape_se)
      $game_system.bgm_play($game_temp.map_bgm)
      battle_end(1)
    else
      $game_party.clear_actions
      start_phase4
    end
  end
  #--------------------------------------------------------------------------
  # * Make Basic Action Results
  #--------------------------------------------------------------------------
  def make_basic_action_result
    # If attack
    if @active_battler.current_action.basic == 0
      @animation1_id = @active_battler.animation1_id
      @animation2_id = @active_battler.animation2_id
      if @active_battler.is_a?(Game_Enemy)
        if @active_battler.restriction == 3
          target = $game_troop.random_target_enemy
        elsif @active_battler.restriction == 2
          target = $game_party.random_target_actor
        else
          index = @active_battler.current_action.target_index
          target = $game_party.smooth_target_actor(index)
        end
      end
      if @active_battler.is_a?(Game_Actor)
        if @active_battler.restriction == 3
          target = $game_party.random_target_actor
        elsif @active_battler.restriction == 2
          target = $game_troop.random_target_enemy
        else
          index = @active_battler.current_action.target_index
          target = $game_troop.smooth_target_enemy(index)
        end
      end
      @target_battlers = [target]
      for target in @target_battlers
        target.attack_effect(@active_battler)
      end
      return
    end
    # If guard
    if @active_battler.current_action.basic == 1
      @help_window.set_text($data_system.words.guard, 1)
      return
    end
    # If escape
    if @active_battler.is_a?(Game_Enemy) and
      @active_battler.current_action.basic == 2
      @help_window.set_text("Escape", 1)
      update_phase4_escape
      return
    end
    # If doing nothing
    if @active_battler.current_action.basic == 3
      $game_temp.forcing_battler = nil
      @phase4_step = 1
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (enemy escape)
  #--------------------------------------------------------------------------
  def update_phase4_escape
    for state in @active_battler.states
      if ZTLA_States::CANT_ESCAPE.include?(state)
        $game_temp.forcing_battler = nil
        @phase4_step = 1
        return
      end
    end
    actors_agi = 0
    actors_number = 0
    for actor in $game_party.actors
      if actor.exist?
        a_agi = actor.agi
        for state in actor.states
          if ZTLA_States::IGNORE_IN_ESCAPE_FORMULA.include?(state)
            a_agi = 0
          end
        end
        actors_agi += a_agi
        actors_number += 1
      end
    end
    if actors_number > 0
      actors_agi /= enemies_number
    end
    success = rand(100) < 50 * @active_battler.agi / actors_agi
    if success
      @active_battler.escape
    else
      $game_temp.forcing_battler = nil
      @phase4_step = 1
    end
  end
end
avatar
Wecoc
Administrador
Administrador



Créditos 12308

Gracias : 653

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.