mirror of
https://github.com/infinitefusion/infinitefusion-e18.git
synced 2025-12-07 21:24:59 +00:00
1085 lines
36 KiB
Ruby
1085 lines
36 KiB
Ruby
#===============================================================================
|
|
#
|
|
#===============================================================================
|
|
module PokemonDebugMenuCommands
|
|
@@commands = HandlerHashBasic.new
|
|
|
|
def self.register(option, hash)
|
|
@@commands.add(option, hash)
|
|
end
|
|
|
|
def self.registerIf(condition, hash)
|
|
@@commands.addIf(condition, hash)
|
|
end
|
|
|
|
def self.copy(option, *new_options)
|
|
@@commands.copy(option, *new_options)
|
|
end
|
|
|
|
def self.each
|
|
@@commands.each { |key, hash| yield key, hash }
|
|
end
|
|
|
|
def self.hasFunction?(option, function)
|
|
option_hash = @@commands[option]
|
|
return option_hash && option_hash.keys.include?(function)
|
|
end
|
|
|
|
def self.getFunction(option, function)
|
|
option_hash = @@commands[option]
|
|
return (option_hash && option_hash[function]) ? option_hash[function] : nil
|
|
end
|
|
|
|
def self.call(function, option, *args)
|
|
option_hash = @@commands[option]
|
|
return nil if !option_hash || !option_hash[function]
|
|
return (option_hash[function].call(*args) == true)
|
|
end
|
|
end
|
|
|
|
#===============================================================================
|
|
# HP/Status options
|
|
#===============================================================================
|
|
PokemonDebugMenuCommands.register("hpstatusmenu", {
|
|
"parent" => "main",
|
|
"name" => _INTL("HP/Status..."),
|
|
"always_show" => true
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("sethp", {
|
|
"parent" => "hpstatusmenu",
|
|
"name" => _INTL("Set HP"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
if pkmn.egg?
|
|
screen.pbDisplay(_INTL("{1} is an egg.", pkmn.name))
|
|
else
|
|
params = ChooseNumberParams.new
|
|
params.setRange(0, pkmn.totalhp)
|
|
params.setDefaultValue(pkmn.hp)
|
|
newhp = pbMessageChooseNumber(
|
|
_INTL("Set {1}'s HP (max. {2}).", pkmn.name, pkmn.totalhp), params) { screen.pbUpdate }
|
|
if newhp != pkmn.hp
|
|
pkmn.hp = newhp
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("setstatus", {
|
|
"parent" => "hpstatusmenu",
|
|
"name" => _INTL("Set status"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
if pkmn.egg?
|
|
screen.pbDisplay(_INTL("{1} is an egg.", pkmn.name))
|
|
elsif pkmn.hp<=0
|
|
screen.pbDisplay(_INTL("{1} is fainted, can't change status.", pkmn.name))
|
|
else
|
|
cmd = 0
|
|
loop do
|
|
cmd = screen.pbShowCommands(_INTL("Set {1}'s status.", pkmn.name), [
|
|
_INTL("[Cure]"),
|
|
_INTL("Sleep"),
|
|
_INTL("Poison"),
|
|
_INTL("Burn"),
|
|
_INTL("Paralysis"),
|
|
_INTL("Frozen")
|
|
], cmd)
|
|
break if cmd < 0
|
|
case cmd
|
|
when 0 # Cure
|
|
pkmn.healStatus
|
|
screen.pbDisplay(_INTL("{1}'s status was cured.", pkmn.name))
|
|
screen.pbRefreshSingle(pkmnid)
|
|
else # Give status problem
|
|
count = 0
|
|
cancel = false
|
|
if cmd == PBStatuses::SLEEP
|
|
params = ChooseNumberParams.new
|
|
params.setRange(0, 9)
|
|
params.setDefaultValue(3)
|
|
count = pbMessageChooseNumber(
|
|
_INTL("Set the Pokémon's sleep count."), params) { screen.pbUpdate }
|
|
cancel = true if count <= 0
|
|
end
|
|
if !cancel
|
|
pkmn.status = cmd
|
|
pkmn.statusCount = count
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("fullheal", {
|
|
"parent" => "hpstatusmenu",
|
|
"name" => _INTL("Fully heal"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
if pkmn.egg?
|
|
screen.pbDisplay(_INTL("{1} is an egg.", pkmn.name))
|
|
else
|
|
pkmn.heal
|
|
screen.pbDisplay(_INTL("{1} was fully healed.", pkmn.name))
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("makefainted", {
|
|
"parent" => "hpstatusmenu",
|
|
"name" => _INTL("Make fainted"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
if pkmn.egg?
|
|
screen.pbDisplay(_INTL("{1} is an egg.", pkmn.name))
|
|
else
|
|
pkmn.hp = 0
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("setpokerus", {
|
|
"parent" => "hpstatusmenu",
|
|
"name" => _INTL("Set Pokérus"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
cmd = 0
|
|
loop do
|
|
pokerus = (pkmn.pokerus) ? pkmn.pokerus : 0
|
|
msg = [_INTL("{1} doesn't have Pokérus.", pkmn.name),
|
|
_INTL("Has strain {1}, infectious for {2} more days.", pokerus / 16, pokerus % 16),
|
|
_INTL("Has strain {1}, not infectious.", pokerus / 16)][pkmn.pokerusStage]
|
|
cmd = screen.pbShowCommands(msg, [
|
|
_INTL("Give random strain"),
|
|
_INTL("Make not infectious"),
|
|
_INTL("Clear Pokérus")], cmd)
|
|
break if cmd < 0
|
|
case cmd
|
|
when 0 # Give random strain
|
|
pkmn.givePokerus
|
|
screen.pbRefreshSingle(pkmnid)
|
|
when 1 # Make not infectious
|
|
if pokerus > 0
|
|
strain = pokerus / 16
|
|
p = strain << 4
|
|
pkmn.pokerus = p
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
when 2 # Clear Pokérus
|
|
pkmn.pokerus = 0
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
end
|
|
}
|
|
})
|
|
|
|
#===============================================================================
|
|
# Level/stats options
|
|
#===============================================================================
|
|
PokemonDebugMenuCommands.register("levelstats", {
|
|
"parent" => "main",
|
|
"name" => _INTL("Level/stats..."),
|
|
"always_show" => true
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("setlevel", {
|
|
"parent" => "levelstats",
|
|
"name" => _INTL("Set level"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
if pkmn.egg?
|
|
screen.pbDisplay(_INTL("{1} is an egg.", pkmn.name))
|
|
else
|
|
mLevel = PBExperience.maxLevel
|
|
params = ChooseNumberParams.new
|
|
params.setRange(1, mLevel)
|
|
params.setDefaultValue(pkmn.level)
|
|
level = pbMessageChooseNumber(
|
|
_INTL("Set the Pokémon's level (max. {1}).", mLevel), params) { screen.pbUpdate }
|
|
if level != pkmn.level
|
|
pkmn.level = level
|
|
pkmn.calcStats
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("setexp", {
|
|
"parent" => "levelstats",
|
|
"name" => _INTL("Set Exp"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
if pkmn.egg?
|
|
screen.pbDisplay(_INTL("{1} is an egg.", pkmn.name))
|
|
else
|
|
minxp = PBExperience.pbGetStartExperience(pkmn.level, pkmn.growthrate)
|
|
maxxp = PBExperience.pbGetStartExperience(pkmn.level + 1, pkmn.growthrate)
|
|
if minxp == maxxp
|
|
screen.pbDisplay(_INTL("{1} is at the maximum level.", pkmn.name))
|
|
else
|
|
params = ChooseNumberParams.new
|
|
params.setRange(minxp, maxxp - 1)
|
|
params.setDefaultValue(pkmn.exp)
|
|
newexp = pbMessageChooseNumber(
|
|
_INTL("Set the Pokémon's Exp (range {1}-{2}).",minxp, maxxp - 1), params) { screen.pbUpdate }
|
|
if newexp != pkmn.exp
|
|
pkmn.exp = newexp
|
|
pkmn.calcStats
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
end
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("hiddenvalues", {
|
|
"parent" => "levelstats",
|
|
"name" => _INTL("EV/IV/pID..."),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
numstats = 6
|
|
cmd = 0
|
|
loop do
|
|
persid = sprintf("0x%08X", pkmn.personalID)
|
|
cmd = screen.pbShowCommands(_INTL("Personal ID is {1}.", persid), [
|
|
_INTL("Set EVs"),
|
|
_INTL("Set IVs"),
|
|
_INTL("Randomise pID")], cmd)
|
|
break if cmd < 0
|
|
case cmd
|
|
when 0 # Set EVs
|
|
cmd2 = 0
|
|
loop do
|
|
totalev = 0
|
|
evcommands = []
|
|
for i in 0...numstats
|
|
evcommands.push(PBStats.getName(i) + " (#{pkmn.ev[i]})")
|
|
totalev += pkmn.ev[i]
|
|
end
|
|
evcommands.push(_INTL("Randomise all"))
|
|
evcommands.push(_INTL("Max randomise all"))
|
|
cmd2 = screen.pbShowCommands(_INTL("Change which EV?\nTotal: {1}/{2} ({3}%)",
|
|
totalev, Pokemon::EV_LIMIT,
|
|
100 * totalev / Pokemon::EV_LIMIT), evcommands, cmd2)
|
|
break if cmd2 < 0
|
|
if cmd2 < numstats
|
|
params = ChooseNumberParams.new
|
|
upperLimit = 0
|
|
for i in 0...numstats
|
|
upperLimit += pkmn.ev[i] if i != cmd2
|
|
end
|
|
upperLimit = Pokemon::EV_LIMIT - upperLimit
|
|
upperLimit = [upperLimit, Pokemon::EV_STAT_LIMIT].min
|
|
thisValue = [pkmn.ev[cmd2], upperLimit].min
|
|
params.setRange(0, upperLimit)
|
|
params.setDefaultValue(thisValue)
|
|
params.setCancelValue(thisValue)
|
|
f = pbMessageChooseNumber(_INTL("Set the EV for {1} (max. {2}).",
|
|
PBStats.getName(cmd2), upperLimit), params) { screen.pbUpdate }
|
|
if f != pkmn.ev[cmd2]
|
|
pkmn.ev[cmd2] = f
|
|
pkmn.calcStats
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
elsif cmd2 < evcommands.length # Randomise
|
|
evTotalTarget = Pokemon::EV_LIMIT
|
|
if cmd2 == evcommands.length - 2
|
|
evTotalTarget = rand(Pokemon::EV_LIMIT)
|
|
end
|
|
for i in 0...numstats
|
|
pkmn.ev[i] = 0
|
|
end
|
|
while evTotalTarget > 0
|
|
r = rand(numstats)
|
|
next if pkmn.ev[r] >= Pokemon::EV_STAT_LIMIT
|
|
addVal = 1 + rand(Pokemon::EV_STAT_LIMIT/4)
|
|
addVal = evTotalTarget if addVal > evTotalTarget
|
|
addVal = [addVal, Pokemon::EV_STAT_LIMIT - pkmn.ev[r]].min
|
|
next if addVal == 0
|
|
pkmn.ev[r] += addVal
|
|
evTotalTarget -= addVal
|
|
end
|
|
pkmn.calcStats
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
end
|
|
when 1 # Set IVs
|
|
cmd2 = 0
|
|
loop do
|
|
hiddenpower = pbHiddenPower(pkmn)
|
|
totaliv = 0
|
|
ivcommands = []
|
|
for i in 0...numstats
|
|
ivcommands.push(PBStats.getName(i) + " (#{pkmn.iv[i]})")
|
|
totaliv += pkmn.iv[i]
|
|
end
|
|
msg = _INTL("Change which IV?\nHidden Power:\n{1}, power {2}\nTotal: {3}/{4} ({5}%)",
|
|
GameData::Type.get(hiddenpower[0]).name, hiddenpower[1], totaliv, numstats * 31,
|
|
100 * totaliv / (numstats * 31))
|
|
ivcommands.push(_INTL("Randomise all"))
|
|
cmd2 = screen.pbShowCommands(msg, ivcommands, cmd2)
|
|
break if cmd2 < 0
|
|
if cmd2 < numstats
|
|
params = ChooseNumberParams.new
|
|
params.setRange(0, 31)
|
|
params.setDefaultValue(pkmn.iv[cmd2])
|
|
params.setCancelValue(pkmn.iv[cmd2])
|
|
f = pbMessageChooseNumber(_INTL("Set the IV for {1} (max. 31).",
|
|
PBStats.getName(cmd2)), params) { screen.pbUpdate }
|
|
if f != pkmn.iv[cmd2]
|
|
pkmn.iv[cmd2] = f
|
|
pkmn.calcStats
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
elsif cmd2 == ivcommands.length - 1 # Randomise
|
|
for i in 0...numstats
|
|
pkmn.iv[i] = rand(Pokemon::IV_STAT_LIMIT + 1)
|
|
end
|
|
pkmn.calcStats
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
end
|
|
when 2 # Randomise pID
|
|
pkmn.personalID = rand(2 ** 16) | rand(2 ** 16) << 16
|
|
pkmn.calcStats
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("sethappiness", {
|
|
"parent" => "levelstats",
|
|
"name" => _INTL("Set happiness"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
params = ChooseNumberParams.new
|
|
params.setRange(0, 255)
|
|
params.setDefaultValue(pkmn.happiness)
|
|
h = pbMessageChooseNumber(
|
|
_INTL("Set the Pokémon's happiness (max. 255)."), params) { screen.pbUpdate }
|
|
if h != pkmn.happiness
|
|
pkmn.happiness = h
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("conteststats", {
|
|
"parent" => "levelstats",
|
|
"name" => _INTL("Contest stats..."),
|
|
"always_show" => true
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("setbeauty", {
|
|
"parent" => "conteststats",
|
|
"name" => _INTL("Set Beauty"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
params = ChooseNumberParams.new
|
|
params.setRange(0, 255)
|
|
params.setDefaultValue(pkmn.beauty)
|
|
newval = pbMessageChooseNumber(
|
|
_INTL("Set the Pokémon's Beauty (max. 255)."), params) { screen.pbUpdate }
|
|
if newval != pkmn.beauty
|
|
pkmn.beauty = newval
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("setcool", {
|
|
"parent" => "conteststats",
|
|
"name" => _INTL("Set Cool"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
params = ChooseNumberParams.new
|
|
params.setRange(0, 255)
|
|
params.setDefaultValue(pkmn.cool)
|
|
newval = pbMessageChooseNumber(
|
|
_INTL("Set the Pokémon's Cool (max. 255)."), params) { screen.pbUpdate }
|
|
if newval != pkmn.cool
|
|
pkmn.cool = newval
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("setcute", {
|
|
"parent" => "conteststats",
|
|
"name" => _INTL("Set Cute"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
params = ChooseNumberParams.new
|
|
params.setRange(0, 255)
|
|
params.setDefaultValue(pkmn.cute)
|
|
newval = pbMessageChooseNumber(
|
|
_INTL("Set the Pokémon's Cute (max. 255)."), params) { screen.pbUpdate }
|
|
if newval != pkmn.cute
|
|
pkmn.cute = newval
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("setsmart", {
|
|
"parent" => "conteststats",
|
|
"name" => _INTL("Set Smart"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
params = ChooseNumberParams.new
|
|
params.setRange(0, 255)
|
|
params.setDefaultValue(pkmn.smart)
|
|
newval = pbMessageChooseNumber(
|
|
_INTL("Set the Pokémon's Smart (max. 255)."), params) { screen.pbUpdate }
|
|
if newval != pkmn.smart
|
|
pkmn.smart = newval
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("settough", {
|
|
"parent" => "conteststats",
|
|
"name" => _INTL("Set Tough"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
params = ChooseNumberParams.new
|
|
params.setRange(0, 255)
|
|
params.setDefaultValue(pkmn.tough)
|
|
newval = pbMessageChooseNumber(
|
|
_INTL("Set the Pokémon's Tough (max. 255)."), params) { screen.pbUpdate }
|
|
if newval != pkmn.tough
|
|
pkmn.tough = newval
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("setsheen", {
|
|
"parent" => "conteststats",
|
|
"name" => _INTL("Set Sheen"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
params = ChooseNumberParams.new
|
|
params.setRange(0, 255)
|
|
params.setDefaultValue(pkmn.sheen)
|
|
newval = pbMessageChooseNumber(
|
|
_INTL("Set the Pokémon's Sheen (max. 255)."), params) { screen.pbUpdate }
|
|
if newval != pkmn.sheen
|
|
pkmn.sheen = newval
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
}
|
|
})
|
|
|
|
#===============================================================================
|
|
# Moves options
|
|
#===============================================================================
|
|
PokemonDebugMenuCommands.register("moves", {
|
|
"parent" => "main",
|
|
"name" => _INTL("Moves..."),
|
|
"always_show" => true
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("teachmove", {
|
|
"parent" => "moves",
|
|
"name" => _INTL("Teach move"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
move = pbChooseMoveList
|
|
if move
|
|
pbLearnMove(pkmn, move)
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("forgetmove", {
|
|
"parent" => "moves",
|
|
"name" => _INTL("Forget move"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
moveindex = screen.pbChooseMove(pkmn, _INTL("Choose move to forget."))
|
|
if moveindex >= 0
|
|
movename = pkmn.moves[moveindex].name
|
|
pkmn.pbDeleteMoveAtIndex(moveindex)
|
|
screen.pbDisplay(_INTL("{1} forgot {2}.", pkmn.name, movename))
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("resetmoves", {
|
|
"parent" => "moves",
|
|
"name" => _INTL("Reset moves"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
pkmn.resetMoves
|
|
screen.pbDisplay(_INTL("{1}'s moves were reset.", pkmn.name))
|
|
screen.pbRefreshSingle(pkmnid)
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("setmovepp", {
|
|
"parent" => "moves",
|
|
"name" => _INTL("Set move PP"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
cmd = 0
|
|
loop do
|
|
commands = []
|
|
for i in pkmn.moves
|
|
break if !i.id
|
|
if i.total_pp <= 0
|
|
commands.push(_INTL("{1} (PP: ---)", i.name))
|
|
else
|
|
commands.push(_INTL("{1} (PP: {2}/{3})", i.name, i.pp, i.total_pp))
|
|
end
|
|
end
|
|
commands.push(_INTL("Restore all PP"))
|
|
cmd = screen.pbShowCommands(_INTL("Alter PP of which move?"), commands, cmd)
|
|
break if cmd < 0
|
|
if cmd >= 0 && cmd < commands.length - 1 # Move
|
|
move = pkmn.moves[cmd]
|
|
movename = move.name
|
|
if move.total_pp <= 0
|
|
screen.pbDisplay(_INTL("{1} has infinite PP.", movename))
|
|
else
|
|
cmd2 = 0
|
|
loop do
|
|
msg = _INTL("{1}: PP {2}/{3} (PP Up {4}/3)", movename, move.pp, move.total_pp, move.ppup)
|
|
cmd2 = screen.pbShowCommands(msg, [
|
|
_INTL("Set PP"),
|
|
_INTL("Full PP"),
|
|
_INTL("Set PP Up")], 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(
|
|
_INTL("Set PP of {1} (max. {2}).", movename, move.total_pp), params) { screen.pbUpdate }
|
|
move.pp = h
|
|
when 1 # Full PP
|
|
move.pp = move.total_pp
|
|
when 2 # Change PP Up
|
|
params = ChooseNumberParams.new
|
|
params.setRange(0, 3)
|
|
params.setDefaultValue(move.ppup)
|
|
h = pbMessageChooseNumber(
|
|
_INTL("Set PP Up of {1} (max. 3).", movename), params) { screen.pbUpdate }
|
|
move.ppup = h
|
|
move.pp = move.total_pp if move.pp > move.total_pp
|
|
end
|
|
end
|
|
end
|
|
elsif cmd == commands.length - 1 # Restore all PP
|
|
pkmn.healPP
|
|
end
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("setinitialmoves", {
|
|
"parent" => "moves",
|
|
"name" => _INTL("Reset initial moves"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
pkmn.pbRecordFirstMoves
|
|
screen.pbDisplay(_INTL("{1}'s moves were set as its first-known moves.", pkmn.name))
|
|
screen.pbRefreshSingle(pkmnid)
|
|
}
|
|
})
|
|
|
|
#===============================================================================
|
|
# Other options
|
|
#===============================================================================
|
|
PokemonDebugMenuCommands.register("setability", {
|
|
"parent" => "main",
|
|
"name" => _INTL("Set ability"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
cmd = 0
|
|
loop do
|
|
abils = pkmn.getAbilityList
|
|
oldabil = (pkmn.ability) ? pkmn.ability.name : "No ability"
|
|
commands = []
|
|
for i in abils
|
|
commands.push(((i[1] < 2) ? "" : "(H) ") + GameData::Ability.get(i[0]).name)
|
|
end
|
|
commands.push(_INTL("Remove override"))
|
|
msg = [_INTL("Ability {1} is natural.", oldabil),
|
|
_INTL("Ability {1} is being forced.", oldabil)][pkmn.abilityflag != nil ? 1 : 0]
|
|
cmd = screen.pbShowCommands(msg, commands, cmd)
|
|
break if cmd < 0
|
|
if cmd >= 0 && cmd < abils.length # Set ability override
|
|
pkmn.setAbility(abils[cmd][1])
|
|
elsif cmd == abils.length # Remove override
|
|
pkmn.abilityflag = nil
|
|
end
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("setnature", {
|
|
"parent" => "main",
|
|
"name" => _INTL("Set nature"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
commands = []
|
|
(PBNatures.getCount).times do |i|
|
|
statUp = PBNatures.getStatRaised(i)
|
|
statDown = PBNatures.getStatLowered(i)
|
|
if statUp != statDown
|
|
text = _INTL("{1} (+{2}, -{3})", PBNatures.getName(i),
|
|
PBStats.getNameBrief(statUp), PBStats.getNameBrief(statDown))
|
|
else
|
|
text = _INTL("{1} (---)", PBNatures.getName(i))
|
|
end
|
|
commands.push(text)
|
|
end
|
|
commands.push(_INTL("[Remove override]"))
|
|
cmd = pkmn.nature
|
|
loop do
|
|
oldnature = PBNatures.getName(pkmn.nature)
|
|
msg = [_INTL("Nature {1} is natural.", oldnature),
|
|
_INTL("Nature {1} is being forced.", oldnature)][pkmn.natureflag ? 1 : 0]
|
|
cmd = screen.pbShowCommands(msg, commands, cmd)
|
|
break if cmd < 0
|
|
if cmd >= 0 && cmd < PBNatures.getCount # Set nature override
|
|
pkmn.setNature(cmd)
|
|
pkmn.calcStats
|
|
elsif cmd == PBNatures.getCount # Remove override
|
|
pkmn.natureflag = nil
|
|
end
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("setgender", {
|
|
"parent" => "main",
|
|
"name" => _INTL("Set gender"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
if pkmn.singleGendered?
|
|
screen.pbDisplay(_INTL("{1} is single-gendered or genderless.", pkmn.speciesName))
|
|
else
|
|
cmd = 0
|
|
loop do
|
|
oldgender = (pkmn.male?) ? _INTL("male") : _INTL("female")
|
|
msg = [_INTL("Gender {1} is natural.", oldgender),
|
|
_INTL("Gender {1} is being forced.", oldgender)][pkmn.genderflag ? 1 : 0]
|
|
cmd = screen.pbShowCommands(msg, [
|
|
_INTL("Make male"),
|
|
_INTL("Make female"),
|
|
_INTL("Remove override")], cmd)
|
|
break if cmd < 0
|
|
case cmd
|
|
when 0 # Make male
|
|
pkmn.makeMale
|
|
if !pkmn.male?
|
|
screen.pbDisplay(_INTL("{1}'s gender couldn't be changed.", pkmn.name))
|
|
end
|
|
when 1 # Make female
|
|
pkmn.makeFemale
|
|
if !pkmn.female?
|
|
screen.pbDisplay(_INTL("{1}'s gender couldn't be changed.", pkmn.name))
|
|
end
|
|
when 2 # Remove override
|
|
pkmn.genderflag = nil
|
|
end
|
|
pbSeenForm(pkmn) if !settingUpBattle
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("speciesform", {
|
|
"parent" => "main",
|
|
"name" => _INTL("Species/form..."),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
cmd = 0
|
|
loop do
|
|
msg = [_INTL("Species {1}, form {2}.", pkmn.speciesName, pkmn.form),
|
|
_INTL("Species {1}, form {2} (forced).", pkmn.speciesName, pkmn.form)][(pkmn.forcedForm != nil) ? 1 : 0]
|
|
cmd = screen.pbShowCommands(msg, [
|
|
_INTL("Set species"),
|
|
_INTL("Set form"),
|
|
_INTL("Remove override")], cmd)
|
|
break if cmd < 0
|
|
case cmd
|
|
when 0 # Set species
|
|
species = pbChooseSpeciesList(pkmn.species)
|
|
if species && species != pkmn.species
|
|
pkmn.species = species
|
|
pkmn.calcStats
|
|
pbSeenForm(pkmn) if !settingUpBattle
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
when 1 # Set form
|
|
cmd2 = 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)
|
|
cmd2 = sp.form if pkmn.form == sp.form
|
|
end
|
|
if formcmds[0].length <= 1
|
|
screen.pbDisplay(_INTL("Species {1} only has one form.", pkmn.speciesName))
|
|
else
|
|
cmd2 = screen.pbShowCommands(_INTL("Set the Pokémon's form."), formcmds[1], cmd2)
|
|
next if cmd2 < 0
|
|
f = formcmds[0][cmd2]
|
|
if f != pkmn.form
|
|
if MultipleForms.hasFunction?(pkmn, "getForm")
|
|
next if !screen.pbConfirm(_INTL("This species decides its own form. Override?"))
|
|
pkmn.forcedForm = f
|
|
end
|
|
pkmn.form = f
|
|
pbSeenForm(pkmn) if !settingUpBattle
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
end
|
|
when 2 # Remove override
|
|
pkmn.forcedForm = nil
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
end
|
|
}
|
|
})
|
|
|
|
#===============================================================================
|
|
# Cosmetic options
|
|
#===============================================================================
|
|
PokemonDebugMenuCommands.register("cosmetic", {
|
|
"parent" => "main",
|
|
"name" => _INTL("Cosmetic info..."),
|
|
"always_show" => true
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("setshininess", {
|
|
"parent" => "cosmetic",
|
|
"name" => _INTL("Set shininess"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
cmd = 0
|
|
loop do
|
|
oldshiny = (pkmn.shiny?) ? _INTL("shiny") : _INTL("normal")
|
|
msg = [_INTL("Shininess ({1}) is natural.", oldshiny),
|
|
_INTL("Shininess ({1}) is being forced.", oldshiny)][pkmn.shinyflag != nil ? 1 : 0]
|
|
cmd = screen.pbShowCommands(msg, [
|
|
_INTL("Make shiny"),
|
|
_INTL("Make normal"),
|
|
_INTL("Remove override")], cmd)
|
|
break if cmd < 0
|
|
case cmd
|
|
when 0 # Make shiny
|
|
pkmn.makeShiny
|
|
when 1 # Make normal
|
|
pkmn.makeNotShiny
|
|
when 2 # Remove override
|
|
pkmn.shinyflag = nil
|
|
end
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("setpokeball", {
|
|
"parent" => "cosmetic",
|
|
"name" => _INTL("Set Poké Ball"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
commands = []
|
|
balls = []
|
|
for key in $BallTypes.keys
|
|
item = GameData::Item.try_get($BallTypes[key])
|
|
balls.push([key.to_i, item.name]) if item
|
|
end
|
|
balls.sort! { |a, b| a[1] <=> b[1] }
|
|
cmd = 0
|
|
for i in 0...balls.length
|
|
next if balls[i][0] != pkmn.ballused
|
|
cmd = i
|
|
break
|
|
end
|
|
balls.each { |ball| commands.push(ball[1]) }
|
|
loop do
|
|
oldball = pbBallTypeToItem(pkmn.ballused).name
|
|
cmd = screen.pbShowCommands(_INTL("{1} used.", oldball), commands, cmd)
|
|
break if cmd < 0
|
|
pkmn.ballused = balls[cmd][0]
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("setribbons", {
|
|
"parent" => "cosmetic",
|
|
"name" => _INTL("Set ribbons"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
cmd = 0
|
|
loop do
|
|
commands = []
|
|
for i in 1..PBRibbons.maxValue
|
|
commands.push(_INTL("{1} {2}",
|
|
(pkmn.hasRibbon?(i)) ? "[Y]" : "[ ]", PBRibbons.getName(i)))
|
|
end
|
|
commands.push(_INTL("Give all"))
|
|
commands.push(_INTL("Clear all"))
|
|
cmd = screen.pbShowCommands(_INTL("{1} ribbons.", pkmn.ribbonCount), commands, cmd)
|
|
break if cmd < 0
|
|
if cmd >= 0 && cmd < PBRibbons.maxValue # Toggle ribbon
|
|
if pkmn.hasRibbon?(cmd + 1)
|
|
pkmn.takeRibbon(cmd + 1)
|
|
else
|
|
pkmn.giveRibbon(cmd + 1)
|
|
end
|
|
elsif cmd == commands.length - 2 # Give all
|
|
for i in 1..PBRibbons.maxValue
|
|
pkmn.giveRibbon(i)
|
|
end
|
|
elsif cmd == commands.length - 1 # Clear all
|
|
for i in 1..PBRibbons.maxValue
|
|
pkmn.takeRibbon(i)
|
|
end
|
|
end
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("setnickname", {
|
|
"parent" => "cosmetic",
|
|
"name" => _INTL("Set nickname"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
cmd = 0
|
|
loop do
|
|
speciesname = pkmn.speciesName
|
|
msg = [_INTL("{1} has the nickname {2}.", speciesname, pkmn.name),
|
|
_INTL("{1} has no nickname.", speciesname)][pkmn.name == speciesname ? 1 : 0]
|
|
cmd = screen.pbShowCommands(msg, [
|
|
_INTL("Rename"),
|
|
_INTL("Erase name")], cmd)
|
|
break if cmd < 0
|
|
case cmd
|
|
when 0 # Rename
|
|
oldname = (pkmn.name && pkmn.name != speciesname) ? pkmn.name : ""
|
|
newname = pbEnterPokemonName(_INTL("{1}'s nickname?", speciesname),
|
|
0, Pokemon::MAX_NAME_SIZE, oldname, pkmn)
|
|
if newname && newname != ""
|
|
pkmn.name = newname
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
when 1 # Erase name
|
|
pkmn.name = speciesname
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("ownership", {
|
|
"parent" => "cosmetic",
|
|
"name" => _INTL("Ownership..."),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
cmd = 0
|
|
loop do
|
|
gender = [_INTL("Male"), _INTL("Female"), _INTL("Unknown")][pkmn.owner.gender]
|
|
msg = [_INTL("Player's Pokémon\n{1}\n{2}\n{3} ({4})", pkmn.owner.name, gender, pkmn.owner.public_id, pkmn.owner.id),
|
|
_INTL("Foreign Pokémon\n{1}\n{2}\n{3} ({4})", pkmn.owner.name, gender, pkmn.owner.public_id, pkmn.owner.id)
|
|
][pkmn.foreign?($Trainer) ? 1 : 0]
|
|
cmd = screen.pbShowCommands(msg, [
|
|
_INTL("Make player's"),
|
|
_INTL("Set OT's name"),
|
|
_INTL("Set OT's gender"),
|
|
_INTL("Random foreign ID"),
|
|
_INTL("Set foreign ID")], cmd)
|
|
break if cmd < 0
|
|
case cmd
|
|
when 0 # Make player's
|
|
pkmn.owner = Pokemon::Owner.new_from_trainer($Trainer)
|
|
when 1 # Set OT's name
|
|
pkmn.owner.name = pbEnterPlayerName(_INTL("{1}'s OT's name?", pkmn.name), 1, MAX_PLAYER_NAME_SIZE)
|
|
when 2 # Set OT's gender
|
|
cmd2 = screen.pbShowCommands(_INTL("Set OT's gender."),
|
|
[_INTL("Male"), _INTL("Female"), _INTL("Unknown")], pkmn.owner.gender)
|
|
pkmn.owner.gender = cmd2 if cmd2 >= 0
|
|
when 3 # Random foreign ID
|
|
pkmn.owner.id = $Trainer.getForeignID
|
|
when 4 # Set foreign ID
|
|
params = ChooseNumberParams.new
|
|
params.setRange(0, 65535)
|
|
params.setDefaultValue(pkmn.owner.public_id)
|
|
val = pbMessageChooseNumber(
|
|
_INTL("Set the new ID (max. 65535)."), params) { screen.pbUpdate }
|
|
pkmn.owner.id = val | val << 16
|
|
end
|
|
end
|
|
}
|
|
})
|
|
|
|
#===============================================================================
|
|
# Other options
|
|
#===============================================================================
|
|
PokemonDebugMenuCommands.register("setegg", {
|
|
"parent" => "main",
|
|
"name" => _INTL("Set egg"),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
cmd = 0
|
|
loop do
|
|
msg = [_INTL("Not an egg"),
|
|
_INTL("Egg with eggsteps: {1}.", pkmn.eggsteps)][pkmn.egg? ? 1 : 0]
|
|
cmd = screen.pbShowCommands(msg, [
|
|
_INTL("Make egg"),
|
|
_INTL("Make Pokémon"),
|
|
_INTL("Set eggsteps to 1")], cmd)
|
|
break if cmd < 0
|
|
case cmd
|
|
when 0 # Make egg
|
|
if !pkmn.egg? && (pbHasEgg?(pkmn.species) ||
|
|
screen.pbConfirm(_INTL("{1} cannot legally be an egg. Make egg anyway?", pkmn.speciesName)))
|
|
pkmn.level = EGG_LEVEL
|
|
pkmn.calcStats
|
|
pkmn.name = _INTL("Egg")
|
|
pkmn.eggsteps = pkmn.species_data.hatch_steps
|
|
pkmn.hatchedMap = 0
|
|
pkmn.obtainMode = 1
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
when 1 # Make Pokémon
|
|
if pkmn.egg?
|
|
pkmn.name = pkmn.speciesName
|
|
pkmn.eggsteps = 0
|
|
pkmn.hatchedMap = 0
|
|
pkmn.obtainMode = 0
|
|
screen.pbRefreshSingle(pkmnid)
|
|
end
|
|
when 2 # Set eggsteps to 1
|
|
pkmn.eggsteps = 1 if pkmn.egg?
|
|
end
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("shadowpkmn", {
|
|
"parent" => "main",
|
|
"name" => _INTL("Shadow Pkmn..."),
|
|
"always_show" => true,
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
cmd = 0
|
|
loop do
|
|
msg = [_INTL("Not a Shadow Pokémon."),
|
|
_INTL("Heart gauge is {1} (stage {2}).", pkmn.heartgauge, pkmn.heartStage)
|
|
][pkmn.shadowPokemon? ? 1 : 0]
|
|
cmd = screen.pbShowCommands(msg, [
|
|
_INTL("Make Shadow"),
|
|
_INTL("Set heart gauge")], cmd)
|
|
break if cmd < 0
|
|
case cmd
|
|
when 0 # Make Shadow
|
|
if !pkmn.shadowPokemon?
|
|
pkmn.makeShadow
|
|
screen.pbRefreshSingle(pkmnid)
|
|
else
|
|
screen.pbDisplay(_INTL("{1} is already a Shadow Pokémon.", pkmn.name))
|
|
end
|
|
when 1 # Set heart gauge
|
|
if pkmn.shadowPokemon?
|
|
oldheart = pkmn.heartgauge
|
|
params = ChooseNumberParams.new
|
|
params.setRange(0, Pokemon::HEARTGAUGESIZE)
|
|
params.setDefaultValue(pkmn.heartgauge)
|
|
val = pbMessageChooseNumber(
|
|
_INTL("Set the heart gauge (max. {1}).", Pokemon::HEARTGAUGESIZE),
|
|
params) { screen.pbUpdate }
|
|
if val != oldheart
|
|
pkmn.adjustHeart(val - oldheart)
|
|
pbReadyToPurify(pkmn)
|
|
end
|
|
else
|
|
screen.pbDisplay(_INTL("{1} is not a Shadow Pokémon.", pkmn.name))
|
|
end
|
|
end
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("mysterygift", {
|
|
"parent" => "main",
|
|
"name" => _INTL("Mystery Gift"),
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
pbCreateMysteryGift(0, pkmn)
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("duplicate", {
|
|
"parent" => "main",
|
|
"name" => _INTL("Duplicate"),
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
if screen.pbConfirm(_INTL("Are you sure you want to copy this Pokémon?"))
|
|
clonedpkmn = pkmn.clone
|
|
if screen.is_a?(PokemonPartyScreen)
|
|
pbStorePokemon(clonedpkmn)
|
|
screen.pbHardRefresh
|
|
screen.pbDisplay(_INTL("The Pokémon was duplicated."))
|
|
elsif screen.is_a?(PokemonStorageScreen)
|
|
if screen.storage.pbMoveCaughtToParty(clonedpkmn)
|
|
if pkmnid[0] != -1
|
|
screen.pbDisplay(_INTL("The duplicated Pokémon was moved to your party."))
|
|
end
|
|
else
|
|
oldbox = screen.storage.currentBox
|
|
newbox = screen.storage.pbStoreCaught(clonedpkmn)
|
|
if newbox < 0
|
|
screen.pbDisplay(_INTL("All boxes are full."))
|
|
elsif newbox != oldbox
|
|
screen.pbDisplay(_INTL("The duplicated Pokémon was moved to box \"{1}.\"", screen.storage[newbox].name))
|
|
screen.storage.currentBox = oldbox
|
|
end
|
|
end
|
|
screen.pbHardRefresh
|
|
end
|
|
next true
|
|
end
|
|
}
|
|
})
|
|
|
|
PokemonDebugMenuCommands.register("delete", {
|
|
"parent" => "main",
|
|
"name" => _INTL("Delete"),
|
|
"effect" => proc { |pkmn, pkmnid, heldpoke, settingUpBattle, screen|
|
|
if screen.pbConfirm(_INTL("Are you sure you want to delete this Pokémon?"))
|
|
if screen.is_a?(PokemonPartyScreen)
|
|
screen.party[pkmnid] = nil
|
|
screen.party.compact!
|
|
screen.pbHardRefresh
|
|
elsif screen.is_a?(PokemonStorageScreen)
|
|
screen.scene.pbRelease(pkmnid, heldpoke)
|
|
(heldpoke) ? screen.heldpkmn = nil : screen.storage.pbDelete(pkmnid[0],pkmnid[1])
|
|
screen.scene.pbRefresh
|
|
end
|
|
next true
|
|
end
|
|
}
|
|
})
|