mirror of
https://github.com/infinitefusion/infinitefusion-e18.git
synced 2025-12-08 21:54:58 +00:00
873 lines
28 KiB
Ruby
873 lines
28 KiB
Ruby
#===============================================================================
|
|
#
|
|
#===============================================================================
|
|
class AnimFrame
|
|
X = 0
|
|
Y = 1
|
|
ZOOMX = 2
|
|
ANGLE = 3
|
|
MIRROR = 4
|
|
BLENDTYPE = 5
|
|
VISIBLE = 6
|
|
PATTERN = 7
|
|
OPACITY = 8
|
|
ZOOMY = 11
|
|
COLORRED = 12
|
|
COLORGREEN = 13
|
|
COLORBLUE = 14
|
|
COLORALPHA = 15
|
|
TONERED = 16
|
|
TONEGREEN = 17
|
|
TONEBLUE = 18
|
|
TONEGRAY = 19
|
|
LOCKED = 20
|
|
FLASHRED = 21
|
|
FLASHGREEN = 22
|
|
FLASHBLUE = 23
|
|
FLASHALPHA = 24
|
|
PRIORITY = 25
|
|
FOCUS = 26
|
|
end
|
|
|
|
|
|
|
|
#===============================================================================
|
|
#
|
|
#===============================================================================
|
|
def yaxisIntersect(x1,y1,x2,y2,px,py)
|
|
dx = x2-x1
|
|
dy = y2-y1
|
|
x = (dx==0) ? 0.0 : (px-x1).to_f/dx
|
|
y = (dy==0) ? 0.0 : (py-y1).to_f/dy
|
|
return [x,y]
|
|
end
|
|
|
|
def repositionY(x1,y1,x2,y2,tx,ty)
|
|
dx = x2-x1
|
|
dy = y2-y1
|
|
x = x1+tx*dx.to_f
|
|
y = y1+ty*dy.to_f
|
|
return [x,y]
|
|
end
|
|
|
|
def transformPoint(x1,y1,x2,y2, # Source line
|
|
x3,y3,x4,y4, # Destination line
|
|
px,py) # Source point
|
|
ret = yaxisIntersect(x1,y1,x2,y2,px,py)
|
|
ret2 = repositionY(x3,y3,x4,y4,ret[0],ret[1])
|
|
return ret2
|
|
end
|
|
|
|
def getSpriteCenter(sprite)
|
|
return [0,0] if !sprite || sprite.disposed?
|
|
return [sprite.x,sprite.y] if !sprite.bitmap || sprite.bitmap.disposed?
|
|
centerX = sprite.src_rect.width/2
|
|
centerY = sprite.src_rect.height/2
|
|
offsetX = (centerX-sprite.ox)*sprite.zoom_x
|
|
offsetY = (centerY-sprite.oy)*sprite.zoom_y
|
|
return [sprite.x+offsetX,sprite.y+offsetY]
|
|
end
|
|
|
|
def isReversed(src0,src1,dst0,dst1)
|
|
return false if src0==src1
|
|
return (dst0>dst1) if src0<src1
|
|
return (dst0<dst1)
|
|
end
|
|
|
|
def pbCreateCel(x,y,pattern,focus=4)
|
|
frame = []
|
|
frame[AnimFrame::X] = x
|
|
frame[AnimFrame::Y] = y
|
|
frame[AnimFrame::PATTERN] = pattern
|
|
frame[AnimFrame::FOCUS] = focus # 1=target, 2=user, 3=user and target, 4=screen
|
|
frame[AnimFrame::LOCKED] = 0
|
|
pbResetCel(frame)
|
|
return frame
|
|
end
|
|
|
|
def pbResetCel(frame)
|
|
return if !frame
|
|
frame[AnimFrame::ZOOMX] = 100
|
|
frame[AnimFrame::ZOOMY] = 100
|
|
frame[AnimFrame::BLENDTYPE] = 0
|
|
frame[AnimFrame::VISIBLE] = 1
|
|
frame[AnimFrame::ANGLE] = 0
|
|
frame[AnimFrame::MIRROR] = 0
|
|
frame[AnimFrame::OPACITY] = 255
|
|
frame[AnimFrame::COLORRED] = 0
|
|
frame[AnimFrame::COLORGREEN] = 0
|
|
frame[AnimFrame::COLORBLUE] = 0
|
|
frame[AnimFrame::COLORALPHA] = 0
|
|
frame[AnimFrame::TONERED] = 0
|
|
frame[AnimFrame::TONEGREEN] = 0
|
|
frame[AnimFrame::TONEBLUE] = 0
|
|
frame[AnimFrame::TONEGRAY] = 0
|
|
frame[AnimFrame::FLASHRED] = 0
|
|
frame[AnimFrame::FLASHGREEN] = 0
|
|
frame[AnimFrame::FLASHBLUE] = 0
|
|
frame[AnimFrame::FLASHALPHA] = 0
|
|
frame[AnimFrame::PRIORITY] = 1 # 0=back, 1=front, 2=behind focus, 3=before focus
|
|
end
|
|
|
|
#===============================================================================
|
|
#
|
|
#===============================================================================
|
|
def pbConvertRPGAnimation(animation)
|
|
pbAnim = PBAnimation.new
|
|
pbAnim.id = animation.id
|
|
pbAnim.name = animation.name.clone
|
|
pbAnim.graphic = animation.animation_name
|
|
pbAnim.hue = animation.animation_hue
|
|
pbAnim.array.clear
|
|
yOffset = 0
|
|
pbAnim.position = animation.position
|
|
yOffset = -64 if animation.position==0
|
|
yOffset = 64 if animation.position==2
|
|
for i in 0...animation.frames.length
|
|
frame = pbAnim.addFrame
|
|
animFrame = animation.frames[i]
|
|
for j in 0...animFrame.cell_max
|
|
data = animFrame.cell_data
|
|
if data[j,0]==-1
|
|
frame.push(nil)
|
|
next
|
|
end
|
|
if animation.position==3 # Screen
|
|
point = transformPoint(
|
|
-160,80,160,-80,
|
|
Battle::Scene::FOCUSUSER_X,Battle::Scene::FOCUSUSER_Y,
|
|
Battle::Scene::FOCUSTARGET_X,Battle::Scene::FOCUSTARGET_Y,
|
|
data[j,1],data[j,2]
|
|
)
|
|
cel = pbCreateCel(point[0],point[1],data[j,0])
|
|
else
|
|
cel = pbCreateCel(data[j,1],data[j,2]+yOffset,data[j,0])
|
|
end
|
|
cel[AnimFrame::ZOOMX] = data[j,3]
|
|
cel[AnimFrame::ZOOMY] = data[j,3]
|
|
cel[AnimFrame::ANGLE] = data[j,4]
|
|
cel[AnimFrame::MIRROR] = data[j,5]
|
|
cel[AnimFrame::OPACITY] = data[j,6]
|
|
cel[AnimFrame::BLENDTYPE] = 0
|
|
frame.push(cel)
|
|
end
|
|
end
|
|
for i in 0...animation.timings.length
|
|
timing = animation.timings[i]
|
|
newTiming = PBAnimTiming.new
|
|
newTiming.frame = timing.frame
|
|
newTiming.name = timing.se.name
|
|
newTiming.volume = timing.se.volume
|
|
newTiming.pitch = timing.se.pitch
|
|
newTiming.flashScope = timing.flash_scope
|
|
newTiming.flashColor = timing.flash_color.clone
|
|
newTiming.flashDuration = timing.flash_duration
|
|
pbAnim.timing.push(newTiming)
|
|
end
|
|
return pbAnim
|
|
end
|
|
|
|
|
|
|
|
#===============================================================================
|
|
#
|
|
#===============================================================================
|
|
class RPG::Animation
|
|
def self.fromOther(otherAnim,id)
|
|
ret = RPG::Animation.new
|
|
ret.id = id
|
|
ret.name = otherAnim.name.clone
|
|
ret.animation_name = otherAnim.animation_name.clone
|
|
ret.animation_hue = otherAnim.animation_hue
|
|
ret.position = otherAnim.position
|
|
return ret
|
|
end
|
|
|
|
def addSound(frame,se)
|
|
timing = RPG::Animation::Timing.new
|
|
timing.frame = frame
|
|
timing.se = RPG::AudioFile.new(se,100)
|
|
self.timings.push(timing)
|
|
end
|
|
|
|
def addAnimation(otherAnim,frame,x,y) # frame is zero-based
|
|
if frame+otherAnim.frames.length>=self.frames.length
|
|
totalframes = frame+otherAnim.frames.length+1
|
|
for i in self.frames.length...totalframes
|
|
self.frames.push(RPG::Animation::Frame.new)
|
|
end
|
|
end
|
|
self.frame_max = self.frames.length
|
|
for i in 0...otherAnim.frame_max
|
|
thisframe = self.frames[frame+i]
|
|
otherframe = otherAnim.frames[i]
|
|
cellStart = thisframe.cell_max
|
|
thisframe.cell_max += otherframe.cell_max
|
|
thisframe.cell_data.resize(thisframe.cell_max,8)
|
|
for j in 0...otherframe.cell_max
|
|
thisframe.cell_data[cellStart+j,0] = otherframe.cell_data[j,0]
|
|
thisframe.cell_data[cellStart+j,1] = otherframe.cell_data[j,1]+x
|
|
thisframe.cell_data[cellStart+j,2] = otherframe.cell_data[j,2]+y
|
|
thisframe.cell_data[cellStart+j,3] = otherframe.cell_data[j,3]
|
|
thisframe.cell_data[cellStart+j,4] = otherframe.cell_data[j,4]
|
|
thisframe.cell_data[cellStart+j,5] = otherframe.cell_data[j,5]
|
|
thisframe.cell_data[cellStart+j,6] = otherframe.cell_data[j,6]
|
|
thisframe.cell_data[cellStart+j,7] = otherframe.cell_data[j,7]
|
|
end
|
|
end
|
|
for i in 0...otherAnim.timings.length
|
|
timing = RPG::Animation::Timing.new
|
|
othertiming = otherAnim.timings[i]
|
|
timing.frame = frame+othertiming.frame
|
|
timing.se = RPG::AudioFile.new(
|
|
othertiming.se.name.clone,
|
|
othertiming.se.volume,
|
|
othertiming.se.pitch)
|
|
timing.flash_scope = othertiming.flash_scope
|
|
timing.flash_color = othertiming.flash_color.clone
|
|
timing.flash_duration = othertiming.flash_duration
|
|
timing.condition = othertiming.condition
|
|
self.timings.push(timing)
|
|
end
|
|
self.timings.sort! { |a,b| a.frame<=>b.frame }
|
|
end
|
|
end
|
|
|
|
|
|
|
|
#===============================================================================
|
|
#
|
|
#===============================================================================
|
|
class PBAnimTiming
|
|
attr_accessor :frame
|
|
attr_writer :timingType # 0=play SE, 1=set bg, 2=bg mod
|
|
attr_accessor :name # Name of SE file or BG file
|
|
attr_accessor :volume
|
|
attr_accessor :pitch
|
|
attr_accessor :bgX # x coordinate of bg (or to move bg to)
|
|
attr_accessor :bgY # y coordinate of bg (or to move bg to)
|
|
attr_accessor :opacity # Opacity of bg (or to change bg to)
|
|
attr_accessor :colorRed # Color of bg (or to change bg to)
|
|
attr_accessor :colorGreen # Color of bg (or to change bg to)
|
|
attr_accessor :colorBlue # Color of bg (or to change bg to)
|
|
attr_accessor :colorAlpha # Color of bg (or to change bg to)
|
|
attr_writer :duration # How long to spend changing to the new bg coords/color
|
|
attr_accessor :flashScope
|
|
attr_accessor :flashColor
|
|
attr_accessor :flashDuration
|
|
|
|
def initialize(type=0)
|
|
@frame = 0
|
|
@timingType = type
|
|
@name = ""
|
|
@volume = 80
|
|
@pitch = 100
|
|
@bgX = nil
|
|
@bgY = nil
|
|
@opacity = nil
|
|
@colorRed = nil
|
|
@colorGreen = nil
|
|
@colorBlue = nil
|
|
@colorAlpha = nil
|
|
@duration = 5
|
|
@flashScope = 0
|
|
@flashColor = Color.new(255,255,255,255)
|
|
@flashDuration = 5
|
|
end
|
|
|
|
def timingType
|
|
return @timingType || 0
|
|
end
|
|
|
|
def duration
|
|
return @duration || 5
|
|
end
|
|
|
|
def to_s
|
|
case self.timingType
|
|
when 0
|
|
return "[#{@frame+1}] Play SE: #{name} (volume #{@volume}, pitch #{@pitch})"
|
|
when 1
|
|
text = sprintf("[%d] Set BG: \"%s\"",@frame+1,name)
|
|
text += sprintf(" (color=%s,%s,%s,%s)",
|
|
(@colorRed!=nil) ? @colorRed.to_i : "-",
|
|
(@colorGreen!=nil) ? @colorGreen.to_i : "-",
|
|
(@colorBlue!=nil) ? @colorBlue.to_i : "-",
|
|
(@colorAlpha!=nil) ? @colorAlpha.to_i : "-")
|
|
text += sprintf(" (opacity=%s)",@opacity.to_i)
|
|
text += sprintf(" (coords=%s,%s)",
|
|
(@bgX!=nil) ? @bgX : "-",
|
|
(@bgY!=nil) ? @bgY : "-")
|
|
return text
|
|
when 2
|
|
text = sprintf("[%d] Change BG: @%d",@frame+1,duration)
|
|
if @colorRed!=nil || @colorGreen!=nil || @colorBlue!=nil || @colorAlpha!=nil
|
|
text += sprintf(" (color=%s,%s,%s,%s)",
|
|
(@colorRed!=nil) ? @colorRed.to_i : "-",
|
|
(@colorGreen!=nil) ? @colorGreen.to_i : "-",
|
|
(@colorBlue!=nil) ? @colorBlue.to_i : "-",
|
|
(@colorAlpha!=nil) ? @colorAlpha.to_i : "-")
|
|
end
|
|
text += sprintf(" (opacity=%s)",@opacity.to_i) if @opacity!=nil
|
|
if @bgX!=nil || @bgY!=nil
|
|
text += sprintf(" (coords=%s,%s)",
|
|
(@bgX!=nil) ? @bgX : "-",
|
|
(@bgY!=nil) ? @bgY : "-")
|
|
end
|
|
return text
|
|
when 3
|
|
text = sprintf("[%d] Set FG: \"%s\"",@frame+1,name)
|
|
text += sprintf(" (color=%s,%s,%s,%s)",
|
|
(@colorRed!=nil) ? @colorRed.to_i : "-",
|
|
(@colorGreen!=nil) ? @colorGreen.to_i : "-",
|
|
(@colorBlue!=nil) ? @colorBlue.to_i : "-",
|
|
(@colorAlpha!=nil) ? @colorAlpha.to_i : "-")
|
|
text += sprintf(" (opacity=%s)",@opacity.to_i)
|
|
text += sprintf(" (coords=%s,%s)",
|
|
(@bgX!=nil) ? @bgX : "-",
|
|
(@bgY!=nil) ? @bgY : "-")
|
|
return text
|
|
when 4
|
|
text = sprintf("[%d] Change FG: @%d",@frame+1,duration)
|
|
if @colorRed!=nil || @colorGreen!=nil || @colorBlue!=nil || @colorAlpha!=nil
|
|
text += sprintf(" (color=%s,%s,%s,%s)",
|
|
(@colorRed!=nil) ? @colorRed.to_i : "-",
|
|
(@colorGreen!=nil) ? @colorGreen.to_i : "-",
|
|
(@colorBlue!=nil) ? @colorBlue.to_i : "-",
|
|
(@colorAlpha!=nil) ? @colorAlpha.to_i : "-")
|
|
end
|
|
text += sprintf(" (opacity=%s)",@opacity.to_i) if @opacity!=nil
|
|
if @bgX!=nil || @bgY!=nil
|
|
text += sprintf(" (coords=%s,%s)",
|
|
(@bgX!=nil) ? @bgX : "-",
|
|
(@bgY!=nil) ? @bgY : "-")
|
|
end
|
|
return text
|
|
end
|
|
return ""
|
|
end
|
|
end
|
|
|
|
|
|
|
|
#===============================================================================
|
|
#
|
|
#===============================================================================
|
|
class PBAnimations < Array
|
|
include Enumerable
|
|
attr_reader :array
|
|
attr_accessor :selected
|
|
|
|
def initialize(size=1)
|
|
@array = []
|
|
@selected = 0
|
|
size = 1 if size<1 # Always create at least one animation
|
|
size.times do
|
|
@array.push(PBAnimation.new)
|
|
end
|
|
end
|
|
|
|
def length
|
|
return @array.length
|
|
end
|
|
|
|
def each
|
|
@array.each { |i| yield i }
|
|
end
|
|
|
|
def [](i)
|
|
return @array[i]
|
|
end
|
|
|
|
def []=(i,value)
|
|
@array[i] = value
|
|
end
|
|
|
|
def compact
|
|
@array.compact!
|
|
end
|
|
|
|
def insert(index,val)
|
|
@array.insert(index,val)
|
|
end
|
|
|
|
def delete_at(index)
|
|
@array.delete_at(index)
|
|
end
|
|
|
|
def resize(len)
|
|
idxStart = @array.length
|
|
idxEnd = len
|
|
if idxStart>idxEnd
|
|
for i in idxEnd...idxStart
|
|
@array.pop
|
|
end
|
|
else
|
|
for i in idxStart...idxEnd
|
|
@array.push(PBAnimation.new)
|
|
end
|
|
end
|
|
self.selected = len if self.selected>=len
|
|
end
|
|
end
|
|
|
|
|
|
|
|
#===============================================================================
|
|
#
|
|
#===============================================================================
|
|
class PBAnimation < Array
|
|
include Enumerable
|
|
attr_accessor :id
|
|
attr_accessor :name
|
|
attr_accessor :graphic
|
|
attr_accessor :hue
|
|
attr_accessor :position
|
|
attr_writer :speed
|
|
attr_reader :array
|
|
attr_reader :timing
|
|
MAX_SPRITES = 60
|
|
|
|
def speed
|
|
return @speed || 20
|
|
end
|
|
|
|
def initialize(size=1)
|
|
@id = -1
|
|
@name = ""
|
|
@graphic = ""
|
|
@hue = 0
|
|
@position = 4 # 1=target, 2=user, 3=user and target, 4=screen
|
|
@array = []
|
|
size = 1 if size<1 # Always create at least one frame
|
|
size.times { addFrame }
|
|
@timing = []
|
|
@scope = 0
|
|
end
|
|
|
|
def length
|
|
return @array.length
|
|
end
|
|
|
|
def each
|
|
@array.each { |i| yield i }
|
|
end
|
|
|
|
def [](i)
|
|
return @array[i]
|
|
end
|
|
|
|
def []=(i,value)
|
|
@array[i] = value
|
|
end
|
|
|
|
def insert(*arg)
|
|
return @array.insert(*arg)
|
|
end
|
|
|
|
def delete_at(*arg)
|
|
return @array.delete_at(*arg)
|
|
end
|
|
|
|
def resize(len)
|
|
if len<@array.length
|
|
@array[len,@array.length-len] = []
|
|
elsif len>@array.length
|
|
(len-@array.length).times do
|
|
addFrame
|
|
end
|
|
end
|
|
end
|
|
|
|
def addFrame
|
|
pos = @array.length
|
|
@array[pos] = []
|
|
# Move's user
|
|
@array[pos][0] = pbCreateCel(Battle::Scene::FOCUSUSER_X, Battle::Scene::FOCUSUSER_Y,-1)
|
|
@array[pos][0][AnimFrame::FOCUS] = 2
|
|
@array[pos][0][AnimFrame::LOCKED] = 1
|
|
# Move's target
|
|
@array[pos][1] = pbCreateCel(Battle::Scene::FOCUSTARGET_X, Battle::Scene::FOCUSTARGET_Y,-2)
|
|
@array[pos][1][AnimFrame::FOCUS] = 1
|
|
@array[pos][1][AnimFrame::LOCKED] = 1
|
|
return @array[pos]
|
|
end
|
|
|
|
def playTiming(frame,bgGraphic,bgColor,foGraphic,foColor,oldbg=[],oldfo=[],user=nil)
|
|
for i in @timing
|
|
next if i.frame!=frame
|
|
case i.timingType
|
|
when 0 # Play SE
|
|
if i.name && i.name!=""
|
|
pbSEPlay("Anim/"+i.name,i.volume,i.pitch)
|
|
elsif user && user.pokemon
|
|
name = GameData::Species.cry_filename_from_pokemon(user.pokemon)
|
|
pbSEPlay(name,i.volume,i.pitch) if name
|
|
end
|
|
# if sprite
|
|
# sprite.flash(i.flashColor,i.flashDuration*2) if i.flashScope==1
|
|
# sprite.flash(nil,i.flashDuration*2) if i.flashScope==3
|
|
# end
|
|
when 1 # Set background graphic (immediate)
|
|
if i.name && i.name!=""
|
|
bgGraphic.setBitmap("Graphics/Animations/"+i.name)
|
|
bgGraphic.ox = -i.bgX || 0
|
|
bgGraphic.oy = -i.bgY || 0
|
|
bgGraphic.color = Color.new(i.colorRed || 0,i.colorGreen || 0,i.colorBlue || 0,i.colorAlpha || 0)
|
|
bgGraphic.opacity = i.opacity || 0
|
|
bgColor.opacity = 0
|
|
else
|
|
bgGraphic.setBitmap(nil)
|
|
bgGraphic.opacity = 0
|
|
bgColor.color = Color.new(i.colorRed || 0,i.colorGreen || 0,i.colorBlue || 0,i.colorAlpha || 0)
|
|
bgColor.opacity = i.opacity || 0
|
|
end
|
|
when 2 # Move/recolour background graphic
|
|
if bgGraphic.bitmap!=nil
|
|
oldbg[0] = bgGraphic.ox || 0
|
|
oldbg[1] = bgGraphic.oy || 0
|
|
oldbg[2] = bgGraphic.opacity || 0
|
|
oldbg[3] = bgGraphic.color.clone || Color.new(0,0,0,0)
|
|
else
|
|
oldbg[0] = 0
|
|
oldbg[1] = 0
|
|
oldbg[2] = bgColor.opacity || 0
|
|
oldbg[3] = bgColor.color.clone || Color.new(0,0,0,0)
|
|
end
|
|
when 3 # Set foreground graphic (immediate)
|
|
if i.name && i.name!=""
|
|
foGraphic.setBitmap("Graphics/Animations/"+i.name)
|
|
foGraphic.ox = -i.bgX || 0
|
|
foGraphic.oy = -i.bgY || 0
|
|
foGraphic.color = Color.new(i.colorRed || 0,i.colorGreen || 0,i.colorBlue || 0,i.colorAlpha || 0)
|
|
foGraphic.opacity = i.opacity || 0
|
|
foColor.opacity = 0
|
|
else
|
|
foGraphic.setBitmap(nil)
|
|
foGraphic.opacity = 0
|
|
foColor.color = Color.new(i.colorRed || 0,i.colorGreen || 0,i.colorBlue || 0,i.colorAlpha || 0)
|
|
foColor.opacity = i.opacity || 0
|
|
end
|
|
when 4 # Move/recolour foreground graphic
|
|
if foGraphic.bitmap!=nil
|
|
oldfo[0] = foGraphic.ox || 0
|
|
oldfo[1] = foGraphic.oy || 0
|
|
oldfo[2] = foGraphic.opacity || 0
|
|
oldfo[3] = foGraphic.color.clone || Color.new(0,0,0,0)
|
|
else
|
|
oldfo[0] = 0
|
|
oldfo[1] = 0
|
|
oldfo[2] = foColor.opacity || 0
|
|
oldfo[3] = foColor.color.clone || Color.new(0,0,0,0)
|
|
end
|
|
end
|
|
end
|
|
for i in @timing
|
|
case i.timingType
|
|
when 2
|
|
next if !i.duration || i.duration<=0
|
|
next if frame<i.frame || frame>i.frame+i.duration
|
|
fraction = (frame-i.frame).to_f/i.duration
|
|
if bgGraphic.bitmap!=nil
|
|
bgGraphic.ox = oldbg[0]-(i.bgX-oldbg[0])*fraction if i.bgX!=nil
|
|
bgGraphic.oy = oldbg[1]-(i.bgY-oldbg[1])*fraction if i.bgY!=nil
|
|
bgGraphic.opacity = oldbg[2]+(i.opacity-oldbg[2])*fraction if i.opacity!=nil
|
|
cr = (i.colorRed!=nil) ? oldbg[3].red+(i.colorRed-oldbg[3].red)*fraction : oldbg[3].red
|
|
cg = (i.colorGreen!=nil) ? oldbg[3].green+(i.colorGreen-oldbg[3].green)*fraction : oldbg[3].green
|
|
cb = (i.colorBlue!=nil) ? oldbg[3].blue+(i.colorBlue-oldbg[3].blue)*fraction : oldbg[3].blue
|
|
ca = (i.colorAlpha!=nil) ? oldbg[3].alpha+(i.colorAlpha-oldbg[3].alpha)*fraction : oldbg[3].alpha
|
|
bgGraphic.color = Color.new(cr,cg,cb,ca)
|
|
else
|
|
bgColor.opacity = oldbg[2]+(i.opacity-oldbg[2])*fraction if i.opacity!=nil
|
|
cr = (i.colorRed!=nil) ? oldbg[3].red+(i.colorRed-oldbg[3].red)*fraction : oldbg[3].red
|
|
cg = (i.colorGreen!=nil) ? oldbg[3].green+(i.colorGreen-oldbg[3].green)*fraction : oldbg[3].green
|
|
cb = (i.colorBlue!=nil) ? oldbg[3].blue+(i.colorBlue-oldbg[3].blue)*fraction : oldbg[3].blue
|
|
ca = (i.colorAlpha!=nil) ? oldbg[3].alpha+(i.colorAlpha-oldbg[3].alpha)*fraction : oldbg[3].alpha
|
|
bgColor.color = Color.new(cr,cg,cb,ca)
|
|
end
|
|
when 4
|
|
next if !i.duration || i.duration<=0
|
|
next if frame<i.frame || frame>i.frame+i.duration
|
|
fraction = (frame-i.frame).to_f/i.duration
|
|
if foGraphic.bitmap!=nil
|
|
foGraphic.ox = oldfo[0]-(i.bgX-oldfo[0])*fraction if i.bgX!=nil
|
|
foGraphic.oy = oldfo[1]-(i.bgY-oldfo[1])*fraction if i.bgY!=nil
|
|
foGraphic.opacity = oldfo[2]+(i.opacity-oldfo[2])*fraction if i.opacity!=nil
|
|
cr = (i.colorRed!=nil) ? oldfo[3].red+(i.colorRed-oldfo[3].red)*fraction : oldfo[3].red
|
|
cg = (i.colorGreen!=nil) ? oldfo[3].green+(i.colorGreen-oldfo[3].green)*fraction : oldfo[3].green
|
|
cb = (i.colorBlue!=nil) ? oldfo[3].blue+(i.colorBlue-oldfo[3].blue)*fraction : oldfo[3].blue
|
|
ca = (i.colorAlpha!=nil) ? oldfo[3].alpha+(i.colorAlpha-oldfo[3].alpha)*fraction : oldfo[3].alpha
|
|
foGraphic.color = Color.new(cr,cg,cb,ca)
|
|
else
|
|
foColor.opacity = oldfo[2]+(i.opacity-oldfo[2])*fraction if i.opacity!=nil
|
|
cr = (i.colorRed!=nil) ? oldfo[3].red+(i.colorRed-oldfo[3].red)*fraction : oldfo[3].red
|
|
cg = (i.colorGreen!=nil) ? oldfo[3].green+(i.colorGreen-oldfo[3].green)*fraction : oldfo[3].green
|
|
cb = (i.colorBlue!=nil) ? oldfo[3].blue+(i.colorBlue-oldfo[3].blue)*fraction : oldfo[3].blue
|
|
ca = (i.colorAlpha!=nil) ? oldfo[3].alpha+(i.colorAlpha-oldfo[3].alpha)*fraction : oldfo[3].alpha
|
|
foColor.color = Color.new(cr,cg,cb,ca)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
#===============================================================================
|
|
#
|
|
#===============================================================================
|
|
def pbSpriteSetAnimFrame(sprite,frame,user=nil,target=nil,inEditor=false)
|
|
return if !sprite
|
|
if !frame
|
|
sprite.visible = false
|
|
sprite.src_rect = Rect.new(0,0,1,1)
|
|
return
|
|
end
|
|
sprite.blend_type = frame[AnimFrame::BLENDTYPE]
|
|
sprite.angle = frame[AnimFrame::ANGLE]
|
|
sprite.mirror = (frame[AnimFrame::MIRROR]>0)
|
|
sprite.opacity = frame[AnimFrame::OPACITY]
|
|
sprite.visible = true
|
|
if !frame[AnimFrame::VISIBLE]==1 && inEditor
|
|
sprite.opacity /= 2
|
|
else
|
|
sprite.visible = (frame[AnimFrame::VISIBLE]==1)
|
|
end
|
|
pattern = frame[AnimFrame::PATTERN]
|
|
if pattern>=0
|
|
animwidth = 192
|
|
sprite.src_rect.set((pattern%5)*animwidth,(pattern/5)*animwidth,
|
|
animwidth,animwidth)
|
|
else
|
|
sprite.src_rect.set(0,0,
|
|
(sprite.bitmap) ? sprite.bitmap.width : 128,
|
|
(sprite.bitmap) ? sprite.bitmap.height : 128)
|
|
end
|
|
sprite.zoom_x = frame[AnimFrame::ZOOMX]/100.0
|
|
sprite.zoom_y = frame[AnimFrame::ZOOMY]/100.0
|
|
sprite.color.set(
|
|
frame[AnimFrame::COLORRED],
|
|
frame[AnimFrame::COLORGREEN],
|
|
frame[AnimFrame::COLORBLUE],
|
|
frame[AnimFrame::COLORALPHA]
|
|
)
|
|
sprite.tone.set(
|
|
frame[AnimFrame::TONERED],
|
|
frame[AnimFrame::TONEGREEN],
|
|
frame[AnimFrame::TONEBLUE],
|
|
frame[AnimFrame::TONEGRAY]
|
|
)
|
|
sprite.ox = sprite.src_rect.width/2
|
|
sprite.oy = sprite.src_rect.height/2
|
|
sprite.x = frame[AnimFrame::X]
|
|
sprite.y = frame[AnimFrame::Y]
|
|
if sprite!=user && sprite!=target
|
|
case frame[AnimFrame::PRIORITY]
|
|
when 0 # Behind everything
|
|
sprite.z = 10
|
|
when 1 # In front of everything
|
|
sprite.z = 80
|
|
when 2 # Just behind focus
|
|
case frame[AnimFrame::FOCUS]
|
|
when 1 # Focused on target
|
|
sprite.z = (target) ? target.z-1 : 20
|
|
when 2 # Focused on user
|
|
sprite.z = (user) ? user.z-1 : 20
|
|
else # Focused on user and target, or screen
|
|
sprite.z = 20
|
|
end
|
|
when 3 # Just in front of focus
|
|
case frame[AnimFrame::FOCUS]
|
|
when 1 # Focused on target
|
|
sprite.z = (target) ? target.z+1 : 80
|
|
when 2 # Focused on user
|
|
sprite.z = (user) ? user.z+1 : 80
|
|
else # Focused on user and target, or screen
|
|
sprite.z = 80
|
|
end
|
|
else
|
|
sprite.z = 80
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
#===============================================================================
|
|
# Animation player
|
|
#===============================================================================
|
|
class PBAnimationPlayerX
|
|
attr_accessor :looping
|
|
MAX_SPRITES = 60
|
|
|
|
def initialize(animation,user,target,scene=nil,oppMove=false,inEditor=false)
|
|
@animation = animation
|
|
@user = (oppMove) ? target : user # Just used for playing user's cry
|
|
@usersprite = (user) ? scene.sprites["pokemon_#{user.index}"] : nil
|
|
@targetsprite = (target) ? scene.sprites["pokemon_#{target.index}"] : nil
|
|
@userbitmap = (@usersprite && @usersprite.bitmap) ? @usersprite.bitmap : nil # not to be disposed
|
|
@targetbitmap = (@targetsprite && @targetsprite.bitmap) ? @targetsprite.bitmap : nil # not to be disposed
|
|
@scene = scene
|
|
@viewport = (scene) ? scene.viewport : nil
|
|
@inEditor = inEditor
|
|
@looping = false
|
|
@animbitmap = nil # Animation sheet graphic
|
|
@frame = -1
|
|
@framesPerTick = [Graphics.frame_rate/20,1].max # 20 ticks per second
|
|
@srcLine = nil
|
|
@dstLine = nil
|
|
@userOrig = getSpriteCenter(@usersprite)
|
|
@targetOrig = getSpriteCenter(@targetsprite)
|
|
@oldbg = []
|
|
@oldfo = []
|
|
initializeSprites
|
|
end
|
|
|
|
def initializeSprites
|
|
# Create animation sprites (0=user's sprite, 1=target's sprite)
|
|
@animsprites = []
|
|
@animsprites[0] = @usersprite
|
|
@animsprites[1] = @targetsprite
|
|
for i in 2...MAX_SPRITES
|
|
@animsprites[i] = Sprite.new(@viewport)
|
|
@animsprites[i].bitmap = nil
|
|
@animsprites[i].visible = false
|
|
end
|
|
# Create background colour sprite
|
|
@bgColor = ColoredPlane.new(Color.new(0,0,0),@viewport)
|
|
@bgColor.borderX = 64 if @inEditor
|
|
@bgColor.borderY = 64 if @inEditor
|
|
@bgColor.z = 5
|
|
@bgColor.opacity = 0
|
|
@bgColor.refresh
|
|
# Create background graphic sprite
|
|
@bgGraphic = AnimatedPlane.new(@viewport)
|
|
@bgGraphic.setBitmap(nil)
|
|
@bgGraphic.borderX = 64 if @inEditor
|
|
@bgGraphic.borderY = 64 if @inEditor
|
|
@bgGraphic.z = 5
|
|
@bgGraphic.opacity = 0
|
|
@bgGraphic.refresh
|
|
# Create foreground colour sprite
|
|
@foColor = ColoredPlane.new(Color.new(0,0,0),@viewport)
|
|
@foColor.borderX = 64 if @inEditor
|
|
@foColor.borderY = 64 if @inEditor
|
|
@foColor.z = 85
|
|
@foColor.opacity = 0
|
|
@foColor.refresh
|
|
# Create foreground graphic sprite
|
|
@foGraphic = AnimatedPlane.new(@viewport)
|
|
@foGraphic.setBitmap(nil)
|
|
@foGraphic.borderX = 64 if @inEditor
|
|
@foGraphic.borderY = 64 if @inEditor
|
|
@foGraphic.z = 85
|
|
@foGraphic.opacity = 0
|
|
@foGraphic.refresh
|
|
end
|
|
|
|
def dispose
|
|
@animbitmap.dispose if @animbitmap
|
|
for i in 2...MAX_SPRITES
|
|
@animsprites[i].dispose if @animsprites[i]
|
|
end
|
|
@bgGraphic.dispose
|
|
@bgColor.dispose
|
|
@foGraphic.dispose
|
|
@foColor.dispose
|
|
end
|
|
|
|
def start
|
|
@frame = 0
|
|
end
|
|
|
|
def animDone?
|
|
return @frame<0
|
|
end
|
|
|
|
def setLineTransform(x1,y1,x2,y2,x3,y3,x4,y4)
|
|
@srcLine = [x1,y1,x2,y2]
|
|
@dstLine = [x3,y3,x4,y4]
|
|
end
|
|
|
|
def update
|
|
return if @frame<0
|
|
animFrame = @frame/@framesPerTick
|
|
|
|
# Loop or end the animation if the animation has reached the end
|
|
if animFrame >= @animation.length
|
|
@frame = (@looping) ? 0 : -1
|
|
if @frame<0
|
|
@animbitmap.dispose if @animbitmap
|
|
@animbitmap = nil
|
|
return
|
|
end
|
|
end
|
|
# Load the animation's spritesheet and assign it to all the sprites.
|
|
if !@animbitmap || @animbitmap.disposed?
|
|
@animbitmap = AnimatedBitmap.new("Graphics/Animations/"+@animation.graphic,
|
|
@animation.hue).deanimate
|
|
for i in 0...MAX_SPRITES
|
|
@animsprites[i].bitmap = @animbitmap if @animsprites[i]
|
|
end
|
|
end
|
|
# Update background and foreground graphics
|
|
@bgGraphic.update
|
|
@bgColor.update
|
|
@foGraphic.update
|
|
@foColor.update
|
|
|
|
# Update all the sprites to depict the animation's next frame
|
|
if @framesPerTick==1 || (@frame%@framesPerTick)==0
|
|
thisframe = @animation[animFrame]
|
|
# Make all cel sprites invisible
|
|
for i in 0...MAX_SPRITES
|
|
@animsprites[i].visible = false if @animsprites[i]
|
|
end
|
|
# Set each cel sprite acoordingly
|
|
for i in 0...thisframe.length
|
|
cel = thisframe[i]
|
|
next if !cel
|
|
sprite = @animsprites[i]
|
|
next if !sprite
|
|
# Set cel sprite's graphic
|
|
case cel[AnimFrame::PATTERN]
|
|
when -1
|
|
sprite.bitmap = @userbitmap
|
|
when -2
|
|
sprite.bitmap = @targetbitmap
|
|
else
|
|
sprite.bitmap = @animbitmap
|
|
end
|
|
# Apply settings to the cel sprite
|
|
pbSpriteSetAnimFrame(sprite,cel,@usersprite,@targetsprite)
|
|
case cel[AnimFrame::FOCUS]
|
|
when 1 # Focused on target
|
|
sprite.x = cel[AnimFrame::X] + @targetOrig[0] - Battle::Scene::FOCUSTARGET_X
|
|
sprite.y = cel[AnimFrame::Y] + @targetOrig[1] - Battle::Scene::FOCUSTARGET_Y
|
|
when 2 # Focused on user
|
|
sprite.x = cel[AnimFrame::X] + @userOrig[0] - Battle::Scene::FOCUSUSER_X
|
|
sprite.y = cel[AnimFrame::Y] + @userOrig[1] - Battle::Scene::FOCUSUSER_Y
|
|
when 3 # Focused on user and target
|
|
next if !@srcLine || !@dstLine
|
|
point = transformPoint(
|
|
@srcLine[0],@srcLine[1],@srcLine[2],@srcLine[3],
|
|
@dstLine[0],@dstLine[1],@dstLine[2],@dstLine[3],
|
|
sprite.x,sprite.y)
|
|
sprite.x = point[0]
|
|
sprite.y = point[1]
|
|
if isReversed(@srcLine[0],@srcLine[2],@dstLine[0],@dstLine[2]) &&
|
|
cel[AnimFrame::PATTERN]>=0
|
|
# Reverse direction
|
|
sprite.mirror = !sprite.mirror
|
|
end
|
|
end
|
|
sprite.x += 64 if @inEditor
|
|
sprite.y += 64 if @inEditor
|
|
end
|
|
# Play timings
|
|
@animation.playTiming(animFrame,@bgGraphic,@bgColor,@foGraphic,@foColor,@oldbg,@oldfo,@user)
|
|
end
|
|
@frame += 1
|
|
end
|
|
end
|