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

game data

Browse Source
This commit is contained in:
infinitefusion
2021-07-28 20:20:50 -04:00
parent 980517c0a2
commit dc7df58c17
1932 changed files with 275538 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

595
Data/Scripts_backup/024_Addons/001_marinUtilities.rb Normal file
View File

@@ -0,0 +1,595 @@
#NOTE:
# USED FOR REGION MAP SCRIPT, BUT IS LIKELY TO BREAK A TON OF OTHER STUFF
#
# TODO: CLEANUP, ONLY KEEP THE STUFF USED IN MAP SCRIPT
# Whether or not you want to use these utility methods. Toggling this off will
# likely break your scripts. So don't do it unless you know what you're doing :)
USING_MARIN_UTILITY = true
# Whether or not you want the custom/better errors message.
SPECIAL_ERRORS = true
# These two settings only apply if SPECIAL_ERRORS is TRUE
DOUBLE_BACKTRACE = false # The interpreter already contains a small
# backtrace for errors in events and such by default.
# Settings this to false will not show the custom
# backtrace.
BACKTRACE_MAX_SIZE = 12 # The backtrace can go all the way from the very first
# call to the very last call. This is the limit as far
# as it can go back, because you could have a massive
# backtrace otherwise.
def pbMarinUtility
return USING_MARIN_UTILITY
end
if USING_MARIN_UTILITY
# Sprite class extensions
class Sprite
# Shorthand for initializing a bitmap by path, bitmap, or width/height:
# -> bmp("Graphics/Pictures/bag")
# -> bmp(32, 32)
# -> bmp(some_other_bitmap)
def bmp(arg1 = nil, arg2 = nil)
if arg1
if arg2
arg1 = Graphics.width if arg1 == -1
arg2 = Graphics.height if arg2 == -1
self.bitmap = Bitmap.new(arg1, arg2)
elsif arg1.is_a?(Bitmap)
self.bitmap = arg1.clone
else
self.bitmap = Bitmap.new(arg1)
end
else
return self.bitmap
end
end
# Alternative to bmp(path):
# -> bmp = "Graphics/Pictures/bag"
def bmp=(arg1)
bmp(arg1)
end
# Usage:
# -> [x] # Sets sprite.x to x
# -> [x,y] # Sets sprite.x to x and sprite.y to y
# -> [x,y,z] # Sets sprite.x to x and sprite.y to y and sprite.z to z
# -> [nil,y] # Sets sprite.y to y
# -> [nil,nil,z] # Sets sprite.z to z
# -> [x,nil,z] # Sets sprite.x to x and sprite.z to z
# Etc.
def xyz=(args)
self.x = args[0] || self.x
self.y = args[1] || self.y
self.z = args[2] || self.z
end
# Returns the x, y, and z coordinates in the xyz=(args) format, [x,y,z]
def xyz
return [self.x,self.y,self.z]
end
# Centers the sprite by setting the origin points to half the width and height
def center_origins
return if !self.bitmap
self.ox = self.bitmap.width / 2
self.oy = self.bitmap.height / 2
end
# Returns the sprite's full width, taking zoom_x into account
def fullwidth
return self.bitmap.width.to_f * self.zoom_x
end
# Returns the sprite's full height, taking zoom_y into account
def fullheight
return self.bitmap.height.to_f * self.zoom_y
end
end
# A better alternative to the typical @sprites = {}
class SpriteHash
attr_reader :x
attr_reader :y
attr_reader :z
attr_reader :visible
attr_reader :opacity
def initialize
@hash = {}
@x = 0
@y = 0
@z = 0
@visible = true
@opacity = 255
end
# Returns the object in the specified key
def [](key)
key = key.to_sym if key.respond_to?(:to_sym) && !key.is_a?(Numeric)
return @hash[key]
end
# Sets an object in specified key to the specified value
def []=(key, value)
key = key.to_sym if key.respond_to?(:to_sym) && !key.is_a?(Numeric)
add(key, value)
end
# Returns the raw hash
def raw
return @hash
end
# Returns the keys in the hash
def keys
return @hash.keys
end
def length; return self.size; end
def count; return self.size; end
# Returns the amount of keys in the hash
def size
return @hash.keys.size
end
# Clones the hash
def clone
return @hash.clone
end
# Adds an object to the specified key
def add(key, value)
clear_disposed
key = key.to_sym if key.respond_to?(:to_sym) && !key.is_a?(Numeric)
@hash[key] if @hash[key] && @hash[key].respond_to?(:dispose)
@hash[key] = value
clear_disposed
end
# Deletes an object in the specified key
def delete(key)
key = key.to_sym if key.respond_to?(:to_sym) && !key.is_a?(Numeric)
@hash[key] = nil
clear_disposed
end
# Iterates over all sprites
def each
clear_disposed
@hash.each { |s| yield s[1] if block_given? }
end
# Updates all sprites
def update
clear_disposed
for key in @hash.keys
@hash[key].update if @hash[key].respond_to?(:update)
end
end
# Disposes all sprites
def dispose
clear_disposed
for key in @hash.keys
@hash[key].dispose if @hash[key].respond_to?(:dispose)
end
clear_disposed
end
# Compatibility
def disposed?
return false
end
# Changes x on all sprites
def x=(value)
clear_disposed
for key in @hash.keys
@hash[key].x += value - @x
end
@x = value
end
# Changes y on all sprites
def y=(value)
clear_disposed
for key in @hash.keys
@hash[key].y += value - @y
end
@y = value
end
# Changes z on all sprites
def z=(value)
clear_disposed
for key in @hash.keys
@hash[key].z += value - @z
end
@z = value
end
# Changes visibility on all sprites
def visible=(value)
clear_disposed
for key in @hash.keys
@hash[key].visible = value
end
end
# Changes opacity on all sprites
def opacity=(value)
clear_disposed
for key in @hash.keys
@hash[key].opacity += value - @opacity
end
@opacity = [0,value,255].sort[1]
end
# Fades out all sprites
def hide(frames = 16)
clear_disposed
frames.times do
Graphics.update
Input.update
for key in @hash.keys
@hash[key].opacity -= 255 / frames.to_f
end
end
@opacity = 0
end
# Fades in all sprites
def show(frames = 16)
clear_disposed
frames.times do
Graphics.update
Input.update
for key in @hash.keys
@hash[key].opacity += 255 / frames.to_f
end
end
@opacity = 255
end
# Deletes all disposed sprites from the hash
def clear_disposed
for key in @hash.keys
if (@hash[key].disposed? rescue true)
@hash[key] = nil
@hash.delete(key)
end
end
end
# Renames the old key to the new key
def rename(old, new)
self[new] = self[old]
delete(old)
end
end
# Stand-alone methods
# Fades in a black overlay
def showBlk(n = 16)
return if $blkVp || $blk
$blkVp = Viewport.new(0,0,DEFAULTSCREENWIDTH,DEFAULTSCREENHEIGHT)
$blkVp.z = 9999999
$blk = Sprite.new($blkVp)
$blk.bmp(-1,-1)
$blk.bitmap.fill_rect(0,0,DEFAULTSCREENWIDTH,DEFAULTSCREENHEIGHT,Color.new(0,0,0))
$blk.opacity = 0
for i in 0...(n + 1)
Graphics.update
Input.update
yield i if block_given?
$blk.opacity += 256 / n.to_f
end
end
# Fades out and disposes a black overlay
def hideBlk(n = 16)
return if !$blk || !$blkVp
for i in 0...(n + 1)
Graphics.update
Input.update
yield i if block_given?
$blk.opacity -= 256 / n.to_f
end
$blk.dispose
$blk = nil
$blkVp.dispose
$blkVp = nil
end
# Returns the percentage of exp the Pokémon has compared to the next level
def pbGetExpPercentage(pokemon)
pokemon = pokemon.pokemon if pokemon.respond_to?("pokemon")
startexp = PBExperience.pbGetStartExperience(pokemon.level, pokemon.growthrate)
endexp = PBExperience.pbGetStartExperience(pokemon.level + 1, pokemon.growthrate)
return (pokemon.exp - startexp).to_f / (endexp - startexp).to_f
end
unless defined?(oldrand)
alias oldrand rand
def rand(a = nil, b = nil)
if a.is_a?(Range)
l = a.min
u = a.max
return l + oldrand(u - l + 1)
elsif a.is_a?(Numeric)
if b.is_a?(Numeric)
return a + oldrand(b - a)
else
return oldrand(a)
end
elsif a.nil?
if b
return rand(b)
else
return oldrand(2)
end
end
end
end
# Input module extensions
module Input
# Returns true if any of the buttons below are pressed
def self.any?
return true if defined?(Game_Mouse) && $mouse && $mouse.click?
keys = [Input::C,Input::B,Input::LEFT,Input::RIGHT,Input::UP,Input::DOWN,
# 0-9, a-z
0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x41,0x42,0x43,0x44,
0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x50,0x51,0x52,0x53,
0x54,0x55,0x56,0x57,0x58,0x59,0x5A]
for key in keys
return true if Input.triggerex?(key)
end
return false
end
end
if SPECIAL_ERRORS
MessageBox = Win32API.new('user32', 'MessageBox', ['I','P','P','I'], 'I')
def p_msg(msg, title = nil, icon = nil)
case icon
when :error, :err
uType = 0x10
title ||= "Error" + "[" + GAME_VERSION_NUMBER + "]"
when :q, :question, :ask
uType = 0x20
title ||= "Question"
when :warning, :warn
uType = 0x30
title ||= "Warning"
when :inform, :info, :information
uType = 0x40
title ||= "Info"
else
uType = 0
title ||= "Pokémon"
end
hwnd = Win32API.pbFindRgssWindow
Graphics.update
t = Thread.new { MessageBox.call(hwnd, msg, title, uType); Thread.exit }
while t.status
Graphics.update
end
end
def buildErrorTitle()
title = "Error " + "[" + GAME_VERSION_NUMBER + "]"
if $game_switches
title += " rt " if $game_switches[987] #random trainers
title += " rwg " if $game_switches[956] #random wild - global
title += " rwa" if $game_switches[777] #random wild - area
title += "_f" if $game_switches[953] #rand to fusion
end
return title
end
def p_err(ex = $!, message = nil)
if $Rescue
raise
return
end
if ex.is_a?(String)
ex = RuntimeError.new ex
elsif ex.is_a?(Class)
ex = ex.new
end
trace = ex.backtrace || caller
script_id = trace[0][7..-1].split(':')[0].to_i
script = $RGSS_SCRIPTS[script_id][1]
line = trace[0].split(':')[1].to_i
msg = "Script '[#{script}]' line #{line}: #{ex.class} occurred."
if message || ex.message != ex.class.to_s
if message
msg << "\n\n#{message}"
else
msg << "\n\n#{ex.message}"
message = ex.message
end
end
showtrace = (trace.size > 2)
showtrace = false if !DOUBLE_BACKTRACE && message.include?(':in `')
if showtrace
msg << "\n\n"
msg << trace[0...BACKTRACE_MAX_SIZE].map do |e|
sID = e.split(':')[0][7..-1]
if sID.numeric?
sID = sID.to_i
s = "'" + $RGSS_SCRIPTS[sID][1] + "'"
else
s = "eval"
end
line = e.split(':')[1].to_i
code = e.split(':')[2..-1].join(':')
str = "from #{s} line #{line}"
str << " #{code}" unless code.empty?
next str
end.join("\n")
end
p_msg(msg, buildErrorTitle(), :err)
Kernel.exit! true
end
def p_info(msg, title = nil)
p_msg(msg, title, :info)
end
def p_warn(msg, title = nil)
p_msg(msg, title, :warn)
end
def p_question(msg, title = nil)
p_msg(msg, title, :question)
end
trace_var(:$scene, proc do |object|
break unless object
unless object.instance_variable_get(:@__old_main)
object.instance_variable_set(:@__old_main, object.method(:main))
def object.main
self.instance_variable_get(:@__old_main).call
rescue
p_err
end
end
end)
else
def p_err(*args)
raise *args
end
end # if SPECIAL_ERRORS
def pbGetActiveEventPage(event, mapid = nil)
mapid ||= event.map.map_id if event.respond_to?(:map)
pages = (event.is_a?(RPG::Event) ? event.pages : event.instance_eval { @event.pages })
for i in 0...pages.size
c = pages[pages.size - 1 - i].condition
ss = !(c.self_switch_valid && !$game_self_switches[[mapid,
event.id,c.self_switch_ch]])
sw1 = !(c.switch1_valid && !$game_switches[c.switch1_id])
sw2 = !(c.switch2_valid && !$game_switches[c.switch2_id])
var = true
if c.variable_valid
if !c.variable_value || !$game_variables[c.variable_id].is_a?(Numeric) ||
$game_variables[c.variable_id] < c.variable_value
var = false
end
end
if ss && sw1 && sw2 && var # All conditions are met
return pages[pages.size - 1 - i]
end
end
return nil
end
class TextSprite < Sprite
# Sets up the sprite and bitmap. You can also pass text to draw
# either an array of arrays, or an array containing the normal "parameters"
# for drawing text:
# [text,x,y,align,basecolor,shadowcolor]
def initialize(viewport = nil, text = nil, width = -1, height = -1)
super(viewport)
@width = width
@height = height
self.bmp(@width, @height)
pbSetSystemFont(self.bmp)
if text.is_a?(Array)
if text[0].is_a?(Array)
pbDrawTextPositions(self.bmp,text)
else
pbDrawTextPositions(self.bmp,[text])
end
end
end
# Clears the bitmap (and thus all drawn text)
def clear
self.bmp.clear
pbSetSystemFont(self.bmp)
end
# You can also pass text to draw either an array of arrays, or an array
# containing the normal "parameters" for drawing text:
# [text,x,y,align,basecolor,shadowcolor]
def draw(text, clear = false)
self.clear if clear
if text[0].is_a?(Array)
pbDrawTextPositions(self.bmp,text)
else
pbDrawTextPositions(self.bmp,[text])
end
end
# Draws text with outline
# [text,x,y,align,basecolor,shadowcolor]
def draw_outline(text, clear = false)
self.clear if clear
if text[0].is_a?(Array)
for e in text
pbDrawOutlineText(self.bmp,e[1],e[2],640,480,e[0],e[4],e[5],e[3])
end
else
e = text
pbDrawOutlineText(self.bmp,e[1],e[2],640,480,e[0],e[4],e[5],e[3])
end
end
# Draws and breaks a line if the width is exceeded
# [text,x,y,width,numlines,basecolor,shadowcolor]
def draw_ex(text, clear = false)
self.clear if clear
if text[0].is_a?(Array)
for e in text
drawTextEx(self.bmp,e[1],e[2],e[3],e[4],e[0],e[5],e[6])
end
else
e = text
drawTextEx(self.bmp,e[1],e[2],e[3],e[4],e[0],e[5],e[6])
end
end
# Clears and disposes the sprite
def dispose
clear
super
end
end
end # if USING_MARIN_UTILITY

102
Data/Scripts_backup/024_Addons/002_Strings util.rb Normal file
View File

@@ -0,0 +1,102 @@
# String class extensions
class String
# Returns true if the string starts with the passed substring.
def starts_with?(str)
return false if !str.is_a?(String)
return false if str.size > self.size
return self[0...str.length] == str
end
# Returns true if the string ends with the passed substring.
def ends_with?(str)
return self.reverse.starts_with?(str.reverse)
end
# Converts to bits
def to_b
return self.unpack('b*')[0]
end
# Converts to bits and replaces itself
def to_b!
self.replace(to_b)
end
# Converts from bits
def from_b
return [self].pack('b*')
end
# Convert from bits and replaces itself
def from_b!
self.replace(from_b)
end
# Returns the first n characters
def first(n = 1)
return self.clone if n >= self.size
return self[0] if n == 1
return self[0...n]
end
# Returns the last n characters
def last(n = 1)
return self.clone if n >= self.size
return self[-1] if n == 1
return self.reverse[0...n].reverse
end
# Returns a random character from the string
def random
return self[rand(self.size)]
end
# Breaks the string up every _n_ characters
def breakup(n)
new = []
for i in 0...self.size
new[(i / n).floor] ||= ""
new[(i / n).floor] += self[i]
end
return new
end
def empty?
return (self.size == 0)
end
def numeric?
i = 0
for e in self.split("")
next if i == 0 && e == "-"
return false unless [0,1,2,3,4,5,6,7,8,9].map { |n| n.to_s }.include?(e)
end
return true
end
# Deflates itself and returns the result
def deflate
return Zlib::Deflate.deflate(self)
end
# Deflates and replaces itself
def deflate!
self.replace(deflate)
end
# Inflates itself and returns the result
def inflate
return Zlib::Inflate.inflate(self)
end
# Inflates and replaces itself
def inflate!
self.replace(inflate)
end
# Adds some aliases for <include?>: <has?>, <includes?>, <contains?>
alias has? include?
alias includes? include?
alias contains? include?
end

704
Data/Scripts_backup/024_Addons/BetterRegionMap.rb Normal file
View File

@@ -0,0 +1,704 @@
#==============================================================================#
# Better Region Map #
# by Marin #
#==============================================================================#
# This region map is smoother and allows you to use region maps larger than #
# 480x320. #
# #
# This resource also comes with a new townmapgen.html to support for the #
# larger images. #
#==============================================================================#
# This region map does NOT support hidden islands such as Berth or Faraday. #
#==============================================================================#
# Please give credit when using this. #
#==============================================================================#
def pbBetterRegionMap(region = nil, show_player = true, can_fly = false)
if region == nil
mapData = pbGetMetadata($game_map.map_id,MetadataMapPosition)
if mapData != nil && mapData.length >= 1
region = mapData[0]
else
region = 0
end
end
scene = BetterRegionMap.new(region, show_player, can_fly)
return scene.flydata
end
class PokemonGlobalMetadata
attr_writer :regionMapSel
attr_writer :region
def regionMapSel
@regionMapSel ||= [0, 0]
return @regionMapSel
end
def region
@region ||= 0
return @region
end
end
class BetterRegionMap
CursorAnimateDelay = 12.0
CursorMoveSpeed = 4
TileWidth = 16.0
TileHeight = 16.0
MAP_MARGIN = 10
FlyPointAnimateDelay = 20.0
attr_reader :flydata
def initialize(region = nil, show_player = true, can_fly = false)
showBlk()
@region = 0#region || $PokemonGlobal.region
@show_player = show_player
@can_fly = can_fly
@data = load_data('Data/townmap.dat')[@region]
@viewport = Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z = 99999
@mapvp = Viewport.new(16,32,480,320)
@mapvp.z = 100000
@viewport2 = Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport2.z = 100001
@sprites = SpriteHash.new
@sprites["bg"] = Sprite.new(@viewport)
@sprites["bg"].bmp("Graphics/Pictures/mapbg")
@window = SpriteHash.new
@window["map"] = Sprite.new(@mapvp)
@window["map"].bmp("Graphics/Pictures/#{@data[1]}")
@sprites["cursor"] = Sprite.new(@viewport2)
@sprites["cursor"].bmp("Graphics/Pictures/mapCursor")
@sprites["cursor"].src_rect.width = @sprites["cursor"].bmp.height
@sprites["cursor"].x = 16 + TileWidth * $PokemonGlobal.regionMapSel[0]
@sprites["cursor"].y = 32 + TileHeight * $PokemonGlobal.regionMapSel[1]
@sprites["cursor"].z = 11
@sprites["cursor"].ox = (@sprites["cursor"].bmp.height - TileWidth) / 2.0
@sprites["cursor"].oy = @sprites["cursor"].ox
@window["player"] = Sprite.new(@mapvp)
if @show_player
player = nil
player = pbGetMetadata($game_map.map_id, MetadataMapPosition) if $game_map
if player && player[0] == @region
gender = $Trainer.gender.to_digits(3)
@window["player"].bmp("Graphics/Pictures/mapPlayer#{gender}")
@window["player"].x = TileWidth * player[1] + (TileWidth / 2.0)
@window["player"].y = TileHeight * player[2] + (TileHeight / 2.0)
@window["player"].center_origins
end
end
@sprites["txt"] = TextSprite.new(@viewport)
@sprites["arrowLeft"] = Sprite.new(@viewport2)
@sprites["arrowLeft"].bmp("Graphics/Pictures/mapArrowRight")
@sprites["arrowLeft"].mirror = true
@sprites["arrowLeft"].center_origins
@sprites["arrowLeft"].xyz = 12, Graphics.height / 2
@sprites["arrowRight"] = Sprite.new(@viewport2)
@sprites["arrowRight"].bmp("Graphics/Pictures/mapArrowRight")
@sprites["arrowRight"].center_origins
@sprites["arrowRight"].xyz = Graphics.width - 12, Graphics.height / 2
@sprites["arrowUp"] = Sprite.new(@viewport2)
@sprites["arrowUp"].bmp("Graphics/Pictures/mapArrowDown")
@sprites["arrowUp"].angle = 180
@sprites["arrowUp"].center_origins
@sprites["arrowUp"].xyz = Graphics.width / 2, 24
@sprites["arrowDown"] = Sprite.new(@viewport2)
@sprites["arrowDown"].bmp("Graphics/Pictures/mapArrowDown")
@sprites["arrowDown"].center_origins
@sprites["arrowDown"].xyz = Graphics.width / 2, Graphics.height - 24
update_text
@dirs = []
@mdirs = []
@i = 0
if can_fly
@spots = {}
n = 0
for x in 0...(@window["map"].bmp.width / TileWidth)
for y in 0...(@window["map"].bmp.height / TileHeight)
healspot = pbGetHealingSpot(x,y)
if healspot && $PokemonGlobal.visitedMaps[healspot[0]]
@window["point#{n}"] = Sprite.new(@mapvp)
@window["point#{n}"].bmp("Graphics/Pictures/mapFly")
@window["point#{n}"].src_rect.width = @window["point#{n}"].bmp.height
@window["point#{n}"].x = TileWidth * x + (TileWidth / 2)
@window["point#{n}"].y = TileHeight * y + (TileHeight / 2)
@window["point#{n}"].oy = @window["point#{n}"].bmp.height / 2.0
@window["point#{n}"].ox = @window["point#{n}"].oy
@spots[[x, y]] = healspot
n += 1
end
end
end
end
initWindowPosition(region)
#if region == nil
#end
hideBlk { update(false) }
main
end
def initWindowPosition(region=0)
x, y = 0
if region == 2 #sevii islands
x=-250
y=-200
elsif region == 1 #johto
x=0
y=0
else #kanto
x=-250
y=0
end
updateWindowPosition(x,y)
end
#@hor_count = position du pointer
def updateWindowPosition(x,y)
@window.x = x
@window.y = y
# @hor_count = 0#x
# @ver_count = 0#y
@sprites["cursor"].x = 16 + TileWidth * $PokemonGlobal.regionMapSel[0] + @window.x
@sprites["cursor"].y = 32 + TileWidth * $PokemonGlobal.regionMapSel[1] + @window.y
end
def pbGetHealingSpot(x,y)
return nil if !@data[2]
for loc in @data[2]
if loc[0] == x && loc[1] == y
if !loc[4] || !loc[5] || !loc[6]
return nil
else
return [loc[4],loc[5],loc[6]]
end
end
end
return nil
end
def main
loop do
update
if Input.press?(Input::RIGHT) && ![4,6].any? { |e| @dirs.include?(e) || @mdirs.include?(e) }
if @sprites["cursor"].x < 480
$PokemonGlobal.regionMapSel[0] += 1
@sx = @sprites["cursor"].x
@dirs << 6
elsif @window.x > -1 * (@window["map"].bmp.width - 480)
$PokemonGlobal.regionMapSel[0] += 1
@mx = @window.x
@mdirs << 6
end
end
if Input.press?(Input::LEFT) && ![4,6].any? { |e| @dirs.include?(e) || @mdirs.include?(e) }
if @sprites["cursor"].x > 16
$PokemonGlobal.regionMapSel[0] -= 1
@sx = @sprites["cursor"].x
@dirs << 4
elsif @window.x < 0
$PokemonGlobal.regionMapSel[0] -= 1
@mx = @window.x
@mdirs << 4
end
end
if Input.press?(Input::DOWN) && ![2,8].any? { |e| @dirs.include?(e) || @mdirs.include?(e) }
if @sprites["cursor"].y <= 320
$PokemonGlobal.regionMapSel[1] += 1
@sy = @sprites["cursor"].y
@dirs << 2
elsif @window.y > -1 * (@window["map"].bmp.height - 320)
$PokemonGlobal.regionMapSel[1] += 1
@my = @window.y
@mdirs << 2
end
end
if Input.press?(Input::UP) && ![2,8].any? { |e| @dirs.include?(e) || @mdirs.include?(e) }
if @sprites["cursor"].y > 32
$PokemonGlobal.regionMapSel[1] -= 1
@sy = @sprites["cursor"].y
@dirs << 8
elsif @window.y < 0
$PokemonGlobal.regionMapSel[1] -= 1
@my = @window.y
@mdirs << 8
end
end
if Input.trigger?(Input::C)
x, y = $PokemonGlobal.regionMapSel
if @spots && @spots[[x, y]]
@flydata = @spots[[x, y]]
break
end
end
break if Input.trigger?(Input::B)
end
dispose
end
def update(update_gfx = true)
@sprites["arrowLeft"].visible = @window.x < 0 -MAP_MARGIN
@sprites["arrowRight"].visible = @window.x > -1 * (@window["map"].bmp.width - 480) +MAP_MARGIN
@sprites["arrowUp"].visible = @window.y < 0 - MAP_MARGIN
@sprites["arrowDown"].visible = @window.y > -1 * (@window["map"].bmp.height - 320) +MAP_MARGIN
if update_gfx
Graphics.update
Input.update
end
@i += 1
if @i % CursorAnimateDelay == 0
@sprites["cursor"].src_rect.x += @sprites["cursor"].src_rect.width
@sprites["cursor"].src_rect.x = 0 if @sprites["cursor"].src_rect.x >= @sprites["cursor"].bmp.width
end
if @i % FlyPointAnimateDelay == 0
@window.keys.each do |e|
next unless e.to_s.starts_with?("point")
@window[e].src_rect.x += @window[e].src_rect.width
@window[e].src_rect.x = 0 if @window[e].src_rect.x >= @window[e].bmp.width
end
end
if @i % 2 == 0
case @i % 32
when 0...8
@sprites["arrowLeft"].x -= 1
@sprites["arrowRight"].x += 1
@sprites["arrowUp"].y -= 1
@sprites["arrowDown"].y += 1
when 8...24
@sprites["arrowLeft"].x += 1
@sprites["arrowRight"].x -= 1
@sprites["arrowUp"].y += 1
@sprites["arrowDown"].y -= 1
when 24...32
@sprites["arrowLeft"].x -= 1
@sprites["arrowRight"].x += 1
@sprites["arrowUp"].y -= 1
@sprites["arrowDown"].y += 1
end
end
# Cursor movement
if @dirs.include?(6)
@hor_count ||= 0
@hor_count += 1
update_text if @hor_count == (CursorMoveSpeed / 2.0).round
@sprites["cursor"].x = @sx + (TileWidth / CursorMoveSpeed.to_f) * @hor_count
if @hor_count == CursorMoveSpeed
@dirs.delete(6)
@hor_count = nil
@sx = nil
end
end
if @dirs.include?(4)
@hor_count ||= 0
@hor_count += 1
update_text if @hor_count == (CursorMoveSpeed / 2.0).round
@sprites["cursor"].x = @sx - (TileWidth / CursorMoveSpeed.to_f) * @hor_count
if @hor_count == CursorMoveSpeed
@dirs.delete(4)
@hor_count = nil
@sx = nil
end
end
if @dirs.include?(8)
@ver_count ||= 0
@ver_count += 1
update_text if @ver_count == (CursorMoveSpeed / 2.0).round
@sprites["cursor"].y = @sy - (TileHeight / CursorMoveSpeed.to_f) * @ver_count
if @ver_count == CursorMoveSpeed
@dirs.delete(8)
@ver_count = nil
@sy = nil
end
end
if @dirs.include?(2)
@ver_count ||= 0
@ver_count += 1
update_text if @ver_count == (CursorMoveSpeed / 2.0).round
@sprites["cursor"].y = @sy + (TileHeight / CursorMoveSpeed.to_f) * @ver_count
if @ver_count == CursorMoveSpeed
@dirs.delete(2)
@ver_count = nil
@sy = nil
end
end
# Map movement
if @mdirs.include?(6)
@hor_count ||= 0
@hor_count += 1
update_text if @hor_count == (CursorMoveSpeed / 2.0).round
@window.x = @mx - (TileWidth / CursorMoveSpeed.to_f) * @hor_count
if @hor_count == CursorMoveSpeed
@mdirs.delete(6)
@hor_count = nil
@mx = nil
end
end
if @mdirs.include?(4)
@hor_count ||= 0
@hor_count += 1
update_text if @hor_count == (CursorMoveSpeed / 2.0).round
@window.x = @mx + (TileWidth / CursorMoveSpeed.to_f) * @hor_count
if @hor_count == CursorMoveSpeed
@mdirs.delete(4)
@hor_count = nil
@mx = nil
end
end
if @mdirs.include?(8)
@ver_count ||= 0
@ver_count += 1
update_text if @ver_count == (CursorMoveSpeed / 2.0).round
@window.y = @my + (TileHeight / CursorMoveSpeed.to_f) * @ver_count
if @ver_count == CursorMoveSpeed
@mdirs.delete(8)
@ver_count = nil
@my = nil
end
end
if @mdirs.include?(2)
@ver_count ||= 0
@ver_count += 1
update_text if @ver_count == (CursorMoveSpeed / 2.0).round
@window.y = @my - (TileHeight / CursorMoveSpeed.to_f) * @ver_count
if @ver_count == CursorMoveSpeed
@mdirs.delete(2)
@ver_count = nil
@my = nil
end
end
end
def update_text
location = @data[2].find do |e|
e[0] == $PokemonGlobal.regionMapSel[0] &&
e[1] == $PokemonGlobal.regionMapSel[1]
end
text = ""
text = location[2] if location
poi = ""
poi = location[3] if location && location[3]
@sprites["txt"].draw([
[pbGetMessage(MessageTypes::RegionNames,@region), 16, 0, 0,
Color.new(255,255,255), Color.new(0,0,0)],
[text, 16, 354, 0, Color.new(255,255,255), Color.new(0,0,0)],
[poi, 496, 354, 1, Color.new(255,255,255), Color.new(0,0,0)]
], true)
end
def dispose
showBlk { update(false) }
@sprites.dispose
@window.dispose
@viewport.dispose
@viewport2.dispose
@mapvp.dispose
hideBlk
Input.update
end
end
#==============================================================================#
# Overwrites some old methods to use the new region map #
#==============================================================================#
#ItemHandlers::UseInField.add(:TOWNMAP,proc{|item|
# pbBetterRegionMap
# next 1
#})
class PokemonPartyScreen
def pbPokemonScreen
@scene.pbStartScene(@party,
(@party.length > 1) ? _INTL("Choose a Pokémon.") : _INTL("Choose Pokémon or cancel."),nil)
loop do
@scene.pbSetHelpText((@party.length > 1) ? _INTL("Choose a Pokémon.") : _INTL("Choose Pokémon or cancel."))
pkmnid = @scene.pbChoosePokemon(false, -1, 1)
break if (pkmnid.is_a?(Numeric) && pkmnid < 0) || (pkmnid.is_a?(Array) && pkmnid[1] < 0)
if pkmnid.is_a?(Array) && pkmnid[0] == 1 # Switch
@scene.pbSetHelpText(_INTL("Move to where?"))
oldpkmnid = pkmnid[1]
pkmnid = @scene.pbChoosePokemon(true, -1, 2)
if pkmnid >= 0 && pkmnid != oldpkmnid
pbSwitch(oldpkmnid, pkmnid)
end
next
end
pkmn = @party[pkmnid]
commands = []
cmdSummary = -1
cmdDebug = -1
cmdMoves = [-1,-1,-1,-1]
cmdSwitch = -1
cmdMail = -1
cmdItem = -1
# Build the commands
commands[cmdSummary = commands.length] = _INTL("Summary")
commands[cmdDebug = commands.length] = _INTL("Debug") if $DEBUG
for i in 0...pkmn.moves.length
move = pkmn.moves[i]
# Check for hidden moves and add any that were found
if !pkmn.egg? && (isConst?(move.id,PBMoves,:MILKDRINK) ||
isConst?(move.id,PBMoves,:SOFTBOILED) ||
HiddenMoveHandlers.hasHandler(move.id))
commands[cmdMoves[i] = commands.length] = [PBMoves.getName(move.id),1]
end
end
commands[cmdSwitch = commands.length] = _INTL("Switch") if @party.length>1
if !pkmn.egg?
if pkmn.mail
commands[cmdMail = commands.length] = _INTL("Mail")
else
commands[cmdItem = commands.length] = _INTL("Item")
end
end
commands[commands.length] = _INTL("Cancel")
command = @scene.pbShowCommands(_INTL("Do what with {1}?",pkmn.name),commands)
havecommand = false
for i in 0...4
if cmdMoves[i] >= 0 && command == cmdMoves[i]
havecommand = true
if isConst?(pkmn.moves[i].id,PBMoves,:SOFTBOILED) ||
isConst?(pkmn.moves[i].id,PBMoves,:MILKDRINK)
amt = [(pkmn.totalhp/5).floor,1].max
if pkmn.hp <= amt
pbDisplay(_INTL("Not enough HP..."))
break
end
@scene.pbSetHelpText(_INTL("Use on which Pokémon?"))
oldpkmnid = pkmnid
loop do
@scene.pbPreSelect(oldpkmnid)
pkmnid = @scene.pbChoosePokemon(true, pkmnid)
break if pkmnid < 0
newpkmn = @party[pkmnid]
movename = PBMoves.getName(pkmn.moves[i].id)
if pkmnid == oldpkmnid
pbDisplay(_INTL("{1} can't use {2} on itself!",pkmn.name,movename))
elsif newpkmn.egg?
pbDisplay(_INTL("{1} can't be used on an Egg!",movename))
elsif newpkmn.hp == 0 || newpkmn.hp == newpkmn.totalhp
pbDisplay(_INTL("{1} can't be used on that Pokémon.",movename))
else
pkmn.hp -= amt
hpgain = pbItemRestoreHP(newpkmn,amt)
@scene.pbDisplay(_INTL("{1}'s HP was restored by {2} points.",newpkmn.name,hpgain))
pbRefresh
end
break if pkmn.hp <= amt
end
@scene.pbSelect(oldpkmnid)
pbRefresh
break
elsif Kernel.pbCanUseHiddenMove?(pkmn,pkmn.moves[i].id)
if Kernel.pbConfirmUseHiddenMove(pkmn,pkmn.moves[i].id)
@scene.pbEndScene
if isConst?(pkmn.moves[i].id,PBMoves,:FLY)
###############################################
ret = pbBetterRegionMap(nil, true, true)
if ret
$PokemonTemp.flydata = ret
return [pkmn,pkmn.moves[i].id]
end
@scene.pbStartScene(@party,
(@party.length > 1) ? _INTL("Choose a Pokémon.") : _INTL("Choose Pokémon or cancel."))
break
###############################################
end
return [pkmn,pkmn.moves[i].id]
end
else
break
end
end
end
next if havecommand
if cmdSummary >= 0 && command == cmdSummary
@scene.pbSummary(pkmnid)
elsif cmdDebug >= 0 && command == cmdDebug
pbPokemonDebug(pkmn,pkmnid)
elsif cmdSwitch >= 0 && command == cmdSwitch
@scene.pbSetHelpText(_INTL("Move to where?"))
oldpkmnid = pkmnid
pkmnid = @scene.pbChoosePokemon(true)
if pkmnid >= 0 && pkmnid != oldpkmnid
pbSwitch(oldpkmnid, pkmnid)
end
elsif cmdMail >= 0 && command == cmdMail
command = @scene.pbShowCommands(_INTL("Do what with the mail?"),
[_INTL("Read"),_INTL("Take"),_INTL("Cancel")])
case command
when 0 # Read
pbFadeOutIn(99999){ pbDisplayMail(pkmn.mail,pkmn) }
when 1 # Take
if pbTakeItemFromPokemon(pkmn, self)
pbRefreshSingle(pkmnid)
end
end
elsif cmdItem >= 0 && command == cmdItem
itemcommands = []
cmdUseItem = -1
cmdGiveItem = -1
cmdTakeItem = -1
cmdMoveItem = -1
# Build the commands
itemcommands[cmdUseItem=itemcommands.length] = _INTL("Use")
itemcommands[cmdGiveItem=itemcommands.length] = _INTL("Give")
itemcommands[cmdTakeItem=itemcommands.length] = _INTL("Take") if pkmn.hasItem?
itemcommands[cmdMoveItem=itemcommands.length] = _INTL("Move") if pkmn.hasItem? && !pbIsMail?(pkmn.item)
itemcommands[itemcommands.length] = _INTL("Cancel")
command = @scene.pbShowCommands(_INTL("Do what with an item?"),itemcommands)
if cmdUseItem >= 0 && command == cmdUseItem # Use
item = @scene.pbUseItem($PokemonBag, pkmn)
if item>0
pbUseItemOnPokemon(item,pkmn,self)
pbRefreshSingle(pkmnid)
end
elsif cmdGiveItem >= 0 && command == cmdGiveItem # Give
item = @scene.pbChooseItem($PokemonBag)
if item > 0
if pbGiveItemToPokemon(item, pkmn, self, pkmnid)
pbRefreshSingle(pkmnid)
end
end
elsif cmdTakeItem >= 0 && command == cmdTakeItem # Take
if pbTakeItemFromPokemon(pkmn, self)
pbRefreshSingle(pkmnid)
end
elsif cmdMoveItem >= 0 && command == cmdMoveItem # Move
item = pkmn.item
itemname = PBItems.getName(item)
@scene.pbSetHelpText(_INTL("Move {1} to where?",itemname))
oldpkmnid = pkmnid
loop do
@scene.pbPreSelect(oldpkmnid)
pkmnid = @scene.pbChoosePokemon(true, pkmnid)
break if pkmnid < 0
newpkmn = @party[pkmnid]
if pkmnid == oldpkmnid
break
elsif newpkmn.egg?
pbDisplay(_INTL("Eggs can't hold items."))
elsif !newpkmn.hasItem?
newpkmn.setItem(item)
pkmn.setItem(0)
@scene.pbClearSwitching
pbRefresh
pbDisplay(_INTL("{1} was given the {2} to hold.",newpkmn.name,itemname))
break
elsif pbIsMail?(newpkmn.item)
pbDisplay(_INTL("{1}'s mail must be removed before giving it an item.",newpkmn.name))
else
newitem = newpkmn.item
newitemname = PBItems.getName(newitem)
if isConst?(newitem,PBItems,:LEFTOVERS)
pbDisplay(_INTL("{1} is already holding some {2}.\1",newpkmn.name,newitemname))
elsif ['a','e','i','o','u'].include?(newitemname[0,1].downcase)
pbDisplay(_INTL("{1} is already holding an {2}.\1",newpkmn.name,newitemname))
else
pbDisplay(_INTL("{1} is already holding a {2}.\1",newpkmn.name,newitemname))
end
if pbConfirm(_INTL("Would you like to switch the two items?"))
newpkmn.setItem(item)
pkmn.setItem(newitem)
@scene.pbClearSwitching
pbRefresh
pbDisplay(_INTL("{1} was given the {2} to hold.",newpkmn.name,itemname))
pbDisplay(_INTL("{1} was given the {2} to hold.",pkmn.name,newitemname))
break
end
end
end
end
end
end
@scene.pbEndScene
return nil
end
end
class PokemonReadyMenu
def pbStartReadyMenu(moves,items)
commands = [[], []] # Moves, items
for i in moves
commands[0].push([i[0], PBMoves.getName(i[0]), true, i[1]])
end
commands[0].sort! { |a,b| a[1] <=> b[1] }
for i in items
commands[1].push([i, PBItems.getName(i), false])
end
commands[1].sort! { |a,b| a[1] <=> b[1] }
@scene.pbStartScene(commands)
loop do
command = @scene.pbShowCommands
if command == -1
break
else
if command[0] == 0 # Use a move
move = commands[0][command[1]][0]
user = $Trainer.party[commands[0][command[1]][3]]
if isConst?(move,PBMoves,:FLY)
###############################################
pbHideMenu
ret = pbBetterRegionMap(nil, true, true)
pbShowMenu unless ret
###############################################
if ret
$PokemonTemp.flydata = ret
$game_temp.in_menu = false
Kernel.pbUseHiddenMove(user,move)
break
end
else
pbHideMenu
if Kernel.pbConfirmUseHiddenMove(user,move)
$game_temp.in_menu = false
Kernel.pbUseHiddenMove(user,move)
break
else
pbShowMenu
end
end
else # Use an item
item = commands[1][command[1]][0]
pbHideMenu
if ItemHandlers.triggerConfirmUseInField(item)
break if Kernel.pbUseKeyItemInField(item)
end
end
pbShowMenu
end
end
@scene.pbEndScene
end
end

48
Data/Scripts_backup/024_Addons/DisplayText.rb Normal file
View File

@@ -0,0 +1,48 @@
def Kernel.pbDisplayText(message,xposition,yposition,z=nil)
@hud = []
# Draw the text
baseColor=Color.new(72,72,72)
shadowColor=Color.new(160,160,160)
sprite = BitmapSprite.new(Graphics.width,Graphics.height,@viewport1)
if z != nil
sprite.z=z
end
@hud.push(sprite)
text1=_INTL(message)
textPosition=[
[text1,xposition,yposition,2,baseColor,shadowColor],
]
pbSetSystemFont(@hud[-1].bitmap)
pbDrawTextPositions(@hud[0].bitmap,textPosition)
end
def Kernel.pbDisplayNumber(number,xposition,yposition)
@numT = []
# Draw the text
baseColor=Color.new(72,72,72)
shadowColor=Color.new(160,160,160)
@numT.push(BitmapSprite.new(Graphics.width,Graphics.height,@viewport1))
text1=_INTL(number.to_s)
textPosition=[
[text1,xposition,yposition,2,baseColor,shadowColor],
]
pbSetSystemFont(@numT[-1].bitmap)
pbDrawTextPositions(@numT[0].bitmap,textPosition)
end
def Kernel.pbClearNumber()
if @numT != nil then
for sprite in @numT
sprite.dispose
end
@numT.clear
end
end
def Kernel.pbClearText()
if @hud != nil then
for sprite in @hud
sprite.dispose
end
@hud.clear
end
end

326
Data/Scripts_backup/024_Addons/Gen 2.rb Normal file
View File

@@ -0,0 +1,326 @@
#IMPORTANT
#La méthode def pbCheckEvolution(pokemon,item=0)
#dans PokemonFusion (class PokemonFusionScene)
#a été modifiée et pour une raison ou une autre ca marche
#pas quand on la copie ici.
#Donc NE PAS OUBLIER DE LE COPIER AVEC
############################
# MODIFIED CODE SECTION #
###########################
#
# require PokeBattle_Scene_edited2
# PokemonFusion
#
NB_POKEMON = 420 #351 #aussi CONST_NB_POKE
def pbPokemonBitmapFile(species)
# Used by the Pokédex
# Load normal bitmap
#get body and head num
isFused = species > NB_POKEMON
if isFused
if species >= ZAPMOLCUNO_NB
path = getSpecialSpriteName(species) + ".png"
else
poke1 = getBodyID(species) #getBasePokemonID(species,true)
poke2 = getHeadID(species, poke1) #getBasePokemonID(species,false)
path = GetSpritePath(poke1, poke2, isFused)
end
else
path = GetSpritePath(species, species, false)
end
ret = sprintf(path) rescue nil
if !pbResolveBitmap(ret)
ret = "Graphics/Battlers/000.png"
end
return ret
end
def pbLoadPokemonBitmap(pokemon, species, back = false)
#species est utilisé par elitebattle mais ca sert a rien
return pbLoadPokemonBitmapSpecies(pokemon, pokemon.species, back)
end
def getEggBitmapPath(pokemon)
bitmapFileName = sprintf("Graphics/Battlers/Eggs/%s", getConstantName(PBSpecies, pokemon.species)) rescue nil
if !pbResolveBitmap(bitmapFileName)
if pokemon.species >= NUM_ZAPMOLCUNO
bitmapFileName = "Graphics/Battlers/Eggs/egg_base"
else
bitmapFileName = sprintf("Graphics/Battlers/Eggs/%03d", pokemon.species)
if !pbResolveBitmap(bitmapFileName)
bitmapFileName = sprintf("Graphics/Battlers/Eggs/000")
end
end
end
return bitmapFileName
end
def pbLoadPokemonBitmapSpecies(pokemon, species, back = false, scale = POKEMONSPRITESCALE)
ret = nil
pokemon = pokemon.pokemon if pokemon.respond_to?(:pokemon)
if pokemon.isEgg?
bitmapFileName = getEggBitmapPath(pokemon)
bitmapFileName = pbResolveBitmap(bitmapFileName)
elsif pokemon.species >= ZAPMOLCUNO_NB #zapmolcuno
bitmapFileName = getSpecialSpriteName(pokemon.species) #sprintf("Graphics/Battlers/special/144.145.146")
bitmapFileName = pbResolveBitmap(bitmapFileName)
else
#edited here
isFusion = species > NB_POKEMON
if isFusion
poke1 = getBodyID(species)
poke2 = getHeadID(species, poke1)
else
poke1 = species
poke2 = species
end
bitmapFileName = GetSpritePath(poke1, poke2, isFusion)
# Alter bitmap if supported
alterBitmap = (MultipleForms.getFunction(species, "alterBitmap") rescue nil)
end
if bitmapFileName && alterBitmap
animatedBitmap = AnimatedBitmap.new(bitmapFileName)
copiedBitmap = animatedBitmap.copy
animatedBitmap.dispose
copiedBitmap.each { |bitmap| alterBitmap.call(pokemon, bitmap) }
ret = copiedBitmap
elsif bitmapFileName
ret = AnimatedBitmap.new(bitmapFileName)
end
return ret
end
def getSpecialSpriteName(dexNum)
base_path = "Graphics/Battlers/special/"
case dexNum
when NUM_ZAPMOLCUNO..NUM_ZAPMOLCUNO + 1
path = sprintf(base_path + "144.145.146")
when NUM_ZAPMOLCUNO + 2
path = sprintf(base_path + "243.244.245")
when NUM_ZAPMOLCUNO + 3
path = sprintf(base_path +"340.341.342")
when NUM_ZAPMOLCUNO + 4
path = sprintf(base_path +"343.344.345")
when NUM_ZAPMOLCUNO + 5
path = sprintf(base_path +"349.350.351")
when NUM_ZAPMOLCUNO + 6
path = sprintf(base_path +"151.251.381")
#starters
when NUM_ZAPMOLCUNO + 7
path = sprintf(base_path +"3.6.9")
when NUM_ZAPMOLCUNO + 8
path = sprintf(base_path +"154.157.160")
when NUM_ZAPMOLCUNO + 9
path = sprintf(base_path +"278.281.284")
when NUM_ZAPMOLCUNO + 10
path = sprintf(base_path +"318.321.324")
else
path = sprintf(base_path + "000")
end
end
#######################
# NEW CODE SECTION #
#######################
DOSSIERCUSTOMSPRITES = "CustomBattlers"
BATTLERSPATH = "Battlers"
def GetSpritePath(poke1, poke2, isFused)
#Check if custom exists
spritename = GetSpriteName(poke1, poke2, isFused)
pathCustom = sprintf("Graphics/%s/%s.png", DOSSIERCUSTOMSPRITES, spritename)
pathReg = sprintf("Graphics/%s/%s/%s.png", BATTLERSPATH, poke2, spritename)
path = pbResolveBitmap(pathCustom) && $game_variables[196] == 0 ? pathCustom : pathReg
return path
end
def GetSpritePathForced(poke1, poke2, isFused)
#Check if custom exists
spritename = GetSpriteName(poke1, poke2, isFused)
pathCustom = sprintf("Graphics/%s/%s.png", DOSSIERCUSTOMSPRITES, spritename)
pathReg = sprintf("Graphics/%s/%s/%s.png", BATTLERSPATH, poke2, spritename)
path = pbResolveBitmap(pathCustom) ? pathCustom : pathReg
return path
end
def GetSpriteName(poke1, poke2, isFused)
ret = isFused ? sprintf("%d.%d", poke2, poke1) : sprintf("%d", poke2) rescue nil
return ret
end
#in: pokemon number
def Kernel.isPartPokemon(src, target)
src = convertSpeciesSymbolToDexNumber(src)
target = convertSpeciesSymbolToDexNumber(target)
return true if src == target
return false if src <= NB_POKEMON
bod = getBasePokemonID(src, true)
head = getBasePokemonID(src, false)
return bod == target || head == target
end
##EDITED HERE
#Retourne le pokemon de base
#param1 = int
#param2 = true pour body, false pour head
#return int du pokemon de base
def getBasePokemonID(pokemon, body = true)
cname = getConstantName(PBSpecies, pokemon) rescue nil
return pokemon if pokemon <= NB_POKEMON
return pokemon if cname == nil
arr = cname.split(/[B,H]/)
bod = arr[1]
head = arr[2]
return bod.to_i if body
return head.to_i
end
###################
## CONVERTER #
###################
def convertAllPokemon()
Kernel.pbMessage(_INTL("The game has detected that your previous savefile was from an earlier build of the game."))
Kernel.pbMessage(_INTL("In order to play this version, your Pokémon need to be converted to their new Pokédex numbers. "))
Kernel.pbMessage(_INTL("If you were playing Randomized mode, the trainers and wild Pokémon will also need to be reshuffled."))
if (Kernel.pbConfirmMessage(_INTL("Convert your Pokémon?")))
#get previous version
msgwindow = Kernel.pbCreateMessageWindow(nil)
msgwindow.text = "What is the last version of the game you played?"
choice = Kernel.pbShowCommands(msgwindow, [
"4.7 (September 2020)",
"4.5-4.6.2 (2019-2020)",
"4.2-4.4 (2019)",
"4.0-4.1 (2018-2019)",
"3.x or earlier (2015-2018)"], -1)
case choice
when 0
prev_total = 381
when 1
prev_total = 351
when 2
prev_total = 315
when 3
prev_total = 275
when 4
prev_total = 151
else
prev_total = 381
end
Kernel.pbDisposeMessageWindow(msgwindow)
pbEachPokemon { |poke, box|
if poke.species >= NB_POKEMON
pf = poke.species
pBody = (pf / prev_total).round
pHead = pf - (prev_total * pBody)
# Kernel.pbMessage(_INTL("pbod {1} pHead {2}, species: {3})",pBody,pHead,pf))
prev_max_value = (prev_total * prev_total) + prev_total
if pf >= prev_max_value
newSpecies = convertTripleFusion(pf, prev_max_value)
if newSpecies == nil
boxname = box == -1 ? "Party" : box
Kernel.pbMessage(_INTL("Invalid Pokémon detected in box {1}:\n num. {2}, {3} (lv. {4})", boxname, pf, poke.name, poke.level))
if (Kernel.pbConfirmMessage(_INTL("Delete Pokémon and continue?")))
poke = nil
next
else
Kernel.pbMessage(_INTL("Conversion cancelled. Please restart the game."))
Graphics.freeze
end
end
end
newSpecies = pBody * NB_POKEMON + pHead
poke.species = newSpecies
end
}
Kernel.initRandomTypeArray()
if $game_switches[987] #randomized trainers
Kernel.pbShuffleTrainers()
end
if $game_switches[956] #randomized pokemon
range = pbGet(197) == nil ? 25 : pbGet(197)
Kernel.pbShuffleDex(range, 1)
end
end
end
def convertTripleFusion(species, prev_max_value)
if prev_max_value == (351 * 351) + 351
case species
when 123553
return 145543
when 123554
return 145544
when 123555
return 145545
when 123556
return 145546
when 123557
return 145547
when 123558
return 145548
else
return nil
end
end
return nil
end
def convertTrainers()
if ($game_switches[987])
Kernel.pbShuffleTrainers()
end
end
def convertAllPokemonManually()
if (Kernel.pbConfirmMessage(_INTL("When you last played the game, where there any gen 2 Pokémon?")))
#4.0
prev_total = 315
else
#3.0
prev_total = 151
end
convertPokemon(prev_total)
end
def convertPokemon(prev_total = 275)
pbEachPokemon { |poke, box|
if poke.species >= NB_POKEMON
pf = poke.species
pBody = (pf / prev_total).round
pHead = pf - (prev_total * pBody)
newSpecies = pBody * NB_POKEMON + pHead
poke.species = newSpecies
end
}
end

1316
Data/Scripts_backup/024_Addons/InfiniteFusion_EDITS.rb Normal file
View File

File diff suppressed because it is too large Load Diff

126
Data/Scripts_backup/024_Addons/New Balls.rb Normal file
View File

@@ -0,0 +1,126 @@
###################
## NEW POKEBALLS #
###################
#GENDER BALL (24) - switch le gender du pokemon
#catch rate: pokeball
BallHandlers::OnCatch.add(:GENDERBALL,proc{|ball,battle,pokemon|
if pokemon.gender == 0
pokemon.makeFemale
elsif pokemon.gender == 1
pokemon.makeMale
end
})
#BOOST BALL 25 - rend le pokemon traded
#catch rate: 80% pokeball
BallHandlers::ModifyCatchRate.add(:TRADEBALL,proc{|ball,catchRate,battle,pokemon|
catchRate=(catchRate*0.8).floor
next catchRate
})
BallHandlers::OnCatch.add(:TRADEBALL,proc{|ball,battle,pokemon|
pokemon.obtainMode = 2
})
#ABILITY BALL 26 - change l'ability
#catch rate: 60% pokeball
BallHandlers::ModifyCatchRate.add(:ABILITYBALL,proc{|ball,catchRate,battle,pokemon|
catchRate=(catchRate*0.6).floor
next catchRate
})
BallHandlers::OnCatch.add(:ABILITYBALL,proc{|ball,battle,pokemon|
pokemon.setAbility(2)
})
#VIRUS BALL 27 - give pokerus
#catch rate: 40% pokeball
BallHandlers::ModifyCatchRate.add(:VIRUSBALL,proc{|ball,catchRate,battle,pokemon|
catchRate=(catchRate*0.4).floor
next catchRate
})
BallHandlers::OnCatch.add(:VIRUSBALL,proc{|ball,battle,pokemon|
pokemon.givePokerus
})
#SHINY BALL 28 - rend shiny
#catchrate: 20% pokeball
BallHandlers::ModifyCatchRate.add(:SHINYBALL,proc{|ball,catchRate,battle,pokemon|
catchRate=(catchRate*0.2).floor
next catchRate
})
BallHandlers::OnCatch.add(:SHINYBALL,proc{|ball,battle,pokemon|
pokemon.makeShiny
})
#PERFECTBALL 29
#catch rate: 10% pokeball
BallHandlers::ModifyCatchRate.add(:PERFECTBALL,proc{|ball,catchRate,battle,pokemon|
catchRate=(catchRate*0.1).floor
next catchRate
})
BallHandlers::OnCatch.add(:PERFECTBALL,proc{|ball,battle,pokemon|
stat1 = rand(5)
stat2 = rand(5)
pokemon.iv[stat1]=31
pokemon.iv[stat2]=31
})
#DREAMBALL - endormi
BallHandlers::ModifyCatchRate.add(:DREAMBALL,proc{|ball,catchRate,battle,battler|
battler.status = PBStatuses::SLEEP
next catchRate
})
#TOXICBALL - empoisonné
BallHandlers::ModifyCatchRate.add(:TOXICBALL,proc{|ball,catchRate,battle,battler|
battler.status = PBStatuses::POISON
next catchRate
})
#SCORCHBALL - brulé
BallHandlers::ModifyCatchRate.add(:SCORCHBALL,proc{|ball,catchRate,battle,battler|
battler.status = PBStatuses::BURN
next catchRate
})
#FROSTBALL - frozen
BallHandlers::ModifyCatchRate.add(:FROSTBALL,proc{|ball,catchRate,battle,battler|
battler.status = PBStatuses::FROZEN
next catchRate
})
#SPARKBALL - paralizé
BallHandlers::ModifyCatchRate.add(:SPARKBALL,proc{|ball,catchRate,battle,battler|
battler.status = PBStatuses::PARALYSIS
next catchRate
})
#PUREBALL - marche mieux quand pas de status
BallHandlers::ModifyCatchRate.add(:PUREBALL,proc{|ball,catchRate,battle,battler|
catchRate=(catchRate*7/2).floor if battler.status ==0
next catchRate
})
#STATUSBALL - marche mieux quand any status
BallHandlers::ModifyCatchRate.add(:STATUSBALL,proc{|ball,catchRate,battle,battler|
catchRate=(catchRate*5/2).floor if battler.status !=0
next catchRate
})
#FUSIONBALL - marche mieux quand fused
BallHandlers::ModifyCatchRate.add(:FUSIONBALL,proc{|ball,catchRate,battle,battler|
catchRate*=3 if battler.species > NB_POKEMON
next catchRate
})
#CANDY BALL - +5 level
#catchrate: 80% pokeball
BallHandlers::ModifyCatchRate.add(:CANDYBALL,proc{|ball,catchRate,battle,pokemon|
catchRate=(catchRate*0.8).floor
next catchRate
})
BallHandlers::OnCatch.add(:CANDYBALL,proc{|ball,battle,pokemon|
pokemon.level = pokemon.level+5
})
#FIRECRACKER
BallHandlers::ModifyCatchRate.add(:FIRECRACKER,proc{|ball,catchRate,battle,battler|
battler.hp -= 10
next 0
})

995
Data/Scripts_backup/024_Addons/New HMs.rb Normal file
View File

@@ -0,0 +1,995 @@
#===============================================================================
# Teleport
#===============================================================================
HiddenMoveHandlers::CanUseMove.add(:TELEPORT,proc{|move,pkmn|
if !$DEBUG &&
!(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORFLY : $Trainer.badges[BADGEFORFLY])
Kernel.pbMessage(_INTL("Sorry, a new Badge is required."))
return false
end
if $game_player.pbHasDependentEvents?
Kernel.pbMessage(_INTL("It can't be used when you have someone with you."))
return false
end
if !pbGetMetadata($game_map.map_id,MetadataOutdoor)
Kernel.pbMessage(_INTL("Can't use that here."))
return false
end
return true
})
HiddenMoveHandlers::UseMove.add(:TELEPORT,proc{|move,pokemon|
if !$PokemonTemp.flydata
Kernel.pbMessage(_INTL("Can't use that here."))
end
if !pbHiddenMoveAnimation(pokemon)
Kernel.pbMessage(_INTL("{1} used {2}!",pokemon.name,PBMoves.getName(move)))
end
pbFadeOutIn(99999){
Kernel.pbCancelVehicles
$game_temp.player_new_map_id=$PokemonTemp.flydata[0]
$game_temp.player_new_x=$PokemonTemp.flydata[1]
$game_temp.player_new_y=$PokemonTemp.flydata[2]
$PokemonTemp.flydata=nil
$game_temp.player_new_direction=2
$scene.transfer_player
$game_map.autoplay
$game_map.refresh
}
pbEraseEscapePoint
return true
})
#===============================================================================
# FLY
#===============================================================================
HiddenMoveHandlers::CanUseMove.add(:FLY,proc{|move,pkmn|
if !$DEBUG &&
!(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORFLY : $Trainer.badges[BADGEFORFLY])
Kernel.pbMessage(_INTL("Sorry, a new Badge is required."))
return false
end
if $game_player.pbHasDependentEvents?
Kernel.pbMessage(_INTL("It can't be used when you have someone with you."))
return false
end
if !pbGetMetadata($game_map.map_id,MetadataOutdoor)
Kernel.pbMessage(_INTL("Can't use that here."))
return false
end
return true
})
HiddenMoveHandlers::UseMove.add(:FLY,proc{|move,pokemon|
if !$PokemonTemp.flydata
Kernel.pbMessage(_INTL("Can't use that here."))
end
if !pbHiddenMoveAnimation(pokemon)
Kernel.pbMessage(_INTL("{1} used {2}!",pokemon.name,PBMoves.getName(move)))
end
pbFadeOutIn(99999){
Kernel.pbCancelVehicles
$game_temp.player_new_map_id=$PokemonTemp.flydata[0]
$game_temp.player_new_x=$PokemonTemp.flydata[1]
$game_temp.player_new_y=$PokemonTemp.flydata[2]
$PokemonTemp.flydata=nil
$game_temp.player_new_direction=2
$scene.transfer_player
$game_map.autoplay
$game_map.refresh
}
pbEraseEscapePoint
return true
})
#===============================================================================
# Cut (+Machete)
#===============================================================================
def Kernel.pbCut
if $DEBUG ||
(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORCUT : $Trainer.badges[BADGEFORCUT])
movefinder=Kernel.pbCheckMove(:CUT)
if $DEBUG || movefinder || $PokemonBag.pbQuantity(PBItems::MACHETE)>0
Kernel.pbMessage(_INTL("This tree looks like it can be cut down!\1"))
if Kernel.pbConfirmMessage(_INTL("Would you like to cut it?"))
speciesname=!movefinder ? $Trainer.name : movefinder.name
Kernel.pbMessage(_INTL("{1} used Cut!",speciesname))
pbHiddenMoveAnimation(movefinder)
return true
end
else
Kernel.pbMessage(_INTL("This tree looks like it could be cut down."))
end
else
Kernel.pbMessage(_INTL("This tree looks like it could be cut down."))
end
return false
end
##Machete
def canUseMoveCut?
if !$DEBUG &&
!(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORCUT : $Trainer.badges[BADGEFORCUT])
Kernel.pbMessage(_INTL("Sorry, a new Badge is required."))
return false
end
facingEvent=$game_player.pbFacingEvent
if !facingEvent || facingEvent.name!="Tree"
Kernel.pbMessage(_INTL("Can't use that here."))
return false
end
return true
end
def useMoveCut
if !pbHiddenMoveAnimation(nil)
Kernel.pbMessage(_INTL("{1} used {2}!",$Trainer.name,"Cut"))
end
facingEvent=$game_player.pbFacingEvent
if facingEvent
facingEvent.erase
$PokemonMap.addErasedEvent(facingEvent.id)
end
return true
end
###
HiddenMoveHandlers::CanUseMove.add(:CUT,proc{|move,pkmn|
if !$DEBUG &&
!(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORCUT : $Trainer.badges[BADGEFORCUT])
Kernel.pbMessage(_INTL("Sorry, a new Badge is required."))
return false
end
facingEvent=$game_player.pbFacingEvent
if !facingEvent || facingEvent.name!="Tree"
Kernel.pbMessage(_INTL("Can't use that here."))
return false
end
return true
})
HiddenMoveHandlers::UseMove.add(:CUT,proc{|move,pokemon|
if !pbHiddenMoveAnimation(pokemon)
Kernel.pbMessage(_INTL("{1} used {2}!",pokemon.name,PBMoves.getName(move)))
end
facingEvent=$game_player.pbFacingEvent
if facingEvent
facingEvent.erase
$PokemonMap.addErasedEvent(facingEvent.id)
end
return true
})
#===============================================================================
# Rock Smash
#===============================================================================
def pbRockSmashRandomEncounter
if rand(100)<40
if pbEncounter(EncounterTypes::RockSmash)
return
else
pbDefaultRockSmashEncounter(5,15)
end
else
rockSmashItem(false)
end
end
def pbDefaultRockSmashEncounter(minLevel,maxLevel)
level =rand((maxLevel-minLevel).abs)+minLevel
$PokemonTemp.encounterType=EncounterTypes::RockSmash
pbWildBattle(PBSpecies::GEODUDE,level)
$PokemonTemp.encounterType=-1
return true
end
#FOR ROCK TUNNEL AND CERULEAN CAVE (+diamond)
def pbRockSmashRandomEncounterSpecial
if rand(100)<35
pbEncounter(EncounterTypes::RockSmash)
else
rockSmashItem(true)
end
end
def getRockSmashItemList(inclRareItems)
basicItems = [PBItems::ROCKGEM, PBItems::GROUNDGEM,PBItems::STEELGEM,
PBItems::HARDSTONE,PBItems::HARDSTONE,PBItems::HARDSTONE,PBItems::ROCKGEM,
PBItems::SMOOTHROCK,PBItems::STARDUST,PBItems::HEARTSCALE,PBItems::HEARTSCALE,
PBItems::HEARTSCALE,PBItems::SOFTSAND,PBItems::HEARTSCALE]
rareItems = [PBItems::RAREBONE,PBItems::STARDUST,PBItems::ETHER,
PBItems::REVIVE,PBItems::NUGGET,PBItems::DIAMOND]
fossilItems = [PBItems::ROOTFOSSIL,PBItems::CLAWFOSSIL,PBItems::DOMEFOSSIL,PBItems::HELIXFOSSIL,
PBItems::SKULLFOSSIL,PBItems::ARMORFOSSIL]
# Kernel.pbMessage(inclRareItems.to_s)
itemsList = inclRareItems ? basicItems + basicItems + rareItems : basicItems
#beaten league
if $game_switches[12]
itemsList += fossilItems
end
return itemsList
end
def rockSmashItem(isDark=false)
chance = isDark ? 25 : 45
if rand(100)< chance
itemsList = getRockSmashItemList(isDark)
i = rand(itemsList.length)
Kernel.pbItemBall(itemsList[i],1,nil,false)
end
end
#Used in underwater maps
def pbRockSmashRandomEncounterDive
if rand(100)<25
pbEncounter(EncounterTypes::RockSmash)
else
if rand(100)<20
itemsList = [PBItems::WATERGEM,PBItems::STEELGEM,
PBItems::HEARTSCALE,PBItems::HEARTSCALE,PBItems::HARDSTONE,PBItems::ROCKGEM,
PBItems::SMOOTHROCK,PBItems::WATERSTONE,PBItems::PEARL,PBItems::HEARTSCALE,
PBItems::HEARTSCALE,PBItems::HEARTSCALE,PBItems::SHOALSHELL,PBItems::BIGPEARL]
i = rand(itemsList.length)
Kernel.pbItemBall(itemsList[i],1,nil,false)
end
end
end
def Kernel.pbRockSmash
if $DEBUG ||
(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORROCKSMASH : $Trainer.badges[BADGEFORROCKSMASH])
movefinder=Kernel.pbCheckMove(:ROCKSMASH)
if $DEBUG || movefinder || $PokemonBag.pbQuantity(PBItems::PICKAXE)>0
if Kernel.pbConfirmMessage(_INTL("This rock appears to be breakable. Would you like to use Rock Smash?"))
speciesname=!movefinder ? $Trainer.name : movefinder.name
Kernel.pbMessage(_INTL("{1} used Rock Smash!",speciesname))
pbHiddenMoveAnimation(movefinder)
return true
end
else
Kernel.pbMessage(_INTL("It's a rugged rock, but a Pokémon may be able to smash it."))
end
else
Kernel.pbMessage(_INTL("It's a rugged rock, but a Pokémon may be able to smash it."))
end
return false
end
HiddenMoveHandlers::CanUseMove.add(:ROCKSMASH,proc{|move,pkmn|
terrain=Kernel.pbFacingTerrainTag
if !$DEBUG &&
!(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORROCKSMASH : $Trainer.badges[BADGEFORROCKSMASH])
Kernel.pbMessage(_INTL("Sorry, a new Badge is required."))
return false
end
facingEvent=$game_player.pbFacingEvent
if !facingEvent || facingEvent.name!="Rock"
Kernel.pbMessage(_INTL("Can't use that here."))
return false
end
return true
})
HiddenMoveHandlers::UseMove.add(:ROCKSMASH,proc{|move,pokemon|
if !pbHiddenMoveAnimation(pokemon)
Kernel.pbMessage(_INTL("{1} used {2}!",pokemon.name,PBMoves.getName(move)))
end
facingEvent=$game_player.pbFacingEvent
if facingEvent
facingEvent.erase
$PokemonMap.addErasedEvent(facingEvent.id)
end
return true
})
#===============================================================================
# Strength
#===============================================================================
def Kernel.pbStrength(isSlowpoke=false)
#isBoulder = !$game_switches[377]
# Kernel.pbMessage(_INTL("{1}",$game_switches[377]))
if isSlowpoke
msg = "It's a big Pokémon, but a Pokémon may be able to push it aside."
else
msg = "It's a big boulder, but a Pokémon may be able to push it aside."
end
if $PokemonMap.strengthUsed
#Kernel.pbMessage(_INTL("Strength made it possible to move boulders around."))
elsif $DEBUG ||
(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORSTRENGTH : $Trainer.badges[BADGEFORSTRENGTH])
movefinder=Kernel.pbCheckMove(:STRENGTH)
if $DEBUG || movefinder || $PokemonBag.pbQuantity(PBItems::LEVER)>0
Kernel.pbMessage(_INTL(msg))
if Kernel.pbConfirmMessage(_INTL("Would you like to use Strength?"))
speciesname=!movefinder ? $Trainer.name : movefinder.name
Kernel.pbMessage(_INTL("{1} used Strength!\1",speciesname))
pbHiddenMoveAnimation(movefinder)
Kernel.pbMessage(_INTL("{1}'s Strength made it possible to move boulders around!",speciesname))
$PokemonMap.strengthUsed=true
return true
end
else
Kernel.pbMessage(_INTL(msg))
end
else
Kernel.pbMessage(_INTL(msg))
end
return false
end
Events.onAction+=proc{|sender,e|
facingEvent=$game_player.pbFacingEvent
if facingEvent
if facingEvent.name=="Boulder"
Kernel.pbStrength
return
end
end
}
Events.onAction+=proc{|sender,e|
facingEvent=$game_player.pbFacingEvent
if facingEvent
if facingEvent.name=="BoulderSlowpoke"
Kernel.pbStrength(true)
return
end
end
}
HiddenMoveHandlers::CanUseMove.add(:STRENGTH,proc{|move,pkmn|
if !$DEBUG &&
!(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORSTRENGTH : $Trainer.badges[BADGEFORSTRENGTH])
Kernel.pbMessage(_INTL("Sorry, a new Badge is required."))
return false
end
if $PokemonMap.strengthUsed
Kernel.pbMessage(_INTL("Strength is already being used."))
return false
end
return true
})
HiddenMoveHandlers::UseMove.add(:STRENGTH,proc{|move,pokemon|
pbHiddenMoveAnimation(pokemon)
Kernel.pbMessage(_INTL("{1} used {2}!\1",pokemon.name,PBMoves.getName(move)))
Kernel.pbMessage(_INTL("{1}'s Strength made it possible to move boulders around!",pokemon.name))
$PokemonMap.strengthUsed=true
return true
})
#===============================================================================
# Surf
#===============================================================================
def pbSurf
return false if $game_player.pbFacingEvent
return false if $game_player.pbHasDependentEvents?
move = getID(PBMoves,:SURF)
movefinder = pbCheckMove(move) || $PokemonBag.pbQuantity(PBItems::SURFBOARD)>0
if !pbCheckHiddenMoveBadge(BADGE_FOR_SURF,false) || (!$DEBUG && !movefinder)
return false
end
if pbConfirmMessage(_INTL("The water is a deep blue...\nWould you like to surf on it?"))
speciesname = (movefinder) ? movefinder.name : $Trainer.name
pbMessage(_INTL("{1} used {2}!",speciesname,PBMoves.getName(move)))
pbCancelVehicles
pbHiddenMoveAnimation(movefinder)
surfbgm = pbGetMetadata(0,MetadataSurfBGM)
pbCueBGM(surfbgm,0.5) if surfbgm
pbStartSurfing
return true
end
return false
end
def playSurfMusic?()
mapsWithoutMusic = [322]
return false if mapsWithoutMusic.include?($game_map.map_id)
return true
end
def Kernel.pbTransferSurfingNoFade(mapid,xcoord,ycoord,direction=$game_player.direction)
$game_temp.player_new_map_id=mapid
$game_temp.player_new_x=xcoord
$game_temp.player_new_y=ycoord
$game_temp.player_new_direction=direction
Kernel.pbCancelVehicles
$PokemonGlobal.surfing=true
Kernel.pbUpdateVehicle
$scene.transfer_player(false)
$game_map.autoplay
$game_map.refresh
end
#===============================================================================
# Waterfall
#===============================================================================
def Kernel.pbAscendWaterfall(event=nil)
event=$game_player if !event
return if !event
return if event.direction!=8 # can't ascend if not facing up
oldthrough=event.through
oldmovespeed=event.move_speed
terrain=Kernel.pbFacingTerrainTag
return if terrain!=PBTerrain::Waterfall && terrain!=PBTerrain::WaterfallCrest
event.through=true
event.move_speed=2
loop do
event.move_up
terrain=pbGetTerrainTag(event)
break if terrain!=PBTerrain::Waterfall && terrain!=PBTerrain::WaterfallCrest
end
event.through=oldthrough
event.move_speed=oldmovespeed
end
def Kernel.pbDescendWaterfall(event=nil)
event=$game_player if !event
return if !event
return if event.direction!=2 # Can't descend if not facing down
oldthrough=event.through
oldmovespeed=event.move_speed
terrain=Kernel.pbFacingTerrainTag
return if terrain!=PBTerrain::Waterfall# && terrain!=PBTerrain::WaterfallCrest
event.through=true
event.move_speed=2
loop do
event.move_down
terrain=pbGetTerrainTag(event)
break if terrain!=PBTerrain::Waterfall && terrain!=PBTerrain::WaterfallCrest
end
event.through=oldthrough
event.move_speed=oldmovespeed
end
def Kernel.pbWaterfall
if $DEBUG ||
(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORWATERFALL : $Trainer.badges[BADGEFORWATERFALL])
movefinder=Kernel.pbCheckMove(:WATERFALL)
if $DEBUG || movefinder || $PokemonBag.pbQuantity(PBItems::JETPACK)>0
if Kernel.pbConfirmMessage(_INTL("It's a large waterfall. Would you like to use Waterfall?"))
speciesname=!movefinder ? $Trainer.name : movefinder.name
Kernel.pbMessage(_INTL("{1} used Waterfall.",speciesname))
pbHiddenMoveAnimation(movefinder)
pbAscendWaterfall
return true
end
else
Kernel.pbMessage(_INTL("A wall of water is crashing down with a mighty roar."))
end
else
Kernel.pbMessage(_INTL("A wall of water is crashing down with a mighty roar."))
end
return false
end
Events.onAction+=proc{|sender,e|
terrain=Kernel.pbFacingTerrainTag
if terrain==PBTerrain::Waterfall
Kernel.pbWaterfall
return
end
if terrain==PBTerrain::WaterfallCrest
Kernel.pbMessage(_INTL("A wall of water is crashing down with a mighty roar."))
return
end
}
HiddenMoveHandlers::CanUseMove.add(:WATERFALL,proc{|move,pkmn|
if !$DEBUG &&
!(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORWATERFALL : $Trainer.badges[BADGEFORWATERFALL])
Kernel.pbMessage(_INTL("Sorry, a new Badge is required."))
return false
end
terrain=Kernel.pbFacingTerrainTag
if terrain!=PBTerrain::Waterfall
Kernel.pbMessage(_INTL("Can't use that here."))
return false
end
return true
})
HiddenMoveHandlers::UseMove.add(:WATERFALL,proc{|move,pokemon|
if !pbHiddenMoveAnimation(pokemon)
Kernel.pbMessage(_INTL("{1} used {2}.",pokemon.name,PBMoves.getName(move)))
end
Kernel.pbAscendWaterfall
return true
})
#===============================================================================
# Rock Climb
#===============================================================================
Events.onAction+=proc{|sender,e|
terrain=Kernel.pbFacingTerrainTag
if terrain==PBTerrain::Ledge
pbRockClimb()
return
end
}
HiddenMoveHandlers::CanUseMove.add(:ROCKCLIMB,proc{|move,pkmn|
pbRockClimb()
})
def pbRockClimb()
if !$DEBUG &&
!(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORROCKCLIMB : $Trainer.badges[BADGEFORWATERFALL])
return false
end
terrain=Kernel.pbFacingTerrainTag
if terrain!=PBTerrain::Ledge
Kernel.pbMessage(_INTL("Can't use that here."))
return false
end
Kernel.pbClimbLedge
return true
end
HiddenMoveHandlers::UseMove.add(:WATERFALL,proc{|move,pokemon|
if !pbHiddenMoveAnimation(pokemon)
Kernel.pbMessage(_INTL("{1} used {2}.",pokemon.name,PBMoves.getName(move)))
end
Kernel.pbClimbLedge
return true
})
def Kernel.pbClimbLedge(event=nil)
if Kernel.pbFacingTerrainTag==PBTerrain::Ledge
if Kernel.pbConfirmMessage(_INTL("It looks like it's possible to climb. Would you like to use Rock Climb?"))
if Kernel.pbJumpToward(2,true)
$scene.spriteset.addUserAnimation(DUST_ANIMATION_ID,$game_player.x,$game_player.y,true)
$game_player.increase_steps
$game_player.check_event_trigger_here([1,2])
end
return true
end
return false
end
end
#===============================================================================
# Dive
#===============================================================================
def Kernel.pbDive
divemap=pbGetMetadata($game_map.map_id,MetadataDiveMap)
return false if !divemap
if $DEBUG ||
(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORDIVE : $Trainer.badges[BADGEFORDIVE])
movefinder=Kernel.pbCheckMove(:DIVE)
if $DEBUG || movefinder || $PokemonBag.pbQuantity(PBItems::SCUBAGEAR)
if Kernel.pbConfirmMessage(_INTL("The sea is deep here. Would you like to use Dive?"))
speciesname=!movefinder ? $Trainer.name : movefinder.name
Kernel.pbMessage(_INTL("{1} used Dive.",speciesname))
pbHiddenMoveAnimation(movefinder)
pbFadeOutIn(99999){
$game_temp.player_new_map_id=divemap
$game_temp.player_new_x=$game_player.x
$game_temp.player_new_y=$game_player.y
$game_temp.player_new_direction=$game_player.direction
Kernel.pbCancelVehicles
$PokemonGlobal.diving=true
$game_screen.weather(0,0,0)
Kernel.pbUpdateVehicle
$scene.transfer_player(false)
$game_map.autoplay
$game_map.refresh
}
return true
end
else
Kernel.pbMessage(_INTL("The sea is deep here. A Pokémon may be able to go underwater."))
end
else
Kernel.pbMessage(_INTL("The sea is deep here. A Pokémon may be able to go underwater."))
end
return false
end
def Kernel.pbSurfacing
return if !$PokemonGlobal.diving
divemap=nil
meta=pbLoadMetadata
for i in 0...meta.length
if meta[i] && meta[i][MetadataDiveMap]
if meta[i][MetadataDiveMap]==$game_map.map_id
divemap=i
break
end
end
end
return if !divemap
movefinder=Kernel.pbCheckMove(:DIVE)
#if $DEBUG || (movefinder &&
# (HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORDIVE : $Trainer.badges[BADGEFORDIVE]) &&
if (canSurfaceHere?(divemap,$game_player.x,$game_player.y))
if Kernel.pbConfirmMessage(_INTL("Light is filtering down from above. Would you like to use Dive?"))
speciesname=!movefinder ? $Trainer.name : movefinder.name
Kernel.pbMessage(_INTL("{1} used Dive.",speciesname))
pbHiddenMoveAnimation(movefinder)
pbFadeOutIn(99999){
$game_temp.player_new_map_id=divemap
$game_temp.player_new_x=$game_player.x
$game_temp.player_new_y=$game_player.y
$game_temp.player_new_direction=$game_player.direction
Kernel.pbCancelVehicles
$PokemonGlobal.surfing=true
Kernel.pbUpdateVehicle
$scene.transfer_player(false)
surfbgm=pbGetMetadata(0,MetadataSurfBGM)
if surfbgm
pbBGMPlay(surfbgm)
else
$game_map.autoplayAsCue
end
$game_map.refresh
}
return true
end
else
Kernel.pbMessage(_INTL("It's impossible to surface here!"))
$PokemonGlobal.surfing = false
end
return false
end
def canSurfaceHere?(mapID,x,y)
terrainTag = $MapFactory.getTerrainTag(mapID,x,y)
map = $MapFactory.getMapNoAdd(mapID)
$PokemonGlobal.surfing = true
#Kernel.pbMessage(_INTL("{1}",mapID))
return pbIsPassableWaterTag?(terrainTag) &&
map.playerPassable?(x,y,0)
end
def Kernel.pbTransferUnderwater(mapid,xcoord,ycoord,direction=$game_player.direction)
pbFadeOutIn(99999){
$game_temp.player_new_map_id=mapid
$game_temp.player_new_x=xcoord
$game_temp.player_new_y=ycoord
$game_temp.player_new_direction=direction
Kernel.pbCancelVehicles
$PokemonGlobal.diving=true
Kernel.pbUpdateVehicle
$scene.transfer_player(false)
$game_map.autoplay
$game_map.refresh
}
end
def Kernel.pbTransfer(mapid,xcoord,ycoord,direction=$game_player.direction)
pbFadeOutIn(99999){
$game_temp.player_new_map_id=mapid
$game_temp.player_new_x=xcoord
$game_temp.player_new_y=ycoord
$game_temp.player_new_direction=direction
$scene.transfer_player(false)
$game_map.autoplay
$game_map.refresh
}
end
Events.onAction+=proc{|sender,e|
terrain=$game_player.terrain_tag
if terrain==PBTerrain::DeepWater
Kernel.pbDive
return
end
if $PokemonGlobal.diving
if DIVINGSURFACEANYWHERE
Kernel.pbSurfacing
return
else
divemap=nil
meta=pbLoadMetadata
for i in 0...meta.length
if meta[i] && meta[i][MetadataDiveMap]
if meta[i][MetadataDiveMap]==$game_map.map_id
divemap=i
break
end
end
end
if $MapFactory.getTerrainTag(divemap,$game_player.x,$game_player.y)==PBTerrain::DeepWater
Kernel.pbSurfacing
return
end
end
end
}
HiddenMoveHandlers::CanUseMove.add(:DIVE,proc{|move,pkmn|
if !$DEBUG &&
!(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORDIVE : $Trainer.badges[BADGEFORDIVE])
Kernel.pbMessage(_INTL("Sorry, a new Badge is required."))
return false
end
if $PokemonGlobal.diving
return true if DIVINGSURFACEANYWHERE
divemap=nil
meta=pbLoadMetadata
for i in 0...meta.length
if meta[i] && meta[i][MetadataDiveMap]
if meta[i][MetadataDiveMap]==$game_map.map_id
divemap=i
break
end
end
end
if $MapFactory.getTerrainTag(divemap,$game_player.x,$game_player.y)==PBTerrain::DeepWater
return true
else
Kernel.pbMessage(_INTL("Can't use that here."))
return false
end
end
if $game_player.terrain_tag!=PBTerrain::DeepWater
Kernel.pbMessage(_INTL("Can't use that here."))
return false
end
if !pbGetMetadata($game_map.map_id,MetadataDiveMap)
Kernel.pbMessage(_INTL("Can't use that here."))
return false
end
return true
})
HiddenMoveHandlers::UseMove.add(:DIVE,proc{|move,pokemon|
wasdiving=$PokemonGlobal.diving
if $PokemonGlobal.diving
divemap=nil
meta=pbLoadMetadata
for i in 0...meta.length
if meta[i] && meta[i][MetadataDiveMap]
if meta[i][MetadataDiveMap]==$game_map.map_id
divemap=i
break
end
end
end
else
divemap=pbGetMetadata($game_map.map_id,MetadataDiveMap)
end
return false if !divemap
if !pbHiddenMoveAnimation(pokemon)
Kernel.pbMessage(_INTL("{1} used {2}.",pokemon.name,PBMoves.getName(move)))
end
pbFadeOutIn(99999){
$game_temp.player_new_map_id=divemap
$game_temp.player_new_x=$game_player.x
$game_temp.player_new_y=$game_player.y
$game_temp.player_new_direction=$game_player.direction
Kernel.pbCancelVehicles
if wasdiving
$PokemonGlobal.surfing=true
else
$PokemonGlobal.diving=true
end
Kernel.pbUpdateVehicle
$scene.transfer_player(false)
$game_map.autoplay
$game_map.refresh
}
return true
})
#===============================================================================
# Flash
#===============================================================================
HiddenMoveHandlers::CanUseMove.add(:FLASH,proc{|move,pkmn|
if !$DEBUG &&
!(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORFLASH : $Trainer.badges[BADGEFORFLASH])
Kernel.pbMessage(_INTL("Sorry, a new Badge is required."))
return false
end
if !pbGetMetadata($game_map.map_id,MetadataDarkMap)
Kernel.pbMessage(_INTL("Can't use that here."))
return false
end
if $PokemonGlobal.flashUsed
Kernel.pbMessage(_INTL("This is in use already."))
return false
end
return true
})
HiddenMoveHandlers::UseMove.add(:FLASH,proc{|move,pokemon|
darkness=$PokemonTemp.darknessSprite
return false if !darkness || darkness.disposed?
if !pbHiddenMoveAnimation(pokemon)
Kernel.pbMessage(_INTL("{1} used {2}!",pokemon.name,PBMoves.getName(move)))
end
$PokemonGlobal.flashUsed=true
darkness.radius+=200
#while darkness.radius<176
# Graphics.update
# Input.update
# pbUpdateSceneMap
# darkness.radius+=4
#end
return true
})
############### MORNING SUN / MOONLIGHT
HiddenMoveHandlers::CanUseMove.add(:MORNINGSUN,proc{|move,pkmn|
if !pbGetMetadata($game_map.map_id,MetadataOutdoor)
Kernel.pbMessage(_INTL("Can't use that here."))
return false
end
return true
})
HiddenMoveHandlers::UseMove.add(:MORNINGSUN,proc{|move,pokemon|
Kernel.pbMessage(_INTL("{1} used {2}!",pokemon.name,PBMoves.getName(move)))
pbHiddenMoveAnimation(pokemon)
pbFadeOutIn(99999){
pbSkipTime(9)
newTime = pbGetTimeNow.strftime("%I:%M %p")
Kernel.pbMessage(_INTL("{1} waited until morning...",$Trainer.name))
Kernel.pbMessage(_INTL("The time is now {1}",newTime))
$game_screen.weather(0,0,0)
$game_map.refresh
}
return true
})
HiddenMoveHandlers::CanUseMove.add(:MOONLIGHT,proc{|move,pkmn|
if !pbGetMetadata($game_map.map_id,MetadataOutdoor)
Kernel.pbMessage(_INTL("Can't use that here."))
return false
end
return true
})
HiddenMoveHandlers::UseMove.add(:MOONLIGHT,proc{|move,pokemon|
Kernel.pbMessage(_INTL("{1} used {2}!",pokemon.name,PBMoves.getName(move)))
pbHiddenMoveAnimation(pokemon)
pbFadeOutIn(99999){
pbSkipTime(21)
newTime = pbGetTimeNow.strftime("%I:%M %p")
Kernel.pbMessage(_INTL("{1} waited until night...",$Trainer.name))
Kernel.pbMessage(_INTL("The time is now {1}",newTime))
$game_screen.weather(0,0,0)
$game_map.refresh
}
return true
})
def pbSkipTime(newTime)
currentTime = pbGetTimeNow.hour
#hoursToAdd = (24-currentTime + newTime)-24
hoursToAdd = newTime - currentTime
$game_variables[79] += hoursToAdd*3600
end
############### WEATHER MOVES
#Rain Dance
HiddenMoveHandlers::UseMove.add(:RAINDANCE,proc{|move,pokemon|
Kernel.pbMessage(_INTL("{1} used {2}!",pokemon.name,PBMoves.getName(move)))
pbHiddenMoveAnimation(pokemon)
if $game_screen.weather_type==1
Kernel.pbMessage(_INTL("It stopped raining!"))
$game_map.refresh
$game_screen.weather(0,0,20)
else
Kernel.pbMessage(_INTL("It started to rain!"))
$game_map.refresh
$game_screen.weather(1,2,20)
end
return true
})
HiddenMoveHandlers::CanUseMove.add(:RAINDANCE,proc{|move,pkmn|
if !pbGetMetadata($game_map.map_id,MetadataOutdoor)
Kernel.pbMessage(_INTL("Can't use that here."))
return false
end
return true
})
#Sunny Day
HiddenMoveHandlers::UseMove.add(:SUNNYDAY,proc{|move,pokemon|
Kernel.pbMessage(_INTL("{1} used {2}!",pokemon.name,PBMoves.getName(move)))
pbHiddenMoveAnimation(pokemon)
if $game_screen.weather_type==5
Kernel.pbMessage(_INTL("The sunlight faded."))
$game_map.refresh
$game_screen.weather(0,0,20)
else
Kernel.pbMessage(_INTL("The sunlight turned harsh!"))
$game_map.refresh
$game_screen.weather(5,2,20)
end
return true
})
HiddenMoveHandlers::CanUseMove.add(:SUNNYDAY,proc{|move,pkmn|
if !pbGetMetadata($game_map.map_id,MetadataOutdoor) || !PBDayNight.isDay?(pbGetTimeNow)
Kernel.pbMessage(_INTL("Can't use that now."))
return false
end
return true
})
#Hail
HiddenMoveHandlers::UseMove.add(:HAIL,proc{|move,pokemon|
Kernel.pbMessage(_INTL("{1} used {2}!",pokemon.name,PBMoves.getName(move)))
pbHiddenMoveAnimation(pokemon)
if $game_screen.weather_type==3
Kernel.pbMessage(_INTL("It stopped hailing"))
$game_map.refresh
$game_screen.weather(0,0,20)
else
Kernel.pbMessage(_INTL("It started to hail!"))
$game_map.refresh
$game_screen.weather(3,2,20)
end
return true
})
HiddenMoveHandlers::CanUseMove.add(:HAIL,proc{|move,pkmn|
if !pbGetMetadata($game_map.map_id,MetadataOutdoor)
Kernel.pbMessage(_INTL("Can't use that here."))
return false
end
return true
})
#sandstorm
HiddenMoveHandlers::UseMove.add(:SANDSTORM,proc{|move,pokemon|
Kernel.pbMessage(_INTL("{1} used {2}!",pokemon.name,PBMoves.getName(move)))
pbHiddenMoveAnimation(pokemon)
if $game_screen.weather_type==7
Kernel.pbMessage(_INTL("The sandstorm faded."))
$game_map.refresh
$game_screen.weather(0,0,20)
else
Kernel.pbMessage(_INTL("A sandstorm brewed up!"))
$game_map.refresh
$game_screen.weather(7,2,20)
end
return true
})
HiddenMoveHandlers::CanUseMove.add(:SANDSTORM,proc{|move,pkmn|
if !pbGetMetadata($game_map.map_id,MetadataOutdoor)
Kernel.pbMessage(_INTL("Can't use that here."))
return false
end
return true
})

1717
Data/Scripts_backup/024_Addons/New Items effects.rb Normal file
View File

File diff suppressed because it is too large Load Diff

1327
Data/Scripts_backup/024_Addons/PokemonFusion.rb Normal file
View File

File diff suppressed because it is too large Load Diff

940
Data/Scripts_backup/024_Addons/QuestLogScript.rb Normal file
View File

@@ -0,0 +1,940 @@
##=##===========================================================================
##=## Easy Questing System - made by M3rein
##=##===========================================================================
##=## Create your own quests starting from line 72. Be aware of the following:
##=## * Every quest should have a unique ID;
##=## * Every quest should be unique (at least one field has to be different);
##=## * The "Name" field can't be very long;
##=## * The "Desc" field can be quite long;
##=## * The "NPC" field is JUST a name;
##=## * The "Sprite" field is the name of the sprite in "Graphics/Characters";
##=## * The "Location" field is JUST a name;
##=## * The "Color" field is a SYMBOL (starts with ':'). List under "pbColor";
##=## * The "Time" field can be a random string for it to be "?????" in-game;
##=## * The "Completed" field can be pre-set, but is normally only changed in-game
##=##===========================================================================
class Quest
attr_accessor :id
attr_accessor :name
attr_accessor :desc
attr_accessor :npc
attr_accessor :sprite
attr_accessor :location
attr_accessor :color
attr_accessor :time
attr_accessor :completed
def initialize(id, name, desc, npc, sprite, location, color = :WHITE, time = Time.now, completed = false)
self.id = id
self.name = name
self.desc = desc
self.npc = npc
self.sprite = sprite
self.location = location
self.color = self.npc == "Hotel Quests"? pbColor(:BLUE) :pbColor(color)
self.time = time
self.completed = completed
end
end
def pbColor(color)
# Mix your own colors: http://www.rapidtables.com/web/color/RGB_Color.htm
return Color.new(0,0,0) if color == :BLACK
return Color.new(255,115,115) if color == :LIGHTRED
return Color.new(245,11,11) if color == :RED
return Color.new(164,3,3) if color == :DARKRED
return Color.new(47,46,46) if color == :DARKGREY
return Color.new(100,92,92) if color == :LIGHTGREY
return Color.new(226,104,250) if color == :PINK
return Color.new(243,154,154) if color == :PINKTWO
return Color.new(255,160,50) if color == :GOLD
return Color.new(255,186,107) if color == :LIGHTORANGE
return Color.new(95,54,6) if color == :BROWN
return Color.new(122,76,24) if color == :LIGHTBROWN
return Color.new(255,246,152) if color == :LIGHTYELLOW
return Color.new(242,222,42) if color == :YELLOW
return Color.new(80,111,6) if color == :DARKGREEN
return Color.new(154,216,8) if color == :GREEN
return Color.new(197,252,70) if color == :LIGHTGREEN
return Color.new(74,146,91) if color == :FADEDGREEN
return Color.new(6,128,92) if color == :DARKLIGHTBLUE
return Color.new(18,235,170) if color == :LIGHTBLUE
return Color.new(139,247,215) if color == :SUPERLIGHTBLUE
return Color.new(35,203,255) if color == :BLUE
return Color.new(3,44,114) if color == :DARKBLUE
return Color.new(7,3,114) if color == :SUPERDARKBLUE
return Color.new(63,6,121) if color == :DARKPURPLE
return Color.new(113,16,209) if color == :PURPLE
return Color.new(219,183,37) if color == :ORANGE
return Color.new(255,255,255)
end
defaultQuestColor = :PURPLE
questBranchHotels = "Hotel Quests"
questBranchField = "Field Quests"
QUESTS = [
#Pewter hotel
Quest.new(0, "Mushroom Gathering", "A lady in Pewter City wants you to bring her 3 TinyMushroom from Viridian Forest to make a stew.", questBranchHotels, "BW (74)", "Pewter City", defaultQuestColor),
Quest.new(1, "Lost Medicine", "A youngster in Pewter City needs your help to find a lost Revive. He lost it by sitting on a bench somewhere in Pewter City.", questBranchHotels, "BW (19)", "Pewter City", defaultQuestColor),
Quest.new(2, "Bug Evolution", "A Bug Catcher in Pewter City wants you to show him a fully-evolved Bug Pokémon.", questBranchHotels, "BWBugCatcher_male", "Pewter City", defaultQuestColor),
#Cerulean hotel
Quest.new(3, "Playing Cupid", "A boy in Cerulean City wants you bring a love letter to a Pokémon Breeder named Maude. She's probably somewhere in one of the routes near Cerulean City", questBranchHotels, "BW (18)","Cerulean City", defaultQuestColor),
Quest.new(4, "Fishing for Sole", "A fisherman wants you to fish up an old boot. Hook it up with the old rod in any body of water.", questBranchHotels, "BW (71)","Cerulean City", defaultQuestColor),
Quest.new(5, "Johto Pokémon", "A woman in Cerulean City wants you to show her a Pokémon native to the Johto region.", questBranchHotels, "BW (37)","Cerulean City", defaultQuestColor),
#Route 24
Quest.new(6, "Field Research (Part 1)", "Professor Oak's aide wants you to catch an Abra.", questBranchField, "BW (82)","Route 24", defaultQuestColor),
Quest.new(7, "Field Research (Part 2)", "Professor Oak's aide wants you to encounter every Pokémon on Route 24.", questBranchField, "BW (82)","Route 24", defaultQuestColor),
Quest.new(8, "Field Research (Part 3)", "Professor Oak's aide wants you to catch a Buneary using the Pokéradar.", questBranchField, "BW (82)","Route 24", defaultQuestColor),
#Vermillion City
Quest.new(9, "Unusual Types 1", "A woman at the hotel wants you to show her a Water/Fire-type Pokémon", questBranchHotels, "BW (58)","Vermillion City", defaultQuestColor),
Quest.new(10, "Trainer House", "Earn 10 Trainer Points at the Trainer House in Viridian City", questBranchHotels, "BW (55)","Vermillion City", defaultQuestColor),
Quest.new(11, "Powering the Lighthouse", "Catch some Voltorb to power up the lighthouse", questBranchHotels, "BW (43)","Vermillion City", defaultQuestColor),
Quest.new(12, "Seafood Cocktail ", "Get some steamed Krabby legs from the S.S. Anne's kitchen and bring them back to the hotel before they get cold", questBranchHotels, "BW (36)","Vermillion City", defaultQuestColor),
Quest.new(13, "Building Materials ", "Get some wooden planks from Viridian City and some Bricks from Pewter City.", questBranchField, "BW (36)","Vermillion City", defaultQuestColor),
#Celadon City
Quest.new(14, "Sun or Moon", "Show the Pokémon that Eevee evolves when exposed to a Moon or Sun stone to help the scientist with her research.", questBranchHotels, "BW (82)","Celadon City", defaultQuestColor),
Quest.new(15, "For Whom the Bell Tolls", "Ring Lavender Town's bell when the time is right to reveal its secret.", questBranchHotels, "BW (40)","Lavender Town", defaultQuestColor),
Quest.new(16, "Hardboiled", "A lady wants you to give her an egg to make an omelette.", questBranchHotels, "BW (24)","Celadon City", defaultQuestColor),
Quest.new(17, "A stroll with Eevee!", "Walk Eevee around for a while until it gets tired.", questBranchField, "BW (37)","Celadon City", defaultQuestColor),
#Fuchsia City
Quest.new(18, "Cleaning up the Cycling Road", "Get rid of all the Pokémon dirtying up the Cycling Road.", questBranchHotels, "BW (77)","Fuchsia City", defaultQuestColor),
Quest.new(19, "Lost Pokémon!", "Find the lost Chansey's trainer!", questBranchHotels, "113","Fuchsia City", defaultQuestColor),
Quest.new(20, "Bicycle Race!", "Go meet the Cyclist at the bottom of Route 17 and beat her time up the Cycling Road!", questBranchHotels, "BW032","Cycling Road", defaultQuestColor),
#Crimson City
Quest.new(21, "Shellfish Rescue", "Put all the stranded Shellders back in the water on the route to Crimson City.", questBranchHotels, "BW (48)","Crimson City", defaultQuestColor),
Quest.new(22, "Fourth Round Rumble", "Defeat Jeanette and her high-level Bellsprout in a Pokémon Battle", questBranchHotels, "BW024","Crimson City", defaultQuestColor),
Quest.new(23, "Unusual Types 2", "A woman at the hotel wants you to show her a Normal/Ghost-type Pokémon", questBranchHotels, "BW (58)","Crimson City", defaultQuestColor),
#Saffron City
Quest.new(24, "Dancing Queen!", "Dance with the Copycat Girl!", questBranchField, "BW (24)","Saffron City (nightclub)", defaultQuestColor),
Quest.new(25, "Sinnoh Pokémon", "A woman wants you to show her a Pokémon native to the Sinnoh region.", questBranchHotels, "BW (37)","Saffron City", defaultQuestColor),
Quest.new(26, "Lost Puppies", "Find all of the missing Growlithe in the routes around Saffron City.", questBranchHotels, "BW (73)","Saffron City", defaultQuestColor),
Quest.new(27, "Invisible Pokémon", "Find an invisible Pokémon in the eastern part of Saffron City.", questBranchHotels, "BW (57)","Saffron City", defaultQuestColor),
Quest.new(28, "Bad to the Bone!", "Find a Rare Bone using Rock Smash.", questBranchHotels, "BW (72)","Saffron City", defaultQuestColor),
#Cinnabar Island
Quest.new(29, "Powder metallurgy", "The scientist at the hotel wants you to find some Metal Powder.", questBranchHotels, "BW (82)","Cinnabar Island", defaultQuestColor),
Quest.new(30, "Diamonds and Pearls", "Find a Diamond Necklace to save the man's marriage.", questBranchHotels, "BW (71)","Cinnabar Island", defaultQuestColor),
Quest.new(42, "Stolen artifact", "Recover a stolen vase from a burglar in the Pokémon Mansion", questBranchHotels, "BW (21)","Cinnabar Island", defaultQuestColor),
#Goldenrod City
Quest.new(31, "Hoenn Pokémon", "A woman wants you to show her a Pokémon native to the Hoenn region.", questBranchHotels, "BW (37)","Goldenrod City", defaultQuestColor),
Quest.new(32, "Safari Souvenir!", "Bring back a souvenir from the Fuchsia City Safari Zone", questBranchHotels, "BW (28)","Goldenrod City", defaultQuestColor),
#Violet City
Quest.new(33, "Defuse the Pinecones!", "Get rid of all the Pineco on Route 31 and Route 30", questBranchHotels, "BW (64)","Violet City", defaultQuestColor),
Quest.new(34, "Find Slowpoke's Tail!", "Find a SlowpokeTail in some flowers, somewhere around Violet City!", questBranchHotels, "BW (19)","Violet City", defaultQuestColor),
#Blackthorn City
Quest.new(35, "Dragon Evolution", "A Dragon Tamer in Blackthorn City wants you to show her a fully-evolved Dragon Pokémon.", questBranchHotels, "BW014","Blackthorn City", defaultQuestColor),
Quest.new(36, "Sunken Treasure!", "Find an old memorabilia on a sunken ship near Cinnabar Island.", questBranchHotels, "BW (28)","Blackthorn City", defaultQuestColor),
Quest.new(37, "The Largest Carp", "A fisherman wants you to fish up a Magikarp that's exceptionally high-level at Dragon's Den.", questBranchHotels, "BW (71)","Blackthorn City", defaultQuestColor),
#Ecruteak City
Quest.new(38, "Kalos Pokémon", "A woman wants you to show her a Pokémon native to the Kalos region.", questBranchHotels, "BW (37)","Ecruteak City", defaultQuestColor),
Quest.new(39, "Ghost Evolution", "A girl in Ecruteak City wants you to show her a fully-evolved Ghost Pokémon.", questBranchHotels, "BW014","Ecruteak City", defaultQuestColor),
#Kin Island
Quest.new(40, "Banana Slamma!", "Collect 30 bananas", questBranchHotels, "BW029","Kin Island", defaultQuestColor),
Quest.new(41, "Unova Pokémon", "A woman wants you to show her a Pokémon native to the Unova region.", questBranchHotels, "BW (37)","Kin Island", defaultQuestColor),
Quest.new(43, "Fallen Meteor", "Investigate a crater near Bond Bridge.", questBranchHotels, "BW009","Kin Island", defaultQuestColor),
Quest.new(44, "First Contact", "Find the missing pieces of a fallen alien spaceship", questBranchHotels, "BW (92)","Bond Bridge", questBranchField),
Quest.new(45, "First Contact (Part 2)", "Ask the sailor at Cinnabar Island's harbour to take you to the uncharted island where the spaceship might be located", questBranchHotels, "BW (92)","Bond Bridge", questBranchField),
#out of order quests
#42 (cinnabar)
]
class PokeBattle_Trainer
attr_accessor :quests
end
def pbAcceptNewQuest(id,bubblePosition=20)
return if isQuestAlreadyAccepted?(id)
$game_variables[96] += 1 #nb. quests accepted
$game_variables[97] += 1 #nb. quests active
title = QUESTS[id].name
description = QUESTS[id].desc
pbMEPlay("Voltorb Flip Win")
pbCallBub(1,bubblePosition)
Kernel.pbMessage("\\C[6]NEW QUEST: " + title)
pbCallBub(1,bubblePosition)
Kernel.pbMessage("\\C[1]" + description)
pbAddQuest(id)
end
def isQuestAlreadyAccepted?(id)
$Trainer.quests = [] if $Trainer.quests.class == NilClass
for quest in $Trainer.quests
return true if quest.id == id
end
return false
end
def finishQuest(id)
$game_variables[222] +=1 # karma
$game_variables[97] -=1 #nb. quests active
$game_variables[98] +=1 #nb. quests completed
pbSetQuest(id, true)
end
def pbCompletedQuest?(id)
$Trainer.quests = [] if $Trainer.quests.class == NilClass
for i in 0...$Trainer.quests.size
return true if $Trainer.quests[i].completed && $Trainer.quests[i].id == id
end
return false
end
def pbQuestlog
Questlog.new
end
def pbAddQuest(id)
$Trainer.quests = [] if $Trainer.quests.class == NilClass
for q in QUESTS
$Trainer.quests << q if q.id == id
end
end
def pbDeleteQuest(id)
$Trainer.quests = [] if $Trainer.quests.class == NilClass
for q in $Trainer.quests
$Trainer.quests.delete(q) if q.id == id
end
end
def pbSetQuest(id, completed)
$Trainer.quests = [] if $Trainer.quests.class == NilClass
for q in $Trainer.quests
q.completed = completed if q.id == id
end
end
def pbSetQuestName(id, name)
$Trainer.quests = [] if $Trainer.quests.class == NilClass
for q in $Trainer.quests
q.name = name if q.id == id
end
end
def pbSetQuestDesc(id, desc)
$Trainer.quests = [] if $Trainer.quests.class == NilClass
for q in $Trainer.quests
q.desc = desc if q.id == id
end
end
def pbSetQuestNPC(id, npc)
$Trainer.quests = [] if $Trainer.quests.class == NilClass
for q in $Trainer.quests
q.npc = npc if q.id == id
end
end
def pbSetQuestNPCSprite(id, sprite)
$Trainer.quests = [] if $Trainer.quests.class == NilClass
for q in $Trainer.quests
q.sprite = sprite if q.id == id
end
end
def pbSetQuestLocation(id, location)
$Trainer.quests = [] if $Trainer.quests.class == NilClass
for q in $Trainer.quests
q.location = location if q.id == id
end
end
def pbSetQuestColor(id, color)
$Trainer.quests = [] if $Trainer.quests.class == NilClass
for q in $Trainer.quests
q.color = pbColor(color) if q.id == id
end
end
class QuestSprite < IconSprite
attr_accessor :quest
end
class Questlog
def initialize
$Trainer.quests = [] if $Trainer.quests.class == NilClass
@page = 0
@sel_one = 0
@sel_two = 0
@scene = 0
@mode = 0
@box = 0
@completed = []
@ongoing = []
for q in $Trainer.quests
@ongoing << q if !q.completed
@completed << q if q.completed
end
@viewport = Viewport.new(0, 0, Graphics.width, Graphics.height)
@viewport.z = 99999
@sprites = {}
@sprites["main"] = BitmapSprite.new(Graphics.width, Graphics.height, @viewport)
@sprites["main"].z = 1
@sprites["main"].opacity = 0
@main = @sprites["main"].bitmap
pbSetSystemFont(@main)
pbDrawOutlineText(@main,0,2-178,512,384,"Quest Log",Color.new(255,255,255),Color.new(0,0,0),1)
@sprites["bg0"] = IconSprite.new(0, 0, @viewport)
@sprites["bg0"].setBitmap("Graphics/Pictures/pokegearbg")
@sprites["bg0"].opacity = 0
for i in 0..1
@sprites["btn#{i}"] = IconSprite.new(0, 0, @viewport)
@sprites["btn#{i}"].setBitmap("Graphics/Pictures/EQI/questBtn")
@sprites["btn#{i}"].x = 84
@sprites["btn#{i}"].y = 130 + 56 * i
@sprites["btn#{i}"].src_rect.height = (@sprites["btn#{i}"].bitmap.height / 2).round
@sprites["btn#{i}"].src_rect.y = i == 0 ? (@sprites["btn#{i}"].bitmap.height / 2).round : 0
@sprites["btn#{i}"].opacity = 0
end
pbDrawOutlineText(@main,0,142-178,512,384,"Ongoing: " + @ongoing.size.to_s,Color.new(255,255,255),Color.new(0,0,0),1)
pbDrawOutlineText(@main,0,198-178,512,384,"Completed: " + @completed.size.to_s,Color.new(255,255,255),Color.new(0,0,0),1)
12.times do |i|
Graphics.update
@sprites["bg0"].opacity += 32 if i < 8
@sprites["btn0"].opacity += 32 if i > 3
@sprites["btn1"].opacity += 32 if i > 3
@sprites["main"].opacity += 64 if i > 7
end
pbUpdate
end
def pbUpdate
@frame = 0
loop do
@frame += 1
Graphics.update
Input.update
if @scene == 0
break if Input.trigger?(Input::B)
pbList(@sel_one) if Input.trigger?(Input::C)
pbSwitch(:DOWN) if Input.trigger?(Input::DOWN)
pbSwitch(:UP) if Input.trigger?(Input::UP)
end
if @scene == 1
pbMain if Input.trigger?(Input::B)
pbMove(:DOWN) if Input.trigger?(Input::DOWN)
pbMove(:UP) if Input.trigger?(Input::UP)
pbLoad(0) if Input.trigger?(Input::C)
pbArrows
end
if @scene == 2
pbList(@sel_one) if Input.trigger?(Input::B)
pbChar if @frame == 6 || @frame == 12 || @frame == 18
#pbLoad(1) if Input.trigger?(Input::RIGHT) && @page == 0
#pbLoad(2) if Input.trigger?(Input::LEFT) && @page == 1
end
@frame = 0 if @frame == 18
end
pbEnd
pbDisposeSpriteHash(@sprites)
@viewport.dispose
pbWait(1)
end
def pbArrows
if @frame == 2 || @frame == 4 || @frame == 14 || @frame == 16
@sprites["up"].y -= 1 rescue nil
@sprites["down"].y -= 1 rescue nil
elsif @frame == 6 || @frame == 8 || @frame == 10 || @frame == 12
@sprites["up"].y += 1 rescue nil
@sprites["down"].y += 1 rescue nil
end
end
def pbLoad(page)
return if @mode == 0 ? @ongoing.size == 0 : @completed.size == 0
quest = @mode == 0 ? @ongoing[@sel_two] : @completed[@sel_two]
pbWait(1)
if page == 0
@scene = 2
@sprites["bg1"] = IconSprite.new(0, 0, @viewport)
@sprites["bg1"].setBitmap("Graphics/Pictures/EQI/questPage1")
@sprites["bg1"].opacity = 0
@sprites["pager"] = IconSprite.new(0, 0, @viewport)
@sprites["pager"].setBitmap("Graphics/Pictures/EQI/questPager")
@sprites["pager"].x = 442
@sprites["pager"].y = 3
@sprites["pager"].z = 1
@sprites["pager"].opacity = 0
8.times do
Graphics.update
@sprites["up"].opacity -= 32
@sprites["down"].opacity -= 32
@sprites["main"].opacity -= 32
@sprites["bg1"].opacity += 32
@sprites["pager"].opacity =0
@sprites["char"].opacity -= 32 rescue nil
for i in 0...@ongoing.size
break if i > 5
@sprites["ongoing#{i}"].opacity -= 32 rescue nil
end
for i in 0...@completed.size
break if i > 5
@sprites["completed#{i}"].opacity -= 32 rescue nil
end
end
@sprites["up"].dispose
@sprites["down"].dispose
@sprites["char"] = IconSprite.new(0, 0, @viewport)
@sprites["char"].setBitmap("Graphics/Characters/#{quest.sprite}")
@sprites["char"].x = 62
@sprites["char"].y = 130
@sprites["char"].src_rect.height = (@sprites["char"].bitmap.height / 4).round
@sprites["char"].src_rect.width = (@sprites["char"].bitmap.width / 4).round
@sprites["char"].opacity = 0
@main.clear
@text.clear rescue nil
@text2.clear rescue nil
drawTextExMulti(@main,188,54,318,8,quest.desc,Color.new(255,255,255),Color.new(0,0,0))
pbDrawOutlineText(@main,188,162,512,384,quest.location,Color.new(255,172,115),Color.new(0,0,0))
pbDrawOutlineText(@main,10,-178,512,384,quest.name,quest.color,Color.new(0,0,0))
if !quest.completed
pbDrawOutlineText(@main,8,136,512,384,"Not Completed",pbColor(:LIGHTRED),Color.new(0,0,0))
else
pbDrawOutlineText(@main,8,136,512,384,"Completed",pbColor(:LIGHTBLUE),Color.new(0,0,0))
end
10.times do |i|
Graphics.update
@sprites["main"].opacity += 32
@sprites["char"].opacity += 32 if i > 1
end
elsif page == 1
@page = 1
@sprites["bg2"] = IconSprite.new(0, 0, @viewport)
@sprites["bg2"].setBitmap("Graphics/Pictures/EQI/questPage1")
@sprites["bg2"].x = 512
@sprites["pager2"] = IconSprite.new(0, 0, @viewport)
#@sprites["pager2"].setBitmap("Graphics/Pictures/EQI/questPager")
#@sprites["pager2"].x = 474 + 512
#@sprites["pager2"].y = 3
#@sprites["pager2"].z = 1
@sprites["char2"].dispose rescue nil
@sprites["char2"] = IconSprite.new(0, 0, @viewport)
@sprites["char2"].setBitmap("Graphics/Characters/#{quest.sprite}")
@sprites["char2"].x = 62 + 512
@sprites["char2"].y = 130
@sprites["char2"].z = 1
@sprites["char2"].src_rect.height = (@sprites["char2"].bitmap.height / 4).round
@sprites["char2"].src_rect.width = (@sprites["char2"].bitmap.width / 4).round
@sprites["text2"] = IconSprite.new(@viewport)
@sprites["text2"].bitmap = Bitmap.new(Graphics.width,Graphics.height)
@text2 = @sprites["text2"].bitmap
pbSetSystemFont(@text2)
pbDrawOutlineText(@text2,188,-122,512,384,"Quest received in:",Color.new(255,255,255),Color.new(0,0,0))
pbDrawOutlineText(@text2,188,-94,512,384,quest.location,Color.new(255,172,115),Color.new(0,0,0))
pbDrawOutlineText(@text2,188,-62,512,384,"Quest received at:",Color.new(255,255,255),Color.new(0,0,0))
time = quest.time.to_s
txt = time.split(' ')[1] + " " + time.split(' ')[2] + ", " + time.split(' ')[3].split(':')[0] + ":" + time.split(' ')[3].split(':')[1] rescue "?????"
pbDrawOutlineText(@text2,188,-36,512,384,txt,Color.new(255,172,115),Color.new(0,0,0))
pbDrawOutlineText(@text2,188,-4,512,384,"Quest received from:",Color.new(255,255,255),Color.new(0,0,0))
pbDrawOutlineText(@text2,188,22,512,384,quest.npc,Color.new(255,172,115),Color.new(0,0,0))
pbDrawOutlineText(@text2,188,162,512,384,"From " + quest.npc,Color.new(255,172,115),Color.new(0,0,0))
pbDrawOutlineText(@text2,10,-178,512,384,quest.name,quest.color,Color.new(0,0,0))
if !quest.completed
pbDrawOutlineText(@text2,8,136,512,384,"Not Completed",pbColor(:LIGHTRED),Color.new(0,0,0))
else
pbDrawOutlineText(@text2,8,136,512,384,"Completed",pbColor(:LIGHTBLUE),Color.new(0,0,0))
end
@sprites["text2"].x = 512
16.times do
Graphics.update
@sprites["bg1"].x -= (@sprites["bg1"].x + 526) * 0.2
@sprites["pager"].x -= (@sprites["pager"].x + 526) * 0.2 rescue nil
@sprites["char"].x -= (@sprites["char"].x + 526) * 0.2 rescue nil
@sprites["main"].x -= (@sprites["main"].x + 526) * 0.2
@sprites["text"].x -= (@sprites["text"].x + 526) * 0.2 rescue nil
@sprites["bg2"].x -= (@sprites["bg2"].x + 14) * 0.2
@sprites["pager2"].x -= (@sprites["pager2"].x - 459) * 0.2
@sprites["text2"].x -= (@sprites["text2"].x + 14) * 0.2
@sprites["char2"].x -= (@sprites["char2"].x - 47) * 0.2
end
@sprites["main"].x = 0
@main.clear
else
@page = 0
@sprites["bg1"] = IconSprite.new(0, 0, @viewport)
@sprites["bg1"].setBitmap("Graphics/Pictures/EQI/questPage1")
@sprites["bg1"].x = -512
@sprites["pager"] = IconSprite.new(0, 0, @viewport)
@sprites["pager"].setBitmap("Graphics/Pictures/EQI/questPager")
@sprites["pager"].x = 442 - 512
@sprites["pager"].y = 3
@sprites["pager"].z = 1
@sprites["text"] = IconSprite.new(@viewport)
@sprites["text"].bitmap = Bitmap.new(Graphics.width,Graphics.height)
@text = @sprites["text"].bitmap
pbSetSystemFont(@text)
@sprites["char"].dispose rescue nil
@sprites["char"] = IconSprite.new(0, 0, @viewport)
@sprites["char"].setBitmap("Graphics/Characters/#{quest.sprite}")
@sprites["char"].x = 62 - 512
@sprites["char"].y = 130
@sprites["char"].z = 1
@sprites["char"].src_rect.height = (@sprites["char"].bitmap.height / 4).round
@sprites["char"].src_rect.width = (@sprites["char"].bitmap.width / 4).round
drawTextExMulti(@text,188,54,318,8,quest.desc,Color.new(255,255,255),Color.new(0,0,0))
pbDrawOutlineText(@text,188,162,512,384,"From " + quest.npc,Color.new(255,172,115),Color.new(0,0,0))
pbDrawOutlineText(@text,10,-178,512,384,quest.name,quest.color,Color.new(0,0,0))
if !quest.completed
pbDrawOutlineText(@text,8,136,512,384,"Not Completed",pbColor(:LIGHTRED),Color.new(0,0,0))
else
pbDrawOutlineText(@text,8,136,512,384,"Completed",pbColor(:LIGHTBLUE),Color.new(0,0,0))
end
@sprites["text"].x = -512
16.times do
Graphics.update
@sprites["bg1"].x -= (@sprites["bg1"].x - 14) * 0.2
@sprites["pager"].x -= (@sprites["pager"].x - 457) * 0.2
@sprites["bg2"].x -= (@sprites["bg2"].x - 526) * 0.2
@sprites["pager2"].x -= (@sprites["pager2"].x - 526) * 0.2
@sprites["char2"].x -= (@sprites["char2"].x - 526) * 0.2
@sprites["text2"].x -= (@sprites["text2"].x - 526) * 0.2
@sprites["text"].x -= (@sprites["text"].x - 15) * 0.2
@sprites["char"].x -= (@sprites["char"].x - 76) * 0.2
end
end
end
def pbChar
@sprites["char"].src_rect.x += (@sprites["char"].bitmap.width / 4).round rescue nil
@sprites["char"].src_rect.x = 0 if @sprites["char"].src_rect.x >= @sprites["char"].bitmap.width rescue nil
@sprites["char2"].src_rect.x += (@sprites["char2"].bitmap.width / 4).round rescue nil
@sprites["char2"].src_rect.x = 0 if @sprites["char2"].src_rect.x >= @sprites["char2"].bitmap.width rescue nil
end
def pbMain
pbWait(1)
12.times do |i|
Graphics.update
@sprites["main"].opacity -= 32 rescue nil
@sprites["bg0"].opacity += 32 if @sprites["bg0"].opacity < 255
@sprites["bg1"].opacity -= 32 rescue nil if i > 3
@sprites["bg2"].opacity -= 32 rescue nil if i > 3
@sprites["pager"].opacity -= 32 rescue nil if i > 3
@sprites["pager2"].opacity -= 32 rescue nil if i > 3
@sprites["char"].opacity -= 32 rescue nil
@sprites["char2"].opacity -= 32 rescue nil
@sprites["text"].opacity -= 32 rescue nil
@sprites["up"].opacity -= 32
@sprites["down"].opacity -= 32
for j in 0...@ongoing.size
@sprites["ongoing#{j}"].opacity -= 32 rescue nil
end
for j in 0...@completed.size
@sprites["completed#{j}"].opacity -= 32 rescue nil
end
end
@sprites["up"].dispose
@sprites["down"].dispose
@main.clear
@text.clear rescue nil
@text2.clear rescue nil
@sel_two = 0
@scene = 0
pbDrawOutlineText(@main,0,2-178,512,384,"Quest Log",Color.new(255,255,255),Color.new(0,0,0),1)
pbDrawOutlineText(@main,0,142-178,512,384,"Ongoing: " + @ongoing.size.to_s,Color.new(255,255,255),Color.new(0,0,0),1)
pbDrawOutlineText(@main,0,198-178,512,384,"Completed: " + @completed.size.to_s,Color.new(255,255,255),Color.new(0,0,0),1)
12.times do |i|
Graphics.update
@sprites["bg0"].opacity += 32 if i < 8
@sprites["btn0"].opacity += 32 if i > 3
@sprites["btn1"].opacity += 32 if i > 3
@sprites["main"].opacity += 48 if i > 5
end
end
def pbSwitch(dir)
if dir == :DOWN
return if @sel_one == 1
@sprites["btn#{@sel_one}"].src_rect.y = 0
@sel_one += 1
@sprites["btn#{@sel_one}"].src_rect.y = (@sprites["btn#{@sel_one}"].bitmap.height / 2).round
else
return if @sel_one == 0
@sprites["btn#{@sel_one}"].src_rect.y = 0
@sel_one -= 1
@sprites["btn#{@sel_one}"].src_rect.y = (@sprites["btn#{@sel_one}"].bitmap.height / 2).round
end
end
def pbMove(dir)
pbWait(1)
if dir == :DOWN
return if @sel_two == @ongoing.size - 1 && @mode == 0
return if @sel_two == @completed.size - 1 && @mode == 1
return if @ongoing.size == 0 && @mode == 0
return if @completed.size == 0 && @mode == 1
@sprites["ongoing#{@box}"].src_rect.y = 0 if @mode == 0
@sprites["completed#{@box}"].src_rect.y = 0 if @mode == 1
@sel_two += 1
@box += 1
@box = 5 if @box > 5
@sprites["ongoing#{@box}"].src_rect.y = (@sprites["ongoing#{@box}"].bitmap.height / 2).round if @mode == 0
@sprites["completed#{@box}"].src_rect.y = (@sprites["completed#{@box}"].bitmap.height / 2).round if @mode == 1
if @box == 5
@main.clear
if @mode == 0
for i in 0...@ongoing.size
break if i > 5
j = (i==0 ? -5 : (i==1 ? -4 : (i==2 ? -3 : (i==3 ? -2 : (i==4 ? -1 : 0)))))
@sprites["ongoing#{i}"].quest = @ongoing[@sel_two+j]
pbDrawOutlineText(@main,11,-124+52*i,512,384,@ongoing[@sel_two+j].name,@ongoing[@sel_two+j].color,Color.new(0,0,0),1)
end
if @sprites["ongoing0"] != @ongoing[0]
@sprites["up"].visible = true
else
@sprites["up"].visible = false
end
if @sprites["ongoing5"] != @ongoing[@ongoing.size - 1]
@sprites["down"].visible = true
else
@sprites["down"].visible = false
end
pbDrawOutlineText(@main,0,2-178,512,384,"Ongoing Quests",Color.new(255,255,255),Color.new(0,0,0),1)
else
for i in 0...@completed.size
break if i > 5
j = (i==0 ? -5 : (i==1 ? -4 : (i==2 ? -3 : (i==3 ? -2 : (i==4 ? -1 : 0)))))
@sprites["completed#{i}"].quest = @completed[@sel_two+j]
pbDrawOutlineText(@main,11,-124+52*i,512,384,@completed[@sel_two+j].name,@completed[@sel_two+j].color,Color.new(0,0,0),1)
end
if @sprites["completed0"] != @completed[0]
@sprites["up"].visible = true
else
@sprites["up"].visible = false
end
if @sprites["completed5"] != @completed[@completed.size - 1]
@sprites["down"].visible = true
else
@sprites["down"].visible = false
end
pbDrawOutlineText(@main,0,2-178,512,384,"Completed Quests",Color.new(255,255,255),Color.new(0,0,0),1)
end
end
else
return if @sel_two == 0
return if @ongoing.size == 0 && @mode == 0
return if @completed.size == 0 && @mode == 1
@sprites["ongoing#{@box}"].src_rect.y = 0 if @mode == 0
@sprites["completed#{@box}"].src_rect.y = 0 if @mode == 1
@sel_two -= 1
@box -= 1
@box = 0 if @box < 0
@sprites["ongoing#{@box}"].src_rect.y = (@sprites["ongoing#{@box}"].bitmap.height / 2).round if @mode == 0
@sprites["completed#{@box}"].src_rect.y = (@sprites["completed#{@box}"].bitmap.height / 2).round if @mode == 1
if @box == 0
@main.clear
if @mode == 0
for i in 0...@ongoing.size
break if i > 5
@sprites["ongoing#{i}"].quest = @ongoing[@sel_two+i]
pbDrawOutlineText(@main,11,-124+52*i,512,384,@ongoing[@sel_two+i].name,@ongoing[@sel_two+i].color,Color.new(0,0,0),1)
end
if @sprites["ongoing5"] != @ongoing[0]
@sprites["up"].visible = true
else
@sprites["up"].visible = false
end
if @sprites["ongoing5"] != @ongoing[@ongoing.size - 1]
@sprites["down"].visible = true
else
@sprites["down"].visible = false
end
pbDrawOutlineText(@main,0,2-178,512,384,"Ongoing Quests",Color.new(255,255,255),Color.new(0,0,0),1)
else
for i in 0...@completed.size
break if i > 5
@sprites["completed#{i}"].quest = @completed[@sel_two+i]
pbDrawOutlineText(@main,11,-124+52*i,512,384,@completed[@sel_two+i].name,@completed[@sel_two+i].color,Color.new(0,0,0),1)
end
if @sprites["completed0"] != @completed[0]
@sprites["up"].visible = true
else
@sprites["up"].visible = false
end
if @sprites["completed5"] != @completed[@completed.size - 1]
@sprites["down"].visible = true
else
@sprites["down"].visible = false
end
pbDrawOutlineText(@main,0,2-178,512,384,"Completed Quests",Color.new(255,255,255),Color.new(0,0,0),1)
end
end
end
end
def pbList(id)
pbWait(1)
@sel_two = 0
@page = 0
@scene = 1
@mode = id
@box = 0
@sprites["up"] = IconSprite.new(0, 0, @viewport)
@sprites["up"].setBitmap("Graphics/Pictures/EQI/questArrow")
@sprites["up"].zoom_x = 1.25
@sprites["up"].zoom_y = 1.25
@sprites["up"].x = Graphics.width / 2
@sprites["up"].y = 36
@sprites["up"].z = 2
@sprites["up"].visible = false
@sprites["down"] = IconSprite.new(0, 0, @viewport)
@sprites["down"].setBitmap("Graphics/Pictures/EQI/questArrow")
@sprites["down"].zoom_x = 1.25
@sprites["down"].zoom_y = 1.25
@sprites["down"].x = Graphics.width / 2 + 21
@sprites["down"].y = 360
@sprites["down"].z = 2
@sprites["down"].angle = 180
@sprites["down"].visible = @mode == 0 ? @ongoing.size > 6 : @completed.size > 6
@sprites["down"].opacity = 0
10.times do |i|
Graphics.update
@sprites["btn0"].opacity -= 32 if i > 1
@sprites["btn1"].opacity -= 32 if i > 1
@sprites["main"].opacity -= 32 if i > 1
@sprites["bg1"].opacity -= 32 rescue nil if i > 1
@sprites["bg2"].opacity -= 32 rescue nil if i > 1
@sprites["pager"].opacity -= 32 rescue nil if i > 1
@sprites["pager2"].opacity -= 32 rescue nil if i > 1
@sprites["char"].opacity -= 32 rescue nil
@sprites["char2"].opacity -= 32 rescue nil
@sprites["text"].opacity -= 32 rescue nil if i > 1
@sprites["text2"].opacity -= 32 rescue nil if i > 1
end
@main.clear
@text.clear rescue nil
@text2.clear rescue nil
if id == 0
for i in 0...@ongoing.size
break if i > 5
@sprites["ongoing#{i}"] = QuestSprite.new(0, 0, @viewport)
@sprites["ongoing#{i}"].setBitmap("Graphics/Pictures/EQI/questBtn")
@sprites["ongoing#{i}"].quest = @ongoing[i]
@sprites["ongoing#{i}"].x = 94
@sprites["ongoing#{i}"].y = 42 + 52 * i
@sprites["ongoing#{i}"].src_rect.height = (@sprites["ongoing#{i}"].bitmap.height / 2).round
@sprites["ongoing#{i}"].src_rect.y = (@sprites["ongoing#{i}"].bitmap.height / 2).round if i == @sel_two
@sprites["ongoing#{i}"].opacity = 0
pbDrawOutlineText(@main,11,-124+52*i,512,384,@ongoing[i].name,@ongoing[i].color,Color.new(0,0,0),1)
end
pbDrawOutlineText(@main,0,0,512,384,"No ongoing quests",pbColor(:WHITE),pbColor(:BLACK),1) if @ongoing.size == 0
pbDrawOutlineText(@main,0,2-178,512,384,"Ongoing Quests",Color.new(255,255,255),Color.new(0,0,0),1)
12.times do |i|
Graphics.update
@sprites["main"].opacity += 32 if i < 8
for j in 0...@ongoing.size
break if j > 5
@sprites["ongoing#{j}"].opacity += 32 if i > 3
end
end
elsif id == 1
for i in 0...@completed.size
break if i > 5
@sprites["completed#{i}"] = QuestSprite.new(0, 0, @viewport)
@sprites["completed#{i}"].setBitmap("Graphics/Pictures/EQI/questBtn")
@sprites["completed#{i}"].x = 94
@sprites["completed#{i}"].y = 42 + 52 * i
@sprites["completed#{i}"].src_rect.height = (@sprites["completed#{i}"].bitmap.height / 2).round
@sprites["completed#{i}"].src_rect.y = (@sprites["completed#{i}"].bitmap.height / 2).round if i == @sel_two
@sprites["completed#{i}"].opacity = 0
pbDrawOutlineText(@main,11,-124+52*i,512,384,@completed[i].name,@completed[i].color,Color.new(0,0,0),1)
end
pbDrawOutlineText(@main,0,0,512,384,"No completed quests",pbColor(:WHITE),pbColor(:BLACK),1) if @completed.size == 0
pbDrawOutlineText(@main,0,2-178,512,384,"Completed Quests",Color.new(255,255,255),Color.new(0,0,0),1)
12.times do |i|
Graphics.update
@sprites["main"].opacity += 32 if i < 8
@sprites["down"].opacity += 32 if i > 3
for j in 0...@completed.size
break if j > 5
@sprites["completed#{j}"].opacity += 32 if i > 3
end
end
end
end
def pbEnd
12.times do |i|
Graphics.update
@sprites["bg0"].opacity -= 32 if i > 3
@sprites["btn0"].opacity -= 32
@sprites["btn1"].opacity -= 32
@sprites["main"].opacity -= 32
@sprites["char"].opacity -= 40 rescue nil
@sprites["char2"].opacity -= 40 rescue nil
end
end
end
#TODO: à terminer
def pbSynchronizeQuestLog()
########################
### Quest started ###
########################
#Pewter
pbAddQuest(0) if $game_switches[926]
pbAddQuest(1) if $game_switches[927]
#Cerulean
pbAddQuest(3) if $game_switches[931]
pbAddQuest(4) if $game_switches[942] || $game_self_switches[[462,7,"A"]]
#Vermillion
pbAddQuest(10) if $game_self_switches[[464,6,"A"]]
pbAddQuest(11) if $game_switches[945]
pbAddQuest(12) if $game_switches[929]
pbAddQuest(13) if $game_switches[175]
#Celadon
pbAddQuest(14) if $game_self_switches[[466,10,"A"]]
pbAddQuest(15) if $game_switches[185]
pbAddQuest(16) if $game_switches[946]
pbAddQuest(17) if $game_switches[172]
#Fuchsia
pbAddQuest(18) if $game_switches[941]
pbAddQuest(19) if $game_switches[943]
pbAddQuest(20) if $game_switches[949]
#Crimson
pbAddQuest(21) if $game_switches[940]
pbAddQuest(22) if $game_self_switches[[177,9,"A"]]
pbAddQuest(23) if $game_self_switches[[177,8,"A"]]
#Saffron
pbAddQuest(24) if $game_switches[932]
pbAddQuest(25) if $game_self_switches[[111,19,"A"]]
pbAddQuest(26) if $game_switches[948]
pbAddQuest(27) if $game_switches[339]
pbAddQuest(28) if $game_switches[300]
#Cinnabar
pbAddQuest(29) if $game_switches[904]
pbAddQuest(30) if $game_switches[903]
#Goldenrod
pbAddQuest(31) if $game_self_switches[[244,5,"A"]]
pbAddQuest(32) if $game_self_switches[[244,8,"A"]]
#Violet
pbSetQuest(33,true) if $game_switches[908]
pbSetQuest(34,true) if $game_switches[410]
#Blackthorn
pbSetQuest(35,true) if $game_self_switches[[332,10,"A"]]
pbSetQuest(36,true) if $game_self_switches[[332,8,"A"]]
pbSetQuest(37,true) if $game_self_switches[[332,5,"B"]]
#Ecruteak
pbSetQuest(38,true) if $game_self_switches[[576,9,"A"]]
pbSetQuest(39,true) if $game_self_switches[[576,8,"A"]]
#Kin
pbSetQuest(40,true) if $game_switches[526]
pbSetQuest(41,true) if $game_self_switches[[565,10,"A"]]
########################
### Quest finished ###
########################
#Pewter
pbSetQuest(0,true) if $game_self_switches[[460,5,"A"]]
pbSetQuest(1,true) if $game_self_switches[[460,7,"A"]] || $game_self_switches[[460,7,"B"]]
if $game_self_switches[[460,9,"A"]]
pbAddQuest(2)
pbSetQuest(2,true)
end
#Cerulean
if $game_self_switches[[462,8,"A"]]
pbAddQuest(5)
pbSetQuest(5,true)
end
pbSetQuest(3,true) if $game_switches[931] && !$game_switches[939]
pbSetQuest(4,true) if $game_self_switches[[462,7,"A"]]
#Vermillion
pbSetQuest(13,true) if $game_self_switches[[19,19,"B"]]
if $game_self_switches[[464,8,"A"]]
pbAddQuest(9)
pbSetQuest(9,true)
end
pbSetQuest(10,true) if $game_self_switches[[464,6,"B"]]
pbSetQuest(11,true) if $game_variables[145] >=1
pbSetQuest(12,true) if $game_self_switches[[464,5,"A"]]
#Celadon
pbSetQuest(14,true) if $game_self_switches[[466,10,"A"]]
pbSetQuest(15,true) if $game_switches[947]
pbSetQuest(16,true) if $game_self_switches[[466,9,"A"]]
pbSetQuest(17,true) if $game_self_switches[[509,5,"D"]]
#Fuchsia
pbSetQuest(18,true) if $game_self_switches[[478,6,"A"]]
pbSetQuest(19,true) if $game_self_switches[[478,8,"A"]]
pbSetQuest(20,true) if $game_switches[922]
#Crimson
pbSetQuest(21,true) if $game_self_switches[[177,5,"A"]]
pbSetQuest(22,true) if $game_self_switches[[177,9,"A"]]
pbSetQuest(23,true) if $game_self_switches[[177,8,"A"]]
#Saffron
pbSetQuest(24,true) if $game_switches[938]
pbSetQuest(25,true) if $game_self_switches[[111,19,"A"]]
pbSetQuest(26,true) if $game_self_switches[[111,9,"A"]]
pbSetQuest(27,true) if $game_switches[338]
pbSetQuest(28,true) if $game_self_switches[[111,18,"A"]]
#Cinnabar
pbSetQuest(29,true) if $game_self_switches[[136,5,"A"]]
pbSetQuest(30,true) if $game_self_switches[[136,8,"A"]]
#Goldenrod
pbSetQuest(31,true) if $game_self_switches[[244,5,"A"]]
pbSetQuest(32,true) if $game_self_switches[[244,8,"B"]]
#Violet
pbSetQuest(33,true) if $game_self_switches[[274,5,"A"]]
pbSetQuest(34,true) if $game_self_switches[[274,8,"A"]] || $game_self_switches[[274,8,"B"]]
#Blackthorn
pbSetQuest(35,true) if $game_self_switches[[332,10,"A"]]
pbSetQuest(36,true) if $game_switches[337]
pbSetQuest(37,true) if $game_self_switches[[332,5,"A"]]
#Ecruteak
pbSetQuest(38,true) if $game_self_switches[[576,9,"A"]]
pbSetQuest(39,true) if $game_self_switches[[576,8,"A"]]
#Kin
pbSetQuest(40,true) if $game_self_switches[[565,9,"A"]]
pbSetQuest(41,true) if $game_self_switches[[565,10,"A"]]
end

1744
Data/Scripts_backup/024_Addons/SpeechBubbles.rb Normal file
View File

File diff suppressed because it is too large Load Diff

28
Data/Scripts_backup/024_Addons/Utilities.rb Normal file
View File

@@ -0,0 +1,28 @@
#méthodes utilitaires ajoutées qui étaient éparpillées partout
# on va essayer de les regrouper ici
def getBodyID(species)
return (species / NB_POKEMON).round
end
def getHeadID(species, bodyId)
return (species - (bodyId * NB_POKEMON)).round
end
#-------------------------------------------------------------------------------
# Misc scripting utilities
#-------------------------------------------------------------------------------
class Bitmap
attr_accessor :storedPath
end
def pbBitmap(name)
if !pbResolveBitmap(name).nil?
bmp = RPG::Cache.load_bitmap(name)
bmp.storedPath = name
else
p "Image located at '#{name}' was not found!" if $DEBUG
bmp = Bitmap.new(1, 1)
end
return bmp
end

616
Data/Scripts_backup/024_Addons/intro screen.rb Normal file
View File

@@ -0,0 +1,616 @@
#===============================================================================
# New animated Title Screens for Pokemon Essentials
# by Luka S.J.
#
# Adds new visual styles to the Pokemon Essentials title screen, and animates
# depending on the style selected
#===============================================================================
###SCRIPTEDIT1
# Config value for selecting title screen style
SCREENSTYLE = 1
# 1 - FR/LG
# 2 - R/S/E
class Scene_Intro
alias main_old main
def main
Graphics.transition(0)
# Loads up a species cry for the title screen
species=PBSpecies::CHARIZARD
@cry=pbCryFile(species)
# Cycles through the intro pictures
@skip=false
self.cyclePics(@pics)
# Selects title screen style
case SCREENSTYLE
when 1
@screen=GenOneStyle.new
when 2
@screen=GenThreeStyle.new
else
@screen=GenOneStyle.new # For compatibility sake if SCREENSTYLE is wrong value
end
# Plays the title screen intro (is skippable)
@screen.intro
# Creates/updates the main title screen loop
self.update
Graphics.freeze
end
def update
ret=0
loop do
@screen.update
Graphics.update
Input.update
if Input.press?(Input::DOWN) &&
Input.press?(Input::B) &&
Input.press?(Input::CTRL)
ret=1
break
end
if Input.trigger?(Input::C)
ret=2
break
end
end
case ret
when 1
closeSplashDelete(scene,args)
when 2
closeTitle
end
end
def closeTitle
# Play Pokemon cry
pbSEPlay("Absorb2",100,100) if @cry
# Fade out
pbBGMStop(1.0)
# disposes current title screen
disposeTitle
# initializes load screen
sscene=PokemonLoadScene.new
sscreen=PokemonLoad.new(sscene)
sscreen.pbStartLoadScreen
end
def closeTitleDelete
pbBGMStop(1.0)
# disposes current title screen
disposeTitle
# initializes delete screen
sscene=PokemonLoadScene.new
sscreen=PokemonLoad.new(sscene)
sscreen.pbStartDeleteScreen
end
def cyclePics(pics)
sprite=Sprite.new
sprite.opacity=0
for i in 0...pics.length
bitmap=pbBitmap("Graphics/Titles/#{pics[i]}")
sprite.bitmap=bitmap
15.times do
sprite.opacity+=17
pbWait(1)
end
wait(32)
15.times do
sprite.opacity-=17
pbWait(1)
end
end
sprite.dispose
end
def disposeTitle
@screen.dispose
end
def wait(frames)
return if @skip
frames.times do
Graphics.update
Input.update
@skip=true if Input.trigger?(Input::C)
end
end
end
#===============================================================================
# Styled to look like the FRLG games
#===============================================================================
class GenOneStyle
def initialize
Kernel.pbDisplayText("Version " + GAME_VERSION_NUMBER,254,312,99999)
@maxPoke = 140 #1st gen, pas de legend la premiere fois, graduellement plus de poke
@customPokeList = getCustomSpeciesList()
#Get random Pokemon (1st gen orandPokenly, pas de legend la prmeiere fois)
randPoke = getRandomCustomFusion()
randpoke1 = randPoke[0] #rand(@maxPoke)+1
randpoke2 = randPoke[1] #rand(@maxPoke)+1
randpoke1s = randpoke1.to_s
randpoke2s = randpoke2.to_s
path_s1 = "Graphics/Battlers/"+ randpoke1s+"/"+randpoke1s +".png"
path_s2 = "Graphics/Battlers/"+ randpoke2s+"/"+randpoke2s +".png"
path_f = getFusedPath(randpoke1,randpoke2)
@prevPoke1 = randpoke1
@prevPoke2 = randpoke2
#Get Fused Poke
fusedpoke = (randpoke2*NB_POKEMON)+randpoke1
fusedpoke_s =fusedpoke.to_s
# sound file for playing the title screen BGM
bgm="Pokemon Red-Blue Opening"
@skip=false
# speed of the effect movement
@speed=16
@opacity=17
@disposed=false
@currentFrame=0
# calculates after how many frames the game will reset
#@totalFrames=getPlayTime("Audio/BGM/#{bgm}")*Graphics.frame_rate
@totalFrames=10*Graphics.frame_rate
pbBGMPlay(bgm)
# creates all the necessary graphics
@viewport=Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z=99998
@sprites={}
@sprites["bars"]=Sprite.new(@viewport)
@sprites["bars"].bitmap=pbBitmap("Graphics/Titles/gen1_bars")
@sprites["bars"].x=Graphics.width
@sprites["bg"]=Sprite.new(@viewport)
@sprites["bg"].bitmap=pbBitmap("Graphics/Titles/gen1_bg")
@sprites["bg"].x=-Graphics.width
#@sprites["bg2"]=Sprite.new(@viewport)
#@sprites["bg2"].bitmap=pbBitmap("Graphics/Titles/gen1_bg_litup")
#@sprites["bg2"].opacity=0
#@sprites["start"]=Sprite.new(@viewport)
#@sprites["start"].bitmap=pbBitmap("Graphics/Titles/pokelogo3")
#@sprites["start"].x=138
#@sprites["start"].y=300
#@sprites["start"].opacity=255
@sprites["effect"]=AnimatedPlane.new(@viewport)
@sprites["effect"].bitmap=pbBitmap("Graphics/Titles/gen1_effect")
@sprites["effect"].opacity=155
@sprites["effect"].visible=false
@sprites["poke"]=Sprite.new(@viewport)
@sprites["poke"].bitmap=pbBitmap(path_s1)
@sprites["poke"].x=400
@sprites["poke"].y=75
@sprites["2poke"]=Sprite.new(@viewport)
@sprites["2poke"].bitmap=pbBitmap(path_s2)
@sprites["2poke"].x=-150
@sprites["2poke"].y=75
@sprites["fpoke"]=Sprite.new(@viewport)
@sprites["fpoke"].bitmap=pbBitmap(path_f)
@sprites["fpoke"].x=125
@sprites["fpoke"].y=75
@sprites["fpoke"].z=999
@sprites["fpoke"].opacity=0
@sprites["poke"].tone=Tone.new(0,0,0,255)
@sprites["poke"].opacity=0
@sprites["poke2"]=Sprite.new(@viewport)
@sprites["poke2"].bitmap=pbBitmap("Graphics/Battlers/21364")
@sprites["poke2"].tone=Tone.new(255,255,255,255)
@sprites["poke2"].src_rect.set(0,Graphics.height,Graphics.width,48)
@sprites["poke2"].y=Graphics.height
@sprites["poke2"].y=100
@sprites["2poke"].tone=Tone.new(0,0,0,255)
@sprites["2poke"].opacity=0
@sprites["2poke2"]=Sprite.new(@viewport)
@sprites["2poke2"].bitmap=pbBitmap("Graphics/Battlers/special/000")
@sprites["2poke2"].tone=Tone.new(255,255,255,255)
@sprites["2poke2"].src_rect.set(0,Graphics.height,Graphics.width,48)
@sprites["2poke2"].y=Graphics.height
@sprites["2poke2"].y=100
@sprites["logo"]=Sprite.new(@viewport)
bitmap2=pbBitmap("Graphics/Titles/pokelogo2")
bitmap1=pbBitmap("Graphics/Titles/pokelogo")
@sprites["logo"].bitmap=Bitmap.new(bitmap1.width,bitmap1.height)
@sprites["logo"].bitmap.blt(0,0,bitmap1,Rect.new(0,0,bitmap1.width,bitmap1.height))
@sprites["logo"].bitmap.blt(0,0,bitmap2,Rect.new(0,40,bitmap2.width,bitmap2.height))
@sprites["logo"].tone=Tone.new(255,255,255,255)
@sprites["logo"].x=50
@sprites["logo"].y=-20
@sprites["logo"].opacity=0
@sprites["star"]=Sprite.new(@viewport)
@sprites["star"].bitmap=pbBitmap("Graphics/Pictures/darkness")
@sprites["star"].opacity=0
@sprites["star"].x=-50
@sprites["star"].y=0
end
def intro
wait(16)
16.times do
end
wait(32)
64.times do
@sprites["2poke"].opacity+=4
@sprites["poke"].opacity+=4
wait(1)
end
8.times do
@sprites["bg"].x+=64
wait(1)
end
wait(8)
8.times do
@sprites["bars"].x-=64
wait(1)
end
wait(8)
@sprites["logo"].opacity=255
@sprites["poke2"].opacity=255
@sprites["2poke2"].opacity=255
@sprites["poke"].tone=Tone.new(0,0,0,0)
@sprites["2poke"].tone=Tone.new(0,0,0,0)
@sprites["effect"].visible=true
c=255.0
16.times do
@sprites["poke2"].opacity-=255.0/16
@sprites["2poke2"].opacity-=255.0/16
c-=255.0/16
@sprites["logo"].tone=Tone.new(c,c,c)
@sprites["effect"].ox+=@speed
wait(1)
end
end
TONE_INCR = 15
def makeShineEffect()
newColor = @sprites["poke"].tone.red + TONE_INCR
newTone =Tone.new(newColor,newColor,newColor,0)
@sprites["poke"].tone=newTone
@sprites["2poke"].tone=newTone
end
def introloop
@sprites["star"].opacity=0
@sprites["poke"].opacity=255
@sprites["2poke"].opacity=255
@sprites["fpoke"].opacity=0
@sprites["poke"].x=@sprites["poke"].x-1
@sprites["2poke"].x=@sprites["2poke"].x+1
end
def update
@sprites["effect"].ox+=@speed
@currentFrame+=1
@skip =false
if @sprites["poke"].x < 175#150
makeShineEffect()
end
if @sprites["poke"].x > @sprites["2poke"].x
@sprites["poke"].x=@sprites["poke"].x-1
@sprites["2poke"].x=@sprites["2poke"].x+1
#@sprites["effect"].opacity-=1
#@sprites["bg"].opacity-=1
#@sprites["bg2"].opacity+=3
end
if @sprites["poke"].x <= @sprites["2poke"].x
@sprites["poke"].opacity=0
@sprites["2poke"].opacity=0
#16.times do
@sprites["fpoke"].opacity=255
#wait(1)
#end
@sprites["poke"].x=400
@sprites["poke"].tone = Tone.new(0,0,0,0)
@sprites["2poke"].x=-150
@sprites["2poke"].tone = Tone.new(0,0,0,0)
if @maxPoke < NB_POKEMON-1
@maxPoke += 5 #-1 pour que ca arrive pile. tant pis pour kyurem
end
randPoke = getRandomCustomFusion()
randpoke1 = randPoke[0] #rand(@maxPoke)+1
randpoke2 = randPoke[1] #rand(@maxPoke)+1
randpoke1s = randpoke1.to_s
randpoke2s = randpoke2.to_s
path_s1 = "Graphics/Battlers/"+ randpoke1s+"/"+randpoke1s +".png"
path_s2 = "Graphics/Battlers/"+ randpoke2s+"/"+randpoke2s + ".png"
path_f = getFusedPath(randpoke1,randpoke2)
path_fMod = getFusedPath(@prevPoke1,@prevPoke2)
@sprites["fpoke"].bitmap=pbBitmap(path_fMod)
@prevPoke1 = randpoke1
@prevPoke2 = randpoke2
@sprites["poke"].bitmap=pbBitmap(path_s1)
@sprites["2poke"].bitmap=pbBitmap(path_s2)
wait(150)
# fusedpoke = (randpoke2*151)+randpoke1
#fusedpoke_s =fusedpoke.to_s
@sprites["fpoke"].bitmap=pbBitmap(path_f)
#@sprites["effect"].opacity=155
#@sprites["bg"].opacity=255
#@sprites["bg2"].opacity=0
end
@sprites["fpoke"].opacity-=10
@sprites["effect"].ox+=@speed
if @currentFrame>=@totalFrames
introloop
end
end
end
def getFusedPatho(randpoke1s,randpoke2s)
path = rand(2) == 0 ? "Graphics/Battlers/"+ randpoke1s+"/"+randpoke1s+"."+randpoke2s : "Graphics/Battlers/"+ randpoke2s+"/"+randpoke2s+"."+randpoke1s
if Input.press?(Input::RIGHT)
path = "Graphics/Battlers/"+ randpoke2s+"/"+randpoke2s+"."+randpoke1s
elsif Input.press?(Input::LEFT)
path = "Graphics/Battlers/"+ randpoke1s+"/"+randpoke1s+"."+randpoke2s
end
return path
end
#new version
def getFusedPath(randpoke1,randpoke2)
path = rand(2) == 0 ? GetSpritePathForced(randpoke1,randpoke2,true) :GetSpritePathForced(randpoke2,randpoke1,true)
if Input.press?(Input::RIGHT)
path = GetSpritePathForced(randpoke1,randpoke2,true)
elsif Input.press?(Input::LEFT)
path = GetSpritePathForced(randpoke2,randpoke1,true)
end
return path
end
def dispose
Kernel.pbClearText()
pbFadeOutAndHide(@sprites)
pbDisposeSpriteHash(@sprites)
@viewport.dispose
@disposed=true
end
def disposed?
return @disposed
end
def wait(frames)
return if @skip
frames.times do
@currentFrame+=1
@sprites["effect"].ox+=@speed
Graphics.update
Input.update
if Input.trigger?(Input::C)
@skip = true
return
end
end
end
#end
#===============================================================================
# Styled to look like the gen 3 games
#===============================================================================
class GenThreeStyle
def initialize
# sound file for playing the title screen BGM
bgm="rse opening"
@skip=false
# speed of the effect movement
@speed=1
@opacity=2
@frame=0
@disposed=false
@currentFrame=0
# calculates after how many frames the game will reset
#@totalFrames=getPlayTime("Audio/BGM/#{bgm}")*Graphics.frame_rate
@totalFrames=10*Graphics.frame_rate
pbBGMPlay(bgm)
# creates all the necessary graphics
@viewport=Viewport.new(0,0,Graphics.width,Graphics.height)
@viewport.z=99999
@sprites={}
@sprites["bg"]=Sprite.new(@viewport)
@sprites["bg"].bitmap=pbBitmap("Graphics/Titles/gen3_bg")
@sprites["bg"].tone=Tone.new(255,255,255)
@sprites["bg"].opacity=0
#@sprites["bg2"]=Sprite.new(@viewport)
#@sprites["bg2"].bitmap=pbBitmap("Graphics/Titles/gen3_bg")
#@sprites["bg2"].tone=Tone.new(255,255,255)
#@sprites["bg2"].opacity=0
@sprites["poke1"]=Sprite.new(@viewport)
@sprites["poke1"].bitmap=pbBitmap("Graphics/Titles/gen3_poke1")
@sprites["poke1"].opacity=0
@sprites["poke2"]=Sprite.new(@viewport)
@sprites["poke2"].bitmap=pbBitmap("Graphics/Titles/gen3_poke2")
@sprites["poke2"].opacity=0
@sprites["effect"]=AnimatedPlane.new(@viewport)
@sprites["effect"].bitmap=pbBitmap("Graphics/Titles/gen3_effect")
@sprites["effect"].visible=false
@sprites["logo2"]=Sprite.new(@viewport)
@sprites["logo2"].bitmap=pbBitmap("Graphics/Titles/pokelogo2")
@sprites["logo2"].x=50
@sprites["logo2"].y=24-32
@sprites["logo2"].opacity=0
@sprites["logo1"]=Sprite.new(@viewport)
@sprites["logo1"].bitmap=pbBitmap("Graphics/Titles/pokelogo")
@sprites["logo1"].x=50
@sprites["logo1"].y=24+64
@sprites["logo1"].opacity=0
@sprites["logo3"]=Sprite.new(@viewport)
@sprites["logo3"].bitmap=pbBitmap("Graphics/Titles/pokelogo")
@sprites["logo3"].tone=Tone.new(255,255,255)
@sprites["logo3"].x=18
@sprites["logo3"].y=24+64
@sprites["logo3"].src_rect.set(-34,0,34,230)
@sprites["start"]=Sprite.new(@viewport)
@sprites["start"].bitmap=pbBitmap("Graphics/Titles/pokelogo3")
@sprites["start"].x=178
@sprites["start"].y=312
@sprites["start"].visible=true
end
def intro
16.times do
@sprites["logo1"].opacity+=16
wait(1)
end
wait(16)
12.times do
@sprites["logo3"].x+=34
@sprites["logo3"].src_rect.x+=34
wait(1)
end
@sprites["logo3"].x=18
@sprites["logo3"].src_rect.x=-34
wait(32)
2.times do
12.times do
@sprites["logo3"].x+=34
@sprites["logo3"].src_rect.x+=34
@sprites["bg"].opacity+=21.5
wait(1)
end
@sprites["logo3"].x=18
@sprites["logo3"].src_rect.x=-34
wait(4)
16.times do
@sprites["bg"].opacity-=16
wait(1)
end
wait(32)
end
@sprites["logo3"].visible=false
16.times do
@sprites["logo1"].y-=2
wait(1)
end
16.times do
@sprites["logo2"].y+=2
@sprites["logo2"].opacity+=16
@sprites["logo1"].y-=2
wait(1)
end
wait(56)
@sprites["bg"].tone=Tone.new(0,0,0)
@sprites["bg"].opacity=255
@sprites["poke1"].opacity=255
@sprites["effect"].visible=true
end
def update
@currentFrame+=1
@frame+=1
@sprites["effect"].oy+=@speed
@sprites["poke2"].opacity+=@opacity
@opacity=-2 if @sprites["poke2"].opacity>=255
@opacity=+2 if @sprites["poke2"].opacity<=0
if @frame==8
@sprites["start"].visible=true
elsif @frame==24
@sprites["start"].visible=false
@frame=0
end
if @currentFrame>=@totalFrames
raise Reset.new
end
end
def dispose
pbFadeOutAndHide(@sprites)
pbDisposeSpriteHash(@sprites)
@viewport.dispose
@disposed=true
end
def disposed?
return @disposed
end
def wait(frames)
return if @skip
frames.times do
@currentFrame+=1
Graphics.update
Input.update
@skip=true if Input.trigger?(Input::C)
end
end
end