#------------------------------------------------------------------------------#
#  Galv's Character Effects
#------------------------------------------------------------------------------#
#  Автор:Galv's
#  Для: RPGMAKER VX ACE
#  Версия:1.9
#  Прервёл:Yros 98 специально для rpg-maker.info
#------------------------------------------------------------------------------#
#  2013-02-24 - Версия 1.9 - Добавлена поддержка определения слоя теней по глубине Z
#  2013-02-23 - Версия 1.8 - Добавлены несколько источников света для теней
#  2013-02-22 - Версия 1.7 - Исправляет ошибку
#  2013-02-22 - Версия 1.6 - Добавлиет значок эфекта над персонажами
#  2013-02-22 - Версия 1.5 - Исправлена ​​ошибка зеркала на больших картах
#  2013-02-22 - Версия 1.4 - Добавлены эффекты для автомобилей
#  2013-02-21 - Версия 1.3 - Фиксированно отражение прыжка и другие мелкие недочеты
#  2013-02-21 - Версия 1.2 - Ошибка с менее 4 персонажами
#  2013-02-21 - Версия 1.1 - Обновленный эффект мерцания
#  2013-02-21 - Версия 1.0 - Первая версия
#------------------------------------------------------------------------------#
#  Этот скрипт добавляет в игру реалистичные эфекты отражения и теней.В
#  настоящее время он включает в себя:
#
#  Тени
#  Тени, которые появляются под игроком и события в направлениях в зависимости
#  от источника света, который вы выберете.
#
#  Параллакс отражения
#  Размышления, которые появляются на параллакс слой для событий и действующих лиц, чтобы быть
#  использовать такие вещи, как отражение в воде и т.д. этаже или стекла Чтобы получить
#  эффекты, такие как демо, вам нужно отредактировать кодировку графического, чтобы сделать воду
#  частично прозрачными.
#
#  Параллакс зеркала
#  Многое, как отражать, но вместо актеров и события отражаются в зеркале
#  на стене назначенных региона. Оба зеркала и отражающие эффекты могут быть
#  изменились так актеры и события можно использовать несколько кодировок для их отражения
#
#------------------------------------------------------------------------------#

#------------------------------------------------------------------------------#
#  Команды скрипта:
#------------------------------------------------------------------------------#
#
#  char_effects(x,x,x,status)
#
#------------------------------------------------------------------------------#
#  # каждый эффект может быть истинным или ложным, чтобы включить / отключить их во время игры.
#  # вы можете изменить кратным эффекты сразу, X является номер эффекта
#  # 0 = отражать   1 = тень   2 = зеркало    3 = значки
#------------------------------------------------------------------------------#
#  Примеры:
#  char_effects(0,true)              # превратить размышления вкл.
#  char_effects(0,2,true)            # включить отражения и зеркала
#  char_effects(1,3,false)           # включить тени и иконки
#------------------------------------------------------------------------------#
#
#  reflect_sprite(actor_id,filename,pos)    # Изменение кодировки актеров отражаються
#
#  reflect_esprite(event_id,filename,pos)   # Изменение события отражают кодировку
#
#  reflect_vsprite(vehicle_id,filename,pos) # Изменить автомобиля отражают кодировку
#
#------------------------------------------------------------------------------#
#  Примеры:
#  reflect_sprite(1,"Actor2",2)      # изменить актер 1 в кодировке использовать спрайт
#                                    # в положении 2 "Actor2" кодировку.
#  reflect_esprite(3,"Actor4",5)     # Событие 3 будет использовать спрайт, в положении 5
#                                    # "Actor4" кодировку.
#  reflect_vsprite(1,"Vehicle",5)    # Корабль будет использовать спрайт, в положении 5
#                                    # "Транспортное средство" кодировку.
#------------------------------------------------------------------------------#

#------------------------------------------------------------------------------#
#  Сценарий вызывает эффекты, чтобы включить или выключить для выбранной СОБЫТИЯ
#------------------------------------------------------------------------------#
#
#  reflect(x,x,x,status)   # Состояние может быть истинным или ложным, чтобы включить или выключить
#                          # использовать это, чтобы указать на зеркало и задуматься.
#  shadow(x,x,x,status)    # где х, коды событий вы хотите изменить
#                          # изменить все события использования: все
#  icon(x,x,x,icon_id)     # установить, какой значок ID должна возвышаться над характером.делает
#                          # 0 для этого нет иконки.
#
#------------------------------------------------------------------------------#
#  Примеры:
#  reflect(14,17,3,1,true) # Включите события 14, 17, 3 и 1 отражений ON
#  shadow(1,false)         # Поверните событие 1 тенью OFF
#  reflect(:all,true)      # Включите все события отражений ON
#  icon(1,2,3,4,38)        # События 1,2,3 и 4 будет иметь значок появится 38
#
#  ПРИМЕЧАНИЕ: Все события по умолчанию будет никаких теней и отражений NO при входе
#  карте. Это дизайнерское решение, чтобы попытаться сохранить отставание до минимума. вы
#  должны использовать эти эффекты редко и только активировать их на события
#  которые требуют от них.
#------------------------------------------------------------------------------#

#------------------------------------------------------------------------------#
#  Сценарий вызывает эффекты, чтобы включить или выключить для актеров и транспортные средства
#------------------------------------------------------------------------------#
#
#  actor_reflect(actor_id,status)  # отражения и тени включены по умолчанию
#  actor_shadow(actor_id,status)   # для актеров и транспортных средств. Выключив их
#  actor_icon(actor_id,icon_id)    # или навсегда изменить их.
#
#  v_reflect(x,x,x,status)    # V_ использовать эти призывы к изменению транспортного средства эффекты
#  v_shadow(x,x,x,status)     # и выключается для транспортных средств.
#  v_icon(x,x,x,icon_id)
#
#------------------------------------------------------------------------------#

#------------------------------------------------------------------------------#
#  Вызов теней
#------------------------------------------------------------------------------#
#
#  shadow_source(x,y,id)       # установите х, у места для света. ID является свет
#                              # номер источника, который хотите изменить
#                              #(больше одного).Эти сбрасываются при смене карты.
#  shadow_source(event_id,id)  # использовать X события, у места для света.
#                              # Это должны быть в параллельном процессе, если вы
#                              # хотите, чтобы он движущегося света.
#
#  shadow_options(intensity,fade,flicker)    # описания ниже
#
#    # Интенсивность = непрозрачность, когда стоял рядом с источником света (255 черный)
#    # исчезать = количество теней становится более прозрачной дальше вы находитесь.
#    # мерцают = истинными или ложными. Тени будет мерцать, как будто быть брошенным огнем.
#
#------------------------------------------------------------------------------#
#  Примеры:
#  shadow_options(80,10,false)    # Это настройка по умолчанию.
#------------------------------------------------------------------------------#

#------------------------------------------------------------------------------#
#  Вызов отражения
#------------------------------------------------------------------------------#
#
#  reflect_options(wave_pwr)
#
#    # wave_pwr = насколько сильна волна движения. 0 выключено
#
#------------------------------------------------------------------------------#
#  Примеры:
#  reflect_options(1) # Включите мощность волны до 1
#------------------------------------------------------------------------------#


#------------------------------------------------------------------------------#
#  NOTETAG для актеров
#------------------------------------------------------------------------------#
#
#  <no_reflect>    # Актер не будет иметь отражения (для вампиров, конечно!)
#
#  <reflect_sprite: FileName,pos>  # Актер будет использовать эту кодировку для размышлений
#                                  # и использовать символ в позиции «POS»
#
#------------------------------------------------------------------------------#
#  Примеры:
#  <reflect_sprite: Actor2,0>    # Первый символ из набора символов Actor2
#  <reflect_sprite: Actor3,7>    # Последний символ из набора символов Actor2
#------------------------------------------------------------------------------#


($imported ||= {})["Galv_Character_Effects"] = true
module Galv_CEffects

#------------------------------------------------------------------------------#
#  ОПЦИИ УСТАНОВКИ
#------------------------------------------------------------------------------#

  MIRROR_REGION = 1     # Регион ID используется для определения зеркальными стенами.
                        # Краска
                        # региона на стене вы хотите сделать отражающей (и
                        # затем использовать плитку / отображения, которые делают параллакса видно)

  ICON_OFFSET = -60     # Y смещение для значков, которые отображаются над символами

  REFLECT_Z = -10       # Z уровень отражений
  SHADOW_Z = 0          # Z уровень тени

#------------------------------------------------------------------------------#
#  END SETUP OPTIONS
#------------------------------------------------------------------------------#
end



class Game_Interpreter

#-----------------------------------#
#  REFLECTIONS
#-----------------------------------#

  # Add/Remove Reflections from selected events
  def reflect(*args,status)
    char_ids = [*args]
    if char_ids == [:all]
      $game_map.events.values.each { |e| e.reflect = status }
    else
      char_ids.each {|c| $game_map.events[c].reflect = status }
    end
    SceneManager.scene.spriteset.refresh_effects
  end

  # Change forever actor's reflect status
  def actor_reflect(actor_id,status)
    $game_actors[actor_id].reflect = status
    $game_player.refresh
  end

  # Change forever vehicle's reflect status
  def v_reflect(*args,status)
    char_ids = [*args]
    if char_ids == [:all]
      $game_map.vehicles.each { |v| v.reflect = status }
    else
      char_ids.each { |v| $game_map.vehicles[v].reflect = status }
    end
    SceneManager.scene.spriteset.refresh_effects
  end

  def reflect_options(*args)
    $game_map.reflect_options = [*args]
    SceneManager.scene.spriteset.refresh_effects
  end

  # Actor reflect sprite change
  def reflect_sprite(actor_id,filename,pos)
    $game_actors[actor_id].reflect_sprite = [filename,pos]
    $game_player.refresh
  end

  # Event reflect sprite change
  def reflect_esprite(event_id,filename,pos)
    $game_map.events[event_id].reflect_sprite = [filename,pos]
    SceneManager.scene.spriteset.refresh_characters
  end

  # Vehicle reflect sprite change
  def reflect_vsprite(v_id,filename,pos)
    $game_map.vehicles[v_id].reflect_sprite = [filename,pos]
    SceneManager.scene.spriteset.refresh_characters
  end

#-----------------------------------#
#  SHADOWS
#-----------------------------------#

  # Add/Remove Shadows from selected characters
  def shadow(*args,status)
    char_ids = [*args]
    if char_ids == [:all]
      $game_map.events.values.each { |e| e.shadow = status }
    else
      char_ids.each {|c| $game_map.events[c].shadow = status }
    end
    SceneManager.scene.spriteset.refresh_effects
  end

  # Change player and follower shadows
  def actor_shadows(status)
    $game_player.shadow = status
    $game_player.followers.each { |f| f.shadow = status }
    SceneManager.scene.spriteset.refresh_effects
  end

  # Change vehicle's shadow status
  def v_shadow(*args,status)
    char_ids = [*args]
    if char_ids == [:all]
      $game_map.vehicles.each { |v| v.shadow = status }
    else
      char_ids.each { |v| $game_map.vehicles[v].shadow = status }
    end
    SceneManager.scene.spriteset.refresh_effects
  end

  def shadow_options(*args)
    $game_map.shadow_options = [*args]
    SceneManager.scene.spriteset.refresh_effects
  end

  def shadow_source(*args,shad_id)
    source = [*args]

    if source.count == 1
      $game_map.light_source[shad_id] = [$game_map.events[source[0]].real_x,
        $game_map.events[source[0]].real_y]
    elsif source.count > 1
      $game_map.light_source[shad_id] = source
    else
      $game_map.light_source = []
    end
  end


#-----------------------------------#
#  ICONS
#-----------------------------------#

  # Add/Remove Icons from selected events
  def icon(*args,icon_id)
    char_ids = [*args]
    if char_ids == [:all]
      $game_map.events.values.each { |e|
      if e.icon <= 0
        e.icon = nil
      else
        e.icon = icon_id
      end
    }
    else
      char_ids.each {|c| $game_map.events[c].icon = icon_id }
    end
    SceneManager.scene.spriteset.refresh_effects
  end

  # Change forever actor's icon
  def actor_icon(actor_id,icon_id)
    $game_actors[actor_id].icon = icon_id
    $game_player.refresh
  end

  # Change forever vehicle's icon
  def v_icon(*args,icon_id)
    char_ids = [*args]
    if char_ids == [:all]
      $game_map.vehicles.each { |v| v.icon = icon_id }
    else
      char_ids.each { |v| $game_map.vehicles[v].icon = icon_id }
    end
    SceneManager.scene.spriteset.refresh_effects
  end

#-----------------------------------#
#  GENERAL
#-----------------------------------#

  # Turn on/off effects
    # 0 = reflect
    # 1 = shadow
    # 2 = mirror
    # 3 = icon

  def char_effects(*args,status)
    [*args].each { |e| $game_map.char_effects[e] = status }
    SceneManager.scene.spriteset.refresh_effects
  end


end # Game_Interpreter


#-------------------------------------------------------------------------------
#  Spriteset_Map
#-------------------------------------------------------------------------------

class Spriteset_Map
  alias galv_reflect_sm_initialize initialize
  def initialize
    create_effects
    galv_reflect_sm_initialize
    refresh_characters
  end

  alias galv_reflect_sm_refresh_characters refresh_characters
  def refresh_characters
    galv_reflect_sm_refresh_characters
    create_effects
  end

  def refresh_effects
    dispose_effects
    create_effects
  end

  def create_effects
    @shadow_sprites = []
    @reflect_sprites = []
    @mirror_sprites = []
    @icon_sprites = []

    # Do reflections
    if $game_map.char_effects[0]
      $game_map.events.values.each { |e|
        @reflect_sprites.push(Sprite_Reflect.new(@viewport1, e)) if e.reflect
      }
      $game_player.followers.each { |f|
        @reflect_sprites.push(Sprite_Reflect.new(@viewport1, f)) if f.reflect
      }
      if $game_player.reflect
        @reflect_sprites.push(Sprite_Reflect.new(@viewport1, $game_player))
      end
      $game_map.vehicles.each { |v|
        @reflect_sprites.push(Sprite_Reflect.new(@viewport1, v)) if v.reflect
      }
    end

    # Do mirrors
    if $game_map.char_effects[2]
      $game_map.events.values.each { |e|
        @mirror_sprites.push(Sprite_Mirror.new(@viewport1, e)) if e.reflect
      }
      $game_player.followers.each { |f|
        @mirror_sprites.push(Sprite_Mirror.new(@viewport1, f)) if f.reflect
      }
      if $game_player.reflect
        @mirror_sprites.push(Sprite_Mirror.new(@viewport1, $game_player))
      end
      $game_map.vehicles.each { |v|
        @mirror_sprites.push(Sprite_Mirror.new(@viewport1, v)) if v.reflect
      }
    end

    # Do Shadows
    if $game_map.char_effects[1]
      return if $game_map.light_source.empty?
      $game_map.light_source.count.times { |s|
        $game_map.events.values.each { |e|
          @shadow_sprites.push(Sprite_Shadow.new(@viewport1, e, s)) if e.shadow
        }
        $game_player.followers.each { |f|
          @shadow_sprites.push(Sprite_Shadow.new(@viewport1, f, s)) if f.shadow
        }
        if $game_player.shadow
          @shadow_sprites.push(Sprite_Shadow.new(@viewport1, $game_player, s))
        end
        $game_map.vehicles.each { |v|
          @shadow_sprites.push(Sprite_Shadow.new(@viewport1, v, s)) if v.shadow
        }
      }
    end

    # Do icons
    if $game_map.char_effects[3]
      $game_map.events.values.each { |e|
        @icon_sprites.push(Sprite_Icon.new(@viewport1, e)) if e.icon
      }
      $game_player.followers.each { |f|
        @icon_sprites.push(Sprite_Icon.new(@viewport1, f)) if f.icon
      }
      if $game_player.icon
        @icon_sprites.push(Sprite_Icon.new(@viewport1, $game_player))
      end
      $game_map.vehicles.each { |v|
        @icon_sprites.push(Sprite_Icon.new(@viewport1, v)) if v.icon
      }
    end
  end

  alias galv_reflect_sm_update update
  def update
    galv_reflect_sm_update
    @reflect_sprites.each {|s| s.update} if $game_map.char_effects[0]
    @mirror_sprites.each {|s| s.update} if $game_map.char_effects[2]
    @shadow_sprites.each {|s| s.update} if $game_map.char_effects[1]
    @icon_sprites.each {|s| s.update} if $game_map.char_effects[3]
  end

  alias galv_reflect_sm_dispose_characters dispose_characters
  def dispose_characters
    galv_reflect_sm_dispose_characters
    dispose_effects
  end

  def dispose_effects
    @reflect_sprites.each {|s| s.dispose}
    @shadow_sprites.each {|s| s.dispose}
    @mirror_sprites.each {|s| s.dispose}
    @icon_sprites.each {|s| s.dispose}
  end
end # Spriteset_Map


#-------------------------------------------------------------------------------
#  Sprite_Reflect
#-------------------------------------------------------------------------------

class Sprite_Reflect < Sprite_Character
  def initialize(viewport, character = nil)
    super(viewport, character)
  end

  def update
    super
  end

  def update_balloon; end
  def setup_new_effect; end

  def set_character_bitmap
    if @character.reflect_sprite
      self.bitmap = Cache.character(@character.reflect_sprite[0])
    else
      self.bitmap = Cache.character(@character_name)
    end
    self.mirror = true
    self.angle = 180
    self.opacity = 220
    self.z = Galv_CEffects::REFLECT_Z
    self.wave_amp = $game_map.reflect_options[0]

    sign = @character_name[/^[\!\$]./]
    if sign && sign.include?('$')
      @cw = bitmap.width / 3
      @ch = bitmap.height / 4
    else
      @cw = bitmap.width / 12
      @ch = bitmap.height / 8
    end
    self.ox = @cw / 2
    self.oy = @ch
  end

  def update_position
    self.x = @character.screen_x
    jump = @character.jumping? ? @character.jump_height * 2 : 0
    alt = @character.altitude ? @character.altitude * 2 : 0
    self.y = @character.screen_y - 3 + jump + alt
  end

  def update_other
    self.blend_type = @character.blend_type
    self.visible = !@character.transparent
  end

  def update_src_rect
    if @character.reflect_sprite
      index = @character.reflect_sprite[1]
    else
      index = @character.character_index
    end
    pattern = @character.pattern < 3 ? @character.pattern : 1
    sx = (index % 4 * 3 + pattern) * @cw
    sy = (index / 4 * 4 + (@character.direction - 2) / 2) * @ch
    self.src_rect.set(sx, sy, @cw, @ch)
  end
end # Sprite_Reflect < Sprite_Character


#-------------------------------------------------------------------------------
#  Sprite_Mirror
#-------------------------------------------------------------------------------

class Sprite_Mirror < Sprite_Character
  def initialize(viewport, character = nil)
    @distance = 0
    super(viewport, character)
  end

  def update
    super
  end

  def update_balloon; end
  def setup_new_effect; end

  def set_character_bitmap
    if @character.reflect_sprite
      self.bitmap = Cache.character(@character.reflect_sprite[0])
    else
      self.bitmap = Cache.character(@character_name)
    end
    self.mirror = true
    self.opacity = 255
    self.z = Galv_CEffects::REFLECT_Z

    sign = @character_name[/^[\!\$]./]
    if sign && sign.include?('$')
      @cw = bitmap.width / 3
      @ch = bitmap.height / 4
    else
      @cw = bitmap.width / 12
      @ch = bitmap.height / 8
    end
    self.ox = @cw / 2
    self.oy = @ch
  end

  def update_src_rect
    if @character.reflect_sprite
      index = @character.reflect_sprite[1]
    else
      index = @character.character_index
    end
    pattern = @character.pattern < 3 ? @character.pattern : 1
    sx = (index % 4 * 3 + pattern) * @cw
    sy = (index / 4 * 4 + (10 - @character.direction - 2) / 2) * @ch
    self.src_rect.set(sx, sy, @cw, @ch)
  end

  def get_mirror_y
    20.times {|i|
      if $game_map.region_id(@character.x, @character.y - i) == Galv_CEffects::MIRROR_REGION
        @distance = (i - 1) * 0.05
        @display = @character.y - i - $game_map.display_y + $game_map.height
        self.opacity = 255
        return (@character.y - i + 1 - $game_map.display_y) * 32 - i * 4
      end
    }
    self.opacity = 0
    return @ch
  end

  def update_position
    self.x = @character.screen_x
    self.y = get_mirror_y - 6
    self.zoom_x = 1 - @distance
    self.zoom_y = 1 - @distance
  end

  def update_other
    self.blend_type = @character.blend_type
    self.visible = !@character.transparent
  end
end # Sprite_Mirror < Sprite_Character


#-------------------------------------------------------------------------------
#  Sprite_Shadow
#-------------------------------------------------------------------------------

class Sprite_Shadow < Sprite_Character
  def initialize(viewport, character = nil, source)
    @flicker = 0
    @famount = 0
    @aamount = 0
    @source = source
    super(viewport, character)
  end

  def update
    super
    update_bitmap
    update_src_rect
    update_position
    update_other
  end

  def set_character_bitmap
    self.bitmap = Cache.character(@character_name)
    self.mirror = true
    self.color = Color.new(0, 0, 0, 255)
    self.z = Galv_CEffects::SHADOW_Z
    self.wave_amp = 1 if $game_map.shadow_options[2]
    self.wave_speed = 1000

    sign = @character_name[/^[\!\$]./]
    if sign && sign.include?('$')
      @cw = bitmap.width / 3
      @ch = bitmap.height / 4
    else
      @cw = bitmap.width / 12
      @ch = bitmap.height / 8
    end
    self.ox = @cw / 2
    self.oy = @ch
  end

  def update_position
    self.x = @character.screen_x
    self.y = @character.screen_y - 10
    get_angle
  end

  def get_angle
    x = $game_map.light_source[@source][0] - @character.real_x
    y = $game_map.light_source[@source][1] - @character.real_y
    self.opacity = $game_map.shadow_options[0] -
      Math::sqrt(x * x + y * y) * $game_map.shadow_options[1]

    if x == 0 && y == 0 || self.opacity <= 0
      self.opacity = 0
    else
      self.angle = Math::atan2(x, y) * 180 / Math::PI + @aamount
    end
  end

  def update_other
    self.blend_type = @character.blend_type
    self.visible = !@character.transparent
  end
end # Sprite_Shadow < Sprite_Character


#-------------------------------------------------------------------------------
#  Sprite_Icon
#-------------------------------------------------------------------------------

class Sprite_Icon < Sprite_Character
  def initialize(viewport, character = nil)
    @icon_sprite ||= Sprite.new
    @icon_sprite.bitmap ||= Cache.system("Iconset")
    @icon = nil
    super(viewport, character)
  end

  def dispose
    super
    if @icon_sprite
      @icon_sprite.dispose
      @icon_sprite = nil
    end
  end

  def update
    super
    update_icon
  end

  def update_icon
    return if !@character.icon
    draw_icon(@character.icon)
  end

  def draw_icon(icon_index)
    return if !@icon.nil?
    rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
    @icon_sprite.src_rect  = rect
    @icon = icon_index
  end

  def update_position
    @icon_sprite.x = @character.screen_x - 12
    @icon_sprite.y = @character.screen_y + Galv_CEffects::ICON_OFFSET
  end

  def update_other
    self.blend_type = @character.blend_type
    @icon_sprite.visible = !@character.transparent
  end
end # Sprite_Icon < Sprite_Character


#-------------------------------------------------------------------------------
#  Other Stuff
#-------------------------------------------------------------------------------


class Game_Character < Game_CharacterBase
  attr_reader    :altitude
  attr_accessor  :reflect
  attr_accessor  :reflect_sprite
  attr_accessor  :shadow
  attr_accessor  :icon
end


class Game_Event < Game_Character
  alias galv_reflect_ge_initialize initialize
  def initialize(map_id, event)
    @reflect = false
    @shadow = false
    galv_reflect_ge_initialize(map_id, event)
  end
end # Game_Event < Game_Character


class Game_Vehicle < Game_Character
  attr_reader :map_id

  alias galv_reflect_gv_initialize initialize
  def initialize(type)
    @reflect = true
    @shadow = true
    galv_reflect_gv_initialize(type)
  end
end # Game_Vehicle < Game_Character


class Game_Follower < Game_Character
  alias galv_reflect_gf_initialize initialize
  def initialize(member_index, preceding_character)
    galv_reflect_gf_initialize(member_index, preceding_character)
    @reflect = true
    @shadow = true
  end

  alias galv_reflect_gf_refresh refresh
  def refresh
    galv_reflect_gf_refresh
    return if actor.nil?
    @reflect = actor.reflect
    @reflect_sprite = actor.reflect_sprite
    @icon = actor.icon
    if SceneManager.scene_is?(Scene_Map)
      SceneManager.scene.spriteset.refresh_effects
    end
  end
end # Game_Follower < Game_Character


class Game_Player < Game_Character
  alias galv_reflect_gp_initialize initialize
  def initialize
    galv_reflect_gp_initialize
    @reflect = true
    @shadow = true
  end

  alias galv_reflect_gp_refresh refresh
  def refresh
    galv_reflect_gp_refresh
    @reflect = actor.reflect
    @reflect_sprite = actor.reflect_sprite
    @icon = actor.icon
    if SceneManager.scene_is?(Scene_Map)
      SceneManager.scene.spriteset.refresh_effects
    end
  end
end # Game_Player < Game_Character


class Scene_Map < Scene_Base
  attr_accessor :spriteset
end # Scene_Map


class Game_Map
  attr_accessor :char_effects
  attr_accessor :light_source
  attr_accessor :shadow_options
  attr_accessor :reflect_options

  alias galv_reflect_game_map_initialize initialize
  def initialize
    @light_source = []
    @shadow_options = [80,10,false]
    @reflect_options = [0]
    @char_effects = [false,false,false,false]
    #[reflect,shadow,mirror,icon]
    galv_reflect_game_map_initialize
  end

  alias galv_reflect_game_map_setup setup
  def setup(map_id)
    galv_reflect_game_map_setup(map_id)
    reset_char_effects
  end

  def reset_char_effects
    @light_source = []
    @events.values.each { |e| e.reflect = false }
    @events.values.each { |e| e.icon = nil }
  end
end # Game_Map


class Game_Actor < Game_Battler
  attr_accessor :reflect
  attr_accessor :reflect_sprite
  attr_accessor :icon

  alias galv_reflect_game_actor_initialize initialize
  def initialize(actor_id)
    galv_reflect_game_actor_initialize(actor_id)
    @reflect = $data_actors[actor_id].reflect
    @reflect_sprite = $data_actors[actor_id].reflect_sprite
  end
end # Game_Actor < Game_Battler


class RPG::Actor
  def reflect_sprite
    if @reflect_sprite.nil?
      if @note =~ /<reflect_sprite:[ ](.*),(.*)>/i
        @reflect_sprite = [$1.to_s,$2.to_i]
      else
        @reflect_sprite = nil
      end
    end
    @reflect_sprite
  end
  def reflect
    if @reflect.nil?
      if @note =~ /<no_reflect>/i
        @reflect = false
      else
        @reflect = true
      end
    end
    @reflect
  end
end # RPG::Actor