¡Bienvenid@ a Mundo Maker!

¿Quieres aprender todo sobre el RPG Maker?



Regístrate y forma parte de Mundo Maker.
Conectarse

Recuperar mi contraseña

Temas importantes
----------------------------------------
Páginas con recursos RPG Maker
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
Afiliados
Estadísticas
Tenemos 3930 miembros registrados.
El último usuario registrado es LKendo.

Nuestros miembros han publicado un total de 83410 mensajes en 11867 argumentos.
Navega con Google Chrome
[DESCARGA]

Problema con el parallax mapping

 :: RPG Maker :: Ayuda RPG

Ver el tema anterior Ver el tema siguiente Ir abajo

RPG Maker VX ACE Problema con el parallax mapping

Mensaje por KandiskiManga el 2017-04-02, 19:10

Buenas, no me gusta mucho pedir ayuda pero aveces veo que no tengo otra opción XD. Bien mi problema es que yo utilizo el script de MGC tilemap Ace que básicamente lo que hace es que te hace un Zoom para que el juego se vea desde mucho mas cerca. Estoy trabajando en VX Ace y bueno las limitaciones de los tilesets... me han molestado así que quiero hacer parralax mapping que ha decir verdad me resulta mas fácil de hacer que poner tilesets. 
SCRIPTS: 
Mgc tilemap ace:
Código:
#====================================================================
# 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 = true
  #--------------------------------------------------------------------------
  # * Lancement de la nouvelle tilemap [1.2]
  #--------------------------------------------------------------------------
  def self.start_new_tilemap
    @end_new_tilemap = true
    @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

MGC ZOOM ACE:
Código:
#====================================================================
# 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 = false
  DEFAULT_ZOOM = 1.8 # [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:
Código:
#====================================================================
# 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
La cosa es que quiero poder usar el parralax mapping con el zoom, ya que por el momento he probado varios scripts como el de Fanfly pero no me funciona, no se si alguien tendrá algún script similar al zoom y al mismo tiempo compatible con el parralax. Muchas gracias por vuestro tiempo.
avatar
KandiskiManga
Iniciado
Iniciado

0/3

Créditos 30

Gracias : 6

https://cr3vass3.tumblr.com/

Volver arriba Ir abajo

RPG Maker VX ACE Re: Problema con el parallax mapping

Mensaje por BreinLand entertainment el 2017-04-02, 22:05

En el script de MGC que has copiado, te viene esto en la parte de configuración:

Código:
# Configuration :
# - PARALLAX_ZOOM : Ponly como true o false
#         - true : El parallax entrará en mismo zoom que el mapa. Desactivado
#                 por defecto porque esto puede inducir lagg, y
#                 no quiero volver a reescribir la gestión del zoom de
#                 class Plane para reemplazar lo que hizo Enterbrain
#         - false : Al parallax se la suda el zoom del mapa!

Y.... luego en las líneas de más abajo:

Código:
 #--------------------------------------------------------------------------
 # * CONFIGURATION
 #--------------------------------------------------------------------------
 PARALLAX_ZOOM = false

Por lo que.... normal que no te funcione el zoom en el parallax.

Ponlo en true, y luego ya podrás utilizar cualquier script de parallaxing como los de Yami.

Sino siempre puedes probar utilizando otros scripts de Zoom, como este, el cual además tiene otros efectos para el mapa:

https://forums.rpgmakerweb.com/index.php?threads/map-effects.13941/

Lo malo es que solo te servirá para uso no comercial a no ser que quieras gastarte dinero en el script si piensas vender tu juego.

El script más comunmente usado para parallaxing:

https://yamiworld.wordpress.com/rgss3/field-scripts/overlay-mapping/

...Para el cual, si quieres que el parallax se quede fijo a los tiles base:

https://yanflychannel.wordpress.com/rmvxa/utility-scripts/parallax-lock/

Alternativa de script de parallaxing:

https://forums.rpgmakerweb.com/index.php?threads/unlimited-graphically-layered-maps.2065/
avatar
BreinLand entertainment
Soñador
Soñador

0/3

Créditos 159

Gracias : 33

http://breinland.tk/

Volver arriba Ir abajo

Ver el tema anterior Ver el tema siguiente Volver arriba


 :: RPG Maker :: Ayuda RPG

Permisos de este foro:
No puedes responder a temas en este foro.