mirror of
https://github.com/infinitefusion/infinitefusion-e18.git
synced 2025-12-06 06:01:46 +00:00
Minor script rearranging
This commit is contained in:
Maruno17
@@ -0,0 +1,877 @@
|
||||
#===============================================================================
|
||||
# HP/Status options
|
||||
#===============================================================================
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :hp_status_menu, {
|
||||
"name" => _INTL("HP/Status..."),
|
||||
"parent" => :main,
|
||||
"usage" => :both
|
||||
})
|
||||
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :set_hp, {
|
||||
"name" => _INTL("Set HP"),
|
||||
"parent" => :hp_status_menu,
|
||||
"usage" => :both,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
if pkmn.egg?
|
||||
pbMessage("\\ts[]" + _INTL("{1} is an egg.", pkmn.name))
|
||||
next
|
||||
elsif battler && pkmn.totalhp == 1
|
||||
pbMessage("\\ts[]" + _INTL("Can't change HP, {1}'s maximum HP is 1 and it's in battle.", pkmn.name))
|
||||
next
|
||||
end
|
||||
min_hp = (battler) ? 1 : 0
|
||||
params = ChooseNumberParams.new
|
||||
params.setRange(min_hp, pkmn.totalhp)
|
||||
params.setDefaultValue(pkmn.hp)
|
||||
new_hp = pbMessageChooseNumber(
|
||||
"\\ts[]" + _INTL("Set {1}'s HP ({2}-{3}).", (battler) ? battler.pbThis(true) : pkmn.name, min_hp, pkmn.totalhp),
|
||||
params
|
||||
)
|
||||
next if new_hp == pkmn.hp
|
||||
(battler || pkmn).hp = new_hp
|
||||
}
|
||||
})
|
||||
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :set_status, {
|
||||
"name" => _INTL("Set status"),
|
||||
"parent" => :hp_status_menu,
|
||||
"usage" => :both,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
if pkmn.egg?
|
||||
pbMessage("\\ts[]" + _INTL("{1} is an egg.", pkmn.name))
|
||||
next
|
||||
elsif pkmn.hp <= 0
|
||||
pbMessage("\\ts[]" + _INTL("{1} is fainted, can't change status.", pkmn.name))
|
||||
next
|
||||
end
|
||||
cmd = 0
|
||||
commands = [_INTL("[Cure]")]
|
||||
ids = [:NONE]
|
||||
GameData::Status.each do |s|
|
||||
next if s.id == :NONE
|
||||
commands.push(_INTL("Set {1}", s.name))
|
||||
ids.push(s.id)
|
||||
end
|
||||
loop do
|
||||
msg = _INTL("Current status: {1}", GameData::Status.get(pkmn.status).name)
|
||||
if pkmn.status == :SLEEP
|
||||
msg += " " + _INTL("(turns: {1})", pkmn.statusCount)
|
||||
elsif pkmn.status == :POISON && pkmn.statusCount > 0
|
||||
if battler
|
||||
msg += " " + _INTL("(toxic, count: {1})", battler.effects[PBEffects::Toxic])
|
||||
else
|
||||
msg += " " + _INTL("(toxic)")
|
||||
end
|
||||
end
|
||||
cmd = pbMessage("\\ts[]" + msg, commands, -1, nil, cmd)
|
||||
break if cmd < 0
|
||||
case cmd
|
||||
when 0 # Cure
|
||||
if battler
|
||||
battler.status = :NONE
|
||||
else
|
||||
pkmn.heal_status
|
||||
end
|
||||
else # Give status problem
|
||||
pkmn_name = (battler) ? battler.pbThis(true) : pkmn.name
|
||||
case ids[cmd]
|
||||
when :SLEEP
|
||||
params = ChooseNumberParams.new
|
||||
params.setRange(0, 99)
|
||||
params.setDefaultValue((pkmn.status == :SLEEP) ? pkmn.statusCount : 3)
|
||||
params.setCancelValue(-1)
|
||||
count = pbMessageChooseNumber("\\ts[]" + _INTL("Set {1}'s sleep count (0-99).", pkmn_name), params)
|
||||
next if count < 0
|
||||
(battler || pkmn).statusCount = count
|
||||
when :POISON
|
||||
if pbConfirmMessage("\\ts[]" + _INTL("Make {1} badly poisoned (toxic)?", pkmn_name))
|
||||
if battler
|
||||
params = ChooseNumberParams.new
|
||||
params.setRange(0, 16)
|
||||
params.setDefaultValue(battler.effects[PBEffects::Toxic])
|
||||
params.setCancelValue(-1)
|
||||
count = pbMessageChooseNumber(
|
||||
"\\ts[]" + _INTL("Set {1}'s toxic count (0-16).", pkmn_name), params
|
||||
)
|
||||
next if count < 0
|
||||
battler.statusCount = 1
|
||||
battler.effects[PBEffects::Toxic] = count
|
||||
else
|
||||
pkmn.statusCount = 1
|
||||
end
|
||||
else
|
||||
(battler || pkmn).statusCount = 0
|
||||
end
|
||||
end
|
||||
(battler || pkmn).status = ids[cmd]
|
||||
end
|
||||
end
|
||||
}
|
||||
})
|
||||
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :full_heal, {
|
||||
"name" => _INTL("Heal HP and status"),
|
||||
"parent" => :hp_status_menu,
|
||||
"usage" => :both,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
if pkmn.egg?
|
||||
pbMessage("\\ts[]" + _INTL("{1} is an egg.", pkmn.name))
|
||||
next
|
||||
end
|
||||
if battler
|
||||
battler.hp = battler.totalhp
|
||||
battler.status = :NONE
|
||||
else
|
||||
pkmn.heal_HP
|
||||
pkmn.heal_status
|
||||
end
|
||||
}
|
||||
})
|
||||
|
||||
#===============================================================================
|
||||
# Level/stats options
|
||||
#===============================================================================
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :level_stats, {
|
||||
"name" => _INTL("Stats/level..."),
|
||||
"parent" => :main,
|
||||
"usage" => :both
|
||||
})
|
||||
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :set_stat_stages, {
|
||||
"name" => _INTL("Set stat stages"),
|
||||
"parent" => :level_stats,
|
||||
"usage" => :battler,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
if pkmn.egg?
|
||||
pbMessage("\\ts[]" + _INTL("{1} is an egg.", pkmn.name))
|
||||
next
|
||||
end
|
||||
cmd = 0
|
||||
loop do
|
||||
commands = []
|
||||
stat_ids = []
|
||||
GameData::Stat.each_battle do |stat|
|
||||
command_name = stat.name + ": "
|
||||
command_name += "+" if battler.stages[stat.id] > 0
|
||||
command_name += battler.stages[stat.id].to_s
|
||||
commands.push(command_name)
|
||||
stat_ids.push(stat.id)
|
||||
end
|
||||
commands.push(_INTL("[Reset all]"))
|
||||
cmd = pbMessage("\\ts[]" + _INTL("Choose a stat stage to change."), commands, -1, nil, cmd)
|
||||
break if cmd < 0
|
||||
if cmd < stat_ids.length # Set a stat
|
||||
params = ChooseNumberParams.new
|
||||
params.setRange(-6, 6)
|
||||
params.setNegativesAllowed(true)
|
||||
params.setDefaultValue(battler.stages[stat_ids[cmd]])
|
||||
value = pbMessageChooseNumber(
|
||||
"\\ts[]" + _INTL("Set the stage for {1}.", GameData::Stat.get(stat_ids[cmd]).name), params
|
||||
)
|
||||
battler.stages[stat_ids[cmd]] = value
|
||||
else # Reset all stats
|
||||
GameData::Stat.each_battle { |stat| battler.stages[stat.id] = 0 }
|
||||
end
|
||||
end
|
||||
}
|
||||
})
|
||||
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :set_stat_values, {
|
||||
"name" => _INTL("Set stat values"),
|
||||
"parent" => :level_stats,
|
||||
"usage" => :battler,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
if pkmn.egg?
|
||||
pbMessage("\\ts[]" + _INTL("{1} is an egg.", pkmn.name))
|
||||
next
|
||||
end
|
||||
stat_ids = []
|
||||
stat_vals = []
|
||||
GameData::Stat.each_main_battle do |stat|
|
||||
stat_ids.push(stat.id)
|
||||
case stat.id
|
||||
when :ATTACK then stat_vals.push(battler.attack)
|
||||
when :DEFENSE then stat_vals.push(battler.defense)
|
||||
when :SPECIAL_ATTACK then stat_vals.push(battler.spatk)
|
||||
when :SPECIAL_DEFENSE then stat_vals.push(battler.spdef)
|
||||
when :SPEED then stat_vals.push(battler.speed)
|
||||
else stat_vals.push(1)
|
||||
end
|
||||
end
|
||||
cmd = 0
|
||||
loop do
|
||||
commands = []
|
||||
GameData::Stat.each_main_battle do |stat|
|
||||
command_name = stat.name + ": " + stat_vals[stat_ids.index(stat.id)].to_s
|
||||
commands.push(command_name)
|
||||
end
|
||||
commands.push(_INTL("[Reset all]"))
|
||||
cmd = pbMessage("\\ts[]" + _INTL("Choose a stat value to change."), commands, -1, nil, cmd)
|
||||
break if cmd < 0
|
||||
if cmd < stat_ids.length # Set a stat
|
||||
params = ChooseNumberParams.new
|
||||
params.setRange(1, 9999)
|
||||
params.setDefaultValue(stat_vals[cmd])
|
||||
value = pbMessageChooseNumber(
|
||||
"\\ts[]" + _INTL("Set the value for {1}.", GameData::Stat.get(stat_ids[cmd]).name), params
|
||||
)
|
||||
case stat_ids[cmd]
|
||||
when :ATTACK then battler.attack = value
|
||||
when :DEFENSE then battler.defense = value
|
||||
when :SPECIAL_ATTACK then battler.spatk = value
|
||||
when :SPECIAL_DEFENSE then battler.spdef = value
|
||||
when :SPEED then battler.speed = value
|
||||
end
|
||||
stat_vals[cmd] = value
|
||||
else # Reset all stat values
|
||||
battler.pbUpdate
|
||||
GameData::Stat.each_main_battle do |stat|
|
||||
case stat.id
|
||||
when :ATTACK then stat_vals[stat_ids.index(stat.id)] = battler.attack
|
||||
when :DEFENSE then stat_vals[stat_ids.index(stat.id)] = battler.defense
|
||||
when :SPECIAL_ATTACK then stat_vals[stat_ids.index(stat.id)] = battler.spatk
|
||||
when :SPECIAL_DEFENSE then stat_vals[stat_ids.index(stat.id)] = battler.spdef
|
||||
when :SPEED then stat_vals[stat_ids.index(stat.id)] = battler.speed
|
||||
else stat_vals[stat_ids.index(stat.id)] = 1
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
}
|
||||
})
|
||||
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :set_level, {
|
||||
"name" => _INTL("Set level"),
|
||||
"parent" => :level_stats,
|
||||
"usage" => :both,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
if pkmn.egg?
|
||||
pbMessage("\\ts[]" + _INTL("{1} is an egg.", pkmn.name))
|
||||
next
|
||||
end
|
||||
params = ChooseNumberParams.new
|
||||
params.setRange(1, GameData::GrowthRate.max_level)
|
||||
params.setDefaultValue(pkmn.level)
|
||||
level = pbMessageChooseNumber(
|
||||
"\\ts[]" + _INTL("Set the Pokémon's level (max. {1}).", params.maxNumber), params
|
||||
)
|
||||
if level != pkmn.level
|
||||
pkmn.level = level
|
||||
pkmn.calc_stats
|
||||
battler&.pbUpdate
|
||||
end
|
||||
}
|
||||
})
|
||||
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :set_exp, {
|
||||
"name" => _INTL("Set Exp"),
|
||||
"parent" => :level_stats,
|
||||
"usage" => :both,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
if pkmn.egg?
|
||||
pbMessage("\\ts[]" + _INTL("{1} is an egg.", pkmn.name))
|
||||
next
|
||||
end
|
||||
min_exp = pkmn.growth_rate.minimum_exp_for_level(pkmn.level)
|
||||
max_exp = pkmn.growth_rate.minimum_exp_for_level(pkmn.level + 1)
|
||||
if min_exp == max_exp
|
||||
pbMessage("\\ts[]" + _INTL("{1} is at the maximum level.", pkmn.name))
|
||||
next
|
||||
end
|
||||
params = ChooseNumberParams.new
|
||||
params.setRange(min_exp, max_exp - 1)
|
||||
params.setDefaultValue(pkmn.exp)
|
||||
new_exp = pbMessageChooseNumber(
|
||||
"\\ts[]" + _INTL("Set the Pokémon's Exp (range {1}-{2}).", min_exp, max_exp - 1), params
|
||||
)
|
||||
pkmn.exp = new_exp if new_exp != pkmn.exp
|
||||
}
|
||||
})
|
||||
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :hidden_values, {
|
||||
"name" => _INTL("EV/IV..."),
|
||||
"parent" => :level_stats,
|
||||
"usage" => :both,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
cmd = 0
|
||||
loop do
|
||||
persid = sprintf("0x%08X", pkmn.personalID)
|
||||
cmd = pbMessage("\\ts[]" + _INTL("Choose hidden values to edit."),
|
||||
[_INTL("Set EVs"), _INTL("Set IVs")], -1, nil, cmd)
|
||||
break if cmd < 0
|
||||
case cmd
|
||||
when 0 # Set EVs
|
||||
cmd2 = 0
|
||||
loop do
|
||||
total_evs = 0
|
||||
ev_commands = []
|
||||
ev_id = []
|
||||
GameData::Stat.each_main do |s|
|
||||
ev_commands.push(s.name + " (#{pkmn.ev[s.id]})")
|
||||
ev_id.push(s.id)
|
||||
total_evs += pkmn.ev[s.id]
|
||||
end
|
||||
ev_commands.push(_INTL("Randomise all"))
|
||||
ev_commands.push(_INTL("Max randomise all"))
|
||||
cmd2 = pbMessage("\\ts[]" + _INTL("Change which EV?\nTotal: {1}/{2} ({3}%)",
|
||||
total_evs, Pokemon::EV_LIMIT, 100 * total_evs / Pokemon::EV_LIMIT),
|
||||
ev_commands, -1, nil, cmd2)
|
||||
break if cmd2 < 0
|
||||
if cmd2 < ev_id.length
|
||||
params = ChooseNumberParams.new
|
||||
upperLimit = 0
|
||||
GameData::Stat.each_main { |s| upperLimit += pkmn.ev[s.id] if s.id != ev_id[cmd2] }
|
||||
upperLimit = Pokemon::EV_LIMIT - upperLimit
|
||||
upperLimit = [upperLimit, Pokemon::EV_STAT_LIMIT].min
|
||||
thisValue = [pkmn.ev[ev_id[cmd2]], upperLimit].min
|
||||
params.setRange(0, upperLimit)
|
||||
params.setDefaultValue(thisValue)
|
||||
params.setCancelValue(thisValue)
|
||||
f = pbMessageChooseNumber("\\ts[]" + _INTL("Set the EV for {1} (max. {2}).",
|
||||
GameData::Stat.get(ev_id[cmd2]).name, upperLimit), params)
|
||||
if f != pkmn.ev[ev_id[cmd2]]
|
||||
pkmn.ev[ev_id[cmd2]] = f
|
||||
pkmn.calc_stats
|
||||
battler&.pbUpdate
|
||||
end
|
||||
else # (Max) Randomise all
|
||||
evTotalTarget = Pokemon::EV_LIMIT
|
||||
if cmd2 == ev_commands.length - 2 # Randomize all (not max)
|
||||
evTotalTarget = rand(Pokemon::EV_LIMIT)
|
||||
end
|
||||
GameData::Stat.each_main { |s| pkmn.ev[s.id] = 0 }
|
||||
while evTotalTarget > 0
|
||||
r = rand(ev_id.length)
|
||||
next if pkmn.ev[ev_id[r]] >= Pokemon::EV_STAT_LIMIT
|
||||
addVal = 1 + rand(Pokemon::EV_STAT_LIMIT / 4)
|
||||
addVal = addVal.clamp(0, evTotalTarget)
|
||||
addVal = addVal.clamp(0, Pokemon::EV_STAT_LIMIT - pkmn.ev[ev_id[r]])
|
||||
next if addVal == 0
|
||||
pkmn.ev[ev_id[r]] += addVal
|
||||
evTotalTarget -= addVal
|
||||
end
|
||||
pkmn.calc_stats
|
||||
battler&.pbUpdate
|
||||
end
|
||||
end
|
||||
when 1 # Set IVs
|
||||
cmd2 = 0
|
||||
loop do
|
||||
hiddenpower = pbHiddenPower(pkmn)
|
||||
totaliv = 0
|
||||
ivcommands = []
|
||||
iv_id = []
|
||||
GameData::Stat.each_main do |s|
|
||||
ivcommands.push(s.name + " (#{pkmn.iv[s.id]})")
|
||||
iv_id.push(s.id)
|
||||
totaliv += pkmn.iv[s.id]
|
||||
end
|
||||
msg = _INTL("Change which IV?\nHidden Power: {1}, power {2}\nTotal: {3}/{4} ({5}%)",
|
||||
GameData::Type.get(hiddenpower[0]).name, hiddenpower[1], totaliv,
|
||||
iv_id.length * Pokemon::IV_STAT_LIMIT, 100 * totaliv / (iv_id.length * Pokemon::IV_STAT_LIMIT))
|
||||
ivcommands.push(_INTL("Randomise all"))
|
||||
cmd2 = pbMessage("\\ts[]\\l[3]" + msg, ivcommands, -1, nil, cmd2)
|
||||
break if cmd2 < 0
|
||||
if cmd2 < iv_id.length
|
||||
params = ChooseNumberParams.new
|
||||
params.setRange(0, Pokemon::IV_STAT_LIMIT)
|
||||
params.setDefaultValue(pkmn.iv[iv_id[cmd2]])
|
||||
params.setCancelValue(pkmn.iv[iv_id[cmd2]])
|
||||
f = pbMessageChooseNumber("\\ts[]" + _INTL("Set the IV for {1} (max. 31).",
|
||||
GameData::Stat.get(iv_id[cmd2]).name), params)
|
||||
if f != pkmn.iv[iv_id[cmd2]]
|
||||
pkmn.iv[iv_id[cmd2]] = f
|
||||
pkmn.calc_stats
|
||||
battler&.pbUpdate
|
||||
end
|
||||
else # Randomise all
|
||||
GameData::Stat.each_main { |s| pkmn.iv[s.id] = rand(Pokemon::IV_STAT_LIMIT + 1) }
|
||||
pkmn.calc_stats
|
||||
battler&.pbUpdate
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
}
|
||||
})
|
||||
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :set_happiness, {
|
||||
"name" => _INTL("Set happiness"),
|
||||
"parent" => :level_stats,
|
||||
"usage" => :both,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
params = ChooseNumberParams.new
|
||||
params.setRange(0, 255)
|
||||
params.setDefaultValue(pkmn.happiness)
|
||||
h = pbMessageChooseNumber("\\ts[]" + _INTL("Set the Pokémon's happiness (max. 255)."), params)
|
||||
pkmn.happiness = h if h != pkmn.happiness
|
||||
}
|
||||
})
|
||||
|
||||
#===============================================================================
|
||||
# Types
|
||||
#===============================================================================
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :set_types, {
|
||||
"name" => _INTL("Set types"),
|
||||
"parent" => :main,
|
||||
"usage" => :battler,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
max_main_types = 2 # The most types a Pokémon can have normally
|
||||
cmd = 0
|
||||
loop do
|
||||
commands = []
|
||||
types = []
|
||||
max_main_types.times do |i|
|
||||
type = battler.types[i]
|
||||
type_name = (type) ? GameData::Type.get(type).name : "-"
|
||||
commands.push(_INTL("Type {1}: {2}", i + 1, type_name))
|
||||
types.push(type)
|
||||
end
|
||||
extra_type = battler.effects[PBEffects::Type3]
|
||||
extra_type_name = (extra_type) ? GameData::Type.get(extra_type).name : "-"
|
||||
commands.push(_INTL("Extra type: {1}", extra_type_name))
|
||||
types.push(extra_type)
|
||||
msg = _INTL("Effective types: {1}", battler.pbTypes(true).map { |t| GameData::Type.get(t).name }.join("/"))
|
||||
msg += "\r\n" + _INTL("(Change a type to itself to remove it.)")
|
||||
cmd = pbMessage("\\ts[]" + msg, commands, -1, nil, cmd)
|
||||
break if cmd < 0
|
||||
old_type = types[cmd]
|
||||
new_type = pbChooseTypeList(old_type)
|
||||
if new_type
|
||||
if new_type == old_type
|
||||
if pbConfirmMessage(_INTL("Remove this type?"))
|
||||
if cmd < max_main_types
|
||||
battler.types[cmd] = nil
|
||||
else
|
||||
battler.effects[PBEffects::Type3] = nil
|
||||
end
|
||||
battler.types.compact!
|
||||
end
|
||||
elsif cmd < max_main_types
|
||||
battler.types[cmd] = new_type
|
||||
else
|
||||
battler.effects[PBEffects::Type3] = new_type
|
||||
end
|
||||
end
|
||||
end
|
||||
}
|
||||
})
|
||||
|
||||
#===============================================================================
|
||||
# Moves options
|
||||
#===============================================================================
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :moves, {
|
||||
"name" => _INTL("Moves..."),
|
||||
"parent" => :main,
|
||||
"usage" => :both
|
||||
})
|
||||
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :teach_move, {
|
||||
"name" => _INTL("Teach move"),
|
||||
"parent" => :moves,
|
||||
"usage" => :both,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
if pkmn.numMoves >= Pokemon::MAX_MOVES
|
||||
pbMessage("\\ts[]" + _INTL("{1} already knows {2} moves. It needs to forget one first.",
|
||||
pkmn.name, pkmn.numMoves))
|
||||
next
|
||||
end
|
||||
new_move = pbChooseMoveList
|
||||
next if !new_move
|
||||
move_name = GameData::Move.get(new_move).name
|
||||
if pkmn.hasMove?(new_move)
|
||||
pbMessage("\\ts[]" + _INTL("{1} already knows {2}.", pkmn.name, move_name))
|
||||
next
|
||||
end
|
||||
pkmn.learn_move(new_move)
|
||||
battler&.moves&.push(Battle::Move.from_pokemon_move(self, pkmn.moves.last))
|
||||
pbMessage("\\ts[]" + _INTL("{1} learned {2}!", pkmn.name, move_name))
|
||||
}
|
||||
})
|
||||
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :forget_move, {
|
||||
"name" => _INTL("Forget move"),
|
||||
"parent" => :moves,
|
||||
"usage" => :both,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
move_names = []
|
||||
move_indices = []
|
||||
pkmn.moves.each_with_index do |move, index|
|
||||
next if !move || !move.id
|
||||
if move.total_pp <= 0
|
||||
move_names.push(_INTL("{1} (PP: ---)", move.name))
|
||||
else
|
||||
move_names.push(_INTL("{1} (PP: {2}/{3})", move.name, move.pp, move.total_pp))
|
||||
end
|
||||
move_indices.push(index)
|
||||
end
|
||||
cmd = pbMessage("\\ts[]" + _INTL("Forget which move?"), move_names, -1)
|
||||
next if cmd < 0
|
||||
old_move_name = pkmn.moves[move_indices[cmd]].name
|
||||
pkmn.forget_move_at_index(move_indices[cmd])
|
||||
battler&.moves&.delete_at(move_indices[cmd])
|
||||
pbMessage("\\ts[]" + _INTL("{1} forgot {2}.", pkmn.name, old_move_name))
|
||||
}
|
||||
})
|
||||
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :set_move_pp, {
|
||||
"name" => _INTL("Set move PP"),
|
||||
"parent" => :moves,
|
||||
"usage" => :both,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
cmd = 0
|
||||
loop do
|
||||
move_names = []
|
||||
move_indices = []
|
||||
pkmn.moves.each_with_index do |move, index|
|
||||
next if !move || !move.id
|
||||
if move.total_pp <= 0
|
||||
move_names.push(_INTL("{1} (PP: ---)", move.name))
|
||||
else
|
||||
move_names.push(_INTL("{1} (PP: {2}/{3})", move.name, move.pp, move.total_pp))
|
||||
end
|
||||
move_indices.push(index)
|
||||
end
|
||||
commands = move_names + [_INTL("Restore all PP")]
|
||||
cmd = pbMessage("\\ts[]" + _INTL("Alter PP of which move?"), commands, -1, nil, cmd)
|
||||
break if cmd < 0
|
||||
if cmd >= 0 && cmd < move_names.length # Move
|
||||
move = pkmn.moves[move_indices[cmd]]
|
||||
move_name = move.name
|
||||
if move.total_pp <= 0
|
||||
pbMessage("\\ts[]" + _INTL("{1} has infinite PP.", move_name))
|
||||
else
|
||||
cmd2 = 0
|
||||
loop do
|
||||
msg = _INTL("{1}: PP {2}/{3} (PP Up {4}/3)", move_name, move.pp, move.total_pp, move.ppup)
|
||||
cmd2 = pbMessage("\\ts[]" + msg,
|
||||
[_INTL("Set PP"), _INTL("Full PP"), _INTL("Set PP Up")], -1, nil, cmd2)
|
||||
break if cmd2 < 0
|
||||
case cmd2
|
||||
when 0 # Change PP
|
||||
params = ChooseNumberParams.new
|
||||
params.setRange(0, move.total_pp)
|
||||
params.setDefaultValue(move.pp)
|
||||
h = pbMessageChooseNumber(
|
||||
"\\ts[]" + _INTL("Set PP of {1} (max. {2}).", move_name, move.total_pp), params
|
||||
)
|
||||
move.pp = h
|
||||
if battler && battler.moves[move_indices[cmd]].id == move.id
|
||||
battler.moves[move_indices[cmd]].pp = move.pp
|
||||
end
|
||||
when 1 # Full PP
|
||||
move.pp = move.total_pp
|
||||
if battler && battler.moves[move_indices[cmd]].id == move.id
|
||||
battler.moves[move_indices[cmd]].pp = move.pp
|
||||
end
|
||||
when 2 # Change PP Up
|
||||
params = ChooseNumberParams.new
|
||||
params.setRange(0, 3)
|
||||
params.setDefaultValue(move.ppup)
|
||||
h = pbMessageChooseNumber(
|
||||
"\\ts[]" + _INTL("Set PP Up of {1} (max. 3).", move_name), params
|
||||
)
|
||||
move.ppup = h
|
||||
move.pp = move.total_pp if move.pp > move.total_pp
|
||||
if battler && battler.moves[move_indices[cmd]].id == move.id
|
||||
battler.moves[move_indices[cmd]].pp = move.pp
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
elsif cmd == commands.length - 1 # Restore all PP
|
||||
pkmn.heal_PP
|
||||
if battler
|
||||
battler.moves.each { |m| m.pp = m.total_pp }
|
||||
end
|
||||
end
|
||||
end
|
||||
}
|
||||
})
|
||||
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :reset_moves, {
|
||||
"name" => _INTL("Reset moves"),
|
||||
"parent" => :moves,
|
||||
"usage" => :pokemon,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
next if !pbConfirmMessage(_INTL("Replace Pokémon's moves with ones it would know if it was wild?"))
|
||||
pkmn.reset_moves
|
||||
pbMessage("\\ts[]" + _INTL("{1}'s moves were reset.", pkmn.name))
|
||||
}
|
||||
})
|
||||
|
||||
#===============================================================================
|
||||
# Other options
|
||||
#===============================================================================
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :set_item, {
|
||||
"name" => _INTL("Set item"),
|
||||
"parent" => :main,
|
||||
"usage" => :both,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
cmd = 0
|
||||
commands = [
|
||||
_INTL("Change item"),
|
||||
_INTL("Remove item")
|
||||
]
|
||||
loop do
|
||||
msg = (pkmn.hasItem?) ? _INTL("Item is {1}.", pkmn.item.name) : _INTL("No item.")
|
||||
cmd = pbMessage("\\ts[]" + msg, commands, -1, nil, cmd)
|
||||
break if cmd < 0
|
||||
case cmd
|
||||
when 0 # Change item
|
||||
item = pbChooseItemList(pkmn.item_id)
|
||||
if item && item != pkmn.item_id
|
||||
(battler || pkmn).item = item
|
||||
if GameData::Item.get(item).is_mail?
|
||||
pkmn.mail = Mail.new(item, _INTL("Text"), $player.name)
|
||||
end
|
||||
end
|
||||
when 1 # Remove item
|
||||
if pkmn.hasItem?
|
||||
(battler || pkmn).item = nil
|
||||
pkmn.mail = nil
|
||||
end
|
||||
else
|
||||
break
|
||||
end
|
||||
end
|
||||
}
|
||||
})
|
||||
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :set_ability, {
|
||||
"name" => _INTL("Set ability"),
|
||||
"parent" => :main,
|
||||
"usage" => :both,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
cmd = 0
|
||||
commands = []
|
||||
commands.push(_INTL("Set ability for Pokémon"))
|
||||
commands.push(_INTL("Set ability for battler")) if battler
|
||||
commands.push(_INTL("Reset"))
|
||||
loop do
|
||||
if battler
|
||||
msg = _INTL("Battler's ability is {1}. Pokémon's ability is {2}.",
|
||||
battler.abilityName, pkmn.ability.name)
|
||||
else
|
||||
msg = _INTL("Pokémon's ability is {1}.", pkmn.ability.name)
|
||||
end
|
||||
cmd = pbMessage("\\ts[]" + msg, commands, -1, nil, cmd)
|
||||
break if cmd < 0
|
||||
cmd = 2 if cmd >= 1 && !battler # Correct command for Pokémon (no battler)
|
||||
case cmd
|
||||
when 0 # Set ability for Pokémon
|
||||
new_ability = pbChooseAbilityList(pkmn.ability_id)
|
||||
if new_ability && new_ability != pkmn.ability_id
|
||||
pkmn.ability = new_ability
|
||||
battler.ability = pkmn.ability if battler
|
||||
end
|
||||
when 1 # Set ability for battler
|
||||
if battler
|
||||
new_ability = pbChooseAbilityList(battler.ability_id)
|
||||
if new_ability && new_ability != battler.ability_id
|
||||
battler.ability = new_ability
|
||||
end
|
||||
else
|
||||
pbMessage(_INTL("This Pokémon isn't in battle."))
|
||||
end
|
||||
when 2 # Reset
|
||||
pkmn.ability_index = nil
|
||||
pkmn.ability = nil
|
||||
battler.ability = pkmn.ability if battler
|
||||
end
|
||||
end
|
||||
}
|
||||
})
|
||||
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :set_nature, {
|
||||
"name" => _INTL("Set nature"),
|
||||
"parent" => :main,
|
||||
"usage" => :both,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
commands = []
|
||||
ids = []
|
||||
GameData::Nature.each do |nature|
|
||||
if nature.stat_changes.length == 0
|
||||
commands.push(_INTL("{1} (---)", nature.real_name))
|
||||
else
|
||||
plus_text = ""
|
||||
minus_text = ""
|
||||
nature.stat_changes.each do |change|
|
||||
if change[1] > 0
|
||||
plus_text += "/" if !plus_text.empty?
|
||||
plus_text += GameData::Stat.get(change[0]).name_brief
|
||||
elsif change[1] < 0
|
||||
minus_text += "/" if !minus_text.empty?
|
||||
minus_text += GameData::Stat.get(change[0]).name_brief
|
||||
end
|
||||
end
|
||||
commands.push(_INTL("{1} (+{2}, -{3})", nature.real_name, plus_text, minus_text))
|
||||
end
|
||||
ids.push(nature.id)
|
||||
end
|
||||
commands.push(_INTL("[Reset]"))
|
||||
cmd = ids.index(pkmn.nature_id || ids[0])
|
||||
loop do
|
||||
msg = _INTL("Nature is {1}.", pkmn.nature.name)
|
||||
cmd = pbMessage("\\ts[]" + msg, commands, -1, nil, cmd)
|
||||
break if cmd < 0
|
||||
if cmd >= 0 && cmd < commands.length - 1 # Set nature
|
||||
pkmn.nature = ids[cmd]
|
||||
elsif cmd == commands.length - 1 # Reset
|
||||
pkmn.nature = nil
|
||||
end
|
||||
battler&.pbUpdate
|
||||
end
|
||||
}
|
||||
})
|
||||
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :set_gender, {
|
||||
"name" => _INTL("Set gender"),
|
||||
"parent" => :main,
|
||||
"usage" => :both,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
if pkmn.singleGendered?
|
||||
pbMessage("\\ts[]" + _INTL("{1} is single-gendered or genderless.", pkmn.speciesName))
|
||||
next
|
||||
end
|
||||
cmd = 0
|
||||
loop do
|
||||
msg = [_INTL("Gender is male."), _INTL("Gender is female.")][pkmn.male? ? 0 : 1]
|
||||
cmd = pbMessage("\\ts[]" + msg,
|
||||
[_INTL("Make male"), _INTL("Make female"), _INTL("Reset")], -1, nil, cmd)
|
||||
break if cmd < 0
|
||||
case cmd
|
||||
when 0 # Make male
|
||||
pkmn.makeMale
|
||||
pbMessage("\\ts[]" + _INTL("{1}'s gender couldn't be changed.", pkmn.name)) if !pkmn.male?
|
||||
when 1 # Make female
|
||||
pkmn.makeFemale
|
||||
pbMessage("\\ts[]" + _INTL("{1}'s gender couldn't be changed.", pkmn.name)) if !pkmn.female?
|
||||
when 2 # Reset
|
||||
pkmn.gender = nil
|
||||
end
|
||||
end
|
||||
}
|
||||
})
|
||||
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :set_form, {
|
||||
"name" => _INTL("Set form"),
|
||||
"parent" => :main,
|
||||
"usage" => :both,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
cmd = 0
|
||||
formcmds = [[], []]
|
||||
GameData::Species.each do |sp|
|
||||
next if sp.species != pkmn.species
|
||||
form_name = sp.form_name
|
||||
form_name = _INTL("Unnamed form") if !form_name || form_name.empty?
|
||||
form_name = sprintf("%d: %s", sp.form, form_name)
|
||||
formcmds[0].push(sp.form)
|
||||
formcmds[1].push(form_name)
|
||||
cmd = formcmds[0].length - 1 if pkmn.form == sp.form
|
||||
end
|
||||
if formcmds[0].length <= 1
|
||||
pbMessage("\\ts[]" + _INTL("Species {1} only has one form.", pkmn.speciesName))
|
||||
next
|
||||
end
|
||||
loop do
|
||||
cmd = pbMessage("\\ts[]" + _INTL("Form is {1}.", pkmn.form), formcmds[1], -1, nil, cmd)
|
||||
break if cmd < 0
|
||||
f = formcmds[0][cmd]
|
||||
next if f == pkmn.form
|
||||
pkmn.forced_form = nil
|
||||
if MultipleForms.hasFunction?(pkmn, "getForm")
|
||||
next if !pbConfirmMessage(_INTL("This species decides its own form. Override?"))
|
||||
pkmn.forced_form = f
|
||||
end
|
||||
pkmn.form_simple = f
|
||||
battler.form = pkmn.form if battler
|
||||
end
|
||||
}
|
||||
})
|
||||
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :set_species, {
|
||||
"name" => _INTL("Set species"),
|
||||
"parent" => :main,
|
||||
"usage" => :both,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
species = pbChooseSpeciesList(pkmn.species)
|
||||
if species && species != pkmn.species
|
||||
pkmn.species = species
|
||||
battler.species = species if battler
|
||||
battler&.pbUpdate(true)
|
||||
battler.name = pkmn.name if battler
|
||||
end
|
||||
}
|
||||
})
|
||||
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :set_shininess, {
|
||||
"name" => _INTL("Set shininess"),
|
||||
"parent" => :main,
|
||||
"usage" => :both,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
cmd = 0
|
||||
loop do
|
||||
msg_idx = pkmn.shiny? ? (pkmn.super_shiny? ? 1 : 0) : 2
|
||||
msg = [_INTL("Is shiny."), _INTL("Is super shiny."), _INTL("Is normal (not shiny).")][msg_idx]
|
||||
cmd = pbMessage("\\ts[]" + msg,
|
||||
[_INTL("Make shiny"),
|
||||
_INTL("Make super shiny"),
|
||||
_INTL("Make normal"),
|
||||
_INTL("Reset")], -1, nil, cmd)
|
||||
break if cmd < 0
|
||||
case cmd
|
||||
when 0 # Make shiny
|
||||
pkmn.shiny = true
|
||||
pkmn.super_shiny = false
|
||||
when 1 # Make super shiny
|
||||
pkmn.super_shiny = true
|
||||
when 2 # Make normal
|
||||
pkmn.shiny = false
|
||||
pkmn.super_shiny = false
|
||||
when 3 # Reset
|
||||
pkmn.shiny = nil
|
||||
pkmn.super_shiny = nil
|
||||
end
|
||||
end
|
||||
}
|
||||
})
|
||||
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :shadow_pokemon, {
|
||||
"name" => _INTL("Shadow Pokémon"),
|
||||
"parent" => :main,
|
||||
"usage" => :battler,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
if battler.shadowPokemon?
|
||||
loop do
|
||||
if battler.inHyperMode?
|
||||
msg = _INTL("Shadow Pokémon (in Hyper Mode)")
|
||||
else
|
||||
msg = _INTL("Shadow Pokémon (not in Hyper Mode)")
|
||||
end
|
||||
cmd = pbMessage("\\ts[]" + msg, [_INTL("Toggle Hyper Mode"), _INTL("Cancel")], -1, nil, 0)
|
||||
break if cmd != 0
|
||||
if battler.inHyperMode?
|
||||
pkmn.hyper_mode = false
|
||||
elsif battler.fainted? || !battler.pbOwnedByPlayer?
|
||||
pbMessage("\\ts[]" + _INTL("Pokémon is fainted or not the player's. Can't put it in Hyper Mode."))
|
||||
else
|
||||
pkmn.hyper_mode = true
|
||||
end
|
||||
end
|
||||
else
|
||||
pbMessage("\\ts[]" + _INTL("Pokémon is not a Shadow Pokémon."))
|
||||
end
|
||||
}
|
||||
})
|
||||
|
||||
MenuHandlers.add(:battle_pokemon_debug_menu, :set_effects, {
|
||||
"name" => _INTL("Set effects"),
|
||||
"parent" => :main,
|
||||
"usage" => :battler,
|
||||
"effect" => proc { |pkmn, battler, battle|
|
||||
editor = Battle::DebugSetEffects.new(battle, :battler, battler.index)
|
||||
editor.update
|
||||
editor.dispose
|
||||
}
|
||||
})
|
||||
Reference in New Issue
Block a user