ТЕМА: Galv's Layer Graphics/Несколько слоев графики[Ace]

#------------------------------------------------------------------------------#
#  Galv's Layer Graphics/ Несколько слоев графики
#------------------------------------------------------------------------------#
#  Платформа: RPGMAKER VX ACE
#  Версия 1.2
#  Автор: Galv.
#  Перевод: YuryOl.
#------------------------------------------------------------------------------#
#  2013-03-22 - Версия 1.2 - Добавлена возможность использования слоёв в боях
#  2013-03-17 - Версия 1.1 - Исправлена ошибка фиксированных слоев
#  2013-03-17 - Версия 1.0 - Публикация
#------------------------------------------------------------------------------#
#  Данный скрипт позволяет использовать несколько слоёв графики через события.
#  Эти слои могут использоваться для создания тумана, облаков, воды, самих карт.
#
#  Примечания:
#  - слои не переносятся с карты на карту. Вы должны создать слой для каждой карты
#  отдельно.
#  - большое количество слоев может значительно нагрузить систему

#  Есть другие доступные сценарии, которые делают нечто подобное.
#  Автор рекомендует пробовать и их, так как они, возможно, лучше. 
#  Автор создал это больше для себя, но хотел бы добавить его в свой список 
#  скриптов для ЛЮБОГО использования.
#------------------------------------------------------------------------------#

#-------------------------------------------------------------------------------
#  ВЫЗОВ СКРИПТА:
#-------------------------------------------------------------------------------
#
#  layer_status(status)    # скрипт включен, если статус "true", отключена, если "false"
#
#  del_layer(map_id,layer_id)       # удаляет выбранный слой на выбранной карте
#
#
#  Для создания слоя введите следующий скрипт

#  layer(map,layer,["Filename",xspeed,yspeed,opacity,z,blend,xoffset,yoffset])

#  , Где
#  #  map        - id карты на котором появится слой
#  #  layer      - номер, id слоя
#  #  "Filename" - имя графического файла, который должен быть расположен 
#                  в созданной вами папке Graphics/Layers/ 
#  #  xspeed     - скорость прокрутки слоя по горизонтали (отрицательное число - налево)
#  #               Нецелые числа следует писать через точку (не через запятую)
#  #  yspeed     - скорость прокрутки слоя по вертикали(отрицательное число - вниз)
#  #  opacity    - прозрачность слоя 
#  #  z value    - на каком уровне отображается слой (земля - 0. Числа можно ставить и отрицательные)
#  #  blend      - смешивание (0 - нормально, 1 - дополнение, 2 - вычитание)
#  #  xoffset    - скорость смещения слоя при движении игрока по карте по горизонтали
#  #  yoffset    - скорость смещения слоя при движении игрока по карте по вертикали. поставьте 0 для фиксации слоя на карте.
#
#  refresh_layers     # При создании НОВОГО слоя на ТЕКУЩЕЙ карте, необходимо
#                     # сразу ввести скрипт refresh_layers.
#                     # При обновление СУЩЕСТВУЮЩЕГО или установки слоя 
#                     # на ДРУГУЮ(НЕТЕКУЩУЮ) карту данный скрипт вводить 
#                     # не требуется.
#
#-------------------------------------------------------------------------------
#  ПРИЕР ВЫЗОВА СКРИПТА:
#  layer(1,6,["water2",0.3,0.1,120,-5,0,0,0])   # создание/обновление слоя 6 
#        на карте 1. Слой НИЖЕ уровня земли так как число z value отрицательное
#  layer(2,1,["map2-over",0,0,255,700,0,10,0])   создание/обновление слоя 1 
#        на карте 2. Слой значительно ВЫШЕ уровня земли так как число z value положительное

#  layer_status(false)    # выключение слоёв
#  layer_status(true)     # включение слоев
#-------------------------------------------------------------------------------

#-------------------------------------------------------------------------------
#  ВЫЗОВ СКРИПТА В БИТВАХ
#-------------------------------------------------------------------------------
#
#  del_blayer(layer_id)       #  Удаление слоя из сражений.
#
#  refresh_layers             # использовать данный скрипт при добавлении нового слоя
#
#  blayer(layer,["Filename",xspeed,yspeed,opacity,z,blend,xoffset,yoffset])
#
#  Эти скрипти вызывает добавление и удаление слоёв, которые будут появляться в бою. они
#  Они рбаотают так же, как слои карты, но без необходимости в ID карты в начале.
#  В идеале необходимо изменять слои перед боем, но они могут быть созданы и
#  во время битв.
#
#-------------------------------------------------------------------------------

#-------------------------------------------------------------------------------
#  НЕ РЕДАКТИРОВАТЬ ниже, если вы не знаете, что вы делаете.
#-------------------------------------------------------------------------------

($imported ||= {})["Galv_Layers"] = true
module Cache
  def self.layers(filename)
    load_bitmap("Graphics/Layers/", filename)
  end
end # Cache

 
class Spriteset_Map
  def create_layers
    @layer_images = []
    return if !$game_map.layer_status
    return if $game_map.layers[$game_map.map_id].nil?
    $game_map.layers[$game_map.map_id].each_with_index { |layer,i|
      if layer.nil?
        @layer_images.push(nil)
      else
        @layer_images.push(Layer_Graphic.new(@viewport1,i))
      end
    }
  end
 
  def update_layers
    @layer_images.each { |o| o.update if !o.nil? }
  end
 
  def dispose_layers
    @layer_images.each { |o| o.dispose if !o.nil? }
    @layer_images = []
  end
 
  def refresh_layers
    dispose_layers
    create_layers
  end
 
  alias galv_layers_sm_create_parallax create_parallax
  def create_parallax
    galv_layers_sm_create_parallax
    create_layers
  end
  alias galv_layers_sm_dispose_parallax dispose_parallax
  def dispose_parallax
    galv_layers_sm_dispose_parallax
    dispose_layers
  end
 
  alias galv_layers_sm_update_parallax update_parallax
  def update_parallax
    galv_layers_sm_update_parallax
    update_layers
  end
end # Spriteset_Map

 
class Spriteset_Battle
  def create_layers
    @layer_images = []
    return if !$game_map.layer_status
    return if $game_map.blayers.nil?
    $game_map.blayers.each_with_index { |layer,i|
      if layer.nil?
        @layer_images.push(nil)
      else
        @layer_images.push(Layer_Graphic.new(@viewport1,i))
      end
    }
  end
 
  def update_layers
    @layer_images.each { |o| o.update if !o.nil? }
  end
 
  def dispose_layers
    @layer_images.each { |o| o.dispose if !o.nil? }
    @layer_images = []
  end
 
  def refresh_layers
    dispose_layers
    create_layers
  end
 
  alias galv_layers_sb_create_battleback2 create_battleback2
  def create_battleback2
    galv_layers_sb_create_battleback2
    create_layers
  end
 
  alias galv_layers_sb_dispose dispose
  def dispose
    dispose_layers
    galv_layers_sb_dispose
  end
 
  alias galv_layers_sb_update update
  def update
    galv_layers_sb_update
    update_layers
  end
end # Spriteset_Battle

 
class Game_Map
  attr_accessor :blayers
  attr_accessor :layers
  attr_accessor :layer_status
 
  alias galv_layers_gm_initialize initialize
  def initialize
    galv_layers_gm_initialize
    @layer_status = true
    @layers = { 0 => [] }
    @blayers = []
  end
 
  alias galv_layers_gm_setup setup
  def setup(map_id)
    galv_layers_gm_setup(map_id)
    if SceneManager.scene_is?(Scene_Map)
      @layers[0] = []
      SceneManager.scene.spriteset.refresh_layers
    end
  end
end # Game_Map

 
class Scene_Map < Scene_Base
  attr_accessor :spriteset
end # Scene_Map < Scene_Base

class Scene_Battle < Scene_Base
  attr_accessor :spriteset
end # Scene_Map < Scene_Base

 
class Game_Interpreter
  def refresh_layers
    SceneManager.scene.spriteset.refresh_layers
  end
 
  def layer(map,id,array)
    need_refresh = false
    $game_map.layers[map] ||= []
    need_refresh = true if $game_map.layers[map][id].nil?
    $game_map.layers[map][id] = array
  end
  def del_layer(map,id)
    return if !$game_map.layers[map]
    $game_map.layers[map][id] = nil
    SceneManager.scene.spriteset.refresh_layers
  end
  def layer_status(status)
    $game_map.layer_status = status
    SceneManager.scene.spriteset.refresh_layers
  end
 
  def blayer(id,array)
    need_refresh = false
    $game_map.blayers ||= []
    need_refresh = true if $game_map.blayers[id].nil?
    $game_map.blayers[id] = array
  end
  def del_blayer(id)
    return if !$game_map.blayers
    $game_map.blayers[id] = nil
    SceneManager.scene.spriteset.refresh_layers if SceneManager.scene_is?(Scene_Battle)
  end
 
end # Game_Interpreter

 
class Layer_Graphic < Plane
  def initialize(viewport,id)
    super(viewport)
    @id = id
    if SceneManager.scene_is?(Scene_Battle)
      @layers = $game_map.blayers
    else
      @layers = $game_map.layers[$game_map.map_id]
    end
    @layers
    init_settings
  end
 
  def init_settings
    @name = @layers[@id][0]  # filename
    self.bitmap = Cache.layers(@name)
    @width = self.bitmap.width
    @height = self.bitmap.height
    if @layers[0] && @layers[0][@id]
      @movedx = @layers[0][@id][0].to_f  # stored x
      @movedy = @layers[0][@id][1].to_f  # stored y
    else
      @movedx = 0.to_f
      @movedy = 0.to_f
    end
  end
 
  def update
    change_graphic if @name != @layers[@id][0]
    update_opacity
    update_movement
  end
 
  def change_graphic
    @name = @layers[@id][0]
    self.bitmap = Cache.layers(@name)
    @width = self.bitmap.width
    @height = self.bitmap.height
  end
 
  def update_movement
    self.ox = 0 + $game_map.display_x * 32 + @movedx + xoffset
    self.oy = 0 + $game_map.display_y * 32 + @movedy + yoffset
    @movedx += @layers[@id][1]
    @movedy += @layers[@id][2]
    @movedx = 0 if @movedx >= @width
    @movedy = 0 if @movedy >= @height
    self.z = @layers[@id][4]
    self.blend_type = @layers[@id][5]
  end
 
  def xoffset
    $game_map.display_x * @layers[@id][6]
  end
  def yoffset
    $game_map.display_x * @layers[@id][7]
  end
 
  def update_opacity
    self.opacity = @layers[@id][3]
  end
 
  def dispose
    $game_map.layers[0][@id] = [@movedx,@movedy]
    self.bitmap.dispose if self.bitmap
    super
  end
end # Layer_Graphic < Plane

#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
#  ▼ Plane
#  Author: Kread-EX
#  Version 1.01
#  Release date: 08/01/2013
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
 
#------------------------------------------------------------------------------
#  ▼ UPDATES
#------------------------------------------------------------------------------
# #  11/04/2013. Added compatibility with Yanfly's Parallax Lock.
#------------------------------------------------------------------------------
#  ▼ TERMS OF USAGE
#------------------------------------------------------------------------------
# #  You are free to adapt this work to suit your needs.
# #  You can use this work for commercial purposes if you like it.
# #
# # For support:
# # grimoirecastle.wordpress.com
# # rpgmakerweb.com
#------------------------------------------------------------------------------
#  ▼ INTRODUCTION
#------------------------------------------------------------------------------
# # Rewrite the Plane class to work with Esrever's hacked DLL. Plug-and-play.
#------------------------------------------------------------------------------
 
#==============================================================================
# ■ Plane
#==============================================================================
 
class Plane
  #--------------------------------------------------------------------------
  # ● Object initialize
  #--------------------------------------------------------------------------
  def initialize(view = nil)
    @viewport = view
    @sprite = Sprite.new(@viewport)
  end
  #--------------------------------------------------------------------------
  # ● Free
  #--------------------------------------------------------------------------
  def dispose
    @sprite.dispose
  end
  #--------------------------------------------------------------------------
  # ● Get freed
  #--------------------------------------------------------------------------
  def disposed?
    @sprite.disposed?
  end
  #--------------------------------------------------------------------------
  # ● Get visible
  #--------------------------------------------------------------------------
  def visible
    @sprite.visible
  end
  #--------------------------------------------------------------------------
  # ● Set visible
  #--------------------------------------------------------------------------
  def visible=(value)
    @sprite.visible = value
  end
  #--------------------------------------------------------------------------
  # ● Get zoom x
  #--------------------------------------------------------------------------
  def zoom_x
    @sprite.zoom_x
  end
  #--------------------------------------------------------------------------
  # ● Set zoom x
  #--------------------------------------------------------------------------
  def zoom_x=(value)
    @sprite.zoom_x = value
  end
  #--------------------------------------------------------------------------
  # ● Get zoom y
  #--------------------------------------------------------------------------
  def zoom_y
    @sprite.zoom_y
  end
  #--------------------------------------------------------------------------
  # ● Set zoom y
  #--------------------------------------------------------------------------
  def zoom_y=(value)
    @sprite.zoom_y = value
  end
  #--------------------------------------------------------------------------
  # ● Get opacity
  #--------------------------------------------------------------------------
  def opacity
    @sprite.opacity
  end
  #--------------------------------------------------------------------------
  # ● Set opacity
  #--------------------------------------------------------------------------
  def opacity=(value)
    @sprite.opacity = value
  end
  #--------------------------------------------------------------------------
  # ● Get blend type
  #--------------------------------------------------------------------------
  def blend_type
    @sprite.blend_type
  end
  #--------------------------------------------------------------------------
  # ● Set blend type
  #--------------------------------------------------------------------------
  def blend_type=(value)
    @sprite.blend_type = value
  end
  #--------------------------------------------------------------------------
  # ● Get color
  #--------------------------------------------------------------------------
  def color
    @sprite.color
  end
  #--------------------------------------------------------------------------
  # ● Set color
  #--------------------------------------------------------------------------
  def color=(value)
    @sprite.color = value
  end
  #--------------------------------------------------------------------------
  # ● Get tone
  #--------------------------------------------------------------------------
  def tone
    @sprite.tone
  end
  #--------------------------------------------------------------------------
  # ● Set tone
  #--------------------------------------------------------------------------
  def tone=(value)
    @sprite.tone = value
  end
  #--------------------------------------------------------------------------
  # ● Frame update
  #--------------------------------------------------------------------------
  def update
    @sprite.update
  end
  #--------------------------------------------------------------------------
  # ● Get viewport
  #--------------------------------------------------------------------------
  def viewport
    @viewport
  end
  #--------------------------------------------------------------------------
  # ● Set viewport
  #--------------------------------------------------------------------------
  def viewport=(value)
    @viewport = value
    @sprite.viewport = viewport
  end
  #--------------------------------------------------------------------------
  # ● Get bitmap
  #--------------------------------------------------------------------------
  def bitmap
    @sprite.bitmap
  end
  #--------------------------------------------------------------------------
  # ● Set bitmap
  #--------------------------------------------------------------------------
  def bitmap=(value)
    if value.nil?
      @sprite.bitmap = value
      return
    end
    bw = @viewport ? @viewport.rect.width : Graphics.width
    bh = @viewport ? @viewport.rect.height : Graphics.height
    if SceneManager.scene.is_a?(Scene_Map) #&& $game_map.parallax_tile_lock?
      bw = $game_map.width * 32
      bh = $game_map.height * 32
    end
    rw = bw.fdiv(value.width).ceil
    rh = bh.fdiv(value.height).ceil
    new_bmp = Bitmap.new(bw, bh)
    0.upto(rw).each do |x|
      0.upto(rh).each do |y|
        new_bmp.blt(x * value.width, y * value.height, value, value.rect)
      end
    end
    @sprite.bitmap = new_bmp
  end
 
  #--------------------------------------------------------------------------
  # ● Get ox
  #--------------------------------------------------------------------------
  def ox
    @sprite.ox
  end
  #--------------------------------------------------------------------------
  # ● Set ox
  #--------------------------------------------------------------------------
  def ox=(nox)
    @sprite.ox = nox
  end
  #--------------------------------------------------------------------------
  # ● Get oy
  #--------------------------------------------------------------------------
  def oy
    @sprite.oy
  end
  #--------------------------------------------------------------------------
  # ● Set oy
  #--------------------------------------------------------------------------
  def oy=(noy)
    @sprite.oy = noy
  end
  #--------------------------------------------------------------------------
  # ● Get z
  #--------------------------------------------------------------------------
  def z
    @sprite.z
  end
  #--------------------------------------------------------------------------
  # ● Set z
  #--------------------------------------------------------------------------
  def z=(z)
    @sprite.z = z
  end
end
 
 
 
##### PLANE FIX #####
#-------------------------------------------------------------------------------
# FenixFyre's custom Plane, simply drawing a sprite. Needs to do something about
# the y-axis
#-------------------------------------------------------------------------------
class Plane
  attr_reader :ox, :oy
 
  alias :th_unlimited_resolution_initialize :initialize
  def initialize(viewport = nil)
    th_unlimited_resolution_initialize(viewport)
    @sprite = Sprite.new(viewport)
    @bitmap = nil
    @ox = 0
    @oy = 0
  end
 
	alias :th_unlimited_resolution_dispose :dispose
  def dispose
    th_unlimited_resolution_dispose
    @sprite.dispose if @sprite
    @sprite = nil
  end
 
  def method_missing(symbol, *args)
    @sprite.method(symbol).call(*args)
  end
 
  def bitmap=(bitmap)
    @bitmap = bitmap
    refresh
  end
 
  def bitmap
    @sprite.bitmap
  end
 
  def ox=(ox)
    w = @sprite.viewport != nil ? @sprite.viewport.rect.width : Graphics.width
    @ox = ox % w
    @sprite.ox = @ox
  end
 
  def oy=(oy)
    h = @sprite.viewport != nil ? @sprite.viewport.rect.height : Graphics.height
    @oy = oy % h
    @sprite.oy = @oy
  end
 
  def refresh
    return if @bitmap.nil?
    w = @sprite.viewport != nil ? @sprite.viewport.rect.width : Graphics.width
    h = @sprite.viewport != nil ? @sprite.viewport.rect.height : Graphics.height
    if @sprite.bitmap != nil
      @sprite.bitmap.dispose
    end
    @sprite.bitmap = Bitmap.new(w * 2, h * 2)
 
    max_x = w / @bitmap.width
    max_y = h / @bitmap.height
    for x in 0..max_x
      for y in 0..max_y
        @sprite.bitmap.blt(x * @bitmap.width, y * @bitmap.height,
         @bitmap, Rect.new(0, 0, @bitmap.width, @bitmap.height))
      end
    end
    for i in 1...4
      x = i % 2 * w
      y = i / 2 * h
      @sprite.bitmap.blt(x, y, @sprite.bitmap, Rect.new(0, 0, w, h))
    end
  end
end