Dúvida com NetPlay v4 - Resets?

E aí galera, bom eu baixei o NetPlay novo e testei um pouco e tal e lembrei de uma coisa: alguns jogos famosos contam com os RESETS, que pra quem não sabe, consiste em um comando que pode ser usado quando seu personagem atinge um nível alto ou o nível máximo que fazem seu personagem voltar ao nível 1, porém continuando com os mesmos status. Eu queria saber se já existe algo assim para o NetPlay ou se alguém pode disponibilizar para mim. Desde já agradeço.

da sim, vc pode cria um npc e por um condição [4 aba, script]

Código:

$game_party.actors[0].level == 99

ai quando a condição for verdadeira vc coloca

Código:

$game_party.actors[0].level = 1

E claro que entre esses códigos vc pode coloca falas e outras coisas que queira. Se vc n conseguir e so manda um PM.

tam bem estava precisando disso vlw gladistony +1 cred

Hm, entendi. Mas aproveitando este tópico, alguém pode me dizer como aumentar o limite de HP,MP,Ataque... ou então me passar um script compatível, agradeço desde já

Existem scripts que fazem isso, mais eu particularmente prefiro ir no script Game_Actor e editar la.
Para isso e so vc procurar a def que contem o atributo que vc quer edita [Para hp e a def maxhp] e dentro dele deve ter isso:

Código:

n = [[Integer(n), 1].max, 9999].min

e so vc edita o 9999 para o limite que vc quer ou apaga a linha para n ter limite.
O mesmo vale para todos os outros atributos e itens.
So 1 coisa para editar os itens vc tem q ir no [GM] Game_Party.
Se quiser uma lista com todos os limites do netplay e so vc aperta ctrl+shift+f e procurar por

Código:

].min

Consegui!! Valeu cara, me ajudou muito!

EDIT>> Mas agora, como eu faço pra aumentar o limite que aparece na caixa dos status? Apesar de eu estar com o nível acima de 100, lá continua 99

o lance dos level e outra coisa, eu vou posta um tutorial de como remover esse limite ja ja, quando eu posta edito.

Valeu cara, tenho certeza de que vai ajudar muitos makers

bem eu ia posta isso la no fórum mais como não foi eu quem fez esse script vou posta sp aqui:

Código:

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#_/    ŸŒÀŠE“Ë”j  | KGC_LimitBreak Ÿ
#_/----------------------------------------------------------------------------
#_/  ŠeŽí Ý’è’l‚Ì ãŒÀ‚ð•Ï X‚µ‚Ü‚· B
#_/============================================================================
#_/  áƒNƒ‰ƒX Ý’è Ú ×‰»[ClassDetailSetting] â‚æ‚è ã
#_/  á‘•”õŠg’£[EquipExtension] â‚æ‚艺
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/

#==============================================================================
#  š ƒJƒXƒ^ƒ}ƒCƒY €–Ú  š
#==============================================================================

module KGC
  #  Ÿ”\—Í’l C ³’l(•S•ª—¦)
  #  ”\—Í’l‚ªƒf [ƒ^ƒx [ƒX‚Ì Ý’è’l‚Ì › “‚É‚È‚é B“G‚à“¯—l B
  #  ( ãŒÀ’l‚ª ‚‚¢ ê ‡‚ÉŽg—p Bƒf [ƒ^ƒx [ƒX‚Ì’l‚ðŽg‚¤ ê ‡‚Í 100)
  LB_MAXHP_REVISE = 100  # MAXHP
  LB_MAXSP_REVISE = 100  # MAXSP
  LB_STR_REVISE  = 100  # ˜r—Í
  LB_DEX_REVISE  = 100  # Ší—p‚³
  LB_AGI_REVISE  = 100  # ‘f‘ ‚³
  LB_INT_REVISE  = 100  # –‚—Í

  #  Ÿƒ_ƒ  [ƒW’l•â ³
  #  MAXHP•â ³’l‚ɉž‚¶‚Ä Aƒ_ƒ  [ƒW’l‚ðŽ“’² ‚·‚é B
  LB_DAMAGE_CORRECT = false

  #  ŸƒAƒNƒ^ [‚̃Œƒxƒ‹ ãŒÀ
  #  ƒAƒNƒ^ [ID ‡‚É”z—ñ‚ÉŠi”[( Å ‰‚Í nil)
  LB_ACTOR_LV_LIMIT = [999]
  #  Ÿ ãŒÀ–¢Žw’èƒAƒNƒ^ [‚̃Œƒxƒ‹ ãŒÀ
  #  ãŒÀ–¢Žw’è(nil)‚̃AƒNƒ^ [‚Í‚±‚Ì’l‚ðŽg—p B
  LB_ACTOR_LV_LIMIT_DEFAULT = 999
  #  ŸƒAƒNƒ^ [‚ÌŒoŒ±’l ãŒÀ
  LB_ACTOR_EXP_LIMIT = 99999999999
  #  ŸƒAƒNƒ^ [‚ÌHP ãŒÀ
  LB_ACTOR_HP_LIMIT  = 99999
  #  ŸƒAƒNƒ^ [‚ÌSP ãŒÀ
  LB_ACTOR_SP_LIMIT  = 99999
  #  ŸƒAƒNƒ^ [‚Ì u˜r—Í, Ší—p‚³, ‘f‘ ‚³, –‚—Í v ãŒÀ
  LB_ACTOR_ETC_LIMIT = 9999
  #  ŸƒŒƒxƒ‹ 100 ˆÈ ~‚Ì”\—Í’lŒvŽZŽ
  #  ylv..Œ»ƒŒƒxƒ‹  p[x]..ƒŒƒxƒ‹ x ‚Ì”\—Í’l z
  #  ‚±‚ÌŒvŽZŒ‹‰Ê‚ðƒŒƒxƒ‹ 99 ‚Ì”\—Í’l‚ɉÁŽZ B
  LB_ACTOR_LV100_CALC = "(p[99] - p[98]) * (lv - 99)"

  #  Ÿ“G‚ÌHP ãŒÀ
  LB_ENEMY_HP_LIMIT  = 9999999
  #  Ÿ“G‚ÌSP ãŒÀ
  LB_ENEMY_SP_LIMIT  = 99999
  #  Ÿ“G‚Ì u˜r—Í, Ší—p‚³, ‘f‘ ‚³, –‚—Í v ãŒÀ
  LB_ENEMY_ETC_LIMIT = 9999
end

# š š š š š š š š š š š š š š š š š š š š

$imported = {} if $imported == nil
$imported["LimitBreak"] = true

if $game_special_elements == nil
  $game_special_elements = {}
  $data_system = load_data("Data/System.rxdata")
end

module LimitBreak
  #--------------------------------------------------------------------------
  #  œ ”\—Í’l•â ³ ς݃oƒgƒ‰ [Žæ“¾
  #--------------------------------------------------------------------------
  def self.get_revised_battler(battler)
    bt = battler.clone
    hp_limit = battler.is_a?(RPG::Enemy) ?
      KGC::LB_ENEMY_HP_LIMIT : KGC::LB_ACTOR_HP_LIMIT
    sp_limit = battler.is_a?(RPG::Enemy) ?
      KGC::LB_ENEMY_SP_LIMIT : KGC::LB_ACTOR_SP_LIMIT
    etc_limit = battler.is_a?(RPG::Enemy) ?
      KGC::LB_ENEMY_ETC_LIMIT : KGC::LB_ACTOR_ETC_LIMIT
    bt.maxhp = [bt.maxhp * KGC::LB_MAXHP_REVISE / 100, hp_limit].min
    bt.maxsp = [bt.maxsp * KGC::LB_MAXSP_REVISE / 100, sp_limit].min
    bt.str  = [bt.str  * KGC::LB_STR_REVISE  / 100, etc_limit].min
    bt.dex  = [bt.dex  * KGC::LB_DEX_REVISE  / 100, etc_limit].min
    bt.agi  = [bt.agi  * KGC::LB_AGI_REVISE  / 100, etc_limit].min
    bt.int  = [bt.int  * KGC::LB_INT_REVISE  / 100, etc_limit].min
    return bt
  end
end

# š š š š š š š š š š š š š š š š š š š š

#==============================================================================
#  ¡ Game_Battler (•ªŠ„’è‹` 1)
#==============================================================================

class Game_Battler
  #--------------------------------------------------------------------------
  #  œ MaxHP ‚̎擾
  #--------------------------------------------------------------------------
  def maxhp
    n = [[base_maxhp + @maxhp_plus, 1].max, KGC::LB_ENEMY_HP_LIMIT].min
    @states.each { |i| n *= $data_states[i].maxhp_rate / 100.0 }
    n = [[Integer(n), 1].max, KGC::LB_ENEMY_HP_LIMIT].min
    return n
  end
  #--------------------------------------------------------------------------
  #  œ MaxSP ‚̎擾
  #--------------------------------------------------------------------------
  def maxsp
    n = [[base_maxsp + @maxsp_plus, 0].max, KGC::LB_ENEMY_SP_LIMIT].min
    @states.each { |i| n *= $data_states[i].maxsp_rate / 100.0 }
    n = [[Integer(n), 0].max, KGC::LB_ENEMY_SP_LIMIT].min
    return n
  end
  #--------------------------------------------------------------------------
  #  œ ˜r—͂̎擾
  #--------------------------------------------------------------------------
  def str
    n = [[base_str + @str_plus, 1].max, KGC::LB_ENEMY_ETC_LIMIT].min
    @states.each { |i| n *= $data_states[i].str_rate / 100.0 }
    n = [[Integer(n), 1].max, KGC::LB_ENEMY_ETC_LIMIT].min
    return n
  end
  #--------------------------------------------------------------------------
  #  œ Ší—p‚³‚̎擾
  #--------------------------------------------------------------------------
  def dex
    n = [[base_dex + @dex_plus, 1].max, KGC::LB_ENEMY_ETC_LIMIT].min
    @states.each { |i| n *= $data_states[i].dex_rate / 100.0 }
    n = [[Integer(n), 1].max, KGC::LB_ENEMY_ETC_LIMIT].min
    return n
  end
  #--------------------------------------------------------------------------
  #  œ ‘f‘ ‚³‚̎擾
  #--------------------------------------------------------------------------
  def agi
    n = [[base_agi + @agi_plus, 1].max, KGC::LB_ENEMY_ETC_LIMIT].min
    @states.each { |i| n *= $data_states[i].agi_rate / 100.0 }
    n = [[Integer(n), 1].max, KGC::LB_ENEMY_ETC_LIMIT].min
    return n
  end
  #--------------------------------------------------------------------------
  #  œ –‚—͂̎擾
  #--------------------------------------------------------------------------
  def int
    n = [[base_int + @int_plus, 1].max, KGC::LB_ENEMY_ETC_LIMIT].min
    @states.each { |i| n *= $data_states[i].int_rate / 100.0 }
    n = [[Integer(n), 1].max, KGC::LB_ENEMY_ETC_LIMIT].min
    return n
  end
  #--------------------------------------------------------------------------
  #  œ MaxHP ‚Ì Ý’è
  #    maxhp :  V‚µ‚¢ MaxHP
  #--------------------------------------------------------------------------
  def maxhp=(maxhp)
    @maxhp_plus += maxhp - self.maxhp
    @maxhp_plus = [[@maxhp_plus, -KGC::LB_ENEMY_HP_LIMIT].max, KGC::LB_ENEMY_HP_LIMIT].min
    @hp = [@hp, self.maxhp].min
  end
  #--------------------------------------------------------------------------
  #  œ MaxSP ‚Ì Ý’è
  #    maxsp :  V‚µ‚¢ MaxSP
  #--------------------------------------------------------------------------
  def maxsp=(maxsp)
    @maxsp_plus += maxsp - self.maxsp
    @maxsp_plus = [[@maxsp_plus, -KGC::LB_ENEMY_SP_LIMIT].max, KGC::LB_ENEMY_SP_LIMIT].min
    @sp = [@sp, self.maxsp].min
  end
  #--------------------------------------------------------------------------
  #  œ ˜r—Í‚Ì Ý’è
  #    str :  V‚µ‚¢˜r—Í
  #--------------------------------------------------------------------------
  def str=(str)
    @str_plus += str - self.str
    @str_plus = [[@str_plus, -KGC::LB_ENEMY_ETC_LIMIT].max, KGC::LB_ENEMY_ETC_LIMIT].min
  end
  #--------------------------------------------------------------------------
  #  œ Ší—p‚³‚Ì Ý’è
  #    dex :  V‚µ‚¢Ší—p‚³
  #--------------------------------------------------------------------------
  def dex=(dex)
    @dex_plus += dex - self.dex
    @dex_plus = [[@dex_plus, -KGC::LB_ENEMY_ETC_LIMIT].max, KGC::LB_ENEMY_ETC_LIMIT].min
  end
  #--------------------------------------------------------------------------
  #  œ ‘f‘ ‚³‚Ì Ý’è
  #    agi :  V‚µ‚¢‘f‘ ‚³
  #--------------------------------------------------------------------------
  def agi=(agi)
    @agi_plus += agi - self.agi
    @agi_plus = [[@agi_plus, -KGC::LB_ENEMY_ETC_LIMIT].max, KGC::LB_ENEMY_ETC_LIMIT].min
  end
  #--------------------------------------------------------------------------
  #  œ –‚—Í‚Ì Ý’è
  #    int :  V‚µ‚¢–‚—Í
  #--------------------------------------------------------------------------
  def int=(int)
    @int_plus += int - self.int
    @int_plus = [[@int_plus, -KGC::LB_ENEMY_ETC_LIMIT].max, KGC::LB_ENEMY_ETC_LIMIT].min
  end
end

# š š š š š š š š š š š š š š š š š š š š

#==============================================================================
#  ¡ Game_Battler (•ªŠ„’è‹` 3)
#==============================================================================

class Game_Battler
  #--------------------------------------------------------------------------
  #  œ ’Ê í UŒ‚‚ÌŒø‰Ê“K—p
  #--------------------------------------------------------------------------
  alias attack_effect_KGC_LimitBreak attack_effect
  def attack_effect(attacker)
    # Œ³‚ÌHP‚ð•Û‘¶
    last_hp = self.hp

    # Œ³‚Ì ˆ— ‚ðŽÀ s
    result = attack_effect_KGC_LimitBreak(attacker)

    # ƒ_ƒ  [ƒW‚ðŽó‚¯‚½ ê ‡
    if result && self.damage.is_a?(Numeric) && self.damage > 0
      # ƒ_ƒ  [ƒW’l’²
      if KGC::LB_DAMAGE_CORRECT
        correct_damage(last_hp)
      end
    end
    return result
  end
  #--------------------------------------------------------------------------
  #  œ ƒ_ƒ  [ƒW’l’²
  #--------------------------------------------------------------------------
  def correct_damage(last_hp)
    self.damage = self.damage * KGC::LB_MAXHP_REVISE * 3 / 400
    if $imported["BonusGauge"]
      self.base_damage = self.base_damage * KGC::LB_MAXHP_REVISE * 3 / 400
    end
    # HPŒ¸ ­ ˆ—
    self.hp = last_hp
    self.hp -= self.damage
  end
  #--------------------------------------------------------------------------
  #  œ ƒXƒLƒ‹‚ÌŒø‰Ê“K—p
  #--------------------------------------------------------------------------
  alias skill_effect_KGC_LimitBreak skill_effect
  def skill_effect(user, skill)
    # Œ³‚ÌHP‚ð•Û‘¶
    last_hp = self.hp

    # Œ³‚Ì ˆ— ‚ðŽÀ s
    result = skill_effect_KGC_LimitBreak(user, skill)

    # ‹C—Í‘ Œ¸‘ «‚ðŽ ‚Á‚Ä‚¢‚È‚¢ A‚‚Š„ ‡ƒ_ƒ  [ƒW‚Å‚Í‚È‚¢ ê ‡
    if result && !skill.element_set.include?($game_special_elements["spirit_id"]) &&
        ($imported["RateDamage"] && KGC.check_damage_rate(skill) == nil) &&
        ($imported["SPCostAlter"] && KGC.check_sp_rate(skill) == nil)
      # ƒ_ƒ  [ƒW‚ðŽó‚¯‚½ ê ‡
      if self.damage.is_a?(Numeric)
        correct_damage(last_hp)
      end
    end
    return result
  end
end

# š š š š š š š š š š š š š š š š š š š š

#==============================================================================
#  ¡ Game_Actor
#==============================================================================

class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  #  œ EXP ŒvŽZ
  #--------------------------------------------------------------------------
  def make_exp_list
    actor = $data_actors[@actor_id]
    @exp_list[1] = 0
    pow_i = 2.4 + actor.exp_inflation / 100.0
    (2..(self.final_level + 1)).each { |i|
      if i > self.final_level
        @exp_list[i] = 0
      else
        n = actor.exp_basis * ((i + 3) ** pow_i) / (5 ** pow_i)
        @exp_list[i] = @exp_list[i-1] + Integer(n)
      end
    }
  end
  #--------------------------------------------------------------------------
  #  œ EXP ‚Ì•Ï X
  #    exp :  V‚µ‚¢ EXP
  #--------------------------------------------------------------------------
  def exp=(exp)
    if $imported["ExpGoldIncrease"]
      rate = calc_exp_increase_rate(KGC::EXPGLD_INC_PERMIT_DOUBLE)
      exp = @exp + (exp - @exp) * rate / 100
    end
    @exp = [[exp, KGC::LB_ACTOR_EXP_LIMIT].min, 0].max
    # ƒŒƒxƒ‹ƒAƒbƒv
    while @exp >= @exp_list[@level+1] and @exp_list[@level+1] > 0
      @level += 1
  actor = $game_party.actors[0]
  $distribuir_pontos += 5
  actor.hp = actor.maxhp
  actor.sp = actor.maxsp
  $game_player.animation_id = 33
  actor.damage = "Level Up"
      # ƒXƒLƒ‹ K“¾
      $data_classes[@class_id].learnings.each { |j|
        if j.level == @level
          learn_skill(j.skill_id)
        end
      }
    end
    # ƒŒƒxƒ‹ƒ_ƒEƒ“
    while @exp < @exp_list[@level]
      @level -= 1
    end
    # Œ» Ý‚Ì HP ‚Æ SP ‚ª Å‘å’l‚ð’´‚¦‚Ä‚¢‚½‚ç C ³
    @hp = [@hp, self.maxhp].min
    @sp = [@sp, self.maxsp].min
  end
  #--------------------------------------------------------------------------
  #  œ ƒpƒ‰ƒ  [ƒ^‚̎擾
  #--------------------------------------------------------------------------
  def parameter(type)
    if @level >= 100
      calc_text = KGC::LB_ACTOR_LV100_CALC.dup
      calc_text.gsub!(/lv/i) { "@level" }
      calc_text.gsub!(/p\[(\d+)\]/i) {
        "$data_actors[@actor_id].parameters[type, #{$1.to_i}]"
      }
      return $data_actors[@actor_id].parameters[type, 99] + eval(calc_text)
    else
      return $data_actors[@actor_id].parameters[type, @level]
    end
  end
  #--------------------------------------------------------------------------
  #  œ MaxHP ‚̎擾
  #--------------------------------------------------------------------------
  def maxhp
    n = [[base_maxhp + @maxhp_plus, 1].max, KGC::LB_ACTOR_HP_LIMIT].min
    @states.each { |i| n *= $data_states[i].maxhp_rate / 100.0 }
    n = [[Integer(n), 1].max, KGC::LB_ACTOR_HP_LIMIT].min
    return n
  end
  #--------------------------------------------------------------------------
  #  œ Šî–{ MaxHP ‚̎擾
  #--------------------------------------------------------------------------
  def base_maxhp
    n = self.parameter(0)
    return n * KGC::LB_MAXHP_REVISE / 100
  end
  #--------------------------------------------------------------------------
  #  œ MaxSP ‚̎擾
  #--------------------------------------------------------------------------
  def maxsp
    n = [[base_maxsp + @maxsp_plus, 0].max, KGC::LB_ACTOR_SP_LIMIT].min
    @states.each { |i| n *= $data_states[i].maxsp_rate / 100.0 }
    n = [[Integer(n), 0].max, KGC::LB_ACTOR_SP_LIMIT].min
    return n
  end
  #--------------------------------------------------------------------------
  #  œ Šî–{ MaxSP ‚̎擾
  #--------------------------------------------------------------------------
  def base_maxsp
    n = self.parameter(1)
    return n * KGC::LB_MAXSP_REVISE / 100
  end
  #--------------------------------------------------------------------------
  #  œ Šî–{˜r—͂̎擾
  #--------------------------------------------------------------------------
  def base_str
    n = self.parameter(2)
    if $imported["EquipExtension"]
      n += equipment_parameter(2)
    end
    return [[n * KGC::LB_STR_REVISE / 100, 1].max, KGC::LB_ACTOR_ETC_LIMIT].min
  end
  #--------------------------------------------------------------------------
  #  œ Šî–{Ší—p‚³‚̎擾
  #--------------------------------------------------------------------------
  def base_dex
    n = self.parameter(3)
    if $imported["EquipExtension"]
      n += equipment_parameter(3)
    end
    return [[n * KGC::LB_DEX_REVISE / 100, 1].max, KGC::LB_ACTOR_ETC_LIMIT].min
  end
  #--------------------------------------------------------------------------
  #  œ Šî–{‘f‘ ‚³‚̎擾
  #--------------------------------------------------------------------------
  def base_agi
    n = self.parameter(4)
    if $imported["EquipExtension"]
      n += equipment_parameter(4)
    end
    return [[n * KGC::LB_AGI_REVISE / 100, 1].max, KGC::LB_ACTOR_ETC_LIMIT].min
  end
  #--------------------------------------------------------------------------
  #  œ Šî–{–‚—͂̎擾
  #--------------------------------------------------------------------------
  def base_int
    n = self.parameter(5)
    if $imported["EquipExtension"]
      n += equipment_parameter(5)
    end
    return [[n * KGC::LB_INT_REVISE / 100, 1].max, KGC::LB_ACTOR_ETC_LIMIT].min
  end
  #--------------------------------------------------------------------------
  #  œ ƒŒƒxƒ‹‚Ì•Ï X
  #    level :  V‚µ‚¢ƒŒƒxƒ‹
  #--------------------------------------------------------------------------
  def level=(level)
    #  ㉺ŒÀƒ`ƒFƒbƒN
    level = [[level, self.final_level].min, 1].max
    # EXP ‚ð•Ï X
    self.exp = @exp_list[level]
  end
  #--------------------------------------------------------------------------
  #  œ  Å IƒŒƒxƒ‹‚̎擾
  #--------------------------------------------------------------------------
  def final_level
    return KGC::LB_ACTOR_LV_LIMIT[@actor_id] != nil ? KGC::LB_ACTOR_LV_LIMIT[@actor_id] : KGC::LB_ACTOR_LV_LIMIT_DEFAULT
  end
end

# š š š š š š š š š š š š š š š š š š š š

#==============================================================================
#  ¡ Game_Enemy
#==============================================================================

class Game_Enemy < Game_Battler
  #--------------------------------------------------------------------------
  #  œ Šî–{ MaxHP ‚̎擾
  #--------------------------------------------------------------------------
  alias base_maxhp_KGC_LimitBreak base_maxhp
  def base_maxhp
    n = base_maxhp_KGC_LimitBreak
    n *= KGC::LB_MAXHP_REVISE
    return n / 100
  end
  #--------------------------------------------------------------------------
  #  œ Šî–{ MaxSP ‚̎擾
  #--------------------------------------------------------------------------
  alias base_maxsp_KGC_LimitBreak base_maxsp
  def base_maxsp
    n = base_maxsp_KGC_LimitBreak
    n *= KGC::LB_MAXSP_REVISE
    return n / 100
  end
  #--------------------------------------------------------------------------
  #  œ Šî–{˜r—͂̎擾
  #--------------------------------------------------------------------------
  alias base_str_KGC_LimitBreak base_str
  def base_str
    n = base_str_KGC_LimitBreak
    n *= KGC::LB_STR_REVISE
    return n / 100
  end
  #--------------------------------------------------------------------------
  #  œ Šî–{Ší—p‚³‚̎擾
  #--------------------------------------------------------------------------
  alias base_dex_KGC_LimitBreak base_dex
  def base_dex
    n = base_dex_KGC_LimitBreak
    n *= KGC::LB_DEX_REVISE
    return n / 100
  end
  #--------------------------------------------------------------------------
  #  œ Šî–{‘f‘ ‚³‚̎擾
  #--------------------------------------------------------------------------
  alias base_agi_KGC_LimitBreak base_agi
  def base_agi
    n = base_agi_KGC_LimitBreak
    n *= KGC::LB_AGI_REVISE
    return n / 100
  end
  #--------------------------------------------------------------------------
  #  œ Šî–{–‚—͂̎擾
  #--------------------------------------------------------------------------
  alias base_int_KGC_LimitBreak base_int
  def base_int
    n = base_int_KGC_LimitBreak
    n *= KGC::LB_INT_REVISE
    return n / 100
  end
end

Esse e o script que eu uso no meu game para remover os limites, cole acima do main, AVISO tem que ser exatamente acima do main.
Depois va no script [WIN] Hud
Procure por

Código:

xpbar = RPG::Cache.picture("XP-2")

e logo abaixo cole esse código.

Código:

    if @actor.next_exp == 0
      barraxp = 1
    else
      barraxp = @actor.next_exp
    end
    xpbarwidth = xpbar.width * @actor.now_exp / barraxp


Depois disso basta apaga a linha que diz

Código:

xpbarwidth = xpbar.width * @actor.now_exp / @actor.next_exp

OFF: Desculpa não ter postado ontem, minha net caiu e não pego mais

Funcionou direitinho!! Valeu