ТЕМА: Ryexs Dynamic Sounds [XP]

#=============================================================================
#
# ** Dynamic Effects Engine
#
#-----------------------------------------------------------------------------
#
# By Ryex
# V 1.61
#
#-----------------------------------------------------------------------------
#
# Features
#
# *Provides a frame work for creating dynamic effects based on the player or an
#   events position relative to a source.
# *Under 200 lines of code (comments not included)
#
#-----------------------------------------------------------------------------
#
# Instructions 
#
# Place in a new script above main
# 
# Note:
# this is a scripting tool. as such on its own it dose NOT add any functionality 
# to a game.
# it is a framework that provides methods and structure to create dynamic 
# effects based on the player or an events position relative to a source on the 
# map.
#==============================================================================
 
module DEE
 
  DEE_VERSION = 1.61
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# START basic Configuration
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  #should be between 32 and 1
  Pixel_Offset_x = 32 
  Pixel_Offset_y = 32 
  #don't change unless the above are a number other than 32 or 1 and 
  #then it should be half of the above values
  Half_Square_x = 16 
  Half_Square_y = 16
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# END Configuration
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
 
  #this is the data loading method
  #because some of the data can't be loaded untill the data system is loaded
  #use it to load the configuration once tha game has started.
  #it is automaticly called if $dee_cfg_loaded != true
  def self.cfg_load
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# START Configuration for map sources
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
#insert map source donfiguration here
 
 
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# END Configuration
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
    $dee_cfg_loaded = true
  end
 
  $dee_cfg_loaded = false
  #=============================================================================
  # * MapSources
  #-----------------------------------------------------------------------------
  # * This is a configuration constant that contains a hash of the sources linked 
  #   to map ids. for all maps that have them. The hash should contain hashes of 
  #   Source_Type (or a subclass) class instances linked to type names for each 
  #   map. Each Source_Type (or subclass) instance should in turn contain 
  #   properly setup sources and clients arrays.
  #=============================================================================
 
  MapSources = {}
 
  #=============================================================================
  # * class Source_Piece
  #-----------------------------------------------------------------------------
  # * The Source_Piece class is a data class that holds x, y, width, and height 
  #    information for one piece of a source, this way a single source can originate
  #    from several different places at once.
  #=============================================================================
  class Source_Piece
 
    attr_accessor :x
    attr_accessor :y
    attr_accessor :width
    attr_accessor :height
    attr_accessor :power
    attr_accessor :mute
 
 
    def initialize (x, y, width, height, power)
      @x = x
      @y = y
      @width = width
      @height = height
      @power = power
      @mute = false
    end
 
  end
 
  #=============================================================================
  # * class Source
  #-----------------------------------------------------------------------------
  # * the Source class is a data class that contains data and methods related to 
  #   a source on the map,  it contains an array called ‘pieces’ that contains 
  #   Source_Piece class instances for each place the source can  originate. It
  #   also has methods like in_range? And effective power, that when called with 
  #   a Client instance as an argument returns data  about this sources relation 
  #   to the client. it is initialized with data to create a singel Source_Piece
  #   instance, each addtional instance must be added manualy.
  #=============================================================================
  class Source 
 
    attr_accessor :pieces, :mute
    attr_accessor :ev_id
 
    def initialize (x, y, width, height, power)
      @pieces = []
      @pieces.push(DEE::Source_Piece.new(x, y, width, height, power))
      @mute = false
      @ev_id = -1
    end
 
    def in_range? (client, bypass_mute = false)
      unless bypass_mute
        return false if @mute
      end
      if client.is_a?(DEE::Client)
        #for each source piece in the @pieces array
        @pieces.each { |piece|
          unless piece.mute
            #if the piece has a width less than 2
            if piece.width < 2
              #if the piece has a height less than 2
              if piece.height < 2
                #treat it as a point
                squared_distance = (client.x - piece.x) ** 2 + (client.y - piece.y) ** 2
                return true if squared_distance <= (piece.power - 1) ** 2
              else #if the height is not less that 2
                #treat it as a strip
                if (client.x >= piece.x - piece.power && client.x <= (piece.x + piece.width - 1 + piece.power))
                  if (client.y >= piece.y && client.y <= (piece.y + piece.height - 1))
                    return true
                  end
                end
                squared_distance = (client.x - piece.x) ** 2 + (client.y - piece.y) ** 2
                return true if squared_distance <= (piece.power - 1) ** 2
                squared_distance = (client.x - piece.x) ** 2 + (client.y - (piece.y + piece.height - 1)) ** 2
                return true if squared_distance <= (piece.power - 1) ** 2
              end
            else #if the width is not less than 2
              #if the piece has a height less than 2
              if piece.height < 2
                #treat it as a strip
                if (client.x >= piece.x && client.x <= (piece.x + piece.width - 1))
                  if (client.y >= piece.y - piece.power && client.y <= (piece.y + piece.height - 1 + piece.power))
                    return true
                  end
                end
                squared_distance = (client.x - piece.x) ** 2 + (client.y - piece.y) ** 2
                return true if squared_distance <= (piece.power - 1) ** 2
                squared_distance = (client.x - (piece.x + piece.width - 1)) ** 2 + (client.y - piece.y) ** 2
                return true if squared_distance <= (piece.power - 1) ** 2
              else #if the height of the piece is not less than 2
                #treat it as a squair 
                #check if the client is in range above, in, or below the piece area
                if (client.x >= piece.x && client.x <= (piece.x + piece.width - 1))
                  if (client.y >= piece.y - piece.power && client.y <= (piece.y + piece.height - 1 + piece.power))
                    return true
                  end
                end
                #check if the client is in range to either side of the source area
                if (client.x >= piece.x - piece.power && client.x <= (piece.x + piece.width - 1 + piece.power))
                  if (client.y >= piece.y && client.y <= (piece.y + piece.height - 1))
                    return true
                  end
                end
                #check if the client is in range at the corners of the source area
                squared_distance = (client.x - piece.x) ** 2 + (client.y - piece.y) ** 2
                return true if squared_distance <= (piece.power - 1) ** 2
                squared_distance = (client.x - (piece.x + piece.width - 1)) ** 2 + (client.y - piece.y) ** 2
                return true if squared_distance <= (piece.power - 1) ** 2
                squared_distance = (client.x - (piece.x + piece.width - 1)) ** 2 + (client.y - (piece.y + piece.height - 1)) ** 2
                return true if squared_distance <= (piece.power - 1) ** 2
                squared_distance = (client.x - piece.x) ** 2 + (client.y - (piece.y + piece.height - 1)) ** 2
                return true if squared_distance <= (piece.power - 1) ** 2
              end
            end
          end
        }
        return false
      else
        return false
      end
    end
 
 
    def effective_power (client, bypass_mute = false)
      unless bypass_mute
        return [0, 0] if @mute
      end
      powers = []
      if client.is_a?(DEE::Client)
        @pieces.each_index { |piece_index|
          piece_has_power = false
          unless @pieces[piece_index].mute
            #if the piece has a width less than 2
            if @pieces[piece_index].width < 2
              #if the piece has a height less than 2
              if @pieces[piece_index].height < 2
                #treat it as a point
                unless piece_has_power
                  squared_distance = (client.x - @pieces[piece_index].x) ** 2 + (client.y - @pieces[piece_index].y) ** 2
                  distence = Math.sqrt(squared_distance)
                  if squared_distance <= (@pieces[piece_index].power - 1) ** 2
                    powers.push([piece_index, @pieces[piece_index].power - distence])
                    piece_has_power = true
                  end
                end
              else #if the height is not less that 2
                #treat it as a strip vertical
                #if it is in the source area
                unless piece_has_power
                  if (client.x == @pieces[piece_index].x)
                    if (client.y >= @pieces[piece_index].y && client.y <= (@pieces[piece_index].y + @pieces[piece_index].height - 1))
                      powers.push([piece_index, @pieces[piece_index].power])
                      piece_has_power = true
                    end
                  end
                end
                #if it is to the left of the source
                unless piece_has_power
                  if (client.x >= @pieces[piece_index].x - @pieces[piece_index].power && client.x <= (@pieces[piece_index].x - 1))
                    if (client.y >= @pieces[piece_index].y && client.y <= (@pieces[piece_index].y + @pieces[piece_index].height - 1))
                      powers.push([piece_index, @pieces[piece_index].power - (@pieces[piece_index].x - client.x)])
                      piece_has_power = true
                    end
                  end
                end
                #if it is to the right of the source
                unless piece_has_power
                  if (client.x >= @pieces[piece_index].x + @pieces[piece_index].width && client.x <= (@pieces[piece_index].x + @pieces[piece_index].width + @pieces[piece_index].power - 1))
                    if (client.y >= @pieces[piece_index].y && client.y <= (@pieces[piece_index].y + @pieces[piece_index].height - 1))
                      powers.push([piece_index, @pieces[piece_index].power - (client.x - @pieces[piece_index].x)])
                      piece_has_power = true
                    end
                  end
                end
                #if is inside a circle from the top end point
                unless piece_has_power
                  squared_distance = (client.x - @pieces[piece_index].x) ** 2 + (client.y - @pieces[piece_index].y) ** 2
                  distence = Math.sqrt(squared_distance)
                  if squared_distance <= (@pieces[piece_index].power - 1) ** 2
                    powers.push([piece_index, @pieces[piece_index].power - distence])
                    piece_has_power = true
                  end
                #if it is inside a circle from the bottom end point
                  squared_distance = (client.x - @pieces[piece_index].x) ** 2 + (client.y - (@pieces[piece_index].y + @pieces[piece_index].height - 1)) ** 2
                  distence = Math.sqrt(squared_distance)
                  if squared_distance <= (@pieces[piece_index].power - 1) ** 2
                    powers.push([piece_index, @pieces[piece_index].power - distence])
                    piece_has_power = true
                  end
                end
              end
            else #if the width is not less than 2
              #if the piece has a height less than 2
              if @pieces[piece_index].height < 2
                #treat it as a strip horasantal
                #if it is inside the area
                unless piece_has_power
                  if (client.y == @pieces[piece_index].y)
                    if (client.x >= @pieces[piece_index].x && client.x <= @pieces[piece_index].x + @pieces[piece_index].width - 1)
                      powers.push([piece_index, @pieces[piece_index].power])
                      piece_has_power = true
                    end
                  end
                end
                #if it is above the strip
                unless piece_has_power
                  if (client.x >= @pieces[piece_index].x && client.x <= (@pieces[piece_index].x + @pieces[piece_index].width - 1))
                    if (client.y >= @pieces[piece_index].y - @pieces[piece_index].power && client.y <= (@pieces[piece_index].y - 1))
                      powers.push([piece_index, @pieces[piece_index].power - (@pieces[piece_index].y - client.y)])
                      piece_has_power = true
                    end
                  end
                end
                #if it is below the strip
                unless piece_has_power
                  if (client.x >= @pieces[piece_index].x && client.x <= (@pieces[piece_index].x + @pieces[piece_index].width - 1))
                    if (client.y >= @pieces[piece_index].y + @pieces[piece_index].height && client.y <= @pieces[piece_index].y + @pieces[piece_index].height + @pieces[piece_index].power - 1)
                      powers.push([piece_index, @pieces[piece_index].power - (client.y - @pieces[piece_index].y)])
                      piece_has_power = true
                    end
                  end
                end
                #if it is inside a circle from the left
                unless piece_has_power
                  squared_distance = (client.x - @pieces[piece_index].x) ** 2 + (client.y - @pieces[piece_index].y) ** 2
                  distence = Math.sqrt(squared_distance)
                  if squared_distance <= (@pieces[piece_index].power - 1) ** 2
                    powers.push([piece_index, @pieces[piece_index].power - distence])
                    piece_has_power = true
                  end
                #if it is inside a circle from the right
                  squared_distance = (client.x - (@pieces[piece_index].x + @pieces[piece_index].width - 1)) ** 2 + (client.y - @pieces[piece_index].y) ** 2
                  distence = Math.sqrt(squared_distance)
                  if squared_distance <= (@pieces[piece_index].power - 1) ** 2
                    powers.push([piece_index, @pieces[piece_index].power - distence])
                    piece_has_power = true
                  end
                end
                else #if the height of the piece is not less than 2
                #treat it as a squair 
                #check if it is in the source area
                unless piece_has_power
                  if (client.y >= @pieces[piece_index].y && client.y <= @pieces[piece_index].y + @pieces[piece_index].height - 1)
                    if (client.x >= @pieces[piece_index].x && client.x <= @pieces[piece_index].x + @pieces[piece_index].width - 1)
                      powers.push([piece_index, @pieces[piece_index].power])
                      piece_has_power = true
                    end
                  end
                end
                #check if it is in range above the source area
                unless piece_has_power
                  if (client.x >= @pieces[piece_index].x && client.x <= (@pieces[piece_index].x + @pieces[piece_index].width - 1))
                    if (client.y >= @pieces[piece_index].y - @pieces[piece_index].power && client.y <= (@pieces[piece_index].y - 1))
                      powers.push([piece_index, @pieces[piece_index].power - (@pieces[piece_index].y - client.y)])
                      piece_has_power = true
                    end
                  end
                end
                #check if it is in range below the soure area
                unless piece_has_power
                  if (client.x >= @pieces[piece_index].x && client.x <= (@pieces[piece_index].x + @pieces[piece_index].width - 1))
                    if (client.y >= @pieces[piece_index].y + @pieces[piece_index].height && client.y <= @pieces[piece_index].y + @pieces[piece_index].height + @pieces[piece_index].power - 1)
                      powers.push([piece_index, @pieces[piece_index].power - (client.y - (@pieces[piece_index].y + @pieces[piece_index].height - 1))])
                      piece_has_power = true
                    end
                  end
                end
                #check if it is in range to the left of the source area
                unless piece_has_power
                  if (client.x >= @pieces[piece_index].x - @pieces[piece_index].power && client.x <= (@pieces[piece_index].x - 1))
                    if (client.y >= @pieces[piece_index].y && client.y <= (@pieces[piece_index].y + @pieces[piece_index].height - 1))
                      powers.push([piece_index, @pieces[piece_index].power - (@pieces[piece_index].x - client.x)])
                      piece_has_power = true
                    end
                  end
                end
                #check if it is in range to the right of the source area
                unless piece_has_power
                  if (client.x >= @pieces[piece_index].x + @pieces[piece_index].width && client.x <= (@pieces[piece_index].x + @pieces[piece_index].width + @pieces[piece_index].power - 1))
                    if (client.y >= @pieces[piece_index].y && client.y <= (@pieces[piece_index].y + @pieces[piece_index].height - 1))
                      powers.push([piece_index, @pieces[piece_index].power - (client.x - (@pieces[piece_index].x + @pieces[piece_index].width - 1))])
                      piece_has_power = true
                    end
                  end
                end
                #if it is in range from the top left corner
                unless piece_has_power
                  squared_distance = (client.x - @pieces[piece_index].x) ** 2 + (client.y - @pieces[piece_index].y) ** 2
                  distence = Math.sqrt(squared_distance)
                  if squared_distance <= (@pieces[piece_index].power - 1) ** 2
                    powers.push([piece_index, @pieces[piece_index].power - distence])
                    piece_has_power = true
                  end
                #if it is in range from the top right corner
                  squared_distance = (client.x - (@pieces[piece_index].x + @pieces[piece_index].width - 1)) ** 2 + (client.y - @pieces[piece_index].y) ** 2
                  distence = Math.sqrt(squared_distance)
                  if squared_distance <= (@pieces[piece_index].power - 1) ** 2
                    powers.push([piece_index, @pieces[piece_index].power - distence])
                    piece_has_power = true
                  end
                #if it is in range from the bottom left corner
                  squared_distance = (client.x - @pieces[piece_index].x) ** 2 + (client.y - (@pieces[piece_index].y + @pieces[piece_index].height - 1)) ** 2
                  distence = Math.sqrt(squared_distance)
                  if squared_distance <= (@pieces[piece_index].power - 1) ** 2
                    powers.push([piece_index, @pieces[piece_index].power - distence])
                    piece_has_power = true
                  end
                #if it is in range from the bottom right corner
                  squared_distance = (client.x - (@pieces[piece_index].x + @pieces[piece_index].width - 1)) ** 2 + (client.y - (@pieces[piece_index].y + @pieces[piece_index].height - 1)) ** 2
                  distence = Math.sqrt(squared_distance)
                  if squared_distance <= (@pieces[piece_index].power - 1) ** 2
                    powers.push([piece_index, @pieces[piece_index].power - distence])
                    piece_has_power = true
                  end
                end
              end
            end
          end
        }
        unless powers.empty? 
          max = powers[0]
          if powers.size > 1
            (1 ... powers.size).each {|i| max = powers[i] if powers[i][1] > max[1]}
          end
          return [max[1], @pieces[max[0]].power]
        else
          return [0, 0]
        end 
      else
        return [0, 0]
      end
    end
 
  end
 
  #=============================================================================
  # * class Client
  #-----------------------------------------------------------------------------
  # * the Client class is a data class that contains information about the player 
  #   or an event including an id variable to help identify the player or the event 
  #   that it is collecting information from. It also includes methods like update 
  #   (to pull new information) and highest_effective_power to identify which 
  #   source in the @source_effective_powers array should take priority if such 
  #   is needed. it is initialized with a 'Game_Player' or a 'Game_Event' (or a
  #   subclass) instance that it is connected to as an argument.
  #=============================================================================
  class Client
    attr_accessor :x, :y, :id, :sources
    attr_reader :source_effective_powers, :sources_in_range
 
    def initialize (client)
      update_location(client)
      @sources_in_range = []
      @source_effective_powers = []
      @sources = []
    end
 
    def update_location (client)
      @x = client.x * DEE::Pixel_Offset_x + DEE::Half_Square_x
      @y = client.y * DEE::Pixel_Offset_y + DEE::Half_Square_y
      @id = client.id
    end
 
 
    def update (sources)
      if @id > 0
        update_location($game_map.events[id])
      else
        update_location($game_player)
      end
      @sources_in_range = []
      @source_effective_powers = []
      @sources = []
      @sources = sources
      @sources.each_index { |source_index|
        if @sources[source_index].in_range?(self)
          @sources_in_range.push(source_index)
          @source_effective_powers.push([@sources[source_index].effective_power(self), source_index])
        end
      }
    end
 
    def highest_effective_power
      unless @source_effective_powers.empty?
        max = @source_effective_powers[0]
        (1 ... @source_effective_powers.size).each {|i| 
          if @source_effective_powers[i][0][0] > max[0][0]
            max = @source_effective_powers[i] 
          elsif @source_effective_powers[i][0][0] == max[0][0]
            if @source_effective_powers[i][0][1] > max[0][1]
              max = @source_effective_powers[i]
            end
          end
        }
        return max
      else
        return [[0, 0], nil] 
      end
    end
 
  end
 
  #=============================================================================
  # * class Source_Type
  #-----------------------------------------------------------------------------
  # * the Source_Type class is a data class that exists as a separator so that 
  #   different types of sources can exist all on the same map and effect 
  #   different clients. It has a @sources array that contains Source (or a 
  #   subclass) instances that fall under this type. It also contains a @clients 
  #   array that contains Client (or a subclass) instances that are effected by 
  #   sources of this type. It is Initialized with a name string. it contains an 
  #   update method that when called calls the update methods of all effected 
  #   clients and passes all the effecting sources as an argument.
  #=============================================================================
  class Source_Type
    attr_accessor :clients
    attr_accessor :sources
    attr_accessor :name
    def initialize (name)
      @name= name
      @clients = []
      @sources = []
    end
 
    def update
      @clients.each { |client|
        client.update(@sources)
      }
    end
 
  end
 
  #========================================================================
  # * class System
  #--------------------------------------------------------------------------------------
  # * the System class is the main processing class of the DEE. Creating a new 
  #   instance with: 
  #   $DEE = DEE::System.new 
  #   and then calling:
  #  $DEE.update 
  #   is all it takes to make the DEE work. (provided that any sup systems that 
  #   are using it are set up correctly)
  #========================================================================
  class System
 
    attr_accessor :types
    attr_reader :map_id
 
    def initialize
      @types = {}
      @map_id = nil
    end
 
    def update
 
      if $scene.is_a?(Scene_Map)
        unless $dee_cfg_loaded
          DEE.cfg_load
        end
        if @map_id != $game_map.map_id
          @map_id = $game_map.map_id
          load_sources(@map_id)
        end
        unless @types == nil
          @types.each_value { |type|
            type.update
          }
        end
      end
    end
 
    def load_sources(map_id)
      @types = DEE::MapSources[map_id]
    end
 
  end
 
  #=============================================================================
  # * class Dynamic_Source_Piece
  #-----------------------------------------------------------------------------
  # * the Dynamic_Source_Piece class is a data class it is exsactly like the 
  #   Source_Piece class execpt that it hadles moving the source to follow an 
  #   event.
  #=============================================================================
  class Dynamic_Source_Piece < Source_Piece
  attr_accessor :id, :radius
 
    def initialize (id, radius, power)
      @id = id
      @radius = radius
      update_location
      super(@x, @y, 1, 1, power)
    end
 
    def update_location
      client = $game_map.events[@id]
      @x = client.x * DEE::Pixel_Offset_x
      @y = client.y * DEE::Pixel_Offset_y
      @id = client.id
    end
 
  end
 
  #=============================================================================
  # * class Dynamic_Source
  #-----------------------------------------------------------------------------
  # * the Dynamic_Source class is a data class it is exsactly like the 
  #   Source class execpt that it hadles moving the source to follow an event.
  #=============================================================================
  class Dynamic_Source < Source
 
    def initialize (id, radius, power)
      @pieces = []
      @pieces.push(Dynamic_Source_Piece.new(id, radius, power))
    end
 
    def update_location
      @pieces.each { |piece|
        piece.update_location
      }
    end
 
    def effective_power (client) 
      update_location
      powers = []
      if client.is_a?(DEE::Client)
        @pieces.each_index { |piece_index|
          unless @pieces[piece_index].mute
            squared_distance = (client.x - @pieces[piece_index].x) ** 2 + (client.y - @pieces[piece_index].y) ** 2
            if @pieces[piece_index].radius ** 2 >= squared_distance
              powers.push([piece_index, @pieces[piece_index].power])
            elsif squared_distance <= (@pieces[piece_index].power + @pieces[piece_index].radius - 1) ** 2
              distence = Math.sqrt(squared_distance) - @pieces[piece_index].radius
              powers.push([piece_index, @pieces[piece_index].power - distence])
            end
          end
        }
        unless powers.empty? 
          max = powers[0]
          if max.size > 1
            (1 ... powers.size).each {|i| max = powers[i] if powers[i][1] > max[1]}
          end
          return [max[1], @pieces[max[0]].power]
        else
          return [0, 0]
        end 
      else
        return [0, 0]
      end
    end
 
    def in_range? (client)
      update_location
      if client.is_a?(DEE::Client)
        @pieces.each { |piece|
          unless piece.mute
            squared_distance = (client.x - piece.x) ** 2 + (client.y - piece.y) ** 2
            if squared_distance <= (piece.power + piece.radius - 1) ** 2
              return true 
            end
          end
        }
        return false
      else
        return false
      end
    end
 
  end
 
end

#=============================================================================
#
# ** Ryex's Dynamic Sounds
#
#-----------------------------------------------------------------------------
#
# By Ryex
# V 2.04
#
#-----------------------------------------------------------------------------
#
# Features
#
# * Creates Dynamic BGS Sound effects
# * Creates Dynamic SE Sound effects
# * Can be easaly set up through events
# * Sources and pieces can be muted
# * SE effects can be set up to repeat every x number of frames
#
#-----------------------------------------------------------------------------
#
# Instructions 
#
# Place in a new script above main
# 
# the instructions for setting up this script are too complex to list here
# please visit
# http://forum.chaos-project.com/index.php/topic,4813.0.html
# to get the instructions.
#==============================================================================
if DEE::DEE_VERSION < 1.61
  raise 'ERROR: Ryex\'s Dynamic Sounds requires DEE v1.5 or higher.'
end
 
module RyexCFG
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# START basic Configuration
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  # this is the number of frames that are skiped before the BGS  gets updated
  # higher values can cause more lag
  # unless you notice chopy changes in volume you don't need to change this
  Dynamic_Sound_Update = 6 
  # if the resulting volume is less that the below number then the BGS will not
  # play hight values can prevent lag from continued calles but at the same 
  # time will increase the chopynes of the effect
  Volume_Cut_off = 1
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# END Configuration
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
end
 
#===============================================================================
# ** module D_S
# - contains script calls to mute and unmute sources and source pieces
# as well the methods to set up sources via events
#===============================================================================
module D_S
 
  VERSION = 2.04
 
  def self.play_se(file, dynamic = false)
	map_sources = DEE::MapSources[$game_map.map_id]
	map_sources['se'].sources.each {|source|
	  if source.dynamic == dynamic
	    if source.se.upcase == file.upcase
	      sound_power = source.effective_power(map_sources['se'].clients[0], true)
	      unless sound_power[0] <= 0 || sound_power[1] <= 0
	        se = source.se
	        se_volume = (sound_power[0].to_f / sound_power[1]) * source.volume_limit
	        sefile = RPG::AudioFile.new(se, se_volume)
	        $game_system.se_play(sefile)
	      end
	    end
	  end
	}
  end
 
  def self.mute_piece(type, file, name, dynamic = false)
	  map_sources = DEE::MapSources[$game_map.map_id]
	case type
	when 0
	  map_sources['bgs'].sources.each {|source|
	    if source.dynamic == dynamic
	      if source.bgs.upcase == file.upcase
	        source.pieces.each {|piece|
	          unless piece.name == nil
	            if piece.name.upcase == name.upcase
	              piece.mute = true
	            end
	          end
	        }
	      end
	    end
	  }
	when 1
	  map_sources['se'].sources.each {|source|
	    if source.dynamic == dynamic
	      if source.se.upcase == file.upcase
	        source.pieces.each {|piece|
	          unless piece.name == nil
	            if piece.name.upcase == name.upcase
	              piece.mute = true
	            end
	          end
	        }
	      end
	    end
	  }
	end
  end
 
  def self.un_mute_piece(type, file, name, dynamic = false)
	map_sources = DEE::MapSources[$game_map.map_id]
	case type
	when 0
	  map_sources['bgs'].sources.each {|source|
	    if source.dynamic == dynamic
	      if source.bgs.upcase == file.upcase
	        source.pieces.each {|piece|
	          unless piece.name == nil
	            if piece.name.upcase == name.upcase
	              piece.mute = false
	            end
	          end
	        }
	      end
	    end
	  }
	when 1
	  map_sources['se'].sources.each {|source|
	    if source.dynamic == dynamic
	      if source.se.upcase == file.upcase
	        source.pieces.each {|piece|
	          unless piece.name == nil
	            if piece.name.upcase == name.upcase
	              piece.mute = false
	            end
	          end
	        }
	      end
	    end
	  }
	end
  end
 
  def self.mute_source(type, file, dynamic = false)
	map_sources = DEE::MapSources[$game_map.map_id]
	case type
	when 0
	  map_sources['bgs'].sources.each {|source|
	    if source.dynamic == dynamic
	      if source.bgs.upcase == file.upcase
	        source.mute = true
	      end
	    end
	  }
	when 1
	  map_sources['se'].sources.each {|source|
	    if source.dynamic == dynamic
	      if source.se.upcase == file.upcase
	        source.mute = true
	      end
	    end
	  }
	end
  end
 
  def self.un_mute_source(type, file, dynamic = false)
	map_sources = DEE::MapSources[$game_map.map_id]
	case type
	when 0
	  map_sources['bgs'].sources.each {|source|
	    if source.dynamic == dynamic
	      if source.bgs.upcase == file.upcase
	        source.mute = false
	      end
	    end
	  }
	when 1
	  map_sources['se'].sources.each {|source|
	    if source.dynamic == dynamic
	      if source.se.upcase == file.upcase
	        source.mute = false
	      end
	    end
	  }
	end
  end
 
 
 
  def self.setup(map_id)
	flag = false
	map_sources = {}
	if DEE::MapSources.has_key?(map_id)
	  map_sources = DEE::MapSources[map_id]
	  unless map_sources.has_key?('bgs')
	    bgs_client_array = []
	    bgs_source_array = []
	    bgs_client_array[0] = DEE::Client.new($game_player)
	    flag = true
	  else
	    bgs_source_array = map_sources['bgs'].sources
	    bgs_client_array = map_sources['bgs'].clients
	  end
	  unless map_sources.has_key?('se')
	    se_client_array = []
	    se_source_array = []
	    se_client_array[0] = DEE::Client.new($game_player)
	    flag = true
	  else
	    se_source_array = map_sources['se'].sources
	    se_client_array = map_sources['se'].clients
	  end
	else
	  bgs_source_array = []
	  bgs_client_array = []
	  bgs_client_array[0] = DEE::Client.new($game_player)
	  se_client_array = []
	  se_source_array = []
	  se_client_array[0] = DEE::Client.new($game_player)
	  flag = true
	end
	map_sources['bgs'] = BGS_Source_Type.new
	map_sources['bgs'].clients = bgs_client_array
	map_sources['bgs'].sources = bgs_source_array
	map_sources['se'] = SE_Source_Type.new
	map_sources['se'].clients = se_client_array
	map_sources['se'].sources = se_source_array
	DEE::MapSources[map_id] = map_sources
	if flag
	  return true
	else
	  return false
	end
  end
 
  def self.dee_comment_search(item, event)
	sources = []
	item.parameters.each {|peram|
	  peram.to_s.gsub(/\\[Dd][Ee][Ee]\[(.*?)\]/) do
	    data = $1.to_s
	    sources.push(data)
	  end
	}
	unless sources.empty?
	  sources.each {|source_data|
	    source_data.gsub(/\A(.+?)\|(.+?)\Z/) do
	      type = $1.to_s
	      data = $2.to_s
	      interpret_dee_data(type, data, event)
	    end
	  }
	end
  end
 
  def self.event_search
	$game_map.events.each_value {|event|
	  if event.list.is_a?(Array)
	    event.list.each {|item|
	      if item.code == 108 || item.code == 408
	        dee_comment_search(item, event)
	      else
	        break
	      end
	    }
	  end
	}
  end
 
  def self.event_search_id(id)
      map_sources = DEE::MapSources[$game_map.map_id]
      for i in 0..map_sources['bgs'].sources.size-1
        source = map_sources['bgs'].sources[i]
        if source != nil && source.ev_id == id
          map_sources['bgs'].sources.delete(source)
        end
      end 
      for i in 0..map_sources['se'].sources.size-1
        source = map_sources['se'].sources[i]
        if source != nil && source.ev_id == id
          map_sources['se'].sources.delete(source)
        end
      end 
 
      $game_map.events.each_value {|event|
        if event.id == id
          if event.list.is_a?(Array)
            event.list.each {|item|
              if item.code == 108 || item.code == 408
                dee_comment_search(item, event)
              else
                break
              end
            }
          end
        end
      }
    end
 
  def self.interpret_dee_data(type, data, event)
	if /\A[Bb][Gg][Ss]\Z/ =~ type
	  interpret_dynamic_sounds_data_bgs(data, event)
	end
	if /\A[Ss][Ee]\Z/ =~ type
	  interpret_dynamic_sounds_data_se(data, event)
	end
	if /\A[Dd][Bb][Gg][Ss]\Z/ =~ type
	  interpret_dynamic_sounds_data_dbgs(data, event)
	end
	if /\A[Dd][Ss][Ee]\Z/ =~ type
	  interpret_dynamic_sounds_data_dse(data, event)
	end
  end
 
  def self.interpret_dynamic_sounds_data_dse(data, event)
	map_sources = {}
	@file = @power = @radius = @delay = @name = @vlimit = nil
	error = false
	@event = event
	data.gsub(/\A(.+?)\|(.+?)\|(.+?)\|(.+?)\Z/) do
	  @file = $1.to_s
	  @radius = $2.to_s.to_i
	  @power = $3.to_s.to_i
	  string = $4.to_s
	  unless /\A(.+?)\|(.+?)\Z/ =~ string
	    @delay = string.to_i
	  else
	    string.gsub(/\A(.+?)\|(.+?)\Z/) do
	      @delay = $1.to_s.to_i
	      @name = $2.to_s
	      if /\A(.+?)\|(.+?)\Z/ =~ @name
	        @name.gsub(/\A(.+?)\|(.+?)\Z/) do
	          @name = $1.to_s
	          @vlimit = $2.to_s.to_i
	        end
	      end
	    end
	  end
	end
	unless @file == nil || @power == nil || @radius == nil || @delay == nil
	  flag = false
	  map_sources = DEE::MapSources[$game_map.map_id]
	  map_sources['se'].sources.each {|source|
	    if source.se == @file && source.dynamic
	      source.delay = @delay
	      if source.delay == 0
	        source.mute = true
	      end
	      new_source_piece = Dynamic_Sound_Source_Piece.new(event.id, @radius, @power, @file, @name)
	      source.pieces.push(new_source_piece)
	      flag = true
	      break
	    end
	  }
	  unless flag
	    unless @vlimit == nil
	      new_source = Dynamic_Sound_Source.new(@event.id, @radius, @power, @file, @name, @delay, @vlimit)
	    else
	      new_source = Dynamic_Sound_Source.new(@event.id, @radius, @power, @file, @name, @delay)
	    end
	    new_source.type = 1
      new_source.ev_id = event.id
	    if new_source.delay == 0
	      new_source.mute = true
	    end
	    map_sources['se'].sources.push(new_source)
	  end
	  DEE::MapSources[$game_map.id] = map_sources
	else
	  error = true
	end
	if error
	  print "Invalid source type (Ryex's Dynamic_Sounds) " +
	    "in event #{event.id.to_s}"
	end
  end
 
  def self.interpret_dynamic_sounds_data_dbgs(data, event)
	map_sources = {}
	@source_type = @file = @power = @width = @height = @name = @vlimit = nil
	error = false
	@event = event
	data.gsub(/\A(.+?)\|(.+?)\|(.+?)\Z/) do
	  @file = $1.to_s
	  @radius = $2.to_s.to_i
	  string = $3.to_s
	  unless /\A(.+?)\|(.+?)\Z/ =~ string
	    @power = string.to_i
	  else
	    string.gsub(/\A(.+?)\|(.+?)\Z/) do
	      @power = $1.to_s.to_i
	      @name = $2.to_s
	      if /\A(.+?)\|(.+?)\Z/ =~ @name
	        @name.gsub(/\A(.+?)\|(.+?)\Z/) do
	          @name = $1.to_s
	          @vlimit = $2.to_s.to_i
	        end
	      end
	    end
	  end
	end
	unless @file == nil || @power == nil || @radius == nil
	  flag = false
	  map_sources = DEE::MapSources[$game_map.map_id]
	  map_sources['bgs'].sources.each {|source|
	    if source.bgs == @file && source.dynamic
	      new_source_piece = Dynamic_Sound_Source_Piece.new(event.id, @radius, @power, @file, @name)
	      source.pieces.push(new_source_piece)
	      flag = true
	      break
	    end
	  }
	  unless flag
	    unless @vlimit == nil
	      new_source = Dynamic_Sound_Source.new(@event.id, @radius, @power, @file, @name, 0, @vlimit)
	    else
	      new_source = Dynamic_Sound_Source.new(@event.id, @radius, @power, @file, @name)
	    end
	    new_source.type = 0
      new_source.ev_id = event.id
	    map_sources['bgs'].sources.push(new_source)
	  end
	  DEE::MapSources[$game_map.id] = map_sources
	else
	  error = true
	end
	if error
	  print "Invalid source type (Ryex's Dynamic_Sounds) " +
	    "in event #{event.id.to_s}"
	end
  end
 
 
  def self.interpret_dynamic_sounds_data_se(data, event)
	map_sources = {}
	@source_type = @file = @power = @width = @height = @delay = nil
	@x = @y = @name = @vlimit = nil
	error = false
	data.gsub(/\A(.+?)\|(.+?)\Z/) do
	  @source_type = $1.to_s
	  @source_data = $2.to_s
	end
	file = nil
	@x = event.x * DEE::Pixel_Offset_x
	@y = event.y * DEE::Pixel_Offset_y
	unless @source_type == nil
	  case @source_type
	  when /[Pp][Oo][Ii][Nn][Tt]/
	    @source_data.gsub(/\A(.+?)\|(.+?)\|(.+?)\Z/) do
	      @file = $1.to_s
	      @power = $2.to_s.to_i
	      string = $3.to_s
	      unless /\A(.+?)\|(.+?)\Z/ =~ string 
	        @delay = string.to_i
	      else
	        string.gsub(/\A(.+?)\|(.+?)\Z/) do
	          @delay = $1.to_s.to_i
	          @name = $2.to_s
	          if /\A(.+?)\|(.+?)\Z/ =~ @name
	            @name.gsub(/\A(.+?)\|(.+?)\Z/) do
	              @name = $1.to_s
	              @vlimit = $2.to_s.to_i
	            end
	          end
	        end
	      end
	      @width = 1
	      @height = 1
	    end
	    @x += 16
	    @y += 16
	  when /[Vv][Ss][Tt][Rr][Ii][Pp]/
	    @source_data.gsub(/\A(.+?)\|(.+?)\|(.+?)\|(.+?)\Z/) do
	      @file = $2.to_s
	      @power = $3.to_s.to_i
	      @height = $1.to_s.to_i
	      string = $4.to_s
	      unless /\A(.+?)\|(.+?)\Z/ =~ string 
	        @delay = string.to_i * 40
	      else
	        string.gsub(/\A(.+?)\|(.+?)\Z/) do
	          @delay = $1.to_s.to_i
	          @name = $2.to_s
	          if /\A(.+?)\|(.+?)\Z/ =~ @name
	            @name.gsub(/\A(.+?)\|(.+?)\Z/) do
	              @name = $1.to_s
	              @vlimit = $2.to_s.to_i
	            end
	          end
	        end
	      end
	      @width = 1
	    end
	    @x += 16
	  when /[Hh][Ss][Tt][Rr][Ii][Pp]/
	    @source_data.gsub(/\A(.+?)\|(.+?)\|(.+?)\|(.+?)\Z/) do
	      @file = $2.to_s
	      @power = $3.to_s.to_i
	      @height = 1
	      @width = $1.to_s.to_i
	      string = $4.to_s
	      unless /\A(.+?)\|(.+?)\Z/ =~ string 
	        @delay = string.to_i * 40
	      else
	        string.gsub(/\A(.+?)\|(.+?)\Z/) do
	          @delay = $1.to_s.to_i
	          @name = $2.to_s
	          if /\A(.+?)\|(.+?)\Z/ =~ @name
	            @name.gsub(/\A(.+?)\|(.+?)\Z/) do
	              @name = $1.to_s
	              @vlimit = $2.to_s.to_i
	            end
	          end
	        end
	      end
	    end
	    @y += 16
	  when /[Bb][Oo][Xx]/
	    @source_data.gsub(/\A(.+?)\|(.+?)\|(.+?)\|(.+?)\|(.+?)\Z/) do
	      @width = $1.to_s.to_i
	      @height = $2.to_s.to_i
	      @file = $3.to_s
	      @power = $4.to_s.to_i
	      string = $5.to_s
	      unless /\A(.+?)\|(.+?)\Z/ =~ string 
	        @delay = string.to_i * 40
	      else
	        string.gsub(/\A(.+?)\|(.+?)\Z/) do
	          @delay = $1.to_s.to_i
	          @name = $2.to_s
	          if /\A(.+?)\|(.+?)\Z/ =~ @name
	            @name.gsub(/\A(.+?)\|(.+?)\Z/) do
	              @name = $1.to_s
	              @vlimit = $2.to_s.to_i
	            end
	          end
	        end
	      end
	    end
	  else
	    error = true
	  end
	  unless @file == nil || @power == nil || @width == nil || @height == nil || @delay == nil
	    flag = false
	    map_sources = DEE::MapSources[$game_map.map_id]
	    map_sources['se'].sources.each {|source|
	      if source.se == @file
	        source.delay = @delay
	        if source.delay == 0
	          source.mute = true
	        end
	        new_source_piece = Sound_Source_Piece.new(@x, @y, @width, @height, @power, 1, @name)
	        source.pieces.push(new_source_piece)
	        flag = true
	        break
	      end
	    }
	    unless flag
	      unless @vlimit == nil
	        new_source = Sound_Source.new(@x, @y, @width, @height, @file, @power, @name, @delay, @vlimit)
	      else
	        new_source = Sound_Source.new(@x, @y, @width, @height, @file, @power, @name, @delay)
	      end
	      new_source.type = 1
        new_source.ev_id = event.id
	      if new_source.delay == 0
	        new_source.mute = true
	      end
	      map_sources['se'].sources.push(new_source)
	    end
	    DEE::MapSources[$game_map.id] = map_sources
	  else
	    error = true
	  end
	end
	if error
	  print "Invalid source type (Ryex's Dynamic_Sounds) " +
	    "in event #{event.id.to_s}"
	end
  end
 
 
  def self.interpret_dynamic_sounds_data_bgs(data, event)
	map_sources = {}
	@source_type = @file = @power = @width = @height = @name = @vlimit = nil
	error = false
	data.gsub(/\A(.+?)\|(.+?)\Z/) do
	  @source_type = $1.to_s
	  @source_data = $2.to_s
	end
	file = nil
	@x = event.x * DEE::Pixel_Offset_x
	@y = event.y * DEE::Pixel_Offset_y
	unless @source_type == nil
	  case @source_type
	  when /[Pp][Oo][Ii][Nn][Tt]/
	    @source_data.gsub(/\A(.+?)\|(.+?)\Z/) do
	      @file = $1.to_s
	      string = $2.to_s
	      unless /\A(.+?)\|(.+?)\Z/ =~ string
	        @power = string.to_i
	      else
	        string.gsub(/\A(.+?)\|(.+?)\Z/) do
	          @power = $1.to_s.to_i
	          @name = $2.to_s
	          if /\A(.+?)\|(.+?)\Z/ =~ @name
	            @name.gsub(/\A(.+?)\|(.+?)\Z/) do
	              @name = $1.to_s
	              @vlimit = $2.to_s.to_i
	            end
	          end
	        end
	      end
	      @width = 1
	      @height = 1
	    end
	    @x += 16
	    @y += 16
	  when /[Vv][Ss][Tt][Rr][Ii][Pp]/
	    @source_data.gsub(/\A(.+?)\|(.+?)\|(.+?)\Z/) do
	      @file = $2.to_s
	      @height = $1.to_s.to_i
	      string = $3.to_s
	      unless /\A(.+?)\|(.+?)\Z/ =~ string
	        @power = string.to_i
	      else
	        string.gsub(/\A(.+?)\|(.+?)\Z/) do
	          @power = $1.to_s.to_i
	          @name = $2.to_s
	          if /\A(.+?)\|(.+?)\Z/ =~ @name
	            @name.gsub(/\A(.+?)\|(.+?)\Z/) do
	              @name = $1.to_s
	              @vlimit = $2.to_s.to_i
	            end
	          end
	        end
	      end
	      @width = 1
	    end
	    @x += 16
	  when /[Hh][Ss][Tt][Rr][Ii][Pp]/
	    @source_data.gsub(/\A(.+?)\|(.+?)\|(.+?)\Z/) do
	      @file = $2.to_s
	      @height = 1
	      @width = $1.to_s.to_i
	      string = $3.to_s
	      unless /\A(.+?)\|(.+?)\Z/ =~ string
	        @power = string.to_i
	      else
	        string.gsub(/\A(.+?)\|(.+?)\Z/) do
	          @power = $1.to_s.to_i
	          @name = $2.to_s
	          if /\A(.+?)\|(.+?)\Z/ =~ @name
	            @name.gsub(/\A(.+?)\|(.+?)\Z/) do
	              @name = $1.to_s
	              @vlimit = $2.to_s.to_i
	            end
	          end
	        end
	      end
	    end
	    @y += 16
	  when /[Bb][Oo][Xx]/
	    @source_data.gsub(/\A(.+?)\|(.+?)\|(.+?)\|(.+?)\Z/) do
	      @width = $1.to_s.to_i
	      @height = $2.to_s.to_i
	      @file = $3.to_s
	      string = $4.to_s
	      unless /\A(.+?)\|(.+?)\Z/ =~ string
	        @power = string.to_i
	      else
	        string.gsub(/\A(.+?)\|(.+?)\Z/) do
	          @power = $1.to_s.to_i
	          @name = $2.to_s
	          if /\A(.+?)\|(.+?)\Z/ =~ @name
	            @name.gsub(/\A(.+?)\|(.+?)\Z/) do
	              @name = $1.to_s
	              @vlimit = $2.to_s.to_i
	            end
	          end
	        end
	      end
	    end
	  else
	    error = true
	  end
	  unless @file == nil || @power == nil || @width == nil || @height == nil
	    flag = false
	    map_sources = DEE::MapSources[$game_map.map_id]
	    map_sources['bgs'].sources.each {|source|
	      if source.bgs == @file
	        new_source_piece = Sound_Source_Piece.new(@x, @y, @width, @height, @power, @name)
	        source.pieces.push(new_source_piece)
	        flag = true
	        break
	      end
	    }
	    unless flag
	      unless @vlimit == nil
	        new_source = Sound_Source.new(@x, @y, @width, @height, @file, @power, @name, 0, @vlimit)
	      else
	        new_source = Sound_Source.new(@x, @y, @width, @height, @file, @power, @name)
	      end
	      new_source.type = 0
        new_source.ev_id = event.id
	      map_sources['bgs'].sources.push(new_source)
	    end
	    DEE::MapSources[$game_map.id] = map_sources
	  else
	    error = true
	  end
	end
	if error
	  print "Invalid source type (Ryex's Dynamic_Sounds) " +
	    "in event #{event.id.to_s}"
	end
  end
 
end
 
#===============================================================================
# ** Game_Event
#===============================================================================
 
class Game_Event
  attr_reader :id
 
   alias dee_refresh refresh
   def refresh
    dee_refresh
    setup_sounds(@page.nil?)
  end
 
  def setup_sounds(dispose)
    D_S.event_search_id(id)
  end
end
 
#===============================================================================
# ** Game_Map
#===============================================================================
 
class Game_Map
  attr_reader :map
 
  alias setup_dynamic_sound setup
  def setup(map_id)
	ds_setup_needed = D_S.setup(map_id)
	setup_dynamic_sound(map_id)
	if ds_setup_needed
	  D_S.event_search
	end
  end
 
  unless self.method_defined?(:update_dee_later)
	alias update_dee_later update
	def update
	  $DEE.update
	  update_dee_later
	end
  end
 
end
 
# create the DDE if it dosen't already exsist
$DEE = DEE::System.new if $DEE == nil
 
#===============================================================================
# ** Game_System
#===============================================================================
 
class Game_System
  attr_reader :playing_bgs
end
 
 
 
#===============================================================================
# ** BGS_Source_Type
#===============================================================================
 
class BGS_Source_Type < DEE::Source_Type
 
  attr_reader :bgs, :bgs_volume
 
  def initialize
	super('bgs')
	@bgs = ''
	@bgs_volume = 100
  end
 
  def update
	if Graphics.frame_count % RyexCFG::Dynamic_Sound_Update == 0
	  super
	  sound_power = @clients[0].highest_effective_power
	  mapbgsfile = $game_map.map.bgs
	  unless sound_power[1] == nil
	    unless sound_power[0][0] == 0
	      @bgs = @sources[sound_power[1]].bgs
	      @bgs_volume = (sound_power[0][0].to_f / sound_power[0][1]) * @sources[sound_power[1]].volume_limit
	      bgsfile = RPG::AudioFile.new(@bgs, @bgs_volume)
	      unless bgsfile == nil
	        unless $game_system.playing_bgs == nil
	          unless $game_system.playing_bgs.name == bgsfile.name &&
	            $game_system.playing_bgs.volume == bgsfile.volume
	            unless @bgs_volume < RyexCFG::Volume_Cut_off
	              $game_system.bgs_play(bgsfile)
	            else
	              $game_system.bgs_play(mapbgsfile)
	            end
	          end
	        else
	          $game_system.bgs_play(mapbgsfile)
	        end
	      end
	    else
	      $game_system.bgs_play(mapbgsfile)
	    end
	  else
	    $game_system.bgs_play(mapbgsfile)
	  end
	end
  end
 
end
 
#===============================================================================
# ** SE_Source_Type
#===============================================================================
 
class SE_Source_Type < DEE::Source_Type
 
 
  def initialize
	super('se')
  end
 
  def update
	if Graphics.frame_count % RyexCFG::Dynamic_Sound_Update == 0
	  super
	  sound_powers = @clients[0].source_effective_powers
	  sound_powers.each {|sound_power|
	    unless sound_power[1] == nil
	      unless sound_power[0][0] == 0
	        se = @sources[sound_power[1]].se
	        se_volume = (sound_power[0][0].to_f / sound_power[0][1]) * @sources[sound_power[1]].volume_limit
	        sefile = RPG::AudioFile.new(se, se_volume)
	        unless sefile == nil
	          unless @sources[sound_power[1]].delay == 0
	            if (Graphics.frame_count - @sources[sound_power[1]].last_update_frame) >= @sources[sound_power[1]].delay
	              $game_system.se_play(sefile)
	              @sources[sound_power[1]].last_update_frame = Graphics.frame_count
	            end
	          end
	        end
	      end
	    end
	  }
	end
  end
 
end
 
#===============================================================================
# ** Sound_Source
#===============================================================================
 
class Sound_Source < DEE::Source
 
  attr_accessor :bgs, :se, :type, :delay, :last_update_frame, :volume_limit
  attr_reader :dynamic
 
  def initialize(x, y, width, height, file, power, name = nil, delay = 40, volume_limit = 100)
	@dynamic = false
	@type = 0
	@delay = delay
	@volume_limit = volume_limit
	@last_update_frame = Graphics.frame_count
	@pieces = []
	@pieces.push(Sound_Source_Piece.new(x, y, width, height, power, name))
	@mute = false
	@bgs = @se = file
  end
 
end
 
#===============================================================================
# ** Sound_Source_Piece
#===============================================================================
 
class Sound_Source_Piece < DEE::Source_Piece
 
  attr_accessor :name
 
  def initialize(x, y, width, height, power, name = nil)
	@name = name
	super(x, y, width, height, power)
  end
 
end
 
#===============================================================================
# ** Dynamic_Sound_Source
#===============================================================================
 
class Dynamic_Sound_Source < DEE::Dynamic_Source
 
  attr_accessor :bgs, :se, :type, :delay, :last_update_frame, :volume_limit
  attr_reader :dynamic
 
  def initialize(id, radius, power, file, name = nil, delay = 40, volume_limit = 100)
	@dynamic = true
	@type = 0
	@delay = delay
	@volume_limit = volume_limit
	@last_update_frame = Graphics.frame_count
	super(id, radius,  power)
	@mute = false
	@bgs = @se = file
  end
 
end
 
#===============================================================================
# ** Dynamic_Sound_Source_Piece
#===============================================================================
 
class Dynamic_Sound_Source_Piece < DEE::Dynamic_Source_Piece
 
  attr_accessor :name
 
  def initialize(id, radius, power, file, name = nil)
	@name = name
	super(id, radius, power)
  end
 
end