class SpriteAnimation
    @@_animations = []
    @@_reference_count = {}
    def initialize(sprite)
      @sprite=sprite
    end
    %w[
      x y ox oy viewport flash src_rect opacity
    ].each_with_index do |s, i|
      eval <<-__END__
        def #{s}(*arg)
          @sprite.#{s}(*arg)
        end
      __END__
    end
    def self.clear
      @@_animations.clear
    end
    
    def dispose
      dispose_animation
      dispose_loop_animation
    end
    
    
    
    def animation(animation, hit)
      dispose_animation
      @_animation = animation
      return if @_animation == nil
      @_animation_hit = hit
      @_animation_duration = @_animation.frame_max
      animation_name = @_animation.animation_name
      animation_hue = @_animation.animation_hue
      bitmap = RPG::Cache.animation(animation_name, animation_hue)
      
      if @@_reference_count.include?(bitmap)
        @@_reference_count[bitmap] += 1
      else
        @@_reference_count[bitmap] = 1
      end
      
      @_animation_sprites = []
      if @_animation.position != 3 or not @@_animations.include?(animation)
        for i in 0..15
          sprite = ::Sprite.new(self.viewport)
          sprite.bitmap = bitmap
          sprite.visible = false
          @_animation_sprites.push(sprite)
        end
        unless @@_animations.include?(animation)
          @@_animations.push(animation)
        end
      end
      update_animation
    end
    
    
    
    def loop_animation(animation)
      return if animation == @_loop_animation
      dispose_loop_animation
      @_loop_animation = animation
      return if @_loop_animation == nil
      @_loop_animation_index = 0
      animation_name = @_loop_animation.animation_name
      animation_hue = @_loop_animation.animation_hue
      bitmap = RPG::Cache.animation(animation_name, animation_hue)
      if @@_reference_count.include?(bitmap)
        @@_reference_count[bitmap] += 1
      else
        @@_reference_count[bitmap] = 1
      end
      @_loop_animation_sprites = []
      for i in 0..15
        sprite = ::Sprite.new(self.viewport)
        sprite.bitmap = bitmap
        sprite.visible = false
        @_loop_animation_sprites.push(sprite)
      end
      update_loop_animation
    end
    
    
    def dispose_animation
      if @_animation_sprites != nil
        sprite = @_animation_sprites[0]
        if sprite != nil
          @@_reference_count[sprite.bitmap] -= 1
          if @@_reference_count[sprite.bitmap] == 0
            sprite.bitmap.dispose
          end
        end
        for sprite in @_animation_sprites
          sprite.dispose
        end
        @_animation_sprites = nil
        @_animation = nil
      end
    end
    
    
    def dispose_loop_animation
      if @_loop_animation_sprites != nil
        sprite = @_loop_animation_sprites[0]
        if sprite != nil
          @@_reference_count[sprite.bitmap] -= 1
          if @@_reference_count[sprite.bitmap] == 0
            sprite.bitmap.dispose
          end
        end
        for sprite in @_loop_animation_sprites
          sprite.dispose
        end
        @_loop_animation_sprites = nil
        @_loop_animation = nil
      end
    end
    
    
    def active?
      @_loop_animation_sprites != nil ||
      @_animation_sprites != nil
    end
    
    
    def effect?
      @_animation_duration > 0
    end
    
    
    def update
      if @_animation != nil and (Graphics.frame_count % 2 == 0)
        @_animation_duration -= 1
        update_animation
      end
      if @_loop_animation != nil and (Graphics.frame_count % 2 == 0)
        update_loop_animation
        @_loop_animation_index += 1
        @_loop_animation_index %= @_loop_animation.frame_max
      end
    end
    
    
    def update_animation
      if @_animation_duration > 0
        frame_index = @_animation.frame_max - @_animation_duration
        cell_data = @_animation.frames[frame_index].cell_data
        position = @_animation.position
        animation_set_sprites(@_animation_sprites, cell_data, position)
        for timing in @_animation.timings
          if timing.frame == frame_index
            animation_process_timing(timing, @_animation_hit)
          end
        end
      else
        dispose_animation
      end
    end
    
    
    def update_loop_animation
      frame_index = @_loop_animation_index
      cell_data = @_loop_animation.frames[frame_index].cell_data
      position = @_loop_animation.position
      animation_set_sprites(@_loop_animation_sprites, cell_data, position)
      for timing in @_loop_animation.timings
        if timing.frame == frame_index
          animation_process_timing(timing, true)
        end
      end
    end
    
    
    def animation_set_sprites(sprites, cell_data, position)
      for i in 0..15
        sprite = sprites[i]
        pattern = cell_data[i, 0]
        if sprite == nil or pattern == nil or pattern == -1
          sprite.visible = false if sprite != nil
          next
        end
        sprite.visible = true
        sprite.src_rect.set(pattern % 5 * 192, pattern / 5 * 192, 192, 192)
        if position == 3
          if self.viewport != nil
            sprite.x = self.viewport.rect.width / 2
            sprite.y = self.viewport.rect.height - 160
          else
            sprite.x = 320
            sprite.y = 240
          end
        else
          sprite.x = self.x - self.ox + self.src_rect.width / 2
          sprite.y = self.y - self.oy + self.src_rect.height / 2
          sprite.y -= self.src_rect.height / 4 if position == 0
          sprite.y += self.src_rect.height / 4 if position == 2
        end
        sprite.x += cell_data[i, 1]
        sprite.y += cell_data[i, 2]
        sprite.z = 2000
        sprite.ox = 96
        sprite.oy = 96
        sprite.zoom_x = cell_data[i, 3] / 100.0
        sprite.zoom_y = cell_data[i, 3] / 100.0
        sprite.angle = cell_data[i, 4]
        sprite.mirror = (cell_data[i, 5] == 1)
        sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
        sprite.blend_type = cell_data[i, 7]
      end
    end
    def animation_process_timing(timing, hit)
      if (timing.condition == 0) or
         (timing.condition == 1 and hit == true) or
         (timing.condition == 2 and hit == false)
        if timing.se.name != ""
          se = timing.se
          Audio.se_play("Audio/SE/" + se.name, se.volume, se.pitch)
        end
        case timing.flash_scope
        when 1
          self.flash(timing.flash_color, timing.flash_duration * 2)
        when 2
          if self.viewport != nil
            self.viewport.flash(timing.flash_color, timing.flash_duration * 2)
          end
        when 3
          self.flash(nil, timing.flash_duration * 2)
        end
      end
    end
    def x=(x)
      sx = x - self.x
      if sx != 0
        if @_animation_sprites != nil
          for i in 0..15
            @_animation_sprites[i].x += sx
          end
        end
        if @_loop_animation_sprites != nil
          for i in 0..15
            @_loop_animation_sprites[i].x += sx
          end
        end
      end
    end
    def y=(y)
      sy = y - self.y
      if sy != 0
        if @_animation_sprites != nil
          for i in 0..15
            @_animation_sprites[i].y += sy
          end
        end
        if @_loop_animation_sprites != nil
          for i in 0..15
            @_loop_animation_sprites[i].y += sy
          end
        end
      end
    end
end
  
  
  
  
  
  
  
  

module RPG
  class Sprite < ::Sprite
    def initialize(viewport = nil)
      super(viewport)
      @_whiten_duration = 0
      @_appear_duration = 0
      @_escape_duration = 0
      @_collapse_duration = 0
      @_damage_duration = 0
      @_animation_duration = 0
      @_blink = false
      @animations=[]
      @loopAnimations=[]
    end
    def dispose
      dispose_damage
      dispose_animation
      dispose_loop_animation
      super
    end
    def whiten
      self.blend_type = 0
      self.color.set(255, 255, 255, 128)
      self.opacity = 255
      @_whiten_duration = 16
      @_appear_duration = 0
      @_escape_duration = 0
      @_collapse_duration = 0
    end
    def appear
      self.blend_type = 0
      self.color.set(0, 0, 0, 0)
      self.opacity = 0
      @_appear_duration = 16
      @_whiten_duration = 0
      @_escape_duration = 0
      @_collapse_duration = 0
    end
    def escape
      self.blend_type = 0
      self.color.set(0, 0, 0, 0)
      self.opacity = 255
      @_escape_duration = 32
      @_whiten_duration = 0
      @_appear_duration = 0
      @_collapse_duration = 0
    end
    def collapse
      self.blend_type = 1
      self.color.set(255, 64, 64, 255)
      self.opacity = 255
      @_collapse_duration = 48
      @_whiten_duration = 0
      @_appear_duration = 0
      @_escape_duration = 0
    end
    def damage(value, critical)
      dispose_damage
      if value.is_a?(Numeric)
        damage_string = value.abs.to_s
      else
        damage_string = value.to_s
      end
      bitmap = Bitmap.new(160, 48)
      bitmap.font.name = "Arial Black"
      bitmap.font.size = 32
      bitmap.font.color.set(0, 0, 0)
      bitmap.draw_text(-1, 12-1, 160, 36, damage_string, 1)
      bitmap.draw_text(+1, 12-1, 160, 36, damage_string, 1)
      bitmap.draw_text(-1, 12+1, 160, 36, damage_string, 1)
      bitmap.draw_text(+1, 12+1, 160, 36, damage_string, 1)
      if value.is_a?(Numeric) and value < 0
        bitmap.font.color.set(176, 255, 144)
      else
        bitmap.font.color.set(255, 255, 255)
      end
      bitmap.draw_text(0, 12, 160, 36, damage_string, 1)
      if critical
        bitmap.font.size = 20
        bitmap.font.color.set(0, 0, 0)
        bitmap.draw_text(-1, -1, 160, 20, "CRITICAL", 1)
        bitmap.draw_text(+1, -1, 160, 20, "CRITICAL", 1)
        bitmap.draw_text(-1, +1, 160, 20, "CRITICAL", 1)
        bitmap.draw_text(+1, +1, 160, 20, "CRITICAL", 1)
        bitmap.font.color.set(255, 255, 255)
        bitmap.draw_text(0, 0, 160, 20, "CRITICAL", 1)
      end
      @_damage_sprite = ::Sprite.new(self.viewport)
      @_damage_sprite.bitmap = bitmap
      @_damage_sprite.ox = 80
      @_damage_sprite.oy = 20
      @_damage_sprite.x = self.x
      @_damage_sprite.y = self.y - self.oy / 2
      @_damage_sprite.z = 3000
      @_damage_duration = 40
    end
    def pushAnimation(array,anim)
      for i in 0...array.length
        if !array[i] || !array[i].active?
          array[i]=anim
          return
        end
      end
      array.push(anim)
    end
    def animation(animation, hit)
      anim=SpriteAnimation.new(self)
      anim.animation(animation,hit)
      pushAnimation(@animations,anim)
    end
    def loop_animation(animation)
      anim=SpriteAnimation.new(self)
      anim.loop_animation(animation)
      pushAnimation(@loopAnimations,anim)
    end
    def dispose_damage
      if @_damage_sprite != nil
        @_damage_sprite.bitmap.dispose
        @_damage_sprite.dispose
        @_damage_sprite = nil
        @_damage_duration = 0
      end
    end
    def dispose_animation
      for a in @animations
        a.dispose_animation if a
      end
      @animations.clear
    end
    def dispose_loop_animation
      for a in @loopAnimations
        a.dispose_loop_animation if a
      end
      @loopAnimations.clear
    end
    def blink_on
      unless @_blink
        @_blink = true
        @_blink_count = 0
      end
    end
    def blink_off
      if @_blink
        @_blink = false
        self.color.set(0, 0, 0, 0)
      end
    end
    def blink?
      @_blink
    end
    def effect?
      return true if @_whiten_duration > 0 or
        @_appear_duration > 0 or
        @_escape_duration > 0 or
        @_collapse_duration > 0 or
        @_damage_duration > 0
      for a in @animations
        return true if a.effect?
      end
      return false
    end
    
    def update
      super
      if @_whiten_duration > 0
        @_whiten_duration -= 1
        self.color.alpha = 128 - (16 - @_whiten_duration) * 10
      end
      if @_appear_duration > 0
        @_appear_duration -= 1
        self.opacity = (16 - @_appear_duration) * 16
      end
      if @_escape_duration > 0
        @_escape_duration -= 1
        self.opacity = 256 - (32 - @_escape_duration) * 10
      end
      if @_collapse_duration > 0
        @_collapse_duration -= 1
        self.opacity = 256 - (48 - @_collapse_duration) * 6
      end
      if @_damage_duration > 0
        @_damage_duration -= 1
        case @_damage_duration
        when 38..39
          @_damage_sprite.y -= 4
        when 36..37
          @_damage_sprite.y -= 2
        when 34..35
          @_damage_sprite.y += 2
        when 28..33
          @_damage_sprite.y += 4
        end
        @_damage_sprite.opacity = 256 - (12 - @_damage_duration) * 32
        if @_damage_duration == 0
          dispose_damage
        end
      end
      for a in @animations
        a.update
      end
      for a in @loopAnimations
        a.update
      end
      if @_blink
        @_blink_count = (@_blink_count + 1) % 32
        if @_blink_count < 16
          alpha = (16 - @_blink_count) * 6
        else
          alpha = (@_blink_count - 16) * 6
        end
        self.color.set(255, 255, 255, alpha)
      end
      SpriteAnimation.clear
    end
    def update_animation
      for a in @animations
        a.update_animation if a && a.active?
      end
    end
    def update_loop_animation
      for a in @loopAnimations
        a.update_loop_animation if a && a.active?
      end
    end
    def x=(x)
      sx = x - self.x
      for a in @animations
        a.x=x if a
      end
      for a in @loopAnimations
        a.x=x if a
      end
      super
    end
    def y=(y)
      sy = y - self.y
      for a in @animations
        a.x=x if a
      end
      for a in @loopAnimations
        a.x=x if a
      end
      super
    end
  end
end

class Ani < RPG::Sprite
  attr_accessor :anim
  def initialize
    
    super(Viewport.new(0, 0, 640, 480))
  end

  
  
  def mio(num,x,y)
   @num = num
   self.x = x
   self.y = y
   self.z = 8000
   @animation_call = $data_animations[@num]
   @frame_count = @animation_call.frame_max
   animation(@animation_call, true)
  

  end

  def animation(animation, hit)
      @anim=SpriteAnimation.new(self)
      @anim.animation(animation,hit)
      pushAnimation(@animations,anim)
      
      super_update
      
  end
    
  def super_update
  
    for i in 0 ... @frame_count
      Graphics.update
      @anim.update
      
    end
    @anim.update
    @anim.dispose
    self.dispose
    Graphics.update
  end
  
  
end

#Made by MCgamer @2009 , to use or modify it, just say I made the original and what changes you've made.

#this win32api is from Squall's win32 api screen size changer
#it is used primarily for getting screen size
#squall@loeher.znn.com

class Win32API
#--------------------------------------------------------------------------
# â—� define constant
#--------------------------------------------------------------------------
GAME_INI_FILE = ".\\Game.ini" # define "Game.ini" file
HWND_TOPMOST = 0 # window always active
HWND_TOP = -1 # window active when used only
SWP_NOMOVE = 0 # window pos and sizes can be changed
#--------------------------------------------------------------------------
# â—� Win32API.GetPrivateProfileString // check your game title in Game.ini
#--------------------------------------------------------------------------
def Win32API.GetPrivateProfileString(section, key)
val = "\0"*256
gps = Win32API.new('kernel32', 'GetPrivateProfileString',%w(p p p p l p), 'l')
gps.call(section, key, "", val, 256, GAME_INI_FILE)
val.delete!("\0")
return val
end
#--------------------------------------------------------------------------
# â—� Win32API.FindWindow // find the RGSS window
#--------------------------------------------------------------------------
def Win32API.FindWindow(class_name, title)
fw = Win32API.new('user32', 'FindWindow', %(p, p), 'i')
hWnd = fw.call(class_name, title)
return hWnd
end
#--------------------------------------------------------------------------
# â—� Win32API.SetWindowPos // change window positions
#--------------------------------------------------------------------------
def Win32API.SetWindowPos(w, h)
title = Win32API.GetPrivateProfileString("Game", "Title")
hWnd = Win32API.FindWindow("RGSS Player", title)
swp = Win32API.new('user32', 'SetWindowPos', %(l, l, i, i, i, i, i), 'i')
win = swp.call(hWnd, HWND_TOP, 150, 50, w+6,h+32, 0)

#the line below makes the window on top of all others
#win = swp.call(hWnd, HWND_TOPMOST, 0, 0, w + 6, h + 32, SWP_NOMOVE)
return win
end
#--------------------------------------------------------------------------
# â—� Win32API.client_size // check the window width and height
#--------------------------------------------------------------------------
def Win32API.client_size
title = Win32API.GetPrivateProfileString("Game", "Title")
hWnd = Win32API.FindWindow("RGSS Player", title)
rect = [0, 0, 0, 0].pack('l4')
Win32API.new('user32', 'GetClientRect', %w(l p), 'i').call(hWnd, rect)
width, height = rect.unpack('l4')[2..3]
return width, height
end



end


$width , $height = Win32API.client_size();




#===================================================#
# #
#===================================================#


class Animator

def initialize()

@viewer = Viewport.new(0,0,$width, $height)
@viewer.visible = true;
@viewer.z = 20000


@anime = RPG::Sprite.new();
end

def dispose()

@anime.dispose();
end

#================================#
##################################
def run(*args)
if args.size > 5 or args.size < 3
return;
elsif args.size == 5
runANI(args[0],args[1],args[2],args[3],args[4]);
elsif args.size == 3
runV1(args[0],args[1],args[2]);
elsif args.include?(true) or args.include?(false)
runV3(args[0],args[1],args[2],args[3]);
else
runV2(args[0],args[1],args[2],args[3]);
end

end

#each V stands for "version"
def runV3(ani_id, x, y, hit)
runANI(ani_id, x, y, 2000, hit);
end

def runV2(ani_id, x, y, z)
runANI(ani_id, x, y, z, true);
end

def runV1(ani_id, x, y)
runANI(ani_id, x, y, 2000, true);
end


#=============================#
def runANI(ani_id, x, y, z, hit)
#establish location
@anime.x = x;
@anime.y = y;
@anime.z = z;
anim = $data_animations[ani_id];
size = anim.frame_max;
@anime.animation(anim, hit);
#run animation
for i in 0...size
@anime.update();
Graphics.update();
end
@anime.dispose();
@anime = RPG::Sprite.new();



end

#================================#
##################################
#this will run it the number of times you want
#with some spacing in between.
def timed_ani(ani_id, x=100, y=100, z=2000,
howManyTimes = 1,
overWhatPeriodOfTime = 1)
interval = overWhatPeriodOfTime / howManyTimes;
interval = 5 if interval < 5;
#@viewer = Viewport.new(0,0,$width, $height)
Thread.new(){
for i in 0...howManyTimes

@anime.x = x;
@anime.y = y;
@anime.z = z;
anim = $data_animations[ani_id];
size = anim.frame_max;
@anime.animation(anim, true);
for i in 0...size
@anime.update();
Graphics.update();
end
@anime.dispose();
@anime = RPG::Sprite.new();

sleep(interval);
end
}

end
#================================#
##################################
#good for lightning effects or any periodic flashes for that matter.

def timed_flash(color = color.new(0,0,0,0),
howManyTimes = 1,
overWhatPeriodOfTime = 1,#note this is in seconds
seAudioName = nil)

interval = overWhatPeriodOfTime / howManyTimes;
interval = 5 if interval < 5;
#@viewer = Viewport.new(0,0,$width, $height)
Thread.new(){
for i in 0...howManyTimes

$ani.flash(color, 14);
Audio.se_play(seAudioName) if seAudioName != nil;
Graphics.update();
sleep(4);
Audio.se_stop();
sleep(interval-4);

end

}


end

#========================#
def flash(newcolor, duration )
#@viewer = Viewport.new(0,0,$width, $height)
@viewer.flash(newcolor, duration);
for i in 0... duration
@viewer.update()
Graphics.update()
end


end

end #end of class





$ani = Animator.new


#========================

####################################
scripter: MCgamer

####################################



#win32api is from Squall's win32 api screen size changer
#squall@loeher.znn.com

class Win32API
#--------------------------------------------------------------------------
# â—� define constant
#--------------------------------------------------------------------------
GAME_INI_FILE = ".\\Game.ini" # define "Game.ini" file
HWND_TOPMOST = 0 # window always active
HWND_TOP = -1 # window active when used only
SWP_NOMOVE = 0 # window pos and sizes can be changed
#--------------------------------------------------------------------------
# â—� Win32API.GetPrivateProfileString // check your game title in Game.ini
#--------------------------------------------------------------------------
def Win32API.GetPrivateProfileString(section, key)
val = "\0"*256
gps = Win32API.new('kernel32', 'GetPrivateProfileString',%w(p p p p l p), 'l')
gps.call(section, key, "", val, 256, GAME_INI_FILE)
val.delete!("\0")
return val
end
#--------------------------------------------------------------------------
# â—� Win32API.FindWindow // find the RGSS window
#--------------------------------------------------------------------------
def Win32API.FindWindow(class_name, title)
fw = Win32API.new('user32', 'FindWindow', %(p, p), 'i')
hWnd = fw.call(class_name, title)
return hWnd
end
#--------------------------------------------------------------------------
# â—� Win32API.SetWindowPos // change window positions
#--------------------------------------------------------------------------
def Win32API.SetWindowPos(w, h)
title = Win32API.GetPrivateProfileString("Game", "Title")
hWnd = Win32API.FindWindow("RGSS Player", title)
swp = Win32API.new('user32', 'SetWindowPos', %(l, l, i, i, i, i, i), 'i')
win = swp.call(hWnd, HWND_TOP, 150, 50, w+6,h+32, 0)

#the line below makes the window on top of all others
#win = swp.call(hWnd, HWND_TOPMOST, 0, 0, w + 6, h + 32, SWP_NOMOVE)
return win
end
#--------------------------------------------------------------------------
# â—� Win32API.client_size // check the window width and height
#--------------------------------------------------------------------------
def Win32API.client_size
title = Win32API.GetPrivateProfileString("Game", "Title")
hWnd = Win32API.FindWindow("RGSS Player", title)
rect = [0, 0, 0, 0].pack('l4')
Win32API.new('user32', 'GetClientRect', %w(l p), 'i').call(hWnd, rect)
width, height = rect.unpack('l4')[2..3]
return width, height
end



end


$width , $height = Win32API.client_size();




#===================================================#
#Animator 2.6#
#===================================================#


class Animator


def initialize()
#=========================================================
#change if you want weather to run during non map scenes
@run_weather_in_non_map_scenes = false
#==============================

@viewer = Viewport.new(0,0,$width, $height)
@viewer.visible = true;
@viewer.z = 20000

@weather1 = Viewport.new(0,0,$width, $height)
@weather1.visible = true;
@weather1.z = 20002

@continueWeather = false;

@anime = RPG::Sprite.new();
end

def dispose()
@viewer.dispose();
@weather1.dispose();

@anime.dispose();
end

#================================#
##################################
def run(*args)
if args.size > 5 or args.size < 3
return;
elsif args.size == 5
runANI(args[0],args[1],args[2],args[3],args[4]);
elsif args.size == 3
runV1(args[0],args[1],args[2]);
elsif args.include?(true) or args.include?(false)
runV3(args[0],args[1],args[2],args[3]);
else
runV2(args[0],args[1],args[2],args[3]);
end

end

#each V stands for "version"
def runV3(ani_id, x, y, hit)
runANI(ani_id, x, y, 2000, hit);
end

def runV2(ani_id, x, y, z)
runANI(ani_id, x, y, z, true);
end

def runV1(ani_id, x, y)
runANI(ani_id, x, y, 2000, true);
end


#=============================#
def runANI(ani_id, x, y, z, hit)
#establish location
@anime.x = x;
@anime.y = y;
@anime.z = z;
anim = $data_animations[ani_id];
size = anim.frame_max;
@anime.animation(anim, hit);
#run animation
for i in 0...size
@anime.update();
#$scene.update() if $scene.respond_to?(:update)
Graphics.update();
end
@anime.dispose();
@anime = RPG::Sprite.new();



end

#================================#
##################################
#this will run it the number of times you want
#with some spacing in between.
def timed_ani(ani_id, x=100, y=100, z=2000,
howManyTimes = 1,
overWhatPeriodOfTime = 1)
interval = overWhatPeriodOfTime / howManyTimes;
interval = 5 if interval < 5;

Thread.new(){
for i in 0...howManyTimes

@anime.x = x;
@anime.y = y;
@anime.z = z;
anim = $data_animations[ani_id];
size = anim.frame_max;
@anime.animation(anim, true);
for i in 0...size
@anime.update();
#$scene.update() if $scene.respond_to?(:update)
Graphics.update();

end
@anime.dispose();
@anime = RPG::Sprite.new();

sleep(interval);
end
}

end
#================================#
##################################
#good for lightning effects or any periodic flashes for that matter.

def timed_flash(color = color.new(0,0,0,0),
howManyTimes = 1,
overWhatPeriodOfTime = 1,#note this is in seconds
seAudioName = nil)

interval = overWhatPeriodOfTime / howManyTimes;
interval = 5 if interval < 5;
#@viewer = Viewport.new(0,0,$width, $height)
Thread.new(){
for i in 0...howManyTimes

$ani.flash(color, 14);
Audio.se_play(seAudioName) if seAudioName != nil;
Graphics.update();
sleep(4);
Audio.se_stop();
sleep(interval-4);

end

}


end

#========================#
def flash(newcolor, duration )
#@viewer = Viewport.new(0,0,$width, $height)
@viewer.flash(newcolor, duration);
for i in 0... duration
@viewer.update()
Graphics.update()
end


end


##############################################
#drive weather patterns
##############################################
#this will alternate back and forth between
#desired weather(s)(it will always show all of them at the same time)
#and none, always varying in intensity.
#This will drive the weather continuously so you do have to make a
#call to $ani.cease_weather() if you want it to stop short of leaving the map.
#which if you do leave the map (ie go to Scene_Title) it will stop on its own.

#all timing is in terms of seconds
#intensity is from 2 to 40
#any intensity greater than 40 will likely be too resource intensive for
#your computer to handle, otherwise I would just make a second
#call to weather with the second call having maxIntensity lowered by 40
#input:duration wait,max intensity, and any number(s)from the weather list.
#For possible weathers, use following list:
#1 = rain
#2 = storm
#3 = snow

#ex of three weathers on top of eachother) $ani.weather(4,8, 10, 1,2,3)


#duration and wait affect how often the thread calls update
#!!!!!!!!!!WARNING!!!!!!!!!!!!!!!
#the weather method might not be compatible with the timed_ani() or run() methods
#if your computer has limited cpu resources and will make game end if that
#be the case that too many threads got called for this game.
#Weather is however, compatible with timed_flash
#This also looks cools if an event makes a call to the fog settings
#and uses clouds

##################################################################
def weather(duration,wait,maxIntensity, *weathers)
#weather(duration,wait,maxIntensity-40, weathers) if maxIntensity > 40
maxIntensity = 40 if maxIntensity > 40;

@continueWeather = true;
weather = RPG::Weather.new(@weather1);
weather.type = weathers[0]
weather.max = maxIntensity;

if weathers.size == 2
weather2 = RPG::Weather.new(@weather1);
weather2.type = weathers[1]
weather2.max = maxIntensity;
elsif weathers.size == 3
weather2 = RPG::Weather.new(@weather1);
weather2.type = weathers[1]
weather2.max = maxIntensity;
weather3 = RPG::Weather.new(@weather1);
weather3.type = weathers[2]
weather3.max = maxIntensity;
else
weather2 = nil;
weather3 = nil;
end

duration = 10 if duration < 10;
wait = 2 if wait < 0;
maxIntensity = 2 if maxIntensity < 2;


#======#

Thread.new(){

while @continueWeather == true
if @run_weather_in_non_map_scenes == false and
$scene.class != Scene_Map
weather.type = 0
weather2.type = 0 if weather2 != nil;
weather3.type = 0 if weather3 != nil;
@continueWeather = false
duration = 0;
end

weather.max = maxIntensity/3
weather2.max = maxIntensity/3 if weather2 != nil;
weather3.max = maxIntensity/3 if weather3 != nil;
weather.type = weathers[0];
weather2.type = weathers[1] if weather2 != nil;
weather3.type = weathers[2] if weather3 != nil;


for i in 0...duration
$scene.update() if $scene.class == Scene_Map
weather.update();
weather2.update() if weather2 != nil
weather3.update() if weather3 != nil
Graphics.update();
end
weather.max = maxIntensity
weather2.max = maxIntensity if weather2 != nil;
weather3.max = maxIntensity if weather3 != nil;

for i in 0...duration
$scene.update() if $scene.class == Scene_Map
duration = 0 if @continueWeather == false
weather.update();
weather2.update() if weather2 != nil
weather3.update() if weather3 != nil
Graphics.update();

end
if @run_weather_in_non_map_scenes == false and
$scene.class != Scene_Map
weather.type = 0
weather2.type = 0 if weather2 != nil;
weather3.type = 0 if weather3 != nil;
@continueWeather = false
duration = 0;
end

#soften effect of cutting out weather
weather.max = weather.max/2;
weather2.max = weather2.max/2 if weather2 != nil;
weather3.max = weather3.max/2 if weather3 != nil;

for i in 0...duration
duration = 0 if @continueWeather == false
$scene.update() if $scene.class == Scene_Map
weather.update();
weather2.update() if weather2 != nil
weather3.update() if weather3 != nil
Graphics.update();
end
weather.max = weather.max/2;
weather2.max = weather2.max/2 if weather2 != nil;
weather3.max = weather3.max/2 if weather3 != nil;

for i in 0...duration
$scene.update() if $scene.class == Scene_Map
duration = 0 if @continueWeather == false
weather.update();
weather2.update() if weather2 != nil
weather3.update() if weather3 != nil
Graphics.update();
end

#clear weather before wait
weather.type = 0;
weather2.type = 0 if weather2 != nil;
weather3.type = 0 if weather3 != nil;
weather.update();
weather2.update() if weather2 != nil
weather3.update() if weather3 != nil
Graphics.update();

sleep(wait);
end

weather.dispose();
weather2.dispose if weather2 != nil;
weather3.dispose if weather3 != nil;
sleep(1);
}

end





#==========================================

def cease_weather()
@continueWeather = false;
#having a line after changing continueWeather is crucial to
#keep the computer going for some reason.
#it freezes up if the line is removed
hello = "yes"
end


end



$ani = Animator.new