DocRock3r/infinitefusion-e18
1
0
Fork 0
mirror of https://github.com/infinitefusion/infinitefusion-e18.git synced 2025-12-06 06:01:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

Yet more script rearranging

Browse Source
This commit is contained in:
Maruno17
2021-04-17 23:45:42 +01:00
parent 96c68e79a3
commit 2ca8a42949
236 changed files with 923 additions and 928 deletions
Download Patch File Download Diff File Expand all files Collapse all files

122
Data/Scripts/016_UI/001_Non-interactive/001_UI_SplashesAndTitleScreen.rb Normal file
View File

@@ -0,0 +1,122 @@
class IntroEventScene < EventScene
# Splash screen images that appear for a few seconds and then disappear.
SPLASH_IMAGES = ['splash1']
# The main title screen background image.
TITLE_BG_IMAGE = 'title'
TITLE_START_IMAGE = 'start'
TITLE_START_IMAGE_X = 0
TITLE_START_IMAGE_Y = 322
SECONDS_PER_SPLASH = 2
TICKS_PER_ENTER_FLASH = 40 # 20 ticks per second
FADE_TICKS = 8 # 20 ticks per second
def initialize(viewport = nil)
super(viewport)
@pic = addImage(0, 0, "")
@pic.setOpacity(0, 0) # set opacity to 0 after waiting 0 frames
@pic2 = addImage(0, 0, "") # flashing "Press Enter" picture
@pic2.setOpacity(0, 0) # set opacity to 0 after waiting 0 frames
@index = 0
pbBGMPlay($data_system.title_bgm)
open_splash(self, nil)
end
def open_splash(_scene, *args)
onCTrigger.clear
@pic.name = "Graphics/Titles/" + SPLASH_IMAGES[@index]
# fade to opacity 255 in FADE_TICKS ticks after waiting 0 frames
@pic.moveOpacity(0, FADE_TICKS, 255)
pictureWait
@timer = 0.0 # reset the timer
onUpdate.set(method(:splash_update)) # called every frame
onCTrigger.set(method(:close_splash)) # called when C key is pressed
end
def close_splash(scene, args)
onUpdate.clear
onCTrigger.clear
@pic.moveOpacity(0, FADE_TICKS, 0)
pictureWait
@index += 1 # Move to the next picture
if @index >= SPLASH_IMAGES.length
open_title_screen(scene, args)
else
open_splash(scene, args)
end
end
def splash_update(scene, args)
@timer += Graphics.delta_s
close_splash(scene, args) if @timer > SECONDS_PER_SPLASH
end
def open_title_screen(_scene, *args)
onUpdate.clear
onCTrigger.clear
@pic.name = "Graphics/Titles/" + TITLE_BG_IMAGE
@pic.moveOpacity(0, FADE_TICKS, 255)
@pic2.name = "Graphics/Titles/" + TITLE_START_IMAGE
@pic2.setXY(0, TITLE_START_IMAGE_X, TITLE_START_IMAGE_Y)
@pic2.setVisible(0, true)
@pic2.moveOpacity(0, FADE_TICKS, 255)
pictureWait
onUpdate.set(method(:title_screen_update)) # called every frame
onCTrigger.set(method(:close_title_screen)) # called when C key is pressed
end
def fade_out_title_screen(scene)
onUpdate.clear
onCTrigger.clear
# Play random cry
species_keys = GameData::Species::DATA.keys
species_data = GameData::Species.get(species_keys[rand(species_keys.length)])
GameData::Species.play_cry_from_species(species_data.species, species_data.form)
@pic.moveXY(0, 20, 0, 0) # Adds 20 ticks (1 second) pause
pictureWait
# Fade out
@pic.moveOpacity(0, FADE_TICKS, 0)
@pic2.clearProcesses
@pic2.moveOpacity(0, FADE_TICKS, 0)
pbBGMStop(1.0)
pictureWait
scene.dispose # Close the scene
end
def close_title_screen(scene, *args)
fade_out_title_screen(scene)
sscene = PokemonLoad_Scene.new
sscreen = PokemonLoadScreen.new(sscene)
sscreen.pbStartLoadScreen
end
def close_title_screen_delete(scene, *args)
fade_out_title_screen(scene)
sscene = PokemonLoad_Scene.new
sscreen = PokemonLoadScreen.new(sscene)
sscreen.pbStartDeleteScreen
end
def title_screen_update(scene, args)
# Flashing of "Press Enter" picture
if !@pic2.running?
@pic2.moveOpacity(TICKS_PER_ENTER_FLASH * 2 / 10, TICKS_PER_ENTER_FLASH * 4 / 10, 0)
@pic2.moveOpacity(TICKS_PER_ENTER_FLASH * 6 / 10, TICKS_PER_ENTER_FLASH * 4 / 10, 255)
end
if Input.press?(Input::DOWN) &&
Input.press?(Input::BACK) &&
Input.press?(Input::CTRL)
close_title_screen_delete(scene, args)
end
end
end
class Scene_Intro
def main
Graphics.transition(0)
@eventscene = IntroEventScene.new
@eventscene.main
Graphics.freeze
end
end

80
Data/Scripts/016_UI/001_Non-interactive/002_UI_Controls.rb Normal file
View File

@@ -0,0 +1,80 @@
#==============================================================================
# * Scene_Controls
#------------------------------------------------------------------------------
# Shows a help screen listing the keyboard controls.
# Display with:
# pbEventScreen(ButtonEventScene)
#==============================================================================
class ButtonEventScene < EventScene
def initialize(viewport = nil)
super
Graphics.freeze
@current_screen = 1
addImage(0, 0, "Graphics/Pictures/Controls help/help_bg")
@labels = []
@label_screens = []
@keys = []
@key_screens = []
addImageForScreen(1, 44, 122, "Graphics/Pictures/Controls help/help_f1")
addImageForScreen(1, 44, 252, "Graphics/Pictures/Controls help/help_f8")
addLabelForScreen(1, 134, 84, 352, _INTL("Opens the Key Bindings window, where you can choose which keyboard keys to use for each control."))
addLabelForScreen(1, 134, 244, 352, _INTL("Take a screenshot. It is put in the same folder as the save file."))
addImageForScreen(2, 16, 158, "Graphics/Pictures/Controls help/help_arrows")
addLabelForScreen(2, 134, 100, 352, _INTL("Use the Arrow keys to move the main character.\r\n\r\nYou can also use the Arrow keys to select entries and navigate menus."))
addImageForScreen(3, 16, 106, "Graphics/Pictures/Controls help/help_usekey")
addImageForScreen(3, 16, 236, "Graphics/Pictures/Controls help/help_backkey")
addLabelForScreen(3, 134, 84, 352, _INTL("Used to confirm a choice, interact with people and things, and move through text. (Default: C)"))
addLabelForScreen(3, 134, 212, 352, _INTL("Used to exit, cancel a choice, and cancel a mode. Also used to open the Pause Menu. (Default: X)"))
addImageForScreen(4, 16, 90, "Graphics/Pictures/Controls help/help_actionkey")
addImageForScreen(4, 16, 252, "Graphics/Pictures/Controls help/help_specialkey")
addLabelForScreen(4, 134, 52, 352, _INTL("Has various functions depending on context. While moving around, hold to move at a different speed. (Default: Z)"))
addLabelForScreen(4, 134, 212, 352, _INTL("Press to open the Ready Menu, where registered items and available field moves can be used. (Default: D)"))
set_up_screen(@current_screen)
Graphics.transition(20)
# Go to next screen when user presses USE
onCTrigger.set(method(:pbOnScreenEnd))
end
def addLabelForScreen(number, x, y, width, text)
@labels.push(addLabel(x, y, width, text))
@label_screens.push(number)
@picturesprites[@picturesprites.length - 1].opacity = 0
end
def addImageForScreen(number, x, y, filename)
@keys.push(addImage(x, y, filename))
@key_screens.push(number)
@picturesprites[@picturesprites.length - 1].opacity = 0
end
def set_up_screen(number)
@label_screens.each_with_index do |screen, i|
@labels[i].moveOpacity((screen == number) ? 10 : 0, 10, (screen == number) ? 255 : 0)
end
@key_screens.each_with_index do |screen, i|
@keys[i].moveOpacity((screen == number) ? 10 : 0, 10, (screen == number) ? 255 : 0)
end
pictureWait # Update event scene with the changes
end
def pbOnScreenEnd(scene, *args)
last_screen = [@label_screens.max, @key_screens.max].max
if @current_screen >= last_screen
# End scene
Graphics.freeze
Graphics.transition(20, "fadetoblack")
scene.dispose
else
# Next screen
@current_screen += 1
onCTrigger.clear
set_up_screen(@current_screen)
onCTrigger.set(method(:pbOnScreenEnd))
end
end
end

229
Data/Scripts/016_UI/001_Non-interactive/003_UI_EggHatching.rb Normal file
View File

@@ -0,0 +1,229 @@
#===============================================================================
# * Egg Hatch Animation - by FL (Credits will be apreciated)
# Tweaked by Maruno
#===============================================================================
# This script is for Pokémon Essentials. It's an egg hatch animation that
# works even with special eggs like Manaphy egg.
#===============================================================================
# To this script works, put it above Main and put a picture (a 5 frames
# sprite sheet) with egg sprite height and 5 times the egg sprite width at
# Graphics/Battlers/eggCracks.
#===============================================================================
class PokemonEggHatch_Scene
def pbStartScene(pokemon)
@sprites={}
@pokemon=pokemon
@nicknamed=false
@viewport=Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z=99999
# Create background image
addBackgroundOrColoredPlane(@sprites,"background","hatchbg",
Color.new(248,248,248),@viewport)
# Create egg sprite/Pokémon sprite
@sprites["pokemon"]=PokemonSprite.new(@viewport)
@sprites["pokemon"].setOffset(PictureOrigin::Bottom)
@sprites["pokemon"].x = Graphics.width/2
@sprites["pokemon"].y = 264+56 # 56 to offset the egg sprite
@sprites["pokemon"].setSpeciesBitmap(@pokemon.species, @pokemon.gender,
@pokemon.form, @pokemon.shiny?,
false, false, true) # Egg sprite
# Load egg cracks bitmap
crackfilename = sprintf("Graphics/Pokemon/Eggs/%s_cracks", @pokemon.species)
crackfilename = sprintf("Graphics/Pokemon/Eggs/000_cracks") if !pbResolveBitmap(crackfilename)
crackfilename=pbResolveBitmap(crackfilename)
@hatchSheet=AnimatedBitmap.new(crackfilename)
# Create egg cracks sprite
@sprites["hatch"]=SpriteWrapper.new(@viewport)
@sprites["hatch"].x = @sprites["pokemon"].x
@sprites["hatch"].y = @sprites["pokemon"].y
@sprites["hatch"].ox = @sprites["pokemon"].ox
@sprites["hatch"].oy = @sprites["pokemon"].oy
@sprites["hatch"].bitmap = @hatchSheet.bitmap
@sprites["hatch"].src_rect = Rect.new(0,0,@hatchSheet.width/5,@hatchSheet.height)
@sprites["hatch"].visible = false
# Create flash overlay
@sprites["overlay"]=BitmapSprite.new(Graphics.width,Graphics.height,@viewport)
@sprites["overlay"].z=200
@sprites["overlay"].bitmap=Bitmap.new(Graphics.width,Graphics.height)
@sprites["overlay"].bitmap.fill_rect(0,0,Graphics.width,Graphics.height,
Color.new(255,255,255))
@sprites["overlay"].opacity=0
# Start up scene
pbFadeInAndShow(@sprites)
end
def pbMain
pbBGMPlay("Evolution")
# Egg animation
updateScene(Graphics.frame_rate*15/10)
pbPositionHatchMask(0)
pbSEPlay("Battle ball shake")
swingEgg(4)
updateScene(Graphics.frame_rate*2/10)
pbPositionHatchMask(1)
pbSEPlay("Battle ball shake")
swingEgg(4)
updateScene(Graphics.frame_rate*4/10)
pbPositionHatchMask(2)
pbSEPlay("Battle ball shake")
swingEgg(8,2)
updateScene(Graphics.frame_rate*4/10)
pbPositionHatchMask(3)
pbSEPlay("Battle ball shake")
swingEgg(16,4)
updateScene(Graphics.frame_rate*2/10)
pbPositionHatchMask(4)
pbSEPlay("Battle recall")
# Fade and change the sprite
fadeTime = Graphics.frame_rate*4/10
toneDiff = (255.0/fadeTime).ceil
for i in 1..fadeTime
@sprites["pokemon"].tone=Tone.new(i*toneDiff,i*toneDiff,i*toneDiff)
@sprites["overlay"].opacity=i*toneDiff
updateScene
end
updateScene(Graphics.frame_rate*3/4)
@sprites["pokemon"].setPokemonBitmap(@pokemon) # Pokémon sprite
@sprites["pokemon"].x = Graphics.width/2
@sprites["pokemon"].y = 264
@pokemon.species_data.apply_metrics_to_sprite(@sprites["pokemon"], 1)
@sprites["hatch"].visible=false
for i in 1..fadeTime
@sprites["pokemon"].tone=Tone.new(255-i*toneDiff,255-i*toneDiff,255-i*toneDiff)
@sprites["overlay"].opacity=255-i*toneDiff
updateScene
end
@sprites["pokemon"].tone=Tone.new(0,0,0)
@sprites["overlay"].opacity=0
# Finish scene
frames = GameData::Species.cry_length(@pokemon)
GameData::Species.play_cry_from_pokemon(@pokemon)
updateScene(frames)
pbBGMStop()
pbMEPlay("Evolution success")
@pokemon.name = nil
pbMessage(_INTL("\\se[]{1} hatched from the Egg!\\wt[80]", @pokemon.name)) { update }
if pbConfirmMessage(
_INTL("Would you like to nickname the newly hatched {1}?", @pokemon.name)) { update }
nickname = pbEnterPokemonName(_INTL("{1}'s nickname?", @pokemon.name),
0, Pokemon::MAX_NAME_SIZE, "", @pokemon, true)
@pokemon.name = nickname
@nicknamed = true
end
end
def pbEndScene
pbFadeOutAndHide(@sprites) { update } if !@nicknamed
pbDisposeSpriteHash(@sprites)
@hatchSheet.dispose
@viewport.dispose
end
def pbPositionHatchMask(index)
@sprites["hatch"].src_rect.x = index*@sprites["hatch"].src_rect.width
end
def swingEgg(speed,swingTimes=1)
@sprites["hatch"].visible = true
speed = speed.to_f*20/Graphics.frame_rate
amplitude = 8
targets = []
swingTimes.times do
targets.push(@sprites["pokemon"].x+amplitude)
targets.push(@sprites["pokemon"].x-amplitude)
end
targets.push(@sprites["pokemon"].x)
targets.each_with_index do |target,i|
loop do
break if i%2==0 && @sprites["pokemon"].x>=target
break if i%2==1 && @sprites["pokemon"].x<=target
@sprites["pokemon"].x += speed
@sprites["hatch"].x = @sprites["pokemon"].x
updateScene
end
speed *= -1
end
@sprites["pokemon"].x = targets[targets.length-1]
@sprites["hatch"].x = @sprites["pokemon"].x
end
def updateScene(frames=1) # Can be used for "wait" effect
frames.times do
Graphics.update
Input.update
self.update
end
end
def update
pbUpdateSpriteHash(@sprites)
end
end
#===============================================================================
#
#===============================================================================
class PokemonEggHatchScreen
def initialize(scene)
@scene=scene
end
def pbStartScreen(pokemon)
@scene.pbStartScene(pokemon)
@scene.pbMain
@scene.pbEndScene
end
end
#===============================================================================
#
#===============================================================================
def pbHatchAnimation(pokemon)
pbMessage(_INTL("Huh?\1"))
pbFadeOutInWithMusic {
scene=PokemonEggHatch_Scene.new
screen=PokemonEggHatchScreen.new(scene)
screen.pbStartScreen(pokemon)
}
return true
end
def pbHatch(pokemon)
speciesname = pokemon.speciesName
pokemon.name = nil
pokemon.owner = Pokemon::Owner.new_from_trainer($Trainer)
pokemon.happiness = 120
pokemon.timeEggHatched = pbGetTimeNow
pokemon.obtain_method = 1 # hatched from egg
pokemon.hatched_map = $game_map.map_id
$Trainer.pokedex.register(pokemon)
$Trainer.pokedex.set_owned(pokemon.species)
pokemon.record_first_moves
if !pbHatchAnimation(pokemon)
pbMessage(_INTL("Huh?\1"))
pbMessage(_INTL("...\1"))
pbMessage(_INTL("... .... .....\1"))
pbMessage(_INTL("{1} hatched from the Egg!", speciesname))
if pbConfirmMessage(_INTL("Would you like to nickname the newly hatched {1}?", speciesname))
nickname = pbEnterPokemonName(_INTL("{1}'s nickname?", speciesname),
0, Pokemon::MAX_NAME_SIZE, "", pokemon)
pokemon.name = nickname
end
end
end
Events.onStepTaken += proc { |_sender,_e|
for egg in $Trainer.party
next if egg.steps_to_hatch <= 0
egg.steps_to_hatch -= 1
for i in $Trainer.pokemon_party
next if !i.hasAbility?(:FLAMEBODY) && !i.hasAbility?(:MAGMAARMOR)
egg.steps_to_hatch -= 1
break
end
if egg.steps_to_hatch <= 0
egg.steps_to_hatch = 0
pbHatch(egg)
end
end
}

621
Data/Scripts/016_UI/001_Non-interactive/004_UI_Evolution.rb Normal file
View File

@@ -0,0 +1,621 @@
#===============================================================================
# Evolution animation metafiles and related methods
#===============================================================================
class SpriteMetafile
VIEWPORT = 0
TONE = 1
SRC_RECT = 2
VISIBLE = 3
X = 4
Y = 5
Z = 6
OX = 7
OY = 8
ZOOM_X = 9
ZOOM_Y = 10
ANGLE = 11
MIRROR = 12
BUSH_DEPTH = 13
OPACITY = 14
BLEND_TYPE = 15
COLOR = 16
FLASHCOLOR = 17
FLASHDURATION = 18
BITMAP = 19
def length
return @metafile.length
end
def [](i)
return @metafile[i]
end
def initialize(viewport=nil)
@metafile=[]
@values=[
viewport,
Tone.new(0,0,0,0),Rect.new(0,0,0,0),
true,
0,0,0,0,0,100,100,
0,false,0,255,0,
Color.new(0,0,0,0),Color.new(0,0,0,0),
0
]
end
def disposed?
return false
end
def dispose; end
def flash(color,duration)
if duration>0
@values[FLASHCOLOR]=color.clone
@values[FLASHDURATION]=duration
@metafile.push([FLASHCOLOR,color])
@metafile.push([FLASHDURATION,duration])
end
end
def x
return @values[X]
end
def x=(value)
@values[X]=value
@metafile.push([X,value])
end
def y
return @values[Y]
end
def y=(value)
@values[Y]=value
@metafile.push([Y,value])
end
def bitmap
return nil
end
def bitmap=(value)
if value && !value.disposed?
@values[SRC_RECT].set(0,0,value.width,value.height)
@metafile.push([SRC_RECT,@values[SRC_RECT].clone])
end
end
def src_rect
return @values[SRC_RECT]
end
def src_rect=(value)
@values[SRC_RECT]=value
@metafile.push([SRC_RECT,value])
end
def visible
return @values[VISIBLE]
end
def visible=(value)
@values[VISIBLE]=value
@metafile.push([VISIBLE,value])
end
def z
return @values[Z]
end
def z=(value)
@values[Z]=value
@metafile.push([Z,value])
end
def ox
return @values[OX]
end
def ox=(value)
@values[OX]=value
@metafile.push([OX,value])
end
def oy
return @values[OY]
end
def oy=(value)
@values[OY]=value
@metafile.push([OY,value])
end
def zoom_x
return @values[ZOOM_X]
end
def zoom_x=(value)
@values[ZOOM_X]=value
@metafile.push([ZOOM_X,value])
end
def zoom_y
return @values[ZOOM_Y]
end
def zoom_y=(value)
@values[ZOOM_Y]=value
@metafile.push([ZOOM_Y,value])
end
def zoom=(value)
@values[ZOOM_X]=value
@metafile.push([ZOOM_X,value])
@values[ZOOM_Y]=value
@metafile.push([ZOOM_Y,value])
end
def angle
return @values[ANGLE]
end
def angle=(value)
@values[ANGLE]=value
@metafile.push([ANGLE,value])
end
def mirror
return @values[MIRROR]
end
def mirror=(value)
@values[MIRROR]=value
@metafile.push([MIRROR,value])
end
def bush_depth
return @values[BUSH_DEPTH]
end
def bush_depth=(value)
@values[BUSH_DEPTH]=value
@metafile.push([BUSH_DEPTH,value])
end
def opacity
return @values[OPACITY]
end
def opacity=(value)
@values[OPACITY]=value
@metafile.push([OPACITY,value])
end
def blend_type
return @values[BLEND_TYPE]
end
def blend_type=(value)
@values[BLEND_TYPE]=value
@metafile.push([BLEND_TYPE,value])
end
def color
return @values[COLOR]
end
def color=(value)
@values[COLOR]=value.clone
@metafile.push([COLOR,@values[COLOR]])
end
def tone
return @values[TONE]
end
def tone=(value)
@values[TONE]=value.clone
@metafile.push([TONE,@values[TONE]])
end
def update
@metafile.push([-1,nil])
end
end
#===============================================================================
#
#===============================================================================
class SpriteMetafilePlayer
def initialize(metafile,sprite=nil)
@metafile=metafile
@sprites=[]
@playing=false
@index=0
@sprites.push(sprite) if sprite
end
def add(sprite)
@sprites.push(sprite)
end
def playing?
return @playing
end
def play
@playing=true
@index=0
end
def update
if @playing
for j in @index...@metafile.length
@index=j+1
break if @metafile[j][0]<0
code=@metafile[j][0]
value=@metafile[j][1]
for sprite in @sprites
case code
when SpriteMetafile::X then sprite.x = value
when SpriteMetafile::Y then sprite.y = value
when SpriteMetafile::OX then sprite.ox = value
when SpriteMetafile::OY then sprite.oy = value
when SpriteMetafile::ZOOM_X then sprite.zoom_x = value
when SpriteMetafile::ZOOM_Y then sprite.zoom_y = value
when SpriteMetafile::SRC_RECT then sprite.src_rect = value
when SpriteMetafile::VISIBLE then sprite.visible = value
when SpriteMetafile::Z then sprite.z = value # prevent crashes
when SpriteMetafile::ANGLE then sprite.angle = (value == 180) ? 179.9 : value
when SpriteMetafile::MIRROR then sprite.mirror = value
when SpriteMetafile::BUSH_DEPTH then sprite.bush_depth = value
when SpriteMetafile::OPACITY then sprite.opacity = value
when SpriteMetafile::BLEND_TYPE then sprite.blend_type = value
when SpriteMetafile::COLOR then sprite.color = value
when SpriteMetafile::TONE then sprite.tone = value
end
end
end
@playing=false if @index==@metafile.length
end
end
end
#===============================================================================
#
#===============================================================================
def pbSaveSpriteState(sprite)
state=[]
return state if !sprite || sprite.disposed?
state[SpriteMetafile::BITMAP] = sprite.x
state[SpriteMetafile::X] = sprite.x
state[SpriteMetafile::Y] = sprite.y
state[SpriteMetafile::SRC_RECT] = sprite.src_rect.clone
state[SpriteMetafile::VISIBLE] = sprite.visible
state[SpriteMetafile::Z] = sprite.z
state[SpriteMetafile::OX] = sprite.ox
state[SpriteMetafile::OY] = sprite.oy
state[SpriteMetafile::ZOOM_X] = sprite.zoom_x
state[SpriteMetafile::ZOOM_Y] = sprite.zoom_y
state[SpriteMetafile::ANGLE] = sprite.angle
state[SpriteMetafile::MIRROR] = sprite.mirror
state[SpriteMetafile::BUSH_DEPTH] = sprite.bush_depth
state[SpriteMetafile::OPACITY] = sprite.opacity
state[SpriteMetafile::BLEND_TYPE] = sprite.blend_type
state[SpriteMetafile::COLOR] = sprite.color.clone
state[SpriteMetafile::TONE] = sprite.tone.clone
return state
end
def pbRestoreSpriteState(sprite,state)
return if !state || !sprite || sprite.disposed?
sprite.x = state[SpriteMetafile::X]
sprite.y = state[SpriteMetafile::Y]
sprite.src_rect = state[SpriteMetafile::SRC_RECT]
sprite.visible = state[SpriteMetafile::VISIBLE]
sprite.z = state[SpriteMetafile::Z]
sprite.ox = state[SpriteMetafile::OX]
sprite.oy = state[SpriteMetafile::OY]
sprite.zoom_x = state[SpriteMetafile::ZOOM_X]
sprite.zoom_y = state[SpriteMetafile::ZOOM_Y]
sprite.angle = state[SpriteMetafile::ANGLE]
sprite.mirror = state[SpriteMetafile::MIRROR]
sprite.bush_depth = state[SpriteMetafile::BUSH_DEPTH]
sprite.opacity = state[SpriteMetafile::OPACITY]
sprite.blend_type = state[SpriteMetafile::BLEND_TYPE]
sprite.color = state[SpriteMetafile::COLOR]
sprite.tone = state[SpriteMetafile::TONE]
end
def pbSaveSpriteStateAndBitmap(sprite)
return [] if !sprite || sprite.disposed?
state=pbSaveSpriteState(sprite)
state[SpriteMetafile::BITMAP]=sprite.bitmap
return state
end
def pbRestoreSpriteStateAndBitmap(sprite,state)
return if !state || !sprite || sprite.disposed?
sprite.bitmap=state[SpriteMetafile::BITMAP]
pbRestoreSpriteState(sprite,state)
return state
end
#===============================================================================
# Evolution screen
#===============================================================================
class PokemonEvolutionScene
private
def pbGenerateMetafiles(s1x,s1y,s2x,s2y)
sprite = SpriteMetafile.new
sprite.ox = s1x
sprite.oy = s1y
sprite.opacity = 255
sprite2 = SpriteMetafile.new
sprite2.ox = s2x
sprite2.oy = s2y
sprite2.zoom = 0.0
sprite2.opacity = 255
alpha = 0
alphaDiff = 10*20/Graphics.frame_rate
loop do
sprite.color.red = 255
sprite.color.green = 255
sprite.color.blue = 255
sprite.color.alpha = alpha
sprite.color = sprite.color
sprite2.color = sprite.color
sprite2.color.alpha = 255
sprite.update
sprite2.update
break if alpha>=255
alpha += alphaDiff
end
totaltempo = 0
currenttempo = 25
maxtempo = 7*Graphics.frame_rate
while totaltempo<maxtempo
for j in 0...currenttempo
if alpha<255
sprite.color.red = 255
sprite.color.green = 255
sprite.color.blue = 255
sprite.color.alpha = alpha
sprite.color = sprite.color
alpha += 10
end
sprite.zoom = [1.1*(currenttempo-j-1)/currenttempo,1.0].min
sprite2.zoom = [1.1*(j+1)/currenttempo,1.0].min
sprite.update
sprite2.update
end
totaltempo += currenttempo
if totaltempo+currenttempo<maxtempo
for j in 0...currenttempo
sprite.zoom = [1.1*(j+1)/currenttempo,1.0].min
sprite2.zoom = [1.1*(currenttempo-j-1)/currenttempo,1.0].min
sprite.update
sprite2.update
end
end
totaltempo += currenttempo
currenttempo = [(currenttempo/1.5).floor,5].max
end
@metafile1 = sprite
@metafile2 = sprite2
end
public
def pbUpdate(animating=false)
if animating # Pokémon shouldn't animate during the evolution animation
@sprites["background"].update
else
pbUpdateSpriteHash(@sprites)
end
end
def pbUpdateNarrowScreen
halfResizeDiff = 8*20/Graphics.frame_rate
if @bgviewport.rect.y<80
@bgviewport.rect.height -= halfResizeDiff*2
if @bgviewport.rect.height<Graphics.height-64
@bgviewport.rect.y += halfResizeDiff
@sprites["background"].oy = @bgviewport.rect.y
end
end
end
def pbUpdateExpandScreen
halfResizeDiff = 8*20/Graphics.frame_rate
if @bgviewport.rect.y>0
@bgviewport.rect.y -= halfResizeDiff
@sprites["background"].oy = @bgviewport.rect.y
end
if @bgviewport.rect.height<Graphics.height
@bgviewport.rect.height += halfResizeDiff*2
end
end
def pbFlashInOut(canceled,oldstate,oldstate2)
tone = 0
toneDiff = 20*20/Graphics.frame_rate
loop do
Graphics.update
pbUpdate(true)
pbUpdateExpandScreen
tone += toneDiff
@viewport.tone.set(tone,tone,tone,0)
break if tone>=255
end
@bgviewport.rect.y = 0
@bgviewport.rect.height = Graphics.height
@sprites["background"].oy = 0
if canceled
pbRestoreSpriteState(@sprites["rsprite1"],oldstate)
pbRestoreSpriteState(@sprites["rsprite2"],oldstate2)
@sprites["rsprite1"].zoom_x = 1.0
@sprites["rsprite1"].zoom_y = 1.0
@sprites["rsprite1"].color.alpha = 0
@sprites["rsprite1"].visible = true
@sprites["rsprite2"].visible = false
else
@sprites["rsprite1"].visible = false
@sprites["rsprite2"].visible = true
@sprites["rsprite2"].zoom_x = 1.0
@sprites["rsprite2"].zoom_y = 1.0
@sprites["rsprite2"].color.alpha = 0
end
(Graphics.frame_rate/4).times do
Graphics.update
pbUpdate(true)
end
tone = 255
toneDiff = 40*20/Graphics.frame_rate
loop do
Graphics.update
pbUpdate
tone -= toneDiff
@viewport.tone.set(tone,tone,tone,0)
break if tone<=0
end
end
def pbStartScreen(pokemon,newspecies)
@pokemon = pokemon
@newspecies = newspecies
@sprites = {}
@bgviewport = Viewport.new(0,0,Graphics.width,Graphics.height)
@bgviewport.z = 99999
@viewport = Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z = 99999
@msgviewport = Viewport.new(0,0,Graphics.width,Graphics.height)
@msgviewport.z = 99999
addBackgroundOrColoredPlane(@sprites,"background","evolutionbg",
Color.new(248,248,248),@bgviewport)
rsprite1 = PokemonSprite.new(@viewport)
rsprite1.setOffset(PictureOrigin::Center)
rsprite1.setPokemonBitmap(@pokemon,false)
rsprite1.x = Graphics.width/2
rsprite1.y = (Graphics.height-64)/2
rsprite2 = PokemonSprite.new(@viewport)
rsprite2.setOffset(PictureOrigin::Center)
rsprite2.setPokemonBitmapSpecies(@pokemon,@newspecies,false)
rsprite2.x = rsprite1.x
rsprite2.y = rsprite1.y
rsprite2.opacity = 0
@sprites["rsprite1"] = rsprite1
@sprites["rsprite2"] = rsprite2
pbGenerateMetafiles(rsprite1.ox,rsprite1.oy,rsprite2.ox,rsprite2.oy)
@sprites["msgwindow"] = pbCreateMessageWindow(@msgviewport)
pbFadeInAndShow(@sprites) { pbUpdate }
end
# Closes the evolution screen.
def pbEndScreen
pbDisposeMessageWindow(@sprites["msgwindow"])
pbFadeOutAndHide(@sprites) { pbUpdate }
pbDisposeSpriteHash(@sprites)
@viewport.dispose
@bgviewport.dispose
@msgviewport.dispose
end
# Opens the evolution screen
def pbEvolution(cancancel=true)
metaplayer1 = SpriteMetafilePlayer.new(@metafile1,@sprites["rsprite1"])
metaplayer2 = SpriteMetafilePlayer.new(@metafile2,@sprites["rsprite2"])
metaplayer1.play
metaplayer2.play
pbBGMStop
GameData::Species.play_cry_from_pokemon(@pokemon)
pbMessageDisplay(@sprites["msgwindow"],
_INTL("\\se[]What? {1} is evolving!\\^",@pokemon.name)) { pbUpdate }
pbMessageWaitForInput(@sprites["msgwindow"],50,true) { pbUpdate }
pbPlayDecisionSE
oldstate = pbSaveSpriteState(@sprites["rsprite1"])
oldstate2 = pbSaveSpriteState(@sprites["rsprite2"])
pbMEPlay("Evolution start")
pbBGMPlay("Evolution")
canceled = false
begin
pbUpdateNarrowScreen
metaplayer1.update
metaplayer2.update
Graphics.update
Input.update
pbUpdate(true)
if Input.trigger?(Input::BACK) && cancancel
pbBGMStop
pbPlayCancelSE
canceled = true
break
end
end while metaplayer1.playing? && metaplayer2.playing?
pbFlashInOut(canceled,oldstate,oldstate2)
if canceled
pbMessageDisplay(@sprites["msgwindow"],
_INTL("Huh? {1} stopped evolving!",@pokemon.name)) { pbUpdate }
else
pbEvolutionSuccess
end
end
def pbEvolutionSuccess
# Play cry of evolved species
frames = GameData::Species.cry_length(@newspecies, @pokemon.form)
pbBGMStop
GameData::Species.play_cry_from_species(@newspecies, @pokemon.form)
frames.times do
Graphics.update
pbUpdate
end
# Success jingle/message
pbMEPlay("Evolution success")
newspeciesname = GameData::Species.get(@newspecies).name
pbMessageDisplay(@sprites["msgwindow"],
_INTL("\\se[]Congratulations! Your {1} evolved into {2}!\\wt[80]",
@pokemon.name,newspeciesname)) { pbUpdate }
@sprites["msgwindow"].text = ""
# Check for consumed item and check if Pokémon should be duplicated
pbEvolutionMethodAfterEvolution
# Modify Pokémon to make it evolved
@pokemon.species = @newspecies
@pokemon.form = 0 if @pokemon.isSpecies?(:MOTHIM)
@pokemon.calc_stats
# See and own evolved species
$Trainer.pokedex.register(@pokemon)
$Trainer.pokedex.set_owned(@newspecies)
# Learn moves upon evolution for evolved species
movelist = @pokemon.getMoveList
for i in movelist
next if i[0]!=0 && i[0]!=@pokemon.level # 0 is "learn upon evolution"
pbLearnMove(@pokemon,i[1],true) { pbUpdate }
end
end
def pbEvolutionMethodAfterEvolution
@pokemon.action_after_evolution(@newspecies)
end
def self.pbDuplicatePokemon(pkmn, new_species)
new_pkmn = pkmn.clone
new_pkmn.species = new_species
new_pkmn.name = nil
new_pkmn.markings = 0
new_pkmn.poke_ball = :POKEBALL
new_pkmn.item = nil
new_pkmn.clearAllRibbons
new_pkmn.calc_stats
new_pkmn.heal
# Add duplicate Pokémon to party
$Trainer.party.push(new_pkmn)
# See and own duplicate Pokémon
$Trainer.pokedex.register(new_pkmn)
$Trainer.pokedex.set_owned(new_species)
end
end

240
Data/Scripts/016_UI/001_Non-interactive/005_UI_Trading.rb Normal file
View File

@@ -0,0 +1,240 @@
#===============================================================================
#
#===============================================================================
class PokemonTrade_Scene
def pbUpdate
pbUpdateSpriteHash(@sprites)
end
def pbRunPictures(pictures,sprites)
loop do
for i in 0...pictures.length
pictures[i].update
end
for i in 0...sprites.length
if sprites[i].is_a?(IconSprite)
setPictureIconSprite(sprites[i],pictures[i])
else
setPictureSprite(sprites[i],pictures[i])
end
end
Graphics.update
Input.update
running = false
for i in 0...pictures.length
running = true if pictures[i].running?
end
break if !running
end
end
def pbStartScreen(pokemon,pokemon2,trader1,trader2)
@sprites = {}
@viewport = Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z = 99999
@pokemon = pokemon
@pokemon2 = pokemon2
@trader1 = trader1
@trader2 = trader2
addBackgroundOrColoredPlane(@sprites,"background","tradebg",
Color.new(248,248,248),@viewport)
@sprites["rsprite1"] = PokemonSprite.new(@viewport)
@sprites["rsprite1"].setPokemonBitmap(@pokemon,false)
@sprites["rsprite1"].setOffset(PictureOrigin::Bottom)
@sprites["rsprite1"].x = Graphics.width/2
@sprites["rsprite1"].y = 264
@sprites["rsprite1"].z = 10
@pokemon.species_data.apply_metrics_to_sprite(@sprites["rsprite1"], 1)
@sprites["rsprite2"] = PokemonSprite.new(@viewport)
@sprites["rsprite2"].setPokemonBitmap(@pokemon2,false)
@sprites["rsprite2"].setOffset(PictureOrigin::Bottom)
@sprites["rsprite2"].x = Graphics.width/2
@sprites["rsprite2"].y = 264
@sprites["rsprite2"].z = 10
@pokemon2.species_data.apply_metrics_to_sprite(@sprites["rsprite2"], 1)
@sprites["rsprite2"].visible = false
@sprites["msgwindow"] = pbCreateMessageWindow(@viewport)
pbFadeInAndShow(@sprites)
end
def pbScene1
spriteBall = IconSprite.new(0,0,@viewport)
pictureBall = PictureEx.new(0)
picturePoke = PictureEx.new(0)
ballimage = sprintf("Graphics/Battle animations/ball_%s", @pokemon.poke_ball)
if !pbResolveBitmap(ballimage)
ballimage = sprintf("Graphics/Battle animations/ball_%02d", pbGetBallType(@pokemon.poke_ball))
end
ballopenimage = sprintf("Graphics/Battle animations/ball_%s_open", @pokemon.poke_ball)
if !pbResolveBitmap(ballimage)
ballopenimage = sprintf("Graphics/Battle animations/ball_%02d_open", pbGetBallType(@pokemon.poke_ball))
end
# Starting position of ball
pictureBall.setXY(0,Graphics.width/2,48)
pictureBall.setName(0,ballimage)
pictureBall.setSrcSize(0,32,64)
pictureBall.setOrigin(0,PictureOrigin::Center)
pictureBall.setVisible(0,true)
# Starting position of sprite
picturePoke.setXY(0,@sprites["rsprite1"].x,@sprites["rsprite1"].y)
picturePoke.setOrigin(0,PictureOrigin::Bottom)
picturePoke.setVisible(0,true)
# Change Pokémon color
picturePoke.moveColor(2,5,Color.new(31*8,22*8,30*8,255))
# Recall
delay = picturePoke.totalDuration
picturePoke.setSE(delay,"Battle recall")
pictureBall.setName(delay,ballopenimage)
pictureBall.setSrcSize(delay,32,64)
# Move sprite to ball
picturePoke.moveZoom(delay,8,0)
picturePoke.moveXY(delay,8,Graphics.width/2,48)
picturePoke.setSE(delay+5,"Battle jump to ball")
picturePoke.setVisible(delay+8,false)
delay = picturePoke.totalDuration+1
pictureBall.setName(delay,ballimage)
pictureBall.setSrcSize(delay,32,64)
# Make Poké Ball go off the top of the screen
delay = picturePoke.totalDuration+10
pictureBall.moveXY(delay,6,Graphics.width/2,-32)
# Play animation
pbRunPictures(
[picturePoke,pictureBall],
[@sprites["rsprite1"],spriteBall]
)
spriteBall.dispose
end
def pbScene2
spriteBall = IconSprite.new(0,0,@viewport)
pictureBall = PictureEx.new(0)
picturePoke = PictureEx.new(0)
ballimage = sprintf("Graphics/Battle animations/ball_%s", @pokemon2.poke_ball)
if !pbResolveBitmap(ballimage)
ballimage = sprintf("Graphics/Battle animations/ball_%02d", pbGetBallType(@pokemon2.poke_ball))
end
ballopenimage = sprintf("Graphics/Battle animations/ball_%s_open", @pokemon2.poke_ball)
if !pbResolveBitmap(ballimage)
ballopenimage = sprintf("Graphics/Battle animations/ball_%02d_open", pbGetBallType(@pokemon2.poke_ball))
end
# Starting position of ball
pictureBall.setXY(0,Graphics.width/2,-32)
pictureBall.setName(0,ballimage)
pictureBall.setSrcSize(0,32,64)
pictureBall.setOrigin(0,PictureOrigin::Center)
pictureBall.setVisible(0,true)
# Starting position of sprite
picturePoke.setOrigin(0,PictureOrigin::Bottom)
picturePoke.setZoom(0,0)
picturePoke.setColor(0,Color.new(31*8,22*8,30*8,255))
picturePoke.setVisible(0,false)
# Dropping ball
y = Graphics.height-96-16-16 # end point of Poké Ball
delay = picturePoke.totalDuration+2
for i in 0...4
t = [4,4,3,2][i] # Time taken to rise or fall for each bounce
d = [1,2,4,8][i] # Fraction of the starting height each bounce rises to
delay -= t if i==0
if i>0
pictureBall.setZoomXY(delay,100+5*(5-i),100-5*(5-i)) # Squish
pictureBall.moveZoom(delay,2,100) # Unsquish
pictureBall.moveXY(delay,t,Graphics.width/2,y-100/d)
end
pictureBall.moveXY(delay+t,t,Graphics.width/2,y)
pictureBall.setSE(delay+2*t,"Battle ball drop")
delay = pictureBall.totalDuration
end
picturePoke.setXY(delay,Graphics.width/2,y)
# Open Poké Ball
delay = pictureBall.totalDuration+15
pictureBall.setSE(delay,"Battle recall")
pictureBall.setName(delay,ballopenimage)
pictureBall.setSrcSize(delay,32,64)
pictureBall.setVisible(delay+5,false)
# Pokémon appears and enlarges
picturePoke.setVisible(delay,true)
picturePoke.moveZoom(delay,8,100)
picturePoke.moveXY(delay,8,Graphics.width/2,@sprites["rsprite2"].y)
# Return Pokémon's color to normal and play cry
delay = picturePoke.totalDuration
picturePoke.moveColor(delay,5,Color.new(31*8,22*8,30*8,0))
cry = GameData::Species.cry_filename_from_pokemon(@pokemon2)
picturePoke.setSE(delay,cry) if cry
# Play animation
pbRunPictures(
[picturePoke,pictureBall],
[@sprites["rsprite2"],spriteBall]
)
spriteBall.dispose
end
def pbEndScreen
pbDisposeMessageWindow(@sprites["msgwindow"])
pbFadeOutAndHide(@sprites)
pbDisposeSpriteHash(@sprites)
@viewport.dispose
newspecies = @pokemon2.check_evolution_on_trade(@pokemon)
if newspecies
evo = PokemonEvolutionScene.new
evo.pbStartScreen(@pokemon2,newspecies)
evo.pbEvolution(false)
evo.pbEndScreen
end
end
def pbTrade
pbBGMStop
GameData::Species.play_cry_from_pokemon(@pokemon)
speciesname1=GameData::Species.get(@pokemon.species).name
speciesname2=GameData::Species.get(@pokemon2.species).name
pbMessageDisplay(@sprites["msgwindow"],
_ISPRINTF("{1:s}\r\nID: {2:05d} OT: {3:s}\\wtnp[0]",
@pokemon.name,@pokemon.owner.public_id,@pokemon.owner.name)) { pbUpdate }
pbMessageWaitForInput(@sprites["msgwindow"],50,true) { pbUpdate }
pbPlayDecisionSE
pbScene1
pbMessageDisplay(@sprites["msgwindow"],
_INTL("For {1}'s {2},\r\n{3} sends {4}.\1",@trader1,speciesname1,@trader2,speciesname2)) { pbUpdate }
pbMessageDisplay(@sprites["msgwindow"],
_INTL("{1} bids farewell to {2}.",@trader2,speciesname2)) { pbUpdate }
pbScene2
pbMessageDisplay(@sprites["msgwindow"],
_ISPRINTF("{1:s}\r\nID: {2:05d} OT: {3:s}\1",
@pokemon2.name,@pokemon2.owner.public_id,@pokemon2.owner.name)) { pbUpdate }
pbMessageDisplay(@sprites["msgwindow"],
_INTL("Take good care of {1}.",speciesname2)) { pbUpdate }
end
end
#===============================================================================
#
#===============================================================================
def pbStartTrade(pokemonIndex,newpoke,nickname,trainerName,trainerGender=0)
myPokemon = $Trainer.party[pokemonIndex]
opponent = NPCTrainer.new(trainerName,trainerGender)
opponent.id = $Trainer.make_foreign_ID
yourPokemon = nil
resetmoves = true
if newpoke.is_a?(Pokemon)
newpoke.owner = Pokemon::Owner.new_from_trainer(opponent)
yourPokemon = newpoke
resetmoves = false
else
species_data = GameData::Species.try_get(newpoke)
raise _INTL("Species does not exist ({1}).", newpoke) if !species_data
yourPokemon = Pokemon.new(species_data.id, myPokemon.level, opponent)
end
yourPokemon.name = nickname
yourPokemon.obtain_method = 2 # traded
yourPokemon.reset_moves if resetmoves
yourPokemon.record_first_moves
$Trainer.pokedex.register(yourPokemon)
$Trainer.pokedex.set_owned(yourPokemon.species)
pbFadeOutInWithMusic {
evo = PokemonTrade_Scene.new
evo.pbStartScreen(myPokemon,yourPokemon,$Trainer.name,opponent.name)
evo.pbTrade
evo.pbEndScreen
}
$Trainer.party[pokemonIndex] = yourPokemon
end

519
Data/Scripts/016_UI/001_Non-interactive/006_UI_HallOfFame.rb Normal file
View File

@@ -0,0 +1,519 @@
#===============================================================================
# * Hall of Fame - by FL (Credits will be apreciated)
#===============================================================================
#
# This script is for Pokémon Essentials. It makes a recordable Hall of Fame
# like the Gen 3 games.
#
#===============================================================================
#
# To this scripts works, put it above main, put a 512x384 picture in
# hallfamebars and a 8x24 background picture in hallfamebg. To call this script,
# use 'pbHallOfFameEntry'. After you recorder the first entry, you can access
# the hall teams using a PC. You can also check the player Hall of Fame last
# number using '$PokemonGlobal.hallOfFameLastNumber'.
#
#===============================================================================
class HallOfFame_Scene
# When true, all pokémon will be in one line
# When false, all pokémon will be in two lines
SINGLEROW = false
# Make the pokémon movement ON in hall entry
ANIMATION = true
# Speed in pokémon movement in hall entry. Don't use less than 2!
ANIMATIONSPEED = 32
# Entry wait time (in 1/20 seconds) between showing each Pokémon (and trainer)
ENTRYWAITTIME = 64
# Maximum number limit of simultaneous hall entries saved.
# 0 = Doesn't save any hall. -1 = no limit
# Prefer to use larger numbers (like 500 and 1000) than don't put a limit
# If a player exceed this limit, the first one will be removed
HALLLIMIT = 50
# The entry music name. Put "" to doesn't play anything
ENTRYMUSIC = "Hall of Fame"
# Allow eggs to be show and saved in hall
ALLOWEGGS = true
# Remove the hallbars when the trainer sprite appears
REMOVEBARS = true
# The final fade speed on entry
FINALFADESPEED = 16
# Sprites opacity value when them aren't selected
OPACITY = 64
BASECOLOR = Color.new(248,248,248)
SHADOWCOLOR = Color.new(0,0,0)
# Placement for pokemon icons
def pbStartScene
@sprites={}
@viewport=Viewport.new(0,0,Graphics.width, Graphics.height)
@viewport.z=99999
# Comment the below line to doesn't use a background
addBackgroundPlane(@sprites,"bg","hallfamebg",@viewport)
@sprites["hallbars"]=IconSprite.new(@viewport)
@sprites["hallbars"].setBitmap("Graphics/Pictures/hallfamebars")
@sprites["overlay"]=BitmapSprite.new(Graphics.width,Graphics.height,@viewport)
@sprites["overlay"].z=10
pbSetSystemFont(@sprites["overlay"].bitmap)
@alreadyFadedInEnd=false
@useMusic=false
@battlerIndex=0
@hallEntry=[]
end
def pbStartSceneEntry
pbStartScene
@useMusic=(ENTRYMUSIC && ENTRYMUSIC!="")
pbBGMPlay(ENTRYMUSIC) if @useMusic
saveHallEntry
@xmovement=[]
@ymovement=[]
createBattlers
pbFadeInAndShow(@sprites) { pbUpdate }
end
def pbStartScenePC
pbStartScene
@hallIndex=$PokemonGlobal.hallOfFame.size-1
@hallEntry=$PokemonGlobal.hallOfFame[-1]
createBattlers(false)
pbFadeInAndShow(@sprites) { pbUpdate }
pbUpdatePC
end
def pbEndScene
$game_map.autoplay if @useMusic
pbDisposeMessageWindow(@sprites["msgwindow"]) if @sprites.include?("msgwindow")
pbFadeOutAndHide(@sprites) { pbUpdate } if !@alreadyFadedInEnd
pbDisposeSpriteHash(@sprites)
@viewport.dispose
end
def slowFadeOut(sprites,exponent) # 2 exponent
# To handle values above 8
extraWaitExponent=exponent-9
exponent=8 if 8<exponent
max=2**exponent
speed=(2**8)/max
for j in 0..max
if extraWaitExponent>-1
(2**extraWaitExponent).times do
Graphics.update
Input.update
pbUpdate
end
end
pbSetSpritesToColor(sprites,Color.new(0,0,0,j*speed))
block_given? ? yield : pbUpdateSpriteHash(sprites)
end
end
# Dispose the sprite if the sprite exists and make it null
def restartSpritePosition(sprites,spritename)
sprites[spritename].dispose if sprites.include?(spritename) && sprites[spritename]
sprites[spritename]=nil
end
# Change the pokémon sprites opacity except the index one
def setPokemonSpritesOpacity(index,opacity=255)
for n in 0...@hallEntry.size
@sprites["pokemon#{n}"].opacity=(n==index) ? 255 : opacity if @sprites["pokemon#{n}"]
end
end
def saveHallEntry
for i in 0...$Trainer.party.length
# Clones every pokémon object
@hallEntry.push($Trainer.party[i].clone) if !$Trainer.party[i].egg? || ALLOWEGGS
end
# Update the global variables
$PokemonGlobal.hallOfFame.push(@hallEntry)
$PokemonGlobal.hallOfFameLastNumber+=1
$PokemonGlobal.hallOfFame.delete_at(0) if HALLLIMIT>-1 &&
$PokemonGlobal.hallOfFame.size>HALLLIMIT
end
# Return the x/y point position in screen for battler index number
# Don't use odd numbers!
def xpointformula(battlernumber)
ret=0
if !SINGLEROW
ret=32+160*xpositionformula(battlernumber)
else
ret=(60*(battlernumber/2)+48)*(xpositionformula(battlernumber)-1)
ret+=Graphics.width/2-56
end
return ret
end
def ypointformula(battlernumber)
ret=0
if !SINGLEROW
ret=32+128*ypositionformula(battlernumber)/2
else
ret=96-8*(battlernumber/2)
end
return ret
end
# Returns 0, 1 or 2 as the x/y column value
def xpositionformula(battlernumber)
ret=0
if !SINGLEROW
ret=(battlernumber/3%2==0) ? (19-battlernumber)%3 : (19+battlernumber)%3
else
ret=battlernumber%2*2
end
return ret
end
def ypositionformula(battlernumber)
ret=0
if !SINGLEROW
ret=(battlernumber/3)%2*2
else
ret=1
end
return ret
end
def moveSprite(i)
spritename=(i>-1) ? "pokemon#{i}" : "trainer"
speed = (i>-1) ? ANIMATIONSPEED : 2
if(!ANIMATION) # Skips animation
@sprites[spritename].x-=speed*@xmovement[i]
@xmovement[i]=0
@sprites[spritename].y-=speed*@ymovement[i]
@ymovement[i]=0
end
if(@xmovement[i]!=0)
direction = (@xmovement[i]>0) ? -1 : 1
@sprites[spritename].x+=speed*direction
@xmovement[i]+=direction
end
if(@ymovement[i]!=0)
direction = (@ymovement[i]>0) ? -1 : 1
@sprites[spritename].y+=speed*direction
@ymovement[i]+=direction
end
end
def createBattlers(hide=true)
# Movement in animation
for i in 0...6
# Clear all 6 pokémon sprites and dispose the ones that exists every time
# that this method is call
restartSpritePosition(@sprites,"pokemon#{i}")
next if i>=@hallEntry.size
xpoint=xpointformula(i)
ypoint=ypointformula(i)
pok=@hallEntry[i]
@sprites["pokemon#{i}"]=PokemonSprite.new(@viewport)
@sprites["pokemon#{i}"].setOffset(PictureOrigin::TopLeft)
@sprites["pokemon#{i}"].setPokemonBitmap(pok)
# This method doesn't put the exact coordinates
@sprites["pokemon#{i}"].x = xpoint
@sprites["pokemon#{i}"].y = ypoint
if @sprites["pokemon#{i}"].bitmap && !@sprites["pokemon#{i}"].disposed?
@sprites["pokemon#{i}"].x += (128-@sprites["pokemon#{i}"].bitmap.width)/2
@sprites["pokemon#{i}"].y += (128-@sprites["pokemon#{i}"].bitmap.height)/2
end
@sprites["pokemon#{i}"].z=7-i if SINGLEROW
next if !hide
# Animation distance calculation
horizontal=1-xpositionformula(i)
vertical=1-ypositionformula(i)
xdistance=(horizontal==-1) ? -@sprites["pokemon#{i}"].bitmap.width : Graphics.width
ydistance=(vertical==-1) ? -@sprites["pokemon#{i}"].bitmap.height : Graphics.height
xdistance=((xdistance-@sprites["pokemon#{i}"].x)/ANIMATIONSPEED).abs+1
ydistance=((ydistance-@sprites["pokemon#{i}"].y)/ANIMATIONSPEED).abs+1
biggerdistance=(xdistance>ydistance) ? xdistance : ydistance
@xmovement[i]=biggerdistance
@xmovement[i]*=-1 if horizontal==-1
@xmovement[i]=0 if horizontal== 0
@ymovement[i]=biggerdistance
@ymovement[i]*=-1 if vertical==-1
@ymovement[i]=0 if vertical== 0
# Hide the battlers
@sprites["pokemon#{i}"].x+=@xmovement[i]*ANIMATIONSPEED
@sprites["pokemon#{i}"].y+=@ymovement[i]*ANIMATIONSPEED
end
end
def createTrainerBattler
@sprites["trainer"]=IconSprite.new(@viewport)
@sprites["trainer"].setBitmap(GameData::TrainerType.front_sprite_filename($Trainer.trainer_type))
if !SINGLEROW
@sprites["trainer"].x=Graphics.width-96
@sprites["trainer"].y=160
else
@sprites["trainer"].x=Graphics.width/2
@sprites["trainer"].y=178
end
@sprites["trainer"].z=9
@sprites["trainer"].ox=@sprites["trainer"].bitmap.width/2
@sprites["trainer"].oy=@sprites["trainer"].bitmap.height/2
if REMOVEBARS
@sprites["overlay"].bitmap.clear
@sprites["hallbars"].visible=false
end
@xmovement[@battlerIndex]=0
@ymovement[@battlerIndex]=0
if(ANIMATION && !SINGLEROW) # Trainer Animation
startpoint=Graphics.width/2
# 2 is the trainer speed
@xmovement[@battlerIndex]=(startpoint-@sprites["trainer"].x)/2
@sprites["trainer"].x=startpoint
else
ENTRYWAITTIME.times do
Graphics.update
Input.update
pbUpdate
end
end
end
def writeTrainerData
totalsec = Graphics.frame_count / Graphics.frame_rate
hour = totalsec / 60 / 60
min = totalsec / 60 % 60
pubid=sprintf("%05d",$Trainer.public_ID)
lefttext= _INTL("Name<r>{1}<br>",$Trainer.name)
lefttext+=_INTL("IDNo.<r>{1}<br>",pubid)
lefttext+=_ISPRINTF("Time<r>{1:02d}:{2:02d}<br>",hour,min)
lefttext+=_INTL("Pokédex<r>{1}/{2}<br>",
$Trainer.pokedex.owned_count,$Trainer.pokedex.seen_count)
@sprites["messagebox"]=Window_AdvancedTextPokemon.new(lefttext)
@sprites["messagebox"].viewport=@viewport
@sprites["messagebox"].width=192 if @sprites["messagebox"].width<192
@sprites["msgwindow"]=pbCreateMessageWindow(@viewport)
pbMessageDisplay(@sprites["msgwindow"],
_INTL("League champion!\nCongratulations!\\^"))
end
def writePokemonData(pokemon,hallNumber=-1)
overlay=@sprites["overlay"].bitmap
overlay.clear
pokename=pokemon.name
speciesname=pokemon.speciesName
if pokemon.male?
speciesname+="♂"
elsif pokemon.female?
speciesname+="♀"
end
pokename+="/"+speciesname
pokename=_INTL("Egg")+"/"+_INTL("Egg") if pokemon.egg?
idno=(pokemon.owner.name.empty? || pokemon.egg?) ? "?????" : sprintf("%05d",pokemon.owner.public_id)
dexnumber = _INTL("No. ???")
if !pokemon.egg?
species_data = GameData::Species.get(pokemon.species)
dexnumber = _ISPRINTF("No. {1:03d}",species_data.id_number)
end
textPositions=[
[dexnumber,32,Graphics.height-86,0,BASECOLOR,SHADOWCOLOR],
[pokename,Graphics.width-192,Graphics.height-86,2,BASECOLOR,SHADOWCOLOR],
[_INTL("Lv. {1}",pokemon.egg? ? "?" : pokemon.level),
64,Graphics.height-54,0,BASECOLOR,SHADOWCOLOR],
[_INTL("IDNo.{1}",pokemon.egg? ? "?????" : idno),
Graphics.width-192,Graphics.height-54,2,BASECOLOR,SHADOWCOLOR]
]
if (hallNumber>-1)
textPositions.push([_INTL("Hall of Fame No."),Graphics.width/2-104,-6,0,BASECOLOR,SHADOWCOLOR])
textPositions.push([hallNumber.to_s,Graphics.width/2+104,-6,1,BASECOLOR,SHADOWCOLOR])
end
pbDrawTextPositions(overlay,textPositions)
end
def writeWelcome
overlay=@sprites["overlay"].bitmap
overlay.clear
pbDrawTextPositions(overlay,[[_INTL("Welcome to the Hall of Fame!"),
Graphics.width/2,Graphics.height-80,-4,BASECOLOR,SHADOWCOLOR]])
end
def pbAnimationLoop
loop do
Graphics.update
Input.update
pbUpdate
pbUpdateAnimation
break if @battlerIndex==@hallEntry.size+2
end
end
def pbPCSelection
loop do
Graphics.update
Input.update
pbUpdate
continueScene=true
break if Input.trigger?(Input::BACK) # Exits
if Input.trigger?(Input::USE) # Moves the selection one entry backward
@battlerIndex+=10
continueScene=pbUpdatePC
end
if Input.trigger?(Input::LEFT) # Moves the selection one pokémon forward
@battlerIndex-=1
continueScene=pbUpdatePC
end
if Input.trigger?(Input::RIGHT) # Moves the selection one pokémon backward
@battlerIndex+=1
continueScene=pbUpdatePC
end
break if !continueScene
end
end
def pbUpdate
pbUpdateSpriteHash(@sprites)
end
def pbUpdateAnimation
if @battlerIndex<=@hallEntry.size
if @xmovement[@battlerIndex]!=0 || @ymovement[@battlerIndex]!=0
spriteIndex=(@battlerIndex<@hallEntry.size) ? @battlerIndex : -1
moveSprite(spriteIndex)
else
@battlerIndex+=1
if @battlerIndex<=@hallEntry.size
# If it is a pokémon, write the pokémon text, wait the
# ENTRYWAITTIME and goes to the next battler
GameData::Species.play_cry_from_pokemon(@hallEntry[@battlerIndex - 1])
writePokemonData(@hallEntry[@battlerIndex-1])
(ENTRYWAITTIME*Graphics.frame_rate/20).times do
Graphics.update
Input.update
pbUpdate
end
if @battlerIndex<@hallEntry.size # Preparates the next battler
setPokemonSpritesOpacity(@battlerIndex,OPACITY)
@sprites["overlay"].bitmap.clear
else # Show the welcome message and preparates the trainer
setPokemonSpritesOpacity(-1)
writeWelcome
(ENTRYWAITTIME*2*Graphics.frame_rate/20).times do
Graphics.update
Input.update
pbUpdate
end
setPokemonSpritesOpacity(-1,OPACITY) if !SINGLEROW
createTrainerBattler
end
end
end
elsif @battlerIndex>@hallEntry.size
# Write the trainer data and fade
writeTrainerData
(ENTRYWAITTIME*Graphics.frame_rate/20).times do
Graphics.update
Input.update
pbUpdate
end
fadeSpeed=((Math.log(2**12)-Math.log(FINALFADESPEED))/Math.log(2)).floor
pbBGMFade((2**fadeSpeed).to_f/20) if @useMusic
slowFadeOut(@sprites,fadeSpeed) { pbUpdate }
@alreadyFadedInEnd=true
@battlerIndex+=1
end
end
def pbUpdatePC
# Change the team
if @battlerIndex>=@hallEntry.size
@hallIndex-=1
return false if @hallIndex==-1
@hallEntry=$PokemonGlobal.hallOfFame[@hallIndex]
@battlerIndex=0
createBattlers(false)
elsif @battlerIndex<0
@hallIndex+=1
return false if @hallIndex>=$PokemonGlobal.hallOfFame.size
@hallEntry=$PokemonGlobal.hallOfFame[@hallIndex]
@battlerIndex=@hallEntry.size-1
createBattlers(false)
end
# Change the pokemon
GameData::Species.play_cry_from_pokemon(@hallEntry[@battlerIndex])
setPokemonSpritesOpacity(@battlerIndex,OPACITY)
hallNumber=$PokemonGlobal.hallOfFameLastNumber + @hallIndex -
$PokemonGlobal.hallOfFame.size + 1
writePokemonData(@hallEntry[@battlerIndex],hallNumber)
return true
end
end
#===============================================================================
#
#===============================================================================
class HallOfFameScreen
def initialize(scene)
@scene = scene
end
def pbStartScreenEntry
@scene.pbStartSceneEntry
@scene.pbAnimationLoop
@scene.pbEndScene
end
def pbStartScreenPC
@scene.pbStartScenePC
@scene.pbPCSelection
@scene.pbEndScene
end
end
#===============================================================================
#
#===============================================================================
class HallOfFamePC
def shouldShow?
return $PokemonGlobal.hallOfFameLastNumber>0
end
def name
return _INTL("Hall of Fame")
end
def access
pbMessage(_INTL("\\se[PC access]Accessed the Hall of Fame."))
pbHallOfFamePC
end
end
#===============================================================================
#
#===============================================================================
PokemonPCList.registerPC(HallOfFamePC.new)
#===============================================================================
#
#===============================================================================
class PokemonGlobalMetadata
attr_writer :hallOfFame
# Number necessary if hallOfFame array reach in its size limit
attr_writer :hallOfFameLastNumber
def hallOfFame
@hallOfFame = [] if !@hallOfFame
return @hallOfFame
end
def hallOfFameLastNumber
return @hallOfFameLastNumber || 0
end
end
#===============================================================================
#
#===============================================================================
def pbHallOfFameEntry
scene=HallOfFame_Scene.new
screen=HallOfFameScreen.new(scene)
screen.pbStartScreenEntry
end
def pbHallOfFamePC
scene=HallOfFame_Scene.new
screen=HallOfFameScreen.new(scene)
screen.pbStartScreenPC
end

230
Data/Scripts/016_UI/001_Non-interactive/007_UI_Credits.rb Normal file
View File

@@ -0,0 +1,230 @@
#==============================================================================
# * Scene_Credits
#------------------------------------------------------------------------------
# Scrolls the credits you make below. Original Author unknown.
#
## Edited by MiDas Mike so it doesn't play over the Title, but runs by calling
# the following:
# $scene = Scene_Credits.new
#
## New Edit 3/6/2007 11:14 PM by AvatarMonkeyKirby.
# Ok, what I've done is changed the part of the script that was supposed to make
# the credits automatically end so that way they actually end! Yes, they will
# actually end when the credits are finished! So, that will make the people you
# should give credit to now is: Unknown, MiDas Mike, and AvatarMonkeyKirby.
# -sincerly yours,
# Your Beloved
# Oh yea, and I also added a line of code that fades out the BGM so it fades
# sooner and smoother.
#
## New Edit 24/1/2012 by Maruno.
# Added the ability to split a line into two halves with <s>, with each half
# aligned towards the centre. Please also credit me if used.
#
## New Edit 22/2/2012 by Maruno.
# Credits now scroll properly when played with a zoom factor of 0.5. Music can
# now be defined. Credits can't be skipped during their first play.
#
## New Edit 25/3/2020 by Maruno.
# Scroll speed is now independent of frame rate. Now supports non-integer values
# for SCROLL_SPEED.
#
## New Edit 21/8/2020 by Marin.
# Now automatically inserts the credits from the plugins that have been
# registered through the PluginManager module.
#==============================================================================
class Scene_Credits
# Backgrounds to show in credits. Found in Graphics/Titles/ folder
BACKGROUNDS_LIST = ["credits1", "credits2", "credits3", "credits4", "credits5"]
BGM = "Credits"
SCROLL_SPEED = 2
SECONDS_PER_BACKGROUND = 9
TEXT_OUTLINE_COLOR = Color.new(0, 0, 128, 255)
TEXT_BASE_COLOR = Color.new(255, 255, 255, 255)
TEXT_SHADOW_COLOR = Color.new(0, 0, 0, 100)
# This next piece of code is the credits.
# Start Editing
CREDIT = <<_END_
Your credits go here.
Your credits go here.
Your credits go here.
Your credits go here.
Your credits go here.
{INSERTS_PLUGIN_CREDITS_DO_NOT_REMOVE}
"Pokémon Essentials" was created by:
Flameguru
Poccil (Peter O.)
Maruno
With contributions from:
AvatarMonkeyKirby<s>Marin
Boushy<s>MiDas Mike
Brother1440<s>Near Fantastica
FL.<s>PinkMan
Genzai Kawakami<s>Popper
help-14<s>Rataime
IceGod64<s>Savordez
Jacob O. Wobbrock<s>SoundSpawn
KitsuneKouta<s>the__end
Lisa Anthony<s>Venom12
Luka S.J.<s>Wachunga
and everyone else who helped out
"mkxp-z" by:
Roza
Based on MKXP by Ancurio et al.
"RPG Maker XP" by:
Enterbrain
Pokémon is owned by:
The Pokémon Company
Nintendo
Affiliated with Game Freak
This is a non-profit fan-made game.
No copyright infringements intended.
Please support the official games!
_END_
# Stop Editing
def main
#-------------------------------
# Animated Background Setup
#-------------------------------
@sprite = IconSprite.new(0,0)
@backgroundList = BACKGROUNDS_LIST
@frameCounter = 0
# Number of game frames per background frame
@framesPerBackground = SECONDS_PER_BACKGROUND * Graphics.frame_rate
@sprite.setBitmap("Graphics/Titles/"+@backgroundList[0])
#------------------
# Credits text Setup
#------------------
plugin_credits = ""
PluginManager.plugins.each do |plugin|
pcred = PluginManager.credits(plugin)
plugin_credits << "\"#{plugin}\" version #{PluginManager.version(plugin)}\n"
if pcred.size >= 5
plugin_credits << pcred[0] + "\n"
i = 1
until i >= pcred.size
plugin_credits << pcred[i] + "<s>" + (pcred[i + 1] || "") + "\n"
i += 2
end
else
pcred.each do |name|
plugin_credits << name + "\n"
end
end
plugin_credits << "\n"
end
CREDIT.gsub!(/\{INSERTS_PLUGIN_CREDITS_DO_NOT_REMOVE\}/, plugin_credits)
credit_lines = CREDIT.split(/\n/)
credit_bitmap = Bitmap.new(Graphics.width,32 * credit_lines.size)
credit_lines.each_index do |i|
line = credit_lines[i]
line = line.split("<s>")
# LINE ADDED: If you use in your own game, you should remove this line
pbSetSystemFont(credit_bitmap) # <--- This line was added
xpos = 0
align = 1 # Centre align
linewidth = Graphics.width
for j in 0...line.length
if line.length>1
xpos = (j==0) ? 0 : 20 + Graphics.width/2
align = (j==0) ? 2 : 0 # Right align : left align
linewidth = Graphics.width/2 - 20
end
credit_bitmap.font.color = TEXT_SHADOW_COLOR
credit_bitmap.draw_text(xpos,i * 32 + 8,linewidth,32,line[j],align)
credit_bitmap.font.color = TEXT_OUTLINE_COLOR
credit_bitmap.draw_text(xpos + 2,i * 32 - 2,linewidth,32,line[j],align)
credit_bitmap.draw_text(xpos,i * 32 - 2,linewidth,32,line[j],align)
credit_bitmap.draw_text(xpos - 2,i * 32 - 2,linewidth,32,line[j],align)
credit_bitmap.draw_text(xpos + 2,i * 32,linewidth,32,line[j],align)
credit_bitmap.draw_text(xpos - 2,i * 32,linewidth,32,line[j],align)
credit_bitmap.draw_text(xpos + 2,i * 32 + 2,linewidth,32,line[j],align)
credit_bitmap.draw_text(xpos,i * 32 + 2,linewidth,32,line[j],align)
credit_bitmap.draw_text(xpos - 2,i * 32 + 2,linewidth,32,line[j],align)
credit_bitmap.font.color = TEXT_BASE_COLOR
credit_bitmap.draw_text(xpos,i * 32,linewidth,32,line[j],align)
end
end
@trim = Graphics.height/10
@realOY = -(Graphics.height-@trim) # -430
@oyChangePerFrame = SCROLL_SPEED*20.0/Graphics.frame_rate
@credit_sprite = Sprite.new(Viewport.new(0,@trim,Graphics.width,Graphics.height-(@trim*2)))
@credit_sprite.bitmap = credit_bitmap
@credit_sprite.z = 9998
@credit_sprite.oy = @realOY
@bg_index = 0
@last_flag = false
#--------
# Setup
#--------
# Stops all audio but background music
previousBGM = $game_system.getPlayingBGM
pbMEStop
pbBGSStop
pbSEStop
pbBGMFade(2.0)
pbBGMPlay(BGM)
Graphics.transition(20)
loop do
Graphics.update
Input.update
update
break if $scene != self
end
Graphics.freeze
@sprite.dispose
@credit_sprite.dispose
$PokemonGlobal.creditsPlayed = true
pbBGMPlay(previousBGM)
end
# Check if the credits should be cancelled
def cancel?
if Input.trigger?(Input::USE) && $PokemonGlobal.creditsPlayed
$scene = Scene_Map.new
pbBGMFade(1.0)
return true
end
return false
end
# Checks if credits bitmap has reached its ending point
def last?
if @realOY > @credit_sprite.bitmap.height + @trim
$scene = ($game_map) ? Scene_Map.new : nil
pbBGMFade(2.0)
return true
end
return false
end
def update
@frameCounter += 1
# Go to next slide
if @frameCounter >= @framesPerBackground
@frameCounter -= @framesPerBackground
@bg_index += 1
@bg_index = 0 if @bg_index >= @backgroundList.length
@sprite.setBitmap("Graphics/Titles/"+@backgroundList[@bg_index])
end
return if cancel?
return if last?
@realOY += @oyChangePerFrame
@credit_sprite.oy = @realOY
end
end

287
Data/Scripts/016_UI/001_UI_PauseMenu.rb Normal file
View File

@@ -0,0 +1,287 @@
#===============================================================================
#
#===============================================================================
class PokemonPauseMenu_Scene
def pbStartScene
@viewport = Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z = 99999
@sprites = {}
@sprites["cmdwindow"] = Window_CommandPokemon.new([])
@sprites["cmdwindow"].visible = false
@sprites["cmdwindow"].viewport = @viewport
@sprites["infowindow"] = Window_UnformattedTextPokemon.newWithSize("",0,0,32,32,@viewport)
@sprites["infowindow"].visible = false
@sprites["helpwindow"] = Window_UnformattedTextPokemon.newWithSize("",0,0,32,32,@viewport)
@sprites["helpwindow"].visible = false
@infostate = false
@helpstate = false
pbSEPlay("GUI menu open")
end
def pbShowInfo(text)
@sprites["infowindow"].resizeToFit(text,Graphics.height)
@sprites["infowindow"].text = text
@sprites["infowindow"].visible = true
@infostate = true
end
def pbShowHelp(text)
@sprites["helpwindow"].resizeToFit(text,Graphics.height)
@sprites["helpwindow"].text = text
@sprites["helpwindow"].visible = true
pbBottomLeft(@sprites["helpwindow"])
@helpstate = true
end
def pbShowMenu
@sprites["cmdwindow"].visible = true
@sprites["infowindow"].visible = @infostate
@sprites["helpwindow"].visible = @helpstate
end
def pbHideMenu
@sprites["cmdwindow"].visible = false
@sprites["infowindow"].visible = false
@sprites["helpwindow"].visible = false
end
def pbShowCommands(commands)
ret = -1
cmdwindow = @sprites["cmdwindow"]
cmdwindow.commands = commands
cmdwindow.index = $PokemonTemp.menuLastChoice
cmdwindow.resizeToFit(commands)
cmdwindow.x = Graphics.width-cmdwindow.width
cmdwindow.y = 0
cmdwindow.visible = true
loop do
cmdwindow.update
Graphics.update
Input.update
pbUpdateSceneMap
if Input.trigger?(Input::BACK)
ret = -1
break
elsif Input.trigger?(Input::USE)
ret = cmdwindow.index
$PokemonTemp.menuLastChoice = ret
break
end
end
return ret
end
def pbEndScene
pbDisposeSpriteHash(@sprites)
@viewport.dispose
end
def pbRefresh; end
end
#===============================================================================
#
#===============================================================================
class PokemonPauseMenu
def initialize(scene)
@scene = scene
end
def pbShowMenu
@scene.pbRefresh
@scene.pbShowMenu
end
def pbStartPokemonMenu
if !$Trainer
if $DEBUG
pbMessage(_INTL("The player trainer was not defined, so the pause menu can't be displayed."))
pbMessage(_INTL("Please see the documentation to learn how to set up the trainer player."))
end
return
end
@scene.pbStartScene
endscene = true
commands = []
cmdPokedex = -1
cmdPokemon = -1
cmdBag = -1
cmdTrainer = -1
cmdSave = -1
cmdOption = -1
cmdPokegear = -1
cmdDebug = -1
cmdQuit = -1
cmdEndGame = -1
if $Trainer.has_pokedex && $Trainer.pokedex.accessible_dexes.length > 0
commands[cmdPokedex = commands.length] = _INTL("Pokédex")
end
commands[cmdPokemon = commands.length] = _INTL("Pokémon") if $Trainer.party_count > 0
commands[cmdBag = commands.length] = _INTL("Bag") if !pbInBugContest?
commands[cmdPokegear = commands.length] = _INTL("Pokégear") if $Trainer.has_pokegear
commands[cmdTrainer = commands.length] = $Trainer.name
if pbInSafari?
if Settings::SAFARI_STEPS <= 0
@scene.pbShowInfo(_INTL("Balls: {1}",pbSafariState.ballcount))
else
@scene.pbShowInfo(_INTL("Steps: {1}/{2}\nBalls: {3}",
pbSafariState.steps, Settings::SAFARI_STEPS, pbSafariState.ballcount))
end
commands[cmdQuit = commands.length] = _INTL("Quit")
elsif pbInBugContest?
if pbBugContestState.lastPokemon
@scene.pbShowInfo(_INTL("Caught: {1}\nLevel: {2}\nBalls: {3}",
pbBugContestState.lastPokemon.speciesName,
pbBugContestState.lastPokemon.level,
pbBugContestState.ballcount))
else
@scene.pbShowInfo(_INTL("Caught: None\nBalls: {1}",pbBugContestState.ballcount))
end
commands[cmdQuit = commands.length] = _INTL("Quit Contest")
else
commands[cmdSave = commands.length] = _INTL("Save") if $game_system && !$game_system.save_disabled
end
commands[cmdOption = commands.length] = _INTL("Options")
commands[cmdDebug = commands.length] = _INTL("Debug") if $DEBUG
commands[cmdEndGame = commands.length] = _INTL("Quit Game")
loop do
command = @scene.pbShowCommands(commands)
if cmdPokedex>=0 && command==cmdPokedex
pbPlayDecisionSE
if Settings::USE_CURRENT_REGION_DEX
pbFadeOutIn {
scene = PokemonPokedex_Scene.new
screen = PokemonPokedexScreen.new(scene)
screen.pbStartScreen
@scene.pbRefresh
}
else
if $Trainer.pokedex.accessible_dexes.length == 1
$PokemonGlobal.pokedexDex = $Trainer.pokedex.accessible_dexes[0]
pbFadeOutIn {
scene = PokemonPokedex_Scene.new
screen = PokemonPokedexScreen.new(scene)
screen.pbStartScreen
@scene.pbRefresh
}
else
pbFadeOutIn {
scene = PokemonPokedexMenu_Scene.new
screen = PokemonPokedexMenuScreen.new(scene)
screen.pbStartScreen
@scene.pbRefresh
}
end
end
elsif cmdPokemon>=0 && command==cmdPokemon
pbPlayDecisionSE
hiddenmove = nil
pbFadeOutIn {
sscene = PokemonParty_Scene.new
sscreen = PokemonPartyScreen.new(sscene,$Trainer.party)
hiddenmove = sscreen.pbPokemonScreen
(hiddenmove) ? @scene.pbEndScene : @scene.pbRefresh
}
if hiddenmove
$game_temp.in_menu = false
pbUseHiddenMove(hiddenmove[0],hiddenmove[1])
return
end
elsif cmdBag>=0 && command==cmdBag
pbPlayDecisionSE
item = nil
pbFadeOutIn {
scene = PokemonBag_Scene.new
screen = PokemonBagScreen.new(scene,$PokemonBag)
item = screen.pbStartScreen
(item) ? @scene.pbEndScene : @scene.pbRefresh
}
if item
$game_temp.in_menu = false
pbUseKeyItemInField(item)
return
end
elsif cmdPokegear>=0 && command==cmdPokegear
pbPlayDecisionSE
pbFadeOutIn {
scene = PokemonPokegear_Scene.new
screen = PokemonPokegearScreen.new(scene)
screen.pbStartScreen
@scene.pbRefresh
}
elsif cmdTrainer>=0 && command==cmdTrainer
pbPlayDecisionSE
pbFadeOutIn {
scene = PokemonTrainerCard_Scene.new
screen = PokemonTrainerCardScreen.new(scene)
screen.pbStartScreen
@scene.pbRefresh
}
elsif cmdQuit>=0 && command==cmdQuit
@scene.pbHideMenu
if pbInSafari?
if pbConfirmMessage(_INTL("Would you like to leave the Safari Game right now?"))
@scene.pbEndScene
pbSafariState.decision = 1
pbSafariState.pbGoToStart
return
else
pbShowMenu
end
else
if pbConfirmMessage(_INTL("Would you like to end the Contest now?"))
@scene.pbEndScene
pbBugContestState.pbStartJudging
return
else
pbShowMenu
end
end
elsif cmdSave>=0 && command==cmdSave
@scene.pbHideMenu
scene = PokemonSave_Scene.new
screen = PokemonSaveScreen.new(scene)
if screen.pbSaveScreen
@scene.pbEndScene
endscene = false
break
else
pbShowMenu
end
elsif cmdOption>=0 && command==cmdOption
pbPlayDecisionSE
pbFadeOutIn {
scene = PokemonOption_Scene.new
screen = PokemonOptionScreen.new(scene)
screen.pbStartScreen
pbUpdateSceneMap
@scene.pbRefresh
}
elsif cmdDebug>=0 && command==cmdDebug
pbPlayDecisionSE
pbFadeOutIn {
pbDebugMenu
@scene.pbRefresh
}
elsif cmdEndGame>=0 && command==cmdEndGame
@scene.pbHideMenu
if pbConfirmMessage(_INTL("Are you sure you want to quit the game?"))
scene = PokemonSave_Scene.new
screen = PokemonSaveScreen.new(scene)
if screen.pbSaveScreen
@scene.pbEndScene
end
@scene.pbEndScene
$scene = nil
return
else
pbShowMenu
end
else
pbPlayCloseMenuSE
break
end
end
@scene.pbEndScene if endscene
end
end

123
Data/Scripts/016_UI/002_UI_Pokedex_Menu.rb Normal file
View File

@@ -0,0 +1,123 @@
#===============================================================================
# Pokédex Regional Dexes list menu screen
# * For choosing which region list to view. Only appears when there is more
# than one accessible region list to choose from, and if
# Settings::USE_CURRENT_REGION_DEX is false.
#===============================================================================
class Window_DexesList < Window_CommandPokemon
def initialize(commands,commands2,width)
@commands2 = commands2
super(commands,width)
@selarrow = AnimatedBitmap.new("Graphics/Pictures/selarrow_white")
self.baseColor = Color.new(248,248,248)
self.shadowColor = Color.new(0,0,0)
self.windowskin = nil
end
def drawItem(index,count,rect)
super(index,count,rect)
if index>=0 && index<@commands2.length
pbDrawShadowText(self.contents,rect.x+254,rect.y,64,rect.height,
sprintf("%d",@commands2[index][0]),self.baseColor,self.shadowColor,1)
pbDrawShadowText(self.contents,rect.x+350,rect.y,64,rect.height,
sprintf("%d",@commands2[index][1]),self.baseColor,self.shadowColor,1)
allseen = (@commands2[index][0]>=@commands2[index][2])
allown = (@commands2[index][1]>=@commands2[index][2])
pbDrawImagePositions(self.contents,[
["Graphics/Pictures/Pokedex/icon_menuseenown",rect.x+236,rect.y+2,(allseen) ? 24 : 0,0,24,24],
["Graphics/Pictures/Pokedex/icon_menuseenown",rect.x+332,rect.y+2,(allown) ? 24 : 0,24,24,24]
])
end
end
end
#===============================================================================
#
#===============================================================================
class PokemonPokedexMenu_Scene
def pbUpdate
pbUpdateSpriteHash(@sprites)
end
def pbStartScene(commands,commands2)
@commands = commands
@viewport = Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z = 99999
@sprites = {}
@sprites["background"] = IconSprite.new(0,0,@viewport)
@sprites["background"].setBitmap(_INTL("Graphics/Pictures/Pokedex/bg_menu"))
@sprites["headings"]=Window_AdvancedTextPokemon.newWithSize(
_INTL("<c3=F8F8F8,C02028>SEEN<r>OBTAINED</c3>"),286,136,208,64,@viewport)
@sprites["headings"].windowskin = nil
@sprites["commands"] = Window_DexesList.new(commands,commands2,Graphics.width-84)
@sprites["commands"].x = 40
@sprites["commands"].y = 192
@sprites["commands"].height = 192
@sprites["commands"].viewport = @viewport
pbFadeInAndShow(@sprites) { pbUpdate }
end
def pbScene
ret = -1
loop do
Graphics.update
Input.update
pbUpdate
if Input.trigger?(Input::BACK)
pbPlayCloseMenuSE
break
elsif Input.trigger?(Input::USE)
ret = @sprites["commands"].index
(ret==@commands.length-1) ? pbPlayCloseMenuSE : pbPlayDecisionSE
break
end
end
return ret
end
def pbEndScene
pbFadeOutAndHide(@sprites) { pbUpdate }
pbDisposeSpriteHash(@sprites)
@viewport.dispose
end
end
#===============================================================================
#
#===============================================================================
class PokemonPokedexMenuScreen
def initialize(scene)
@scene = scene
end
def pbStartScreen
commands = []
commands2 = []
dexnames = Settings.pokedex_names
$Trainer.pokedex.accessible_dexes.each do |dex|
if dexnames[dex].nil?
commands.push(_INTL("Pokédex"))
elsif dexnames[dex].is_a?(Array)
commands.push(dexnames[dex][0])
else
commands.push(dexnames[dex])
end
commands2.push([$Trainer.pokedex.seen_count(dex),
$Trainer.pokedex.owned_count(dex),
pbGetRegionalDexLength(dex)])
end
commands.push(_INTL("Exit"))
@scene.pbStartScene(commands,commands2)
loop do
cmd = @scene.pbScene
break if cmd<0 || cmd>=commands2.length # Cancel/Exit
$PokemonGlobal.pokedexDex = $Trainer.pokedex.accessible_dexes[cmd]
pbFadeOutIn {
scene = PokemonPokedex_Scene.new
screen = PokemonPokedexScreen.new(scene)
screen.pbStartScreen
}
end
@scene.pbEndScene
end
end

1198
Data/Scripts/016_UI/003_UI_Pokedex_Main.rb Normal file
View File

File diff suppressed because it is too large Load Diff

567
Data/Scripts/016_UI/004_UI_Pokedex_Entry.rb Normal file
View File

@@ -0,0 +1,567 @@
#===============================================================================
#
#===============================================================================
class PokemonPokedexInfo_Scene
def pbStartScene(dexlist,index,region)
@viewport = Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z = 99999
@dexlist = dexlist
@index = index
@region = region
@page = 1
@typebitmap = AnimatedBitmap.new(_INTL("Graphics/Pictures/Pokedex/icon_types"))
@sprites = {}
@sprites["background"] = IconSprite.new(0,0,@viewport)
@sprites["infosprite"] = PokemonSprite.new(@viewport)
@sprites["infosprite"].setOffset(PictureOrigin::Center)
@sprites["infosprite"].x = 104
@sprites["infosprite"].y = 136
@mapdata = pbLoadTownMapData
map_metadata = GameData::MapMetadata.try_get($game_map.map_id)
mappos = (map_metadata) ? map_metadata.town_map_position : nil
if @region < 0 # Use player's current region
@region = (mappos) ? mappos[0] : 0 # Region 0 default
end
@sprites["areamap"] = IconSprite.new(0,0,@viewport)
@sprites["areamap"].setBitmap("Graphics/Pictures/#{@mapdata[@region][1]}")
@sprites["areamap"].x += (Graphics.width-@sprites["areamap"].bitmap.width)/2
@sprites["areamap"].y += (Graphics.height+32-@sprites["areamap"].bitmap.height)/2
for hidden in Settings::REGION_MAP_EXTRAS
if hidden[0]==@region && hidden[1]>0 && $game_switches[hidden[1]]
pbDrawImagePositions(@sprites["areamap"].bitmap,[
["Graphics/Pictures/#{hidden[4]}",
hidden[2]*PokemonRegionMap_Scene::SQUAREWIDTH,
hidden[3]*PokemonRegionMap_Scene::SQUAREHEIGHT]
])
end
end
@sprites["areahighlight"] = BitmapSprite.new(Graphics.width,Graphics.height,@viewport)
@sprites["areaoverlay"] = IconSprite.new(0,0,@viewport)
@sprites["areaoverlay"].setBitmap("Graphics/Pictures/Pokedex/overlay_area")
@sprites["formfront"] = PokemonSprite.new(@viewport)
@sprites["formfront"].setOffset(PictureOrigin::Center)
@sprites["formfront"].x = 130
@sprites["formfront"].y = 158
@sprites["formback"] = PokemonSprite.new(@viewport)
@sprites["formback"].setOffset(PictureOrigin::Bottom)
@sprites["formback"].x = 382 # y is set below as it depends on metrics
@sprites["formicon"] = PokemonSpeciesIconSprite.new(nil, @viewport)
@sprites["formicon"].setOffset(PictureOrigin::Center)
@sprites["formicon"].x = 82
@sprites["formicon"].y = 328
@sprites["uparrow"] = AnimatedSprite.new("Graphics/Pictures/uparrow",8,28,40,2,@viewport)
@sprites["uparrow"].x = 242
@sprites["uparrow"].y = 268
@sprites["uparrow"].play
@sprites["uparrow"].visible = false
@sprites["downarrow"] = AnimatedSprite.new("Graphics/Pictures/downarrow",8,28,40,2,@viewport)
@sprites["downarrow"].x = 242
@sprites["downarrow"].y = 348
@sprites["downarrow"].play
@sprites["downarrow"].visible = false
@sprites["overlay"] = BitmapSprite.new(Graphics.width,Graphics.height,@viewport)
pbSetSystemFont(@sprites["overlay"].bitmap)
pbUpdateDummyPokemon
@available = pbGetAvailableForms
drawPage(@page)
pbFadeInAndShow(@sprites) { pbUpdate }
end
def pbStartSceneBrief(species) # For standalone access, shows first page only
@viewport = Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z = 99999
dexnum = species
dexnumshift = false
if $Trainer.pokedex.unlocked?(-1) # National Dex is unlocked
dexnumshift = true if Settings::DEXES_WITH_OFFSETS.include?(-1)
else
dexnum = 0
for i in 0...$Trainer.pokedex.dexes_count - 1 # Regional Dexes
next if !$Trainer.pokedex.unlocked?(i)
num = pbGetRegionalNumber(i,species)
next if num <= 0
dexnum = num
dexnumshift = true if Settings::DEXES_WITH_OFFSETS.include?(i)
break
end
end
@dexlist = [[species,"",0,0,dexnum,dexnumshift]]
@index = 0
@page = 1
@brief = true
@typebitmap = AnimatedBitmap.new(_INTL("Graphics/Pictures/Pokedex/icon_types"))
@sprites = {}
@sprites["background"] = IconSprite.new(0,0,@viewport)
@sprites["infosprite"] = PokemonSprite.new(@viewport)
@sprites["infosprite"].setOffset(PictureOrigin::Center)
@sprites["infosprite"].x = 104
@sprites["infosprite"].y = 136
@sprites["overlay"] = BitmapSprite.new(Graphics.width,Graphics.height,@viewport)
pbSetSystemFont(@sprites["overlay"].bitmap)
pbUpdateDummyPokemon
drawPage(@page)
pbFadeInAndShow(@sprites) { pbUpdate }
end
def pbEndScene
pbFadeOutAndHide(@sprites) { pbUpdate }
pbDisposeSpriteHash(@sprites)
@typebitmap.dispose
@viewport.dispose
end
def pbUpdate
if @page==2
intensity = (Graphics.frame_count%40)*12
intensity = 480-intensity if intensity>240
@sprites["areahighlight"].opacity = intensity
end
pbUpdateSpriteHash(@sprites)
end
def pbUpdateDummyPokemon
@species = @dexlist[@index][0]
@gender, @form = $Trainer.pokedex.last_form_seen(@species)
species_data = GameData::Species.get_species_form(@species, @form)
@sprites["infosprite"].setSpeciesBitmap(@species,@gender,@form)
if @sprites["formfront"]
@sprites["formfront"].setSpeciesBitmap(@species,@gender,@form)
end
if @sprites["formback"]
@sprites["formback"].setSpeciesBitmap(@species,@gender,@form,false,false,true)
@sprites["formback"].y = 256
@sprites["formback"].y += species_data.back_sprite_y * 2
end
if @sprites["formicon"]
@sprites["formicon"].pbSetParams(@species,@gender,@form)
end
end
def pbGetAvailableForms
ret = []
multiple_forms = false
# Find all genders/forms of @species that have been seen
GameData::Species.each do |sp|
next if sp.species != @species
next if sp.form != 0 && (!sp.real_form_name || sp.real_form_name.empty?)
next if sp.pokedex_form != sp.form
multiple_forms = true if sp.form > 0
case sp.gender_ratio
when :AlwaysMale, :AlwaysFemale, :Genderless
real_gender = (sp.gender_ratio == :AlwaysFemale) ? 1 : 0
next if !$Trainer.pokedex.seen_form?(@species, real_gender, sp.form) && !Settings::DEX_SHOWS_ALL_FORMS
real_gender = 2 if sp.gender_ratio == :Genderless
ret.push([sp.form_name, real_gender, sp.form])
else # Both male and female
for real_gender in 0...2
next if !$Trainer.pokedex.seen_form?(@species, real_gender, sp.form) && !Settings::DEX_SHOWS_ALL_FORMS
ret.push([sp.form_name, real_gender, sp.form])
break if sp.form_name && !sp.form_name.empty? # Only show 1 entry for each non-0 form
end
end
end
# Sort all entries
ret.sort! { |a, b| (a[2] == b[2]) ? a[1] <=> b[1] : a[2] <=> b[2] }
# Create form names for entries if they don't already exist
ret.each do |entry|
if !entry[0] || entry[0].empty? # Necessarily applies only to form 0
case entry[1]
when 0 then entry[0] = _INTL("Male")
when 1 then entry[0] = _INTL("Female")
else
entry[0] = (multiple_forms) ? _INTL("One Form") : _INTL("Genderless")
end
end
entry[1] = 0 if entry[1] == 2 # Genderless entries are treated as male
end
return ret
end
def drawPage(page)
overlay = @sprites["overlay"].bitmap
overlay.clear
# Make certain sprites visible
@sprites["infosprite"].visible = (@page==1)
@sprites["areamap"].visible = (@page==2) if @sprites["areamap"]
@sprites["areahighlight"].visible = (@page==2) if @sprites["areahighlight"]
@sprites["areaoverlay"].visible = (@page==2) if @sprites["areaoverlay"]
@sprites["formfront"].visible = (@page==3) if @sprites["formfront"]
@sprites["formback"].visible = (@page==3) if @sprites["formback"]
@sprites["formicon"].visible = (@page==3) if @sprites["formicon"]
# Draw page-specific information
case page
when 1 then drawPageInfo
when 2 then drawPageArea
when 3 then drawPageForms
end
end
def drawPageInfo
@sprites["background"].setBitmap(_INTL("Graphics/Pictures/Pokedex/bg_info"))
overlay = @sprites["overlay"].bitmap
base = Color.new(88, 88, 80)
shadow = Color.new(168, 184, 184)
imagepos = []
if @brief
imagepos.push([_INTL("Graphics/Pictures/Pokedex/overlay_info"), 0, 0])
end
species_data = GameData::Species.get_species_form(@species, @form)
# Write various bits of text
indexText = "???"
if @dexlist[@index][4] > 0
indexNumber = @dexlist[@index][4]
indexNumber -= 1 if @dexlist[@index][5]
indexText = sprintf("%03d", indexNumber)
end
textpos = [
[_INTL("{1}{2} {3}", indexText, " ", species_data.name),
246, 36, 0, Color.new(248, 248, 248), Color.new(0, 0, 0)],
[_INTL("Height"), 314, 152, 0, base, shadow],
[_INTL("Weight"), 314, 184, 0, base, shadow]
]
if $Trainer.owned?(@species)
# Write the category
textpos.push([_INTL("{1} Pokémon", species_data.category), 246, 68, 0, base, shadow])
# Write the height and weight
height = species_data.height
weight = species_data.weight
if System.user_language[3..4] == "US" # If the user is in the United States
inches = (height / 0.254).round
pounds = (weight / 0.45359).round
textpos.push([_ISPRINTF("{1:d}'{2:02d}\"", inches / 12, inches % 12), 460, 152, 1, base, shadow])
textpos.push([_ISPRINTF("{1:4.1f} lbs.", pounds / 10.0), 494, 184, 1, base, shadow])
else
textpos.push([_ISPRINTF("{1:.1f} m", height / 10.0), 470, 152, 1, base, shadow])
textpos.push([_ISPRINTF("{1:.1f} kg", weight / 10.0), 482, 184, 1, base, shadow])
end
# Draw the Pokédex entry text
drawTextEx(overlay, 40, 240, Graphics.width - (40 * 2), 4, # overlay, x, y, width, num lines
species_data.pokedex_entry, base, shadow)
# Draw the footprint
footprintfile = GameData::Species.footprint_filename(@species, @form)
if footprintfile
footprint = RPG::Cache.load_bitmap("",footprintfile)
overlay.blt(226, 138, footprint, footprint.rect)
footprint.dispose
end
# Show the owned icon
imagepos.push(["Graphics/Pictures/Pokedex/icon_own", 212, 44])
# Draw the type icon(s)
type1 = species_data.type1
type2 = species_data.type2
type1_number = GameData::Type.get(type1).id_number
type2_number = GameData::Type.get(type2).id_number
type1rect = Rect.new(0, type1_number * 32, 96, 32)
type2rect = Rect.new(0, type2_number * 32, 96, 32)
overlay.blt(296, 120, @typebitmap.bitmap, type1rect)
overlay.blt(396, 120, @typebitmap.bitmap, type2rect) if type1 != type2
else
# Write the category
textpos.push([_INTL("????? Pokémon"), 246, 68, 0, base, shadow])
# Write the height and weight
if System.user_language[3..4] == "US" # If the user is in the United States
textpos.push([_INTL("???'??\""), 460, 152, 1, base, shadow])
textpos.push([_INTL("????.? lbs."), 494, 184, 1, base, shadow])
else
textpos.push([_INTL("????.? m"), 470, 152, 1, base, shadow])
textpos.push([_INTL("????.? kg"), 482, 184, 1, base, shadow])
end
end
# Draw all text
pbDrawTextPositions(overlay, textpos)
# Draw all images
pbDrawImagePositions(overlay, imagepos)
end
def pbFindEncounter(enc_types, species)
return false if !enc_types
enc_types.each_value do |slots|
next if !slots
slots.each { |slot| return true if GameData::Species.get(slot[1]).species == species }
end
return false
end
def drawPageArea
@sprites["background"].setBitmap(_INTL("Graphics/Pictures/Pokedex/bg_area"))
overlay = @sprites["overlay"].bitmap
base = Color.new(88,88,80)
shadow = Color.new(168,184,184)
@sprites["areahighlight"].bitmap.clear
# Fill the array "points" with all squares of the region map in which the
# species can be found
points = []
mapwidth = 1+PokemonRegionMap_Scene::RIGHT-PokemonRegionMap_Scene::LEFT
GameData::Encounter.each_of_version($PokemonGlobal.encounter_version) do |enc_data|
next if !pbFindEncounter(enc_data.types, @species)
map_metadata = GameData::MapMetadata.try_get(enc_data.map)
mappos = (map_metadata) ? map_metadata.town_map_position : nil
next if !mappos || mappos[0] != @region
showpoint = true
for loc in @mapdata[@region][2]
showpoint = false if loc[0]==mappos[1] && loc[1]==mappos[2] &&
loc[7] && !$game_switches[loc[7]]
end
next if !showpoint
mapsize = map_metadata.town_map_size
if mapsize && mapsize[0] && mapsize[0]>0
sqwidth = mapsize[0]
sqheight = (mapsize[1].length*1.0/mapsize[0]).ceil
for i in 0...sqwidth
for j in 0...sqheight
if mapsize[1][i+j*sqwidth,1].to_i>0
points[mappos[1]+i+(mappos[2]+j)*mapwidth] = true
end
end
end
else
points[mappos[1]+mappos[2]*mapwidth] = true
end
end
# Draw coloured squares on each square of the region map with a nest
pointcolor = Color.new(0,248,248)
pointcolorhl = Color.new(192,248,248)
sqwidth = PokemonRegionMap_Scene::SQUAREWIDTH
sqheight = PokemonRegionMap_Scene::SQUAREHEIGHT
for j in 0...points.length
if points[j]
x = (j%mapwidth)*sqwidth
x += (Graphics.width-@sprites["areamap"].bitmap.width)/2
y = (j/mapwidth)*sqheight
y += (Graphics.height+32-@sprites["areamap"].bitmap.height)/2
@sprites["areahighlight"].bitmap.fill_rect(x,y,sqwidth,sqheight,pointcolor)
if j-mapwidth<0 || !points[j-mapwidth]
@sprites["areahighlight"].bitmap.fill_rect(x,y-2,sqwidth,2,pointcolorhl)
end
if j+mapwidth>=points.length || !points[j+mapwidth]
@sprites["areahighlight"].bitmap.fill_rect(x,y+sqheight,sqwidth,2,pointcolorhl)
end
if j%mapwidth==0 || !points[j-1]
@sprites["areahighlight"].bitmap.fill_rect(x-2,y,2,sqheight,pointcolorhl)
end
if (j+1)%mapwidth==0 || !points[j+1]
@sprites["areahighlight"].bitmap.fill_rect(x+sqwidth,y,2,sqheight,pointcolorhl)
end
end
end
# Set the text
textpos = []
if points.length==0
pbDrawImagePositions(overlay,[
[sprintf("Graphics/Pictures/Pokedex/overlay_areanone"),108,188]
])
textpos.push([_INTL("Area unknown"),Graphics.width/2,Graphics.height/2 - 6,2,base,shadow])
end
textpos.push([pbGetMessage(MessageTypes::RegionNames,@region),414,38,2,base,shadow])
textpos.push([_INTL("{1}'s area",GameData::Species.get(@species).name),
Graphics.width/2,346,2,base,shadow])
pbDrawTextPositions(overlay,textpos)
end
def drawPageForms
@sprites["background"].setBitmap(_INTL("Graphics/Pictures/Pokedex/bg_forms"))
overlay = @sprites["overlay"].bitmap
base = Color.new(88,88,80)
shadow = Color.new(168,184,184)
# Write species and form name
formname = ""
for i in @available
if i[1]==@gender && i[2]==@form
formname = i[0]; break
end
end
textpos = [
[GameData::Species.get(@species).name,Graphics.width/2,Graphics.height-94,2,base,shadow],
[formname,Graphics.width/2,Graphics.height-62,2,base,shadow],
]
# Draw all text
pbDrawTextPositions(overlay,textpos)
end
def pbGoToPrevious
newindex = @index
while newindex>0
newindex -= 1
if $Trainer.seen?(@dexlist[newindex][0])
@index = newindex
break
end
end
end
def pbGoToNext
newindex = @index
while newindex<@dexlist.length-1
newindex += 1
if $Trainer.seen?(@dexlist[newindex][0])
@index = newindex
break
end
end
end
def pbChooseForm
index = 0
for i in 0...@available.length
if @available[i][1]==@gender && @available[i][2]==@form
index = i
break
end
end
oldindex = -1
loop do
if oldindex!=index
$Trainer.pokedex.set_last_form_seen(@species, @available[index][1], @available[index][2])
pbUpdateDummyPokemon
drawPage(@page)
@sprites["uparrow"].visible = (index>0)
@sprites["downarrow"].visible = (index<@available.length-1)
oldindex = index
end
Graphics.update
Input.update
pbUpdate
if Input.trigger?(Input::UP)
pbPlayCursorSE
index = (index+@available.length-1)%@available.length
elsif Input.trigger?(Input::DOWN)
pbPlayCursorSE
index = (index+1)%@available.length
elsif Input.trigger?(Input::BACK)
pbPlayCancelSE
break
elsif Input.trigger?(Input::USE)
pbPlayDecisionSE
break
end
end
@sprites["uparrow"].visible = false
@sprites["downarrow"].visible = false
end
def pbScene
GameData::Species.play_cry_from_species(@species, @form)
loop do
Graphics.update
Input.update
pbUpdate
dorefresh = false
if Input.trigger?(Input::ACTION)
pbSEStop
GameData::Species.play_cry_from_species(@species, @form) if @page == 1
elsif Input.trigger?(Input::BACK)
pbPlayCloseMenuSE
break
elsif Input.trigger?(Input::USE)
if @page==2 # Area
# dorefresh = true
elsif @page==3 # Forms
if @available.length>1
pbPlayDecisionSE
pbChooseForm
dorefresh = true
end
end
elsif Input.trigger?(Input::UP)
oldindex = @index
pbGoToPrevious
if @index!=oldindex
pbUpdateDummyPokemon
@available = pbGetAvailableForms
pbSEStop
(@page==1) ? GameData::Species.play_cry_from_species(@species, @form) : pbPlayCursorSE
dorefresh = true
end
elsif Input.trigger?(Input::DOWN)
oldindex = @index
pbGoToNext
if @index!=oldindex
pbUpdateDummyPokemon
@available = pbGetAvailableForms
pbSEStop
(@page==1) ? GameData::Species.play_cry_from_species(@species, @form) : pbPlayCursorSE
dorefresh = true
end
elsif Input.trigger?(Input::LEFT)
oldpage = @page
@page -= 1
@page = 1 if @page<1
@page = 3 if @page>3
if @page!=oldpage
pbPlayCursorSE
dorefresh = true
end
elsif Input.trigger?(Input::RIGHT)
oldpage = @page
@page += 1
@page = 1 if @page<1
@page = 3 if @page>3
if @page!=oldpage
pbPlayCursorSE
dorefresh = true
end
end
if dorefresh
drawPage(@page)
end
end
return @index
end
def pbSceneBrief
GameData::Species.play_cry_from_species(@species, @form)
loop do
Graphics.update
Input.update
pbUpdate
if Input.trigger?(Input::ACTION)
pbSEStop
GameData::Species.play_cry_from_species(@species, @form)
elsif Input.trigger?(Input::BACK)
pbPlayCloseMenuSE
break
elsif Input.trigger?(Input::USE)
pbPlayDecisionSE
break
end
end
end
end
#===============================================================================
#
#===============================================================================
class PokemonPokedexInfoScreen
def initialize(scene)
@scene = scene
end
def pbStartScreen(dexlist,index,region)
@scene.pbStartScene(dexlist,index,region)
ret = @scene.pbScene
@scene.pbEndScene
return ret # Index of last species viewed in dexlist
end
def pbStartSceneSingle(species) # For use from a Pokémon's summary screen
region = -1
if Settings::USE_CURRENT_REGION_DEX
region = pbGetCurrentRegion
region = -1 if region >= $Trainer.pokedex.dexes_count - 1
else
region = $PokemonGlobal.pokedexDex # National Dex -1, regional Dexes 0, 1, etc.
end
dexnum = pbGetRegionalNumber(region,species)
dexnumshift = Settings::DEXES_WITH_OFFSETS.include?(region)
dexlist = [[species,GameData::Species.get(species).name,0,0,dexnum,dexnumshift]]
@scene.pbStartScene(dexlist,0,region)
@scene.pbScene
@scene.pbEndScene
end
def pbDexEntry(species) # For use when capturing a new species
@scene.pbStartSceneBrief(species)
@scene.pbSceneBrief
@scene.pbEndScene
end
end

1404
Data/Scripts/016_UI/005_UI_Party.rb Normal file
View File

File diff suppressed because it is too large Load Diff

1384
Data/Scripts/016_UI/006_UI_Summary.rb Normal file
View File

File diff suppressed because it is too large Load Diff

691
Data/Scripts/016_UI/007_UI_Bag.rb Normal file
View File

@@ -0,0 +1,691 @@
#===============================================================================
#
#===============================================================================
class Window_PokemonBag < Window_DrawableCommand
attr_reader :pocket
attr_accessor :sorting
def initialize(bag,filterlist,pocket,x,y,width,height)
@bag = bag
@filterlist = filterlist
@pocket = pocket
@sorting = false
@adapter = PokemonMartAdapter.new
super(x,y,width,height)
@selarrow = AnimatedBitmap.new("Graphics/Pictures/Bag/cursor")
@swaparrow = AnimatedBitmap.new("Graphics/Pictures/Bag/cursor_swap")
self.windowskin = nil
end
def dispose
@swaparrow.dispose
super
end
def pocket=(value)
@pocket = value
@item_max = (@filterlist) ? @filterlist[@pocket].length+1 : @bag.pockets[@pocket].length+1
self.index = @bag.getChoice(@pocket)
end
def page_row_max; return PokemonBag_Scene::ITEMSVISIBLE; end
def page_item_max; return PokemonBag_Scene::ITEMSVISIBLE; end
def item
return nil if @filterlist && !@filterlist[@pocket][self.index]
thispocket = @bag.pockets[@pocket]
item = (@filterlist) ? thispocket[@filterlist[@pocket][self.index]] : thispocket[self.index]
return (item) ? item[0] : nil
end
def itemCount
return (@filterlist) ? @filterlist[@pocket].length+1 : @bag.pockets[@pocket].length+1
end
def itemRect(item)
if item<0 || item>=@item_max || item<self.top_item-1 ||
item>self.top_item+self.page_item_max
return Rect.new(0,0,0,0)
else
cursor_width = (self.width-self.borderX-(@column_max-1)*@column_spacing) / @column_max
x = item % @column_max * (cursor_width + @column_spacing)
y = item / @column_max * @row_height - @virtualOy
return Rect.new(x, y, cursor_width, @row_height)
end
end
def drawCursor(index,rect)
if self.index==index
bmp = (@sorting) ? @swaparrow.bitmap : @selarrow.bitmap
pbCopyBitmap(self.contents,bmp,rect.x,rect.y+2)
end
end
def drawItem(index,_count,rect)
textpos = []
rect = Rect.new(rect.x+16,rect.y+16,rect.width-16,rect.height)
thispocket = @bag.pockets[@pocket]
if index==self.itemCount-1
textpos.push([_INTL("CLOSE BAG"),rect.x,rect.y-2,false,self.baseColor,self.shadowColor])
else
item = (@filterlist) ? thispocket[@filterlist[@pocket][index]][0] : thispocket[index][0]
baseColor = self.baseColor
shadowColor = self.shadowColor
if @sorting && index==self.index
baseColor = Color.new(224,0,0)
shadowColor = Color.new(248,144,144)
end
textpos.push(
[@adapter.getDisplayName(item),rect.x,rect.y-2,false,baseColor,shadowColor]
)
if GameData::Item.get(item).is_important?
if @bag.pbIsRegistered?(item)
pbDrawImagePositions(self.contents,[
["Graphics/Pictures/Bag/icon_register",rect.x+rect.width-72,rect.y+8,0,0,-1,24]
])
elsif pbCanRegisterItem?(item)
pbDrawImagePositions(self.contents,[
["Graphics/Pictures/Bag/icon_register",rect.x+rect.width-72,rect.y+8,0,24,-1,24]
])
end
else
qty = (@filterlist) ? thispocket[@filterlist[@pocket][index]][1] : thispocket[index][1]
qtytext = _ISPRINTF("x{1: 3d}",qty)
xQty = rect.x+rect.width-self.contents.text_size(qtytext).width-16
textpos.push([qtytext,xQty,rect.y-2,false,baseColor,shadowColor])
end
end
pbDrawTextPositions(self.contents,textpos)
end
def refresh
@item_max = itemCount()
self.update_cursor_rect
dwidth = self.width-self.borderX
dheight = self.height-self.borderY
self.contents = pbDoEnsureBitmap(self.contents,dwidth,dheight)
self.contents.clear
for i in 0...@item_max
next if i<self.top_item-1 || i>self.top_item+self.page_item_max
drawItem(i,@item_max,itemRect(i))
end
drawCursor(self.index,itemRect(self.index))
end
def update
super
@uparrow.visible = false
@downarrow.visible = false
end
end
#===============================================================================
# Bag visuals
#===============================================================================
class PokemonBag_Scene
ITEMLISTBASECOLOR = Color.new(88,88,80)
ITEMLISTSHADOWCOLOR = Color.new(168,184,184)
ITEMTEXTBASECOLOR = Color.new(248,248,248)
ITEMTEXTSHADOWCOLOR = Color.new(0,0,0)
POCKETNAMEBASECOLOR = Color.new(88,88,80)
POCKETNAMESHADOWCOLOR = Color.new(168,184,184)
ITEMSVISIBLE = 7
def pbUpdate
pbUpdateSpriteHash(@sprites)
end
def pbStartScene(bag,choosing=false,filterproc=nil,resetpocket=true)
@viewport = Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z = 99999
@bag = bag
@choosing = choosing
@filterproc = filterproc
pbRefreshFilter
lastpocket = @bag.lastpocket
numfilledpockets = @bag.pockets.length-1
if @choosing
numfilledpockets = 0
if @filterlist!=nil
for i in 1...@bag.pockets.length
numfilledpockets += 1 if @filterlist[i].length>0
end
else
for i in 1...@bag.pockets.length
numfilledpockets += 1 if @bag.pockets[i].length>0
end
end
lastpocket = (resetpocket) ? 1 : @bag.lastpocket
if (@filterlist && @filterlist[lastpocket].length==0) ||
(!@filterlist && @bag.pockets[lastpocket].length==0)
for i in 1...@bag.pockets.length
if @filterlist && @filterlist[i].length>0
lastpocket = i; break
elsif !@filterlist && @bag.pockets[i].length>0
lastpocket = i; break
end
end
end
end
@bag.lastpocket = lastpocket
@sliderbitmap = AnimatedBitmap.new(_INTL("Graphics/Pictures/Bag/icon_slider"))
@pocketbitmap = AnimatedBitmap.new(_INTL("Graphics/Pictures/Bag/icon_pocket"))
@sprites = {}
@sprites["background"] = IconSprite.new(0,0,@viewport)
@sprites["overlay"] = BitmapSprite.new(Graphics.width,Graphics.height,@viewport)
pbSetSystemFont(@sprites["overlay"].bitmap)
@sprites["bagsprite"] = IconSprite.new(30,20,@viewport)
@sprites["pocketicon"] = BitmapSprite.new(186,32,@viewport)
@sprites["pocketicon"].x = 0
@sprites["pocketicon"].y = 224
@sprites["leftarrow"] = AnimatedSprite.new("Graphics/Pictures/leftarrow",8,40,28,2,@viewport)
@sprites["leftarrow"].x = -4
@sprites["leftarrow"].y = 76
@sprites["leftarrow"].visible = (!@choosing || numfilledpockets>1)
@sprites["leftarrow"].play
@sprites["rightarrow"] = AnimatedSprite.new("Graphics/Pictures/rightarrow",8,40,28,2,@viewport)
@sprites["rightarrow"].x = 150
@sprites["rightarrow"].y = 76
@sprites["rightarrow"].visible = (!@choosing || numfilledpockets>1)
@sprites["rightarrow"].play
@sprites["itemlist"] = Window_PokemonBag.new(@bag,@filterlist,lastpocket,168,-8,314,40+32+ITEMSVISIBLE*32)
@sprites["itemlist"].viewport = @viewport
@sprites["itemlist"].pocket = lastpocket
@sprites["itemlist"].index = @bag.getChoice(lastpocket)
@sprites["itemlist"].baseColor = ITEMLISTBASECOLOR
@sprites["itemlist"].shadowColor = ITEMLISTSHADOWCOLOR
@sprites["itemicon"] = ItemIconSprite.new(48,Graphics.height-48,nil,@viewport)
@sprites["itemtext"] = Window_UnformattedTextPokemon.newWithSize("",
72, 270, Graphics.width - 72 - 24, 128, @viewport)
@sprites["itemtext"].baseColor = ITEMTEXTBASECOLOR
@sprites["itemtext"].shadowColor = ITEMTEXTSHADOWCOLOR
@sprites["itemtext"].visible = true
@sprites["itemtext"].windowskin = nil
@sprites["helpwindow"] = Window_UnformattedTextPokemon.new("")
@sprites["helpwindow"].visible = false
@sprites["helpwindow"].viewport = @viewport
@sprites["msgwindow"] = Window_AdvancedTextPokemon.new("")
@sprites["msgwindow"].visible = false
@sprites["msgwindow"].viewport = @viewport
pbBottomLeftLines(@sprites["helpwindow"],1)
pbDeactivateWindows(@sprites)
pbRefresh
pbFadeInAndShow(@sprites)
end
def pbFadeOutScene
@oldsprites = pbFadeOutAndHide(@sprites)
end
def pbFadeInScene
pbFadeInAndShow(@sprites,@oldsprites)
@oldsprites = nil
end
def pbEndScene
pbFadeOutAndHide(@sprites) if !@oldsprites
@oldsprites = nil
pbDisposeSpriteHash(@sprites)
@sliderbitmap.dispose
@pocketbitmap.dispose
@viewport.dispose
end
def pbDisplay(msg,brief=false)
UIHelper.pbDisplay(@sprites["msgwindow"],msg,brief) { pbUpdate }
end
def pbConfirm(msg)
UIHelper.pbConfirm(@sprites["msgwindow"],msg) { pbUpdate }
end
def pbChooseNumber(helptext,maximum,initnum=1)
return UIHelper.pbChooseNumber(@sprites["helpwindow"],helptext,maximum,initnum) { pbUpdate }
end
def pbShowCommands(helptext,commands,index=0)
return UIHelper.pbShowCommands(@sprites["helpwindow"],helptext,commands,index) { pbUpdate }
end
def pbRefresh
# Set the background image
@sprites["background"].setBitmap(sprintf("Graphics/Pictures/Bag/bg_#{@bag.lastpocket}"))
# Set the bag sprite
fbagexists = pbResolveBitmap(sprintf("Graphics/Pictures/Bag/bag_#{@bag.lastpocket}_f"))
if $Trainer.female? && fbagexists
@sprites["bagsprite"].setBitmap("Graphics/Pictures/Bag/bag_#{@bag.lastpocket}_f")
else
@sprites["bagsprite"].setBitmap("Graphics/Pictures/Bag/bag_#{@bag.lastpocket}")
end
# Draw the pocket icons
@sprites["pocketicon"].bitmap.clear
if @choosing && @filterlist
for i in 1...@bag.pockets.length
if @filterlist[i].length==0
@sprites["pocketicon"].bitmap.blt(6+(i-1)*22,6,
@pocketbitmap.bitmap,Rect.new((i-1)*20,28,20,20))
end
end
end
@sprites["pocketicon"].bitmap.blt(2+(@sprites["itemlist"].pocket-1)*22,2,
@pocketbitmap.bitmap,Rect.new((@sprites["itemlist"].pocket-1)*28,0,28,28))
# Refresh the item window
@sprites["itemlist"].refresh
# Refresh more things
pbRefreshIndexChanged
end
def pbRefreshIndexChanged
itemlist = @sprites["itemlist"]
overlay = @sprites["overlay"].bitmap
overlay.clear
# Draw the pocket name
pbDrawTextPositions(overlay,[
[PokemonBag.pocketNames[@bag.lastpocket],94,176,2,POCKETNAMEBASECOLOR,POCKETNAMESHADOWCOLOR]
])
# Draw slider arrows
showslider = false
if itemlist.top_row>0
overlay.blt(470,16,@sliderbitmap.bitmap,Rect.new(0,0,36,38))
showslider = true
end
if itemlist.top_item+itemlist.page_item_max<itemlist.itemCount
overlay.blt(470,228,@sliderbitmap.bitmap,Rect.new(0,38,36,38))
showslider = true
end
# Draw slider box
if showslider
sliderheight = 174
boxheight = (sliderheight*itemlist.page_row_max/itemlist.row_max).floor
boxheight += [(sliderheight-boxheight)/2,sliderheight/6].min
boxheight = [boxheight.floor,38].max
y = 54
y += ((sliderheight-boxheight)*itemlist.top_row/(itemlist.row_max-itemlist.page_row_max)).floor
overlay.blt(470,y,@sliderbitmap.bitmap,Rect.new(36,0,36,4))
i = 0
while i*16<boxheight-4-18
height = [boxheight-4-18-i*16,16].min
overlay.blt(470,y+4+i*16,@sliderbitmap.bitmap,Rect.new(36,4,36,height))
i += 1
end
overlay.blt(470,y+boxheight-18,@sliderbitmap.bitmap,Rect.new(36,20,36,18))
end
# Set the selected item's icon
@sprites["itemicon"].item = itemlist.item
# Set the selected item's description
@sprites["itemtext"].text =
(itemlist.item) ? GameData::Item.get(itemlist.item).description : _INTL("Close bag.")
end
def pbRefreshFilter
@filterlist = nil
return if !@choosing
return if @filterproc==nil
@filterlist = []
for i in 1...@bag.pockets.length
@filterlist[i] = []
for j in 0...@bag.pockets[i].length
@filterlist[i].push(j) if @filterproc.call(@bag.pockets[i][j][0])
end
end
end
# Called when the item screen wants an item to be chosen from the screen
def pbChooseItem
@sprites["helpwindow"].visible = false
itemwindow = @sprites["itemlist"]
thispocket = @bag.pockets[itemwindow.pocket]
swapinitialpos = -1
pbActivateWindow(@sprites,"itemlist") {
loop do
oldindex = itemwindow.index
Graphics.update
Input.update
pbUpdate
if itemwindow.sorting && itemwindow.index>=thispocket.length
itemwindow.index = (oldindex==thispocket.length-1) ? 0 : thispocket.length-1
end
if itemwindow.index!=oldindex
# Move the item being switched
if itemwindow.sorting
thispocket.insert(itemwindow.index,thispocket.delete_at(oldindex))
end
# Update selected item for current pocket
@bag.setChoice(itemwindow.pocket,itemwindow.index)
pbRefresh
end
if itemwindow.sorting
if Input.trigger?(Input::ACTION) ||
Input.trigger?(Input::USE)
itemwindow.sorting = false
pbPlayDecisionSE
pbRefresh
elsif Input.trigger?(Input::BACK)
thispocket.insert(swapinitialpos,thispocket.delete_at(itemwindow.index))
itemwindow.index = swapinitialpos
itemwindow.sorting = false
pbPlayCancelSE
pbRefresh
end
else
# Change pockets
if Input.trigger?(Input::LEFT)
newpocket = itemwindow.pocket
loop do
newpocket = (newpocket==1) ? PokemonBag.numPockets : newpocket-1
break if !@choosing || newpocket==itemwindow.pocket
if @filterlist
break if @filterlist[newpocket].length>0
else
break if @bag.pockets[newpocket].length>0
end
end
if itemwindow.pocket!=newpocket
itemwindow.pocket = newpocket
@bag.lastpocket = itemwindow.pocket
thispocket = @bag.pockets[itemwindow.pocket]
pbPlayCursorSE
pbRefresh
end
elsif Input.trigger?(Input::RIGHT)
newpocket = itemwindow.pocket
loop do
newpocket = (newpocket==PokemonBag.numPockets) ? 1 : newpocket+1
break if !@choosing || newpocket==itemwindow.pocket
if @filterlist
break if @filterlist[newpocket].length>0
else
break if @bag.pockets[newpocket].length>0
end
end
if itemwindow.pocket!=newpocket
itemwindow.pocket = newpocket
@bag.lastpocket = itemwindow.pocket
thispocket = @bag.pockets[itemwindow.pocket]
pbPlayCursorSE
pbRefresh
end
# elsif Input.trigger?(Input::SPECIAL) # Register/unregister selected item
# if !@choosing && itemwindow.index<thispocket.length
# if @bag.pbIsRegistered?(itemwindow.item)
# @bag.pbUnregisterItem(itemwindow.item)
# elsif pbCanRegisterItem?(itemwindow.item)
# @bag.pbRegisterItem(itemwindow.item)
# end
# pbPlayDecisionSE
# pbRefresh
# end
elsif Input.trigger?(Input::ACTION) # Start switching the selected item
if !@choosing
if thispocket.length>1 && itemwindow.index<thispocket.length &&
!Settings::BAG_POCKET_AUTO_SORT[itemwindow.pocket]
itemwindow.sorting = true
swapinitialpos = itemwindow.index
pbPlayDecisionSE
pbRefresh
end
end
elsif Input.trigger?(Input::BACK) # Cancel the item screen
pbPlayCloseMenuSE
return nil
elsif Input.trigger?(Input::USE) # Choose selected item
(itemwindow.item) ? pbPlayDecisionSE : pbPlayCloseMenuSE
return itemwindow.item
end
end
end
}
end
end
#===============================================================================
# Bag mechanics
#===============================================================================
class PokemonBagScreen
def initialize(scene,bag)
@bag = bag
@scene = scene
end
def pbStartScreen
@scene.pbStartScene(@bag)
item = nil
loop do
item = @scene.pbChooseItem
break if !item
itm = GameData::Item.get(item)
cmdRead = -1
cmdUse = -1
cmdRegister = -1
cmdGive = -1
cmdToss = -1
cmdDebug = -1
commands = []
# Generate command list
commands[cmdRead = commands.length] = _INTL("Read") if itm.is_mail?
if ItemHandlers.hasOutHandler(item) || (itm.is_machine? && $Trainer.party.length>0)
if ItemHandlers.hasUseText(item)
commands[cmdUse = commands.length] = ItemHandlers.getUseText(item)
else
commands[cmdUse = commands.length] = _INTL("Use")
end
end
commands[cmdGive = commands.length] = _INTL("Give") if $Trainer.pokemon_party.length > 0 && itm.can_hold?
commands[cmdToss = commands.length] = _INTL("Toss") if !itm.is_important? || $DEBUG
if @bag.pbIsRegistered?(item)
commands[cmdRegister = commands.length] = _INTL("Deselect")
elsif pbCanRegisterItem?(item)
commands[cmdRegister = commands.length] = _INTL("Register")
end
commands[cmdDebug = commands.length] = _INTL("Debug") if $DEBUG
commands[commands.length] = _INTL("Cancel")
# Show commands generated above
itemname = itm.name
command = @scene.pbShowCommands(_INTL("{1} is selected.",itemname),commands)
if cmdRead>=0 && command==cmdRead # Read mail
pbFadeOutIn {
pbDisplayMail(Mail.new(item, "", ""))
}
elsif cmdUse>=0 && command==cmdUse # Use item
ret = pbUseItem(@bag,item,@scene)
# ret: 0=Item wasn't used; 1=Item used; 2=Close Bag to use in field
break if ret==2 # End screen
@scene.pbRefresh
next
elsif cmdGive>=0 && command==cmdGive # Give item to Pokémon
if $Trainer.pokemon_count == 0
@scene.pbDisplay(_INTL("There is no Pokémon."))
elsif itm.is_important?
@scene.pbDisplay(_INTL("The {1} can't be held.",itemname))
else
pbFadeOutIn {
sscene = PokemonParty_Scene.new
sscreen = PokemonPartyScreen.new(sscene,$Trainer.party)
sscreen.pbPokemonGiveScreen(item)
@scene.pbRefresh
}
end
elsif cmdToss>=0 && command==cmdToss # Toss item
qty = @bag.pbQuantity(item)
if qty>1
helptext = _INTL("Toss out how many {1}?",itm.name_plural)
qty = @scene.pbChooseNumber(helptext,qty)
end
if qty>0
itemname = itm.name_plural if qty>1
if pbConfirm(_INTL("Is it OK to throw away {1} {2}?",qty,itemname))
pbDisplay(_INTL("Threw away {1} {2}.",qty,itemname))
qty.times { @bag.pbDeleteItem(item) }
@scene.pbRefresh
end
end
elsif cmdRegister>=0 && command==cmdRegister # Register item
if @bag.pbIsRegistered?(item)
@bag.pbUnregisterItem(item)
else
@bag.pbRegisterItem(item)
end
@scene.pbRefresh
elsif cmdDebug>=0 && command==cmdDebug # Debug
command = 0
loop do
command = @scene.pbShowCommands(_INTL("Do what with {1}?",itemname),[
_INTL("Change quantity"),
_INTL("Make Mystery Gift"),
_INTL("Cancel")
],command)
case command
### Cancel ###
when -1, 2
break
### Change quantity ###
when 0
qty = @bag.pbQuantity(item)
itemplural = itm.name_plural
params = ChooseNumberParams.new
params.setRange(0, Settings::BAG_MAX_PER_SLOT)
params.setDefaultValue(qty)
newqty = pbMessageChooseNumber(
_INTL("Choose new quantity of {1} (max. #{Settings::BAG_MAX_PER_SLOT}).",itemplural),params) { @scene.pbUpdate }
if newqty>qty
@bag.pbStoreItem(item,newqty-qty)
elsif newqty<qty
@bag.pbDeleteItem(item,qty-newqty)
end
@scene.pbRefresh
break if newqty==0
### Make Mystery Gift ###
when 1
pbCreateMysteryGift(1,item)
end
end
end
end
@scene.pbEndScene
return item
end
def pbDisplay(text)
@scene.pbDisplay(text)
end
def pbConfirm(text)
return @scene.pbConfirm(text)
end
# UI logic for the item screen for choosing an item.
def pbChooseItemScreen(proc=nil)
oldlastpocket = @bag.lastpocket
oldchoices = @bag.getAllChoices
@scene.pbStartScene(@bag,true,proc)
item = @scene.pbChooseItem
@scene.pbEndScene
@bag.lastpocket = oldlastpocket
@bag.setAllChoices(oldchoices)
return item
end
# UI logic for withdrawing an item in the item storage screen.
def pbWithdrawItemScreen
if !$PokemonGlobal.pcItemStorage
$PokemonGlobal.pcItemStorage = PCItemStorage.new
end
storage = $PokemonGlobal.pcItemStorage
@scene.pbStartScene(storage)
loop do
item = @scene.pbChooseItem
break if !item
itm = GameData::Item.get(item)
qty = storage.pbQuantity(item)
if qty>1 && !itm.is_important?
qty = @scene.pbChooseNumber(_INTL("How many do you want to withdraw?"),qty)
end
next if qty<=0
if @bag.pbCanStore?(item,qty)
if !storage.pbDeleteItem(item,qty)
raise "Can't delete items from storage"
end
if !@bag.pbStoreItem(item,qty)
raise "Can't withdraw items from storage"
end
@scene.pbRefresh
dispqty = (itm.is_important?) ? 1 : qty
itemname = (dispqty>1) ? itm.name_plural : itm.name
pbDisplay(_INTL("Withdrew {1} {2}.",dispqty,itemname))
else
pbDisplay(_INTL("There's no more room in the Bag."))
end
end
@scene.pbEndScene
end
# UI logic for depositing an item in the item storage screen.
def pbDepositItemScreen
@scene.pbStartScene(@bag)
if !$PokemonGlobal.pcItemStorage
$PokemonGlobal.pcItemStorage = PCItemStorage.new
end
storage = $PokemonGlobal.pcItemStorage
loop do
item = @scene.pbChooseItem
break if !item
itm = GameData::Item.get(item)
qty = @bag.pbQuantity(item)
if qty>1 && !itm.is_important?
qty = @scene.pbChooseNumber(_INTL("How many do you want to deposit?"),qty)
end
if qty>0
if !storage.pbCanStore?(item,qty)
pbDisplay(_INTL("There's no room to store items."))
else
if !@bag.pbDeleteItem(item,qty)
raise "Can't delete items from Bag"
end
if !storage.pbStoreItem(item,qty)
raise "Can't deposit items to storage"
end
@scene.pbRefresh
dispqty = (itm.is_important?) ? 1 : qty
itemname = (dispqty>1) ? itm.name_plural : itm.name
pbDisplay(_INTL("Deposited {1} {2}.",dispqty,itemname))
end
end
end
@scene.pbEndScene
end
# UI logic for tossing an item in the item storage screen.
def pbTossItemScreen
if !$PokemonGlobal.pcItemStorage
$PokemonGlobal.pcItemStorage = PCItemStorage.new
end
storage = $PokemonGlobal.pcItemStorage
@scene.pbStartScene(storage)
loop do
item = @scene.pbChooseItem
break if !item
itm = GameData::Item.get(item)
if itm.is_important?
@scene.pbDisplay(_INTL("That's too important to toss out!"))
next
end
qty = storage.pbQuantity(item)
itemname = itm.name
itemnameplural = itm.name_plural
if qty>1
qty=@scene.pbChooseNumber(_INTL("Toss out how many {1}?",itemnameplural),qty)
end
if qty>0
itemname = itemnameplural if qty>1
if pbConfirm(_INTL("Is it OK to throw away {1} {2}?",qty,itemname))
if !storage.pbDeleteItem(item,qty)
raise "Can't delete items from storage"
end
@scene.pbRefresh
pbDisplay(_INTL("Threw away {1} {2}.",qty,itemname))
end
end
end
@scene.pbEndScene
end
end

157
Data/Scripts/016_UI/008_UI_Pokegear.rb Normal file
View File

@@ -0,0 +1,157 @@
#===============================================================================
#
#===============================================================================
class PokegearButton < SpriteWrapper
attr_reader :index
attr_reader :name
attr_reader :selected
def initialize(command,x,y,viewport=nil)
super(viewport)
@image = command[0]
@name = command[1]
@selected = false
if $Trainer.female? && pbResolveBitmap(sprintf("Graphics/Pictures/Pokegear/icon_button_f"))
@button = AnimatedBitmap.new("Graphics/Pictures/Pokegear/icon_button_f")
else
@button = AnimatedBitmap.new("Graphics/Pictures/Pokegear/icon_button")
end
@contents = BitmapWrapper.new(@button.width,@button.height)
self.bitmap = @contents
self.x = x
self.y = y
pbSetSystemFont(self.bitmap)
refresh
end
def dispose
@button.dispose
@contents.dispose
super
end
def selected=(val)
oldsel = @selected
@selected = val
refresh if oldsel!=val
end
def refresh
self.bitmap.clear
rect = Rect.new(0,0,@button.width,@button.height/2)
rect.y = @button.height/2 if @selected
self.bitmap.blt(0,0,@button.bitmap,rect)
textpos = [
[@name,self.bitmap.width/2,4,2,Color.new(248,248,248),Color.new(40,40,40)],
]
pbDrawTextPositions(self.bitmap,textpos)
imagepos = [
[sprintf("Graphics/Pictures/Pokegear/icon_"+@image),18,10]
]
pbDrawImagePositions(self.bitmap,imagepos)
end
end
#===============================================================================
#
#===============================================================================
class PokemonPokegear_Scene
def pbUpdate
for i in 0...@commands.length
@sprites["button#{i}"].selected = (i==@index)
end
pbUpdateSpriteHash(@sprites)
end
def pbStartScene(commands)
@commands = commands
@index = 0
@viewport = Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z = 99999
@sprites = {}
@sprites["background"] = IconSprite.new(0,0,@viewport)
if $Trainer.female? && pbResolveBitmap(sprintf("Graphics/Pictures/Pokegear/bg_f"))
@sprites["background"].setBitmap("Graphics/Pictures/Pokegear/bg_f")
else
@sprites["background"].setBitmap("Graphics/Pictures/Pokegear/bg")
end
for i in 0...@commands.length
y = 196 - (@commands.length*24) + (i*48)
@sprites["button#{i}"] = PokegearButton.new(@commands[i],118,y,@viewport)
end
pbFadeInAndShow(@sprites) { pbUpdate }
end
def pbScene
ret = -1
loop do
Graphics.update
Input.update
pbUpdate
if Input.trigger?(Input::BACK)
pbPlayCloseMenuSE
break
elsif Input.trigger?(Input::USE)
pbPlayDecisionSE
ret = @index
break
elsif Input.trigger?(Input::UP)
pbPlayCursorSE if @commands.length>1
@index -= 1
@index = @commands.length-1 if @index<0
elsif Input.trigger?(Input::DOWN)
pbPlayCursorSE if @commands.length>1
@index += 1
@index = 0 if @index>=@commands.length
end
end
return ret
end
def pbEndScene
pbFadeOutAndHide(@sprites) { pbUpdate }
pbDisposeSpriteHash(@sprites)
@viewport.dispose
end
end
#===============================================================================
#
#===============================================================================
class PokemonPokegearScreen
def initialize(scene)
@scene = scene
end
def pbStartScreen
commands = []
cmdMap = -1
cmdPhone = -1
cmdJukebox = -1
commands[cmdMap = commands.length] = ["map",_INTL("Map")]
if $PokemonGlobal.phoneNumbers && $PokemonGlobal.phoneNumbers.length>0
commands[cmdPhone = commands.length] = ["phone",_INTL("Phone")]
end
commands[cmdJukebox = commands.length] = ["jukebox",_INTL("Jukebox")]
@scene.pbStartScene(commands)
loop do
cmd = @scene.pbScene
if cmd<0
break
elsif cmdMap>=0 && cmd==cmdMap
pbShowMap(-1,false)
elsif cmdPhone>=0 && cmd==cmdPhone
pbFadeOutIn {
PokemonPhoneScene.new.start
}
elsif cmdJukebox>=0 && cmd==cmdJukebox
pbFadeOutIn {
scene = PokemonJukebox_Scene.new
screen = PokemonJukeboxScreen.new(scene)
screen.pbStartScreen
}
end
end
@scene.pbEndScene
end
end

376
Data/Scripts/016_UI/009_UI_RegionMap.rb Normal file
View File

@@ -0,0 +1,376 @@
#===============================================================================
#
#===============================================================================
class MapBottomSprite < SpriteWrapper
attr_reader :mapname
attr_reader :maplocation
def initialize(viewport=nil)
super(viewport)
@mapname = ""
@maplocation = ""
@mapdetails = ""
@thisbitmap = BitmapWrapper.new(Graphics.width,Graphics.height)
pbSetSystemFont(@thisbitmap)
self.x = 0
self.y = 0
self.bitmap = @thisbitmap
refresh
end
def dispose
@thisbitmap.dispose
super
end
def mapname=(value)
if @mapname!=value
@mapname = value
refresh
end
end
def maplocation=(value)
if @maplocation!=value
@maplocation = value
refresh
end
end
def mapdetails=(value) # From Wichu
if @mapdetails!=value
@mapdetails = value
refresh
end
end
def refresh
self.bitmap.clear
textpos = [
[@mapname,18,-8,0,Color.new(248,248,248),Color.new(0,0,0)],
[@maplocation,18,348,0,Color.new(248,248,248),Color.new(0,0,0)],
[@mapdetails,Graphics.width-16,348,1,Color.new(248,248,248),Color.new(0,0,0)]
]
pbDrawTextPositions(self.bitmap,textpos)
end
end
#===============================================================================
#
#===============================================================================
class PokemonRegionMap_Scene
LEFT = 0
TOP = 0
RIGHT = 29
BOTTOM = 19
SQUAREWIDTH = 16
SQUAREHEIGHT = 16
def initialize(region=-1,wallmap=true)
@region = region
@wallmap = wallmap
end
def pbUpdate
pbUpdateSpriteHash(@sprites)
end
def pbStartScene(aseditor=false,mode=0)
@editor = aseditor
@viewport = Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z = 99999
@sprites = {}
@mapdata = pbLoadTownMapData
map_metadata = GameData::MapMetadata.try_get($game_map.map_id)
playerpos = (map_metadata) ? map_metadata.town_map_position : nil
if !playerpos
mapindex = 0
@map = @mapdata[0]
@mapX = LEFT
@mapY = TOP
elsif @region>=0 && @region!=playerpos[0] && @mapdata[@region]
mapindex = @region
@map = @mapdata[@region]
@mapX = LEFT
@mapY = TOP
else
mapindex = playerpos[0]
@map = @mapdata[playerpos[0]]
@mapX = playerpos[1]
@mapY = playerpos[2]
mapsize = map_metadata.town_map_size
if mapsize && mapsize[0] && mapsize[0]>0
sqwidth = mapsize[0]
sqheight = (mapsize[1].length*1.0/mapsize[0]).ceil
if sqwidth>1
@mapX += ($game_player.x*sqwidth/$game_map.width).floor
end
if sqheight>1
@mapY += ($game_player.y*sqheight/$game_map.height).floor
end
end
end
if !@map
pbMessage(_INTL("The map data cannot be found."))
return false
end
addBackgroundOrColoredPlane(@sprites,"background","mapbg",Color.new(0,0,0),@viewport)
@sprites["map"] = IconSprite.new(0,0,@viewport)
@sprites["map"].setBitmap("Graphics/Pictures/#{@map[1]}")
@sprites["map"].x += (Graphics.width-@sprites["map"].bitmap.width)/2
@sprites["map"].y += (Graphics.height-@sprites["map"].bitmap.height)/2
for hidden in Settings::REGION_MAP_EXTRAS
if hidden[0]==mapindex && ((@wallmap && hidden[5]) ||
(!@wallmap && hidden[1]>0 && $game_switches[hidden[1]]))
if !@sprites["map2"]
@sprites["map2"] = BitmapSprite.new(480,320,@viewport)
@sprites["map2"].x = @sprites["map"].x
@sprites["map2"].y = @sprites["map"].y
end
pbDrawImagePositions(@sprites["map2"].bitmap,[
["Graphics/Pictures/#{hidden[4]}",hidden[2]*SQUAREWIDTH,hidden[3]*SQUAREHEIGHT]
])
end
end
@sprites["mapbottom"] = MapBottomSprite.new(@viewport)
@sprites["mapbottom"].mapname = pbGetMessage(MessageTypes::RegionNames,mapindex)
@sprites["mapbottom"].maplocation = pbGetMapLocation(@mapX,@mapY)
@sprites["mapbottom"].mapdetails = pbGetMapDetails(@mapX,@mapY)
if playerpos && mapindex==playerpos[0]
@sprites["player"] = IconSprite.new(0,0,@viewport)
@sprites["player"].setBitmap(GameData::TrainerType.player_map_icon_filename($Trainer.trainer_type))
@sprites["player"].x = -SQUAREWIDTH/2+(@mapX*SQUAREWIDTH)+(Graphics.width-@sprites["map"].bitmap.width)/2
@sprites["player"].y = -SQUAREHEIGHT/2+(@mapY*SQUAREHEIGHT)+(Graphics.height-@sprites["map"].bitmap.height)/2
end
if mode>0
k = 0
for i in LEFT..RIGHT
for j in TOP..BOTTOM
healspot = pbGetHealingSpot(i,j)
if healspot && $PokemonGlobal.visitedMaps[healspot[0]]
@sprites["point#{k}"] = AnimatedSprite.create("Graphics/Pictures/mapFly",2,16)
@sprites["point#{k}"].viewport = @viewport
@sprites["point#{k}"].x = -SQUAREWIDTH/2+(i*SQUAREWIDTH)+(Graphics.width-@sprites["map"].bitmap.width)/2
@sprites["point#{k}"].y = -SQUAREHEIGHT/2+(j*SQUAREHEIGHT)+(Graphics.height-@sprites["map"].bitmap.height)/2
@sprites["point#{k}"].play
k += 1
end
end
end
end
@sprites["cursor"] = AnimatedSprite.create("Graphics/Pictures/mapCursor",2,5)
@sprites["cursor"].viewport = @viewport
@sprites["cursor"].x = -SQUAREWIDTH/2+(@mapX*SQUAREWIDTH)+(Graphics.width-@sprites["map"].bitmap.width)/2
@sprites["cursor"].y = -SQUAREHEIGHT/2+(@mapY*SQUAREHEIGHT)+(Graphics.height-@sprites["map"].bitmap.height)/2
@sprites["cursor"].play
@changed = false
pbFadeInAndShow(@sprites) { pbUpdate }
return true
end
# TODO: Why is this PBS file writer here?
def pbSaveMapData
File.open("PBS/townmap.txt","wb") { |f|
Compiler.add_PBS_header_to_file(f)
for i in 0...@mapdata.length
map = @mapdata[i]
next if !map
f.write("\#-------------------------------\r\n")
f.write(sprintf("[%d]\r\n",i))
f.write(sprintf("Name = %s\r\nFilename = %s\r\n",
Compiler.csvQuote(map[0]), Compiler.csvQuote(map[1])))
for loc in map[2]
f.write("Point = ")
Compiler.pbWriteCsvRecord(loc,f,[nil,"uussUUUU"])
f.write("\r\n")
end
end
}
end
def pbEndScene
pbFadeOutAndHide(@sprites)
pbDisposeSpriteHash(@sprites)
@viewport.dispose
end
def pbGetMapLocation(x,y)
return "" if !@map[2]
for loc in @map[2]
if loc[0]==x && loc[1]==y
if !loc[7] || (!@wallmap && $game_switches[loc[7]])
maploc = pbGetMessageFromHash(MessageTypes::PlaceNames,loc[2])
return @editor ? loc[2] : maploc
else
return ""
end
end
end
return ""
end
def pbChangeMapLocation(x,y)
return if !@editor
return "" if !@map[2]
currentname = ""
currentobj = nil
for loc in @map[2]
if loc[0]==x && loc[1]==y
currentobj = loc
currentname = loc[2]
break
end
end
currentname = pbMessageFreeText(_INTL("Set the name for this point."),currentname,false,250) { pbUpdate }
if currentname
if currentobj
currentobj[2] = currentname
else
newobj = [x,y,currentname,""]
@map[2].push(newobj)
end
@changed = true
end
end
def pbGetMapDetails(x,y) # From Wichu, with my help
return "" if !@map[2]
for loc in @map[2]
if loc[0]==x && loc[1]==y
if !loc[7] || (!@wallmap && $game_switches[loc[7]])
mapdesc = pbGetMessageFromHash(MessageTypes::PlaceDescriptions,loc[3])
return (@editor) ? loc[3] : mapdesc
else
return ""
end
end
end
return ""
end
def pbGetHealingSpot(x,y)
return nil if !@map[2]
for loc in @map[2]
if loc[0]==x && loc[1]==y
if !loc[4] || !loc[5] || !loc[6]
return nil
else
return [loc[4],loc[5],loc[6]]
end
end
end
return nil
end
def pbMapScene(mode=0)
xOffset = 0
yOffset = 0
newX = 0
newY = 0
@sprites["cursor"].x = -SQUAREWIDTH/2+(@mapX*SQUAREWIDTH)+(Graphics.width-@sprites["map"].bitmap.width)/2
@sprites["cursor"].y = -SQUAREHEIGHT/2+(@mapY*SQUAREHEIGHT)+(Graphics.height-@sprites["map"].bitmap.height)/2
loop do
Graphics.update
Input.update
pbUpdate
if xOffset!=0 || yOffset!=0
distancePerFrame = 8*20/Graphics.frame_rate
xOffset += (xOffset>0) ? -distancePerFrame : (xOffset<0) ? distancePerFrame : 0
yOffset += (yOffset>0) ? -distancePerFrame : (yOffset<0) ? distancePerFrame : 0
@sprites["cursor"].x = newX-xOffset
@sprites["cursor"].y = newY-yOffset
next
end
@sprites["mapbottom"].maplocation = pbGetMapLocation(@mapX,@mapY)
@sprites["mapbottom"].mapdetails = pbGetMapDetails(@mapX,@mapY)
ox = 0
oy = 0
case Input.dir8
when 1 # lower left
oy = 1 if @mapY<BOTTOM
ox = -1 if @mapX>LEFT
when 2 # down
oy = 1 if @mapY<BOTTOM
when 3 # lower right
oy = 1 if @mapY<BOTTOM
ox = 1 if @mapX<RIGHT
when 4 # left
ox = -1 if @mapX>LEFT
when 6 # right
ox = 1 if @mapX<RIGHT
when 7 # upper left
oy = -1 if @mapY>TOP
ox = -1 if @mapX>LEFT
when 8 # up
oy = -1 if @mapY>TOP
when 9 # upper right
oy = -1 if @mapY>TOP
ox = 1 if @mapX<RIGHT
end
if ox!=0 || oy!=0
@mapX += ox
@mapY += oy
xOffset = ox*SQUAREWIDTH
yOffset = oy*SQUAREHEIGHT
newX = @sprites["cursor"].x+xOffset
newY = @sprites["cursor"].y+yOffset
end
if Input.trigger?(Input::BACK)
if @editor && @changed
if pbConfirmMessage(_INTL("Save changes?")) { pbUpdate }
pbSaveMapData
end
if pbConfirmMessage(_INTL("Exit from the map?")) { pbUpdate }
break
end
else
break
end
elsif Input.trigger?(Input::USE) && mode==1 # Choosing an area to fly to
healspot = pbGetHealingSpot(@mapX,@mapY)
if healspot
if $PokemonGlobal.visitedMaps[healspot[0]] || ($DEBUG && Input.press?(Input::CTRL))
return healspot
end
end
elsif Input.trigger?(Input::USE) && @editor # Intentionally after other USE input check
pbChangeMapLocation(@mapX,@mapY)
end
end
pbPlayCloseMenuSE
return nil
end
end
#===============================================================================
#
#===============================================================================
class PokemonRegionMapScreen
def initialize(scene)
@scene = scene
end
def pbStartFlyScreen
@scene.pbStartScene(false,1)
ret = @scene.pbMapScene(1)
@scene.pbEndScene
return ret
end
def pbStartScreen
@scene.pbStartScene($DEBUG)
@scene.pbMapScene
@scene.pbEndScene
end
end
#===============================================================================
#
#===============================================================================
def pbShowMap(region=-1,wallmap=true)
pbFadeOutIn {
scene = PokemonRegionMap_Scene.new(region,wallmap)
screen = PokemonRegionMapScreen.new(scene)
screen.pbStartScreen
}
end

149
Data/Scripts/016_UI/010_UI_Phone.rb Normal file
View File

@@ -0,0 +1,149 @@
#===============================================================================
# Phone screen
#===============================================================================
class Window_PhoneList < Window_CommandPokemon
def drawCursor(index,rect)
selarrow = AnimatedBitmap.new("Graphics/Pictures/phoneSel")
if self.index==index
pbCopyBitmap(self.contents,selarrow.bitmap,rect.x,rect.y)
end
return Rect.new(rect.x+28,rect.y+8,rect.width-16,rect.height)
end
def drawItem(index,count,rect)
return if index>=self.top_row+self.page_item_max
super
drawCursor(index-1,itemRect(index-1))
end
end
#===============================================================================
#
#===============================================================================
class PokemonPhoneScene
def start
commands = []
@trainers = []
if $PokemonGlobal.phoneNumbers
for num in $PokemonGlobal.phoneNumbers
if num[0] # if visible
if num.length==8 # if trainer
@trainers.push([num[1],num[2],num[6],(num[4]>=2)])
else # if NPC
@trainers.push([num[1],num[2],num[3]])
end
end
end
end
if @trainers.length==0
pbMessage(_INTL("There are no phone numbers stored."))
return
end
@sprites = {}
@viewport = Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z = 99999
@sprites["list"] = Window_PhoneList.newEmpty(152,32,Graphics.width-142,Graphics.height-80,@viewport)
@sprites["header"] = Window_UnformattedTextPokemon.newWithSize(_INTL("Phone"),
2,-18,128,64,@viewport)
@sprites["header"].baseColor = Color.new(248,248,248)
@sprites["header"].shadowColor = Color.new(0,0,0)
mapname = (@trainers[0][2]) ? pbGetMessage(MessageTypes::MapNames,@trainers[0][2]) : ""
@sprites["bottom"] = Window_AdvancedTextPokemon.newWithSize("",
162,Graphics.height-64,Graphics.width-158,64,@viewport)
@sprites["bottom"].text = "<ac>"+mapname
@sprites["info"] = Window_AdvancedTextPokemon.newWithSize("",-8,224,180,160,@viewport)
addBackgroundPlane(@sprites,"bg","phonebg",@viewport)
@sprites["icon"] = IconSprite.new(70,102,@viewport)
if @trainers[0].length==4
filename = GameData::TrainerType.charset_filename(@trainers[0][0])
else
filename = sprintf("Graphics/Characters/phone%03d",@trainers[0][0])
end
@sprites["icon"].setBitmap(filename)
charwidth = @sprites["icon"].bitmap.width
charheight = @sprites["icon"].bitmap.height
@sprites["icon"].x = 86-charwidth/8
@sprites["icon"].y = 134-charheight/8
@sprites["icon"].src_rect = Rect.new(0,0,charwidth/4,charheight/4)
for trainer in @trainers
if trainer.length==4
displayname = _INTL("{1} {2}", GameData::TrainerType.get(trainer[0]).name,
pbGetMessageFromHash(MessageTypes::TrainerNames,trainer[1])
)
commands.push(displayname) # trainer's display name
else
commands.push(trainer[1]) # NPC's display name
end
end
@sprites["list"].commands = commands
for i in 0...@sprites["list"].page_item_max
@sprites["rematch[#{i}]"] = IconSprite.new(468,62+i*32,@viewport)
j = i+@sprites["list"].top_item
next if j>=commands.length
trainer = @trainers[j]
if trainer.length==4
if trainer[3]
@sprites["rematch[#{i}]"].setBitmap("Graphics/Pictures/phoneRematch")
end
end
end
rematchcount = 0
for trainer in @trainers
if trainer.length==4
rematchcount += 1 if trainer[3]
end
end
infotext = _INTL("Registered<br>")
infotext += _INTL(" <r>{1}<br>",@sprites["list"].commands.length)
infotext += _INTL("Waiting for a rematch<r>{1}",rematchcount)
@sprites["info"].text = infotext
pbFadeInAndShow(@sprites)
pbActivateWindow(@sprites,"list") {
oldindex = -1
loop do
Graphics.update
Input.update
pbUpdateSpriteHash(@sprites)
if @sprites["list"].index!=oldindex
trainer = @trainers[@sprites["list"].index]
if trainer.length==4
filename = GameData::TrainerType.charset_filename(trainer[0])
else
filename = sprintf("Graphics/Characters/phone%03d",trainer[0])
end
@sprites["icon"].setBitmap(filename)
charwidth = @sprites["icon"].bitmap.width
charheight = @sprites["icon"].bitmap.height
@sprites["icon"].x = 86-charwidth/8
@sprites["icon"].y = 134-charheight/8
@sprites["icon"].src_rect = Rect.new(0,0,charwidth/4,charheight/4)
mapname=(trainer[2]) ? pbGetMessage(MessageTypes::MapNames,trainer[2]) : ""
@sprites["bottom"].text = "<ac>"+mapname
for i in 0...@sprites["list"].page_item_max
@sprites["rematch[#{i}]"].clearBitmaps
j = i+@sprites["list"].top_item
next if j>=commands.length
trainer = @trainers[j]
if trainer.length==4
if trainer[3]
@sprites["rematch[#{i}]"].setBitmap("Graphics/Pictures/phoneRematch")
end
end
end
end
if Input.trigger?(Input::BACK)
pbPlayCloseMenuSE
break
elsif Input.trigger?(Input::USE)
index = @sprites["list"].index
if index>=0
pbCallTrainer(@trainers[index][0],@trainers[index][1])
end
end
end
}
pbFadeOutAndHide(@sprites)
pbDisposeSpriteHash(@sprites)
@viewport.dispose
end
end

136
Data/Scripts/016_UI/011_UI_Jukebox.rb Normal file
View File

@@ -0,0 +1,136 @@
#===============================================================================
#
#===============================================================================
class PokemonJukebox_Scene
def pbUpdate
pbUpdateSpriteHash(@sprites)
end
def pbStartScene(commands)
@commands = commands
@viewport = Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z = 99999
@sprites = {}
@sprites["background"] = IconSprite.new(0,0,@viewport)
@sprites["background"].setBitmap("Graphics/Pictures/jukeboxbg")
@sprites["header"] = Window_UnformattedTextPokemon.newWithSize(
_INTL("Jukebox"),2,-18,128,64,@viewport)
@sprites["header"].baseColor = Color.new(248,248,248)
@sprites["header"].shadowColor = Color.new(0,0,0)
@sprites["header"].windowskin = nil
@sprites["commands"] = Window_CommandPokemon.newWithSize(@commands,
94,92,324,224,@viewport)
@sprites["commands"].windowskin = nil
pbFadeInAndShow(@sprites) { pbUpdate }
end
def pbScene
ret = -1
loop do
Graphics.update
Input.update
pbUpdate
if Input.trigger?(Input::BACK)
break
elsif Input.trigger?(Input::USE)
ret = @sprites["commands"].index
break
end
end
return ret
end
def pbSetCommands(newcommands,newindex)
@sprites["commands"].commands = (!newcommands) ? @commands : newcommands
@sprites["commands"].index = newindex
end
def pbEndScene
pbFadeOutAndHide(@sprites) { pbUpdate }
pbDisposeSpriteHash(@sprites)
@viewport.dispose
end
end
#===============================================================================
#
#===============================================================================
class PokemonJukeboxScreen
def initialize(scene)
@scene = scene
end
def pbStartScreen
commands = []
cmdMarch = -1
cmdLullaby = -1
cmdOak = -1
cmdCustom = -1
commands[cmdMarch = commands.length] = _INTL("March")
commands[cmdLullaby = commands.length] = _INTL("Lullaby")
commands[cmdOak = commands.length] = _INTL("Oak")
commands[cmdCustom = commands.length] = _INTL("Custom")
commands[commands.length] = _INTL("Exit")
@scene.pbStartScene(commands)
loop do
cmd = @scene.pbScene
if cmd<0
pbPlayCloseMenuSE
break
elsif cmdMarch>=0 && cmd==cmdMarch
pbPlayDecisionSE
pbBGMPlay("Radio - March", 100, 100)
$PokemonMap.whiteFluteUsed = true if $PokemonMap
$PokemonMap.blackFluteUsed = false if $PokemonMap
elsif cmdLullaby>=0 && cmd==cmdLullaby
pbPlayDecisionSE
pbBGMPlay("Radio - Lullaby", 100, 100)
$PokemonMap.blackFluteUsed = true if $PokemonMap
$PokemonMap.whiteFluteUsed = false if $PokemonMap
elsif cmdOak>=0 && cmd==cmdOak
pbPlayDecisionSE
pbBGMPlay("Radio - Oak", 100, 100)
$PokemonMap.whiteFluteUsed = false if $PokemonMap
$PokemonMap.blackFluteUsed = false if $PokemonMap
elsif cmdCustom>=0 && cmd==cmdCustom
pbPlayDecisionSE
files = [_INTL("(Default)")]
Dir.chdir("Audio/BGM/") {
Dir.glob("*.mp3") { |f| files.push(f) }
Dir.glob("*.MP3") { |f| files.push(f) }
Dir.glob("*.ogg") { |f| files.push(f) }
Dir.glob("*.OGG") { |f| files.push(f) }
Dir.glob("*.wav") { |f| files.push(f) }
Dir.glob("*.WAV") { |f| files.push(f) }
Dir.glob("*.mid") { |f| files.push(f) }
Dir.glob("*.MID") { |f| files.push(f) }
Dir.glob("*.midi") { |f| files.push(f) }
Dir.glob("*.MIDI") { |f| files.push(f) }
}
@scene.pbSetCommands(files,0)
loop do
cmd2 = @scene.pbScene
if cmd2<0
pbPlayCancelSE
break
elsif cmd2==0
pbPlayDecisionSE
$game_system.setDefaultBGM(nil)
$PokemonMap.whiteFluteUsed = false if $PokemonMap
$PokemonMap.blackFluteUsed = false if $PokemonMap
else
pbPlayDecisionSE
$game_system.setDefaultBGM(files[cmd2])
$PokemonMap.whiteFluteUsed = false if $PokemonMap
$PokemonMap.blackFluteUsed = false if $PokemonMap
end
end
@scene.pbSetCommands(nil,cmdCustom)
else # Exit
pbPlayCloseMenuSE
break
end
end
@scene.pbEndScene
end
end

111
Data/Scripts/016_UI/012_UI_TrainerCard.rb Normal file
View File

@@ -0,0 +1,111 @@
#===============================================================================
#
#===============================================================================
class PokemonTrainerCard_Scene
def pbUpdate
pbUpdateSpriteHash(@sprites)
end
def pbStartScene
@viewport = Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z = 99999
@sprites = {}
background = pbResolveBitmap(sprintf("Graphics/Pictures/Trainer Card/bg_f"))
if $Trainer.female? && background
addBackgroundPlane(@sprites,"bg","Trainer Card/bg_f",@viewport)
else
addBackgroundPlane(@sprites,"bg","Trainer Card/bg",@viewport)
end
cardexists = pbResolveBitmap(sprintf("Graphics/Pictures/Trainer Card/card_f"))
@sprites["card"] = IconSprite.new(0,0,@viewport)
if $Trainer.female? && cardexists
@sprites["card"].setBitmap("Graphics/Pictures/Trainer Card/card_f")
else
@sprites["card"].setBitmap("Graphics/Pictures/Trainer Card/card")
end
@sprites["overlay"] = BitmapSprite.new(Graphics.width,Graphics.height,@viewport)
pbSetSystemFont(@sprites["overlay"].bitmap)
@sprites["trainer"] = IconSprite.new(336,112,@viewport)
@sprites["trainer"].setBitmap(GameData::TrainerType.player_front_sprite_filename($Trainer.trainer_type))
@sprites["trainer"].x -= (@sprites["trainer"].bitmap.width-128)/2
@sprites["trainer"].y -= (@sprites["trainer"].bitmap.height-128)
@sprites["trainer"].z = 2
pbDrawTrainerCardFront
pbFadeInAndShow(@sprites) { pbUpdate }
end
def pbDrawTrainerCardFront
overlay = @sprites["overlay"].bitmap
overlay.clear
baseColor = Color.new(72,72,72)
shadowColor = Color.new(160,160,160)
totalsec = Graphics.frame_count / Graphics.frame_rate
hour = totalsec / 60 / 60
min = totalsec / 60 % 60
time = (hour>0) ? _INTL("{1}h {2}m",hour,min) : _INTL("{1}m",min)
$PokemonGlobal.startTime = pbGetTimeNow if !$PokemonGlobal.startTime
starttime = _INTL("{1} {2}, {3}",
pbGetAbbrevMonthName($PokemonGlobal.startTime.mon),
$PokemonGlobal.startTime.day,
$PokemonGlobal.startTime.year)
textPositions = [
[_INTL("Name"),34,58,0,baseColor,shadowColor],
[$Trainer.name,302,58,1,baseColor,shadowColor],
[_INTL("ID No."),332,58,0,baseColor,shadowColor],
[sprintf("%05d",$Trainer.public_ID),468,58,1,baseColor,shadowColor],
[_INTL("Money"),34,106,0,baseColor,shadowColor],
[_INTL("${1}",$Trainer.money.to_s_formatted),302,106,1,baseColor,shadowColor],
[_INTL("Pokédex"),34,154,0,baseColor,shadowColor],
[sprintf("%d/%d",$Trainer.pokedex.owned_count,$Trainer.pokedex.seen_count),302,154,1,baseColor,shadowColor],
[_INTL("Time"),34,202,0,baseColor,shadowColor],
[time,302,202,1,baseColor,shadowColor],
[_INTL("Started"),34,250,0,baseColor,shadowColor],
[starttime,302,250,1,baseColor,shadowColor]
]
pbDrawTextPositions(overlay,textPositions)
x = 72
region = pbGetCurrentRegion(0) # Get the current region
imagePositions = []
for i in 0...8
if $Trainer.badges[i+region*8]
imagePositions.push(["Graphics/Pictures/Trainer Card/icon_badges",x,310,i*32,region*32,32,32])
end
x += 48
end
pbDrawImagePositions(overlay,imagePositions)
end
def pbTrainerCard
pbSEPlay("GUI trainer card open")
loop do
Graphics.update
Input.update
pbUpdate
if Input.trigger?(Input::BACK)
pbPlayCloseMenuSE
break
end
end
end
def pbEndScene
pbFadeOutAndHide(@sprites) { pbUpdate }
pbDisposeSpriteHash(@sprites)
@viewport.dispose
end
end
#===============================================================================
#
#===============================================================================
class PokemonTrainerCardScreen
def initialize(scene)
@scene = scene
end
def pbStartScreen
@scene.pbStartScene
@scene.pbTrainerCard
@scene.pbEndScene
end
end

345
Data/Scripts/016_UI/013_UI_Load.rb Normal file
View File

@@ -0,0 +1,345 @@
#===============================================================================
#
#===============================================================================
class PokemonLoadPanel < SpriteWrapper
attr_reader :selected
TEXTCOLOR = Color.new(232,232,232)
TEXTSHADOWCOLOR = Color.new(136,136,136)
MALETEXTCOLOR = Color.new(56,160,248)
MALETEXTSHADOWCOLOR = Color.new(56,104,168)
FEMALETEXTCOLOR = Color.new(240,72,88)
FEMALETEXTSHADOWCOLOR = Color.new(160,64,64)
def initialize(index,title,isContinue,trainer,framecount,mapid,viewport=nil)
super(viewport)
@index = index
@title = title
@isContinue = isContinue
@trainer = trainer
@totalsec = (framecount || 0) / Graphics.frame_rate
@mapid = mapid
@selected = (index==0)
@bgbitmap = AnimatedBitmap.new("Graphics/Pictures/loadPanels")
@refreshBitmap = true
@refreshing = false
refresh
end
def dispose
@bgbitmap.dispose
self.bitmap.dispose
super
end
def selected=(value)
return if @selected==value
@selected = value
@refreshBitmap = true
refresh
end
def pbRefresh
@refreshBitmap = true
refresh
end
def refresh
return if @refreshing
return if disposed?
@refreshing = true
if !self.bitmap || self.bitmap.disposed?
self.bitmap = BitmapWrapper.new(@bgbitmap.width,111*2)
pbSetSystemFont(self.bitmap)
end
if @refreshBitmap
@refreshBitmap = false
self.bitmap.clear if self.bitmap
if @isContinue
self.bitmap.blt(0,0,@bgbitmap.bitmap,Rect.new(0,(@selected) ? 111*2 : 0,@bgbitmap.width,111*2))
else
self.bitmap.blt(0,0,@bgbitmap.bitmap,Rect.new(0,111*2*2+((@selected) ? 23*2 : 0),@bgbitmap.width,23*2))
end
textpos = []
if @isContinue
textpos.push([@title,16*2,2*2,0,TEXTCOLOR,TEXTSHADOWCOLOR])
textpos.push([_INTL("Badges:"),16*2,53*2,0,TEXTCOLOR,TEXTSHADOWCOLOR])
textpos.push([@trainer.badge_count.to_s,103*2,53*2,1,TEXTCOLOR,TEXTSHADOWCOLOR])
textpos.push([_INTL("Pokédex:"),16*2,69*2,0,TEXTCOLOR,TEXTSHADOWCOLOR])
textpos.push([@trainer.pokedex.seen_count.to_s,103*2,69*2,1,TEXTCOLOR,TEXTSHADOWCOLOR])
textpos.push([_INTL("Time:"),16*2,85*2,0,TEXTCOLOR,TEXTSHADOWCOLOR])
hour = @totalsec / 60 / 60
min = @totalsec / 60 % 60
if hour>0
textpos.push([_INTL("{1}h {2}m",hour,min),103*2,85*2,1,TEXTCOLOR,TEXTSHADOWCOLOR])
else
textpos.push([_INTL("{1}m",min),103*2,85*2,1,TEXTCOLOR,TEXTSHADOWCOLOR])
end
if @trainer.male?
textpos.push([@trainer.name,56*2,29*2,0,MALETEXTCOLOR,MALETEXTSHADOWCOLOR])
elsif @trainer.female?
textpos.push([@trainer.name,56*2,29*2,0,FEMALETEXTCOLOR,FEMALETEXTSHADOWCOLOR])
else
textpos.push([@trainer.name,56*2,29*2,0,TEXTCOLOR,TEXTSHADOWCOLOR])
end
mapname = pbGetMapNameFromId(@mapid)
mapname.gsub!(/\\PN/,@trainer.name)
textpos.push([mapname,193*2,2*2,1,TEXTCOLOR,TEXTSHADOWCOLOR])
else
textpos.push([@title,16*2,1*2,0,TEXTCOLOR,TEXTSHADOWCOLOR])
end
pbDrawTextPositions(self.bitmap,textpos)
end
@refreshing = false
end
end
#===============================================================================
#
#===============================================================================
class PokemonLoad_Scene
def pbStartScene(commands, show_continue, trainer, frame_count, map_id)
@commands = commands
@sprites = {}
@viewport = Viewport.new(0, 0, Graphics.width, Graphics.height)
@viewport.z = 99998
addBackgroundOrColoredPlane(@sprites,"background","loadbg",Color.new(248,248,248),@viewport)
y = 16*2
for i in 0...commands.length
@sprites["panel#{i}"] = PokemonLoadPanel.new(i,commands[i],
(show_continue) ? (i==0) : false,trainer,frame_count,map_id,@viewport)
@sprites["panel#{i}"].x = 24*2
@sprites["panel#{i}"].y = y
@sprites["panel#{i}"].pbRefresh
y += (show_continue && i==0) ? 112*2 : 24*2
end
@sprites["cmdwindow"] = Window_CommandPokemon.new([])
@sprites["cmdwindow"].viewport = @viewport
@sprites["cmdwindow"].visible = false
end
def pbStartScene2
pbFadeInAndShow(@sprites) { pbUpdate }
end
def pbStartDeleteScene
@sprites = {}
@viewport = Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z = 99998
addBackgroundOrColoredPlane(@sprites,"background","loadbg",Color.new(248,248,248),@viewport)
end
def pbUpdate
oldi = @sprites["cmdwindow"].index rescue 0
pbUpdateSpriteHash(@sprites)
newi = @sprites["cmdwindow"].index rescue 0
if oldi!=newi
@sprites["panel#{oldi}"].selected = false
@sprites["panel#{oldi}"].pbRefresh
@sprites["panel#{newi}"].selected = true
@sprites["panel#{newi}"].pbRefresh
while @sprites["panel#{newi}"].y>Graphics.height-40*2
for i in 0...@commands.length
@sprites["panel#{i}"].y -= 24*2
end
for i in 0...6
break if !@sprites["party#{i}"]
@sprites["party#{i}"].y -= 24*2
end
@sprites["player"].y -= 24*2 if @sprites["player"]
end
while @sprites["panel#{newi}"].y<16*2
for i in 0...@commands.length
@sprites["panel#{i}"].y += 24*2
end
for i in 0...6
break if !@sprites["party#{i}"]
@sprites["party#{i}"].y += 24*2
end
@sprites["player"].y += 24*2 if @sprites["player"]
end
end
end
def pbSetParty(trainer)
return if !trainer || !trainer.party
meta = GameData::Metadata.get_player(trainer.character_ID)
if meta
filename = pbGetPlayerCharset(meta,1,trainer,true)
@sprites["player"] = TrainerWalkingCharSprite.new(filename,@viewport)
charwidth = @sprites["player"].bitmap.width
charheight = @sprites["player"].bitmap.height
@sprites["player"].x = 56*2-charwidth/8
@sprites["player"].y = 56*2-charheight/8
@sprites["player"].src_rect = Rect.new(0,0,charwidth/4,charheight/4)
end
for i in 0...trainer.party.length
@sprites["party#{i}"] = PokemonIconSprite.new(trainer.party[i],@viewport)
@sprites["party#{i}"].setOffset(PictureOrigin::Center)
@sprites["party#{i}"].x = (167+33*(i%2))*2
@sprites["party#{i}"].y = (56+25*(i/2))*2
@sprites["party#{i}"].z = 99999
end
end
def pbChoose(commands)
@sprites["cmdwindow"].commands = commands
loop do
Graphics.update
Input.update
pbUpdate
if Input.trigger?(Input::USE)
return @sprites["cmdwindow"].index
end
end
end
def pbEndScene
pbFadeOutAndHide(@sprites) { pbUpdate }
pbDisposeSpriteHash(@sprites)
@viewport.dispose
end
def pbCloseScene
pbDisposeSpriteHash(@sprites)
@viewport.dispose
end
end
#===============================================================================
#
#===============================================================================
class PokemonLoadScreen
def initialize(scene)
@scene = scene
if SaveData.exists?
@save_data = load_save_file(SaveData::FILE_PATH)
else
@save_data = {}
end
end
# @param file_path [String] file to load save data from
# @return [Hash] save data
def load_save_file(file_path)
save_data = SaveData.read_from_file(file_path)
unless SaveData.valid?(save_data)
if File.file?(file_path + '.bak')
pbMessage(_INTL('The save file is corrupt. A backup will be loaded.'))
save_data = load_save_file(file_path + '.bak')
else
self.prompt_save_deletion
return {}
end
end
return save_data
end
# Called if all save data is invalid.
# Prompts the player to delete the save files.
def prompt_save_deletion
pbMessage(_INTL('The save file is corrupt, or is incompatible with this game.'))
exit unless pbConfirmMessageSerious(
_INTL('Do you want to delete the save file and start anew?')
)
self.delete_save_data
$game_system = Game_System.new
$PokemonSystem = PokemonSystem.new
end
def pbStartDeleteScreen
@scene.pbStartDeleteScene
@scene.pbStartScene2
if SaveData.exists?
if pbConfirmMessageSerious(_INTL("Delete all saved data?"))
pbMessage(_INTL("Once data has been deleted, there is no way to recover it.\1"))
if pbConfirmMessageSerious(_INTL("Delete the saved data anyway?"))
pbMessage(_INTL("Deleting all data. Don't turn off the power.\\wtnp[0]"))
self.delete_save_data
end
end
else
pbMessage(_INTL("No save file was found."))
end
@scene.pbEndScene
$scene = pbCallTitle
end
def delete_save_data
begin
SaveData.delete_file
pbMessage(_INTL('The saved data was deleted.'))
rescue SystemCallError
pbMessage(_INTL('All saved data could not be deleted.'))
end
end
def pbStartLoadScreen
commands = []
cmd_continue = -1
cmd_new_game = -1
cmd_options = -1
cmd_language = -1
cmd_mystery_gift = -1
cmd_debug = -1
cmd_quit = -1
show_continue = !@save_data.empty?
if show_continue
commands[cmd_continue = commands.length] = _INTL('Continue')
if @save_data[:player].mystery_gift_unlocked
commands[cmd_mystery_gift = commands.length] = _INTL('Mystery Gift')
end
end
commands[cmd_new_game = commands.length] = _INTL('New Game')
commands[cmd_options = commands.length] = _INTL('Options')
commands[cmd_language = commands.length] = _INTL('Language') if Settings::LANGUAGES.length >= 2
commands[cmd_debug = commands.length] = _INTL('Debug') if $DEBUG
commands[cmd_quit = commands.length] = _INTL('Quit Game')
map_id = show_continue ? @save_data[:map_factory].map.map_id : 0
@scene.pbStartScene(commands, show_continue, @save_data[:player],
@save_data[:frame_count] || 0, map_id)
@scene.pbSetParty(@save_data[:player]) if show_continue
@scene.pbStartScene2
loop do
command = @scene.pbChoose(commands)
pbPlayDecisionSE if command != cmd_quit
case command
when cmd_continue
@scene.pbEndScene
Game.load(@save_data)
return
when cmd_new_game
@scene.pbEndScene
Game.start_new
return
when cmd_mystery_gift
pbFadeOutIn { pbDownloadMysteryGift(@save_data[:player]) }
when cmd_options
pbFadeOutIn do
scene = PokemonOption_Scene.new
screen = PokemonOptionScreen.new(scene)
screen.pbStartScreen(true)
end
when cmd_language
@scene.pbEndScene
$PokemonSystem.language = pbChooseLanguage
pbLoadMessages('Data/' + Settings::LANGUAGES[$PokemonSystem.language][1])
if show_continue
@save_data[:pokemon_system] = $PokemonSystem
File.open(SaveData::FILE_PATH, 'wb') { |file| Marshal.dump(@save_data, file) }
end
$scene = pbCallTitle
return
when cmd_debug
pbFadeOutIn { pbDebugMenu(false) }
when cmd_quit
pbPlayCloseMenuSE
@scene.pbEndScene
$scene = nil
return
else
pbPlayBuzzerSE
end
end
end
end

128
Data/Scripts/016_UI/014_UI_Save.rb Normal file
View File

@@ -0,0 +1,128 @@
# @deprecated Use {Game.save} instead. pbSave is slated to be removed in v20.
def pbSave(safesave = false)
Deprecation.warn_method('pbSave', 'Game.save', 'v20')
Game.save(safe: safesave)
end
def pbEmergencySave
oldscene = $scene
$scene = nil
pbMessage(_INTL("The script is taking too long. The game will restart."))
return if !$Trainer
if SaveData.exists?
File.open(SaveData::FILE_PATH, 'rb') do |r|
File.open(SaveData::FILE_PATH + '.bak', 'wb') do |w|
while s = r.read(4096)
w.write s
end
end
end
end
if Game.save
pbMessage(_INTL("\\se[]The game was saved.\\me[GUI save game] The previous save file has been backed up.\\wtnp[30]"))
else
pbMessage(_INTL("\\se[]Save failed.\\wtnp[30]"))
end
$scene = oldscene
end
#===============================================================================
#
#===============================================================================
class PokemonSave_Scene
def pbStartScreen
@viewport=Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z=99999
@sprites={}
totalsec = Graphics.frame_count / Graphics.frame_rate
hour = totalsec / 60 / 60
min = totalsec / 60 % 60
mapname=$game_map.name
textColor = ["0070F8,78B8E8","E82010,F8A8B8","0070F8,78B8E8"][$Trainer.gender]
locationColor = "209808,90F090" # green
loctext=_INTL("<ac><c3={1}>{2}</c3></ac>",locationColor,mapname)
loctext+=_INTL("Player<r><c3={1}>{2}</c3><br>",textColor,$Trainer.name)
if hour>0
loctext+=_INTL("Time<r><c3={1}>{2}h {3}m</c3><br>",textColor,hour,min)
else
loctext+=_INTL("Time<r><c3={1}>{2}m</c3><br>",textColor,min)
end
loctext+=_INTL("Badges<r><c3={1}>{2}</c3><br>",textColor,$Trainer.badge_count)
if $Trainer.has_pokedex
loctext+=_INTL("Pokédex<r><c3={1}>{2}/{3}</c3>",textColor,$Trainer.pokedex.owned_count,$Trainer.pokedex.seen_count)
end
@sprites["locwindow"]=Window_AdvancedTextPokemon.new(loctext)
@sprites["locwindow"].viewport=@viewport
@sprites["locwindow"].x=0
@sprites["locwindow"].y=0
@sprites["locwindow"].width=228 if @sprites["locwindow"].width<228
@sprites["locwindow"].visible=true
end
def pbEndScreen
pbDisposeSpriteHash(@sprites)
@viewport.dispose
end
end
#===============================================================================
#
#===============================================================================
class PokemonSaveScreen
def initialize(scene)
@scene=scene
end
def pbDisplay(text,brief=false)
@scene.pbDisplay(text,brief)
end
def pbDisplayPaused(text)
@scene.pbDisplayPaused(text)
end
def pbConfirm(text)
return @scene.pbConfirm(text)
end
def pbSaveScreen
ret = false
@scene.pbStartScreen
if pbConfirmMessage(_INTL('Would you like to save the game?'))
if SaveData.exists? && $PokemonTemp.begunNewGame
pbMessage(_INTL('WARNING!'))
pbMessage(_INTL('There is a different game file that is already saved.'))
pbMessage(_INTL("If you save now, the other file's adventure, including items and Pokémon, will be entirely lost."))
if !pbConfirmMessageSerious(
_INTL('Are you sure you want to save now and overwrite the other save file?'))
pbSEPlay('GUI save choice')
@scene.pbEndScreen
return false
end
end
$PokemonTemp.begunNewGame = false
pbSEPlay('GUI save choice')
if Game.save
pbMessage(_INTL("\\se[]{1} saved the game.\\me[GUI save game]\\wtnp[30]", $Trainer.name))
ret = true
else
pbMessage(_INTL("\\se[]Save failed.\\wtnp[30]"))
ret = false
end
else
pbSEPlay('GUI save choice')
end
@scene.pbEndScreen
return ret
end
end
#===============================================================================
#
#===============================================================================
def pbSaveScreen
scene = PokemonSave_Scene.new
screen = PokemonSaveScreen.new(scene)
ret = screen.pbSaveScreen
return ret
end

475
Data/Scripts/016_UI/015_UI_Options.rb Normal file
View File

@@ -0,0 +1,475 @@
#===============================================================================
#
#===============================================================================
class PokemonSystem
attr_accessor :textspeed
attr_accessor :battlescene
attr_accessor :battlestyle
attr_accessor :frame
attr_accessor :textskin
attr_accessor :font
attr_accessor :screensize
attr_accessor :language
attr_accessor :runstyle
attr_accessor :bgmvolume
attr_accessor :sevolume
attr_accessor :textinput
def initialize
@textspeed = 1 # Text speed (0=slow, 1=normal, 2=fast)
@battlescene = 0 # Battle effects (animations) (0=on, 1=off)
@battlestyle = 0 # Battle style (0=switch, 1=set)
@frame = 0 # Default window frame (see also Settings::MENU_WINDOWSKINS)
@textskin = 0 # Speech frame
@font = 0 # Font (see also Settings::FONT_OPTIONS)
@screensize = (Settings::SCREEN_SCALE * 2).floor - 1 # 0=half size, 1=full size, 2=full-and-a-half size, 3=double size
@language = 0 # Language (see also Settings::LANGUAGES in script PokemonSystem)
@runstyle = 0 # Default movement speed (0=walk, 1=run)
@bgmvolume = 100 # Volume of background music and ME
@sevolume = 100 # Volume of sound effects
@textinput = 0 # Text input mode (0=cursor, 1=keyboard)
end
def tilemap; return Settings::MAP_VIEW_MODE; end
end
#===============================================================================
#
#===============================================================================
module PropertyMixin
def get
(@getProc) ? @getProc.call : nil
end
def set(value)
@setProc.call(value) if @setProc
end
end
#===============================================================================
#
#===============================================================================
class EnumOption
include PropertyMixin
attr_reader :values
attr_reader :name
def initialize(name,options,getProc,setProc)
@name = name
@values = options
@getProc = getProc
@setProc = setProc
end
def next(current)
index = current+1
index = @values.length-1 if index>@values.length-1
return index
end
def prev(current)
index = current-1
index = 0 if index<0
return index
end
end
#===============================================================================
#
#===============================================================================
class EnumOption2
include PropertyMixin
attr_reader :values
attr_reader :name
def initialize(name,options,getProc,setProc)
@name = name
@values = options
@getProc = getProc
@setProc = setProc
end
def next(current)
index = current+1
index = @values.length-1 if index>@values.length-1
return index
end
def prev(current)
index = current-1
index = 0 if index<0
return index
end
end
#===============================================================================
#
#===============================================================================
class NumberOption
include PropertyMixin
attr_reader :name
attr_reader :optstart
attr_reader :optend
def initialize(name,optstart,optend,getProc,setProc)
@name = name
@optstart = optstart
@optend = optend
@getProc = getProc
@setProc = setProc
end
def next(current)
index = current+@optstart
index += 1
index = @optstart if index>@optend
return index-@optstart
end
def prev(current)
index = current+@optstart
index -= 1
index = @optend if index<@optstart
return index-@optstart
end
end
#===============================================================================
#
#===============================================================================
class SliderOption
include PropertyMixin
attr_reader :name
attr_reader :optstart
attr_reader :optend
def initialize(name,optstart,optend,optinterval,getProc,setProc)
@name = name
@optstart = optstart
@optend = optend
@optinterval = optinterval
@getProc = getProc
@setProc = setProc
end
def next(current)
index = current+@optstart
index += @optinterval
index = @optend if index>@optend
return index-@optstart
end
def prev(current)
index = current+@optstart
index -= @optinterval
index = @optstart if index<@optstart
return index-@optstart
end
end
#===============================================================================
# Main options list
#===============================================================================
class Window_PokemonOption < Window_DrawableCommand
attr_reader :mustUpdateOptions
def initialize(options,x,y,width,height)
@options = options
@nameBaseColor = Color.new(24*8,15*8,0)
@nameShadowColor = Color.new(31*8,22*8,10*8)
@selBaseColor = Color.new(31*8,6*8,3*8)
@selShadowColor = Color.new(31*8,17*8,16*8)
@optvalues = []
@mustUpdateOptions = false
for i in 0...@options.length
@optvalues[i] = 0
end
super(x,y,width,height)
end
def [](i)
return @optvalues[i]
end
def []=(i,value)
@optvalues[i] = value
refresh
end
def setValueNoRefresh(i,value)
@optvalues[i] = value
end
def itemCount
return @options.length+1
end
def drawItem(index,_count,rect)
rect = drawCursor(index,rect)
optionname = (index==@options.length) ? _INTL("Cancel") : @options[index].name
optionwidth = rect.width*9/20
pbDrawShadowText(self.contents,rect.x,rect.y,optionwidth,rect.height,optionname,
@nameBaseColor,@nameShadowColor)
return if index==@options.length
if @options[index].is_a?(EnumOption)
if @options[index].values.length>1
totalwidth = 0
for value in @options[index].values
totalwidth += self.contents.text_size(value).width
end
spacing = (optionwidth-totalwidth)/(@options[index].values.length-1)
spacing = 0 if spacing<0
xpos = optionwidth+rect.x
ivalue = 0
for value in @options[index].values
pbDrawShadowText(self.contents,xpos,rect.y,optionwidth,rect.height,value,
(ivalue==self[index]) ? @selBaseColor : self.baseColor,
(ivalue==self[index]) ? @selShadowColor : self.shadowColor
)
xpos += self.contents.text_size(value).width
xpos += spacing
ivalue += 1
end
else
pbDrawShadowText(self.contents,rect.x+optionwidth,rect.y,optionwidth,rect.height,
optionname,self.baseColor,self.shadowColor)
end
elsif @options[index].is_a?(NumberOption)
value = _INTL("Type {1}/{2}",@options[index].optstart+self[index],
@options[index].optend-@options[index].optstart+1)
xpos = optionwidth+rect.x
pbDrawShadowText(self.contents,xpos,rect.y,optionwidth,rect.height,value,
@selBaseColor,@selShadowColor)
elsif @options[index].is_a?(SliderOption)
value = sprintf(" %d",@options[index].optend)
sliderlength = optionwidth-self.contents.text_size(value).width
xpos = optionwidth+rect.x
self.contents.fill_rect(xpos,rect.y-2+rect.height/2,
optionwidth-self.contents.text_size(value).width,4,self.baseColor)
self.contents.fill_rect(
xpos+(sliderlength-8)*(@options[index].optstart+self[index])/@options[index].optend,
rect.y-8+rect.height/2,
8,16,@selBaseColor)
value = sprintf("%d",@options[index].optstart+self[index])
xpos += optionwidth-self.contents.text_size(value).width
pbDrawShadowText(self.contents,xpos,rect.y,optionwidth,rect.height,value,
@selBaseColor,@selShadowColor)
else
value = @options[index].values[self[index]]
xpos = optionwidth+rect.x
pbDrawShadowText(self.contents,xpos,rect.y,optionwidth,rect.height,value,
@selBaseColor,@selShadowColor)
end
end
def update
oldindex = self.index
@mustUpdateOptions = false
super
dorefresh = (self.index!=oldindex)
if self.active && self.index<@options.length
if Input.repeat?(Input::LEFT)
self[self.index] = @options[self.index].prev(self[self.index])
dorefresh = true
@mustUpdateOptions = true
elsif Input.repeat?(Input::RIGHT)
self[self.index] = @options[self.index].next(self[self.index])
dorefresh = true
@mustUpdateOptions = true
end
end
refresh if dorefresh
end
end
#===============================================================================
# Options main screen
#===============================================================================
class PokemonOption_Scene
def pbUpdate
pbUpdateSpriteHash(@sprites)
end
def pbStartScene(inloadscreen=false)
@sprites = {}
@viewport = Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z = 99999
@sprites["title"] = Window_UnformattedTextPokemon.newWithSize(
_INTL("Options"),0,0,Graphics.width,64,@viewport)
@sprites["textbox"] = pbCreateMessageWindow
@sprites["textbox"].text = _INTL("Speech frame {1}.",1+$PokemonSystem.textskin)
@sprites["textbox"].letterbyletter = false
pbSetSystemFont(@sprites["textbox"].contents)
# These are the different options in the game. To add an option, define a
# setter and a getter for that option. To delete an option, comment it out
# or delete it. The game's options may be placed in any order.
@PokemonOptions = [
SliderOption.new(_INTL("Music Volume"),0,100,5,
proc { $PokemonSystem.bgmvolume },
proc { |value|
if $PokemonSystem.bgmvolume!=value
$PokemonSystem.bgmvolume = value
if $game_system.playing_bgm!=nil && !inloadscreen
$game_system.playing_bgm.volume = value
playingBGM = $game_system.getPlayingBGM
$game_system.bgm_pause
$game_system.bgm_resume(playingBGM)
end
end
}
),
SliderOption.new(_INTL("SE Volume"),0,100,5,
proc { $PokemonSystem.sevolume },
proc { |value|
if $PokemonSystem.sevolume!=value
$PokemonSystem.sevolume = value
if $game_system.playing_bgs!=nil
$game_system.playing_bgs.volume = value
playingBGS = $game_system.getPlayingBGS
$game_system.bgs_pause
$game_system.bgs_resume(playingBGS)
end
pbPlayCursorSE
end
}
),
EnumOption.new(_INTL("Text Speed"),[_INTL("Slow"),_INTL("Normal"),_INTL("Fast")],
proc { $PokemonSystem.textspeed },
proc { |value|
$PokemonSystem.textspeed = value
MessageConfig.pbSetTextSpeed(MessageConfig.pbSettingToTextSpeed(value))
}
),
EnumOption.new(_INTL("Battle Effects"),[_INTL("On"),_INTL("Off")],
proc { $PokemonSystem.battlescene },
proc { |value| $PokemonSystem.battlescene = value }
),
EnumOption.new(_INTL("Battle Style"),[_INTL("Switch"),_INTL("Set")],
proc { $PokemonSystem.battlestyle },
proc { |value| $PokemonSystem.battlestyle = value }
),
EnumOption.new(_INTL("Default Movement"),[_INTL("Walking"),_INTL("Running")],
proc { $PokemonSystem.runstyle },
proc { |value| $PokemonSystem.runstyle = value }
),
NumberOption.new(_INTL("Speech Frame"),1,Settings::SPEECH_WINDOWSKINS.length,
proc { $PokemonSystem.textskin },
proc { |value|
$PokemonSystem.textskin = value
MessageConfig.pbSetSpeechFrame("Graphics/Windowskins/" + Settings::SPEECH_WINDOWSKINS[value])
}
),
NumberOption.new(_INTL("Menu Frame"),1,Settings::MENU_WINDOWSKINS.length,
proc { $PokemonSystem.frame },
proc { |value|
$PokemonSystem.frame = value
MessageConfig.pbSetSystemFrame("Graphics/Windowskins/" + Settings::MENU_WINDOWSKINS[value])
}
),
EnumOption.new(_INTL("Font Style"),[_INTL("Em"),_INTL("R/S"),_INTL("FRLG"),_INTL("DP")],
proc { $PokemonSystem.font },
proc { |value|
$PokemonSystem.font = value
MessageConfig.pbSetSystemFontName(Settings::FONT_OPTIONS[value])
}
),
EnumOption.new(_INTL("Text Entry"),[_INTL("Cursor"),_INTL("Keyboard")],
proc { $PokemonSystem.textinput },
proc { |value| $PokemonSystem.textinput = value }
),
EnumOption.new(_INTL("Screen Size"),[_INTL("S"),_INTL("M"),_INTL("L"),_INTL("XL"),_INTL("Full")],
proc { [$PokemonSystem.screensize, 4].min },
proc { |value|
if $PokemonSystem.screensize != value
$PokemonSystem.screensize = value
pbSetResizeFactor($PokemonSystem.screensize)
end
}
)
]
@PokemonOptions = pbAddOnOptions(@PokemonOptions)
@sprites["option"] = Window_PokemonOption.new(@PokemonOptions,0,
@sprites["title"].height,Graphics.width,
Graphics.height-@sprites["title"].height-@sprites["textbox"].height)
@sprites["option"].viewport = @viewport
@sprites["option"].visible = true
# Get the values of each option
for i in 0...@PokemonOptions.length
@sprites["option"].setValueNoRefresh(i,(@PokemonOptions[i].get || 0))
end
@sprites["option"].refresh
pbDeactivateWindows(@sprites)
pbFadeInAndShow(@sprites) { pbUpdate }
end
def pbAddOnOptions(options)
return options
end
def pbOptions
oldSystemSkin = $PokemonSystem.frame # Menu
oldTextSkin = $PokemonSystem.textskin # Speech
oldFont = $PokemonSystem.font
pbActivateWindow(@sprites,"option") {
loop do
Graphics.update
Input.update
pbUpdate
if @sprites["option"].mustUpdateOptions
# Set the values of each option
for i in 0...@PokemonOptions.length
@PokemonOptions[i].set(@sprites["option"][i])
end
if $PokemonSystem.textskin!=oldTextSkin
@sprites["textbox"].setSkin(MessageConfig.pbGetSpeechFrame())
@sprites["textbox"].text = _INTL("Speech frame {1}.",1+$PokemonSystem.textskin)
oldTextSkin = $PokemonSystem.textskin
end
if $PokemonSystem.frame!=oldSystemSkin
@sprites["title"].setSkin(MessageConfig.pbGetSystemFrame())
@sprites["option"].setSkin(MessageConfig.pbGetSystemFrame())
oldSystemSkin = $PokemonSystem.frame
end
if $PokemonSystem.font!=oldFont
pbSetSystemFont(@sprites["textbox"].contents)
@sprites["textbox"].text = _INTL("Speech frame {1}.",1+$PokemonSystem.textskin)
oldFont = $PokemonSystem.font
end
end
if Input.trigger?(Input::BACK)
break
elsif Input.trigger?(Input::USE)
break if @sprites["option"].index==@PokemonOptions.length
end
end
}
end
def pbEndScene
pbPlayCloseMenuSE
pbFadeOutAndHide(@sprites) { pbUpdate }
# Set the values of each option
for i in 0...@PokemonOptions.length
@PokemonOptions[i].set(@sprites["option"][i])
end
pbDisposeMessageWindow(@sprites["textbox"])
pbDisposeSpriteHash(@sprites)
pbRefreshSceneMap
@viewport.dispose
end
end
#===============================================================================
#
#===============================================================================
class PokemonOptionScreen
def initialize(scene)
@scene = scene
end
def pbStartScreen(inloadscreen=false)
@scene.pbStartScene(inloadscreen)
@scene.pbOptions
@scene.pbEndScene
end
end

327
Data/Scripts/016_UI/016_UI_ReadyMenu.rb Normal file
View File

@@ -0,0 +1,327 @@
#===============================================================================
#
#===============================================================================
class ReadyMenuButton < SpriteWrapper
attr_reader :index # ID of button
attr_reader :selected
attr_reader :side
def initialize(index,command,selected,side,viewport=nil)
super(viewport)
@index = index
@command = command # Item/move ID, name, mode (T move/F item), pkmnIndex
@selected = selected
@side = side
if @command[2]
@button = AnimatedBitmap.new("Graphics/Pictures/Ready Menu/icon_movebutton")
else
@button = AnimatedBitmap.new("Graphics/Pictures/Ready Menu/icon_itembutton")
end
@contents = BitmapWrapper.new(@button.width,@button.height/2)
self.bitmap = @contents
pbSetSystemFont(self.bitmap)
if @command[2]
@icon = PokemonIconSprite.new($Trainer.party[@command[3]],viewport)
@icon.setOffset(PictureOrigin::Center)
else
@icon = ItemIconSprite.new(0,0,@command[0],viewport)
end
@icon.z = self.z+1
refresh
end
def dispose
@button.dispose
@contents.dispose
@icon.dispose
super
end
def visible=(val)
@icon.visible = val
super(val)
end
def selected=(val)
oldsel = @selected
@selected = val
refresh if oldsel!=val
end
def side=(val)
oldsel = @side
@side = val
refresh if oldsel!=val
end
def refresh
sel = (@selected==@index && (@side==0)==@command[2])
self.y = (Graphics.height-@button.height/2)/2 - (@selected-@index)*(@button.height/2+4)
if @command[2] # Pokémon
self.x = (sel) ? 0 : -16
@icon.x = self.x+52
@icon.y = self.y+32
else # Item
self.x = (sel) ? Graphics.width-@button.width : Graphics.width+16-@button.width
@icon.x = self.x+32
@icon.y = self.y+@button.height/4
end
self.bitmap.clear
rect = Rect.new(0,(sel) ? @button.height/2 : 0,@button.width,@button.height/2)
self.bitmap.blt(0,0,@button.bitmap,rect)
textx = (@command[2]) ? 164 : (GameData::Item.get(@command[0]).is_important?) ? 146 : 124
textpos = [
[@command[1],textx,16,2,Color.new(248,248,248),Color.new(40,40,40),1],
]
if !@command[2]
if !GameData::Item.get(@command[0]).is_important?
qty = $PokemonBag.pbQuantity(@command[0])
if qty>99
textpos.push([_INTL(">99"),230,16,1,
Color.new(248,248,248),Color.new(40,40,40),1])
else
textpos.push([_INTL("x{1}",qty),230,16,1,
Color.new(248,248,248),Color.new(40,40,40),1])
end
end
end
pbDrawTextPositions(self.bitmap,textpos)
end
def update
@icon.update if @icon
super
end
end
#===============================================================================
#
#===============================================================================
class PokemonReadyMenu_Scene
attr_reader :sprites
def pbStartScene(commands)
@commands = commands
@movecommands = []
@itemcommands = []
for i in 0...@commands[0].length
@movecommands.push(@commands[0][i][1])
end
for i in 0...@commands[1].length
@itemcommands.push(@commands[1][i][1])
end
@index = $PokemonBag.registeredIndex
if @index[0]>=@movecommands.length && @movecommands.length>0
@index[0] = @movecommands.length-1
end
if @index[1]>=@itemcommands.length && @itemcommands.length>0
@index[1] = @itemcommands.length-1
end
if @index[2]==0 && @movecommands.length==0; @index[2] = 1
elsif @index[2]==1 && @itemcommands.length==0; @index[2] = 0
end
@viewport = Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z = 99999
@sprites = {}
@sprites["cmdwindow"] = Window_CommandPokemon.new((@index[2]==0) ? @movecommands : @itemcommands)
@sprites["cmdwindow"].height = 6*32
@sprites["cmdwindow"].visible = false
@sprites["cmdwindow"].viewport = @viewport
for i in 0...@commands[0].length
@sprites["movebutton#{i}"] = ReadyMenuButton.new(i,@commands[0][i],@index[0],@index[2],@viewport)
end
for i in 0...@commands[1].length
@sprites["itembutton#{i}"] = ReadyMenuButton.new(i,@commands[1][i],@index[1],@index[2],@viewport)
end
pbSEPlay("GUI menu open")
end
def pbShowMenu
@sprites["cmdwindow"].visible = false
for i in 0...@commands[0].length
@sprites["movebutton#{i}"].visible = true
end
for i in 0...@commands[1].length
@sprites["itembutton#{i}"].visible = true
end
end
def pbHideMenu
@sprites["cmdwindow"].visible = false
for i in 0...@commands[0].length
@sprites["movebutton#{i}"].visible = false
end
for i in 0...@commands[1].length
@sprites["itembutton#{i}"].visible = false
end
end
def pbShowCommands
ret = -1
cmdwindow = @sprites["cmdwindow"]
cmdwindow.commands = (@index[2]==0) ? @movecommands : @itemcommands
cmdwindow.index = @index[@index[2]]
cmdwindow.visible = false
loop do
pbUpdate
if Input.trigger?(Input::LEFT) && @index[2]==1 && @movecommands.length>0
@index[2] = 0
pbChangeSide
elsif Input.trigger?(Input::RIGHT) && @index[2]==0 && @itemcommands.length>0
@index[2] = 1
pbChangeSide
elsif Input.trigger?(Input::BACK)
pbPlayCloseMenuSE
ret = -1
break
elsif Input.trigger?(Input::USE)
ret = [@index[2],cmdwindow.index]
break
end
end
return ret
end
def pbEndScene
pbDisposeSpriteHash(@sprites)
@viewport.dispose
end
def pbChangeSide
for i in 0...@commands[0].length
@sprites["movebutton#{i}"].side = @index[2]
end
for i in 0...@commands[1].length
@sprites["itembutton#{i}"].side = @index[2]
end
@sprites["cmdwindow"].commands = (@index[2]==0) ? @movecommands : @itemcommands
@sprites["cmdwindow"].index = @index[@index[2]]
end
def pbRefresh; end
def pbUpdate
oldindex = @index[@index[2]]
@index[@index[2]] = @sprites["cmdwindow"].index
if @index[@index[2]]!=oldindex
if @index[2]==0
for i in 0...@commands[0].length
@sprites["movebutton#{i}"].selected = @index[@index[2]]
end
elsif @index[2]==1
for i in 0...@commands[1].length
@sprites["itembutton#{i}"].selected = @index[@index[2]]
end
end
end
pbUpdateSpriteHash(@sprites)
Graphics.update
Input.update
pbUpdateSceneMap
end
end
#===============================================================================
#
#===============================================================================
class PokemonReadyMenu
def initialize(scene)
@scene = scene
end
def pbHideMenu
@scene.pbHideMenu
end
def pbShowMenu
@scene.pbRefresh
@scene.pbShowMenu
end
def pbStartReadyMenu(moves,items)
commands = [[],[]] # Moves, items
for i in moves
commands[0].push([i[0], GameData::Move.get(i[0]).name, true, i[1]])
end
commands[0].sort! { |a,b| a[1]<=>b[1] }
for i in items
commands[1].push([i, GameData::Item.get(i).name, false])
end
commands[1].sort! { |a,b| a[1]<=>b[1] }
@scene.pbStartScene(commands)
loop do
command = @scene.pbShowCommands
break if command==-1
if command[0]==0 # Use a move
move = commands[0][command[1]][0]
user = $Trainer.party[commands[0][command[1]][3]]
if move == :FLY
ret = nil
pbFadeOutInWithUpdate(99999,@scene.sprites) {
pbHideMenu
scene = PokemonRegionMap_Scene.new(-1,false)
screen = PokemonRegionMapScreen.new(scene)
ret = screen.pbStartFlyScreen
pbShowMenu if !ret
}
if ret
$PokemonTemp.flydata = ret
$game_temp.in_menu = false
pbUseHiddenMove(user,move)
break
end
else
pbHideMenu
if pbConfirmUseHiddenMove(user,move)
$game_temp.in_menu = false
pbUseHiddenMove(user,move)
break
else
pbShowMenu
end
end
else # Use an item
item = commands[1][command[1]][0]
pbHideMenu
if ItemHandlers.triggerConfirmUseInField(item)
$game_temp.in_menu = false
break if pbUseKeyItemInField(item)
$game_temp.in_menu = true
end
end
pbShowMenu
end
@scene.pbEndScene
end
end
#===============================================================================
# Using a registered item
#===============================================================================
def pbUseKeyItem
moves = [:CUT, :DEFOG, :DIG, :DIVE, :FLASH, :FLY, :HEADBUTT, :ROCKCLIMB,
:ROCKSMASH, :SECRETPOWER, :STRENGTH, :SURF, :SWEETSCENT, :TELEPORT,
:WATERFALL, :WHIRLPOOL]
real_moves = []
moves.each do |move|
$Trainer.pokemon_party.each_with_index do |pkmn, i|
next if !pkmn.hasMove?(move)
real_moves.push([move, i]) if pbCanUseHiddenMove?(pkmn, move, false)
end
end
real_items = []
for i in $PokemonBag.registeredItems
itm = GameData::Item.get(i).id
real_items.push(itm) if $PokemonBag.pbHasItem?(itm)
end
if real_items.length == 0 && real_moves.length == 0
pbMessage(_INTL("An item in the Bag can be registered to this key for instant use."))
else
$game_temp.in_menu = true
$game_map.update
sscene = PokemonReadyMenu_Scene.new
sscreen = PokemonReadyMenu.new(sscene)
sscreen.pbStartReadyMenu(real_moves, real_items)
$game_temp.in_menu = false
end
end

1987
Data/Scripts/016_UI/017_UI_PokemonStorage.rb Normal file
View File

File diff suppressed because it is too large Load Diff

368
Data/Scripts/016_UI/018_UI_ItemStorage.rb Normal file
View File

@@ -0,0 +1,368 @@
#===============================================================================
#
#===============================================================================
class Window_PokemonItemStorage < Window_DrawableCommand
attr_reader :bag
attr_reader :pocket
attr_reader :sortIndex
def sortIndex=(value)
@sortIndex = value
refresh
end
def initialize(bag,x,y,width,height)
@bag = bag
@sortIndex = -1
@adapter = PokemonMartAdapter.new
super(x,y,width,height)
self.windowskin = nil
end
def item
item = @bag[self.index]
return item ? item[0] : nil
end
def itemCount
return @bag.length+1
end
def drawItem(index,_count,rect)
rect = drawCursor(index,rect)
textpos = []
if index==@bag.length
textpos.push([_INTL("CANCEL"),rect.x,rect.y-6,false,self.baseColor,self.shadowColor])
else
item = @bag[index][0]
itemname = @adapter.getDisplayName(item)
baseColor = (index==@sortIndex) ? Color.new(248,24,24) : self.baseColor
textpos.push([itemname,rect.x,rect.y-6,false,self.baseColor,self.shadowColor])
if !GameData::Item.get(item).is_important? # Not a Key item or HM (or infinite TM)
qty = _ISPRINTF("x{1: 2d}",@bag[index][1])
sizeQty = self.contents.text_size(qty).width
xQty = rect.x+rect.width-sizeQty-2
textpos.push([qty,xQty,rect.y-6,false,baseColor,self.shadowColor])
end
end
pbDrawTextPositions(self.contents,textpos)
end
end
#===============================================================================
#
#===============================================================================
class ItemStorage_Scene
ITEMLISTBASECOLOR = Color.new(88,88,80)
ITEMLISTSHADOWCOLOR = Color.new(168,184,184)
ITEMTEXTBASECOLOR = Color.new(248,248,248)
ITEMTEXTSHADOWCOLOR = Color.new(0,0,0)
TITLEBASECOLOR = Color.new(248,248,248)
TITLESHADOWCOLOR = Color.new(0,0,0)
ITEMSVISIBLE = 7
def initialize(title)
@title = title
end
def update
pbUpdateSpriteHash(@sprites)
end
def pbStartScene(bag)
@viewport = Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z = 99999
@bag = bag
@sprites = {}
@sprites["background"] = IconSprite.new(0,0,@viewport)
@sprites["background"].setBitmap("Graphics/Pictures/pcItembg")
@sprites["icon"] = ItemIconSprite.new(50,334,nil,@viewport)
# Item list
@sprites["itemwindow"] = Window_PokemonItemStorage.new(@bag,98,14,334,32+ITEMSVISIBLE*32)
@sprites["itemwindow"].viewport = @viewport
@sprites["itemwindow"].index = 0
@sprites["itemwindow"].baseColor = ITEMLISTBASECOLOR
@sprites["itemwindow"].shadowColor = ITEMLISTSHADOWCOLOR
@sprites["itemwindow"].refresh
# Title
@sprites["pocketwindow"] = BitmapSprite.new(88,64,@viewport)
@sprites["pocketwindow"].x = 14
@sprites["pocketwindow"].y = 16
pbSetNarrowFont(@sprites["pocketwindow"].bitmap)
# Item description
@sprites["itemtextwindow"] = Window_UnformattedTextPokemon.newWithSize("",84,270,Graphics.width-84,128,@viewport)
@sprites["itemtextwindow"].baseColor = ITEMTEXTBASECOLOR
@sprites["itemtextwindow"].shadowColor = ITEMTEXTSHADOWCOLOR
@sprites["itemtextwindow"].windowskin = nil
@sprites["helpwindow"] = Window_UnformattedTextPokemon.new("")
@sprites["helpwindow"].visible = false
@sprites["helpwindow"].viewport = @viewport
# Letter-by-letter message window
@sprites["msgwindow"] = Window_AdvancedTextPokemon.new("")
@sprites["msgwindow"].visible = false
@sprites["msgwindow"].viewport = @viewport
pbBottomLeftLines(@sprites["helpwindow"],1)
pbDeactivateWindows(@sprites)
pbRefresh
pbFadeInAndShow(@sprites)
end
def pbEndScene
pbFadeOutAndHide(@sprites)
pbDisposeSpriteHash(@sprites)
@viewport.dispose
end
def pbChooseNumber(helptext,maximum)
return UIHelper.pbChooseNumber(@sprites["helpwindow"],helptext,maximum) { update }
end
def pbDisplay(msg,brief=false)
UIHelper.pbDisplay(@sprites["msgwindow"],msg,brief) { update }
end
def pbConfirm(msg)
UIHelper.pbConfirm(@sprites["msgwindow"],msg) { update }
end
def pbShowCommands(helptext,commands)
return UIHelper.pbShowCommands(@sprites["helpwindow"],helptext,commands) { update }
end
def pbRefresh
bm = @sprites["pocketwindow"].bitmap
# Draw title at upper left corner ("Toss Item/Withdraw Item")
drawTextEx(bm,0,0,bm.width,2,@title,TITLEBASECOLOR,TITLESHADOWCOLOR)
itemwindow = @sprites["itemwindow"]
# Draw item icon
@sprites["icon"].item = itemwindow.item
# Get item description
if itemwindow.item
@sprites["itemtextwindow"].text = GameData::Item.get(itemwindow.item).description
else
@sprites["itemtextwindow"].text = _INTL("Close storage.")
end
itemwindow.refresh
end
def pbChooseItem
pbRefresh
@sprites["helpwindow"].visible = false
itemwindow = @sprites["itemwindow"]
itemwindow.refresh
pbActivateWindow(@sprites,"itemwindow") {
loop do
Graphics.update
Input.update
olditem = itemwindow.item
self.update
pbRefresh if itemwindow.item!=olditem
if Input.trigger?(Input::BACK)
return nil
elsif Input.trigger?(Input::USE)
if itemwindow.index<@bag.length
pbRefresh
return @bag[itemwindow.index][0]
else
return nil
end
end
end
}
end
end
#===============================================================================
#
#===============================================================================
class WithdrawItemScene < ItemStorage_Scene
def initialize
super(_INTL("Withdraw\nItem"))
end
end
#===============================================================================
#
#===============================================================================
class TossItemScene < ItemStorage_Scene
def initialize
super(_INTL("Toss\nItem"))
end
end
#===============================================================================
# Common UI functions used in both the Bag and item storage screens.
# Displays messages and allows the user to choose a number/command.
# The window _helpwindow_ will display the _helptext_.
#===============================================================================
module UIHelper
# Letter by letter display of the message _msg_ by the window _helpwindow_.
def self.pbDisplay(helpwindow,msg,brief)
cw = helpwindow
oldvisible = cw.visible
cw.letterbyletter = true
cw.text = msg+"\1"
cw.visible = true
pbBottomLeftLines(cw,2)
loop do
Graphics.update
Input.update
(block_given?) ? yield : cw.update
if !cw.busy?
if brief || (Input.trigger?(Input::USE) && cw.resume)
break
end
end
end
cw.visible = oldvisible
end
def self.pbDisplayStatic(msgwindow,message)
oldvisible = msgwindow.visible
msgwindow.visible = true
msgwindow.letterbyletter = false
msgwindow.width = Graphics.width
msgwindow.resizeHeightToFit(message,Graphics.width)
msgwindow.text = message
pbBottomRight(msgwindow)
loop do
Graphics.update
Input.update
(block_given?) ? yield : msgwindow.update
if Input.trigger?(Input::BACK) || Input.trigger?(Input::USE)
break
end
end
msgwindow.visible = oldvisible
Input.update
end
# Letter by letter display of the message _msg_ by the window _helpwindow_,
# used to ask questions. Returns true if the user chose yes, false if no.
def self.pbConfirm(helpwindow,msg)
dw = helpwindow
oldvisible = dw.visible
dw.letterbyletter = true
dw.text = msg
dw.visible = true
pbBottomLeftLines(dw,2)
commands = [_INTL("Yes"),_INTL("No")]
cw = Window_CommandPokemon.new(commands)
cw.index = 0
cw.viewport = helpwindow.viewport
pbBottomRight(cw)
cw.y -= dw.height
ret = false
loop do
cw.visible = (!dw.busy?)
Graphics.update
Input.update
cw.update
(block_given?) ? yield : dw.update
if !dw.busy? && dw.resume
if Input.trigger?(Input::BACK)
pbPlayCancelSE
break
elsif Input.trigger?(Input::USE)
pbPlayDecisionSE
ret = (cw.index==0)
break
end
end
end
cw.dispose
dw.visible = oldvisible
return ret
end
def self.pbChooseNumber(helpwindow,helptext,maximum,initnum=1)
oldvisible = helpwindow.visible
helpwindow.visible = true
helpwindow.text = helptext
helpwindow.letterbyletter = false
curnumber = initnum
ret = 0
numwindow = Window_UnformattedTextPokemon.new("x000")
numwindow.viewport = helpwindow.viewport
numwindow.letterbyletter = false
numwindow.text = _ISPRINTF("x{1:03d}",curnumber)
numwindow.resizeToFit(numwindow.text,Graphics.width)
pbBottomRight(numwindow)
helpwindow.resizeHeightToFit(helpwindow.text,Graphics.width-numwindow.width)
pbBottomLeft(helpwindow)
loop do
Graphics.update
Input.update
numwindow.update
helpwindow.update
if Input.trigger?(Input::BACK)
ret = 0
pbPlayCancelSE
break
elsif Input.trigger?(Input::USE)
ret = curnumber
pbPlayDecisionSE
break
elsif Input.repeat?(Input::UP)
curnumber += 1
curnumber = 1 if curnumber>maximum
numwindow.text = _ISPRINTF("x{1:03d}",curnumber)
pbPlayCursorSE
elsif Input.repeat?(Input::DOWN)
curnumber -= 1
curnumber = maximum if curnumber<1
numwindow.text = _ISPRINTF("x{1:03d}",curnumber)
pbPlayCursorSE
elsif Input.repeat?(Input::LEFT)
curnumber -= 10
curnumber = 1 if curnumber<1
numwindow.text = _ISPRINTF("x{1:03d}",curnumber)
pbPlayCursorSE
elsif Input.repeat?(Input::RIGHT)
curnumber += 10
curnumber = maximum if curnumber>maximum
numwindow.text = _ISPRINTF("x{1:03d}",curnumber)
pbPlayCursorSE
end
end
numwindow.dispose
helpwindow.visible = oldvisible
return ret
end
def self.pbShowCommands(helpwindow,helptext,commands,initcmd=0)
ret = -1
oldvisible = helpwindow.visible
helpwindow.visible = helptext ? true : false
helpwindow.letterbyletter = false
helpwindow.text = helptext ? helptext : ""
cmdwindow = Window_CommandPokemon.new(commands)
cmdwindow.index = initcmd
begin
cmdwindow.viewport = helpwindow.viewport
pbBottomRight(cmdwindow)
helpwindow.resizeHeightToFit(helpwindow.text,Graphics.width-cmdwindow.width)
pbBottomLeft(helpwindow)
loop do
Graphics.update
Input.update
yield
cmdwindow.update
if Input.trigger?(Input::BACK)
ret = -1
pbPlayCancelSE
break
end
if Input.trigger?(Input::USE)
ret = cmdwindow.index
pbPlayDecisionSE
break
end
end
ensure
cmdwindow.dispose if cmdwindow
end
helpwindow.visible = oldvisible
return ret
end
end

259
Data/Scripts/016_UI/019_UI_PC.rb Normal file
View File

@@ -0,0 +1,259 @@
#===============================================================================
#
#===============================================================================
class TrainerPC
def shouldShow?
return true
end
def name
return _INTL("{1}'s PC",$Trainer.name)
end
def access
pbMessage(_INTL("\\se[PC access]Accessed {1}'s PC.",$Trainer.name))
pbTrainerPCMenu
end
end
#===============================================================================
#
#===============================================================================
class StorageSystemPC
def shouldShow?
return true
end
def name
if $Trainer.seen_storage_creator
return _INTL("{1}'s PC",pbGetStorageCreator)
else
return _INTL("Someone's PC")
end
end
def access
pbMessage(_INTL("\\se[PC access]The Pokémon Storage System was opened."))
command = 0
loop do
command = pbShowCommandsWithHelp(nil,
[_INTL("Organize Boxes"),
_INTL("Withdraw Pokémon"),
_INTL("Deposit Pokémon"),
_INTL("See ya!")],
[_INTL("Organize the Pokémon in Boxes and in your party."),
_INTL("Move Pokémon stored in Boxes to your party."),
_INTL("Store Pokémon in your party in Boxes."),
_INTL("Return to the previous menu.")],-1,command
)
if command>=0 && command<3
if command==1 # Withdraw
if $PokemonStorage.party_full?
pbMessage(_INTL("Your party is full!"))
next
end
elsif command==2 # Deposit
count=0
for p in $PokemonStorage.party
count += 1 if p && !p.egg? && p.hp>0
end
if count<=1
pbMessage(_INTL("Can't deposit the last Pokémon!"))
next
end
end
pbFadeOutIn {
scene = PokemonStorageScene.new
screen = PokemonStorageScreen.new(scene,$PokemonStorage)
screen.pbStartScreen(command)
}
else
break
end
end
end
end
#===============================================================================
#
#===============================================================================
module PokemonPCList
@@pclist = []
def self.registerPC(pc)
@@pclist.push(pc)
end
def self.getCommandList
commands = []
for pc in @@pclist
commands.push(pc.name) if pc.shouldShow?
end
commands.push(_INTL("Log Off"))
return commands
end
def self.callCommand(cmd)
return false if cmd<0 || cmd>=@@pclist.length
i = 0
for pc in @@pclist
next if !pc.shouldShow?
if i==cmd
pc.access
return true
end
i += 1
end
return false
end
end
#===============================================================================
# PC menus
#===============================================================================
def pbPCItemStorage
command = 0
loop do
command = pbShowCommandsWithHelp(nil,
[_INTL("Withdraw Item"),
_INTL("Deposit Item"),
_INTL("Toss Item"),
_INTL("Exit")],
[_INTL("Take out items from the PC."),
_INTL("Store items in the PC."),
_INTL("Throw away items stored in the PC."),
_INTL("Go back to the previous menu.")],-1,command
)
case command
when 0 # Withdraw Item
if !$PokemonGlobal.pcItemStorage
$PokemonGlobal.pcItemStorage = PCItemStorage.new
end
if $PokemonGlobal.pcItemStorage.empty?
pbMessage(_INTL("There are no items."))
else
pbFadeOutIn {
scene = WithdrawItemScene.new
screen = PokemonBagScreen.new(scene,$PokemonBag)
screen.pbWithdrawItemScreen
}
end
when 1 # Deposit Item
pbFadeOutIn {
scene = PokemonBag_Scene.new
screen = PokemonBagScreen.new(scene,$PokemonBag)
screen.pbDepositItemScreen
}
when 2 # Toss Item
if !$PokemonGlobal.pcItemStorage
$PokemonGlobal.pcItemStorage = PCItemStorage.new
end
if $PokemonGlobal.pcItemStorage.empty?
pbMessage(_INTL("There are no items."))
else
pbFadeOutIn {
scene = TossItemScene.new
screen = PokemonBagScreen.new(scene,$PokemonBag)
screen.pbTossItemScreen
}
end
else
break
end
end
end
def pbPCMailbox
if !$PokemonGlobal.mailbox || $PokemonGlobal.mailbox.length==0
pbMessage(_INTL("There's no Mail here."))
else
loop do
command = 0
commands=[]
for mail in $PokemonGlobal.mailbox
commands.push(mail.sender)
end
commands.push(_INTL("Cancel"))
command = pbShowCommands(nil,commands,-1,command)
if command>=0 && command<$PokemonGlobal.mailbox.length
mailIndex = command
commandMail = pbMessage(_INTL("What do you want to do with {1}'s Mail?",
$PokemonGlobal.mailbox[mailIndex].sender),[
_INTL("Read"),
_INTL("Move to Bag"),
_INTL("Give"),
_INTL("Cancel")
],-1)
case commandMail
when 0 # Read
pbFadeOutIn {
pbDisplayMail($PokemonGlobal.mailbox[mailIndex])
}
when 1 # Move to Bag
if pbConfirmMessage(_INTL("The message will be lost. Is that OK?"))
if $PokemonBag.pbStoreItem($PokemonGlobal.mailbox[mailIndex].item)
pbMessage(_INTL("The Mail was returned to the Bag with its message erased."))
$PokemonGlobal.mailbox.delete_at(mailIndex)
else
pbMessage(_INTL("The Bag is full."))
end
end
when 2 # Give
pbFadeOutIn {
sscene = PokemonParty_Scene.new
sscreen = PokemonPartyScreen.new(sscene,$Trainer.party)
sscreen.pbPokemonGiveMailScreen(mailIndex)
}
end
else
break
end
end
end
end
def pbTrainerPCMenu
command = 0
loop do
command = pbMessage(_INTL("What do you want to do?"),[
_INTL("Item Storage"),
_INTL("Mailbox"),
_INTL("Turn Off")
],-1,nil,command)
case command
when 0 then pbPCItemStorage
when 1 then pbPCMailbox
else break
end
end
end
def pbTrainerPC
pbMessage(_INTL("\\se[PC open]{1} booted up the PC.",$Trainer.name))
pbTrainerPCMenu
pbSEPlay("PC close")
end
def pbPokeCenterPC
pbMessage(_INTL("\\se[PC open]{1} booted up the PC.",$Trainer.name))
command = 0
loop do
commands = PokemonPCList.getCommandList
command = pbMessage(_INTL("Which PC should be accessed?"),commands,
commands.length,nil,command)
break if !PokemonPCList.callCommand(command)
end
pbSEPlay("PC close")
end
def pbGetStorageCreator
creator = Settings.storage_creator_name
creator = _INTL("Bill") if !creator || creator==""
return creator
end
#===============================================================================
#
#===============================================================================
PokemonPCList.registerPC(StorageSystemPC.new)
PokemonPCList.registerPC(TrainerPC.new)

683
Data/Scripts/016_UI/020_UI_PokeMart.rb Normal file
View File

@@ -0,0 +1,683 @@
#===============================================================================
# Abstraction layer for Pokemon Essentials
#===============================================================================
class PokemonMartAdapter
def getMoney
return $Trainer.money
end
def getMoneyString
return pbGetGoldString
end
def setMoney(value)
$Trainer.money=value
end
def getInventory
return $PokemonBag
end
def getName(item)
return GameData::Item.get(item).name
end
def getDisplayName(item)
item_name = getName(item)
if GameData::Item.get(item).is_machine?
machine = GameData::Item.get(item).move
item_name = _INTL("{1} {2}", item_name, GameData::Move.get(machine).name)
end
return item_name
end
def getDescription(item)
return GameData::Item.get(item).description
end
def getItemIcon(item)
return (item) ? GameData::Item.icon_filename(item) : nil
end
# Unused
def getItemIconRect(_item)
return Rect.new(0, 0, 48, 48)
end
def getQuantity(item)
return $PokemonBag.pbQuantity(item)
end
def showQuantity?(item)
return !GameData::Item.get(item).is_important?
end
def getPrice(item, selling = false)
if $game_temp.mart_prices && $game_temp.mart_prices[item]
if selling
return $game_temp.mart_prices[item][1] if $game_temp.mart_prices[item][1] >= 0
else
return $game_temp.mart_prices[item][0] if $game_temp.mart_prices[item][0] > 0
end
end
return GameData::Item.get(item).price
end
def getDisplayPrice(item, selling = false)
price = getPrice(item, selling).to_s_formatted
return _INTL("$ {1}", price)
end
def canSell?(item)
return getPrice(item, true) > 0 && !GameData::Item.get(item).is_important?
end
def addItem(item)
return $PokemonBag.pbStoreItem(item)
end
def removeItem(item)
return $PokemonBag.pbDeleteItem(item)
end
end
#===============================================================================
# Buy and Sell adapters
#===============================================================================
class BuyAdapter
def initialize(adapter)
@adapter = adapter
end
def getDisplayName(item)
@adapter.getDisplayName(item)
end
def getDisplayPrice(item)
@adapter.getDisplayPrice(item, false)
end
def isSelling?
return false
end
end
#===============================================================================
#
#===============================================================================
class SellAdapter
def initialize(adapter)
@adapter = adapter
end
def getDisplayName(item)
@adapter.getDisplayName(item)
end
def getDisplayPrice(item)
if @adapter.showQuantity?(item)
return sprintf("x%d", @adapter.getQuantity(item))
else
return ""
end
end
def isSelling?
return true
end
end
#===============================================================================
# Pokémon Mart
#===============================================================================
class Window_PokemonMart < Window_DrawableCommand
def initialize(stock, adapter, x, y, width, height, viewport = nil)
@stock = stock
@adapter = adapter
super(x, y, width, height, viewport)
@selarrow = AnimatedBitmap.new("Graphics/Pictures/martSel")
@baseColor = Color.new(88,88,80)
@shadowColor = Color.new(168,184,184)
self.windowskin = nil
end
def itemCount
return @stock.length + 1
end
def item
return (self.index >= @stock.length) ? nil : @stock[self.index]
end
def drawItem(index, count, rect)
textpos = []
rect = drawCursor(index, rect)
ypos = rect.y
if index == count-1
textpos.push([_INTL("CANCEL"), rect.x, ypos - 4, false, self.baseColor, self.shadowColor])
else
item = @stock[index]
itemname = @adapter.getDisplayName(item)
qty = @adapter.getDisplayPrice(item)
sizeQty = self.contents.text_size(qty).width
xQty = rect.x + rect.width - sizeQty - 2 - 16
textpos.push([itemname, rect.x, ypos - 4, false, self.baseColor, self.shadowColor])
textpos.push([qty, xQty, ypos - 4, false, self.baseColor, self.shadowColor])
end
pbDrawTextPositions(self.contents, textpos)
end
end
#===============================================================================
#
#===============================================================================
class PokemonMart_Scene
def update
pbUpdateSpriteHash(@sprites)
@subscene.pbUpdate if @subscene
end
def pbRefresh
if @subscene
@subscene.pbRefresh
else
itemwindow = @sprites["itemwindow"]
@sprites["icon"].item = itemwindow.item
@sprites["itemtextwindow"].text =
(itemwindow.item) ? @adapter.getDescription(itemwindow.item) : _INTL("Quit shopping.")
itemwindow.refresh
end
@sprites["moneywindow"].text = _INTL("Money:\r\n<r>{1}", @adapter.getMoneyString)
end
def pbStartBuyOrSellScene(buying, stock, adapter)
# Scroll right before showing screen
pbScrollMap(6, 5, 5)
@viewport = Viewport.new(0, 0, Graphics.width, Graphics.height)
@viewport.z = 99999
@stock = stock
@adapter = adapter
@sprites = {}
@sprites["background"] = IconSprite.new(0, 0, @viewport)
@sprites["background"].setBitmap("Graphics/Pictures/martScreen")
@sprites["icon"] = ItemIconSprite.new(36, Graphics.height - 50, nil, @viewport)
winAdapter = buying ? BuyAdapter.new(adapter) : SellAdapter.new(adapter)
@sprites["itemwindow"] = Window_PokemonMart.new(stock, winAdapter,
Graphics.width - 316 - 16, 12, 330 + 16, Graphics.height - 126)
@sprites["itemwindow"].viewport = @viewport
@sprites["itemwindow"].index = 0
@sprites["itemwindow"].refresh
@sprites["itemtextwindow"] = Window_UnformattedTextPokemon.newWithSize("",
64, Graphics.height - 96 - 16, Graphics.width - 64, 128, @viewport)
pbPrepareWindow(@sprites["itemtextwindow"])
@sprites["itemtextwindow"].baseColor = Color.new(248, 248, 248)
@sprites["itemtextwindow"].shadowColor = Color.new(0, 0, 0)
@sprites["itemtextwindow"].windowskin = nil
@sprites["helpwindow"] = Window_AdvancedTextPokemon.new("")
pbPrepareWindow(@sprites["helpwindow"])
@sprites["helpwindow"].visible = false
@sprites["helpwindow"].viewport = @viewport
pbBottomLeftLines(@sprites["helpwindow"], 1)
@sprites["moneywindow"] = Window_AdvancedTextPokemon.new("")
pbPrepareWindow(@sprites["moneywindow"])
@sprites["moneywindow"].setSkin("Graphics/Windowskins/goldskin")
@sprites["moneywindow"].visible = true
@sprites["moneywindow"].viewport = @viewport
@sprites["moneywindow"].x = 0
@sprites["moneywindow"].y = 0
@sprites["moneywindow"].width = 190
@sprites["moneywindow"].height = 96
@sprites["moneywindow"].baseColor = Color.new(88, 88, 80)
@sprites["moneywindow"].shadowColor = Color.new(168, 184, 184)
pbDeactivateWindows(@sprites)
@buying = buying
pbRefresh
Graphics.frame_reset
end
def pbStartBuyScene(stock, adapter)
pbStartBuyOrSellScene(true, stock, adapter)
end
def pbStartSellScene(bag, adapter)
if $PokemonBag
pbStartSellScene2(bag, adapter)
else
pbStartBuyOrSellScene(false, bag, adapter)
end
end
def pbStartSellScene2(bag, adapter)
@subscene = PokemonBag_Scene.new
@adapter = adapter
@viewport2 = Viewport.new(0, 0, Graphics.width, Graphics.height)
@viewport2.z = 99999
numFrames = Graphics.frame_rate * 4 / 10
alphaDiff = (255.0 / numFrames).ceil
for j in 0..numFrames
col = Color.new(0, 0, 0, j * alphaDiff)
@viewport2.color = col
Graphics.update
Input.update
end
@subscene.pbStartScene(bag)
@viewport = Viewport.new(0, 0, Graphics.width, Graphics.height)
@viewport.z = 99999
@sprites = {}
@sprites["helpwindow"] = Window_AdvancedTextPokemon.new("")
pbPrepareWindow(@sprites["helpwindow"])
@sprites["helpwindow"].visible = false
@sprites["helpwindow"].viewport = @viewport
pbBottomLeftLines(@sprites["helpwindow"], 1)
@sprites["moneywindow"] = Window_AdvancedTextPokemon.new("")
pbPrepareWindow(@sprites["moneywindow"])
@sprites["moneywindow"].setSkin("Graphics/Windowskins/goldskin")
@sprites["moneywindow"].visible = false
@sprites["moneywindow"].viewport = @viewport
@sprites["moneywindow"].x = 0
@sprites["moneywindow"].y = 0
@sprites["moneywindow"].width = 186
@sprites["moneywindow"].height = 96
@sprites["moneywindow"].baseColor = Color.new(88, 88, 80)
@sprites["moneywindow"].shadowColor = Color.new(168, 184, 184)
pbDeactivateWindows(@sprites)
@buying = false
pbRefresh
end
def pbEndBuyScene
pbDisposeSpriteHash(@sprites)
@viewport.dispose
# Scroll left after showing screen
pbScrollMap(4, 5, 5)
end
def pbEndSellScene
@subscene.pbEndScene if @subscene
pbDisposeSpriteHash(@sprites)
if @viewport2
numFrames = Graphics.frame_rate * 4 / 10
alphaDiff = (255.0 / numFrames).ceil
for j in 0..numFrames
col = Color.new(0, 0, 0, (numFrames - j) * alphaDiff)
@viewport2.color = col
Graphics.update
Input.update
end
@viewport2.dispose
end
@viewport.dispose
pbScrollMap(4, 5, 5) if !@subscene
end
def pbPrepareWindow(window)
window.visible = true
window.letterbyletter = false
end
def pbShowMoney
pbRefresh
@sprites["moneywindow"].visible = true
end
def pbHideMoney
pbRefresh
@sprites["moneywindow"].visible = false
end
def pbDisplay(msg, brief = false)
cw = @sprites["helpwindow"]
cw.letterbyletter = true
cw.text = msg
pbBottomLeftLines(cw, 2)
cw.visible = true
i = 0
pbPlayDecisionSE
loop do
Graphics.update
Input.update
self.update
if !cw.busy?
return if brief
pbRefresh if i == 0
end
if Input.trigger?(Input::USE) && cw.busy?
cw.resume
end
return if i >= Graphics.frame_rate * 3 / 2
i += 1 if !cw.busy?
end
end
def pbDisplayPaused(msg)
cw = @sprites["helpwindow"]
cw.letterbyletter = true
cw.text = msg
pbBottomLeftLines(cw, 2)
cw.visible = true
yielded = false
pbPlayDecisionSE
loop do
Graphics.update
Input.update
wasbusy = cw.busy?
self.update
if !cw.busy? && !yielded
yield if block_given? # For playing SE as soon as the message is all shown
yielded = true
end
pbRefresh if !cw.busy? && wasbusy
if Input.trigger?(Input::USE) && cw.resume && !cw.busy?
@sprites["helpwindow"].visible = false
return
end
end
end
def pbConfirm(msg)
dw = @sprites["helpwindow"]
dw.letterbyletter = true
dw.text = msg
dw.visible = true
pbBottomLeftLines(dw, 2)
commands = [_INTL("Yes"), _INTL("No")]
cw = Window_CommandPokemon.new(commands)
cw.viewport = @viewport
pbBottomRight(cw)
cw.y -= dw.height
cw.index = 0
pbPlayDecisionSE
loop do
cw.visible = !dw.busy?
Graphics.update
Input.update
cw.update
self.update
if Input.trigger?(Input::BACK) && dw.resume && !dw.busy?
cw.dispose
@sprites["helpwindow"].visible = false
return false
end
if Input.trigger?(Input::USE) && dw.resume && !dw.busy?
cw.dispose
@sprites["helpwindow"].visible = false
return (cw.index == 0)
end
end
end
def pbChooseNumber(helptext,item,maximum)
curnumber = 1
ret = 0
helpwindow = @sprites["helpwindow"]
itemprice = @adapter.getPrice(item, !@buying)
itemprice /= 2 if !@buying
pbDisplay(helptext, true)
using (numwindow = Window_AdvancedTextPokemon.new("")) { # Showing number of items
qty = @adapter.getQuantity(item)
using (inbagwindow = Window_AdvancedTextPokemon.new("")) { # Showing quantity in bag
pbPrepareWindow(numwindow)
pbPrepareWindow(inbagwindow)
numwindow.viewport = @viewport
numwindow.width = 224
numwindow.height = 64
numwindow.baseColor = Color.new(88, 88, 80)
numwindow.shadowColor = Color.new(168, 184, 184)
inbagwindow.visible = @buying
inbagwindow.viewport = @viewport
inbagwindow.width = 190
inbagwindow.height = 64
inbagwindow.baseColor = Color.new(88, 88, 80)
inbagwindow.shadowColor = Color.new(168, 184, 184)
inbagwindow.text = _INTL("In Bag:<r>{1} ", qty)
numwindow.text = _INTL("x{1}<r>$ {2}", curnumber, (curnumber * itemprice).to_s_formatted)
pbBottomRight(numwindow)
numwindow.y -= helpwindow.height
pbBottomLeft(inbagwindow)
inbagwindow.y -= helpwindow.height
loop do
Graphics.update
Input.update
numwindow.update
inbagwindow.update
self.update
if Input.repeat?(Input::LEFT)
pbPlayCursorSE
curnumber -= 10
curnumber = 1 if curnumber < 1
numwindow.text = _INTL("x{1}<r>$ {2}", curnumber, (curnumber * itemprice).to_s_formatted)
elsif Input.repeat?(Input::RIGHT)
pbPlayCursorSE
curnumber += 10
curnumber = maximum if curnumber > maximum
numwindow.text = _INTL("x{1}<r>$ {2}", curnumber, (curnumber * itemprice).to_s_formatted)
elsif Input.repeat?(Input::UP)
pbPlayCursorSE
curnumber += 1
curnumber = 1 if curnumber > maximum
numwindow.text = _INTL("x{1}<r>$ {2}", curnumber, (curnumber * itemprice).to_s_formatted)
elsif Input.repeat?(Input::DOWN)
pbPlayCursorSE
curnumber -= 1
curnumber = maximum if curnumber < 1
numwindow.text = _INTL("x{1}<r>$ {2}", curnumber, (curnumber * itemprice).to_s_formatted)
elsif Input.trigger?(Input::USE)
pbPlayDecisionSE
ret = curnumber
break
elsif Input.trigger?(Input::BACK)
pbPlayCancelSE
ret = 0
break
end
end
}
}
helpwindow.visible = false
return ret
end
def pbChooseBuyItem
itemwindow = @sprites["itemwindow"]
@sprites["helpwindow"].visible = false
pbActivateWindow(@sprites, "itemwindow") {
pbRefresh
loop do
Graphics.update
Input.update
olditem = itemwindow.item
self.update
if itemwindow.item != olditem
@sprites["icon"].item = itemwindow.item
@sprites["itemtextwindow"].text =
(itemwindow.item) ? @adapter.getDescription(itemwindow.item) : _INTL("Quit shopping.")
end
if Input.trigger?(Input::BACK)
pbPlayCloseMenuSE
return nil
elsif Input.trigger?(Input::USE)
if itemwindow.index < @stock.length
pbRefresh
return @stock[itemwindow.index]
else
return nil
end
end
end
}
end
def pbChooseSellItem
if @subscene
return @subscene.pbChooseItem
else
return pbChooseBuyItem
end
end
end
#===============================================================================
#
#===============================================================================
class PokemonMartScreen
def initialize(scene,stock)
@scene=scene
@stock=stock
@adapter=PokemonMartAdapter.new
end
def pbConfirm(msg)
return @scene.pbConfirm(msg)
end
def pbDisplay(msg)
return @scene.pbDisplay(msg)
end
def pbDisplayPaused(msg,&block)
return @scene.pbDisplayPaused(msg,&block)
end
def pbBuyScreen
@scene.pbStartBuyScene(@stock,@adapter)
item=nil
loop do
item=@scene.pbChooseBuyItem
break if !item
quantity=0
itemname=@adapter.getDisplayName(item)
price=@adapter.getPrice(item)
if @adapter.getMoney<price
pbDisplayPaused(_INTL("You don't have enough money."))
next
end
if GameData::Item.get(item).is_important?
if !pbConfirm(_INTL("Certainly. You want {1}. That will be ${2}. OK?",
itemname,price.to_s_formatted))
next
end
quantity=1
else
maxafford = (price <= 0) ? Settings::BAG_MAX_PER_SLOT : @adapter.getMoney / price
maxafford = Settings::BAG_MAX_PER_SLOT if maxafford > Settings::BAG_MAX_PER_SLOT
quantity=@scene.pbChooseNumber(
_INTL("{1}? Certainly. How many would you like?",itemname),item,maxafford)
next if quantity==0
price*=quantity
if !pbConfirm(_INTL("{1}, and you want {2}. That will be ${3}. OK?",
itemname,quantity,price.to_s_formatted))
next
end
end
if @adapter.getMoney<price
pbDisplayPaused(_INTL("You don't have enough money."))
next
end
added=0
quantity.times do
break if !@adapter.addItem(item)
added+=1
end
if added!=quantity
added.times do
if !@adapter.removeItem(item)
raise _INTL("Failed to delete stored items")
end
end
pbDisplayPaused(_INTL("You have no more room in the Bag."))
else
@adapter.setMoney(@adapter.getMoney-price)
for i in 0...@stock.length
if GameData::Item.get(@stock[i]).is_important? && $PokemonBag.pbHasItem?(@stock[i])
@stock[i]=nil
end
end
@stock.compact!
pbDisplayPaused(_INTL("Here you are! Thank you!")) { pbSEPlay("Mart buy item") }
if $PokemonBag
if quantity>=10 && GameData::Item.get(item).is_poke_ball? && GameData::Item.exists?(:PREMIERBALL)
if @adapter.addItem(GameData::Item.get(:PREMIERBALL))
pbDisplayPaused(_INTL("I'll throw in a Premier Ball, too."))
end
end
end
end
end
@scene.pbEndBuyScene
end
def pbSellScreen
item=@scene.pbStartSellScene(@adapter.getInventory,@adapter)
loop do
item=@scene.pbChooseSellItem
break if !item
itemname=@adapter.getDisplayName(item)
price=@adapter.getPrice(item,true)
if !@adapter.canSell?(item)
pbDisplayPaused(_INTL("{1}? Oh, no. I can't buy that.",itemname))
next
end
qty=@adapter.getQuantity(item)
next if qty==0
@scene.pbShowMoney
if qty>1
qty=@scene.pbChooseNumber(
_INTL("{1}? How many would you like to sell?",itemname),item,qty)
end
if qty==0
@scene.pbHideMoney
next
end
price/=2
price*=qty
if pbConfirm(_INTL("I can pay ${1}. Would that be OK?",price.to_s_formatted))
@adapter.setMoney(@adapter.getMoney+price)
qty.times do
@adapter.removeItem(item)
end
pbDisplayPaused(_INTL("Turned over the {1} and received ${2}.",itemname,price.to_s_formatted)) { pbSEPlay("Mart buy item") }
@scene.pbRefresh
end
@scene.pbHideMoney
end
@scene.pbEndSellScene
end
end
#===============================================================================
#
#===============================================================================
def pbPokemonMart(stock,speech=nil,cantsell=false)
for i in 0...stock.length
stock[i] = GameData::Item.get(stock[i]).id
stock[i] = nil if GameData::Item.get(stock[i]).is_important? && $PokemonBag.pbHasItem?(stock[i])
end
stock.compact!
commands = []
cmdBuy = -1
cmdSell = -1
cmdQuit = -1
commands[cmdBuy = commands.length] = _INTL("Buy")
commands[cmdSell = commands.length] = _INTL("Sell") if !cantsell
commands[cmdQuit = commands.length] = _INTL("Quit")
cmd = pbMessage(
speech ? speech : _INTL("Welcome! How may I serve you?"),
commands,cmdQuit+1)
loop do
if cmdBuy>=0 && cmd==cmdBuy
scene = PokemonMart_Scene.new
screen = PokemonMartScreen.new(scene,stock)
screen.pbBuyScreen
elsif cmdSell>=0 && cmd==cmdSell
scene = PokemonMart_Scene.new
screen = PokemonMartScreen.new(scene,stock)
screen.pbSellScreen
else
pbMessage(_INTL("Please come again!"))
break
end
cmd = pbMessage(_INTL("Is there anything else I can help you with?"),
commands,cmdQuit+1)
end
$game_temp.clear_mart_prices
end

203
Data/Scripts/016_UI/021_UI_MoveRelearner.rb Normal file
View File

@@ -0,0 +1,203 @@
#===============================================================================
# Scene class for handling appearance of the screen
#===============================================================================
class MoveRelearner_Scene
VISIBLEMOVES = 4
def pbDisplay(msg,brief=false)
UIHelper.pbDisplay(@sprites["msgwindow"],msg,brief) { pbUpdate }
end
def pbConfirm(msg)
UIHelper.pbConfirm(@sprites["msgwindow"],msg) { pbUpdate }
end
def pbUpdate
pbUpdateSpriteHash(@sprites)
end
def pbStartScene(pokemon,moves)
@pokemon=pokemon
@moves=moves
moveCommands=[]
moves.each { |m| moveCommands.push(GameData::Move.get(m).name) }
# Create sprite hash
@viewport=Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z=99999
@sprites={}
addBackgroundPlane(@sprites,"bg","reminderbg",@viewport)
@sprites["pokeicon"]=PokemonIconSprite.new(@pokemon,@viewport)
@sprites["pokeicon"].setOffset(PictureOrigin::Center)
@sprites["pokeicon"].x=320
@sprites["pokeicon"].y=84
@sprites["background"]=IconSprite.new(0,0,@viewport)
@sprites["background"].setBitmap("Graphics/Pictures/reminderSel")
@sprites["background"].y=78
@sprites["background"].src_rect=Rect.new(0,72,258,72)
@sprites["overlay"]=BitmapSprite.new(Graphics.width,Graphics.height,@viewport)
pbSetSystemFont(@sprites["overlay"].bitmap)
@sprites["commands"]=Window_CommandPokemon.new(moveCommands,32)
@sprites["commands"].height=32*(VISIBLEMOVES+1)
@sprites["commands"].visible=false
@sprites["msgwindow"]=Window_AdvancedTextPokemon.new("")
@sprites["msgwindow"].visible=false
@sprites["msgwindow"].viewport=@viewport
@typebitmap=AnimatedBitmap.new(_INTL("Graphics/Pictures/types"))
pbDrawMoveList
pbDeactivateWindows(@sprites)
# Fade in all sprites
pbFadeInAndShow(@sprites) { pbUpdate }
end
def pbDrawMoveList
overlay=@sprites["overlay"].bitmap
overlay.clear
type1_number = GameData::Type.get(@pokemon.type1).id_number
type2_number = GameData::Type.get(@pokemon.type2).id_number
type1rect=Rect.new(0, type1_number * 28, 64, 28)
type2rect=Rect.new(0, type2_number * 28, 64, 28)
if @pokemon.type1==@pokemon.type2
overlay.blt(400,70,@typebitmap.bitmap,type1rect)
else
overlay.blt(366,70,@typebitmap.bitmap,type1rect)
overlay.blt(436,70,@typebitmap.bitmap,type2rect)
end
textpos=[
[_INTL("Teach which move?"),16,2,0,Color.new(88,88,80),Color.new(168,184,184)]
]
imagepos=[]
yPos=76
for i in 0...VISIBLEMOVES
moveobject=@moves[@sprites["commands"].top_item+i]
if moveobject
moveData=GameData::Move.get(moveobject)
type_number = GameData::Type.get(moveData.type).id_number
imagepos.push(["Graphics/Pictures/types", 12, yPos + 8, 0, type_number * 28, 64, 28])
textpos.push([moveData.name,80,yPos,0,Color.new(248,248,248),Color.new(0,0,0)])
if moveData.total_pp>0
textpos.push([_INTL("PP"),112,yPos+32,0,Color.new(64,64,64),Color.new(176,176,176)])
textpos.push([_INTL("{1}/{1}",moveData.total_pp),230,yPos+32,1,
Color.new(64,64,64),Color.new(176,176,176)])
else
textpos.push(["-",80,yPos,0,Color.new(64,64,64),Color.new(176,176,176)])
textpos.push(["--",228,yPos+32,1,Color.new(64,64,64),Color.new(176,176,176)])
end
end
yPos+=64
end
imagepos.push(["Graphics/Pictures/reminderSel",
0,78+(@sprites["commands"].index-@sprites["commands"].top_item)*64,
0,0,258,72])
selMoveData=GameData::Move.get(@moves[@sprites["commands"].index])
basedamage=selMoveData.base_damage
category=selMoveData.category
accuracy=selMoveData.accuracy
textpos.push([_INTL("CATEGORY"),272,108,0,Color.new(248,248,248),Color.new(0,0,0)])
textpos.push([_INTL("POWER"),272,140,0,Color.new(248,248,248),Color.new(0,0,0)])
textpos.push([basedamage<=1 ? basedamage==1 ? "???" : "---" : sprintf("%d",basedamage),
468,140,2,Color.new(64,64,64),Color.new(176,176,176)])
textpos.push([_INTL("ACCURACY"),272,172,0,Color.new(248,248,248),Color.new(0,0,0)])
textpos.push([accuracy==0 ? "---" : "#{accuracy}%",
468,172,2,Color.new(64,64,64),Color.new(176,176,176)])
pbDrawTextPositions(overlay,textpos)
imagepos.push(["Graphics/Pictures/category",436,116,0,category*28,64,28])
if @sprites["commands"].index<@moves.length-1
imagepos.push(["Graphics/Pictures/reminderButtons",48,350,0,0,76,32])
end
if @sprites["commands"].index>0
imagepos.push(["Graphics/Pictures/reminderButtons",134,350,76,0,76,32])
end
pbDrawImagePositions(overlay,imagepos)
drawTextEx(overlay,272,210,230,5,selMoveData.description,
Color.new(64,64,64),Color.new(176,176,176))
end
# Processes the scene
def pbChooseMove
oldcmd=-1
pbActivateWindow(@sprites,"commands") {
loop do
oldcmd=@sprites["commands"].index
Graphics.update
Input.update
pbUpdate
if @sprites["commands"].index!=oldcmd
@sprites["background"].x=0
@sprites["background"].y=78+(@sprites["commands"].index-@sprites["commands"].top_item)*64
pbDrawMoveList
end
if Input.trigger?(Input::BACK)
return nil
elsif Input.trigger?(Input::USE)
return @moves[@sprites["commands"].index]
end
end
}
end
# End the scene here
def pbEndScene
pbFadeOutAndHide(@sprites) { pbUpdate }
pbDisposeSpriteHash(@sprites)
@typebitmap.dispose
@viewport.dispose
end
end
#===============================================================================
# Screen class for handling game logic
#===============================================================================
class MoveRelearnerScreen
def initialize(scene)
@scene = scene
end
def pbGetRelearnableMoves(pkmn)
return [] if !pkmn || pkmn.egg? || pkmn.shadowPokemon?
moves = []
pkmn.getMoveList.each do |m|
next if m[0] > pkmn.level || pkmn.hasMove?(m[1])
moves.push(m[1]) if !moves.include?(m[1])
end
tmoves = []
if pkmn.first_moves
for i in pkmn.first_moves
tmoves.push(i) if !pkmn.hasMove?(i) && !moves.include?(i)
end
end
moves = tmoves + moves
return moves | [] # remove duplicates
end
def pbStartScreen(pkmn)
moves = pbGetRelearnableMoves(pkmn)
@scene.pbStartScene(pkmn, moves)
loop do
move = @scene.pbChooseMove
if move
if @scene.pbConfirm(_INTL("Teach {1}?", GameData::Move.get(move).name))
if pbLearnMove(pkmn, move)
@scene.pbEndScene
return true
end
end
elsif @scene.pbConfirm(_INTL("Give up trying to teach a new move to {1}?", pkmn.name))
@scene.pbEndScene
return false
end
end
end
end
#===============================================================================
#
#===============================================================================
def pbRelearnMoveScreen(pkmn)
retval = true
pbFadeOutIn {
scene = MoveRelearner_Scene.new
screen = MoveRelearnerScreen.new(scene)
retval = screen.pbStartScreen(pkmn)
}
return retval
end

1360
Data/Scripts/016_UI/022_UI_PurifyChamber.rb Normal file
View File

File diff suppressed because it is too large Load Diff

418
Data/Scripts/016_UI/023_UI_MysteryGift.rb Normal file
View File

@@ -0,0 +1,418 @@
#===============================================================================
# Mystery Gift system
# By Maruno
#===============================================================================
# This url is the location of an example Mystery Gift file.
# You should change it to your file's url once you upload it.
# NOTE: Essentials cannot handle https addresses. You must use a http address.
#===============================================================================
module MysteryGift
URL = "https://pastebin.com/raw/w6BqqUsm"
end
#===============================================================================
# Creating a new Mystery Gift for the Master file, and editing an existing one.
#===============================================================================
# type: 0=Pokémon; 1 or higher=item (is the item's quantity).
# item: The thing being turned into a Mystery Gift (Pokémon object or item ID).
def pbEditMysteryGift(type,item,id=0,giftname="")
begin
if type==0 # Pokémon
commands=[_INTL("Mystery Gift"),
_INTL("Faraway place")]
commands.push(item.obtain_text) if item.obtain_text && !item.obtain_text.empty?
commands.push(_INTL("[Custom]"))
loop do
command=pbMessage(
_INTL("Choose a phrase to be where the gift Pokémon was obtained from."),commands,-1)
if command<0
return nil if pbConfirmMessage(_INTL("Stop editing this gift?"))
elsif command<commands.length-1
item.obtain_text = commands[command]
break
elsif command==commands.length-1
obtainname=pbMessageFreeText(_INTL("Enter a phrase."),"",false,30)
if obtainname!=""
item.obtain_text = obtainname
break
end
return nil if pbConfirmMessage(_INTL("Stop editing this gift?"))
end
end
elsif type>0 # Item
params=ChooseNumberParams.new
params.setRange(1,99999)
params.setDefaultValue(type)
params.setCancelValue(0)
loop do
newtype=pbMessageChooseNumber(_INTL("Choose a quantity of {1}.",
GameData::Item.get(item).name),params)
if newtype==0
return nil if pbConfirmMessage(_INTL("Stop editing this gift?"))
else
type=newtype
break
end
end
end
if id==0
master=[]
idlist=[]
if safeExists?("MysteryGiftMaster.txt")
master=IO.read("MysteryGiftMaster.txt")
master=pbMysteryGiftDecrypt(master)
end
for i in master; idlist.push(i[0]); end
params=ChooseNumberParams.new
params.setRange(0,99999)
params.setDefaultValue(id)
params.setCancelValue(0)
loop do
newid=pbMessageChooseNumber(_INTL("Choose a unique ID for this gift."),params)
if newid==0
return nil if pbConfirmMessage(_INTL("Stop editing this gift?"))
else
if idlist.include?(newid)
pbMessage(_INTL("That ID is already used by a Mystery Gift."))
else
id=newid
break
end
end
end
end
loop do
newgiftname=pbMessageFreeText(_INTL("Enter a name for the gift."),giftname,false,250)
if newgiftname!=""
giftname=newgiftname
break
end
return nil if pbConfirmMessage(_INTL("Stop editing this gift?"))
end
return [id,type,item,giftname]
rescue
pbMessage(_INTL("Couldn't edit the gift."))
return nil
end
end
def pbCreateMysteryGift(type,item)
gift=pbEditMysteryGift(type,item)
if !gift
pbMessage(_INTL("Didn't create a gift."))
else
begin
if safeExists?("MysteryGiftMaster.txt")
master=IO.read("MysteryGiftMaster.txt")
master=pbMysteryGiftDecrypt(master)
master.push(gift)
else
master=[gift]
end
string=pbMysteryGiftEncrypt(master)
File.open("MysteryGiftMaster.txt","wb") { |f| f.write(string) }
pbMessage(_INTL("The gift was saved to MysteryGiftMaster.txt."))
rescue
pbMessage(_INTL("Couldn't save the gift to MysteryGiftMaster.txt."))
end
end
end
#===============================================================================
# Debug option for managing gifts in the Master file and exporting them to a
# file to be uploaded.
#===============================================================================
def pbManageMysteryGifts
if !safeExists?("MysteryGiftMaster.txt")
pbMessage(_INTL("There are no Mystery Gifts defined."))
return
end
# Load all gifts from the Master file.
master=IO.read("MysteryGiftMaster.txt")
master=pbMysteryGiftDecrypt(master)
if !master || !master.is_a?(Array) || master.length==0
pbMessage(_INTL("There are no Mystery Gifts defined."))
return
end
# Download all gifts from online
msgwindow=pbCreateMessageWindow
pbMessageDisplay(msgwindow,_INTL("Searching for online gifts...\\wtnp[0]"))
online = pbDownloadToString(MysteryGift::URL)
pbDisposeMessageWindow(msgwindow)
if online==""
pbMessage(_INTL("No online Mystery Gifts found.\\wtnp[20]"))
online=[]
else
pbMessage(_INTL("Online Mystery Gifts found.\\wtnp[20]"))
online=pbMysteryGiftDecrypt(online)
t=[]
online.each { |gift| t.push(gift[0]) }
online=t
end
# Show list of all gifts.
command=0
loop do
commands=pbRefreshMGCommands(master,online)
command=pbMessage(_INTL("\\ts[]Manage Mystery Gifts (X=online)."),commands,-1,nil,command)
# Gift chosen
if command==-1 || command==commands.length-1 # Cancel
break
elsif command==commands.length-2 # Export selected to file
begin
newfile=[]
for gift in master
newfile.push(gift) if online.include?(gift[0])
end
string=pbMysteryGiftEncrypt(newfile)
File.open("MysteryGift.txt","wb") { |f| f.write(string) }
pbMessage(_INTL("The gifts were saved to MysteryGift.txt."))
pbMessage(_INTL("Upload MysteryGift.txt to the Internet."))
rescue
pbMessage(_INTL("Couldn't save the gifts to MysteryGift.txt."))
end
elsif command>=0 && command<commands.length-2 # A gift
cmd=0
loop do
commands=pbRefreshMGCommands(master,online)
gift=master[command]
cmds=[_INTL("Toggle on/offline"),
_INTL("Edit"),
_INTL("Receive"),
_INTL("Delete"),
_INTL("Cancel")]
cmd=pbMessage("\\ts[]"+commands[command],cmds,-1,nil,cmd)
if cmd==-1 || cmd==cmds.length-1
break
elsif cmd==0 # Toggle on/offline
if online.include?(gift[0])
for i in 0...online.length
online[i]=nil if online[i]==gift[0]
end
online.compact!
else
online.push(gift[0])
end
elsif cmd==1 # Edit
newgift=pbEditMysteryGift(gift[1],gift[2],gift[0],gift[3])
master[command]=newgift if newgift
elsif cmd==2 # Receive
replaced=false
for i in 0...$Trainer.mystery_gifts.length
if $Trainer.mystery_gifts[i][0]==gift[0]
$Trainer.mystery_gifts[i]=gift; replaced=true
end
end
$Trainer.mystery_gifts.push(gift) if !replaced
pbReceiveMysteryGift(gift[0])
elsif cmd==3 # Delete
if pbConfirmMessage(_INTL("Are you sure you want to delete this gift?"))
master[command]=nil
master.compact!
end
break
end
end
end
end
end
def pbRefreshMGCommands(master, online)
commands = []
for gift in master
itemname = "BLANK"
if gift[1] == 0
itemname = gift[2].speciesName
elsif gift[1] > 0
itemname = GameData::Item.get(gift[2]).name + sprintf(" x%d", gift[1])
end
ontext = ["[ ]", "[X]"][(online.include?(gift[0])) ? 1 : 0]
commands.push(_INTL("{1} {2}: {3} ({4})", ontext, gift[0], gift[3], itemname))
end
commands.push(_INTL("Export selected to file"))
commands.push(_INTL("Cancel"))
return commands
end
#===============================================================================
# Downloads all available Mystery Gifts that haven't been downloaded yet.
#===============================================================================
# Called from the Continue/New Game screen.
def pbDownloadMysteryGift(trainer)
sprites={}
viewport=Viewport.new(0,0,Graphics.width,Graphics.height)
viewport.z=99999
addBackgroundPlane(sprites,"background","mysteryGiftbg",viewport)
pbFadeInAndShow(sprites)
sprites["msgwindow"]=pbCreateMessageWindow
pbMessageDisplay(sprites["msgwindow"],_INTL("Searching for a gift.\nPlease wait...\\wtnp[0]"))
string = pbDownloadToString(MysteryGift::URL)
if string==""
pbMessageDisplay(sprites["msgwindow"],_INTL("No new gifts are available."))
else
online=pbMysteryGiftDecrypt(string)
pending=[]
for gift in online
notgot=true
for j in trainer.mystery_gifts
notgot=false if j[0]==gift[0]
end
pending.push(gift) if notgot
end
if pending.length==0
pbMessageDisplay(sprites["msgwindow"],_INTL("No new gifts are available."))
else
loop do
commands=[]
for gift in pending; commands.push(gift[3]); end
commands.push(_INTL("Cancel"))
pbMessageDisplay(sprites["msgwindow"],_INTL("Choose the gift you want to receive.\\wtnp[0]"))
command=pbShowCommands(sprites["msgwindow"],commands,-1)
if command==-1 || command==commands.length-1
break
else
gift=pending[command]
sprites["msgwindow"].visible=false
if gift[1]==0
sprite=PokemonSprite.new(viewport)
sprite.setOffset(PictureOrigin::Center)
sprite.setPokemonBitmap(gift[2])
sprite.x=Graphics.width/2
sprite.y=-sprite.bitmap.height/2
else
sprite=ItemIconSprite.new(0,0,gift[2],viewport)
sprite.x=Graphics.width/2
sprite.y=-sprite.height/2
end
distanceDiff = 8*20/Graphics.frame_rate
loop do
Graphics.update
Input.update
sprite.update
sprite.y+=distanceDiff
break if sprite.y>=Graphics.height/2
end
pbMEPlay("Battle capture success")
(Graphics.frame_rate*3).times do
Graphics.update
Input.update
sprite.update
pbUpdateSceneMap
end
sprites["msgwindow"].visible=true
pbMessageDisplay(sprites["msgwindow"],_INTL("The gift has been received!")) { sprite.update }
pbMessageDisplay(sprites["msgwindow"],_INTL("Please pick up your gift from the deliveryman in any Poké Mart.")) { sprite.update }
trainer.mystery_gifts.push(gift)
pending[command]=nil; pending.compact!
opacityDiff = 16*20/Graphics.frame_rate
loop do
Graphics.update
Input.update
sprite.update
sprite.opacity-=opacityDiff
break if sprite.opacity<=0
end
sprite.dispose
end
if pending.length==0
pbMessageDisplay(sprites["msgwindow"],_INTL("No new gifts are available."))
break
end
end
end
end
pbFadeOutAndHide(sprites)
pbDisposeMessageWindow(sprites["msgwindow"])
pbDisposeSpriteHash(sprites)
viewport.dispose
end
#===============================================================================
# Converts an array of gifts into a string and back.
#===============================================================================
def pbMysteryGiftEncrypt(gift)
ret=[Zlib::Deflate.deflate(Marshal.dump(gift))].pack("m")
return ret
end
def pbMysteryGiftDecrypt(gift)
return [] if gift==""
ret = Marshal.restore(Zlib::Inflate.inflate(gift.unpack("m")[0]))
if ret
ret.each do |gift|
if gift[1] == 0 # Pokémon
gift[2] = PokeBattle_Pokemon.convert(gift[2])
else # Item
gift[2] = GameData::Item.get(gift[2]).id
end
end
end
return ret
end
#===============================================================================
# Collecting a Mystery Gift from the deliveryman.
#===============================================================================
def pbNextMysteryGiftID
for i in $Trainer.mystery_gifts
return i[0] if i.length>1
end
return 0
end
def pbReceiveMysteryGift(id)
index=-1
for i in 0...$Trainer.mystery_gifts.length
if $Trainer.mystery_gifts[i][0]==id && $Trainer.mystery_gifts[i].length>1
index=i
break
end
end
if index==-1
pbMessage(_INTL("Couldn't find an unclaimed Mystery Gift with ID {1}.",id))
return false
end
gift=$Trainer.mystery_gifts[index]
if gift[1]==0 # Pokémon
gift[2].personalID = rand(2**16) | rand(2**16) << 16
gift[2].calc_stats
time=pbGetTimeNow
gift[2].timeReceived=time.getgm.to_i
gift[2].obtain_method = 4 # Fateful encounter
gift[2].record_first_moves
if $game_map
gift[2].obtain_map=$game_map.map_id
gift[2].obtain_level=gift[2].level
else
gift[2].obtain_map=0
gift[2].obtain_level=gift[2].level
end
if pbAddPokemonSilent(gift[2])
pbMessage(_INTL("\\me[Pkmn get]{1} received {2}!",$Trainer.name,gift[2].name))
$Trainer.mystery_gifts[index]=[id]
return true
end
elsif gift[1]>0 # Item
item=gift[2]
qty=gift[1]
if $PokemonBag.pbCanStore?(item,qty)
$PokemonBag.pbStoreItem(item,qty)
itm = GameData::Item.get(item)
itemname=(qty>1) ? itm.name_plural : itm.name
if item == :LEFTOVERS
pbMessage(_INTL("\\me[Item get]You obtained some \\c[1]{1}\\c[0]!\\wtnp[30]",itemname))
elsif itm.is_machine? # TM or HM
pbMessage(_INTL("\\me[Item get]You obtained \\c[1]{1} {2}\\c[0]!\\wtnp[30]",itemname,
GameData::Move.get(itm.move).name))
elsif qty>1
pbMessage(_INTL("\\me[Item get]You obtained {1} \\c[1]{2}\\c[0]!\\wtnp[30]",qty,itemname))
elsif itemname.starts_with_vowel?
pbMessage(_INTL("\\me[Item get]You obtained an \\c[1]{1}\\c[0]!\\wtnp[30]",itemname))
else
pbMessage(_INTL("\\me[Item get]You obtained a \\c[1]{1}\\c[0]!\\wtnp[30]",itemname))
end
$Trainer.mystery_gifts[index]=[id]
return true
end
end
return false
end

799
Data/Scripts/016_UI/024_UI_TextEntry.rb Normal file
View File

@@ -0,0 +1,799 @@
#===============================================================================
#
#===============================================================================
class Window_CharacterEntry < Window_DrawableCommand
XSIZE=13
YSIZE=4
def initialize(charset,viewport=nil)
@viewport=viewport
@charset=charset
@othercharset=""
super(0,96,480,192)
colors=getDefaultTextColors(self.windowskin)
self.baseColor=colors[0]
self.shadowColor=colors[1]
self.columns=XSIZE
refresh
end
def setOtherCharset(value)
@othercharset=value.clone
refresh
end
def setCharset(value)
@charset=value.clone
refresh
end
def character
if self.index<0 || self.index>=@charset.length
return ""
else
return @charset[self.index]
end
end
def command
return -1 if self.index==@charset.length
return -2 if self.index==@charset.length+1
return -3 if self.index==@charset.length+2
return self.index
end
def itemCount
return @charset.length+3
end
def drawItem(index,_count,rect)
rect=drawCursor(index,rect)
if index==@charset.length # -1
pbDrawShadowText(self.contents,rect.x,rect.y,rect.width,rect.height,"[ ]",
self.baseColor,self.shadowColor)
elsif index==@charset.length+1 # -2
pbDrawShadowText(self.contents,rect.x,rect.y,rect.width,rect.height,@othercharset,
self.baseColor,self.shadowColor)
elsif index==@charset.length+2 # -3
pbDrawShadowText(self.contents,rect.x,rect.y,rect.width,rect.height,_INTL("OK"),
self.baseColor,self.shadowColor)
else
pbDrawShadowText(self.contents,rect.x,rect.y,rect.width,rect.height,@charset[index],
self.baseColor,self.shadowColor)
end
end
end
#===============================================================================
# Text entry screen - free typing.
#===============================================================================
class PokemonEntryScene
@@Characters=[
[("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz").scan(/./),"[*]"],
[("0123456789 !@\#$%^&*() ~`-_+={}[] :;'\"<>,.?/ ").scan(/./),"[A]"],
]
USEKEYBOARD=true
def pbStartScene(helptext,minlength,maxlength,initialText,subject=0,pokemon=nil)
@sprites={}
@viewport=Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z=99999
if USEKEYBOARD
@sprites["entry"]=Window_TextEntry_Keyboard.new(initialText,
0,0,400-112,96,helptext,true)
Input.text_input = true
else
@sprites["entry"]=Window_TextEntry.new(initialText,0,0,400,96,helptext,true)
end
@sprites["entry"].x=(Graphics.width/2)-(@sprites["entry"].width/2)+32
@sprites["entry"].viewport=@viewport
@sprites["entry"].visible=true
@minlength=minlength
@maxlength=maxlength
@symtype=0
@sprites["entry"].maxlength=maxlength
if !USEKEYBOARD
@sprites["entry2"]=Window_CharacterEntry.new(@@Characters[@symtype][0])
@sprites["entry2"].setOtherCharset(@@Characters[@symtype][1])
@sprites["entry2"].viewport=@viewport
@sprites["entry2"].visible=true
@sprites["entry2"].x=(Graphics.width/2)-(@sprites["entry2"].width/2)
end
if minlength==0
@sprites["helpwindow"]=Window_UnformattedTextPokemon.newWithSize(
_INTL("Enter text using the keyboard. Press\nEnter to confirm, or Esc to cancel."),
32,Graphics.height-96,Graphics.width-64,96,@viewport
)
else
@sprites["helpwindow"]=Window_UnformattedTextPokemon.newWithSize(
_INTL("Enter text using the keyboard.\nPress Enter to confirm."),
32,Graphics.height-96,Graphics.width-64,96,@viewport
)
end
@sprites["helpwindow"].letterbyletter=false
@sprites["helpwindow"].viewport=@viewport
@sprites["helpwindow"].visible=USEKEYBOARD
@sprites["helpwindow"].baseColor=Color.new(16,24,32)
@sprites["helpwindow"].shadowColor=Color.new(168,184,184)
addBackgroundPlane(@sprites,"background","Naming/bg_2",@viewport)
case subject
when 1 # Player
meta=GameData::Metadata.get_player($Trainer.character_ID)
if meta
@sprites["shadow"]=IconSprite.new(0,0,@viewport)
@sprites["shadow"].setBitmap("Graphics/Pictures/Naming/icon_shadow")
@sprites["shadow"].x=33*2
@sprites["shadow"].y=32*2
filename=pbGetPlayerCharset(meta,1,nil,true)
@sprites["subject"]=TrainerWalkingCharSprite.new(filename,@viewport)
charwidth=@sprites["subject"].bitmap.width
charheight=@sprites["subject"].bitmap.height
@sprites["subject"].x = 44*2 - charwidth/8
@sprites["subject"].y = 38*2 - charheight/4
end
when 2 # Pokémon
if pokemon
@sprites["shadow"]=IconSprite.new(0,0,@viewport)
@sprites["shadow"].setBitmap("Graphics/Pictures/Naming/icon_shadow")
@sprites["shadow"].x=33*2
@sprites["shadow"].y=32*2
@sprites["subject"]=PokemonIconSprite.new(pokemon,@viewport)
@sprites["subject"].setOffset(PictureOrigin::Center)
@sprites["subject"].x=88
@sprites["subject"].y=54
@sprites["gender"]=BitmapSprite.new(32,32,@viewport)
@sprites["gender"].x=430
@sprites["gender"].y=54
@sprites["gender"].bitmap.clear
pbSetSystemFont(@sprites["gender"].bitmap)
textpos=[]
if pokemon.male?
textpos.push([_INTL("♂"),0,-6,false,Color.new(0,128,248),Color.new(168,184,184)])
elsif pokemon.female?
textpos.push([_INTL("♀"),0,-6,false,Color.new(248,24,24),Color.new(168,184,184)])
end
pbDrawTextPositions(@sprites["gender"].bitmap,textpos)
end
when 3 # NPC
@sprites["shadow"]=IconSprite.new(0,0,@viewport)
@sprites["shadow"].setBitmap("Graphics/Pictures/Naming/icon_shadow")
@sprites["shadow"].x=33*2
@sprites["shadow"].y=32*2
@sprites["subject"]=TrainerWalkingCharSprite.new(pokemon.to_s,@viewport)
charwidth=@sprites["subject"].bitmap.width
charheight=@sprites["subject"].bitmap.height
@sprites["subject"].x = 44*2 - charwidth/8
@sprites["subject"].y = 38*2 - charheight/4
when 4 # Storage box
@sprites["subject"]=TrainerWalkingCharSprite.new(nil,@viewport)
@sprites["subject"].altcharset="Graphics/Pictures/Naming/icon_storage"
@sprites["subject"].animspeed=4
charwidth=@sprites["subject"].bitmap.width
charheight=@sprites["subject"].bitmap.height
@sprites["subject"].x = 44*2 - charwidth/8
@sprites["subject"].y = 26*2 - charheight/2
end
pbFadeInAndShow(@sprites)
end
def pbEntry1
ret=""
loop do
Graphics.update
Input.update
if Input.triggerex?(:ESCAPE) && @minlength==0
ret=""
break
elsif Input.triggerex?(:RETURN) && @sprites["entry"].text.length>=@minlength
ret=@sprites["entry"].text
break
end
@sprites["helpwindow"].update
@sprites["entry"].update
@sprites["subject"].update if @sprites["subject"]
end
Input.update
return ret
end
def pbEntry2
ret=""
loop do
Graphics.update
Input.update
@sprites["helpwindow"].update
@sprites["entry"].update
@sprites["entry2"].update
@sprites["subject"].update if @sprites["subject"]
if Input.trigger?(Input::USE)
index=@sprites["entry2"].command
if index==-3 # Confirm text
ret=@sprites["entry"].text
if ret.length<@minlength || ret.length>@maxlength
pbPlayBuzzerSE()
else
pbPlayDecisionSE()
break
end
elsif index==-1 # Insert a space
if @sprites["entry"].insert(" ")
pbPlayDecisionSE()
else
pbPlayBuzzerSE()
end
elsif index==-2 # Change character set
pbPlayDecisionSE()
@symtype+=1
@symtype=0 if @symtype>=@@Characters.length
@sprites["entry2"].setCharset(@@Characters[@symtype][0])
@sprites["entry2"].setOtherCharset(@@Characters[@symtype][1])
else # Insert given character
if @sprites["entry"].insert(@sprites["entry2"].character)
pbPlayDecisionSE()
else
pbPlayBuzzerSE()
end
end
next
end
end
Input.update
return ret
end
def pbEntry
return USEKEYBOARD ? pbEntry1 : pbEntry2
end
def pbEndScene
pbFadeOutAndHide(@sprites)
pbDisposeSpriteHash(@sprites)
@viewport.dispose
Input.text_input = false if USEKEYBOARD
end
end
#===============================================================================
# Text entry screen - arrows to select letter.
#===============================================================================
class PokemonEntryScene2
@@Characters = [
[("ABCDEFGHIJ ,."+"KLMNOPQRST '-"+"UVWXYZ ♂♀"+" "+"0123456789 ").scan(/./),_INTL("UPPER")],
[("abcdefghij ,."+"klmnopqrst '-"+"uvwxyz ♂♀"+" "+"0123456789 ").scan(/./),_INTL("lower")],
[(",.:;!? ♂♀ "+"\"'()<>[] "+"~@#%*&$ "+"+-=^_/\\| "+" ").scan(/./),_INTL("other")],
]
ROWS = 13
COLUMNS = 5
MODE1 = -5
MODE2 = -4
MODE3 = -3
BACK = -2
OK = -1
class NameEntryCursor
def initialize(viewport)
@sprite = SpriteWrapper.new(viewport)
@cursortype = 0
@cursor1 = AnimatedBitmap.new("Graphics/Pictures/Naming/cursor_1")
@cursor2 = AnimatedBitmap.new("Graphics/Pictures/Naming/cursor_2")
@cursor3 = AnimatedBitmap.new("Graphics/Pictures/Naming/cursor_3")
@cursorPos = 0
updateInternal
end
def setCursorPos(value)
@cursorPos = value
end
def updateCursorPos
value=@cursorPos
if value==PokemonEntryScene2::MODE1 # Upper case
@sprite.x=48
@sprite.y=120
@cursortype=1
elsif value==PokemonEntryScene2::MODE2 # Lower case
@sprite.x=112
@sprite.y=120
@cursortype=1
elsif value==PokemonEntryScene2::MODE3 # Other symbols
@sprite.x=176
@sprite.y=120
@cursortype=1
elsif value==PokemonEntryScene2::BACK # Back
@sprite.x=312
@sprite.y=120
@cursortype=2
elsif value==PokemonEntryScene2::OK # OK
@sprite.x=392
@sprite.y=120
@cursortype=2
elsif value>=0
@sprite.x=52+32*(value%PokemonEntryScene2::ROWS)
@sprite.y=180+38*(value/PokemonEntryScene2::ROWS)
@cursortype=0
end
end
def visible=(value)
@sprite.visible=value
end
def visible
@sprite.visible
end
def color=(value)
@sprite.color=value
end
def color
@sprite.color
end
def disposed?
@sprite.disposed?
end
def updateInternal
@cursor1.update
@cursor2.update
@cursor3.update
updateCursorPos
case @cursortype
when 0 then @sprite.bitmap=@cursor1.bitmap
when 1 then @sprite.bitmap=@cursor2.bitmap
when 2 then @sprite.bitmap=@cursor3.bitmap
end
end
def update
updateInternal
end
def dispose
@cursor1.dispose
@cursor2.dispose
@cursor3.dispose
@sprite.dispose
end
end
def pbStartScene(helptext,minlength,maxlength,initialText,subject=0,pokemon=nil)
@sprites={}
@viewport=Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z=99999
@helptext=helptext
@helper=CharacterEntryHelper.new(initialText)
@bitmaps=[
AnimatedBitmap.new("Graphics/Pictures/Naming/overlay_tab_1"),
AnimatedBitmap.new("Graphics/Pictures/Naming/overlay_tab_2"),
AnimatedBitmap.new("Graphics/Pictures/Naming/overlay_tab_3")
]
@bitmaps[3]=@bitmaps[0].bitmap.clone
@bitmaps[4]=@bitmaps[1].bitmap.clone
@bitmaps[5]=@bitmaps[2].bitmap.clone
for i in 0...3
pos=0
pbSetSystemFont(@bitmaps[i+3])
textPos=[]
for y in 0...COLUMNS
for x in 0...ROWS
textPos.push([@@Characters[i][0][pos],44+x*32,12+y*38,2,
Color.new(16,24,32), Color.new(160,160,160)])
pos+=1
end
end
pbDrawTextPositions(@bitmaps[i+3],textPos)
end
@bitmaps[6]=BitmapWrapper.new(24,6)
@bitmaps[6].fill_rect(2,2,22,4,Color.new(168,184,184))
@bitmaps[6].fill_rect(0,0,22,4,Color.new(16,24,32))
@sprites["bg"]=IconSprite.new(0,0,@viewport)
@sprites["bg"].setBitmap("Graphics/Pictures/Naming/bg")
case subject
when 1 # Player
meta=GameData::Metadata.get_player($Trainer.character_ID)
if meta
@sprites["shadow"]=IconSprite.new(0,0,@viewport)
@sprites["shadow"].setBitmap("Graphics/Pictures/Naming/icon_shadow")
@sprites["shadow"].x=33*2
@sprites["shadow"].y=32*2
filename=pbGetPlayerCharset(meta,1,nil,true)
@sprites["subject"]=TrainerWalkingCharSprite.new(filename,@viewport)
charwidth=@sprites["subject"].bitmap.width
charheight=@sprites["subject"].bitmap.height
@sprites["subject"].x = 44*2 - charwidth/8
@sprites["subject"].y = 38*2 - charheight/4
end
when 2 # Pokémon
if pokemon
@sprites["shadow"]=IconSprite.new(0,0,@viewport)
@sprites["shadow"].setBitmap("Graphics/Pictures/Naming/icon_shadow")
@sprites["shadow"].x=33*2
@sprites["shadow"].y=32*2
@sprites["subject"]=PokemonIconSprite.new(pokemon,@viewport)
@sprites["subject"].setOffset(PictureOrigin::Center)
@sprites["subject"].x=88
@sprites["subject"].y=54
@sprites["gender"]=BitmapSprite.new(32,32,@viewport)
@sprites["gender"].x=430
@sprites["gender"].y=54
@sprites["gender"].bitmap.clear
pbSetSystemFont(@sprites["gender"].bitmap)
textpos=[]
if pokemon.male?
textpos.push([_INTL("♂"),0,-6,false,Color.new(0,128,248),Color.new(168,184,184)])
elsif pokemon.female?
textpos.push([_INTL("♀"),0,-6,false,Color.new(248,24,24),Color.new(168,184,184)])
end
pbDrawTextPositions(@sprites["gender"].bitmap,textpos)
end
when 3 # NPC
@sprites["shadow"]=IconSprite.new(0,0,@viewport)
@sprites["shadow"].setBitmap("Graphics/Pictures/Naming/icon_shadow")
@sprites["shadow"].x=33*2
@sprites["shadow"].y=32*2
@sprites["subject"]=TrainerWalkingCharSprite.new(pokemon.to_s,@viewport)
charwidth=@sprites["subject"].bitmap.width
charheight=@sprites["subject"].bitmap.height
@sprites["subject"].x = 44*2 - charwidth/8
@sprites["subject"].y = 38*2 - charheight/4
when 4 # Storage box
@sprites["subject"]=TrainerWalkingCharSprite.new(nil,@viewport)
@sprites["subject"].altcharset="Graphics/Pictures/Naming/icon_storage"
@sprites["subject"].animspeed=4
charwidth=@sprites["subject"].bitmap.width
charheight=@sprites["subject"].bitmap.height
@sprites["subject"].x = 44*2 - charwidth/8
@sprites["subject"].y = 26*2 - charheight/2
end
@sprites["bgoverlay"]=BitmapSprite.new(Graphics.width,Graphics.height,@viewport)
pbDoUpdateOverlay
@blanks=[]
@mode=0
@minlength=minlength
@maxlength=maxlength
@maxlength.times { |i|
@sprites["blank#{i}"]=SpriteWrapper.new(@viewport)
@sprites["blank#{i}"].bitmap=@bitmaps[6]
@sprites["blank#{i}"].x=160+24*i
@blanks[i]=0
}
@sprites["bottomtab"]=SpriteWrapper.new(@viewport) # Current tab
@sprites["bottomtab"].x=22
@sprites["bottomtab"].y=162
@sprites["bottomtab"].bitmap=@bitmaps[0+3]
@sprites["toptab"]=SpriteWrapper.new(@viewport) # Next tab
@sprites["toptab"].x=22-504
@sprites["toptab"].y=162
@sprites["toptab"].bitmap=@bitmaps[1+3]
@sprites["controls"]=IconSprite.new(0,0,@viewport)
@sprites["controls"].setBitmap(_INTL("Graphics/Pictures/Naming/overlay_controls"))
@sprites["controls"].x=16
@sprites["controls"].y=96
@init=true
@sprites["overlay"]=BitmapSprite.new(Graphics.width,Graphics.height,@viewport)
pbDoUpdateOverlay2
@sprites["cursor"]=NameEntryCursor.new(@viewport)
@cursorpos=0
@refreshOverlay=true
@sprites["cursor"].setCursorPos(@cursorpos)
pbFadeInAndShow(@sprites) { pbUpdate }
end
def pbUpdateOverlay
@refreshOverlay=true
end
def pbDoUpdateOverlay2
overlay=@sprites["overlay"].bitmap
overlay.clear
modeIcon=[[_INTL("Graphics/Pictures/Naming/icon_mode"),48+@mode*64,120,@mode*60,0,60,44]]
pbDrawImagePositions(overlay,modeIcon)
end
def pbDoUpdateOverlay
return if !@refreshOverlay
@refreshOverlay=false
bgoverlay=@sprites["bgoverlay"].bitmap
bgoverlay.clear
pbSetSystemFont(bgoverlay)
textPositions=[
[@helptext,160,6,false,Color.new(16,24,32),Color.new(168,184,184)]
]
chars=@helper.textChars
x=166
for ch in chars
textPositions.push([ch,x,42,false,Color.new(16,24,32),Color.new(168,184,184)])
x+=24
end
pbDrawTextPositions(bgoverlay,textPositions)
end
def pbChangeTab(newtab=@mode+1)
pbSEPlay("GUI naming tab swap start")
@sprites["cursor"].visible = false
@sprites["toptab"].bitmap = @bitmaps[(newtab%3)+3]
# Move bottom (old) tab down off the screen, and move top (new) tab right
# onto the screen
deltaX = 48*20/Graphics.frame_rate
deltaY = 24*20/Graphics.frame_rate
loop do
if @sprites["bottomtab"].y<414
@sprites["bottomtab"].y += deltaY
@sprites["bottomtab"].y = 414 if @sprites["bottomtab"].y>414
end
if @sprites["toptab"].x<22
@sprites["toptab"].x += deltaX
@sprites["toptab"].x = 22 if @sprites["toptab"].x>22
end
Graphics.update
Input.update
pbUpdate
break if @sprites["toptab"].x>=22 && @sprites["bottomtab"].y>=414
end
# Swap top and bottom tab around
@sprites["toptab"].x, @sprites["bottomtab"].x = @sprites["bottomtab"].x, @sprites["toptab"].x
@sprites["toptab"].y, @sprites["bottomtab"].y = @sprites["bottomtab"].y, @sprites["toptab"].y
@sprites["toptab"].bitmap, @sprites["bottomtab"].bitmap = @sprites["bottomtab"].bitmap, @sprites["toptab"].bitmap
Graphics.update
Input.update
pbUpdate
# Set the current mode
@mode = (newtab)%3
# Set the top tab up to be the next tab
newtab = @bitmaps[((@mode+1)%3)+3]
@sprites["cursor"].visible = true
@sprites["toptab"].bitmap = newtab
@sprites["toptab"].x = 22-504
@sprites["toptab"].y = 162
pbSEPlay("GUI naming tab swap end")
pbDoUpdateOverlay2
end
def pbUpdate
for i in 0...3
@bitmaps[i].update
end
if @init || Graphics.frame_count%5==0
@init = false
cursorpos = @helper.cursor
cursorpos = @maxlength-1 if cursorpos>=@maxlength
cursorpos = 0 if cursorpos<0
@maxlength.times { |i|
@blanks[i] = (i==cursorpos) ? 1 : 0
@sprites["blank#{i}"].y = [78,82][@blanks[i]]
}
end
pbDoUpdateOverlay
pbUpdateSpriteHash(@sprites)
end
def pbColumnEmpty?(m)
return false if m>=ROWS-1
chset=@@Characters[@mode][0]
return (
chset[m]==" " &&
chset[m+((ROWS-1))]==" " &&
chset[m+((ROWS-1)*2)]==" " &&
chset[m+((ROWS-1)*3)]==" "
)
end
def wrapmod(x,y)
result=x%y
result+=y if result<0
return result
end
def pbMoveCursor
oldcursor=@cursorpos
cursordiv=@cursorpos/ROWS
cursormod=@cursorpos%ROWS
cursororigin=@cursorpos-cursormod
if Input.repeat?(Input::LEFT)
if @cursorpos<0 # Controls
@cursorpos-=1
@cursorpos=OK if @cursorpos<MODE1
else
begin
cursormod=wrapmod((cursormod-1),ROWS)
@cursorpos=cursororigin+cursormod
end while pbColumnEmpty?(cursormod)
end
elsif Input.repeat?(Input::RIGHT)
if @cursorpos<0 # Controls
@cursorpos+=1
@cursorpos=MODE1 if @cursorpos>OK
else
begin
cursormod=wrapmod((cursormod+1),ROWS)
@cursorpos=cursororigin+cursormod
end while pbColumnEmpty?(cursormod)
end
elsif Input.repeat?(Input::UP)
if @cursorpos<0 # Controls
case @cursorpos
when MODE1 then @cursorpos = ROWS*(COLUMNS-1)
when MODE2 then @cursorpos = ROWS*(COLUMNS-1)+2
when MODE3 then @cursorpos = ROWS*(COLUMNS-1)+4
when BACK then @cursorpos = ROWS*(COLUMNS-1)+8
when OK then @cursorpos = ROWS*(COLUMNS-1)+11
end
elsif @cursorpos<ROWS # Top row of letters
case @cursorpos
when 0, 1 then @cursorpos = MODE1
when 2, 3 then @cursorpos = MODE2
when 4, 5, 6 then @cursorpos = MODE3
when 7, 8, 9, 10 then @cursorpos = BACK
when 11, 12 then @cursorpos = OK
end
else
cursordiv=wrapmod((cursordiv-1),COLUMNS)
@cursorpos=(cursordiv*ROWS)+cursormod
end
elsif Input.repeat?(Input::DOWN)
if @cursorpos<0 # Controls
case @cursorpos
when MODE1 then @cursorpos = 0
when MODE2 then @cursorpos = 2
when MODE3 then @cursorpos = 4
when BACK then @cursorpos = 8
when OK then @cursorpos = 11
end
elsif @cursorpos>=ROWS*(COLUMNS-1) # Bottom row of letters
case @cursorpos
when ROWS*(COLUMNS-1),ROWS*(COLUMNS-1)+1
@cursorpos = MODE1
when ROWS*(COLUMNS-1)+2,ROWS*(COLUMNS-1)+3
@cursorpos = MODE2
when ROWS*(COLUMNS-1)+4,ROWS*(COLUMNS-1)+5,ROWS*(COLUMNS-1)+6
@cursorpos = MODE3
when ROWS*(COLUMNS-1)+7,ROWS*(COLUMNS-1)+8,ROWS*(COLUMNS-1)+9,ROWS*(COLUMNS-1)+10
@cursorpos = BACK
when ROWS*(COLUMNS-1)+11,ROWS*(COLUMNS-1)+12
@cursorpos = OK
end
else
cursordiv=wrapmod((cursordiv+1),COLUMNS)
@cursorpos=(cursordiv*ROWS)+cursormod
end
end
if @cursorpos!=oldcursor # Cursor position changed
@sprites["cursor"].setCursorPos(@cursorpos)
pbPlayCursorSE()
return true
else
return false
end
end
def pbEntry
ret=""
loop do
Graphics.update
Input.update
pbUpdate
next if pbMoveCursor
if Input.trigger?(Input::SPECIAL)
pbChangeTab
elsif Input.trigger?(Input::ACTION)
@cursorpos = OK
@sprites["cursor"].setCursorPos(@cursorpos)
elsif Input.trigger?(Input::BACK)
@helper.delete
pbPlayCancelSE()
pbUpdateOverlay
elsif Input.trigger?(Input::USE)
case @cursorpos
when BACK # Backspace
@helper.delete
pbPlayCancelSE()
pbUpdateOverlay
when OK # Done
pbSEPlay("GUI naming confirm")
if @helper.length>=@minlength
ret=@helper.text
break
end
when MODE1
pbChangeTab(0) if @mode!=0
when MODE2
pbChangeTab(1) if @mode!=1
when MODE3
pbChangeTab(2) if @mode!=2
else
cursormod=@cursorpos%ROWS
cursordiv=@cursorpos/ROWS
charpos=cursordiv*(ROWS)+cursormod
chset=@@Characters[@mode][0]
if @helper.length>=@maxlength
@helper.delete
end
@helper.insert(chset[charpos])
pbPlayCursorSE()
if @helper.length>=@maxlength
@cursorpos=OK
@sprites["cursor"].setCursorPos(@cursorpos)
end
pbUpdateOverlay
end
end
end
Input.update
return ret
end
def pbEndScene
pbFadeOutAndHide(@sprites) { pbUpdate }
for bitmap in @bitmaps
bitmap.dispose if bitmap
end
@bitmaps.clear
pbDisposeSpriteHash(@sprites)
@viewport.dispose
end
end
#===============================================================================
#
#===============================================================================
class PokemonEntry
def initialize(scene)
@scene=scene
end
def pbStartScreen(helptext,minlength,maxlength,initialText,mode=-1,pokemon=nil)
@scene.pbStartScene(helptext,minlength,maxlength,initialText,mode,pokemon)
ret=@scene.pbEntry
@scene.pbEndScene
return ret
end
end
#===============================================================================
#
#===============================================================================
def pbEnterText(helptext,minlength,maxlength,initialText="",mode=0,pokemon=nil,nofadeout=false)
ret=""
if ($PokemonSystem.textinput==1 rescue false) # Keyboard
pbFadeOutIn(99999,nofadeout) {
sscene=PokemonEntryScene.new
sscreen=PokemonEntry.new(sscene)
ret=sscreen.pbStartScreen(helptext,minlength,maxlength,initialText,mode,pokemon)
}
else # Cursor
pbFadeOutIn(99999,nofadeout) {
sscene=PokemonEntryScene2.new
sscreen=PokemonEntry.new(sscene)
ret=sscreen.pbStartScreen(helptext,minlength,maxlength,initialText,mode,pokemon)
}
end
return ret
end
def pbEnterPlayerName(helptext,minlength,maxlength,initialText="",nofadeout=false)
return pbEnterText(helptext,minlength,maxlength,initialText,1,nil,nofadeout)
end
def pbEnterPokemonName(helptext,minlength,maxlength,initialText="",pokemon=nil,nofadeout=false)
return pbEnterText(helptext,minlength,maxlength,initialText,2,pokemon,nofadeout)
end
def pbEnterNPCName(helptext,minlength,maxlength,initialText="",id=0,nofadeout=false)
return pbEnterText(helptext,minlength,maxlength,initialText,3,id,nofadeout)
end
def pbEnterBoxName(helptext,minlength,maxlength,initialText="",nofadeout=false)
return pbEnterText(helptext,minlength,maxlength,initialText,4,nil,nofadeout)
end