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

Fixed Beak Blast/Shell Trap always failing, typo in Brick Break

Browse Source
This commit is contained in:
Maruno17
2021-04-18 16:30:17 +01:00
parent f10fe5c491
commit 66ee5937bc
17 changed files with 3 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

122
Data/Scripts/016_UI/001_Non-interactive UI/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 UI/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 UI/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 UI/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 UI/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 UI/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 UI/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