ULDS脚本和外站地图缩放脚本冲突(解決)

翠靈月

外站连结：http://www.rgss-factory.net/2012 ... e-zoom-de-la-carte/
脚本顺序由上至下，附DLL

MGC Tilemap Ace

#====================================================================
# MGC Tilemap Ace
# v.1.4
# Auteur : MGC
#
# Il s'agit d'une réécriture de la classe Tilemap pour RMVX Ace.
#
# - Ne gère pas le flash_data
# - Ne gère pas le décalage des motifs d'autotiles du tiles du
#   tileset A2 avec l'indicateur "counter"
# - Gère le reste, et même d'autres propriétés/méthodes empruntées
#   à la classe Sprite :
#         - opacity
#         - blend_type
#         - color
#         - tone
#         - wave_amp
#         - wave_length
#         - wave_speed
#         - wave_phase
#         - zoom
#         - flash
# - Ajout d'une méthode to_zoom(new_zoom, duration) pour un zoom
#   progressif
#
# Nécessite :
# - le fichier MGC_Map_Ace_1_6.dll à la racine du projet
# - les 3 fichiers graphiques suivants, déposés dans Pictures/ :
#         - autotiles_data.png
#         - autotiles_data_small.png
#         - autotiles_data_xsmall.png
#
# Configuration :
# - NEW_TILEMAP_FOR_ALL_MAPS : alimenté à true ou false
#         - true : la nouvelle Tilemap sera utilisée pour toutes les cartes
#         - false : la nouvelle Tilemap ne sera utilisée que pour les
#                   cartes dont l'id est dans NEW_TILEMAP_MAPS_IDS
# - NEW_TILEMAP_MAPS_IDS : utilisé si NEW_TILEMAP_FOR_ALL_MAPS est à false
#         Contient la liste des id des cartes pour lesquelles la nouvelle
#         tilemap doit être utilisée
#====================================================================
module MGC
  #--------------------------------------------------------------------------
  # * CONFIGURATION
  #--------------------------------------------------------------------------
  NEW_TILEMAP_FOR_ALL_MAPS = true
  NEW_TILEMAP_MAPS_IDS = [1, 2] # seules les cartes 1 et 2 utilisent cette tilemap
  #--------------------------------------------------------------------------
  # * Initialisation [1.2]
  #--------------------------------------------------------------------------
  @new_tilemap_active = false
  #--------------------------------------------------------------------------
  # * Lancement de la nouvelle tilemap [1.2]
  #--------------------------------------------------------------------------
  def self.start_new_tilemap
    @end_new_tilemap = false
    @spriteset.start_new_tilemap
  end
  #--------------------------------------------------------------------------
  # * Fin de la nouvelle tilemap [1.2]
  #--------------------------------------------------------------------------
  def self.end_new_tilemap
    @end_new_tilemap = true
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut new_tilemap_active [1.2]
  #--------------------------------------------------------------------------
  def self.new_tilemap_active=(flag)
    $game_system.new_tilemap_active = flag
    @new_tilemap_active = flag
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut new_tilemap_active [1.2]
  #--------------------------------------------------------------------------
  def self.new_tilemap_active
    return @new_tilemap_active
  end
  #--------------------------------------------------------------------------
  # * Mise à jour de la nouvelle tilemap [1.2]
  #--------------------------------------------------------------------------
  def self.update_new_tilemap
    if @new_tilemap_active && @end_new_tilemap
      @spriteset.end_new_tilemap
      @end_new_tilemap = false
    end
  end
  #--------------------------------------------------------------------------
  # * Vérifie si un effet est en cours [1.2]
  #--------------------------------------------------------------------------
  def self.new_tilemap_effect?
    return @new_tilemap_active && @end_new_tilemap
  end
  #==============================================================================
  # ** MGC::Tilemap
  #==============================================================================
  class Tilemap
    #--------------------------------------------------------------------------
    # * Attributs
    #--------------------------------------------------------------------------
    attr_reader :viewport, :visible, :ox, :oy, :opacity, :blend_type, :color,
    :tone, :wave_amp, :wave_length, :wave_speed, :wave_phase, :zoom, :map_data,
    :flags
    attr_accessor :flash_data
    attr_writer :bitmaps # [1.2]
    #--------------------------------------------------------------------------
    # * Constantes
    #--------------------------------------------------------------------------
    RENDER = Win32API.new("MGC_Map_Ace_1_6", "renderMap", "l", "l")
    #--------------------------------------------------------------------------
    # * Initialisation
    #--------------------------------------------------------------------------
    def initialize(viewport)
      @viewport = viewport
      self.bitmaps = [0, 0, 0, 0, 0, 0, 0, 0, 0]
      @map_data = 0
      @flags = 0
      self.flash_data = nil
      @cx = Graphics.width >> 1
      @cy = Graphics.height >> 1
      @sprite_render = Sprite.new(viewport)
      @render = Bitmap.new(Graphics.width + 64, Graphics.height + 64)
      @sprite_render.bitmap = @render
      @sprite_render.x = -32
      @sprite_render.y = -32
      @sprite_render.z = 0
      @sprite_render_layer2 = Sprite.new(viewport)
      @render_layer2 = Bitmap.new(Graphics.width + 64, Graphics.height + 64)
      @sprite_render_layer2.bitmap = @render_layer2
      @sprite_render_layer2.x = -32
      @sprite_render_layer2.y = -32
      @sprite_render_layer2.z = 200
      @zoom_incr = 0.0
      @zoom_duration = 0
      @parameters = [@render, @render_layer2, map_data, bitmaps,
      Cache.picture('autotiles_data'), Cache.picture('autotiles_data_small'),
      Cache.picture('autotiles_data_xsmall'), flags, 0, 0, 0, 0, 0, 0, 1024,
      100, $game_map.loop_horizontal?, $game_map.loop_vertical?]
      self.visible = true
      self.zoom = 1.0
      self.ox = 0
      self.oy = 0
      self.opacity = 255
      self.blend_type = 0
      self.color = Color.new
      self.tone = Tone.new
      self.wave_amp = 0
      self.wave_length = 180
      self.wave_speed = 360
      self.wave_phase = 0.0
      @refresh_all = true
    end
    #--------------------------------------------------------------------------
    # * Getter pour l'attribut bitmaps # [1.2]
    #--------------------------------------------------------------------------
    def bitmaps
      force_refresh
      return @bitmaps
    end
    #--------------------------------------------------------------------------
    # * Force le rafraîchissement de la tilemap # [1.2]
    #--------------------------------------------------------------------------
    def force_refresh
      @need_refresh = true # [1.2]
      @refresh_all = true # [1.2]
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut map_data
    #--------------------------------------------------------------------------
    def map_data=(new_map_data)
      @map_data = new_map_data
      @parameters[2] = @map_data
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut flags
    #--------------------------------------------------------------------------
    def flags=(new_flags)
      @flags = new_flags
      @parameters[7] = @flags
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut zoom
    #--------------------------------------------------------------------------
    def zoom=(new_zoom)
      unless zoom == new_zoom
        if new_zoom < 0.125 || new_zoom > 8.0 then return end
        @zoom = new_zoom
        @parameters[14] = (1024.0 / new_zoom).to_i
        vox = @ox
        @ox = nil
        self.ox = vox
        voy = @oy
        @oy = nil
        self.oy = voy
        @need_refresh = true
        @refresh_all = true
      end
    end
    #--------------------------------------------------------------------------
    # * Incrémentation de la valeur du zoom
    #--------------------------------------------------------------------------
    def incr_zoom(val = 0.02)
      @zoom_incr += val
      new_zoom = 2 ** @zoom_incr
      self.zoom = new_zoom
    end
    #--------------------------------------------------------------------------
    # * Pour aller progressivement vers une nouvelle valeur de zoom
    #--------------------------------------------------------------------------
    def to_zoom(new_zoom, duration)
      unless zoom == new_zoom
        if new_zoom < 0.125 || new_zoom > 8.0 then return end
        @zoom_duration = duration
        target_zoom_incr = Math.log(new_zoom) / Math.log(2)
        @zoom_step = (target_zoom_incr - @zoom_incr) / duration
        @target_zoom = new_zoom
      end
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut visible
    #--------------------------------------------------------------------------
    def shadow_opacity=(value)
      @parameters[15] = [[value, 0].max, 255].min
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut visible
    #--------------------------------------------------------------------------
    def visible=(flag)
      @visible = flag
      @sprite_render.visible = flag
      @sprite_render_layer2.visible = flag
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut ox
    #--------------------------------------------------------------------------
    def ox=(new_ox)
      @parameters[12] = 0
      unless new_ox == @ox
        if ox && $game_map.loop_horizontal?
          if (new_ox.to_i - ox >> 5) == $game_map.width - 1 ||
            (ox - new_ox.to_i >> 5) == $game_map.width - 1
          then
            @refresh_all = true
          end
        end
        @ox = new_ox.to_i
        ox_zoom = (@ox << 10) / @parameters[14]
        ox_floor = ox_zoom >> 5 << 5
        unless ox_floor == @parameters[8]
          @parameters[12] = ox_floor - @parameters[8] >> 5
          @need_refresh = true
        end
        @parameters[8] = ox_floor
        @sprite_render.ox = ox_zoom - ox_floor
        @sprite_render_layer2.ox = @sprite_render.ox
      end
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut oy
    #--------------------------------------------------------------------------
    def oy=(new_oy)
      @parameters[13] = 0
      unless new_oy == @oy
        if oy && $game_map.loop_vertical?
          if (new_oy.to_i - oy >> 5) == $game_map.height - 1 ||
            (oy - new_oy.to_i >> 5) == $game_map.height - 1
          then
            @refresh_all = true
          end
        end
        @oy = new_oy.to_i
        oy_zoom = (@oy << 10) / @parameters[14]
        oy_floor = oy_zoom >> 5 << 5
        unless oy_floor == @parameters[9]
          @parameters[13] = oy_floor - @parameters[9] >> 5
          @need_refresh = true
        end
        @parameters[9] = oy_floor
        @sprite_render.oy = oy_zoom - oy_floor
        @sprite_render_layer2.oy = @sprite_render.oy
      end
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut opacity
    #--------------------------------------------------------------------------
    def opacity=(new_opacity)
      @opacity = new_opacity
      @sprite_render.opacity = new_opacity
      @sprite_render_layer2.opacity = new_opacity
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut blend_type
    #--------------------------------------------------------------------------
    def blend_type=(new_blend_type)
      @blend_type = new_blend_type
      @sprite_render.blend_type = new_blend_type
      @sprite_render_layer2.blend_type = new_blend_type
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut color
    #--------------------------------------------------------------------------
    def color=(new_color)
      @color = new_color
      @sprite_render.color = new_color
      @sprite_render_layer2.color = new_color
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut tone
    #--------------------------------------------------------------------------
    def tone=(new_tone)
      @tone = new_tone
      @sprite_render.tone = new_tone
      @sprite_render_layer2.tone = new_tone
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut wave_amp
    #--------------------------------------------------------------------------
    def wave_amp=(new_wave_amp)
      @wave_amp = new_wave_amp
      @sprite_render.wave_amp = new_wave_amp
      @sprite_render_layer2.wave_amp = new_wave_amp
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut wave_length
    #--------------------------------------------------------------------------
    def wave_length=(new_wave_length)
      @wave_length = new_wave_length
      @sprite_render.wave_length = new_wave_length
      @sprite_render_layer2.wave_length = new_wave_length
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut wave_speed
    #--------------------------------------------------------------------------
    def wave_speed=(new_wave_speed)
      @wave_speed = new_wave_speed
      @sprite_render.wave_speed = new_wave_speed
      @sprite_render_layer2.wave_speed = new_wave_speed
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut wave_phase
    #--------------------------------------------------------------------------
    def wave_phase=(new_wave_phase)
      @wave_phase = new_wave_phase
      @sprite_render.wave_phase = new_wave_phase
      @sprite_render_layer2.wave_phase = new_wave_phase
    end
    #--------------------------------------------------------------------------
    # * Libération de l'instance
    #--------------------------------------------------------------------------
    def dispose
      @render.dispose
      @render_layer2.dispose
      @sprite_render.dispose
      @sprite_render_layer2.dispose
    end
    #--------------------------------------------------------------------------
    # * Retourne true si l'instance a été libérée
    #--------------------------------------------------------------------------
    def disposed?
      return @render.disposed?
    end
    #--------------------------------------------------------------------------
    # * Mise à jour, appelée normalement à chaque frame
    #--------------------------------------------------------------------------
    def update
      if @visible
        if @zoom_duration > 0
          @zoom_duration -= 1
          if @zoom_duration == 0
            self.zoom = @target_zoom
          else
            incr_zoom(@zoom_step)
          end
        end
        if Graphics.frame_count & 31 == 0
          @parameters[10] += 1
          @parameters[10] %= 3
          unless @need_refresh
            @need_refresh_anim = true
          end
        end
        if @need_refresh
          if @refresh_all
            @render.clear
            @render_layer2.clear
            @parameters[12] = 0
            @parameters[13] = 0
            @refresh_all = false
          end
          @parameters[11] = 0
          RENDER.call(@parameters.__id__)
          @need_refresh = false
        elsif @need_refresh_anim
          @parameters[11] = 1
          @parameters[12] = 0
          @parameters[13] = 0
          RENDER.call(@parameters.__id__)
          @need_refresh_anim = false
        end
        @sprite_render.update
        @sprite_render_layer2.update
      end
    end
    #--------------------------------------------------------------------------
    # * Flash des couches de la tilemap
    #--------------------------------------------------------------------------
    def flash(color, duration)
      @sprite_render.flash(color, duration)
      @sprite_render_layer2.flash(color, duration)
    end
  end
end

#==============================================================================
# ** Spriteset_Map
#==============================================================================
class Spriteset_Map
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_tilemap
    alias create_tilemap_mgc_tilemap create_tilemap
    alias update_mgc_tilemap update # [1.2]
    @already_aliased_mgc_tilemap = true
  end
  #--------------------------------------------------------------------------
  # * Create Tilemap [1.2]-MOD
  #--------------------------------------------------------------------------
  def create_tilemap
    create_tilemap_mgc_tilemap
    unless $game_system.new_tilemap_active
      MGC.new_tilemap_active = false
    end
    if $game_map.use_new_tilemap? || $game_system.new_tilemap_active
      start_new_tilemap
    end
  end
  #--------------------------------------------------------------------------
  # * Active la nouvelle tilemap [1.2]
  #--------------------------------------------------------------------------
  def start_new_tilemap
    unless @tilemap_new
      @tilemap_classic = @tilemap
      @tilemap_new = MGC::Tilemap.new(@viewport1)
      @tilemap_new.map_data = $game_map.data
      @tilemap_new.force_refresh
      @tilemap = @tilemap_new
      load_tileset
    end
    @tilemap_new.visible = true
    @tilemap_classic.visible = false
    @tilemap = @tilemap_new
    MGC.new_tilemap_active = true
    $game_player.center($game_player.x, $game_player.y)
  end
  #--------------------------------------------------------------------------
  # * Désactive la nouvelle tilemap [1.2]
  #--------------------------------------------------------------------------
  def end_new_tilemap
    if @tilemap_new
      @tilemap_new.visible = false
      @tilemap_classic.visible = true
      @tilemap = @tilemap_classic
      load_tileset
    end
    MGC.new_tilemap_active = false
  end
  #--------------------------------------------------------------------------
  # * Update [1.2]
  #--------------------------------------------------------------------------
  def update
    MGC.update_new_tilemap
    if $game_map.start_new_tilemap
      start_new_tilemap
      $game_map.start_new_tilemap = false
    elsif $game_map.end_new_tilemap
      end_new_tilemap
      $game_map.end_new_tilemap = false
    end
    update_mgc_tilemap
  end
end

#==============================================================================
# ** Game_System [1.2]
#==============================================================================
class Game_System
  #--------------------------------------------------------------------------
  # * Attributs
  #--------------------------------------------------------------------------
  attr_accessor :new_tilemap_active
end

#==============================================================================
# ** Game_Map [1.2]
#==============================================================================
class Game_Map
  attr_accessor :start_new_tilemap, :end_new_tilemap
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_tilemap
    alias setup_mgc_tilemap setup
    @already_aliased_mgc_tilemap = true
  end
  #--------------------------------------------------------------------------
  # * Setup
  #--------------------------------------------------------------------------
  def setup(map_id)
    setup_mgc_tilemap(map_id)
    if use_new_tilemap?
      self.start_new_tilemap = true
    else
      self.end_new_tilemap = true
    end
  end
  #--------------------------------------------------------------------------
  # * Check if the map is configured for the new tilemap
  #--------------------------------------------------------------------------
  def use_new_tilemap?
    return MGC::NEW_TILEMAP_FOR_ALL_MAPS ||
    MGC::NEW_TILEMAP_MAPS_IDS.include?($game_map.map_id)
  end
end

#==============================================================================
# ** Scene_Map [1.2]
#==============================================================================
class Scene_Map < Scene_Base
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_tilemap
    alias update_call_menu_mgc_tilemap update_call_menu
    @already_aliased_mgc_tilemap = true
  end
  #--------------------------------------------------------------------------
  # * Determine if Menu is Called due to Cancel Button
  #--------------------------------------------------------------------------
  def update_call_menu
    unless MGC.new_tilemap_effect?
      update_call_menu_mgc_tilemap
    end
  end
end

Map Zoom Ace

#====================================================================
# Map Zoom Ace
# v.1.6
# Auteur : MGC
#
# Ce script pour RMVX Ace permet de jouer avec une carte zoomée.
# Le coefficient de zoom peut aller de 1/8 à 8
#
# Nécessite :
# - le script "MGC Tilemap Ace" du même auteur en V.1.4 minimum, placé
#   directement au-dessus de ce script
#
# Utilisation :
# - pour une carte utilisant la tilemap du script "MGC Tilemap Ace" (cf.
#   ce script pour savoir comment obtenir une telle carte), deux
#   commandes en script sont utilisables :
#         - MGC.map_zoom=(nouvelle valeur de zoom)
#         - MGC.to_map_zoom(nouvelle valeur de zoom, durée de la transition)
#
# Configuration :
# - PARALLAX_ZOOM : alimenté à true ou false
#         - true : le panorama subi le même zoom que la carte. Désactivé
#                 par défaut car il semble que cela introduit du lag, et
#                 je n'ai pas envie de réécrire la gestion du zoom de la
#                 classe Plane pour remplacer ce que nous a écrit Enterbrain
#         - false : le panorama est insensible au zoom de la carte
# - DEFAULT_ZOOM : valeur de zoom par défaut qui s'applique à chaque entrée
#         dans une carte supportant le zoom. Compris entre 0.125 et 8.0.
#
# Vous pouvez ajouter une commande dans le nom des cartes pour forcer le
# la valeur du zoom à l'entrée dans cette carte. Cela est prioritaire par
# rapport à DEFAULT_ZOOM.
# - [Zx], où x est un décimal entre 0.125 et 8.0 : zoom de la carte
# Exemple : My Worldmap[Z0.5]
#====================================================================
module MGC
  #--------------------------------------------------------------------------
  # * CONFIGURATION
  #--------------------------------------------------------------------------
  PARALLAX_ZOOM = true
  DEFAULT_ZOOM = 1.0 # [1.4]
  #--------------------------------------------------------------------------
  # * Initialisation
  #--------------------------------------------------------------------------
  @zoom = 1.0
  #--------------------------------------------------------------------------
  # * Aliased methods [1.4]
  #--------------------------------------------------------------------------
  class << self
    unless @already_aliased_mgc_zoom
      alias end_new_tilemap_mgc_zoom end_new_tilemap
      alias update_new_tilemap_mgc_zoom update_new_tilemap
      alias new_tilemap_effect_mgc_zoom? new_tilemap_effect?
      @already_aliased_mgc_zoom = true
    end
  end
  #--------------------------------------------------------------------------
  # * Fin de la nouvelle tilemap [1.4]
  #--------------------------------------------------------------------------
  def self.end_new_tilemap
    self.end_new_tilemap_mgc_zoom
    self.to_map_zoom(1.0, 1)
  end
  #--------------------------------------------------------------------------
  # * Initialisation de la valeur de zoom [1.4]-MOD
  #--------------------------------------------------------------------------
  def self.initialize_map_zoom
    @zoom = $game_system.map_zoom ? $game_system.map_zoom :
    $game_map.get_default_zoom
    @map_zoom_incr = Math.log(@zoom) / Math.log(2)
    @map_zoom_duration = 0
  end
  #--------------------------------------------------------------------------
  # * Change Map [1.4]
  #--------------------------------------------------------------------------
  def self.start_change_map_new_zoom
    @zoom = $game_map.get_default_zoom
    @map_zoom_incr = Math.log(@zoom) / Math.log(2)
    @map_zoom_duration = 0
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut zoom
  #--------------------------------------------------------------------------
  def self.map_zoom
    return @zoom
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut zoom
  #--------------------------------------------------------------------------
  def self.map_zoom=(zoom_value)
    unless map_zoom == zoom_value
      if zoom_value < 0.125 || zoom_value > 8.0 then return end
      @zoom = zoom_value
      $game_system.map_zoom = @zoom
      $game_player.center($game_player.x, $game_player.y)
    end
  end
  #--------------------------------------------------------------------------
  # * Incrémentation de la valeur du zoom
  #--------------------------------------------------------------------------
  def self.incr_map_zoom(val = 0.02)
    @map_zoom_incr += val
    new_zoom = 2 ** @map_zoom_incr
    self.map_zoom = new_zoom
  end
  #--------------------------------------------------------------------------
  # * Pour aller progressivement vers une nouvelle valeur de zoom
  #--------------------------------------------------------------------------
  def self.to_map_zoom(new_zoom, duration)
    unless map_zoom == new_zoom
      if new_zoom < 0.125 || new_zoom > 8.0 then return end
      @map_zoom_duration = duration
      target_zoom_incr = Math.log(new_zoom) / Math.log(2)
      @map_zoom_step = (target_zoom_incr - @map_zoom_incr) / duration
      @target_map_zoom = new_zoom
    end
  end
  #--------------------------------------------------------------------------
  # * Mise à jour de la nouvelle tilemap [1.4]
  #--------------------------------------------------------------------------
  def self.update_new_tilemap
    if @new_tilemap_active && @map_zoom_duration > 0
      @map_zoom_duration -= 1
      if @map_zoom_duration == 0
        self.map_zoom = @target_map_zoom
      else
        self.incr_map_zoom(@map_zoom_step)
      end
    end
    update_new_tilemap_mgc_zoom
  end
  #--------------------------------------------------------------------------
  # * Vérifie si un effet est en cours
  #--------------------------------------------------------------------------
  def self.new_tilemap_effect?
    return new_tilemap_effect_mgc_zoom? ||
    @new_tilemap_active && @map_zoom_duration > 0
  end
end

#==============================================================================
# ** Game_System [1.4]
#==============================================================================
class Game_System
  #--------------------------------------------------------------------------
  # * Attributs
  #--------------------------------------------------------------------------
  attr_accessor :map_zoom
end

#==============================================================================
# ** Viewport
#==============================================================================
class Viewport
  #--------------------------------------------------------------------------
  # * Attributs
  #--------------------------------------------------------------------------
  attr_reader :zoom
  attr_accessor :contains_zoomable_map
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_zoom
    alias initialize_mgc_zoom initialize
    @already_aliased_mgc_zoom = true
  end
  #--------------------------------------------------------------------------
  # * Initialisation
  #--------------------------------------------------------------------------
  def initialize(*args)
    initialize_mgc_zoom(*args)
    self.zoom = 1.0
    @contains_zoomable_map = false
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut zoom
  #--------------------------------------------------------------------------
  def zoom=(new_zoom)
    unless zoom == new_zoom
      if new_zoom < 0.125 || new_zoom > 8.0 then return end
      @zoom = new_zoom
    end
  end
  #--------------------------------------------------------------------------
  # * Mise à jour du zoom
  #--------------------------------------------------------------------------
  def update_zoom
    if contains_zoomable_map
      self.zoom = MGC.map_zoom
    end
  end
end

#==============================================================================
# ** MGC::Tilemap
#==============================================================================
module MGC
  class Tilemap
    #--------------------------------------------------------------------------
    # * Aliased methods
    #--------------------------------------------------------------------------
    unless @already_aliased_mgc_zoom
      alias initialize_mgc_zoom initialize
      alias update_mgc_zoom update
      @already_aliased_mgc_zoom = true
    end
    #--------------------------------------------------------------------------
    # * Initialisation
    #--------------------------------------------------------------------------
    def initialize(viewport)
      initialize_mgc_zoom(viewport)
      @sprite_render.no_viewport_zoom = true
      @sprite_render_layer2.no_viewport_zoom = true
      viewport.contains_zoomable_map = true
    end
    #--------------------------------------------------------------------------
    # * Mise à jour, appelée normalement à chaque frame
    #--------------------------------------------------------------------------
    def update
      if @visible
        self.zoom = viewport.zoom
      end
      update_mgc_zoom
    end
  end
end

#==============================================================================
# ** Plane
#==============================================================================
class Plane
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_zoom
    alias initialize_mgc_zoom initialize
    alias ox_mgc_zoom= ox=
    alias oy_mgc_zoom= oy=
    @already_aliased_mgc_zoom = true
  end
  #--------------------------------------------------------------------------
  # * Initialisation
  #--------------------------------------------------------------------------
  def initialize(*args)
    initialize_mgc_zoom(*args)
    @phase_viewport_zoom = false
    self.ox = 0
    self.oy = 0
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut ox
  #--------------------------------------------------------------------------
  def ox=(new_ox)
    unless @phase_viewport_zoom
      @base_ox = new_ox
    end
    self.ox_mgc_zoom = new_ox
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut ox
  #--------------------------------------------------------------------------
  def ox
    return @base_ox
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut oy
  #--------------------------------------------------------------------------
  def oy=(new_oy)
    unless @phase_viewport_zoom
      @base_oy = new_oy
    end
    self.oy_mgc_zoom = new_oy
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut oy
  #--------------------------------------------------------------------------
  def oy
    return @base_oy
  end
  #--------------------------------------------------------------------------
  # * Mise à jour du zoom en fonction du zoom du viewport
  #--------------------------------------------------------------------------
  def update_viewport_zoom
    if MGC::PARALLAX_ZOOM
      unless viewport.nil? || !viewport.contains_zoomable_map
        @phase_viewport_zoom = true
        self.zoom_x = viewport.zoom
        self.zoom_y = viewport.zoom
        self.ox = - ((Graphics.width >> 1) +
        (ox - (Graphics.width >> 1)) * viewport.zoom).to_i
        self.oy = - ((Graphics.height >> 1) +
        (oy - (Graphics.height >> 1)) * viewport.zoom).to_i
        @phase_viewport_zoom = false
      end
    end
  end
end

#==============================================================================
# ** Spriteset_Map
#==============================================================================
class Spriteset_Map
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_zoom
    alias start_new_tilemap_mgc_zoom start_new_tilemap
    alias update_parallax_mgc_zoom update_parallax
    @already_aliased_mgc_zoom = true
  end
  #--------------------------------------------------------------------------
  # * Active la nouvelle tilemap [1.4]
  #--------------------------------------------------------------------------
  def start_new_tilemap
    unless @tilemap_new
      MGC.initialize_map_zoom
    end
    start_new_tilemap_mgc_zoom
  end
  #--------------------------------------------------------------------------
  # * Update [1.4]-MOD
  #--------------------------------------------------------------------------
  def update
    MGC.update_new_tilemap
    if $game_map.start_new_tilemap
      start_new_tilemap
      $game_map.start_new_tilemap = false
    elsif $game_map.end_new_tilemap
      end_new_tilemap
      $game_map.end_new_tilemap = false
    end
    update_viewports_zoom
    update_mgc_tilemap
  end
  #--------------------------------------------------------------------------
  # * Update Parallax
  #--------------------------------------------------------------------------
  def update_parallax
    update_parallax_mgc_zoom
    @parallax.update_viewport_zoom
  end
  #--------------------------------------------------------------------------
  # * Update Viewports Zoom
  #--------------------------------------------------------------------------
  def update_viewports_zoom
    @viewport1.update_zoom
  end
end

#==============================================================================
# ** Sprite
#==============================================================================
class Sprite
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_zoom
    alias initialize_mgc_zoom initialize
    alias x_mgc_zoom= x=
    alias y_mgc_zoom= y=
    alias zoom_x_mgc_zoom= zoom_x=
    alias zoom_y_mgc_zoom= zoom_y=
    @already_aliased_mgc_zoom = true
  end
  #--------------------------------------------------------------------------
  # * Attributs
  #--------------------------------------------------------------------------
  attr_accessor :no_viewport_zoom
  #--------------------------------------------------------------------------
  # * Initialisation
  #--------------------------------------------------------------------------
  def initialize(*args)
    initialize_mgc_zoom(*args)
    @phase_viewport_zoom = false
    self.x = 0
    self.y = 0
    self.zoom_x = 1.0
    self.zoom_y = 1.0
    self.no_viewport_zoom = false
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut x
  #--------------------------------------------------------------------------
  def x=(new_x)
    unless @phase_viewport_zoom
      @base_x = new_x
    end
    self.x_mgc_zoom = new_x
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut y
  #--------------------------------------------------------------------------
  def y=(new_y)
    unless @phase_viewport_zoom
      @base_y = new_y
    end
    self.y_mgc_zoom = new_y
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut x
  #--------------------------------------------------------------------------
  def x
    return @base_x
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut y
  #--------------------------------------------------------------------------
  def y
    return @base_y
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut zoom_x
  #--------------------------------------------------------------------------
  def zoom_x=(new_zoom_x)
    unless @phase_viewport_zoom
      @base_zoom_x = new_zoom_x
    end
    self.zoom_x_mgc_zoom = new_zoom_x
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut zoom_y
  #--------------------------------------------------------------------------
  def zoom_y=(new_zoom_y)
    unless @phase_viewport_zoom
      @base_zoom_y = new_zoom_y
    end
    self.zoom_y_mgc_zoom = new_zoom_y
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut zoom_x
  #--------------------------------------------------------------------------
  def zoom_x
    return @base_zoom_x
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut zoom_y
  #--------------------------------------------------------------------------
  def zoom_y
    return @base_zoom_y
  end
  #--------------------------------------------------------------------------
  # * Valeur réelle du zoom_x en prenant en compte le zoom de la carte
  #--------------------------------------------------------------------------
  def zoom_x_global
    return @zoom_x
  end
  #--------------------------------------------------------------------------
  # * Valeur réelle du zoom_y en prenant en compte le zoom de la carte
  #--------------------------------------------------------------------------
  def zoom_y_global
    return @zoom_y
  end
end

#==============================================================================
# ** Sprite and all its subclasses [1.4]-MOD
#==============================================================================
[:Sprite, :Sprite_Base, :Sprite_Character, :Sprite_Battler, :Sprite_Picture,
:Sprite_Timer].each {|classname|
  parent = eval("#{classname}.superclass")
  eval(
  "class #{classname} < #{parent}
    unless @already_aliased_mgc_zoom_#{classname}
      alias update_mgc_zoom_#{classname} update
      @already_aliased_mgc_zoom_#{classname} = true
    end
    def update
      update_mgc_zoom_#{classname}
      if self.instance_of?(#{classname})
        if MGC.new_tilemap_active && viewport && !no_viewport_zoom &&
          viewport.contains_zoomable_map
          @phase_viewport_zoom = true
          self.zoom_x = @base_zoom_x * viewport.zoom
          self.zoom_y = @base_zoom_y * viewport.zoom
          self.x = ((Graphics.width >> 1) +
          (x - (Graphics.width >> 1)) * viewport.zoom).to_i
          self.y = ((Graphics.height >> 1) +
          (y - (Graphics.height >> 1)) * viewport.zoom).to_i
          @phase_viewport_zoom = false
          @in_new_tilemap_zoom = true
        elsif @in_new_tilemap_zoom
          self.zoom_x = @base_zoom_x
          self.zoom_y = @base_zoom_y
          @in_new_tilemap_zoom = false
        end
      end
    end
  end")
}

#==============================================================================
# ** Sprite_Character
#==============================================================================
class Sprite_Character < Sprite_Base
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_zoom
    alias update_balloon_mgc_zoom update_balloon
    @already_aliased_mgc_zoom = true
  end
  #--------------------------------------------------------------------------
  # * Update Balloon Icon
  #--------------------------------------------------------------------------
  def update_balloon
    update_balloon_mgc_zoom
    if @balloon_sprite then @balloon_sprite.update end
  end
end

#==============================================================================
# ** Sprite_Base
#==============================================================================
class Sprite_Base < Sprite
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_zoom
    alias animation_set_sprites_mgc_zoom animation_set_sprites
    @already_aliased_mgc_zoom = true
  end
  #--------------------------------------------------------------------------
  # * Set Animation Sprite
  #     frame : Frame data (RPG::Animation::Frame)
  #--------------------------------------------------------------------------
  def animation_set_sprites(frame)
    animation_set_sprites_mgc_zoom(frame)
    @ani_sprites.each {|sprite| sprite.update}
  end
end

#==============================================================================
# ** Game_Map
#==============================================================================
class Game_Map
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_zoom
    alias set_display_pos_mgc_zoom set_display_pos
    alias scroll_down_mgc_zoom scroll_down
    alias scroll_left_mgc_zoom scroll_left
    alias scroll_right_mgc_zoom scroll_right
    alias scroll_up_mgc_zoom scroll_up
    @already_aliased_mgc_zoom = true
  end
  #--------------------------------------------------------------------------
  # * Setup [1.4]
  #--------------------------------------------------------------------------
  def setup(map_id)
    setup_mgc_tilemap(map_id)
    if use_new_tilemap?
      if MGC.new_tilemap_active
        MGC.start_change_map_new_zoom
      end
      self.start_new_tilemap = true
    else
      self.end_new_tilemap = true
    end
  end
  #--------------------------------------------------------------------------
  # * Get default zoom [1.4]
  #--------------------------------------------------------------------------
  def get_default_zoom
    if $data_mapinfos[@map_id].full_name[/\[Z(\d+(?:\.\d+)*)\]/]
      return [[$1.to_f, 0.125].max, 8.0].min
    else
      return MGC::DEFAULT_ZOOM
    end
  end
  #--------------------------------------------------------------------------
  # * Set Display Position
  #--------------------------------------------------------------------------
  def set_display_pos(x, y)
    if MGC.new_tilemap_active && $game_map.use_new_tilemap? # [1.4]
      if loop_horizontal?
        @display_x = (x + width) % width
      else
        if width * MGC.map_zoom < screen_tile_x
          @display_x = (width - screen_tile_x).abs / 2
        else
          x_min = screen_tile_x * (1.0 / MGC.map_zoom - 1.0) / 2
          x_max = width + screen_tile_x * ((1.0 - 1.0 / MGC.map_zoom) / 2 - 1)
          x = [x_min, [x, x_max].min].max
          @display_x = x
        end
      end
      if loop_vertical?
        @display_y = (y + height) % height
      else
        if height * MGC.map_zoom < screen_tile_y
          @display_y = (height - screen_tile_y).abs / 2
        else
          y_min = screen_tile_y * (1.0 / MGC.map_zoom - 1.0) / 2
          y_max = height + screen_tile_y * ((1.0 - 1.0 / MGC.map_zoom) / 2 - 1)
          y = [y_min, [y, y_max].min].max
          @display_y = y
        end
      end
      @parallax_x = x
      @parallax_y = y
    else
      set_display_pos_mgc_zoom(x, y)
    end
  end
  #--------------------------------------------------------------------------
  # * Scroll Down
  #--------------------------------------------------------------------------
  def scroll_down(distance)
    if MGC.new_tilemap_active # [1.4]
      if loop_vertical?
        @display_y += distance
        @display_y %= @map.height
        @parallax_y += distance if @parallax_loop_y
      else
        last_y = @display_y
        if height * MGC.map_zoom < screen_tile_y
          @display_y = (height - screen_tile_y).abs / 2
        else
          max = height + screen_tile_y * ((1.0 - 1.0 / MGC.map_zoom) / 2 - 1)
          @display_y = [@display_y + distance, max].min
        end
        @parallax_y += @display_y - last_y
      end
    else
      scroll_down_mgc_zoom(distance)
    end
  end
  #--------------------------------------------------------------------------
  # * Scroll Left
  #--------------------------------------------------------------------------
  def scroll_left(distance)
    if MGC.new_tilemap_active # [1.4]
      if loop_horizontal?
        @display_x += @map.width - distance
        @display_x %= @map.width
        @parallax_x -= distance if @parallax_loop_x
      else
        last_x = @display_x
        if width * MGC.map_zoom < screen_tile_x
          @display_x = (width - screen_tile_x).abs / 2
        else
          min = screen_tile_x * (1.0 / MGC.map_zoom - 1.0) / 2
          @display_x = [@display_x - distance, min].max
        end
        @parallax_x += @display_x - last_x
      end
    else
      scroll_left_mgc_zoom(distance)
    end
  end
  #--------------------------------------------------------------------------
  # * Scroll Right
  #--------------------------------------------------------------------------
  def scroll_right(distance)
    if MGC.new_tilemap_active # [1.4]
      if loop_horizontal?
        @display_x += distance
        @display_x %= @map.width
        @parallax_x += distance if @parallax_loop_x
      else
        last_x = @display_x
        if width * MGC.map_zoom < screen_tile_x
          @display_x = (width - screen_tile_x).abs / 2
        else
          max = width + screen_tile_x * ((1.0 - 1.0 / MGC.map_zoom) / 2 - 1)
          @display_x = [@display_x + distance, max].min
        end
        @parallax_x += @display_x - last_x
      end
    else
      scroll_right_mgc_zoom(distance)
    end
  end
  #--------------------------------------------------------------------------
  # * Scroll Up
  #--------------------------------------------------------------------------
  def scroll_up(distance)
    if MGC.new_tilemap_active # [1.4]
      if loop_vertical?
        @display_y += @map.height - distance
        @display_y %= @map.height
        @parallax_y -= distance if @parallax_loop_y
      else
        last_y = @display_y
        if height * MGC.map_zoom < screen_tile_y
          @display_y = (height - screen_tile_y).abs / 2
        else
          min = screen_tile_y * (1.0 / MGC.map_zoom - 1.0) / 2
          @display_y = [@display_y - distance, min].max
        end
        @parallax_y += @display_y - last_y
      end
    else
      scroll_up_mgc_zoom(distance)
    end
  end
end

#============================================================================
# ** RPG::MapInfo
#============================================================================
class RPG::MapInfo
  # defines the map name as the name without anything within brackets,
  # including brackets
  def name
    return @name.gsub(/\[.*\]/) {''}
  end
  #--------------------------------------------------------------------------
  # the original name with the codes
  def full_name
    return @name
  end
end

Map Zoom Ace Addon

#====================================================================
# Map Zoom Ace Addon
# v.1.0
# Auteur : MGC
#
# Permet de zoomer sur une position de la carte, ou sur un évènement.
#
# Nécessite :
# - le script "Map Zoom Ace" du même auteur en V.1.1 minimum, placé
#   directement au-dessus de ce script
#
# Utilisation :
# - au sujet de commande existante :
#   MGC.to_map_zoom(nouvelle valeur de zoom, durée de la transition)
#   Cette commande centre systématiquement la vue sur le joueur.
# - nouvelle commande pour zoomer sur une position de la carte
#   MGC.zoom_on_position(abscisse, ordonnée, nouvelle valeur de zoom, durée de la transition)
#   L'abscisse (x) et l'ordonnée (y) sont exprimées en tiles.
# - nouvelle commande pour zoomer sur un évènement
#   MGC.zoom_on_event(identifiant de l'évènement, nouvelle valeur de zoom, durée de la transition)
#====================================================================
module MGC
  #--------------------------------------------------------------------------
  # * Pour zoomer sur une position (valeurs en tiles)
  #--------------------------------------------------------------------------
  def self.zoom_on_position(pos_x, pos_y, new_zoom, duration)
    @pos_x = pos_x
    @pos_y = pos_y
    @free_camera = true
    self.process_to_map_zoom(new_zoom, duration)
  end
  #--------------------------------------------------------------------------
  # * Pour zoomer sur un évènement
  #--------------------------------------------------------------------------
  def self.zoom_on_event(event_id, new_zoom, duration)
    event = $game_map.events[event_id]
    @pos_x = event.x
    @pos_y = event.y
    @free_camera = true
    self.process_to_map_zoom(new_zoom, duration)
  end
  #--------------------------------------------------------------------------
  # * Pour aller progressivement vers une nouvelle valeur de zoom
  #--------------------------------------------------------------------------
  def self.to_map_zoom(new_zoom, duration)
    if @free_camera
      @free_camera = false
      if map_zoom == new_zoom
        $game_player.center($game_player.x, $game_player.y)
        @force_map_update = true
      end
    end
    self.process_to_map_zoom(new_zoom, duration)
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut zoom
  #--------------------------------------------------------------------------
  def self.map_zoom=(zoom_value)
    unless map_zoom == zoom_value
      if zoom_value < 0.125 || zoom_value > 8.0 then return end
      @zoom = zoom_value
      $game_system.map_zoom = @zoom
      if @free_camera
        $game_map.set_display_pos(@pos_x - (Graphics.width / 32 - 1) / 2.0,
        @pos_y - (Graphics.height / 32 - 1) / 2.0)
      else
        $game_player.center($game_player.x, $game_player.y)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Pour aller progressivement vers une nouvelle valeur de zoom,
  # sans centrage automatique sur le joueur
  #--------------------------------------------------------------------------
  def self.process_to_map_zoom(new_zoom, duration)
    unless map_zoom == new_zoom
      if new_zoom < 0.125 || new_zoom > 8.0 then return end
      @map_zoom_duration = duration
      target_zoom_incr = Math.log(new_zoom) / Math.log(2)
      @map_zoom_step = (target_zoom_incr - @map_zoom_incr) / duration
      @target_map_zoom = new_zoom
    end
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut force_map_update
  #--------------------------------------------------------------------------
  def self.force_map_update=(flag)
    @force_map_update = flag
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut force_map_update
  #--------------------------------------------------------------------------
  def self.force_map_update
    return @force_map_update
  end
  #--------------------------------------------------------------------------
  # ** Tilemap
  #--------------------------------------------------------------------------
  class Tilemap
    #--------------------------------------------------------------------------
    # * Aliased methods
    #--------------------------------------------------------------------------
    unless @already_aliased_mgc_zoom_addon
      alias update_map_zoom_addon update
      @already_aliased_mgc_zoom_addon = true
    end
    #--------------------------------------------------------------------------
    # * Mise à jour, appelée normalement à chaque frame
    #--------------------------------------------------------------------------
    def update
      if @visible && MGC.force_map_update
        @need_refresh = true
        @refresh_all = true
        MGC.force_map_update = false
      end
      update_map_zoom_addon
    end
  end
end

TEST - à ne pas reprendre

# F5 -> 1:1
# F6 -> 2:1
# F7 -> 4:1
# F8 -> 1:2
module MGC
  class << self
    #--------------------------------------------------------------------------
    # * Aliased methods
    #--------------------------------------------------------------------------
    unless @already_aliased_mgc_zoom_test
      alias update_new_tilemap_test update_new_tilemap
      @already_aliased_mgc_zoom_test = true
    end
  end
  #--------------------------------------------------------------------------
  # * Mise à jour de la valeur du zoom
  #--------------------------------------------------------------------------
  def self.update_new_tilemap
    if Input.trigger?(:F5)
      self.to_map_zoom(1.0, 10)
    elsif Input.trigger?(:F6)
      self.to_map_zoom(2.0, 10)
    elsif Input.trigger?(:F7)
      self.to_map_zoom(4.0, 10)
    elsif Input.trigger?(:F8)
      self.to_map_zoom(0.5, 10)
    end
    update_new_tilemap_test
  end
end

和【ULDS】无限图层显示系统 Unlimited Layers Display System
虽然找过其他图层脚本，但还是觉得Taroxd的ULDS脚本自由度高上许多
请问有办法可以兼容吗？




重发了好几遍才发现论坛居然是不让我发图◢▆▅▄▃崩╰(〒皿〒)╯溃▃▄▅▇◣

报错内容如下：
脚本无限图层显示系统的第124行 NoMethodErrorが発生
undefined method‵abs' for nil:NilClass

翠靈月

掉到第二页了，自顶一下

Nil2018

缺少 picture auto base

Nil2018

所以。。暂时不懂两个脚本合并在一起报的是啥错