地图整体缩放（关于tilemap）

zhangbanxian

用sprite作地图吧- -b不过效率悲剧...

uuiio797

LZ，是这个吗？http://www.youtube.com/watch?v=C8Czqd5wMC0
能缩小放大的。
该脚本来源网战:http://www.rgss-factory.net/

RUBY 代码复制

#====================================================================
# MGC Tilemap Ace
# v.1.0
# 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.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
  #==============================================================================
  # ** 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 :bitmaps, :flash_data
    #--------------------------------------------------------------------------
    # * Constantes
    #--------------------------------------------------------------------------
    RENDER = Win32API.new("MGC_Map_Ace", "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
    #--------------------------------------------------------------------------
    # * 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
        [url=home.php?mod=space&uid=98379]@zoom[/url] = 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)
      [url=home.php?mod=space&uid=10453]@color[/url] = 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
    @already_aliased_mgc_tilemap = true
  end
  #--------------------------------------------------------------------------
  # * Create Tilemap
  #--------------------------------------------------------------------------
  def create_tilemap
    if MGC::NEW_TILEMAP_FOR_ALL_MAPS ||
      MGC::NEW_TILEMAP_MAPS_IDS.include?($game_map.map_id)
    then
      @tilemap = MGC::Tilemap.new(@viewport1)
      @tilemap.map_data = $game_map.data
      load_tileset
    else
      create_tilemap_mgc_tilemap
    end
  end
end

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


# MGC Tilemap Ace


# v.1.0


# 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.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


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


  # ** 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 :bitmaps, :flash_data


    #--------------------------------------------------------------------------


    # * Constantes


    #--------------------------------------------------------------------------


    RENDER = Win32API.new("MGC_Map_Ace", "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


    #--------------------------------------------------------------------------


    # * 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


        [url=home.php?mod=space&uid=98379]@zoom[/url] = 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)


      [url=home.php?mod=space&uid=10453]@color[/url] = 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


    @already_aliased_mgc_tilemap = true


  end


  #--------------------------------------------------------------------------


  # * Create Tilemap


  #--------------------------------------------------------------------------


  def create_tilemap


    if MGC::NEW_TILEMAP_FOR_ALL_MAPS ||


      MGC::NEW_TILEMAP_MAPS_IDS.include?($game_map.map_id)


    then


      @tilemap = MGC::Tilemap.new(@viewport1)


      @tilemap.map_data = $game_map.data


      load_tileset


    else


      create_tilemap_mgc_tilemap


    end


  end


end

RUBY 代码复制

#====================================================================
# Map Zoom Ace
# v.1.2
# 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.0, 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
#====================================================================
module MGC
  #--------------------------------------------------------------------------
  # * CONFIGURATION
  #--------------------------------------------------------------------------
  PARALLAX_ZOOM = false
  #--------------------------------------------------------------------------
  # * GESTION DU ZOOM
  #--------------------------------------------------------------------------
  @zoom = 1.0
  #--------------------------------------------------------------------------
  # * Initialisation de la valeur de zoom
  #--------------------------------------------------------------------------
  def self.initialize_map_zoom
    @zoom = $game_system.map_zoom ? $game_system.map_zoom : 1.0
    @map_zoom_incr = Math.log(@zoom) / Math.log(2)
    @map_zoom_duration = 0
    @zoom_map_active = false
  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
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut zoom_map_active
  #--------------------------------------------------------------------------
  def self.zoom_map_active=(flag)
    @zoom_map_active = flag
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut zoom_map_active
  #--------------------------------------------------------------------------
  def self.zoom_map_active
    return @zoom_map_active
  end
  #--------------------------------------------------------------------------
  # * Mise à jour de la valeur du zoom
  #--------------------------------------------------------------------------
  def self.update_map_zoom
    if @zoom_map_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
  end
end
 
#==============================================================================
# ** Game_System
#==============================================================================
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 ||
        zoom_x == viewport.zoom
        @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 initialize_mgc_zoom initialize
    alias create_tilemap_mgc_zoom create_tilemap
    alias update_mgc_zoom update
    alias update_parallax_mgc_zoom update_parallax
    @already_aliased_mgc_zoom = true
  end
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    MGC.initialize_map_zoom
    initialize_mgc_zoom
  end
  #--------------------------------------------------------------------------
  # * Create Tilemap
  #--------------------------------------------------------------------------
  def create_tilemap
    create_tilemap_mgc_zoom
    MGC.zoom_map_active = @viewport1.contains_zoomable_map
  end
  #--------------------------------------------------------------------------
  # * Update
  #--------------------------------------------------------------------------
  def update
    MGC.update_map_zoom
    update_viewports_zoom
    update_mgc_zoom
  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
#==============================================================================
[: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})
        unless viewport.nil? || 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
        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
  #--------------------------------------------------------------------------
  # * Set Display Position
  #--------------------------------------------------------------------------
  def set_display_pos(x, y)
    if MGC.zoom_map_active
      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.zoom_map_active
      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.zoom_map_active
      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.zoom_map_active
      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.zoom_map_active
      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

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


# Map Zoom Ace


# v.1.2


# 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.0, 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


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


module MGC


  #--------------------------------------------------------------------------


  # * CONFIGURATION


  #--------------------------------------------------------------------------


  PARALLAX_ZOOM = false


  #--------------------------------------------------------------------------


  # * GESTION DU ZOOM


  #--------------------------------------------------------------------------


  @zoom = 1.0


  #--------------------------------------------------------------------------


  # * Initialisation de la valeur de zoom


  #--------------------------------------------------------------------------


  def self.initialize_map_zoom


    @zoom = $game_system.map_zoom ? $game_system.map_zoom : 1.0


    @map_zoom_incr = Math.log(@zoom) / Math.log(2)


    @map_zoom_duration = 0


    @zoom_map_active = false


  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


  #--------------------------------------------------------------------------


  # * Setter pour l'attribut zoom_map_active


  #--------------------------------------------------------------------------


  def self.zoom_map_active=(flag)


    @zoom_map_active = flag


  end


  #--------------------------------------------------------------------------


  # * Getter pour l'attribut zoom_map_active


  #--------------------------------------------------------------------------


  def self.zoom_map_active


    return @zoom_map_active


  end


  #--------------------------------------------------------------------------


  # * Mise à jour de la valeur du zoom


  #--------------------------------------------------------------------------


  def self.update_map_zoom


    if @zoom_map_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


  end


end


 


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


# ** Game_System


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


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 ||


        zoom_x == viewport.zoom


        @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 initialize_mgc_zoom initialize


    alias create_tilemap_mgc_zoom create_tilemap


    alias update_mgc_zoom update


    alias update_parallax_mgc_zoom update_parallax


    @already_aliased_mgc_zoom = true


  end


  #--------------------------------------------------------------------------


  # * Object Initialization


  #--------------------------------------------------------------------------


  def initialize


    MGC.initialize_map_zoom


    initialize_mgc_zoom


  end


  #--------------------------------------------------------------------------


  # * Create Tilemap


  #--------------------------------------------------------------------------


  def create_tilemap


    create_tilemap_mgc_zoom


    MGC.zoom_map_active = @viewport1.contains_zoomable_map


  end


  #--------------------------------------------------------------------------


  # * Update


  #--------------------------------------------------------------------------


  def update


    MGC.update_map_zoom


    update_viewports_zoom


    update_mgc_zoom


  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


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


[: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})


        unless viewport.nil? || 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


        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


  #--------------------------------------------------------------------------


  # * Set Display Position


  #--------------------------------------------------------------------------


  def set_display_pos(x, y)


    if MGC.zoom_map_active


      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.zoom_map_active


      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.zoom_map_active


      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.zoom_map_active


      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.zoom_map_active


      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

RUBY 代码复制

# 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_map_zoom_test update_map_zoom
      @already_aliased_mgc_zoom_test = true
    end
  end
  #--------------------------------------------------------------------------
  # * Mise à jour de la valeur du zoom
  #--------------------------------------------------------------------------
  def self.update_map_zoom
    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_map_zoom_test
  end
end

# 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_map_zoom_test update_map_zoom


      @already_aliased_mgc_zoom_test = true


    end


  end


  #--------------------------------------------------------------------------


  # * Mise à jour de la valeur du zoom


  #--------------------------------------------------------------------------


  def self.update_map_zoom


    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_map_zoom_test


  end


end

uuiio797

给个范例工程:http://pan.baidu.com/share/link?shareid=152926&uk=153859016
脚本出错原因:应该是缺少文件，把范例工程里的的MGC_Map_Ace文件和pictures里的全部文件复制到你的工程就行了。