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

Remove Scripts folder to convert to submodule

Browse Source
This commit is contained in:
chardub
2025-04-19 15:43:57 -04:00
parent 0807a7ea79
commit 58da1023c1
429 changed files with 0 additions and 165507 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
View File

@@ -1,122 +0,0 @@
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)])
Pokemon.play_cry(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
View File

@@ -1,80 +0,0 @@
#==============================================================================
# * 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

248
Data/Scripts/016_UI/001_Non-interactive UI/003_UI_EggHatching.rb
View File

@@ -1,248 +0,0 @@
#===============================================================================
# * 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/Battlers/Eggs/%s_cracks", @pokemon.species)
crackfilename = sprintf("Graphics/Battlers/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
@sprites["pokemon"].zoom_x=Settings::FRONTSPRITE_SCALE
@sprites["pokemon"].zoom_y=Settings::FRONTSPRITE_SCALE
@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)
@pokemon.play_cry
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
if !$Trainer.pokedex.owned?(@pokemon.species)
$Trainer.pokedex.register(@pokemon)
$Trainer.pokedex.set_owned(@pokemon.species)
pbMessage(_INTL("{1}'s data was added to the Pokédex", @pokemon.name))
pbShowPokedex(@pokemon.species)
end
nb_eggs_hatched = pbGet(VAR_NB_EGGS_HATCHED)
pbSet(VAR_NB_EGGS_HATCHED,nb_eggs_hatched+1)
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
if player_on_hidden_ability_map
chosenAbility = pokemon.getAbilityList.sample #format: [[:ABILITY, index],...]
#pokemon.ability = chosenAbility[0]
pokemon.ability_index = chosenAbility[1]
end
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
egg.steps_to_hatch -= 1 if isWearingClothes(CLOTHES_BREEDER)
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
}

666
Data/Scripts/016_UI/001_Non-interactive UI/004_UI_Evolution.rb
View File

@@ -1,666 +0,0 @@
#===============================================================================
# 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 = Settings::FRONTSPRITE_SCALE
@sprites["rsprite1"].zoom_y = Settings::FRONTSPRITE_SCALE
@sprites["rsprite2"].zoom_x = Settings::FRONTSPRITE_SCALE
@sprites["rsprite2"].zoom_y = Settings::FRONTSPRITE_SCALE
@sprites["rsprite1"].color.alpha = 0
@sprites["rsprite1"].visible = true
@sprites["rsprite2"].visible = false
else
@sprites["rsprite1"].visible = false
@sprites["rsprite2"].visible = true
@sprites["rsprite1"].zoom_x = Settings::FRONTSPRITE_SCALE
@sprites["rsprite1"].zoom_y = Settings::FRONTSPRITE_SCALE
@sprites["rsprite2"].zoom_x = Settings::FRONTSPRITE_SCALE
@sprites["rsprite2"].zoom_y = Settings::FRONTSPRITE_SCALE
@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,reversing=false)
@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
background_file = reversing ? "DNAbg": "evolutionbg"
addBackgroundOrColoredPlane(@sprites,"background",background_file,
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["rsprite1"].zoom_x = Settings::FRONTSPRITE_SCALE
@sprites["rsprite1"].zoom_y = Settings::FRONTSPRITE_SCALE
@sprites["rsprite2"].zoom_x = Settings::FRONTSPRITE_SCALE
@sprites["rsprite2"].zoom_y = Settings::FRONTSPRITE_SCALE
@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,reversing=false)
metaplayer1 = SpriteMetafilePlayer.new(@metafile1,@sprites["rsprite1"])
metaplayer2 = SpriteMetafilePlayer.new(@metafile2,@sprites["rsprite2"])
metaplayer1.play
metaplayer2.play
pbBGMStop
@pokemon.play_cry
if !reversing
pbMessageDisplay(@sprites["msgwindow"],
_INTL("\\se[]What? {1} is evolving!\\^",@pokemon.name)) { pbUpdate }
pbMessageWaitForInput(@sprites["msgwindow"],50,true) { pbUpdate }
end
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(reversing)
end
end
def pbEvolutionSuccess(reversing=false)
# Play cry of evolved species
frames = GameData::Species.cry_length(@newspecies, @pokemon.form)
pbBGMStop
Pokemon.play_cry(@newspecies, @pokemon.form)
frames.times do
Graphics.update
pbUpdate
end
# Success jingle/message
pbMEPlay("Evolution success")
sprite_bitmap=@sprites["rsprite2"].getBitmap
#drawSpriteCredits(sprite_bitmap.filename,sprite_bitmap.path, @viewport)
newspeciesname = GameData::Species.get(@newspecies).name
if !reversing
pbMessageDisplay(@sprites["msgwindow"],
_INTL("\\se[]Congratulations! Your {1} evolved into {2}!\\wt[80]",
@pokemon.name,newspeciesname)) { pbUpdate }
else
pbMessageDisplay(@sprites["msgwindow"],
_INTL("\\se[]{1} has been turned into {2}!\\wt[80]",
@pokemon.name,newspeciesname)) { pbUpdate }
end
@sprites["msgwindow"].text = ""
# Check for consumed item and check if Pokémon should be duplicated
pbEvolutionMethodAfterEvolution if !reversing
#oldAbility = @pokemon.ability.id if @pokemon.ability
newSpecies = GameData::Species.get(@newspecies)
#allNewPossibleAbilities = newSpecies.abilities + newSpecies.hidden_abilities
# 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
#
if !$Trainer.pokedex.owned?(@newspecies)
$Trainer.pokedex.register(@pokemon)
$Trainer.pokedex.set_owned(@newspecies)
Kernel.pbMessageDisplay(@sprites["msgwindow"],
_INTL("{1}'s data was added to the Pokédex", newspeciesname))
@scene.pbShowPokedex(@newspecies)
end
# if allNewPossibleAbilities.include?(oldAbility)
# @pokemon.ability=oldAbility
# end
# 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

252
Data/Scripts/016_UI/001_Non-interactive UI/005_UI_Trading.rb
View File

@@ -1,252 +0,0 @@
#===============================================================================
#
#===============================================================================
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
@sprites["rsprite1"].zoom_x = Settings::FRONTSPRITE_SCALE
@sprites["rsprite1"].zoom_y = Settings::FRONTSPRITE_SCALE
@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
@sprites["rsprite2"].zoom_x = Settings::FRONTSPRITE_SCALE
@sprites["rsprite2"].zoom_y = Settings::FRONTSPRITE_SCALE
@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
@pokemon.play_cry
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,@pokemon.name,@trader2,@pokemon2.name)) { pbUpdate }
pbMessageDisplay(@sprites["msgwindow"],
_INTL("{1} bids farewell to {2}.",@trader2,@pokemon2.name)) { pbUpdate }
pbScene2
pbMessageDisplay(@sprites["msgwindow"],
_ISPRINTF("{1:s}\r\nNN: {2:s} OT: {3:s}\1", speciesname2,@pokemon2.name,@pokemon2.owner.name)) { pbUpdate }
pbMessageDisplay(@sprites["msgwindow"],
_INTL("Take good care of {1}.",@pokemon2.name)) { pbUpdate }
end
end
#===============================================================================
#
#===============================================================================
def pbStartTrade(pokemonIndex,newpoke,nickname,trainerName,trainerGender=0,savegame=false)
Kernel.Autosave if savegame
myPokemon = $Trainer.party[pokemonIndex]
heldItem = myPokemon.item
echoln heldItem
$PokemonBag.pbStoreItem(heldItem, 1) if heldItem
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

673
Data/Scripts/016_UI/001_Non-interactive UI/006_UI_HallOfFame.rb
View File

@@ -1,673 +0,0 @@
#===============================================================================
# * 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 = true
# 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 = false
# 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
bgFile = @singlerow ? "hallfamebg" : "hallfamebg_multiline"
addBackgroundPlane(@sprites, "bg", bgFile, @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
@singlerow = true
pbStartScene
@useMusic = (ENTRYMUSIC && ENTRYMUSIC != "")
pbBGMPlay(ENTRYMUSIC) if @useMusic
saveHallEntry
@xmovement = []
@ymovement = []
createBattlers
pbFadeInAndShow(@sprites) { pbUpdate }
end
def pbStartScenePC
@singlerow = false
pbStartScene
@hallIndex = $PokemonGlobal.hallOfFame.size - 1
echoln $PokemonGlobal.hallOfFame[-1]
@hallEntry = $PokemonGlobal.hallOfFame[-1][:TEAM]
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
entryData = {}
entryData[:TEAM] = @hallEntry
entryData[:DIFFICULTY] = getDifficulty
entryData[:MODE] = getCurrentGameMode()
entryData[:DATE] = getCurrentDate()
#Save trainer data (unused for now)
entryData[:TRAINER_HAT] = $Trainer.hat
entryData[:TRAINER_HAT_COLOR] = $Trainer.hat_color
entryData[:TRAINER_HAIR] = $Trainer.hair
entryData[:TRAINER_HAIR_COLOR] = $Trainer.hair_color
entryData[:TRAINER_CLOTHES] = $Trainer.clothes
entryData[:TRAINER_CLOTHES_COLOR] = $Trainer.clothes_color
entryData[:TRAINER_SKIN] = $Trainer.skin_tone
# Update the global variables
$PokemonGlobal.hallOfFame.push(entryData)
$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 = 92 + 160 * xpositionformula(battlernumber) #32
else
start_position = -16 #-56
spacing = 70 # spacing between mons
ret = (spacing * (battlernumber / 2) + 48) * (xpositionformula(battlernumber) - 1)
gap_size = 40 #gap for the trainer sprite in the middle
if battlernumber % 2 == 0 #left side
ret -= gap_size / 2
else
ret += gap_size / 2
end
ret += Graphics.width / 2 + start_position
end
return ret
end
def ypointformula(battlernumber)
ret = 0
if !@singlerow
ret = 92 + 128 * ypositionformula(battlernumber) / 2
else
y_position_base = 125
height_increase = 20
# Calculate the decrement based on the battlernumber:
# Each pair (1-2, 3-4, etc.) will decrease y by 20
y_decrement = 40 - height_increase * (battlernumber / 2)
ret = y_position_base + y_decrement
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)
@sprites["pokemon#{i}"].zoom_x = Settings::FRONTSPRITE_SCALE
@sprites["pokemon#{i}"].zoom_y = Settings::FRONTSPRITE_SCALE
# 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"].setBitmapDirectly(generate_front_trainer_sprite_bitmap())
if !@singlerow
@sprites["trainer"].x = Graphics.width - 96
@sprites["trainer"].y = 160
else
@sprites["trainer"].x = Graphics.width / 2 # - 96
@sprites["trainer"].y = 178
end
@sprites["trainer"].opacity = 255
@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) - 200
# 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
#Get difficulty for displaying in-game
def getDifficulty
return getDisplayDifficulty()
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)
lefttext += _INTL("Difficulty<r>{1}<br>", getDifficulty())
@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, 2, BASECOLOR, SHADOWCOLOR]])
writeDate(overlay, 120, Graphics.height - 50)
writeGameMode(overlay, (Graphics.width / 2) + 100, Graphics.height - 50)
end
def writeWelcomePC
overlay = @sprites["overlay"].bitmap
overlay.clear
pbDrawTextPositions(overlay, [[_INTL("Entered the Hall of Fame!"),
Graphics.width / 2, Graphics.height - 80, 2, BASECOLOR, SHADOWCOLOR]])
date = $PokemonGlobal.hallOfFame[@hallIndex][:DATE]
mode = $PokemonGlobal.hallOfFame[@hallIndex][:MODE]
difficulty = $PokemonGlobal.hallOfFame[@hallIndex][:DIFFICULTY]
writeDate(overlay, 120, Graphics.height - 50,date) if date
writeGameMode(overlay, (Graphics.width / 2) + 100, Graphics.height - 50, mode, difficulty) if mode && difficulty
end
def writeDate(overlay, x, y, timeString = nil)
timeString = getCurrentDate() if !timeString
pbDrawTextPositions(overlay, [[_INTL("{1}", timeString), x, y, 2, BASECOLOR, SHADOWCOLOR]])
end
def getCurrentDate()
currentTime = Time.new
return currentTime.year.to_s + "-" + ("%02d" % currentTime.month) + "-" + ("%02d" % currentTime.day)
end
def getCurrentGameMode()
gameMode = "Classic mode"
if $game_switches[SWITCH_MODERN_MODE]
gameMode = "Remix mode"
end
if $game_switches[SWITCH_EXPERT_MODE]
gameMode = "Expert mode"
end
if $game_switches[SWITCH_SINGLE_POKEMON_MODE]
pokemon_number = pbGet(VAR_SINGLE_POKEMON_MODE)
if pokemon_number.is_a?(Integer) && pokemon_number > 0
pokemon = GameData::Species.get(pokemon_number)
gameMode = pokemon.real_name + " mode"
else
gameMode = "Debug mode"
end
end
if $game_switches[SWITCH_RANDOMIZED_AT_LEAST_ONCE]
gameMode = "Randomized mode"
end
if $game_switches[ENABLED_DEBUG_MODE_AT_LEAST_ONCE] || $DEBUG
gameMode = "Debug mode"
end
return gameMode
end
def writeGameMode(overlay, x, y, gameMode = nil, difficulty = nil)
gameMode = getCurrentGameMode() if !gameMode
difficulty = getDifficulty() if !difficulty
pbDrawTextPositions(overlay, [[_INTL("{1} ({2})", gameMode, difficulty), x, y, 2, 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
@hallEntry[@battlerIndex - 1].play_cry
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
createTrainerBattler
(ENTRYWAITTIME * 2 * Graphics.frame_rate / 20).times do
moveSprite(-1)
Graphics.update
Input.update
pbUpdate
end
while !(waitForInput)
Graphics.update
Input.update
pbUpdate
end
setPokemonSpritesOpacity(-1, OPACITY) # if !@singlerow
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 waitForInput
if Input.trigger?(Input::USE) || Input.trigger?(Input::BACK)
return true
end
return false
end
def pbUpdatePC
# Change the team
if @battlerIndex >= @hallEntry.size + 1
@hallIndex -= 1
return false if @hallIndex == -1
@hallEntry = $PokemonGlobal.hallOfFame[@hallIndex][:TEAM]
@battlerIndex = 0
createBattlers(false)
elsif @battlerIndex == @hallEntry.size
for n in 0...@hallEntry.size
@sprites["pokemon#{n}"].opacity = 255
end
echoln @hallEntry
writeWelcomePC
return true
elsif @battlerIndex < 0
@hallIndex += 1
return false if @hallIndex >= $PokemonGlobal.hallOfFame.size
@hallEntry = $PokemonGlobal.hallOfFame[@hallIndex][:TEAM]
@battlerIndex = @hallEntry.size - 1
createBattlers(false)
end
# Change the pokemon
@hallEntry[@battlerIndex].play_cry
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
#
# [{:TEAM:[], :DATE:string, :MODE:string, :DIFFICULTY:string}]
#
def hallOfFame
@hallOfFame = [] if !@hallOfFame
if @hallOfFame.size > 0 && @hallOfFame[0].is_a?(Array)
echoln "converting hall of fame"
convertedHallOfFame = []
@hallOfFame.each do |team|
hallOfFame = {}
hallOfFame[:TEAM] = team
hallOfFame[:DATE] = nil
hallOfFame[:MODE] = nil
hallOfFame[:DIFFICULTY] = nil
hallOfFame[:TRAINER_HAT] = nil
hallOfFame[:TRAINER_HAT_COLOR] = nil
hallOfFame[:TRAINER_HAIR] = nil
hallOfFame[:TRAINER_HAIR_COLOR] = nil
hallOfFame[:TRAINER_CLOTHES] = nil
hallOfFame[:TRAINER_CLOTHES_COLOR] = nil
hallOfFame[:TRAINER_SKIN] = nil
convertedHallOfFame << hallOfFame
end
@hallOfFame = convertedHallOfFame
echoln @hallOfFame
end
return @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

374
Data/Scripts/016_UI/001_Non-interactive UI/007_UI_Credits.rb
View File

@@ -1,374 +0,0 @@
#==============================================================================
# * 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 = 62 # Pixels per second , ajuster pour fitter avec la musique
SECONDS_PER_BACKGROUND = 4
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)
NB_SPRITES_TO_PRELOAD = 30
TOTAL_NB_FRAMES = 4000 #set manually, depends on music length
FUSION_SPRITES_MAX_OPACITY=200
NB_FRAMES_AT_MAX_OPACITY=30
# This next piece of code is the credits.
# Start Editing
CREDIT = <<_END_
Pokémon Infinite Fusion
By Chardub (Frogzilla)
Programming / Game design:
Chardub
Fused Pokemon Sprites :
Japeal - Pokefusion 2
http://japeal.com/pkm
Special thanks to Aegide and Reizod for
helping to download the autogenerated sprites
and to the owners of Japeal for accepting to
share their sprites.
Maps:
Chardub
Kiwikelly
Some of the maps were based on work by:
BenGames, Zeak6464
Gameplay / Story :
Chardub
Kiwikelly
Custom sprites collecting and handling
Kiwikelly, Payapon, Thornsoflight
Discord custom sprites coordination
avianAnnihilator<s>Blaquaza
BéBoutton<s>CaBiNE
CoramSun<s>hero.drawing
Howls<s>Ignus
Kiwi<s>Maelmc
Milchik the Miltank<s>Payapon
Pix<s>Rosemagwin
Thornsoflight
All of the custom fused Pokémon sprites
were made by various members of the
Pokémon Infinite Fusion Discord
Including significant contributions from:
{SPRITER_CREDITS}
Other custom graphics:
Kiwikelly<s>Knuckles
UnworthyPie<s>Doctor Miawoo
Chardub<s>TCGrunler#4583
The following free ressources were also used
with their respective authors' consent:
Public use tileset graphics:
Alucus BoOmxBiG<s>chimcharsfireworkd
EpicDay<s>EternalTakai
Gallanty Heavy-Metal-Lover<s>Hek-el-grande
DirtyWiggles<s>iametrine
Jorginho<s>kizemaru-kurunosuke
KKKaito<s>kyle-dove
Minorthreat0987<s>Phyromatical
Pokemon-Diamond<s>rayd12smitty
Rossay<s>Shiney570
Spacemotion<s>Speedialga
ThatsSoWitty Thurpok<s>TyranitarDark
UltimoSpriter<s>WesleyFG
Public use music:
Pokeli, TailDoll666100
Kazune Sawatari, sentsinkantéun,
Nanashima, CharizardTheMaster, The Zame Jack
{INSERTS_PLUGIN_CREDITS_DO_NOT_REMOVE}
"Pokémon Essentials" was created by:
Flameguru
Poccil (Peter O.)
Maruno
With contributions from:
AvatarMonkeyKirby<s>MiDas Mike
Boushy<s>Near Fantastica
Brother1440<s>PinkMan
FL.<s>Popper
Genzai Kawakami<s>Rataime
Harshboy<s>SoundSpawn
help-14<s>the__end
IceGod64<s>Venom12
Jacob O. Wobbrock<s>Wachunga
KitsuneKouta<s>xLeD
Lisa Anthony<s>
and everyone else who helped out
"mkxp-z" by:
Roza
Based on MKXP by Ancurio et al.
"RPG Maker XP" by:
Enterbrain
This game was inspired by the original
fusion generator:
alexonsager.alexonsager.net
All generated fusion sprites in this game
come from the Pokémon Fusion Generator:
https://japeal.com/pkm/
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.
_END_
# Stop Editing
def main
endCredits() if $PokemonSystem.on_mobile
#-------------------------------
# Animated Background Setup
#-------------------------------
@counter = 0.0 # Counts time elapsed since the background image changed
@bg_index = 0
@bitmap_height = Graphics.height # For a single credits text bitmap
@trim = Graphics.height / 10
# Number of game frames per background frame
@realOY = -(Graphics.height - @trim)
@customSpritesList = getSpritesList()
#-------------------------------
# Credits text Setup
#-------------------------------
plugin_credits = ""
PluginManager.plugins.each do |plugin|
pcred = PluginManager.credits(plugin)
plugin_credits << "\"#{plugin}\" v.#{PluginManager.version(plugin)} by:\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 { |name| plugin_credits << name + "\n" }
end
plugin_credits << "\n"
end
CREDIT.gsub!(/\{INSERTS_PLUGIN_CREDITS_DO_NOT_REMOVE\}/, plugin_credits)
CREDIT.gsub!(/{SPRITER_CREDITS}/, format_names_for_game_credits())
credit_lines = CREDIT.split(/\n/)
#-------------------------------
# Make background and text sprites
#-------------------------------
viewport = Viewport.new(0, 0, Graphics.width, Graphics.height)
viewport.z = 99999
text_viewport = Viewport.new(0, @trim, Graphics.width, Graphics.height - (@trim * 2))
text_viewport.z = 99999
@background_sprite = IconSprite.new(0, 0)
@background_sprite.setBitmap("Graphics/Titles/" + BACKGROUNDS_LIST[0])
@credit_sprites = []
@total_height = credit_lines.size * 32
lines_per_bitmap = @bitmap_height / 32
num_bitmaps = (credit_lines.size.to_f / lines_per_bitmap).ceil
for i in 0...num_bitmaps
credit_bitmap = Bitmap.new(Graphics.width, @bitmap_height)
pbSetSystemFont(credit_bitmap)
for j in 0...lines_per_bitmap
line = credit_lines[i * lines_per_bitmap + j]
next if !line
line = line.split("<s>")
xpos = 0
align = 1 # Centre align
linewidth = Graphics.width
for k in 0...line.length
if line.length > 1
xpos = (k == 0) ? 0 : 20 + Graphics.width / 2
align = (k == 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, j * 32 + 8, linewidth, 32, line[k], align)
credit_bitmap.font.color = TEXT_OUTLINE_COLOR
credit_bitmap.draw_text(xpos + 2, j * 32 - 2, linewidth, 32, line[k], align)
credit_bitmap.draw_text(xpos, j * 32 - 2, linewidth, 32, line[k], align)
credit_bitmap.draw_text(xpos - 2, j * 32 - 2, linewidth, 32, line[k], align)
credit_bitmap.draw_text(xpos + 2, j * 32, linewidth, 32, line[k], align)
credit_bitmap.draw_text(xpos - 2, j * 32, linewidth, 32, line[k], align)
credit_bitmap.draw_text(xpos + 2, j * 32 + 2, linewidth, 32, line[k], align)
credit_bitmap.draw_text(xpos, j * 32 + 2, linewidth, 32, line[k], align)
credit_bitmap.draw_text(xpos - 2, j * 32 + 2, linewidth, 32, line[k], align)
credit_bitmap.font.color = TEXT_BASE_COLOR
credit_bitmap.draw_text(xpos, j * 32, linewidth, 32, line[k], align)
end
end
credit_sprite = Sprite.new(text_viewport)
credit_sprite.bitmap = credit_bitmap
credit_sprite.z = 9998
credit_sprite.oy = @realOY - @bitmap_height * i
@credit_sprites[i] = credit_sprite
end
#-------------------------------
# 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
pbBGMFade(2.0)
Graphics.freeze
viewport.color = Color.new(0, 0, 0, 255) # Ensure screen is black
Graphics.transition(20, "fadetoblack")
@background_sprite.dispose
@credit_sprites.each { |s| s.dispose if s }
text_viewport.dispose
viewport.dispose
$PokemonGlobal.creditsPlayed = true
pbBGMPlay(previousBGM)
end
def getSpritesList()
spritesList = []
$PokemonGlobal.alt_sprite_substitutions.each_value do |value|
if value.is_a?(PIFSprite)
spritesList << value
end
end
selected_spritesList = spritesList.sample(NB_SPRITES_TO_PRELOAD)
spriteLoader = BattleSpriteLoader.new
for sprite in selected_spritesList
spriteLoader.preload(sprite)
end
return selected_spritesList
end
# Check if the credits should be cancelled
def cancel?
if Input.trigger?(Input::USE) && $PokemonGlobal.creditsPlayed
endCredits
return true
end
return false
end
def endCredits
$scene = Scene_Map.new
pbBGMFade(1.0)
end
# Checks if credits bitmap has reached its ending point
def last?
if @realOY > @total_height + @trim
$scene = ($game_map) ? Scene_Map.new : nil
pbBGMFade(2.0)
return true
end
return false
end
def update
delta = Graphics.delta_s
@counter += delta
@sprites_counter = 0 if !@sprites_counter
#@background_sprite.setBitmap("Graphics/Titles/" + BACKGROUNDS_LIST[@bg_index])
# # Go to next slide
@frames_counter = 0 if !@frames_counter
@frames_counter+=1
stopShowingSprites = @frames_counter >= (TOTAL_NB_FRAMES-300)
pbBGSStop if @frames_counter > TOTAL_NB_FRAMES
spriteLoader = BattleSpriteLoader.new
if @counter >= SECONDS_PER_BACKGROUND && @customSpritesList.length > 0 && !stopShowingSprites
@sprites_counter=0
randomSprite = @customSpritesList.sample
@customSpritesList.delete(randomSprite)
@background_sprite.setBitmapDirectly(spriteLoader.load_pif_sprite(randomSprite))
@background_sprite.x = rand(0..300)
@background_sprite.y = rand(0..200)
@counter -= SECONDS_PER_BACKGROUND
@background_sprite.opacity = 50
@fadingIn=true
end
if @fadingIn
if @background_sprite.opacity < FUSION_SPRITES_MAX_OPACITY
@background_sprite.opacity +=5
else
@fadingIn=false
end
else
@sprites_counter += 1
if @sprites_counter >= NB_FRAMES_AT_MAX_OPACITY
@background_sprite.opacity-=3
end
end
return if cancel?
return if last?
@realOY += SCROLL_SPEED * delta
@credit_sprites.each_with_index { |s, i| s.oy = @realOY - @bitmap_height * i }
end
end