Mundo Maker
¡Bienvenid@ a Mundo Maker!

¿Quieres aprender todo sobre el RPG Maker?



Regístrate y forma parte de Mundo Maker.

[XP] Mostrar cuanto SP es recuperado en batalla.

Ver el tema anterior Ver el tema siguiente Ir abajo

RPG Maker XP [XP] Mostrar cuanto SP es recuperado en batalla.

Mensaje por Lance Amano el 2015-02-04, 01:42

Este par de scripts permite hacer lo que se indica en el título.

Primera parte:
Código:
SP_COLOR = Color.new(144, 176, 255)
#==============================================================================
# ** Scene_Battle
#==============================================================================
class Scene_Battle
  #--------------------------------------------------------------------------
  # * Frame Update (main phase step 4 : animation for target)
  #--------------------------------------------------------------------------
  def update_phase4_step4
    screen_animation = false
    animation_launched = false
    if @animation2_id > 0
      animation = $data_animations[@animation2_id]
      screen_animation = animation.position == 3
    end
    # Animation for target
    for target in @target_battlers
      target.animation_id = @animation2_id
      unless screen_animation && animation_launched
        target.only_flash_animation = false
        animation_launched = true
      else
        target.only_flash_animation = true
      end
      target.animation_hit = (target.damage != "Miss")
    end
    # Animation has at least 8 frames, regardless of its length
    @wait_count = 8
    # Shift to step 5
    @phase4_step = 5
  end
end
#==============================================================================
# ** Game_Battler
#==============================================================================
class Game_Battler
  attr_accessor :only_flash_animation
  #--------------------------------------------------------------------------
  unless @already_initialised_screen_anim
    alias initialize_screen_anim initialize
    @already_initialised_screen_anim = true
  end
  #--------------------------------------------------------------------------
  def initialize
    initialize_screen_anim
    only_flash_animation = false
  end
end
#==============================================================================
# ** Sprite_Battler
#==============================================================================
class Sprite_Battler < RPG::Sprite
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    # If battler is nil
    if @battler == nil
      self.bitmap = nil
      loop_animation(nil)
      return
    end
    # If file name or hue are different than current ones
    if @battler.battler_name != @battler_name or
       @battler.battler_hue != @battler_hue
      # Get and set bitmap
      @battler_name = @battler.battler_name
      @battler_hue = @battler.battler_hue
      self.bitmap = RPG::Cache.battler(@battler_name, @battler_hue)
      @width = bitmap.width
      @height = bitmap.height
      self.ox = @width / 2
      self.oy = @height
      # Change opacity level to 0 when dead or hidden
      if @battler.dead? or @battler.hidden
        self.opacity = 0
      end
    end
    # If animation ID is different than current one
    if @battler.damage == nil and
       @battler.state_animation_id != @state_animation_id
      @state_animation_id = @battler.state_animation_id
      loop_animation($data_animations[@state_animation_id])
    end
    # If actor which should be displayed
    if @battler.is_a?(Game_Actor) and @battler_visible
      # Bring opacity level down a bit when not in main phase
      if $game_temp.battle_main_phase
        self.opacity += 3 if self.opacity < 255
      else
        self.opacity -= 3 if self.opacity > 207
      end
    end
    # Blink
    if @battler.blink
      blink_on
    else
      blink_off
    end
    # If invisible
    unless @battler_visible
      # Appear
      if not @battler.hidden and not @battler.dead? and
         (@battler.damage == nil or @battler.damage_pop)
        appear
        @battler_visible = true
      end
    end
    # If visible
    if @battler_visible
      # Escape
      if @battler.hidden
        $game_system.se_play($data_system.escape_se)
        escape
        @battler_visible = false
      end
      # White flash
      if @battler.white_flash
        whiten
        @battler.white_flash = false
      end
      # Animation
      if @battler.animation_id != 0
        animation = $data_animations[@battler.animation_id]
        if @battler.only_flash_animation
          animation_flash(animation, @battler.animation_hit)
          @battler.only_flash_animation = false
        else
          animation(animation, @battler.animation_hit)
        end
        @battler.animation_id = 0
      end
      # Damage
      if @battler.damage_pop
        if @battler.damage_spf
                  @oldc = self.color.dup
                  damage(@battler.damage, @battler.critical, true)
                else
                  damage(@battler.damage, @battler.critical)
                end
        @battler.damage_spf = nil if @battler.damage_spf        
        @battler.damage = nil
        @battler.critical = false
        @battler.damage_pop = false
      end
      # Collapse
      if @battler.damage == nil and @battler.dead?
        if @battler.is_a?(Game_Enemy)
          $game_system.se_play($data_system.enemy_collapse_se)
        else
          $game_system.se_play($data_system.actor_collapse_se)
        end
        collapse
        @battler_visible = false
      end
    end
    # Set sprite coordinates
    self.x = @battler.screen_x
    self.y = @battler.screen_y
    self.z = @battler.screen_z
  end
end
#==============================================================================
# ** RPG::Sprite
#==============================================================================
module RPG
  class Sprite < ::Sprite
    #----SP Color stuff----
    def damage(value, critical, spfrom = false)
          dispose_damage
          if value.is_a?(Numeric)
                damage_string = value.abs.to_s
          else
                damage_string = value.to_s
          end
          bitmap = Bitmap.new(160, 48)
          bitmap.font.name = "Arial Black"
          bitmap.font.size = 32
          bitmap.font.color.set(0, 0, 0)
          bitmap.draw_text(-1, 12-1, 160, 36, damage_string, 1)
          bitmap.draw_text(+1, 12-1, 160, 36, damage_string, 1)
          bitmap.draw_text(-1, 12+1, 160, 36, damage_string, 1)
          bitmap.draw_text(+1, 12+1, 160, 36, damage_string, 1)
          if value.is_a?(Numeric) and value < 0
                bitmap.font.color.set(176, 255, 144)
          else
                bitmap.font.color.set(255, 255, 255)
          end
          if spfrom
                bitmap.font.color.set(SP_COLOR.red, SP_COLOR.green, SP_COLOR.blue)
          end
          bitmap.draw_text(0, 12, 160, 36, damage_string, 1)
          if critical
                bitmap.font.size = 20
                bitmap.font.color.set(0, 0, 0)
                bitmap.draw_text(-1, -1, 160, 20, "CRITICAL", 1)
                bitmap.draw_text(+1, -1, 160, 20, "CRITICAL", 1)
                bitmap.draw_text(-1, +1, 160, 20, "CRITICAL", 1)
                bitmap.draw_text(+1, +1, 160, 20, "CRITICAL", 1)
                bitmap.font.color.set(255, 255, 255)
                bitmap.draw_text(0, 0, 160, 20, "CRITICAL", 1)
          end
          @_damage_sprite = ::Sprite.new(self.viewport)
          @_damage_sprite.bitmap = bitmap
          @_damage_sprite.ox = 80
          @_damage_sprite.oy = 20
          @_damage_sprite.x = self.x
          @_damage_sprite.y = self.y - self.oy / 2
          @_damage_sprite.z = 3000
          @_damage_duration = 40
        end
    #-------------------------------------------------------------------------
    unless @already_initialised_screen_anim
      alias animation_screen_anim animation
      alias update_animation_screen_anim update_animation
      @already_initialised_screen_anim = true
    end
    #-------------------------------------------------------------------------
    def animation(animation, hit)
      @_flash = false
      animation_screen_anim(animation, hit)
    end
    #-------------------------------------------------------------------------
    def update_animation
      unless @_flash
        update_animation_screen_anim
      else
        update_animation_flash
      end
    end
    #-------------------------------------------------------------------------
    def animation_flash(animation, hit)
      @_flash = true
      dispose_animation
      @_animation = animation
      return if @_animation == nil
      @_animation_hit = hit
      @_animation_duration = @_animation.frame_max
      animation_name = @_animation.animation_name
      animation_hue = @_animation.animation_hue
      @_animation_sprites = []
      update_animation
    end
    #-------------------------------------------------------------------------
    def update_animation_flash
      if @_animation_duration > 0
        frame_index = @_animation.frame_max - @_animation_duration
        cell_data = @_animation.frames[frame_index].cell_data
        position = @_animation.position
        animation_set_sprites(@_animation_sprites, cell_data, position)
        for timing in @_animation.timings
          if timing.frame == frame_index
            animation_process_timing_flash(timing, @_animation_hit)
          end
        end
      else
        dispose_animation
      end
    end
    #-------------------------------------------------------------------------
    def animation_process_timing_flash(timing, hit)
      if (timing.condition == 0) or
         (timing.condition == 1 and hit == true) or
         (timing.condition == 2 and hit == false)
        case timing.flash_scope
        when 1
          self.flash(timing.flash_color, timing.flash_duration * 2)
        when 2
          if self.viewport != nil
            self.viewport.flash(timing.flash_color, timing.flash_duration * 2)
          end
        when 3
          self.flash(nil, timing.flash_duration * 2)
        end
      end
    end
  end
end

Segunda parte:
Código:
class Game_Battler
  attr_accessor :damage_spf
  #--------------------------------------------------------------------------
  # * Application of Item Effects
  #      item : item
  #--------------------------------------------------------------------------
  def item_effect(item)
        # Clear critical flag
        self.critical = false
        # If item scope is for ally with 1 or more HP, and your own HP = 0,
        # or item scope is for ally with 0 HP, and your own HP = 1 or more
        if ((item.scope == 3 or item.scope == 4) and self.hp == 0) or
           ((item.scope == 5 or item.scope == 6) and self.hp >= 1)
          # End Method
          return false
        end
        # Clear effective flag
        effective = false
        # Set effective flag if common ID is effective
        effective |= item.common_event_id > 0
        # Determine hit
        hit_result = (rand(100) < item.hit)
        # Set effective flag is skill is uncertain
        effective |= item.hit < 100
        # If hit occurs
        if hit_result == true
          # Calculate amount of recovery
          recover_hp = maxhp * item.recover_hp_rate / 100 + item.recover_hp
          recover_sp = maxsp * item.recover_sp_rate / 100 + item.recover_sp
          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
          # Element correction
          recover_hp *= elements_correct(item.element_set)
          recover_hp /= 100
          recover_sp *= elements_correct(item.element_set)
          recover_sp /= 100
          # Dispersion
          if item.variance > 0 and recover_hp.abs > 0
                amp = [recover_hp.abs * item.variance / 100, 1].max
                recover_hp += rand(amp+1) + rand(amp+1) - amp
          end
          if item.variance > 0 and recover_sp.abs > 0
                amp = [recover_sp.abs * item.variance / 100, 1].max
                recover_sp += rand(amp+1) + rand(amp+1) - amp
          end
          # If recovery code is negative
          if recover_hp < 0
                # Guard correction
                if self.guarding?
                  recover_hp /= 2
                end
          end
          # Set damage value and reverse HP recovery amount
          self.damage = -recover_hp
          if recover_hp == 0
                @damage_spf = true
                self.damage = -recover_sp
          end
          # HP and SP recovery
          last_hp = self.hp
          last_sp = self.sp
          self.hp += recover_hp
          self.sp += recover_sp
          effective |= self.hp != last_hp
          effective |= self.sp != last_sp
          # State change
          @state_changed = false
          effective |= states_plus(item.plus_state_set)
          effective |= states_minus(item.minus_state_set)
          # If parameter value increase is effective
          if item.parameter_type > 0 and item.parameter_points != 0
                # Branch by parameter
                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
                # Set to effective flag
                effective = true
          end
          # If HP recovery rate and recovery amount are 0
          if (item.recover_hp_rate == 0 and item.recover_hp == 0) &&
                (item.recover_sp_rate == 0 and item.recover_sp == 0)
                # Set damage to empty string
                self.damage = ""
                # If SP recovery rate / recovery amount are 0, and parameter increase
                # value is ineffective.
                if item.recover_sp_rate == 0 and item.recover_sp == 0 and
                   (item.parameter_type == 0 or item.parameter_points == 0)
                  # If state is unchanged
                  unless @state_changed
                        # Set damage to "Miss"
                        self.damage = "Miss"
                  end
                end
          end
        # If miss occurs
        else
          # Set damage to "Miss"
          self.damage = "Miss"
        end
        # If not in battle
        unless $game_temp.in_battle
          # Set damage to nil
          self.damage = nil
        end
        # End Method
        return effective
  end
end

Notas:

- No recuerdo donde encontré este script y el nombre del autor no aparece en ninguna parte. Si alguien lo reconoce, que por favor lo mencione para darle el crédito que merece.
- Noté un pequeño error: si usas un item que recupera HP y SP, sólo el HP recuperado va a aparecer. Supongo que una cuestión de prioridades en la configuración del XP.
avatar
Lance Amano
Soñador
Soñador

0/3

Créditos 218

Gracias : 23

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.