Mundo Maker
¡Bienvenid@ a Mundo Maker!

¿Quieres aprender todo sobre el RPG Maker?



Regístrate y forma parte de Mundo Maker.
Conectarse

Recuperar mi contraseña

Temas importantes
----------------------------------------
Páginas con recursos RPG Maker
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
Afiliados
Estadísticas
Tenemos 3763 miembros registrados.
El último usuario registrado es Carlos Rodriguez.

Nuestros miembros han publicado un total de 85782 mensajes en 12216 argumentos.

[RMXP] Number Flood v0.5a

Ver el tema anterior Ver el tema siguiente Ir abajo

RPG Maker XP [RMXP] Number Flood v0.5a

Mensaje por silvanash el 2017-01-08, 16:52

Number Flood es una herramienta de scripter que permite mostrar múltiples mensajes de daño sobre el mismo sprite. Su utilidad inmediata es permitir mostrar varios efectos sobre el mismo actor; por ejemplo, mostrar veneno y curación en un mismo turno debido a estados alterados que causen ambos efectos. El sistema por default del Maker, y el que usan muchos makeros, es crear un valor final sumando el veneno y la curación y mostrar una sola animación de daño con ese valor. Number Flood permite mostrar esos daños por separado y con mensajes personalizados, para que el jugador sepa qué está pasando.

Number Flood
Código:
# Number Flood v0.5a
# silvanash

# Number Flood is a modification of RPG::Sprite, Sprite_Battler, Game_Battler
# and Scene_Battle that allows showing multiple damage displays on the same sprite

# v0.4 fixed lots of bugs and made the system easier to handle
# v0.4.1 fixed some small bugs
# v0.4.1b added colored status changes
# v0.5a attempted to merge the script with the damage delay from Wecoc

module SLV_Number_Flood_Config
 
  # Set to higher values to increase delay between damage displays
  #EXTRA_FRAMES = 18
  # Message displayed when the [Attack] produces a crit
  CRITICAL = "CRITICAL"
  # Message displayed when an attacks/skill misses
  MISS = "MISS"
  # Message displayed for status changes with 0 damage
  STATUS = "STATUS"
 
  PLUS_STATES = {
    # State_ID => [RED, GREEN, BLUE],
    3 => [255, 128, 128],
  }
 
  MINUS_STATES = {
    # State_ID => [RED, GREEN, BLUE],
    3 => [64, 64, 64],
  }
 
end

module RPG

  class Sprite < ::Sprite

    alias slv_init initialize unless $@
 
    def initialize(viewport = nil)
      slv_init(viewport)
      @_damage_sprites = []
      @_critical_sprites = []
      @_damage_duration = []
      @_damage_amount = -1
    end
 
    #Creates and stores a damage sprite
    def damage(hash)
      # Returns if Number Flood was called with nil damage
      return if hash[:value].nil?
      value = hash[:value]
      critical = hash[:crit]
      color = hash[:color]
      if value.is_a?(Numeric)
        damage_string = value.abs.to_s
      else
        damage_string = value.to_s
      end
      font_name = "Arial Black"
      font_size = 32
      damage_sprites = []
      bitmap = Bitmap.new(1, 1)
      damage_width = bitmap.text_size(damage_string).width
      for i in 0...damage_string.size
        sprite = ::Sprite.new(self.viewport)
        bitmap.font.name = font_name
        bitmap.font.size = font_size
        w = bitmap.text_size(damage_string[i].chr).width + 2
        h = bitmap.text_size(damage_string[i].chr).height + 2
        sprite.bitmap = Bitmap.new(w, h)
        sprite.bitmap.font.name = font_name
        sprite.bitmap.font.size = font_size
        sprite.bitmap.font.color.set(0, 0, 0)
        sprite.bitmap.draw_text(-1, -1, w, h, damage_string[i].chr, 1)
        sprite.bitmap.draw_text(+1, -1, w, h, damage_string[i].chr, 1)
        sprite.bitmap.draw_text(-1, +1, w, h, damage_string[i].chr, 1)
        sprite.bitmap.draw_text(+1, +1, w, h, damage_string[i].chr, 1)
        if value.is_a?(Numeric) and value < 0
          sprite.bitmap.font.color.set(176, 255, 144)
        else
          if color.nil?
            sprite.bitmap.font.color.set(255, 255, 255)
          else
            sprite.bitmap.font.color.set(color)
          end
        end
        sprite.bitmap.draw_text(0, 0, w, h, damage_string[i].chr, 1)
        damage_sprites.push(sprite)
      end
      if !critical.nil?
        critical = critical.to_s
        sprite = ::Sprite.new(self.viewport)
        bitmap = Bitmap.new(1, 1)
        bitmap.font.name = font_name
        bitmap.font.size = font_size
        #critical_width = bitmap.text_size(critical).width
        w = bitmap.text_size(critical).width + 2
        h = bitmap.text_size(critical).height + 2
        sprite.bitmap = Bitmap.new(w, h)
        sprite.bitmap.font.name = font_name
        sprite.bitmap.font.size = 16
        sprite.bitmap.font.color.set(0, 0, 0)
        sprite.bitmap.draw_text(-1, -1, w, h, critical, 1)
        sprite.bitmap.draw_text(+1, -1, w, h, critical, 1)
        sprite.bitmap.draw_text(-1, +1, w, h, critical, 1)
        sprite.bitmap.draw_text(+1, +1, w, h, critical, 1)
        sprite.bitmap.font.color.set(255, 255, 255)
        sprite.bitmap.draw_text(0, 0, w, h, critical, 1)
        if color.nil?
        sprite. bitmap.font.color.set(255, 255, 255)
        else
          sprite.bitmap.font.color.set(color)
        end
        sprite.bitmap.draw_text(0, 0, w, h, critical, 1)
        sprite.x = self.x - w / 2
        sprite.y = self.y - self.oy / 2 - 32
        sprite.z = 3000
        sprite.visible = false
        @_critical_sprites.push(sprite)
      else
        @_critical_sprites.push(nil)
      end
      # Sprite positions
      dx = 0
      for i in 0...damage_sprites.size
        damage_sprites[i].x = self.x - damage_width / 2 + dx
        dx += damage_sprites[i].bitmap.width - 2
        damage_sprites[i].y = self.y - self.oy / 2 - 16
        damage_sprites[i].z = 3000
        damage_sprites[i].visible = false
      end
      @_damage_sprites.push(damage_sprites)
      d = damage_sprites.size * 20
      @_damage_duration.push(d)
      @_damage_amount = @_damage_sprites.size - 1
    end
 
    #Disposes all stored damage sprites
    def dispose_damage
      for ary in @_damage_sprites
        for sprite in ary
          sprite.bitmap.dispose
          sprite.dispose
        end
      end
      @_damage_sprites.clear
      for sprite in @_critical_sprites
        next if sprite.nil?
        sprite.bitmap.dispose
        sprite.dispose
      end
      @_critical_sprites.clear
      @_damage_duration.clear
      @_damage_amount = -1
    end
 
    def damage_active?
      return @_damage_amount > -1
    end

    def update
      super
      if @_whiten_duration > 0
        @_whiten_duration -= 1
        self.color.alpha = 128 - (16 - @_whiten_duration) * 10
      end
      if @_appear_duration > 0
        @_appear_duration -= 1
        self.opacity = (16 - @_appear_duration) * 16
      end
      if @_escape_duration > 0
        @_escape_duration -= 1
        self.opacity = 256 - (32 - @_escape_duration) * 10
      end
      if @_collapse_duration > 0
        @_collapse_duration -= 1
        self.opacity = 256 - (48 - @_collapse_duration) * 6
      end
      if @_animation != nil and (Graphics.frame_count % 2 == 0)
        @_animation_duration -= 1
        update_animation
      end
      if @_loop_animation != nil and (Graphics.frame_count % 2 == 0)
        update_loop_animation
        @_loop_animation_index += 1
        @_loop_animation_index %= @_loop_animation.frame_max
      end
      if @_blink
        @_blink_count = (@_blink_count + 1) % 32
        if @_blink_count < 16
          alpha = (16 - @_blink_count) * 6
        else
          alpha = (@_blink_count - 16) * 6
        end
        self.color.set(255, 255, 255, alpha)
      end
      @@_animations.clear
      if @_damage_sprites.size > 0
        update_damage(0)
        if @_damage_duration[0] <= 0
          # This damage was updated; delete it
          for sprite in @_damage_sprites[0]
            sprite.bitmap.dispose
            sprite.dispose
          end
          @_damage_sprites.delete_at(0)
          @_damage_sprites.compact!
          @_damage_duration.delete_at(0)
          @_critical_sprites.delete_at(0)
          @_damage_amount -= 1
        end
      end
    end
   
    def update_damage(i)
      return if @_damage_duration[i] <= 0
      if @_damage_duration[i] > 0
        index = @_damage_sprites[i].size * 20 - @_damage_duration[i]
        @_damage_duration[i] -= 1
        if index < @_damage_sprites[i].size
          @_damage_sprites[i][index].visible = true
        end
        for j in 0...@_damage_sprites[i].size
          next if @_damage_sprites[i][j].visible == false
          case (index - j)
          when 0..3
            @_damage_sprites[i][j].y -= 4
          when 4..7
            @_damage_sprites[i][j].y -= 2
          when 8..10
            @_damage_sprites[i][j].y += 2
          when 11..15
            @_damage_sprites[i][j].y += 4
          end
          if (index - j) > 1
            @_damage_sprites[i][j].opacity = 256 - (12 - @_damage_duration[i]) * 32
          else
            @_damage_sprites[i][j].opacity = 128
          end
        end
        if !@_critical_sprites[i].nil?
          @_critical_sprites[i].visible = true
          case index
          when 0..3
            @_critical_sprites[i].y -= 4
          when 4..7
            @_critical_sprites[i].y -= 2
          when 8..10
            @_critical_sprites[i].y += 2
          when 11..15
            @_critical_sprites[i].y += 4   
          end
          @_critical_sprites[i].opacity = 256 - (12 - @_damage_duration[i]) * 32
        end
      end
    end
   
    def effect?
      @_whiten_duration > 0 or
      @_appear_duration > 0 or
      @_escape_duration > 0 or
      @_collapse_duration > 0 or
      @_damage_amount > -1 or
      @_animation_duration > 0
    end

  end

end

class Sprite_Battler < RPG::Sprite
 
  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.damaged? 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.damaged? 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]
        animation(animation, @battler.animation_hit)
        @battler.animation_id = 0
      end
      # Damage
      if @battler.damage_pop
        if !@battler.main_damage.nil?
          damage(@battler.main_damage)
        end
        @battler.main_damage = nil
        for item in @battler.damages
          damage(item)
        end
        @battler.damage_pop = false
        @battler.damages = []
      end
      # Collapse
      if !@battler.damaged? 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

class Game_Battler
 
  alias slv_initialize initialize unless $@
 
 
  attr_accessor :main_damage
  attr_accessor :damages
 
  def initialize
    slv_initialize
    # Main damage stores the first move that hit the actor
    @main_damage = nil
    # Damages stores all the secondary damage displays
    @damages = []
  end

  #--------------------------------------------------------------------------
  # * Applying Normal Attack Effects
  #    attacker : battler
  #--------------------------------------------------------------------------
  def attack_effect(attacker)
    # Clear critical flag
    # First hit detection
    hit_result = (rand(100) < attacker.hit)
    # If hit occurs
    if hit_result == true
      # Calculate basic damage
      atk = [attacker.atk - self.pdef / 2, 0].max
      damage = atk * (20 + attacker.str) / 20
      # Element correction
      damage *= elements_correct(attacker.element_set)
      damage /= 100
      # If damage value is strictly positive
      crit = nil
      if damage > 0
        # Critical correction
        if rand(100) < 4 * attacker.dex / self.agi
          damage *= 2
          crit = SLV_Number_Flood_Config::CRITICAL
        end
        # Guard correction
        if self.guarding?
          damage /= 2
        end
      end
      # Dispersion
      if damage.abs > 0
        amp = [damage.abs * 15 / 100, 1].max
        damage += rand(amp+1) + rand(amp+1) - amp
      end
      # Second hit detection
      eva = 8 * self.agi / attacker.dex + self.eva
      hit = damage < 0 ? 100 : 100 - eva
      hit = self.cant_evade? ? 100 : hit
      hit_result = (rand(100) < hit)
    end
    # If hit occurs
    if hit_result == true
      # State Removed by Shock
      remove_states_shock
      # Substract damage from HP
      self.hp -= damage
      # State change
      @state_changed = false
      states_plus(attacker.plus_state_set)
      states_minus(attacker.minus_state_set)
      @main_damage = {:value => damage, :crit => crit,}
    # When missing
    else
      # Set damage to "Miss"
      @main_damage = {:value => SLV_Number_Flood_Config::MISS}
    end
    # End Method
    return true
  end
  #--------------------------------------------------------------------------
  # * Apply Skill Effects
  #    user  : the one using skills (battler)
  #    skill : skill
  #--------------------------------------------------------------------------
  def skill_effect(user, skill)
    # If skill scope is for ally with 1 or more HP, and your own HP = 0,
    # or skill scope is for ally with 0, and your own HP = 1 or more
    if ((skill.scope == 3 or skill.scope == 4) and self.hp == 0) or
      ((skill.scope == 5 or skill.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 |= skill.common_event_id > 0
    # First hit detection
    hit = skill.hit
    if skill.atk_f > 0
      hit *= user.hit / 100
    end
    hit_result = (rand(100) < hit)
    # Set effective flag if skill is uncertain
    effective |= hit < 100
    # If hit occurs
    if hit_result == true
      # Calculate power
      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
      # Calculate rate
      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)
      # Calculate basic damage
      damage = power * rate / 20
      # Element correction
      damage *= elements_correct(skill.element_set)
      damage /= 100
      # If damage value is strictly positive
      if damage > 0
        # Guard correction
        if self.guarding?
          damage /= 2
        end
      end
      # Dispersion
      if skill.variance > 0 and damage.abs > 0
        amp = [damage.abs * skill.variance / 100, 1].max
        damage += rand(amp+1) + rand(amp+1) - amp
      end
      # Second hit detection
      eva = 8 * self.agi / user.dex + self.eva
      hit = damage < 0 ? 100 : 100 - eva * skill.eva_f / 100
      hit = self.cant_evade? ? 100 : hit
      hit_result = (rand(100) < hit)
      # Set effective flag if skill is uncertain
      effective |= hit < 100
    end
    # If hit occurs
    if hit_result == true
      # If physical attack has power other than 0
      if skill.power != 0 and skill.atk_f > 0
        # State Removed by Shock
        remove_states_shock
        # Set to effective flag
        effective = true
      end
      # Substract damage from HP
      last_hp = self.hp
      self.hp -= damage
      effective |= self.hp != last_hp
      # State change
      @state_changed = false
      effective |= states_plus(skill.plus_state_set)
      effective |= states_minus(skill.minus_state_set)
      #@main_damage = [damage]
      @main_damage = {:value => damage,}
      # If power is 0
      if skill.power == 0
        # Set damage to an empty string
        #@main_damage = [0]
        @main_damage = {:value => 0,}
        # If state is unchanged
        unless @state_changed
          # Set damage to "Miss"
          #@main_damage = [SLV_Number_Flood_Config::MISS]
          @main_damage = {:value => SLV_Number_Flood_Config::MISS,}
        end
      end
    # If miss occurs
    else
      # Set damage to "Miss"
      #@main_damage = [SLV_Number_Flood_Config::MISS]
      @main_damage = {:value => SLV_Number_Flood_Config::MISS,}
    end
    # If not in battle
    unless $game_temp.in_battle
      # Set damage to nil
      #@main_damage = []
      @main_damage = nil
    end
    # End Method
    return effective
  end
  #--------------------------------------------------------------------------
  # * 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
      damage = -recover_hp
      # 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
      #@main_damage = [damage]
      @main_damage = {:value => damage,}
      # If HP recovery rate and recovery amount are 0
      if item.recover_hp_rate == 0 and item.recover_hp == 0
        # 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
          if @state_changed
            # Set damage to "Miss"
            #@main_damage = ["", SLV_Number_Flood_Config::STATUS]
            @main_damage = {:value => SLV_Number_Flood_Config::STATUS,}
          else
            #@main_damage = [SLV_Number_Flood_Config::MISS]
            @main_damage = {:value => SLV_Number_Flood_Config::MISS,}
          end
        end
      end
    # If miss occurs
    else
      # Set damage to "Miss"
      #@main_damages = [SLV_Number_Flood_Config::MISS]
      @main_damage = {:value => SLV_Number_Flood_Config::MISS,}
    end
    # If not in battle
    unless $game_temp.in_battle
      # Set damage to nil
      #@main_damage = []
      @main_damage = nil
    end
    # End Method
    return effective
  end
  #--------------------------------------------------------------------------
  # * Application of Slip Damage Effects
  #--------------------------------------------------------------------------
  def slip_damage_effect
    # Set damage
    damage = self.maxhp / 10
    # Dispersion
    if damage.abs > 0
      amp = [damage.abs * 15 / 100, 1].max
      damage += rand(amp+1) + rand(amp+1) - amp
    end
    # Subtract damage from HP
    self.hp -= damage
    #@damages.push([damage])
    @damages.push({:value => damage,})
    # End Method
    return true
  end
 
  def damage
    # Returns the value of the primary move that hit the actor
    # This value is used for calculations that require the main damage value
    if @main_damage.nil? or !@main_damage[:value].is_a?(Numeric)
      # Main damage doesn't exist or isn't a number
      return nil
    end
    return @main_damage[:value]
  end
 
  def damaged?
    r = false
    r = true if !@main_damage.nil?
    r = true if @damages.size > 0
    return r
  end
 
  #--------------------------------------------------------------------------
  # * Add State
  #    state_id : state ID
  #    force    : forcefully added flag (used to deal with auto state)
  #--------------------------------------------------------------------------
  def add_state(state_id, force = false)
    # For an ineffective state
    if $data_states[state_id] == nil
      # End Method
      return
    end
    # If not forcefully added
    unless force
      # A state loop already in existance
      for i in @states
        # If a new state is included in the state change (-) of an existing
        # state, and that state is not included in the state change (-) of
        # a new state (example: an attempt to add poison during dead)
        if $data_states[i].minus_state_set.include?(state_id) and
          not $data_states[state_id].minus_state_set.include?(i)
          # End Method
          return
        end
      end
    end
    # If this state is not added
    unless state?(state_id)
      # Add state ID to @states array
      @states.push(state_id)
      if SLV_Number_Flood_Config::PLUS_STATES.has_key?(state_id) and $game_temp.in_battle
        @damages.push({:value => "+" + $data_states[state_id].name,
        :color => SLV_Number_Flood_Config::PLUS_STATES[state_id]})
      end
      # If option [regarded as HP 0]is effective
      if $data_states[state_id].zero_hp
        # Change HP to 0
        @hp = 0
      end
      # All state loops
      for i in 1...$data_states.size
        # Dealing with a state change (+)
        if $data_states[state_id].plus_state_set.include?(i)
          add_state(i)
        end
        # Dealing with a state change (-)
        if $data_states[state_id].minus_state_set.include?(i)
          remove_state(i)
        end
      end
      # line change to a large rating order (if value is the same, then a
      # strong restriction order)
      @states.sort! do |a, b|
        state_a = $data_states[a]
        state_b = $data_states[b]
        if state_a.rating > state_b.rating
          -1
        elsif state_a.rating < state_b.rating
          +1
        elsif state_a.restriction > state_b.restriction
          -1
        elsif state_a.restriction < state_b.restriction
          +1
        else
          a <=> b
        end
      end
    end
    # If added forcefully
    if force
      # Set the natural removal's lowest number of turns to -1
      @states_turn[state_id] = -1
    end
    # If not added forcefully
    unless  @states_turn[state_id] == -1
      # Set the natural removal's lowest number of turns
      @states_turn[state_id] = $data_states[state_id].hold_turn
    end
    # If unable to move
    unless movable?
      # Clear action
      @current_action.clear
    end
    # Check the maximum value of HP and SP
    @hp = [@hp, self.maxhp].min
    @sp = [@sp, self.maxsp].min
  end
  #--------------------------------------------------------------------------
  # * Remove State
  #    state_id : state ID
  #    force    : forcefully removed flag (used to deal with auto state)
  #--------------------------------------------------------------------------
  def remove_state(state_id, force = false)
    # If this state is added
    if state?(state_id)
      # If a forcefully added state is not forcefully removed
      if @states_turn[state_id] == -1 and not force
        # End Method
        return
      end
      # If current HP is at 0 and options are effective [regarded as HP 0]
      if @hp == 0 and $data_states[state_id].zero_hp
        # Determine if there's another state [regarded as HP 0] or not
        zero_hp = false
        for i in @states
          if i != state_id and $data_states[i].zero_hp
            zero_hp = true
          end
        end
        # Change HP to 1 if OK to remove incapacitation.
        if zero_hp == false
          @hp = 1
        end
      end
      # Delete state ID from @states and @states_turn hash array
      @states.delete(state_id)
      @states_turn.delete(state_id)
      if SLV_Number_Flood_Config::MINUS_STATES.has_key?(state_id) and $game_temp.in_battle
        @damages.push({:value => "-" + $data_states[state_id].name,
        :color => SLV_Number_Flood_Config::MINUS_STATES[state_id]})
      end
    end
    # Check maximum value for HP and SP
    @hp = [@hp, self.maxhp].min
    @sp = [@sp, self.maxsp].min
  end
 
end

class Scene_Battle
 
  alias slv_update update unless $@
 
  def update
    slv_update
    if @phase == 6
      update_phase6
    end
  end
 
  def update_phase6
    # Phase 6 is executed after phase 4 ends
    # It's used to proc after turn mass effects
    start_phase2
  end
 
  def update_phase4_step1
    # Hide help window
    @help_window.visible = false
    # Determine win/loss
    if judge
      # If won, or if lost : end method
      return
    end
    # If an action forcing battler doesn't exist
    if $game_temp.forcing_battler == nil
      # Set up battle event
      setup_battle_event
      # If battle event is running
      if $game_system.battle_interpreter.running?
        return
      end
    end
    # If an action forcing battler exists
    if $game_temp.forcing_battler != nil
      # Add to head, or move
      @action_battlers.delete($game_temp.forcing_battler)
      @action_battlers.unshift($game_temp.forcing_battler)
    end
    # If no actionless battlers exist (all have performed an action)
    if @action_battlers.size == 0
      # Start party command phase
      @phase = 6
      return
    end
    # Initialize animation ID and common event ID
    @animation1_id = 0
    @animation2_id = 0
    @common_event_id = 0
    # Shift from head of actionless battlers
    @active_battler = @action_battlers.shift
    # If already removed from battle
    if @active_battler.index == nil
      return
    end
    # Slip damage
    if @active_battler.hp > 0 and @active_battler.slip_damage?
      @active_battler.slip_damage_effect
      @active_battler.damage_pop = true
    end
    # Natural removal of states
    @active_battler.remove_states_auto
    # Refresh status window
    @status_window.refresh
    # Shift to step 2
    @phase4_step = 2
  end
 
  def update_phase4_step4
    # Animation for target
    for target in @target_battlers
      target.animation_id = @animation2_id
      target.animation_hit = target.damaged?
    end
    # Animation has at least 8 frames, regardless of its length
    @wait_count = 8
    # Shift to step 5
    @phase4_step = 5
  end
 
  def update_phase4_step5
    # Hide help window
    @help_window.visible = false
    # Refresh status window
    @status_window.refresh
    # Display damage
    for target in @target_battlers
      target.damage_pop = target.damaged?
    end
    # Shift to step 6
    @phase4_step = 7
  end
 
  alias slv_update_phase4 update_phase4 unless $@
 
  def update_phase4
  slv_update_phase4
    case @phase4_step
    when 7
      update_phase4_step7
    end
  end
 
  def update_phase4_step7
    @phase4_step = 6
  end

end

Instrucciones:

Copy-pastear el script a la base de datos. Number Flood es una herramienta para scripters, lo que significa que la gente que no sepa de scripts no le sacará mucho provecho.

Las versiones anteriores a la 0.5 usaban arrays. Las versiones posteriores usan hashes. Todos los battlers tienen dos nuevos parámetros, que son @main_damage y @damages.

@main_damage vale nil por default, y cuando se le mandan valores, se usa una hash que se configura tal que así:

Código:
battler.main_damage = {:value => something, :crit => "text", :color => [R, G, B]}

Las llamadas de script para mandar los daños adicionales se hacen a "damages" en lugar de a "damage":
Código:
battler.damages.push({:value => something, :crit => "text", :color => [R, G, B]}


:value es el valor del daño, sea en Numeric o un String.
:crit es un parámetro opcional que sirve para mostrar mensajes adicionales. El ataque normal muestra la palabra "CRITICAL" cuando el ataque hace un crítico, pero se pueden hacer llamadas usando "Veneno" como :crit, para decirle al jugador que su personaje acaba de sufrir daño por veneno.
:color es un parámetro opcional añadido en la versión 0.4.1b que define un color específico para el texto mostrado. El sistema lo usa en la configuración inicial para dar color a ciertos mensajes de estados añadidos/quitados. Son los PLUS_STATES y MINUS_STATES del principio.

Nota: cualquier llamada a daño DEBE tener :value definido. Una llamada a Number Flood que sólo tenga :crit no servirá para nada porque el sistema ignora esas llamadas.

Notas sobre la versión 0.4.1b: PLUS_STATES y MINUS_STATES es un feature en fase de prueba. En principio funciona correctamente, pero no puedo asegurar que no ocurran cosas raras porque no eran parte del diseño inicial del sistema.

"actor.damage" devuelve el último daño recibido por un ataque normal/habilidad, objeto, para recuperar el funcionamiento normal de los battlers en ese aspecto. Esto permite que los add-ons de Wecocio sean más fáciles de adaptar, porque muchos de ellos basan sus efectos en el último daño recibido por el objetivo del ataque/habilidad/estado. "actor.damage" no guarda ningún otro valor del Number Flood. La animación de daño por el veneno se guarda en "damages", pero no en "damage".

"actor.damaged?" devuelve true si main_damage o damages tiene algún elemento dentro, independientemente de su valor.

Number Flood modifica las fases estándar de la batalla para poder procesar sus efectos adicionales. Después de phase_4_step5, Number Flood ejecuta un phase_4_step7. Ese step7, por default, simplemente devuelve la escena a su lugar normal, con un @phase4_step = 6. En el step7 se pueden ejecutar código y animaciones que salgan después de que se haya ejecutado la animación de daño sobre el objetivo. Esto permite ejecutar efectos de "Recuperar SPs" al matar, por ejemplo.

Nota: un ataque/habilidad que falle devolverá "nil" como valor de actor.damage. Un ataque/habilidad que haya hecho 0 de daño devolverá "0" como valor de actor.damage. Si se van a hacer add-ons que usen el valor de damage para calcular efectos adicionales, primero hay que asegurarse de que "actor.damage.to_i > 0".

Number Flood viene con un pequeño module config al principio, para arreglar principalmente la separación entre una animación de daño y la siguiente. Una separación entre 18 y 24 es razonable, ni muy rápido ni muy lento.

Si alguien necesita más instrucciones que las indicadas anteriormente, esa persona no debería usar Number Flood.

Intentaré mantener este script y los add-ons que haga tan actualizados como me sea humanamente posible.

Pido créditos por usar Number Flood.


Última edición por silvanash el 2017-05-03, 23:26, editado 13 veces
avatar
silvanash
Aventurero
Aventurero

0/3

Créditos 1627

Gracias : 229

Volver arriba Ir abajo

RPG Maker XP Re: [RMXP] Number Flood v0.5a

Mensaje por silvanash el 2017-01-08, 18:42

Sacar capturas del Number Flood es difícil porque las animaciones casi no se solapan. La idea es que el sistema permite mostrar más de una animación por acción, en lugar de la única animación de daño que hay por default.

Number Flood en batalla:
Spoiler:

Number flood para eventos de mapa:
Spoiler:

Las dos animaciones solapadas es el efecto del Number Flood. La primera captura la saqué con el script de prueba, que hace [Hail] y [Sandstorm].
avatar
silvanash
Aventurero
Aventurero

0/3

Créditos 1627

Gracias : 229

Volver arriba Ir abajo

RPG Maker XP Tips & Tricks de Wecocio adaptados a Number Flood

Mensaje por silvanash el 2017-01-09, 02:58

Cosas de los Tips & Tricks de Wecocio adaptados (y alguno que otro corregido) para funcionar con Number Flood. Algunos de los scripts de Wecocio se ejecutan en fases diferentes a las originales si usas Number Flood.

Para más información sobre qué hace cada Tip & Trick, molestad a Wecocio.

Slip Cure
Código:
#==============================================================================
# ** [XP] Wecoc's Tips & Tricks Battle Collection
#------------------------------------------------------------------------------
# 34. Slip Cure
#------------------------------------------------------------------------------
# Estado similar a Veneno (en batalla) pero que cura en vez de dañar.
# Nota: En las propiedades hay que definirlo como si fuera Veneno
#==============================================================================
# Ported to Number Flood
#==============================================================================

class Game_Battler
  def slip_damage_effect
    #--------------------------------------------------------------------------
    if self.state?(2) # Estado Veneno
      # Fórmula de daño
      damage = self.maxhp / 10
      @damages.push([damage, "Veneno"])
      if damage.abs > 0
        amp = [damage.abs * 15 / 100, 1].max
        damage += rand(amp+1) + rand(amp+1) - amp
      end
      self.hp -= damage
    end
    #--------------------------------------------------------------------------
    if self.state?(3) # Estado Slip Cure
      if defined?(BLACK_BLOOD_ID) != nil && self.state?(BLACK_BLOOD_ID)
        # Fórmula de daño (Black Blood)
        damage = self.maxhp / 10
        @damages.push([damage, "Black blood"])
      else
        # Fórmula de curación
        damage = -self.maxhp / 10
        @damages.push([damage, "Slip cure"])
      end
      if damage.abs > 0
        amp = [damage.abs * 15 / 100, 1].max
        damage += rand(amp+1) + rand(amp+1) - amp
      end
      self.hp -= damage
    end
    #--------------------------------------------------------------------------
    return true
  end
end

Organic Fragment
Código:
#==============================================================================
# ** [XP] Wecoc's Tips & Tricks Battle Collection
#------------------------------------------------------------------------------
# 25. Organic Fragment
#------------------------------------------------------------------------------
# Habilidad que a parte de golpear "marca" al enemigo.
# Hay que atacarlo tres veces seguidas con la habilidad, si no desaparece el
# efecto. Una vez llegada la tercera, causa una gran cantidad de daño.
#------------------------------------------------------------------------------
# Nota: Hay que definir dos Estados alterados distintos
# Ataque 1 - Añade Estado 1 ('Organic Fragment')
# Ataque 2 - Añade Estado 2 ('Organic Complete')
# Ataque 3 - Causa mucho daño
#==============================================================================
# Ported to Number Flood
#==============================================================================

module SLV_Number_Flood_For_Wecoc
  
  # IDs of the skills that trigger [Organic Fragment]
  ORGANIC_FRAGMENT_ID = [81]
  
  ORGANIC_STATE_1 = 15
  
  ORGANIC_STATE_2 = 16
  
end

class Game_Battler

  alias organic_des_skill skill_effect unless $@
  
  def skill_effect(user, skill)
    effective = organic_des_skill(user, skill)
    if SLV_Number_Flood_For_Wecoc::ORGANIC_FRAGMENT_ID.include?(skill.id)
      # Si no tiene ni el Estado 1 ni el Estado 2
      if !self.state?(SLV_Number_Flood_For_Wecoc::ORGANIC_STATE_1) and
        !self.state?(SLV_Number_Flood_For_Wecoc::ORGANIC_STATE_2)
        # Añadir Estado 1
        self.damages.push([1, "Organic Count"])
        add_state(SLV_Number_Flood_For_Wecoc::ORGANIC_STATE_1)
        return true
      end
      # Si tiene el Estado 1
      if self.state?(SLV_Number_Flood_For_Wecoc::ORGANIC_STATE_1)
        #self.damage = "" if self.damage == "Miss"
        # Quitar Estado 1 y añadir Estado 2
        self.damages.push([2, "Organic Count"])
        remove_state(SLV_Number_Flood_For_Wecoc::ORGANIC_STATE_1)
        add_state(SLV_Number_Flood_For_Wecoc::ORGANIC_STATE_2)
        return true
      end
      # Si tiene el Estado 2
      if self.state?(SLV_Number_Flood_For_Wecoc::ORGANIC_STATE_2) and
        !self.damage.nil? && self.damage.to_i > 0
        # Quitar Estado 2 y hacer mucho daño (Definir aquí la fórmula de daño)
        remove_state(SLV_Number_Flood_For_Wecoc::ORGANIC_STATE_2)
        damage_extra = self.damage * 5
        self.damage += damage_extra
        @damages.push([damage_extra, "Organic Smash"])
        return true
      end
    end
    return effective
  end
  
end

Nota: los mensajes que aparecen a medida que se activa la skill son "Organic Counter 1", "Organic Counter " y "Organic Smash [daño]". Si no os gustan, cambiadlos. Si no sabéis cambiarlos, molestad a Wecocio.

Leech Seed
Código:
#==============================================================================
# ** [XP] Wecoc's Tips & Tricks Battle Collection
#------------------------------------------------------------------------------
# 24. Leech Seed
#------------------------------------------------------------------------------
# Skill que causa un estado alterado que hace que cada turno el que hizo la
# skill robe vida al enemigo con el estado. Esa vida robada depende del %HP
# del enemigo, cuanto mayor más vida se roba.
#==============================================================================
# Ported to Number Flood
#==============================================================================

module SLV_Number_Flood_For_Wecoc
 
  # ID of the [Lifeleech] state
  LIFELEECH_ID = 18
 
  # IDs of the skills that can apply the [Lifeleech] status
  LIFELEECH_SKILLS = [81]
 
end

class Game_Battler
  unless $@
    alias leech_seed_ini initialize
    alias leech_seed_skill skill_effect
  end
   
  attr_accessor :leech_seed_attacker
 
  def initialize
    leech_seed_ini
    @leech_seed_attacker = nil
  end
 
  def skill_effect(user, skill)
    effective = leech_seed_skill(user, skill)
    #--------------------------------------------------------------------------
    # Definir aquí el efecto de la Skill
    #--------------------------------------------------------------------------
    if effective and SLV_Number_Flood_For_Wecoc::LIFELEECH_SKILLS.include?(skill.id)
      remove_state(SLV_Number_Flood_For_Wecoc::LIFELEECH_ID)
      add_state(SLV_Number_Flood_For_Wecoc::LIFELEECH_ID)
      @leech_seed_attacker = user
    end
    #--------------------------------------------------------------------------
    return effective
  end
end

class Scene_Battle
  alias update_remove_leach update
  def update
    update_remove_leach
    for target in $game_party.actors + $game_troop.enemies
      next if target.dead?
      #------------------------------------------------------------------------
      # Al morirse el causante del estado, es retirado automáticamente
      #------------------------------------------------------------------------
      if target.state?(SLV_Number_Flood_For_Wecoc::LIFELEECH_ID)
        next if target.leech_seed_attacker == nil
        attacker = target.leech_seed_attacker
        if attacker.dead?
          target.remove_state(SLV_Number_Flood_For_Wecoc::LIFELEECH_ID)
          target.leech_seed_attacker = nil
        end
      end
      #------------------------------------------------------------------------
    end
  end
     
  alias update_leech_seed update_phase6 unless $@
 
  def update_phase6
    for target in $game_party.actors + $game_troop.enemies
      next if target.dead?
      #------------------------------------------------------------------------
      # Definir aquí el efecto del Estado
      #------------------------------------------------------------------------
      if target.state?(SLV_Number_Flood_For_Wecoc::LIFELEECH_ID)
        next if target.leech_seed_attacker == nil
        attacker = target.leech_seed_attacker
        damage = [[target.hp / 4, 10].max, 200].min
        amp = [damage.abs * 15 / 100, 1].max
        damage += rand(amp+1) + rand(amp+1) - amp
        target.damages.push([damage, "Stolen"])
        target.hp -= damage
        target.damage_pop = true
        damage = -damage
        if defined?(Game_Battler::BLACK_BLOOD_ID) != nil
          if target.state?(Game_Battler::BLACK_BLOOD_ID)
            damage = -damage
          end
        end
        attacker.damages.push([damage, "Leeched"])
        attacker.hp -= damage
        attacker.damage_pop = true
      end
      @status_window.refresh
      #------------------------------------------------------------------------
    end
    update_leech_seed
  end
end

Nota: Leech Seed se ejecuta en phase6, añadida con el Number Flood. Esta fase se ejecuta en cuanto todos los atacantes hayan ejecutado sus acciones (lo que vendría a ser el final de phase4 completa).

Flare Gun
Código:
#==============================================================================
# ** [XP] Wecoc's Tips & Tricks Battle Collection
#------------------------------------------------------------------------------
# 21. Flare Gun
#------------------------------------------------------------------------------
# Arma que quema a los enemigos. Eso no les hace demasiado daño pero si vuelves
# a aplicarlo sobre un enemigo ya quemado, le hace mucho más daño.
#==============================================================================
# Ported to Number Flood
#==============================================================================

module SLV_Number_Flood_For_Wecoc
  
  # ID of the [Flaregun] state
  FLAREGUN_STATE = 17
  
  # IDs of the [Flaregun] weapons
  FLAREGUN_WEAPONS = [1]
  
  # ID of the element use for bonus damage
  FLAREGUN_ELEMENT = 1
  
end

class Game_Battler
  alias flare_gun_attack attack_effect unless $@
  def attack_effect(attacker)
    effective = flare_gun_attack(attacker)
    #------------------------------------------------------------------------
    # Definir el efecto del arma de fuego
    #------------------------------------------------------------------------
    if attacker.is_a?(Game_Actor) and
      SLV_Number_Flood_For_Wecoc::FLAREGUN_WEAPONS.include?(attacker.weapon_id)
      if effective && self.damage.to_i > 0
        if self.state?(SLV_Number_Flood_For_Wecoc::FLAREGUN_STATE)
          element = element_rate(SLV_Number_Flood_For_Wecoc::FLAREGUN_ELEMENT)
          damage_extra = self.damage * (200 - element) / 100
          self.damage += damage_extra
          self.hp -= damage_extra
          self.damages.push([damage_extra, "Flare"])
        else
          add_state(SLV_Number_Flood_For_Wecoc::FLAREGUN_STATE)
          self.damages.push(["Marked", "Flare"])
        end
      end
    end
    #------------------------------------------------------------------------
    return effective
  end
end

Destiny Bond
Código:
#==============================================================================
# ** [XP] Wecoc's Tips & Tricks Battle Collection
#------------------------------------------------------------------------------
# 19. Destiny Bond
#------------------------------------------------------------------------------
# Estado que hace que si matan al que te lo aplicó, tú también mueras
#==============================================================================
# Ported to Number Flood
#==============================================================================

module SLV_Number_Flood_For_Wecoc
  
  # ID of the [Destiny bond] state
  DESTINY_BOND_ID = 17
  
  # IDs of the skills that can apply [Destiny bond]
  DESTINY_BOND_SKILLS = [81]

end
  
class Game_Battler
  unless $@
    alias destiny_bond_ini initialize
    alias destiny_bond_remove_state remove_state
    alias destiny_bond_skill skill_effect
  end
  
  attr_accessor :destiny_bond_attacker
  
  def initialize
    destiny_bond_ini
    @destiny_bond_attacker = nil
  end
 
  def remove_state(state_id, force = false)
    destiny_bond_remove_state(state_id, force)
    if state_id == SLV_Number_Flood_For_Wecoc::DESTINY_BOND_ID
      @destiny_bond_attacker = nil
    end
  end
 
  def skill_effect(user, skill)
    if SLV_Number_Flood_For_Wecoc::DESTINY_BOND_SKILLS.include?(skill.id)
      if self.dead? or self.state?(SLV_Number_Flood_For_Wecoc::DESTINY_BOND_ID)
        return false
      end
      add_state(SLV_Number_Flood_For_Wecoc::DESTINY_BOND_ID)
      @destiny_bond_attacker = user
      self.damages.push(["BOUND", "Lifebind"])
      return true
    end
    return destiny_bond_skill(user, skill)
  end
end

class Scene_Battle
  
  alias destiny_bond_update update_phase4_step7
  
  def update_phase4_step7
    for target in $game_party.actors + $game_troop.enemies
      if target.state?(SLV_Number_Flood_For_Wecoc::DESTINY_BOND_ID)
        next if target.destiny_bond_attacker == nil
        if target.destiny_bond_attacker.dead?
          target.damages.push([target.hp, "Lifebind"])
          target.hp -= target.hp
          target.damage_pop = true
        end
      end
    end
    
    @status_window.refresh
    destiny_bond_update
  end
  
end

Nota: Destiny Bond se ejecuta en phase4_step7, una fase que no existe sin Number Flood. Esta fase se ejecuta después de que
- 1. Se hayan ejecutado las animaciones sobre el atacante y
- 2. Se hayan ejecutado las animaciones sobre los objetivos de la acción.

Fun fact: si un enemigo marca a todo el grupo aliado con Destiny Bond y ese enemigo muere, el juego llama a Gameover.
avatar
silvanash
Aventurero
Aventurero

0/3

Créditos 1627

Gracias : 229

Volver arriba Ir abajo

RPG Maker XP Re: [RMXP] Number Flood v0.5a

Mensaje por silvanash el 2017-04-07, 17:55

Actualizado a la versión 0.4 para corregir algunos bugs de la versión anterior, y también para facilitar el manejo del script.

Number Flood para eventos de mapa está pendiente de más fixes. Ya veré qué hago con él.

El Leech Seed que posteé ha sido actualizado a la versión 0.4 de Number Flood. Si alguien lo usaba (es decir, nadie), que pille la nueva versión.
avatar
silvanash
Aventurero
Aventurero

0/3

Créditos 1627

Gracias : 229

Volver arriba Ir abajo

RPG Maker XP Re: [RMXP] Number Flood v0.5a

Mensaje por silvanash el 2017-04-17, 10:30

Actualizado a la versión 0.4.1 para corregir algunos errores.
avatar
silvanash
Aventurero
Aventurero

0/3

Créditos 1627

Gracias : 229

Volver arriba Ir abajo

RPG Maker XP Re: [RMXP] Number Flood v0.5a

Mensaje por Wecoc el 2017-04-17, 15:03

No recuerdo quien pero me hicieron un pedido hace un tiempo que no llegué a hacer, y he estado pensando que quizá se pueda hacer a partir de éste script sin demasiado problema.

El pedido era que por ejemplo un enemigo al envenenarte te salga un popup similar al de daño que diga +Veneno o algo así, de color liloso (el color se configuraría para cada estado, y no en todos saldría popup). En resumen, el script sería para mostrar los estados obtenidos en un popup similar al de daño.

En fin, yo tiro ideas xD

Por cierto te agradezco esa adaptación de algunos de esos Tips & Tricks.
avatar
Wecoc
Administrador
Administrador



Créditos 9370

Gracias : 517

Volver arriba Ir abajo

RPG Maker XP Re: [RMXP] Number Flood v0.5a

Mensaje por silvanash el 2017-04-17, 16:00

He añadido un cutri-edit con eso que dices, pero no aseguro que funcione bien para todas las batallas porque hay demasiados factores a la hora de modificar estados en el Maker.

La versión 0.4.1b muestra textos de "+Estado" y "-Estado" para ciertos estados en concreto, definidos en el module de configuración del principio. Estos avisos se mostrarán en CUALQUIER SITUACIÓN en la que esos estados se añadan o quiten. Eso incluye añadirlos con skills, con ataques, perderlos por recibir daño o de forma pasiva por el paso del tiempo. Usad este feature con moderación para no saturar la pantalla.
avatar
silvanash
Aventurero
Aventurero

0/3

Créditos 1627

Gracias : 229

Volver arriba Ir abajo

RPG Maker XP Re: [RMXP] Number Flood v0.5a

Mensaje por silvanash el 2017-05-03, 23:26

Actualizado a versión 0.5a para añadir eso de mostrar los números de daño con una animación por dígito/letra en lugar de mostrar todo el mensaje a la vez. Esta versión es una beta temprana que acabo de apañar, y todavía tiene algunas cosas por solucionar (esencialmente, la posición de los números, que está un poco mal ajustada, aunque la copié tal cual del script de Wecocio) y un delay extraño en algunas animaciones de daño. Lo importante es que no crashea.

Esta versión también ha cambiado el funcionamiento del sistema, así que, hasta nuevo aviso, todos los add-ons y demases que hay para Number Flood no funcionan. Intentaré adaptarlos a la nueva versión tan pronto como me sea humanamente posible.
avatar
silvanash
Aventurero
Aventurero

0/3

Créditos 1627

Gracias : 229

Volver arriba Ir abajo

RPG Maker XP Re: [RMXP] Number Flood v0.5a

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.