Scripts de status e level 999

Características.
Script permite ultrapassar os limites padrões dos parâmetros de Status
(LV,HP,SP,STR,DEX,Etc.), e também de dinheiro e o número de itens.

NOTA – Cautela na hora de definir os números para o não tirar o balanço do
jogo (dificuldade), ou seja, você pode deixar o jogo insanamente difícil ou
fácil demais, este script é indicado para quem quer fazer chefes estilos
Weapons (Atma, Ruby, Crsytal, etc.) da serie FF onde os chefes são quase
impossíveis de se vencer.

Utilização
Procure estas linhas logo no começo do script.


#---------------------------------------------------------------
LB_MAXHP_REVISE = 99999
#---------------------------------------------------------------
Limite de HP.

#---------------------------------------------------------------
LB_MAXSP_REVISE = 99999
#---------------------------------------------------------------
Limite de SP.

#---------------------------------------------------------------
LB_STR_REVISE = 100
#---------------------------------------------------------------
Força.

#---------------------------------------------------------------
LB_DEX_REVISE = 100
#---------------------------------------------------------------
Dextreza.

#---------------------------------------------------------------
LB_AGI_REVISE = 100
#---------------------------------------------------------------
Agilidade.

#---------------------------------------------------------------
LB_INT_REVISE = 100
#---------------------------------------------------------------
Inteligência

#---------------------------------------------------------------
LB_DAMAGE_CORRECT = true
#---------------------------------------------------------------
O parâmetro do dano será modificado?

#---------------------------------------------------------------
#-----------------------INIMIGO----------------------------
#---------------------------------------------------------------

#---------------------------------------------------------------
LB_ENEMY_HP_LIMIT = 999999999
#---------------------------------------------------------------
Limite maximo do HP

#---------------------------------------------------------------
LB_ENEMY_SP_LIMIT = 9999999
#---------------------------------------------------------------
Limite maximo do SP

#---------------------------------------------------------------
LB_ENEMY_ETC_LIMIT = 999999
#---------------------------------------------------------------
Definição dos parâmetros de Ataque, Def magia e Def Física.

#---------------------------------------------------------------
#-------------------------HERO------------------------------
#---------------------------------------------------------------

#---------------------------------------------------------------
LB_ACTOR_LV_LIMIT_DEFAULT = 512
#---------------------------------------------------------------
Nível maximo do seu personagem.

#---------------------------------------------------------------
LB_ACTOR_EXP_LIMIT = 9999999999
#---------------------------------------------------------------
Experiência máxima de seu personagem.

#---------------------------------------------------------------
LB_ACTOR_HP_LIMIT = 9999999
#---------------------------------------------------------------
Limite de HP maximo de seu personagem.

#---------------------------------------------------------------
LB_ACTOR_SP_LIMIT = 9999999
#---------------------------------------------------------------
Limite de SP maximo de seu personagem.

#---------------------------------------------------------------
LB_ACTOR_ETC_LIMIT = 99999
#---------------------------------------------------------------
Limite maximo para os parâmetros de status (STR,DEX,INT,AGL)

#---------------------------------------------------------------
LB_ACTOR_LV100_CALC = "(p[2] - p[1]) * (lv - 99)"
#---------------------------------------------------------------
Definição do calculo para LV após o LV99.

#---------------------------------------------------------------
#--------------------------MISC------------------------------
#---------------------------------------------------------------

#---------------------------------------------------------------
LB_GOLD_LIMIT = 99999999
#---------------------------------------------------------------
Limite maximo de dinheiro.

#---------------------------------------------------------------
LB_ITEM_LIMIT = 99
#---------------------------------------------------------------
Limite maximo de item.

Copie o script acima do script Main.

Codigo:
#######################################################################################
############################# KGC
#####################################################
#######################################################################################
# O script permite que o jogo ultrapasse os parametros definidos
#como HP,SP,STR,EXP,etc...
#Mog Nota - Este script cancela o efeito do Else EX.
#######################################################################################

module KGC
# O numero que colocar aqui será o valor que vai multiplicar
#os parametros de status.
LB_MAXHP_REVISE = 99999 # MAXHP
LB_MAXSP_REVISE = 99999 # MAXSP
LB_STR_REVISE = 100 # Força
LB_DEX_REVISE = 100 # Dextreza
LB_AGI_REVISE = 100 # Agilidade
LB_INT_REVISE = 100 # Inteligência
# O parâmetro do dano será modificado?
LB_DAMAGE_CORRECT = true
########################
########INIMIGO#########
########################
# Limite maximo do HP
LB_ENEMY_HP_LIMIT = 999999999
# Limite maximo do SP
LB_ENEMY_SP_LIMIT = 9999999
# Definição dos parâmetros de Ataque, Def magia e Def Física.
LB_ENEMY_ETC_LIMIT = 999999
##########################
##########HERO############
##########################
# Nível maximo do seu personagem.
LB_ACTOR_LV_LIMIT = [nil]
LB_ACTOR_LV_LIMIT_DEFAULT = 512
# Experiência máxima de seu personagem.
LB_ACTOR_EXP_LIMIT = 9999999999
# Limite de HP maximo de seu personagem.
LB_ACTOR_HP_LIMIT = 9999999
# Limite de SP maximo de seu personagem.
LB_ACTOR_SP_LIMIT = 9999999
# Definição de calculo para o LV-UP.
LB_ACTOR_ETC_LIMIT = 99999
# Definição do calculo para LV após o LV99.
LB_ACTOR_LV100_CALC = "(p[2] - p[1]) * (lv - 99)"
# Limite maximo de dinheiro.
LB_GOLD_LIMIT = 99999999
# Limite maximo de item.
LB_ITEM_LIMIT = 99
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
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
class Game_Battler
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
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), 1].max, KGC::LB_ENEMY_SP_LIMIT].min
return n
end
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
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
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
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
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
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
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
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
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
class Game_Battler
alias attack_effect_KGC_LimitBreak attack_effect
def attack_effect(attacker)
last_hp = self.hp
result = attack_effect_KGC_LimitBreak(attacker)
if result && self.damage.is_a?(Numeric) && self.damage > 0
if KGC::LB_DAMAGE_CORRECT
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
end
self.hp = last_hp
self.hp -= self.damage
end
return result
end
alias skill_effect_KGC_LimitBreak skill_effect
def skill_effect(user, skill)
last_hp = self.hp
result = skill_effect_KGC_LimitBreak(user, skill)
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)
if self.damage.is_a?(Numeric)
if KGC::LB_DAMAGE_CORRECT
self.damage = self.damage * KGC::LB_MAXHP_REVISE * 3 / 400
end
self.base_damage = self.damage if $imported["BonusGauge"]
self.hp = last_hp
self.hp -= self.damage
end
end
return result
end
end
class Game_Actor < Game_Battler
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
def exp=(exp)
if $imported["ExpGoldIncrease"]
inc_exp = 100
self.states.compact.each { |state|
if $data_states[state].name =~ $game_special_states["inc_exp"]
inc_exp *= $1.to_i
inc_exp /= 100
end
}
exp = exp * inc_exp / 100
end
@exp = [[exp, KGC::LB_ACTOR_EXP_LIMIT].min, 0].max
while @exp >= @exp_list[@level+1] and @exp_list[@level+1] > 0
@level += 1
$data_classes[@class_id].learnings.each { |j|
if j.level == @level
learn_skill(j.skill_id)
end
}
end
while @exp < @exp_list[@level]
@level -= 1
end
if @level >= 100
self.restore_parameter
end
@hp = [@hp, self.maxhp].min
@sp = [@sp, self.maxsp].min
end
def restore_parameter
return if @level < 100
$data_actors[@actor_id].parameters.resize(6, @level + 1)
(0..5).each { |k|
if $data_actors[@actor_id].parameters[k, @level] == 0
calc_text = KGC::LB_ACTOR_LV100_CALC
calc_text.gsub!(/lv/i) { "@level" }
calc_text.gsub!(/p\[(\d+)\]/i) {
"$data_actors[@actor_id].parameters[k, #{$1.to_i}]" }
n = $data_actors[@actor_id].parameters[k, 99]
n += eval(calc_text)
$data_actors[@actor_id].parameters[k, @level] = [n, 32767].min
end
}
end
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
def base_maxhp
restore_parameter if $data_actors[@actor_id].parameters[0, @level] ==
nil
n = $data_actors[@actor_id].parameters[0, @level]
n *= KGC::LB_MAXHP_REVISE
return n / 100
end
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), 1].max, KGC::LB_ACTOR_SP_LIMIT].min
return n
end
def base_maxsp
restore_parameter if $data_actors[@actor_id].parameters[1, @level] ==
nil
n = $data_actors[@actor_id].parameters[1, @level]
n *= KGC::LB_MAXSP_REVISE
return n / 100
end
alias base_str_KGC_LimitBreak base_str
def base_str
restore_parameter if $data_actors[@actor_id].parameters[2, @level] ==
nil

if $imported["EquipExtension"]
n = base_str_KGC_LimitBreak
else
n = $data_actors[@actor_id].parameters[2, @level]
weapon = $data_weapons[@weapon_id]
n += weapon != nil ? weapon.str_plus : 0
(1..4).each { |i|
eval("armor = $data_armors[@armor#{i}_id];".concat(
"n += armor != nil ? armor.str_plus : 0"))
}
end
return [[n * KGC::LB_STR_REVISE / 100, 1].max,
KGC::LB_ACTOR_ETC_LIMIT].min
end
alias base_dex_KGC_LimitBreak base_dex
def base_dex
restore_parameter if $data_actors[@actor_id].parameters[3, @level] ==
nil

if $imported["EquipExtension"]
n = base_dex_KGC_LimitBreak
else
n = $data_actors[@actor_id].parameters[3, @level]
weapon = $data_weapons[@weapon_id]
n += weapon != nil ? weapon.dex_plus : 0
(1..4).each { |i|
eval("armor = $data_armors[@armor#{i}_id];".concat(
"n += armor != nil ? armor.dex_plus : 0"))
}
end
return [[n * KGC::LB_DEX_REVISE / 100, 1].max,
KGC::LB_ACTOR_ETC_LIMIT].min
end
alias base_agi_KGC_LimitBreak base_agi
def base_agi
restore_parameter if $data_actors[@actor_id].parameters[4, @level] ==
nil

if $imported["EquipExtension"]
n = base_agi_KGC_LimitBreak
else
n = $data_actors[@actor_id].parameters[4, @level]
weapon = $data_weapons[@weapon_id]
n += weapon != nil ? weapon.agi_plus : 0
(1..4).each { |i|
eval("armor = $data_armors[@armor#{i}_id];".concat(
"n += armor != nil ? armor.agi_plus : 0"))
}
end
return [[n * KGC::LB_AGI_REVISE / 100, 1].max,
KGC::LB_ACTOR_ETC_LIMIT].min
end
alias base_int_KGC_LimitBreak base_int
def base_int
restore_parameter if $data_actors[@actor_id].parameters[5, @level] ==
nil

if $imported["EquipExtension"]
n = base_int_KGC_LimitBreak
else
n = $data_actors[@actor_id].parameters[5, @level]
weapon = $data_weapons[@weapon_id]
n += weapon != nil ? weapon.int_plus : 0
(1..4).each { |i|
eval("armor = $data_armors[@armor#{i}_id];".concat(
"n += armor != nil ? armor.int_plus : 0"))
}
end
return [[n * KGC::LB_INT_REVISE / 100, 1].max,
KGC::LB_ACTOR_ETC_LIMIT].min
end
def level=(level)
level = [[level, self.final_level].min, 1].max
self.exp = @exp_list[level]
end
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
class Game_Enemy < Game_Battler
alias base_maxhp_KGC_LimitBreak base_maxhp
def base_maxhp
n = base_maxhp_KGC_LimitBreak
n *= KGC::LB_MAXHP_REVISE
return n / 100
end
alias base_maxsp_KGC_LimitBreak base_maxsp
def base_maxsp
n = base_maxsp_KGC_LimitBreak
n *= KGC::LB_MAXSP_REVISE
return n / 100
end
alias base_str_KGC_LimitBreak base_str
def base_str
n = base_str_KGC_LimitBreak
n *= KGC::LB_STR_REVISE
return n / 100
end
alias base_dex_KGC_LimitBreak base_dex
def base_dex
n = base_dex_KGC_LimitBreak
n *= KGC::LB_DEX_REVISE
return n / 100
end
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
class Game_Party
def gain_gold(n)
@gold = [[@gold + n, 0].max, KGC::LB_GOLD_LIMIT].min
end
def gain_item(item_id, n)
if item_id > 0
@items[item_id] = [[item_number(item_id) + n, 0].max,
KGC::LB_ITEM_LIMIT].min
end
end
def gain_weapon(weapon_id, n)
if weapon_id > 0
@weapons[weapon_id] = [[weapon_number(weapon_id) + n, 0].max,
KGC::LB_ITEM_LIMIT].min
end
end
def gain_armor(armor_id, n)
if armor_id > 0
@armors[armor_id] = [[armor_number(armor_id) + n, 0].max,
KGC::LB_ITEM_LIMIT].min
end
end
end

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#_/ ŸŒÀŠ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

# Ÿ ŠŽ ‹à ãŒÀ
LB_GOLD_LIMIT = 99999999
# ŸƒAƒCƒeƒ€ ŠŽ ” ãŒÀ
LB_ITEM_LIMIT = 99
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
# ƒ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

# š ™ š ™ š ™ š ™ š ™ š ™ š ™ š ™ š ™ š ™ š ™ š ™ š ™ š ™ š ™ š ™ š ™ š ™ š ™ š

#==============================================================================
# ¡ Game_Party
#==============================================================================

class Game_Party
#--------------------------------------------------------------------------
# œ ƒS [ƒ‹ƒh‚Ì‘ ‰Á (Œ¸ ­)
# n : ‹àŠz
#--------------------------------------------------------------------------
def gain_gold(n)
# ŠŽ ‹à‚ÌŒÀŠE’l•Ï X
@gold = [[@gold + n, 0].max, KGC::LB_GOLD_LIMIT].min
end
#--------------------------------------------------------------------------
# œ ƒAƒCƒeƒ€‚Ì‘ ‰Á (Œ¸ ­)
# item_id : ƒAƒCƒeƒ€ ID
# n : ŒÂ ”
#--------------------------------------------------------------------------
def gain_item(item_id, n)
# ƒnƒbƒVƒ…‚̌ ”ƒf [ƒ^‚ð X V
if item_id > 0
@items[item_id] = [[item_number(item_id) + n, 0].max, KGC::LB_ITEM_LIMIT].min
end
end
#--------------------------------------------------------------------------
# œ • Ší‚Ì‘ ‰Á (Œ¸ ­)
# weapon_id : • Ší ID
# n : ŒÂ ”
#--------------------------------------------------------------------------
def gain_weapon(weapon_id, n)
# ƒnƒbƒVƒ…‚̌ ”ƒf [ƒ^‚ð X V
if weapon_id > 0
@weapons[weapon_id] = [[weapon_number(weapon_id) + n, 0].max, KGC::LB_ITEM_LIMIT].min
end
end
#--------------------------------------------------------------------------
# œ –h‹ï‚Ì‘ ‰Á (Œ¸ ­)
# armor_id : –h‹ï ID
# n : ŒÂ ”
#--------------------------------------------------------------------------
def gain_armor(armor_id, n)
# ƒnƒbƒVƒ…‚̌ ”ƒf [ƒ^‚ð X V
if armor_id > 0
@armors[armor_id] = [[armor_number(armor_id) + n, 0].max, KGC::LB_ITEM_LIMIT].min
end