mirror of
https://github.com/infinitefusion/infinitefusion-e18.git
synced 2025-12-06 06:01:46 +00:00
1338 lines
41 KiB
Ruby
1338 lines
41 KiB
Ruby
#===============================================================================
|
|
# Pokémon party buttons and menu
|
|
#===============================================================================
|
|
class PokemonPartyConfirmCancelSprite < SpriteWrapper
|
|
attr_reader :selected
|
|
|
|
def initialize(text,x,y,narrowbox=false,viewport=nil)
|
|
super(viewport)
|
|
@refreshBitmap = true
|
|
@bgsprite = ChangelingSprite.new(0,0,viewport)
|
|
if narrowbox
|
|
@bgsprite.addBitmap("desel","Graphics/Pictures/Party/icon_cancel_narrow")
|
|
@bgsprite.addBitmap("sel","Graphics/Pictures/Party/icon_cancel_narrow_sel")
|
|
else
|
|
@bgsprite.addBitmap("desel","Graphics/Pictures/Party/icon_cancel")
|
|
@bgsprite.addBitmap("sel","Graphics/Pictures/Party/icon_cancel_sel")
|
|
end
|
|
@bgsprite.changeBitmap("desel")
|
|
@overlaysprite = BitmapSprite.new(@bgsprite.bitmap.width,@bgsprite.bitmap.height,viewport)
|
|
@overlaysprite.z = self.z+1
|
|
pbSetSystemFont(@overlaysprite.bitmap)
|
|
@yoffset = 8
|
|
textpos = [[text,56,(narrowbox) ? 2 : 8,2,Color.new(248,248,248),Color.new(40,40,40)]]
|
|
pbDrawTextPositions(@overlaysprite.bitmap,textpos)
|
|
self.x = x
|
|
self.y = y
|
|
end
|
|
|
|
def dispose
|
|
@bgsprite.dispose
|
|
@overlaysprite.bitmap.dispose
|
|
@overlaysprite.dispose
|
|
super
|
|
end
|
|
|
|
def viewport=(value)
|
|
super
|
|
refresh
|
|
end
|
|
|
|
def x=(value)
|
|
super
|
|
refresh
|
|
end
|
|
|
|
def y=(value)
|
|
super
|
|
refresh
|
|
end
|
|
|
|
def color=(value)
|
|
super
|
|
refresh
|
|
end
|
|
|
|
def selected=(value)
|
|
if @selected!=value
|
|
@selected = value
|
|
refresh
|
|
end
|
|
end
|
|
|
|
def refresh
|
|
if @bgsprite && !@bgsprite.disposed?
|
|
@bgsprite.changeBitmap((@selected) ? "sel" : "desel")
|
|
@bgsprite.x = self.x
|
|
@bgsprite.y = self.y
|
|
@bgsprite.color = self.color
|
|
end
|
|
if @overlaysprite && !@overlaysprite.disposed?
|
|
@overlaysprite.x = self.x
|
|
@overlaysprite.y = self.y
|
|
@overlaysprite.color = self.color
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
class PokemonPartyCancelSprite < PokemonPartyConfirmCancelSprite
|
|
def initialize(viewport=nil)
|
|
super(_INTL("CANCEL"),398,328,false,viewport)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
class PokemonPartyConfirmSprite < PokemonPartyConfirmCancelSprite
|
|
def initialize(viewport=nil)
|
|
super(_INTL("CONFIRM"),398,308,true,viewport)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
class PokemonPartyCancelSprite2 < PokemonPartyConfirmCancelSprite
|
|
def initialize(viewport=nil)
|
|
super(_INTL("CANCEL"),398,346,true,viewport)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
class Window_CommandPokemonColor < Window_CommandPokemon
|
|
def initialize(commands,width=nil)
|
|
@colorKey = []
|
|
for i in 0...commands.length
|
|
if commands[i].is_a?(Array)
|
|
@colorKey[i] = commands[i][1]
|
|
commands[i] = commands[i][0]
|
|
end
|
|
end
|
|
super(commands,width)
|
|
end
|
|
|
|
def drawItem(index,_count,rect)
|
|
pbSetSystemFont(self.contents) if @starting
|
|
rect = drawCursor(index,rect)
|
|
base = self.baseColor
|
|
shadow = self.shadowColor
|
|
if @colorKey[index] && @colorKey[index]==1
|
|
base = Color.new(0,80,160)
|
|
shadow = Color.new(128,192,240)
|
|
end
|
|
pbDrawShadowText(self.contents,rect.x,rect.y,rect.width,rect.height,@commands[index],base,shadow)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
#===============================================================================
|
|
# Pokémon party panels
|
|
#===============================================================================
|
|
class PokemonPartyBlankPanel < SpriteWrapper
|
|
attr_accessor :text
|
|
|
|
def initialize(_pokemon,index,viewport=nil)
|
|
super(viewport)
|
|
self.x = [0, Graphics.width/2][index%2]
|
|
self.y = [0, 16, 96, 112, 192, 208][index]
|
|
@panelbgsprite = AnimatedBitmap.new("Graphics/Pictures/Party/panel_blank")
|
|
self.bitmap = @panelbgsprite.bitmap
|
|
@text = nil
|
|
end
|
|
|
|
def dispose
|
|
@panelbgsprite.dispose
|
|
super
|
|
end
|
|
|
|
def selected; return false; end
|
|
def selected=(value); end
|
|
def preselected; return false; end
|
|
def preselected=(value); end
|
|
def switching; return false; end
|
|
def switching=(value); end
|
|
def refresh; end
|
|
end
|
|
|
|
|
|
|
|
class PokemonPartyPanel < SpriteWrapper
|
|
attr_reader :pokemon
|
|
attr_reader :active
|
|
attr_reader :selected
|
|
attr_reader :preselected
|
|
attr_reader :switching
|
|
attr_reader :text
|
|
|
|
def initialize(pokemon,index,viewport=nil)
|
|
super(viewport)
|
|
@pokemon = pokemon
|
|
@active = (index==0) # true = rounded panel, false = rectangular panel
|
|
@refreshing = true
|
|
self.x = [0, Graphics.width/2][index%2]
|
|
self.y = [0, 16, 96, 112, 192, 208][index]
|
|
@panelbgsprite = ChangelingSprite.new(0,0,viewport)
|
|
@panelbgsprite.z = self.z
|
|
if @active # Rounded panel
|
|
@panelbgsprite.addBitmap("able","Graphics/Pictures/Party/panel_round")
|
|
@panelbgsprite.addBitmap("ablesel","Graphics/Pictures/Party/panel_round_sel")
|
|
@panelbgsprite.addBitmap("fainted","Graphics/Pictures/Party/panel_round_faint")
|
|
@panelbgsprite.addBitmap("faintedsel","Graphics/Pictures/Party/panel_round_faint_sel")
|
|
@panelbgsprite.addBitmap("swap","Graphics/Pictures/Party/panel_round_swap")
|
|
@panelbgsprite.addBitmap("swapsel","Graphics/Pictures/Party/panel_round_swap_sel")
|
|
@panelbgsprite.addBitmap("swapsel2","Graphics/Pictures/Party/panel_round_swap_sel2")
|
|
else # Rectangular panel
|
|
@panelbgsprite.addBitmap("able","Graphics/Pictures/Party/panel_rect")
|
|
@panelbgsprite.addBitmap("ablesel","Graphics/Pictures/Party/panel_rect_sel")
|
|
@panelbgsprite.addBitmap("fainted","Graphics/Pictures/Party/panel_rect_faint")
|
|
@panelbgsprite.addBitmap("faintedsel","Graphics/Pictures/Party/panel_rect_faint_sel")
|
|
@panelbgsprite.addBitmap("swap","Graphics/Pictures/Party/panel_rect_swap")
|
|
@panelbgsprite.addBitmap("swapsel","Graphics/Pictures/Party/panel_rect_swap_sel")
|
|
@panelbgsprite.addBitmap("swapsel2","Graphics/Pictures/Party/panel_rect_swap_sel2")
|
|
end
|
|
@hpbgsprite = ChangelingSprite.new(0,0,viewport)
|
|
@hpbgsprite.z = self.z+1
|
|
@hpbgsprite.addBitmap("able","Graphics/Pictures/Party/overlay_hp_back")
|
|
@hpbgsprite.addBitmap("fainted","Graphics/Pictures/Party/overlay_hp_back_faint")
|
|
@hpbgsprite.addBitmap("swap","Graphics/Pictures/Party/overlay_hp_back_swap")
|
|
@ballsprite = ChangelingSprite.new(0,0,viewport)
|
|
@ballsprite.z = self.z+1
|
|
@ballsprite.addBitmap("desel","Graphics/Pictures/Party/icon_ball")
|
|
@ballsprite.addBitmap("sel","Graphics/Pictures/Party/icon_ball_sel")
|
|
@pkmnsprite = PokemonIconSprite.new(pokemon,viewport)
|
|
@pkmnsprite.setOffset(PictureOrigin::Center)
|
|
@pkmnsprite.active = @active
|
|
@pkmnsprite.z = self.z+2
|
|
@helditemsprite = HeldItemIconSprite.new(0,0,@pokemon,viewport)
|
|
@helditemsprite.z = self.z+3
|
|
@overlaysprite = BitmapSprite.new(Graphics.width,Graphics.height,viewport)
|
|
@overlaysprite.z = self.z+4
|
|
@hpbar = AnimatedBitmap.new("Graphics/Pictures/Party/overlay_hp")
|
|
@statuses = AnimatedBitmap.new(_INTL("Graphics/Pictures/statuses"))
|
|
@selected = false
|
|
@preselected = false
|
|
@switching = false
|
|
@text = nil
|
|
@refreshBitmap = true
|
|
@refreshing = false
|
|
refresh
|
|
end
|
|
|
|
def dispose
|
|
@panelbgsprite.dispose
|
|
@hpbgsprite.dispose
|
|
@ballsprite.dispose
|
|
@pkmnsprite.dispose
|
|
@helditemsprite.dispose
|
|
@overlaysprite.bitmap.dispose
|
|
@overlaysprite.dispose
|
|
@hpbar.dispose
|
|
@statuses.dispose
|
|
super
|
|
end
|
|
|
|
def x=(value)
|
|
super
|
|
refresh
|
|
end
|
|
|
|
def y=(value)
|
|
super
|
|
refresh
|
|
end
|
|
|
|
def color=(value)
|
|
super
|
|
refresh
|
|
end
|
|
|
|
def text=(value)
|
|
if @text!=value
|
|
@text = value
|
|
@refreshBitmap = true
|
|
refresh
|
|
end
|
|
end
|
|
|
|
def pokemon=(value)
|
|
@pokemon = value
|
|
@pkmnsprite.pokemon = value if @pkmnsprite && !@pkmnsprite.disposed?
|
|
@helditemsprite.pokemon = value if @helditemsprite && !@helditemsprite.disposed?
|
|
@refreshBitmap = true
|
|
refresh
|
|
end
|
|
|
|
def selected=(value)
|
|
if @selected!=value
|
|
@selected = value
|
|
refresh
|
|
end
|
|
end
|
|
|
|
def preselected=(value)
|
|
if @preselected!=value
|
|
@preselected = value
|
|
refresh
|
|
end
|
|
end
|
|
|
|
def switching=(value)
|
|
if @switching!=value
|
|
@switching = value
|
|
refresh
|
|
end
|
|
end
|
|
|
|
def hp; return @pokemon.hp; end
|
|
|
|
def refresh
|
|
return if disposed?
|
|
return if @refreshing
|
|
@refreshing = true
|
|
if @panelbgsprite && !@panelbgsprite.disposed?
|
|
if self.selected
|
|
if self.preselected; @panelbgsprite.changeBitmap("swapsel2")
|
|
elsif @switching; @panelbgsprite.changeBitmap("swapsel")
|
|
elsif @pokemon.fainted?; @panelbgsprite.changeBitmap("faintedsel")
|
|
else; @panelbgsprite.changeBitmap("ablesel")
|
|
end
|
|
else
|
|
if self.preselected; @panelbgsprite.changeBitmap("swap")
|
|
elsif @pokemon.fainted?; @panelbgsprite.changeBitmap("fainted")
|
|
else; @panelbgsprite.changeBitmap("able")
|
|
end
|
|
end
|
|
@panelbgsprite.x = self.x
|
|
@panelbgsprite.y = self.y
|
|
@panelbgsprite.color = self.color
|
|
end
|
|
if @hpbgsprite && !@hpbgsprite.disposed?
|
|
@hpbgsprite.visible = (!@pokemon.egg? && !(@text && @text.length>0))
|
|
if @hpbgsprite.visible
|
|
if self.preselected || (self.selected && @switching); @hpbgsprite.changeBitmap("swap")
|
|
elsif @pokemon.fainted?; @hpbgsprite.changeBitmap("fainted")
|
|
else; @hpbgsprite.changeBitmap("able")
|
|
end
|
|
@hpbgsprite.x = self.x+96
|
|
@hpbgsprite.y = self.y+50
|
|
@hpbgsprite.color = self.color
|
|
end
|
|
end
|
|
if @ballsprite && !@ballsprite.disposed?
|
|
@ballsprite.changeBitmap((self.selected) ? "sel" : "desel")
|
|
@ballsprite.x = self.x+10
|
|
@ballsprite.y = self.y
|
|
@ballsprite.color = self.color
|
|
end
|
|
if @pkmnsprite && !@pkmnsprite.disposed?
|
|
@pkmnsprite.x = self.x+60
|
|
@pkmnsprite.y = self.y+40
|
|
@pkmnsprite.color = self.color
|
|
@pkmnsprite.selected = self.selected
|
|
end
|
|
if @helditemsprite && !@helditemsprite.disposed?
|
|
if @helditemsprite.visible
|
|
@helditemsprite.x = self.x+62
|
|
@helditemsprite.y = self.y+48
|
|
@helditemsprite.color = self.color
|
|
end
|
|
end
|
|
if @overlaysprite && !@overlaysprite.disposed?
|
|
@overlaysprite.x = self.x
|
|
@overlaysprite.y = self.y
|
|
@overlaysprite.color = self.color
|
|
end
|
|
if @refreshBitmap
|
|
@refreshBitmap = false
|
|
@overlaysprite.bitmap.clear if @overlaysprite.bitmap
|
|
basecolor = Color.new(248,248,248)
|
|
shadowcolor = Color.new(40,40,40)
|
|
pbSetSystemFont(@overlaysprite.bitmap)
|
|
textpos = []
|
|
# Draw Pokémon name
|
|
textpos.push([@pokemon.name,96,16,0,basecolor,shadowcolor])
|
|
if !@pokemon.egg?
|
|
if !@text || @text.length==0
|
|
# Draw HP numbers
|
|
textpos.push([sprintf("% 3d /% 3d",@pokemon.hp,@pokemon.totalhp),224,60,1,basecolor,shadowcolor])
|
|
# Draw HP bar
|
|
if @pokemon.hp>0
|
|
w = @pokemon.hp*96*1.0/@pokemon.totalhp
|
|
w = 1 if w<1
|
|
w = ((w/2).round)*2
|
|
hpzone = 0
|
|
hpzone = 1 if @pokemon.hp<=(@pokemon.totalhp/2).floor
|
|
hpzone = 2 if @pokemon.hp<=(@pokemon.totalhp/4).floor
|
|
hprect = Rect.new(0,hpzone*8,w,8)
|
|
@overlaysprite.bitmap.blt(128,52,@hpbar.bitmap,hprect)
|
|
end
|
|
# Draw status
|
|
status = -1
|
|
status = 6 if @pokemon.pokerusStage==1
|
|
status = @pokemon.status-1 if @pokemon.status>0
|
|
status = 5 if @pokemon.hp<=0
|
|
if status>=0
|
|
statusrect = Rect.new(0,16*status,44,16)
|
|
@overlaysprite.bitmap.blt(78,68,@statuses.bitmap,statusrect)
|
|
end
|
|
end
|
|
# Draw gender symbol
|
|
if @pokemon.male?
|
|
textpos.push([_INTL("♂"),224,16,0,Color.new(0,112,248),Color.new(120,184,232)])
|
|
elsif @pokemon.female?
|
|
textpos.push([_INTL("♀"),224,16,0,Color.new(232,32,16),Color.new(248,168,184)])
|
|
end
|
|
# Draw shiny icon
|
|
if @pokemon.shiny?
|
|
pbDrawImagePositions(@overlaysprite.bitmap,[[
|
|
"Graphics/Pictures/shiny",80,48,0,0,16,16]])
|
|
end
|
|
end
|
|
pbDrawTextPositions(@overlaysprite.bitmap,textpos)
|
|
# Draw level text
|
|
if !@pokemon.egg?
|
|
pbDrawImagePositions(@overlaysprite.bitmap,[[
|
|
"Graphics/Pictures/Party/overlay_lv",20,70,0,0,22,14]])
|
|
pbSetSmallFont(@overlaysprite.bitmap)
|
|
pbDrawTextPositions(@overlaysprite.bitmap,[
|
|
[@pokemon.level.to_s,42,62,0,basecolor,shadowcolor]
|
|
])
|
|
end
|
|
# Draw annotation text
|
|
if @text && @text.length>0
|
|
pbSetSystemFont(@overlaysprite.bitmap)
|
|
pbDrawTextPositions(@overlaysprite.bitmap,[
|
|
[@text,96,58,0,basecolor,shadowcolor]
|
|
])
|
|
end
|
|
end
|
|
@refreshing = false
|
|
end
|
|
|
|
def update
|
|
super
|
|
@panelbgsprite.update if @panelbgsprite && !@panelbgsprite.disposed?
|
|
@hpbgsprite.update if @hpbgsprite && !@hpbgsprite.disposed?
|
|
@ballsprite.update if @ballsprite && !@ballsprite.disposed?
|
|
@pkmnsprite.update if @pkmnsprite && !@pkmnsprite.disposed?
|
|
@helditemsprite.update if @helditemsprite && !@helditemsprite.disposed?
|
|
end
|
|
end
|
|
|
|
|
|
|
|
#===============================================================================
|
|
# Pokémon party visuals
|
|
#===============================================================================
|
|
class PokemonParty_Scene
|
|
def pbStartScene(party,starthelptext,annotations=nil,multiselect=false)
|
|
@sprites = {}
|
|
@party = party
|
|
@viewport = Viewport.new(0,0,Graphics.width,Graphics.height)
|
|
@viewport.z = 99999
|
|
@multiselect = multiselect
|
|
addBackgroundPlane(@sprites,"partybg","Party/bg",@viewport)
|
|
@sprites["messagebox"] = Window_AdvancedTextPokemon.new("")
|
|
@sprites["messagebox"].viewport = @viewport
|
|
@sprites["messagebox"].visible = false
|
|
@sprites["messagebox"].letterbyletter = true
|
|
pbBottomLeftLines(@sprites["messagebox"],2)
|
|
@sprites["helpwindow"] = Window_UnformattedTextPokemon.new(starthelptext)
|
|
@sprites["helpwindow"].viewport = @viewport
|
|
@sprites["helpwindow"].visible = true
|
|
pbBottomLeftLines(@sprites["helpwindow"],1)
|
|
pbSetHelpText(starthelptext)
|
|
# Add party Pokémon sprites
|
|
for i in 0...6
|
|
if @party[i]
|
|
@sprites["pokemon#{i}"] = PokemonPartyPanel.new(@party[i],i,@viewport)
|
|
else
|
|
@sprites["pokemon#{i}"] = PokemonPartyBlankPanel.new(@party[i],i,@viewport)
|
|
end
|
|
@sprites["pokemon#{i}"].text = annotations[i] if annotations
|
|
end
|
|
if @multiselect
|
|
@sprites["pokemon6"] = PokemonPartyConfirmSprite.new(@viewport)
|
|
@sprites["pokemon7"] = PokemonPartyCancelSprite2.new(@viewport)
|
|
else
|
|
@sprites["pokemon6"] = PokemonPartyCancelSprite.new(@viewport)
|
|
end
|
|
# Select first Pokémon
|
|
@activecmd = 0
|
|
@sprites["pokemon0"].selected = true
|
|
pbFadeInAndShow(@sprites) { update }
|
|
end
|
|
|
|
def pbEndScene
|
|
pbFadeOutAndHide(@sprites) { update }
|
|
pbDisposeSpriteHash(@sprites)
|
|
@viewport.dispose
|
|
end
|
|
|
|
def pbDisplay(text)
|
|
@sprites["messagebox"].text = text
|
|
@sprites["messagebox"].visible = true
|
|
@sprites["helpwindow"].visible = false
|
|
pbPlayDecisionSE
|
|
loop do
|
|
Graphics.update
|
|
Input.update
|
|
self.update
|
|
if @sprites["messagebox"].busy?
|
|
if Input.trigger?(Input::C)
|
|
pbPlayDecisionSE if @sprites["messagebox"].pausing?
|
|
@sprites["messagebox"].resume
|
|
end
|
|
else
|
|
if Input.trigger?(Input::B) || Input.trigger?(Input::C)
|
|
break
|
|
end
|
|
end
|
|
end
|
|
@sprites["messagebox"].visible = false
|
|
@sprites["helpwindow"].visible = true
|
|
end
|
|
|
|
def pbDisplayConfirm(text)
|
|
ret = -1
|
|
@sprites["messagebox"].text = text
|
|
@sprites["messagebox"].visible = true
|
|
@sprites["helpwindow"].visible = false
|
|
using(cmdwindow = Window_CommandPokemon.new([_INTL("Yes"),_INTL("No")])) {
|
|
cmdwindow.visible = false
|
|
pbBottomRight(cmdwindow)
|
|
cmdwindow.y -= @sprites["messagebox"].height
|
|
cmdwindow.z = @viewport.z+1
|
|
loop do
|
|
Graphics.update
|
|
Input.update
|
|
cmdwindow.visible = true if !@sprites["messagebox"].busy?
|
|
cmdwindow.update
|
|
self.update
|
|
if !@sprites["messagebox"].busy?
|
|
if Input.trigger?(Input::B)
|
|
ret = false
|
|
break
|
|
elsif Input.trigger?(Input::C) && @sprites["messagebox"].resume
|
|
ret = (cmdwindow.index==0)
|
|
break
|
|
end
|
|
end
|
|
end
|
|
}
|
|
@sprites["messagebox"].visible = false
|
|
@sprites["helpwindow"].visible = true
|
|
return ret
|
|
end
|
|
|
|
def pbShowCommands(helptext,commands,index=0)
|
|
ret = -1
|
|
helpwindow = @sprites["helpwindow"]
|
|
helpwindow.visible = true
|
|
using(cmdwindow = Window_CommandPokemonColor.new(commands)) {
|
|
cmdwindow.z = @viewport.z+1
|
|
cmdwindow.index = index
|
|
pbBottomRight(cmdwindow)
|
|
helpwindow.resizeHeightToFit(helptext,Graphics.width-cmdwindow.width)
|
|
helpwindow.text = helptext
|
|
pbBottomLeft(helpwindow)
|
|
loop do
|
|
Graphics.update
|
|
Input.update
|
|
cmdwindow.update
|
|
self.update
|
|
if Input.trigger?(Input::B)
|
|
pbPlayCancelSE
|
|
ret = -1
|
|
break
|
|
elsif Input.trigger?(Input::C)
|
|
pbPlayDecisionSE
|
|
ret = cmdwindow.index
|
|
break
|
|
end
|
|
end
|
|
}
|
|
return ret
|
|
end
|
|
|
|
def pbSetHelpText(helptext)
|
|
helpwindow = @sprites["helpwindow"]
|
|
pbBottomLeftLines(helpwindow,1)
|
|
helpwindow.text = helptext
|
|
helpwindow.width = 398
|
|
helpwindow.visible = true
|
|
end
|
|
|
|
def pbHasAnnotations?
|
|
return @sprites["pokemon0"].text!=nil
|
|
end
|
|
|
|
def pbAnnotate(annot)
|
|
for i in 0...6
|
|
@sprites["pokemon#{i}"].text = (annot) ? annot[i] : nil
|
|
end
|
|
end
|
|
|
|
def pbSelect(item)
|
|
@activecmd = item
|
|
numsprites = (@multiselect) ? 8 : 7
|
|
for i in 0...numsprites
|
|
@sprites["pokemon#{i}"].selected = (i==@activecmd)
|
|
end
|
|
end
|
|
|
|
def pbPreSelect(item)
|
|
@activecmd = item
|
|
end
|
|
|
|
def pbSwitchBegin(oldid,newid)
|
|
pbSEPlay("GUI party switch")
|
|
oldsprite = @sprites["pokemon#{oldid}"]
|
|
newsprite = @sprites["pokemon#{newid}"]
|
|
timeTaken = Graphics.frame_rate*4/10
|
|
distancePerFrame = (Graphics.width/(2.0*timeTaken)).ceil
|
|
timeTaken.times do
|
|
oldsprite.x += (oldid&1)==0 ? -distancePerFrame : distancePerFrame
|
|
newsprite.x += (newid&1)==0 ? -distancePerFrame : distancePerFrame
|
|
Graphics.update
|
|
Input.update
|
|
self.update
|
|
end
|
|
end
|
|
|
|
def pbSwitchEnd(oldid,newid)
|
|
pbSEPlay("GUI party switch")
|
|
oldsprite = @sprites["pokemon#{oldid}"]
|
|
newsprite = @sprites["pokemon#{newid}"]
|
|
oldsprite.pokemon = @party[oldid]
|
|
newsprite.pokemon = @party[newid]
|
|
timeTaken = Graphics.frame_rate*4/10
|
|
distancePerFrame = (Graphics.width/(2.0*timeTaken)).ceil
|
|
timeTaken.times do
|
|
oldsprite.x -= (oldid&1)==0 ? -distancePerFrame : distancePerFrame
|
|
newsprite.x -= (newid&1)==0 ? -distancePerFrame : distancePerFrame
|
|
Graphics.update
|
|
Input.update
|
|
self.update
|
|
end
|
|
for i in 0...6
|
|
@sprites["pokemon#{i}"].preselected = false
|
|
@sprites["pokemon#{i}"].switching = false
|
|
end
|
|
pbRefresh
|
|
end
|
|
|
|
def pbClearSwitching
|
|
for i in 0...6
|
|
@sprites["pokemon#{i}"].preselected = false
|
|
@sprites["pokemon#{i}"].switching = false
|
|
end
|
|
end
|
|
|
|
def pbSummary(pkmnid,inbattle=false)
|
|
oldsprites = pbFadeOutAndHide(@sprites)
|
|
scene = PokemonSummary_Scene.new
|
|
screen = PokemonSummaryScreen.new(scene,inbattle)
|
|
screen.pbStartScreen(@party,pkmnid)
|
|
yield if block_given?
|
|
pbFadeInAndShow(@sprites,oldsprites)
|
|
end
|
|
|
|
def pbChooseItem(bag)
|
|
ret = 0
|
|
pbFadeOutIn {
|
|
scene = PokemonBag_Scene.new
|
|
screen = PokemonBagScreen.new(scene,bag)
|
|
ret = screen.pbChooseItemScreen(Proc.new { |item| pbCanHoldItem?(item) })
|
|
yield if block_given?
|
|
}
|
|
return ret
|
|
end
|
|
|
|
def pbUseItem(bag,pokemon)
|
|
ret = 0
|
|
pbFadeOutIn {
|
|
scene = PokemonBag_Scene.new
|
|
screen = PokemonBagScreen.new(scene,bag)
|
|
ret = screen.pbChooseItemScreen(Proc.new { |item|
|
|
next false if !pbCanUseOnPokemon?(item)
|
|
if pbIsMachine?(item)
|
|
move = pbGetMachine(item)
|
|
next false if pokemon.hasMove?(move) || !pokemon.compatibleWithMove?(move)
|
|
end
|
|
next true
|
|
})
|
|
yield if block_given?
|
|
}
|
|
return ret
|
|
end
|
|
|
|
def pbChoosePokemon(switching=false,initialsel=-1,canswitch=0)
|
|
for i in 0...6
|
|
@sprites["pokemon#{i}"].preselected = (switching && i==@activecmd)
|
|
@sprites["pokemon#{i}"].switching = switching
|
|
end
|
|
@activecmd = initialsel if initialsel>=0
|
|
pbRefresh
|
|
loop do
|
|
Graphics.update
|
|
Input.update
|
|
self.update
|
|
oldsel = @activecmd
|
|
key = -1
|
|
key = Input::DOWN if Input.repeat?(Input::DOWN)
|
|
key = Input::RIGHT if Input.repeat?(Input::RIGHT)
|
|
key = Input::LEFT if Input.repeat?(Input::LEFT)
|
|
key = Input::UP if Input.repeat?(Input::UP)
|
|
if key>=0
|
|
@activecmd = pbChangeSelection(key,@activecmd)
|
|
end
|
|
if @activecmd!=oldsel # Changing selection
|
|
pbPlayCursorSE
|
|
numsprites = (@multiselect) ? 8 : 7
|
|
for i in 0...numsprites
|
|
@sprites["pokemon#{i}"].selected = (i==@activecmd)
|
|
end
|
|
end
|
|
cancelsprite = (@multiselect) ? 7 : 6
|
|
if Input.trigger?(Input::A) && canswitch==1 && @activecmd!=cancelsprite
|
|
pbPlayDecisionSE
|
|
return [1,@activecmd]
|
|
elsif Input.trigger?(Input::A) && canswitch==2
|
|
return -1
|
|
elsif Input.trigger?(Input::B)
|
|
pbPlayCloseMenuSE if !switching
|
|
return -1
|
|
elsif Input.trigger?(Input::C)
|
|
if @activecmd==cancelsprite
|
|
(switching) ? pbPlayDecisionSE : pbPlayCloseMenuSE
|
|
return -1
|
|
else
|
|
pbPlayDecisionSE
|
|
return @activecmd
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def pbChangeSelection(key,currentsel)
|
|
numsprites = (@multiselect) ? 8 : 7
|
|
case key
|
|
when Input::LEFT
|
|
begin
|
|
currentsel -= 1
|
|
end while currentsel>0 && currentsel<@party.length && !@party[currentsel]
|
|
if currentsel>=@party.length && currentsel<6
|
|
currentsel = @party.length-1
|
|
end
|
|
currentsel = numsprites-1 if currentsel<0
|
|
when Input::RIGHT
|
|
begin
|
|
currentsel += 1
|
|
end while currentsel<@party.length && !@party[currentsel]
|
|
if currentsel==@party.length
|
|
currentsel = 6
|
|
elsif currentsel==numsprites
|
|
currentsel = 0
|
|
end
|
|
when Input::UP
|
|
if currentsel>=6
|
|
begin
|
|
currentsel -= 1
|
|
end while currentsel>0 && !@party[currentsel]
|
|
else
|
|
begin
|
|
currentsel -= 2
|
|
end while currentsel>0 && !@party[currentsel]
|
|
end
|
|
if currentsel>=@party.length && currentsel<6
|
|
currentsel = @party.length-1
|
|
end
|
|
currentsel = numsprites-1 if currentsel<0
|
|
when Input::DOWN
|
|
if currentsel>=5
|
|
currentsel += 1
|
|
else
|
|
currentsel += 2
|
|
currentsel = 6 if currentsel<6 && !@party[currentsel]
|
|
end
|
|
if currentsel>=@party.length && currentsel<6
|
|
currentsel = 6
|
|
elsif currentsel>=numsprites
|
|
currentsel = 0
|
|
end
|
|
end
|
|
return currentsel
|
|
end
|
|
|
|
def pbHardRefresh
|
|
oldtext = []
|
|
lastselected = -1
|
|
for i in 0...6
|
|
oldtext.push(@sprites["pokemon#{i}"].text)
|
|
lastselected = i if @sprites["pokemon#{i}"].selected
|
|
@sprites["pokemon#{i}"].dispose
|
|
end
|
|
lastselected = @party.length-1 if lastselected>=@party.length
|
|
lastselected = 0 if lastselected<0
|
|
for i in 0...6
|
|
if @party[i]
|
|
@sprites["pokemon#{i}"] = PokemonPartyPanel.new(@party[i],i,@viewport)
|
|
else
|
|
@sprites["pokemon#{i}"] = PokemonPartyBlankPanel.new(@party[i],i,@viewport)
|
|
end
|
|
@sprites["pokemon#{i}"].text = oldtext[i]
|
|
end
|
|
pbSelect(lastselected)
|
|
end
|
|
|
|
def pbRefresh
|
|
for i in 0...6
|
|
sprite = @sprites["pokemon#{i}"]
|
|
if sprite
|
|
if sprite.is_a?(PokemonPartyPanel)
|
|
sprite.pokemon = sprite.pokemon
|
|
else
|
|
sprite.refresh
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def pbRefreshSingle(i)
|
|
sprite = @sprites["pokemon#{i}"]
|
|
if sprite
|
|
if sprite.is_a?(PokemonPartyPanel)
|
|
sprite.pokemon = sprite.pokemon
|
|
else
|
|
sprite.refresh
|
|
end
|
|
end
|
|
end
|
|
|
|
def update
|
|
pbUpdateSpriteHash(@sprites)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
#===============================================================================
|
|
# Pokémon party mechanics
|
|
#===============================================================================
|
|
class PokemonPartyScreen
|
|
attr_reader :scene
|
|
attr_reader :party
|
|
|
|
def initialize(scene,party)
|
|
@scene = scene
|
|
@party = party
|
|
end
|
|
|
|
def pbStartScene(helptext,_numBattlersOut,annotations=nil)
|
|
@scene.pbStartScene(@party,helptext,annotations)
|
|
end
|
|
|
|
def pbChoosePokemon(helptext=nil)
|
|
@scene.pbSetHelpText(helptext) if helptext
|
|
return @scene.pbChoosePokemon
|
|
end
|
|
|
|
def pbPokemonGiveScreen(item)
|
|
@scene.pbStartScene(@party,_INTL("Give to which Pokémon?"))
|
|
pkmnid = @scene.pbChoosePokemon
|
|
ret = false
|
|
if pkmnid>=0
|
|
ret = pbGiveItemToPokemon(item,@party[pkmnid],self,pkmnid)
|
|
end
|
|
pbRefreshSingle(pkmnid)
|
|
@scene.pbEndScene
|
|
return ret
|
|
end
|
|
|
|
def pbPokemonGiveMailScreen(mailIndex)
|
|
@scene.pbStartScene(@party,_INTL("Give to which Pokémon?"))
|
|
pkmnid = @scene.pbChoosePokemon
|
|
if pkmnid>=0
|
|
pkmn = @party[pkmnid]
|
|
if pkmn.hasItem? || pkmn.mail
|
|
pbDisplay(_INTL("This Pokémon is holding an item. It can't hold mail."))
|
|
elsif pkmn.egg?
|
|
pbDisplay(_INTL("Eggs can't hold mail."))
|
|
else
|
|
pbDisplay(_INTL("Mail was transferred from the Mailbox."))
|
|
pkmn.mail = $PokemonGlobal.mailbox[mailIndex]
|
|
pkmn.setItem(pkmn.mail.item)
|
|
$PokemonGlobal.mailbox.delete_at(mailIndex)
|
|
pbRefreshSingle(pkmnid)
|
|
end
|
|
end
|
|
@scene.pbEndScene
|
|
end
|
|
|
|
def pbEndScene
|
|
@scene.pbEndScene
|
|
end
|
|
|
|
def pbUpdate
|
|
@scene.update
|
|
end
|
|
|
|
def pbHardRefresh
|
|
@scene.pbHardRefresh
|
|
end
|
|
|
|
def pbRefresh
|
|
@scene.pbRefresh
|
|
end
|
|
|
|
def pbRefreshSingle(i)
|
|
@scene.pbRefreshSingle(i)
|
|
end
|
|
|
|
def pbDisplay(text)
|
|
@scene.pbDisplay(text)
|
|
end
|
|
|
|
def pbConfirm(text)
|
|
return @scene.pbDisplayConfirm(text)
|
|
end
|
|
|
|
def pbShowCommands(helptext,commands,index=0)
|
|
return @scene.pbShowCommands(helptext,commands,index)
|
|
end
|
|
|
|
# Checks for identical species
|
|
def pbCheckSpecies(array) # Unused
|
|
for i in 0...array.length
|
|
for j in i+1...array.length
|
|
return false if array[i].species==array[j].species
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
# Checks for identical held items
|
|
def pbCheckItems(array) # Unused
|
|
for i in 0...array.length
|
|
next if !array[i].hasItem?
|
|
for j in i+1...array.length
|
|
return false if array[i].item==array[j].item
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
def pbSwitch(oldid,newid)
|
|
if oldid!=newid
|
|
@scene.pbSwitchBegin(oldid,newid)
|
|
tmp = @party[oldid]
|
|
@party[oldid] = @party[newid]
|
|
@party[newid] = tmp
|
|
@scene.pbSwitchEnd(oldid,newid)
|
|
end
|
|
end
|
|
|
|
def pbChooseMove(pokemon,helptext,index=0)
|
|
movenames = []
|
|
for i in pokemon.moves
|
|
break if i.id==0
|
|
if i.totalpp<=0
|
|
movenames.push(_INTL("{1} (PP: ---)",PBMoves.getName(i.id)))
|
|
else
|
|
movenames.push(_INTL("{1} (PP: {2}/{3})",PBMoves.getName(i.id),i.pp,i.totalpp))
|
|
end
|
|
end
|
|
return @scene.pbShowCommands(helptext,movenames,index)
|
|
end
|
|
|
|
def pbRefreshAnnotations(ableProc) # For after using an evolution stone
|
|
return if !@scene.pbHasAnnotations?
|
|
annot = []
|
|
for pkmn in @party
|
|
elig = ableProc.call(pkmn)
|
|
annot.push((elig) ? _INTL("ABLE") : _INTL("NOT ABLE"))
|
|
end
|
|
@scene.pbAnnotate(annot)
|
|
end
|
|
|
|
def pbClearAnnotations
|
|
@scene.pbAnnotate(nil)
|
|
end
|
|
|
|
def pbPokemonMultipleEntryScreenEx(ruleset)
|
|
annot = []
|
|
statuses = []
|
|
ordinals = [
|
|
_INTL("INELIGIBLE"),
|
|
_INTL("NOT ENTERED"),
|
|
_INTL("BANNED"),
|
|
_INTL("FIRST"),
|
|
_INTL("SECOND"),
|
|
_INTL("THIRD"),
|
|
_INTL("FOURTH"),
|
|
_INTL("FIFTH"),
|
|
_INTL("SIXTH")
|
|
]
|
|
return nil if !ruleset.hasValidTeam?(@party)
|
|
ret = nil
|
|
addedEntry = false
|
|
for i in 0...@party.length
|
|
statuses[i] = (ruleset.isPokemonValid?(@party[i])) ? 1 : 2
|
|
end
|
|
for i in 0...@party.length
|
|
annot[i] = ordinals[statuses[i]]
|
|
end
|
|
@scene.pbStartScene(@party,_INTL("Choose Pokémon and confirm."),annot,true)
|
|
loop do
|
|
realorder = []
|
|
for i in 0...@party.length
|
|
for j in 0...@party.length
|
|
if statuses[j]==i+3
|
|
realorder.push(j)
|
|
break
|
|
end
|
|
end
|
|
end
|
|
for i in 0...realorder.length
|
|
statuses[realorder[i]] = i+3
|
|
end
|
|
for i in 0...@party.length
|
|
annot[i] = ordinals[statuses[i]]
|
|
end
|
|
@scene.pbAnnotate(annot)
|
|
if realorder.length==ruleset.number && addedEntry
|
|
@scene.pbSelect(6)
|
|
end
|
|
@scene.pbSetHelpText(_INTL("Choose Pokémon and confirm."))
|
|
pkmnid = @scene.pbChoosePokemon
|
|
addedEntry = false
|
|
if pkmnid==6 # Confirm was chosen
|
|
ret = []
|
|
for i in realorder; ret.push(@party[i]); end
|
|
error = []
|
|
break if ruleset.isValid?(ret,error)
|
|
pbDisplay(error[0])
|
|
ret = nil
|
|
end
|
|
break if pkmnid<0 # Cancelled
|
|
cmdEntry = -1
|
|
cmdNoEntry = -1
|
|
cmdSummary = -1
|
|
commands = []
|
|
if (statuses[pkmnid] || 0) == 1
|
|
commands[cmdEntry = commands.length] = _INTL("Entry")
|
|
elsif (statuses[pkmnid] || 0) > 2
|
|
commands[cmdNoEntry = commands.length] = _INTL("No Entry")
|
|
end
|
|
pkmn = @party[pkmnid]
|
|
commands[cmdSummary = commands.length] = _INTL("Summary")
|
|
commands[commands.length] = _INTL("Cancel")
|
|
command = @scene.pbShowCommands(_INTL("Do what with {1}?",pkmn.name),commands) if pkmn
|
|
if cmdEntry>=0 && command==cmdEntry
|
|
if realorder.length>=ruleset.number && ruleset.number>0
|
|
pbDisplay(_INTL("No more than {1} Pokémon may enter.",ruleset.number))
|
|
else
|
|
statuses[pkmnid] = realorder.length+3
|
|
addedEntry = true
|
|
pbRefreshSingle(pkmnid)
|
|
end
|
|
elsif cmdNoEntry>=0 && command==cmdNoEntry
|
|
statuses[pkmnid] = 1
|
|
pbRefreshSingle(pkmnid)
|
|
elsif cmdSummary>=0 && command==cmdSummary
|
|
@scene.pbSummary(pkmnid) {
|
|
@scene.pbSetHelpText((@party.length>1) ? _INTL("Choose a Pokémon.") : _INTL("Choose Pokémon or cancel."))
|
|
}
|
|
end
|
|
end
|
|
@scene.pbEndScene
|
|
return ret
|
|
end
|
|
|
|
def pbChooseAblePokemon(ableProc,allowIneligible=false)
|
|
annot = []
|
|
eligibility = []
|
|
for pkmn in @party
|
|
elig = ableProc.call(pkmn)
|
|
eligibility.push(elig)
|
|
annot.push((elig) ? _INTL("ABLE") : _INTL("NOT ABLE"))
|
|
end
|
|
ret = -1
|
|
@scene.pbStartScene(@party,
|
|
(@party.length>1) ? _INTL("Choose a Pokémon.") : _INTL("Choose Pokémon or cancel."),annot)
|
|
loop do
|
|
@scene.pbSetHelpText(
|
|
(@party.length>1) ? _INTL("Choose a Pokémon.") : _INTL("Choose Pokémon or cancel."))
|
|
pkmnid = @scene.pbChoosePokemon
|
|
break if pkmnid<0
|
|
if !eligibility[pkmnid] && !allowIneligible
|
|
pbDisplay(_INTL("This Pokémon can't be chosen."))
|
|
else
|
|
ret = pkmnid
|
|
break
|
|
end
|
|
end
|
|
@scene.pbEndScene
|
|
return ret
|
|
end
|
|
|
|
def pbChooseTradablePokemon(ableProc,allowIneligible=false)
|
|
annot = []
|
|
eligibility = []
|
|
for pkmn in @party
|
|
elig = ableProc.call(pkmn)
|
|
elig = false if pkmn.egg? || pkmn.shadowPokemon?
|
|
eligibility.push(elig)
|
|
annot.push((elig) ? _INTL("ABLE") : _INTL("NOT ABLE"))
|
|
end
|
|
ret = -1
|
|
@scene.pbStartScene(@party,
|
|
(@party.length>1) ? _INTL("Choose a Pokémon.") : _INTL("Choose Pokémon or cancel."),annot)
|
|
loop do
|
|
@scene.pbSetHelpText(
|
|
(@party.length>1) ? _INTL("Choose a Pokémon.") : _INTL("Choose Pokémon or cancel."))
|
|
pkmnid = @scene.pbChoosePokemon
|
|
break if pkmnid<0
|
|
if !eligibility[pkmnid] && !allowIneligible
|
|
pbDisplay(_INTL("This Pokémon can't be chosen."))
|
|
else
|
|
ret = pkmnid
|
|
break
|
|
end
|
|
end
|
|
@scene.pbEndScene
|
|
return ret
|
|
end
|
|
|
|
def pbPokemonScreen
|
|
@scene.pbStartScene(@party,
|
|
(@party.length>1) ? _INTL("Choose a Pokémon.") : _INTL("Choose Pokémon or cancel."),nil)
|
|
loop do
|
|
@scene.pbSetHelpText((@party.length>1) ? _INTL("Choose a Pokémon.") : _INTL("Choose Pokémon or cancel."))
|
|
pkmnid = @scene.pbChoosePokemon(false,-1,1)
|
|
break if (pkmnid.is_a?(Numeric) && pkmnid<0) || (pkmnid.is_a?(Array) && pkmnid[1]<0)
|
|
if pkmnid.is_a?(Array) && pkmnid[0]==1 # Switch
|
|
@scene.pbSetHelpText(_INTL("Move to where?"))
|
|
oldpkmnid = pkmnid[1]
|
|
pkmnid = @scene.pbChoosePokemon(true,-1,2)
|
|
if pkmnid>=0 && pkmnid!=oldpkmnid
|
|
pbSwitch(oldpkmnid,pkmnid)
|
|
end
|
|
next
|
|
end
|
|
pkmn = @party[pkmnid]
|
|
commands = []
|
|
cmdSummary = -1
|
|
cmdDebug = -1
|
|
cmdMoves = [-1,-1,-1,-1]
|
|
cmdSwitch = -1
|
|
cmdMail = -1
|
|
cmdItem = -1
|
|
# Build the commands
|
|
commands[cmdSummary = commands.length] = _INTL("Summary")
|
|
commands[cmdDebug = commands.length] = _INTL("Debug") if $DEBUG
|
|
for i in 0...pkmn.moves.length
|
|
move = pkmn.moves[i]
|
|
# Check for hidden moves and add any that were found
|
|
if !pkmn.egg? && (isConst?(move.id,PBMoves,:MILKDRINK) ||
|
|
isConst?(move.id,PBMoves,:SOFTBOILED) ||
|
|
HiddenMoveHandlers.hasHandler(move.id))
|
|
commands[cmdMoves[i] = commands.length] = [PBMoves.getName(move.id),1]
|
|
end
|
|
end
|
|
commands[cmdSwitch = commands.length] = _INTL("Switch") if @party.length>1
|
|
if !pkmn.egg?
|
|
if pkmn.mail
|
|
commands[cmdMail = commands.length] = _INTL("Mail")
|
|
else
|
|
commands[cmdItem = commands.length] = _INTL("Item")
|
|
end
|
|
end
|
|
commands[commands.length] = _INTL("Cancel")
|
|
command = @scene.pbShowCommands(_INTL("Do what with {1}?",pkmn.name),commands)
|
|
havecommand = false
|
|
for i in 0...4
|
|
if cmdMoves[i]>=0 && command==cmdMoves[i]
|
|
havecommand = true
|
|
if isConst?(pkmn.moves[i].id,PBMoves,:SOFTBOILED) ||
|
|
isConst?(pkmn.moves[i].id,PBMoves,:MILKDRINK)
|
|
amt = [(pkmn.totalhp/5).floor,1].max
|
|
if pkmn.hp<=amt
|
|
pbDisplay(_INTL("Not enough HP..."))
|
|
break
|
|
end
|
|
@scene.pbSetHelpText(_INTL("Use on which Pokémon?"))
|
|
oldpkmnid = pkmnid
|
|
loop do
|
|
@scene.pbPreSelect(oldpkmnid)
|
|
pkmnid = @scene.pbChoosePokemon(true,pkmnid)
|
|
break if pkmnid<0
|
|
newpkmn = @party[pkmnid]
|
|
movename = PBMoves.getName(pkmn.moves[i].id)
|
|
if pkmnid==oldpkmnid
|
|
pbDisplay(_INTL("{1} can't use {2} on itself!",pkmn.name,movename))
|
|
elsif newpkmn.egg?
|
|
pbDisplay(_INTL("{1} can't be used on an Egg!",movename))
|
|
elsif newpkmn.hp==0 || newpkmn.hp==newpkmn.totalhp
|
|
pbDisplay(_INTL("{1} can't be used on that Pokémon.",movename))
|
|
else
|
|
pkmn.hp -= amt
|
|
hpgain = pbItemRestoreHP(newpkmn,amt)
|
|
@scene.pbDisplay(_INTL("{1}'s HP was restored by {2} points.",newpkmn.name,hpgain))
|
|
pbRefresh
|
|
end
|
|
break if pkmn.hp<=amt
|
|
end
|
|
@scene.pbSelect(oldpkmnid)
|
|
pbRefresh
|
|
break
|
|
elsif pbCanUseHiddenMove?(pkmn,pkmn.moves[i].id)
|
|
if pbConfirmUseHiddenMove(pkmn,pkmn.moves[i].id)
|
|
@scene.pbEndScene
|
|
if isConst?(pkmn.moves[i].id,PBMoves,:FLY)
|
|
scene = PokemonRegionMap_Scene.new(-1,false)
|
|
screen = PokemonRegionMapScreen.new(scene)
|
|
ret = screen.pbStartFlyScreen
|
|
if ret
|
|
$PokemonTemp.flydata=ret
|
|
return [pkmn,pkmn.moves[i].id]
|
|
end
|
|
@scene.pbStartScene(@party,
|
|
(@party.length>1) ? _INTL("Choose a Pokémon.") : _INTL("Choose Pokémon or cancel."))
|
|
break
|
|
end
|
|
return [pkmn,pkmn.moves[i].id]
|
|
end
|
|
else
|
|
break
|
|
end
|
|
end
|
|
end
|
|
next if havecommand
|
|
if cmdSummary>=0 && command==cmdSummary
|
|
@scene.pbSummary(pkmnid) {
|
|
@scene.pbSetHelpText((@party.length>1) ? _INTL("Choose a Pokémon.") : _INTL("Choose Pokémon or cancel."))
|
|
}
|
|
elsif cmdDebug>=0 && command==cmdDebug
|
|
pbPokemonDebug(pkmn,pkmnid)
|
|
elsif cmdSwitch>=0 && command==cmdSwitch
|
|
@scene.pbSetHelpText(_INTL("Move to where?"))
|
|
oldpkmnid = pkmnid
|
|
pkmnid = @scene.pbChoosePokemon(true)
|
|
if pkmnid>=0 && pkmnid!=oldpkmnid
|
|
pbSwitch(oldpkmnid,pkmnid)
|
|
end
|
|
elsif cmdMail>=0 && command==cmdMail
|
|
command = @scene.pbShowCommands(_INTL("Do what with the mail?"),
|
|
[_INTL("Read"),_INTL("Take"),_INTL("Cancel")])
|
|
case command
|
|
when 0 # Read
|
|
pbFadeOutIn {
|
|
pbDisplayMail(pkmn.mail,pkmn)
|
|
@scene.pbSetHelpText((@party.length>1) ? _INTL("Choose a Pokémon.") : _INTL("Choose Pokémon or cancel."))
|
|
}
|
|
when 1 # Take
|
|
if pbTakeItemFromPokemon(pkmn,self)
|
|
pbRefreshSingle(pkmnid)
|
|
end
|
|
end
|
|
elsif cmdItem>=0 && command==cmdItem
|
|
itemcommands = []
|
|
cmdUseItem = -1
|
|
cmdGiveItem = -1
|
|
cmdTakeItem = -1
|
|
cmdMoveItem = -1
|
|
# Build the commands
|
|
itemcommands[cmdUseItem=itemcommands.length] = _INTL("Use")
|
|
itemcommands[cmdGiveItem=itemcommands.length] = _INTL("Give")
|
|
itemcommands[cmdTakeItem=itemcommands.length] = _INTL("Take") if pkmn.hasItem?
|
|
itemcommands[cmdMoveItem=itemcommands.length] = _INTL("Move") if pkmn.hasItem? && !pbIsMail?(pkmn.item)
|
|
itemcommands[itemcommands.length] = _INTL("Cancel")
|
|
command = @scene.pbShowCommands(_INTL("Do what with an item?"),itemcommands)
|
|
if cmdUseItem>=0 && command==cmdUseItem # Use
|
|
item = @scene.pbUseItem($PokemonBag,pkmn) {
|
|
@scene.pbSetHelpText((@party.length>1) ? _INTL("Choose a Pokémon.") : _INTL("Choose Pokémon or cancel."))
|
|
}
|
|
if item>0
|
|
pbUseItemOnPokemon(item,pkmn,self)
|
|
pbRefreshSingle(pkmnid)
|
|
end
|
|
elsif cmdGiveItem>=0 && command==cmdGiveItem # Give
|
|
item = @scene.pbChooseItem($PokemonBag) {
|
|
@scene.pbSetHelpText((@party.length>1) ? _INTL("Choose a Pokémon.") : _INTL("Choose Pokémon or cancel."))
|
|
}
|
|
if item>0
|
|
if pbGiveItemToPokemon(item,pkmn,self,pkmnid)
|
|
pbRefreshSingle(pkmnid)
|
|
end
|
|
end
|
|
elsif cmdTakeItem>=0 && command==cmdTakeItem # Take
|
|
if pbTakeItemFromPokemon(pkmn,self)
|
|
pbRefreshSingle(pkmnid)
|
|
end
|
|
elsif cmdMoveItem>=0 && command==cmdMoveItem # Move
|
|
item = pkmn.item
|
|
itemname = PBItems.getName(item)
|
|
@scene.pbSetHelpText(_INTL("Move {1} to where?",itemname))
|
|
oldpkmnid = pkmnid
|
|
loop do
|
|
@scene.pbPreSelect(oldpkmnid)
|
|
pkmnid = @scene.pbChoosePokemon(true,pkmnid)
|
|
break if pkmnid<0
|
|
newpkmn = @party[pkmnid]
|
|
if pkmnid==oldpkmnid
|
|
break
|
|
elsif newpkmn.egg?
|
|
pbDisplay(_INTL("Eggs can't hold items."))
|
|
elsif !newpkmn.hasItem?
|
|
newpkmn.setItem(item)
|
|
pkmn.setItem(0)
|
|
@scene.pbClearSwitching
|
|
pbRefresh
|
|
pbDisplay(_INTL("{1} was given the {2} to hold.",newpkmn.name,itemname))
|
|
break
|
|
elsif pbIsMail?(newpkmn.item)
|
|
pbDisplay(_INTL("{1}'s mail must be removed before giving it an item.",newpkmn.name))
|
|
else
|
|
newitem = newpkmn.item
|
|
newitemname = PBItems.getName(newitem)
|
|
if isConst?(newitem,PBItems,:LEFTOVERS)
|
|
pbDisplay(_INTL("{1} is already holding some {2}.\1",newpkmn.name,newitemname))
|
|
elsif newitemname.starts_with_vowel?
|
|
pbDisplay(_INTL("{1} is already holding an {2}.\1",newpkmn.name,newitemname))
|
|
else
|
|
pbDisplay(_INTL("{1} is already holding a {2}.\1",newpkmn.name,newitemname))
|
|
end
|
|
if pbConfirm(_INTL("Would you like to switch the two items?"))
|
|
newpkmn.setItem(item)
|
|
pkmn.setItem(newitem)
|
|
@scene.pbClearSwitching
|
|
pbRefresh
|
|
pbDisplay(_INTL("{1} was given the {2} to hold.",newpkmn.name,itemname))
|
|
pbDisplay(_INTL("{1} was given the {2} to hold.",pkmn.name,newitemname))
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
@scene.pbEndScene
|
|
return nil
|
|
end
|
|
end
|
|
|
|
|
|
|
|
def pbPokemonScreen
|
|
pbFadeOutIn {
|
|
sscene = PokemonParty_Scene.new
|
|
sscreen = PokemonPartyScreen.new(sscene,$Trainer.party)
|
|
sscreen.pbPokemonScreen
|
|
}
|
|
end
|