¡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 3378 miembros registrados.
El último usuario registrado es Max003.

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

Ayuda con Parallax :c vx ace

 :: RPG Maker :: Ayuda RPG

Ver el tema anterior Ver el tema siguiente Ir abajo

Ayuda con Parallax :c vx ace

Mensaje por Calayax el 2014-03-20, 23:44

Emm bueno creo que el título lo dice todo, el hecho es que busqué un tutorial por internet, me descargé la demo de Yami, unas cosas extras de bitmap2file.dll, otra cosa que no recuerdo su nombre, un script para tomar captura de mapa en el juego blablabla como decía un tutorial que hallé.

El hecho es que ahora no entiendo nada, el personaje está sobre los árboles, no hay bloqueos etc u.u Y no sé que hacer, pues encontré mucho mejor la forma de mapear en photoshop y... quería saber si me podrían ayudar  Sweat 

Imagen bosque:

(si me di cuenta del error del pino, pero neh! lo que me importa ahora es que se pueda jugar dentro del mapa :c)

Y bueno... así se vería completo:

Saludotes! y bueno, gracias por adelantado~

Calayax
Soñador
Soñador

0/3

Créditos 470

Gracias : 11

Volver arriba Ir abajo

Re: Ayuda con Parallax :c vx ace

Mensaje por comgerde05 el 2014-03-21, 02:01



Espero te ayude como me ayudo a mi.

para lo de los bloqueos debes crear un tile y configurarlo manualmente si quieres te paso mi plantilla
Plantilla:

comgerde05
Principiante
Principiante

0/3

Créditos 653

Gracias : 31

http://vision-comgerde.blogspot.com/

Volver arriba Ir abajo

Re: Ayuda con Parallax :c vx ace

Mensaje por Calayax el 2014-03-21, 03:24

pero si a él mismo vi ._____. vi sus 5 videos paso por paso y descargé todo lo que dijo y busqué lo que ya no salía en los links y blaaah :cc neh... de todos modos, cuando quise poner eso de los tiles me salían arriba de la imagen ._.

(Y)

Calayax
Soñador
Soñador

0/3

Créditos 470

Gracias : 11

Volver arriba Ir abajo

Re: Ayuda con Parallax :c vx ace

Mensaje por comgerde05 el 2014-03-21, 04:22

Calayax escribió:pero si a él mismo vi ._____. vi sus 5 videos paso por paso y descargé todo lo que dijo y busqué lo que ya no salía en los links y blaaah :cc neh... de todos modos, cuando quise poner eso de los tiles me salían arriba de la imagen ._.

(Y)

Que script tienes? puedes ser más detallado.

Los que yo uso:
Map Screenshot
Código:
=begin
#===============================================================================
 Title: Map Screenshot
 Author: Tsukihime
 Date: Apr 15, 2013
--------------------------------------------------------------------------------
 ** Change log
 Apr 15, 2013
   - updated script to use GDI+ interface
   - added support for region map overlay and passage map overlay
 Apr 6, 2013
   - fixed bug where drawing events crashed the game
 Apr 2, 2013
   - map data is now setup by an instance of Game_Map, to account for custom
     map scripts adding to the map
 Jul 27
   - Export dirNames are now optional
 May 28
   - updated overlay mapping compatibility to draw the overlays
    based on the player's current position
   - fixed issue where import hash was commented out
   - Added support for Yami's overlay mapping
 May 24, 2012
   - fixed large characters
   - some optimizations for calculating bounds and dimensions
 May 5, 2012
   - fixed waterfall autotile
   - added screenshot feature
 May 4, 2012
   - fixed tiles with alpha channel
   - fixed shadows
   - fixed wall autotiles
 May 1, 2012
   - fixed wall autotile, although there is still an issue with some tiles
 Apr 29, 2012
   - fixed shadow map drawing
   - added region highlighting
   - added damage tile highlighting
 Apr 28, 2012
   - Initial Release
------------------------------------------------------------------------------
 ** Description
 
This script allows you to take a full image of any of your game's maps
 and export. An image of the map is referred to as a "mapshot" (as opposed to
 screenshot).
 
The script provides various configuration options to control what kinds of
 things you want to see on your map, such as events, vehicles, region ID's, or
 specific tile properties.
 
------------------------------------------------------------------------------
 ** Usage
 
The default key for taking a mapshot is F7. This can be changed in the
 configuration section.
 
To take a mapshot, first start the game, and then hit F7.
 A message will appear informing you that a mapshot was successfully taken.
 
Alternatively, you can use script calls to take mapshots.

    Map_Saver.new(map_id).export
    
 Aside from exporting images, you are able to use the image that the
 map saver captures.
 
  ms = Map_Saver.new(map_id)
   bmp = ms.map_image
  
This gives you a reference to a Bitmap object that contains an image of
 your map.
--------------------------------------------------------------------------------
  ** Credits
 
 Cremno
    -GDI+ interface code
  Cidiomar
    -for drawing autotiles and shadows,
   -providing efficient bmp and png exporters
  Moon
    -auto-tile related info
  Mephistox
    -testing and suggestions
================================================================================
=end
$imported = {} if $imported.nil?
$imported["TH_MapSaver"] = true
#===============================================================================
# ** Configuration
#===============================================================================
module TH
  module Map_Saver
    
    #Mapshot options. This takes an image of the entire map
    Mapshot_Button = Input::F7
    Mapshot_Scale = 1
    
    #Screenshot options. This takes an image of the visible map
    Screenshot_Button = Input::F6
    Screenshot_Scale = 1
    
    #Folder that the map will be exported to
    Mapshot_Directory = "Mapshots"
    Screenshot_Directory = "Screenshots"
    
    # format you want to export to. You should stick with png.
    # Options: [bmp, png]
   Export_Format = "png"
    
    # Sprite draw options
    Draw_Events = false
    Draw_Player = true
    Draw_Followers = false
    Draw_Vehicles = false
    
    #Should shadows be drawn? What color?
    Draw_Shadow = true
    Shadow_Color = Color.new(0, 0, 0, 128)
    
    # Should regions be drawn? Requires "Region Overlay Map" script
    Draw_Regions = false
    
    # Should passage settings be drawn? Requires "Passage Overlay Map" script
    Draw_Passages = false
    
    #Should damage tiles be highlighted? What color?
    Highlight_Damage = true
    Damage_Color = Color.new(128, 0, 0, 128)
  end
end

#==============================================================================
# ** Module: Map_Tiles
# Contains data and methods useful for working with maps and tiles
#==============================================================================

module Map_Tiles
  AUTOTILE_PARTS = [[18,17,14,13], [ 2,14,17,18], [13, 3,17,18], [ 2, 3,17,18],
                    [13,14,17, 7], [ 2,14,17, 7], [13, 3,17, 7], [ 2, 3,17, 7],
                    [13,14, 6,18], [ 2,14, 6,18], [13, 3, 6,18], [ 2, 3, 6,18],
                    [13,14, 6, 7], [ 2,14, 6, 7], [13, 3, 6, 7], [ 2, 3, 6, 7],
                    [16,17,12,13], [16, 3,12,13], [16,17,12, 7], [12, 3,16, 7],
                   [10, 9,14,13], [10, 9,14, 7], [10, 9, 6,13], [10, 9, 6, 7],
                    [18,19,14,15], [18,19, 6,15], [ 2,19,14,15], [ 2,19, 6,15],
                    [18,17,22,21], [ 2,17,22,21], [18, 3,22,21], [ 2, 3,21,22],
                    [16,19,12,15], [10, 9,22,21], [ 8, 9,12,13], [ 8, 9,12, 7],
                    [10,11,14,15], [10,11, 6,15], [18,19,22,23], [ 2,19,22,23],
                    [16,17,20,21], [16, 3,20,21], [ 8,11,12,15], [ 8, 9,20,21],
                    [16,19,20,23], [10,11,22,23], [ 8,11,20,23], [ 0, 1, 4, 5]]
  WATERFALL_PIECES = [[ 2, 1, 6, 5], [ 0, 1, 4, 5], [ 2, 3, 6, 7], [0, 3, 4, 7]]
  WALL_PIECES =  [[10, 9, 6, 5], [ 8, 9, 4, 5], [ 2, 1, 6, 5], [ 0, 1, 4, 5],
                  [10,11, 6, 7], [ 8,11, 4, 7], [ 2, 3, 6, 7], [ 0, 3, 4, 7],
                  [10, 9,14,13], [ 8, 9,12,13], [ 2, 1,14,13], [ 0, 1,12,13],
                  [10,11,14,15], [8, 11,12,15], [ 2, 3,14,15], [ 0, 3,12,15]]

  A1_TILES = [[0, 0], [0, 96], [192, 0], [192, 96],
               [256, 0], [448, 0], [256, 96], [448, 96],
               [0, 192], [192, 192], [0, 288], [192, 288],
               [256, 192], [448, 192], [256, 288], [448, 288]]
    
  
  #--------------------------------------------------------------------------
  # * Checks if a tile is a wall
  #--------------------------------------------------------------------------
  def is_wall?(data)
    return true if data.between?(2288, 2335)
    return true if data.between?(2384, 2431)
    return true if data.between?(2480, 2527)
    return true if data.between?(2576, 2623)
    return true if data.between?(2672, 2719)
    return true if data.between?(2768, 2815)
    return true if data.between?(4736, 5119)
    return true if data.between?(5504, 5887)
    return true if data.between?(6272, 6655)
    return true if data.between?(7040, 7423)
    return true if data > 7807
    false
  end
  #--------------------------------------------------------------------------
  # * Checks if a tile is roof
  #--------------------------------------------------------------------------
  def is_roof?(data)
    return true if data.between?(4352, 4735)
    return true if data.between?(5120, 5503)
    return true if data.between?(5888, 6271)
    return true if data.between?(6656, 7039)
    return true if data.between?(7424, 7807)
    false
  end  
  #--------------------------------------------------------------------------
  # * Checks if a tile is soil
  #--------------------------------------------------------------------------
  def is_soil?(data)
    return true if data.between?(2816, 4351) && !is_table?(data)
    return true if data > 1663 && !is_stair?(data)
    false
  end    
  #--------------------------------------------------------------------------
  # * Checks if a tile is a stair
  #--------------------------------------------------------------------------
  def is_stair?(data)
     return true if data.between?(1541, 1542)
     return true if data.between?(1549, 1550)
     return true if data.between?(1600, 1615)
     false
  end
  #--------------------------------------------------------------------------
  # * Checks if a tile is a table
  #--------------------------------------------------------------------------
  def is_table?(data)
    return true if data.between?(3152, 3199)
    return true if data.between?(3536, 3583)
    return true if data.between?(3920, 3967)
    return true if data.between?(4304, 4351)
    false
  end
 
 #--------------------------------------------------------------------------
  # * The tileset to be used
  #--------------------------------------------------------------------------
  def tileset
    $data_tilesets[@tileset_id]
  end
  
  #--------------------------------------------------------------------------
  # * Region ID
  #--------------------------------------------------------------------------
  def region_id(x, y)
    valid?(x, y) ? @map.data[x, y, 3] >> 8 : 0
  end
  
  #--------------------------------------------------------------------------
  # * Gets all of the tiles for each layer at position x,y
  #--------------------------------------------------------------------------
  def layered_tiles(x, y)
    [2, 1, 0].collect {|z| @map.data[x, y, z] }
  end
  
  def layered_tiles_flag?(x, y, bit)
    layered_tiles(x, y).any? {|tile_id| tileset.flags[tile_id] & bit != 0 }
  end
  
 def valid?(x, y)
    x >= 0 && x < width && y >= 0 && y < height
  end
  
  def damage_floor?(x, y)
    valid?(x, y) && layered_tiles_flag?(x, y, 0x100)
  end
  
  #--------------------------------------------------------------------------
  # * Specifies which type of autotile is used
  #--------------------------------------------------------------------------
  def auto_tile(id)
    id / 48
  end
  
  #--------------------------------------------------------------------------
  # * Specifies the specific arrangement of autotiles used
  #--------------------------------------------------------------------------
  def auto_index(id)
    id % 48
  end
  
  #--------------------------------------------------------------------------
  # * Put the auto-tile pieces together
  #--------------------------------------------------------------------------
  def make_autotile(rects, sx, sy)
    @tile.clear
    for i in 0...4
      @auto_rect.x = (rects[i] % 4) * 16 + sx
      @auto_rect.y = (rects[i] / 4) * 16 + sy
      @tile.blt((i % 2) * 16,(i / 2) * 16, @tilemap, @auto_rect)
    end
  end
    
 #--------------------------------------------------------------------------
  # * Get auto-tile A1 tiles
  #--------------------------------------------------------------------------
  def autotile_A1(tile_id)
    @tilemap = @bitmaps[0]
    autotile = tile_id / 48
    auto_id = tile_id % 48
    sx, sy = A1_TILES[autotile]
    if is_wall?(tile_id + 2048)
      rects = WATERFALL_PIECES[auto_id]
    else  
      rects = AUTOTILE_PARTS[auto_id]
    end
    make_autotile(rects, sx, sy)
  end
  
  #--------------------------------------------------------------------------
  # * Get auto-tile A2 tiles.
  # 64x96 tiles, 8 per row, 4 rows
  #--------------------------------------------------------------------------
  def autotile_A2(tile_id)
    autotile = tile_id / 48
    auto_id = tile_id % 48
    @tilemap = @bitmaps[1]
    sx = (autotile % 8) * 64
    sy = (autotile / 8 % 4) * 96
    rects = AUTOTILE_PARTS[auto_id]
    make_autotile(rects, sx, sy)
  end
  
  #--------------------------------------------------------------------------
  # * Get auto-tile A3 tiles.
  # 64x64 tiles, 8 per row, 4 rows
  #--------------------------------------------------------------------------
  def autotile_A3(tid)
    @tilemap = @bitmaps[2]
    sx = (auto_tile(tid) % 8) * 64
    sy = (auto_tile(tid) / 8 % 4) * 64
    rects = WALL_PIECES[auto_index(tid)]
    make_autotile(rects, sx, sy)
  end
  
  #--------------------------------------------------------------------------
  # * Get auto-tile A4 tiles (walls)
  #--------------------------------------------------------------------------
  def autotile_A4(tile_id)
    @tilemap = @bitmaps[3]
    autotile = tile_id / 48
    auto_id = tile_id % 48
    sx = (autotile % 8) * 64
    sy = (autotile / 16 * 160) + (autotile / 8 % 2) * 96
    if is_wall?(tile_id + 5888)
      rects = WALL_PIECES[auto_id]
    else
      rects = AUTOTILE_PARTS[auto_id]
    end
   make_autotile(rects, sx, sy)
  end
  
  #--------------------------------------------------------------------------
  # * Get auto-tile A5 tiles (normal)
  #--------------------------------------------------------------------------
  def autotile_A5(tile_id)
    @tilemap = @bitmaps[4]
    sx = (tile_id) % 8 * tilesize
    sy = (tile_id) / 8 * tilesize
    @src_rect.set(sx, sy, tilesize, tilesize)
    @tile.clear
    @tile.blt(0, 0, @tilemap, @src_rect)
  end
  
  #--------------------------------------------------------------------------
  # * Get normal tiles B, C, D, E
  #--------------------------------------------------------------------------
  def normal_tile(tile_id)
    @tilemap = @bitmaps[5 + tile_id / 256]
    sx = (tile_id / 128 % 2 * 8 + tile_id % 8) * tilesize;
    sy = (tile_id % 256 / 8 % 16) * tilesize;
    @src_rect.set(sx, sy, tilesize, tilesize)
    @tile.clear
    @tile.blt(0, 0, @tilemap, @src_rect)
  end
  
 #--------------------------------------------------------------------------
  # * Get bitmap for the specified tile id
  #--------------------------------------------------------------------------
  def get_bitmap(id)
    if id < 1024
      normal_tile(id)
    elsif id < 1664
      autotile_A5(id - 1536)
    elsif id < 2816
      autotile_A1(id - 2048)
    elsif id < 4352
      autotile_A2(id - 2816)
    elsif id < 5888
      autotile_A3(id - 4352)
    else
      autotile_A4(id - 5888)
    end
  end
end

#==============================================================================
# **
#==============================================================================

class Game_Player < Game_Character
  
  alias :th_mapsaver_update :update
  def update
    th_mapsaver_update
    if Input.trigger?(TH::Map_Saver::Mapshot_Button)
      s = Map_Saver.new($game_map.map_id)
      s.set_scale(TH::Map_Saver::Mapshot_Scale)
      s.mapshot
    end
    if Input.trigger?(TH::Map_Saver::Screenshot_Button)
      s = Map_Saver.new($game_map.map_id)
      s.set_scale(TH::Map_Saver::Screenshot_Scale)
      s.screenshot
    end
  end
end

class Game_Vehicle < Game_Character
  attr_reader :map_id
end

class Game_Map
  attr_reader :map
end

#==============================================================================
# **
#==============================================================================

class Map_Saver
  include TH::Map_Saver
  include Map_Tiles
  #--------------------------------------------------------------------------
  # * Constants
  #--------------------------------------------------------------------------

  SHADOW_COLOR = TH::Map_Saver::Shadow_Color
  DAMAGE_COLOR = TH::Map_Saver::Damage_Color

  #--------------------------------------------------------------------------
  # * Public instance variables
  #--------------------------------------------------------------------------
  attr_reader :map_image
  
  def initialize(map_id=$game_map.map_id, x=$game_player.x, y=$game_player.y)
    @scale = 1
    @local_x = x
    @local_y = y
    @screen_local = false
    @shadow_bitmap = Bitmap.new(128, 128)
    @draw_layer0 = true
    @draw_layer1 = true
    @draw_layer2 = true
    @draw_events = Draw_Events
    @draw_vehicles = Draw_Vehicles
    @draw_player = Draw_Player
    @draw_followers = Draw_Followers
    @draw_shadow = Draw_Shadow
    @draw_damage = Highlight_Damage
    @draw_regions = Draw_Regions
    @draw_passages = Draw_Passages
    @tile = Bitmap.new(32, 32) #stores the current tile to be drawn
    @tilemap = nil
    @src_rect = Rect.new
    @auto_rect = Rect.new(0, 0, tilesize / 2, tilesize/ 2) #constant
    @tile_rect = Rect.new(0, 0, tilesize, tilesize)        #constant
  end
  
  def load_tilesets
    bitmaps = []
    tileset.tileset_names.each_with_index do |name, i|
      bitmaps[i] = Cache.tileset(name)
    end
    return bitmaps
  end
  
  #--------------------------------------------------------------------------
  # * Refresh, possibly with a new map
  #--------------------------------------------------------------------------
  def redraw(map_id=$game_map.map_id, x=$game_player.x, y=$game_player.y)
    @map_image.dispose if @map_image
    @map_id = map_id
    @local_x = x
    @local_y = y
    @game_map = Game_Map.new
    @game_map.setup(map_id)
    @map = @game_map.map
    @map_info = $data_mapinfos[map_id]
    @screen = $game_map.screen
    @tileset_id = @game_map.tileset.id
    @bitmaps = load_tilesets
    
    get_bounds
    @map_image = Bitmap.new(@width * tilesize, @height * tilesize)
    draw_map
    scale_map if @scale != 1
  end
  
  #--------------------------------------------------------------------------
  # * Pre-process. These will never change when drawing the map.
 #--------------------------------------------------------------------------
  def get_bounds
    @start_x = start_x
    @start_y = start_y
    @end_x = end_x
    @end_y = end_y
    @width = width
    @height = height
    @tilesize = tilesize
  end
  
  def screen_tile_x
    Graphics.width / 32
  end
  
  def screen_tile_y
    Graphics.height / 32
  end
  
  #--------------------------------------------------------------------------
  # * Sets the scale for the map
  #--------------------------------------------------------------------------
  def set_scale(scale)
    @scale = scale
  end
  
  #--------------------------------------------------------------------------
  # * Size of a tile
  #--------------------------------------------------------------------------
  def tilesize
    32
  end
  
  #--------------------------------------------------------------------------
  # * Width and height of the map, both locally and globally
  #--------------------------------------------------------------------------
  def width
    end_x - @start_x
  end
  
  def height
    end_y - @start_y
  end
  
  #--------------------------------------------------------------------------
  # * Starting and end positions, relative to the screen or map
  #--------------------------------------------------------------------------
  def start_x
    @screen_local ? [[$game_player.x - screen_tile_x / 2, @map.width - screen_tile_x].min, 0].max : 0
  end

  def start_y
    @screen_local ? [[$game_player.y - screen_tile_y / 2, @map.height - screen_tile_y].min, 0].max : 0
  end
  
  def end_x
    @screen_local ? [[screen_tile_x, @local_x + screen_tile_x / 2 + 1].max, @map.width].min : @map.width
  end
  
  def end_y
    @screen_local ? [[screen_tile_y, @local_y + screen_tile_y / 2 + 1].max, @map.height].min : @map.height
  end

  #--------------------------------------------------------------------------
  # * Draw tile onto image. x and y values are absolute coords. They should
  # be re-mapped based on the start_x and start_y values
  #--------------------------------------------------------------------------
  def draw_tile(x, y, tile, rect)
    ox = (x - @start_x) * tilesize
    oy = (y - @start_y) * tilesize
    @map_image.blt(ox, oy, tile, rect)
  end
  
  #--------------------------------------------------------------------------
  # * Get bitmap for the specified character
  #--------------------------------------------------------------------------
  def get_character_bitmap(name)
    charmap = Cache.character(name)
    sign = name[/^[\!\$]./]
    if sign && sign.include?('$')
      cw = charmap.width / 3
      ch = charmap.height / 4
    else
      cw = charmap.width / 12
      ch = charmap.height / 8
    end
    return charmap, cw, ch
  end
  
  #--------------------------------------------------------------------------
  # * Draw the character onto the tile
  #--------------------------------------------------------------------------
  def set_character_bitmap(character, x, y)
    charmap, cw, ch = get_character_bitmap(character.character_name)
    index = character.character_index
    pattern = character.pattern < 3 ? character.pattern : 1
    sx = (index % 4 * 3 + pattern) * cw
    sy = (index / 4 * 4 + (character.direction - 2) / 2) * ch
    @src_rect.set(sx, sy, cw, ch)
    x -= cw / (@tilesize * 2) if cw >= @tilesize
    y -= ch / (@tilesize * 2) if ch >= @tilesize  
    draw_tile(x, y, charmap, @src_rect)
  end
  
  #--------------------------------------------------------------------------
  # * create the shadow map
  #--------------------------------------------------------------------------
  def make_shadow_map
    for s in 0 ... 16
      x = s % 4
      y = s / 4
      if s & 0b1000 == 0b1000
        @shadow_bitmap.fill_rect(x*tilesize+16, y*@tilesize+16, 16, 16, SHADOW_COLOR)
      end
      if s & 0b0100 == 0b0100
        @shadow_bitmap.fill_rect(x*tilesize, y*@tilesize+16, 16, 16, SHADOW_COLOR)
      end
      if s & 0b0010 == 0b0010
        @shadow_bitmap.fill_rect(x*tilesize+16, y*@tilesize, 16, 16, SHADOW_COLOR)
      end
      if s & 0b0001 == 0b0001
        @shadow_bitmap.fill_rect(x*tilesize, y*@tilesize, 16, 16, SHADOW_COLOR)
      end
    end
  end
  
  def draw_parallax
    image = Cache.parallax(@map.parallax_name)
    @src_rect.set(0, 0, image.width, image.height)
    @map_image.blt(0, 0, image, @src_rect)
  end
  
  #--------------------------------------------------------------------------
  # * Draw the shadow map
  #--------------------------------------------------------------------------
  def draw_shadow_map
    for x in @start_x ... @end_x
      for y in @start_y ... @end_y
      _x, _y = x*@tilesize, y*@tilesize
        s = @map.data[x, y, 3]  & 0b1111
        if s != 0
          x_ = (s % 4) * @tilesize
          y_ = (s / 4) * @tilesize
          @src_rect.set(x_, y_, @tilesize, @tilesize)
          draw_tile(x, y, @shadow_bitmap, @src_rect)
        end
      end
    end
  end
  
  #--------------------------------------------------------------------------
  # * Draw the specified layer
  #--------------------------------------------------------------------------
  def draw_layer(layer)
    for x in @start_x ... @end_x
      for y in @start_y ... @end_y
        _x, _y = x*@tilesize, y*@tilesize
        tile_id = @map.data[x, y, layer]
        next if tile_id == 0
        get_bitmap(tile_id)
        draw_tile(x, y, @tile, @tile_rect)
      end
    end
  end
  
  #-----------------------------------------------------------------------------
  # Draw game regions
  #-----------------------------------------------------------------------------
  def draw_regions
    if $imported["TH_RegionOverlay"]
      image = SceneManager.scene.instance_variable_get(:@spriteset).instance_variable_get(:@region_map).bitmap
      @src_rect.set(@start_x * tilesize, @start_y * tilesize, image.width, image.height)
      @map_image.blt(0, 0, image, @src_rect, 255)
    end
  end
  
  def draw_passages
    if $imported["TH_OverlayPassageMap"]
      image = SceneManager.scene.instance_variable_get(:@spriteset).instance_variable_get(:@passage_map).bitmap
      @src_rect.set(@start_x * tilesize, @start_y * tilesize, image.width, image.height)
      @map_image.blt(0, 0, image, @src_rect, 255)
    end
  end

  #--------------------------------------------------------------------------
  # * Draw the game player
  #--------------------------------------------------------------------------
  def draw_player
    set_character_bitmap($game_player, $game_player.x, $game_player.y) if @map_id == $game_map.map_id
  end
  
  def draw_followers
  end
  
  #--------------------------------------------------------------------------
  # * Draw map events
  #--------------------------------------------------------------------------
  def draw_events
    @map.events.values.each do |event|
      id = event.pages[0].graphic.tile_id
      char_name = event.pages[0].graphic.character_name
      if id > 0
        normal_tile(id)
        draw_tile(event.x, event.y, @tilemap, @src_rect)
      elsif char_name != ""
        set_character_bitmap(event.pages[0].graphic, event.x, event.y)
      end
    end
  end
  
  #--------------------------------------------------------------------------
  # * Draw map vehicles
  #--------------------------------------------------------------------------
  def draw_vehicles
    $game_map.vehicles.each do |vehicle|
      set_character_bitmap(vehicle, vehicle.x, vehicle.y,) if @map_id == vehicle.map_id
    end
  end
  
  #--------------------------------------------------------------------------
  # * Draw map sprites
  #--------------------------------------------------------------------------
  def draw_sprites
    draw_events if @draw_events
    draw_vehicles if @draw_vehicles
    draw_player if @draw_player
    draw_followers if @draw_followers
  end
  
  #--------------------------------------------------------------------------
  # * Highlight damage tiles
  #--------------------------------------------------------------------------
  def draw_damage
    @tile.clear
    @tile.fill_rect(0, 0, @tilesize, @tilesize, DAMAGE_COLOR)
    @src_rect.set(0, 0, @tilesize, @tilesize)
    for x in @start_x ... @end_x
      for y in @start_y ... @end_y
        _x, _y = x*@tilesize, y*@tilesize
        if damage_floor?(x, y)
          draw_tile(x, y, @tile, @src_rect)
        end
      end
    end
  end
  
  def draw_screen_effects
  end
  #--------------------------------------------------------------------------
  # * Draw the map
  #--------------------------------------------------------------------------
  def draw_map
    make_shadow_map if @draw_shadow
    draw_parallax
    draw_layer(0)
    draw_layer(1)
    draw_shadow_map
    draw_layer(2)
    draw_damage if @draw_damage
    draw_regions if @draw_regions
    draw_passages if @draw_passages
    draw_sprites
    draw_screen_effects
  end
  
  #--------------------------------------------------------------------------
  # * Scale the map
  #--------------------------------------------------------------------------
  def scale_map
    nw = @width * @scale
    nh = @height * @scale
    @src_rect.set(0, 0, @width, @height)
    scaled_map = Bitmap.new(nw, nh)
    scaled_rect = Rect.new(0, 0, nw, nh)
    scaled_map.stretch_blt(scaled_rect, @map_image, @src_rect)
    @map_image = scaled_map
  end
  
  #--------------------------------------------------------------------------
  # * Take a mapshot of the map
  #--------------------------------------------------------------------------
  def mapshot
    @screen_local = false
    redraw
    export(TH::Map_Saver::Mapshot_Directory)
    $game_message.add("Mapshot taken")
  end
    
  #--------------------------------------------------------------------------
  # * Take a screenshot of the map
  #--------------------------------------------------------------------------
  def screenshot
    @screen_local = true
    redraw
    export(TH::Map_Saver::Screenshot_Directory)
    $game_message.add("Screenshot taken")
  end
  
  #--------------------------------------------------------------------------
  # * Get the format to export to
  #--------------------------------------------------------------------------
  def get_format
    TH::Map_Saver::Export_Format
  end
  
  #--------------------------------------------------------------------------
  # * Export the map to a file
  #--------------------------------------------------------------------------
  def export(dirName="")
    format = get_format
    #name = @map.display_name != "" ? @map.display_name : @map_info.name
    name = sprintf("Map%03d" %[@map_id])
    Dir.mkdir(dirName) unless File.directory?(dirName)
    name =
   filename = "%s\\%s.%s" %[dirName, name, format]
    t1 = Time.now
    @map_image.save(filename)
    t2 = Time.now
    $game_message.add("Exported in %f seconds" %[t2 - t1])
  end
end

class Bitmap
 
 def save(filename, options = {})
    options.merge!(format: File.extname(filename)[1..-1].to_sym)
    retval = false
    #bitmap = Gdiplus::Bitmap.new(:hbitmap, hbitmap)
    #bitmap = Gdiplus::Bitmap.new(:gdidib, *gdidib)
    # this seems to be the fastest one (RGSS 3.0.1, Windows 8 64-bit)
    bitmap = Gdiplus::Bitmap.new(:scan0, width, height, scan0)
    if bitmap
      retval = bitmap.save(:file, filename, options[:format])
      bitmap.dispose
    end
    retval
  end
 
private
 
 def _data_struct(offset = 0)
    @_data_struct ||= (DL::CPtr.new((object_id << 1) + 16).ptr + 8).ptr
    (@_data_struct + offset).ptr.to_i
  end
 
 def gdidib
     [_data_struct(8), _data_struct(16)]
  end
 
 def hbitmap
    _data_struct(44)
  end
 
 def scan0
    _data_struct(12)
  end
 
end

# ★ GDI+ interface
# ★★★★★★★★★★★★
#
# Author : Cremno
#
 
module Gdiplus
  DLL = 'gdiplus.dll'
 
 def self.get_function name, import, export = 'L'
    Win32API.new DLL, name, import, export
  end
 
 FUNCTIONS = {
    GdiplusStartup: get_function('GdiplusStartup', 'PPP'),
    GdiplusShutdown: get_function('GdiplusShutdown', 'P', 'V'),
    GdipDisposeImage: get_function('GdipDisposeImage', 'P'),
    GdipSaveImageToFile: get_function('GdipSaveImageToFile', 'PPPP'),
    GdipCreateBitmapFromGdiDib: get_function('GdipCreateBitmapFromGdiDib', 'LLP'),
    GdipCreateBitmapFromHBITMAP: get_function('GdipCreateBitmapFromHBITMAP', 'LLP'),
    GdipCreateBitmapFromScan0: get_function('GdipCreateBitmapFromScan0', 'LLLLPP')
  }
 
 @@token = [0].pack('I')
  def self.token
    @@token
  end
 
 @@clsids = {}
  def self.clsids
    @@clsids
  end
 
 def self.gen_clsids
    return unless @@clsids.empty?
    func = Win32API.new('rpcrt4.dll', 'UuidFromString', 'PP', 'L')
    {
      bmp:  '557cf400-1a04-11d3-9a73-0000f81ef32e',
      jpeg: '557cf401-1a04-11d3-9a73-0000f81ef32e',
      gif:  '557cf402-1a04-11d3-9a73-0000f81ef32e',
      tiff: '557cf405-1a04-11d3-9a73-0000f81ef32e',
      png:  '557cf406-1a04-11d3-9a73-0000f81ef32e'
    }.each_pair do |k, v|
      clsid = [0].pack('I')
      func.call(v, clsid)
      @@clsids[k] = clsid
    end
    @@clsids[:jpg] = @@clsids[:jpeg]
    @@clsids[:tif] = @@clsids[:tiff]
  end
 
 # TODO: prepend prefix (Gdip or Gdiplus) automatically
  def self.call(*args)
    name = args.shift
    func = FUNCTIONS[name]
    v = func.call(*args)
    if v && v != 0
      msgbox "GDI+ error: #{v}\n\nFunction: #{name}\nArguments: #{args.inspect}"
      false
    else
      true
    end
  end
 
 def self.startup
    call :GdiplusStartup, @@token, [1, 0, 0, 0].pack('L4'), 0
  end
 
 def self.shutdown
    call :GdiplusShutdown, @@token
  end
 
 class Image
 
   attr_reader :instance
    def initialize
      @instance = 0
      true
    end
 
   def save(destination, *args)
      case destination
      when :file
        filename = args.shift << "\0"
        filename.encode!('UTF-16LE')
        argv = [:GdipSaveImageToFile, filename, Gdiplus.clsids[args.shift], 0]
      else
        raise ArgumentError, "unknown GDI+ image destination: #{source}"
      end
      argv.insert(1, @instance)
      Gdiplus.call *argv
    end
 
   def dispose
      Gdiplus.call :GdipDisposeImage, @instance
    end
  end
 
 class Bitmap < Image
 
   def initialize source, *args
      case source
      when :gdidib
        argv = [:GdipCreateBitmapFromGdiDib, args.shift, args.shift]
      when :hbitmap
        argv = [:GdipCreateBitmapFromHBITMAP, args.shift, 0]
      when :scan0
        w = args.shift
        h = args.shift
        argv = [:GdipCreateBitmapFromScan0, w, h, w * -4, 0x26200a, args.shift]
      else
        raise ArgumentError, "unknown GDI+ bitmap source: #{source}"
      end
      argv.push([0].pack('I'))
      retval = Gdiplus.call *argv
      @instance = retval ? argv.last.unpack('I').first : 0
      retval
    end
  end
end
 
if Gdiplus.startup
  Gdiplus.gen_clsids
  class << SceneManager
    alias_method :run_wo_gdip_shutdown, :run
    def run
      run_wo_gdip_shutdown
      Gdiplus.shutdown
    end
  end
end

#==============================================================================
# * Compatibility add-ons
#==============================================================================
#Yami overlays
if $imported["YSE-OverlayMapping"]
  class Map_Saver
    def draw_overlay_map_ground
      filename = YSA::OVERLAY::GROUND
      filename += $game_map.map_id.to_s
      filename += "-" + $game_variables[YSA::OVERLAY::GROUND_VARIABLE].to_s
      p filename
      image = Cache.overlay(filename)
      @src_rect.set(@start_x*tilesize, @start_y*tilesize, image.width, image.height)
      @map_image.blt(0, 0, image, @src_rect)
    end
    
    def draw_overlay_map_parallax
      filename = YSA::OVERLAY::PARALLAX
      filename += $game_map.map_id.to_s
      filename += "-" + $game_variables[YSA::OVERLAY::PARALLAX_VARIABLE].to_s
      image = Cache.overlay(filename)
      @src_rect.set(@start_x*tilesize, @start_y*tilesize, image.width, image.height)
      @map_image.blt(0, 0, image, @src_rect)
    end
    
    def draw_overlay_map_light
      filename = YSA::OVERLAY::LIGHT
      filename += $game_map.map_id.to_s
      filename += "-" + $game_variables[YSA::OVERLAY::LIGHT_VARIABLE].to_s
      image = Cache.overlay(filename)
      @src_rect.set(@start_x*tilesize, @start_y*tilesize, image.width, image.height)
      @map_image.blt(0, 0, image, @src_rect, 10)
    end
    
    def draw_overlay_map_shadow
      filename = YSA::OVERLAY::SHADOW
      filename += $game_map.map_id.to_s
      filename += "-" + $game_variables[YSA::OVERLAY::SHADOW_VARIABLE].to_s
      image = Cache.overlay(filename)
      @src_rect.set(@start_x*tilesize, @start_y*tilesize, image.width, image.height)
      @map_image.blt(0, 0, image, @src_rect, 10)
    end
  
    alias :th_map_overlay_draw_map :draw_map
    def draw_map
      th_map_overlay_draw_map
      draw_overlay_map_ground if $game_switches[YSA::OVERLAY::GROUND_SWITCH]
     draw_overlay_map_parallax if $game_switches[YSA::OVERLAY::PARALLAX_SWITCH]
     draw_overlay_map_shadow if $game_switches[YSA::OVERLAY::SHADOW_SWITCH]
      draw_overlay_map_light if $game_switches[YSA::OVERLAY::LIGHT_SWITCH]
    end
  end
end

if $imported["TH_AreaOverlay"]
  class Map_Saver
    def draw_overlay_area_map
      image = SceneManager.scene.instance_variable_get(:@spriteset).instance_variable_get(:@area_map).bitmap
      @src_rect.set(@start_x * tilesize, @start_y * tilesize, image.width, image.height)
      @map_image.blt(0, 0, image, @src_rect, 255)
    end
    
    alias :th_area_overlay_draw_map :draw_map
    def draw_map
      th_area_overlay_draw_map
      draw_overlay_area_map
    end
  end
end
Parallax
Código:
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    # Ultimate Parallax Control V1.0
    #
    # By: GDS
    # Translate: Pigu
    #
    #==============================================================================
    # ▼ Updates
    # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    # 2012.21.05 - Script istart and finish
    #
    #==============================================================================
    # ▼ Introduccion
    # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    # Con este script tienes todas las funciones de parallaxes en uno
    #  no necesita "script calls", <notetags> ni tampoco switches o variables
    #  aunque estos ultimos si se pueden activar
    #
    #==============================================================================
    #  CONFIGURACIONES
    #==============================================================================
    module GDS_Parallax
    module Parallax
      #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
      #All parallaxes are fixed by defaut now,
      #if want the default movement of the parallaxex just put the map id here
      #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
      FIXED_Parallax =[  #<=|Id of the map that will not be fixed
    ] #
      #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
      # Cielo,
      #  Esta capa esta arriba de todas las demas, no tiene movimiento
      #
      # Para activarla necesitamos una imagen en \Graphics\Parallaxes
      # con el nombre "x"_layer2,
      # X es el numero de ID que lleva el mapa
      #
      # Ejemplo:
      #        "\Graphics\Parallaxes\1_layer2"
      #  Esto activa la imagen "layer2"
      #
      # Parallax2  <= Poner el ID del mapa q va a usar cielo
      #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
      Parallax2 = [0, # Mapas con el Cielo activado
    ]
      #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
      # Luces
      #  Esta capa esta justo debajo de la capa cielo, puede moverse o estar quieta
      #
      #
      # Para activarla necesitamos una imagen en \Graphics\Parallaxes
      # con el nombre "X"_light
     # X es el numero de ID que lleva el mapa
      #
      # Ejemplo:
      #        "\Graphics\Parallaxes\1_light"
      #
      #
      # Light <= Poner el ID del mapa q va a usar luces
      #
      #
      #:Flicker_Light
      #
      # 0            => No se mueve
      # 1 o mas => la luz se mueve, cualquier valor mayor a 1 queda raro el efecto
      #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
      Light = [0,            #< Mapas con luces activadas
    ]
      Flicker_Light = 1                      #< Movimiento de luces

      #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
      # Sombras
      #  Esta capa esta debajo del Cielo y las Luces, esta arriba del Suelo
      #  puede moverse o estar quieta
      #
      # Para activarla necesitamos una imagen en  \Graphics\Parallaxes
      # con el nombre "X"_shadow
     # X es el numero de ID que lleva el mapa
      #
      # Ejemplo:
      #        "\Graphics\Parallaxes\1_shadow"
      #
      #
      # Shadow <= Poner el ID del mapa que va a usar las sombras
      #
      #
      #:Flicker_Shadow
      #
      # 0            => No se mueve
      # 1 o mas => la sombra se mueve, cualquier valor mayor a 1 queda raro el efecto
      #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
      Shadow = [0,                    #<=|Mapas con sombras activadas
    ]
      Flicker_Shadow = 0        #<= Movimiento de sombras

      #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
      # Suelo
      # Esta capa esta debajo de los personajes y eventos y por encima de los Tiles
      #
      # Para activarla necesitamos una imagen en \Graphics\Parallaxes\
      # Con el nombre "X"_Ground
     # X es el numero de ID que lleva el mapa
      #
      # Ejemplo:
      #        "\Graphics\Parallaxes\1_ground"
      #
      #
      # Ground <= Poner el ID del mapa que va a usar las sombras
      #
      #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
      Ground = [0 #<=|Id of the map that will use the ground layer

    
   ]
      #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
      # Switches/Interruptores y Variables
      #
      # Interruptores
      #
      #  Activa o desactiva las capas de parallax
      #  si no lo vas a usar deja "nil"
      #
      # Variables
      # cambia la imagen de que va a usar
      #
      # Ejemplo:
      #        La luz del mapa cuatro se llama: "4_light"
      #
      #  pero si queres usar variables para ver que luz se activa:
      #
      # Valor de variable = "0 nombre"  = "4_light"
      # Valor de variable = "1 nombre"  = "4-1_light"
      # Valor de variable = "5 nombre"  = "4-5_light
      #
      # Hay que agregar "-X" despues del ID del mapa
      # en el que "X" es el numero de variable
      #
      #
      #
      #        Atencion
      #
      # Los switches/interruptores solo van a funcionar cuando este en on/off
      # Las variables necesitan cambiar de mapa primero
      #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
      SWITCH_SKY = nil      
     SWITCH_LIGHT = nil  
     SWITCH_SHADOW = nil  
     SWITCH_GROUND = nil
    
     VARIABLE_SKY = nil    
     VARIABLE_LIGHT = nil
     VARIABLE_SHADOW = nil  
     VARIABLE_GROUND = nil  
   #==============================================================================
    # End of configuration
    #==============================================================================
    #==============================================================================
    # ** Spriteset_Map
    #------------------------------------------------------------------------------
    #  This class brings together map screen sprites, tilemaps, etc. It's used
    # within the Scene_Map class.
    #==============================================================================
    end
    end
    class Spriteset_Map
      include GDS_Parallax::Parallax
      #=============================================================================
      # * alias method create_parallax
      #=============================================================================
      alias create_parallax_gds create_parallax
      def create_parallax
        create_parallax_gds
        create_parallaxes
        @do_it1 = true;@do_it2 = true;@do_it3 = true;@do_it4 = true
      end
      def create_parallaxes
        map = $game_map.map_id
        @maps = $game_map.map_id
        ;@check1 = true;@check2 = true;@check3 = true;@check4 = true
        @fixed_p = false;@create1 = false;@create2 = false;@create2 = false;@create3 = false;@create4 = false
        for i in FIXED_Parallax;@fixed_p = true if i == map;end
        for i in Parallax2;@create1 = true if i == map;end
        for i in Light;@create2 = true if i == map;end
        for i in Shadow;@create3 = true if i == map;end
        for i in Ground;@create4 = true if i == map;end
        @parallax1 = Plane.new(@viewport1) if @create1 == true
        @parallax1.z = 203 if @create1 == true;@check1 = false
        @parallax2 = Plane.new(@viewport1) if @create2 == true
        @parallax2.z = 202 if @create2 == true ;@check2 = false
        @parallax3 = Plane.new(@viewport1) if @create3 == true
        @parallax3.z = 201 if @create3 == true;@check3 = false
        @parallax4 = Plane.new(@viewport1) if @create4 == true
        @parallax4.z = 50 if @create4 == true ;@check4 = false
        on1= false
        on2= false
        on3= false
        on4= false
      end
      #=============================================================================
      # * new method create_and_dispose
      # * new method check_for_dispose
      #=============================================================================
      def create_and_dispose
        @parallax1.dispose if @on1 == true
        @parallax2.dispose if @on2 == true
        @parallax3.dispose if @on3 == true
        @parallax4.dispose if @on4 == true
        create_parallaxes
        p "done"
      end
      def check_for_dispose
      create_and_dispose if @maps != $game_map.map_id
     end
      #=============================================================================
      # * new method check_for_swicthes
      #=============================================================================
    
   
   
   
   
     #=============================================================================
      # * alias method dispose_parallax
     #=============================================================================
      alias dispose_parallax_gds dispose_parallax
      def dispose_parallax
        @parallax1.dispose if @on1 == true
        @parallax2.dispose if @on2 == true
        @parallax3.dispose if @on3 == true
        @parallax4.dispose if @on4 == true
        dispose_parallax_gds
      end
      #=============================================================================
      # * overwrite method update_parallax
      #=============================================================================
      def update_parallax
        check_for_dispose
        @parallax1.visible= $game_switches[SWITCH_SKY] if SWITCH_SKY != nil
        @parallax2.visible= $game_switches[SWITCH_LIGHT] if SWITCH_LIGHT != nil
        @parallax3.visible= $game_switches[SWITCH_SHADOW] if SWITCH_SHADOW != nil
      @parallax4.visible= $game_switches[SWITCH_GROUND] if SWITCH_GROUND != nil
      
       if @parallax_name != $game_map.parallax_name
              @parallax_name = $game_map.parallax_name
              @parallax.bitmap.dispose if @parallax.bitmap
              @parallax.bitmap = Cache.parallax(@parallax_name)
              Graphics.frame_reset
        end
        if @create1 == true and @check1 == false
              @parallax1.bitmap.dispose if @parallax1.bitmap
              sky = $game_map.map_id.to_s
              if VARIABLE_SKY != nil
                sky = $game_map.map_id.to_s+"-"+$game_variables[VARIABLE_SKY].to_s
                sky = $game_map.map_id.to_s if $game_variables[VARIABLE_SKY] == 0
              end
              @parallax1.bitmap = Cache.parallax(sky+"_layer2")
              Graphics.frame_reset
              @check1 = true;@on1 = true
        end
        if @create2 == true and @check2 == false
              @parallax2.bitmap.dispose if @parallax2.bitmap
              light = $game_map.map_id.to_s
              if VARIABLE_LIGHT != nil
                light = $game_map.map_id.to_s+"-"+$game_variables[VARIABLE_LIGHT].to_s
                light = $game_map.map_id.to_s if $game_variables[VARIABLE_LIGHT] == 0
              end
              @parallax2.bitmap = Cache.parallax(light+"_light")
              Graphics.frame_reset
              @check2 = true;@on2 = true
        end
        if @create3 == true and @check3 == false
              @parallax3.bitmap.dispose if @parallax3.bitmap
              shadow = $game_map.map_id.to_s
              if VARIABLE_SHADOW != nil
                shadow = $game_map.map_id.to_s+"-"+$game_variables[VARIABLE_SHADOW].to_s
                shadow = $game_map.map_id.to_s if $game_variables[VARIABLE_SHADOW] == 0
              end
              @parallax3.bitmap = Cache.parallax(shadow+"_shadow")
              Graphics.frame_reset
              @check3 = true;@on3 = true
        end
            if @create4 == true and @check4 == false
              @parallax4.bitmap.dispose if @parallax4.bitmap
              ground = $game_map.map_id.to_s
              if VARIABLE_GROUND != nil
                ground = $game_map.map_id.to_s+"-"+$game_variables[VARIABLE_GROUND].to_s
                ground = $game_map.map_id.to_s if $game_variables[VARIABLE_GROUND] == 0
              end
              @parallax4.bitmap = Cache.parallax(ground+"_ground")
              Graphics.frame_reset
              @check4 = true;@on4 = true
        end
              @parallax1.ox = $game_map.display_x * 32  if @create1 == true
              @parallax1.oy = $game_map.display_y * 32  if @create1 == true
    
             @parallax2.ox = $game_map.display_x * 32 + rand(Flicker_Light) if @create2 == true
              @parallax2.oy = $game_map.display_y * 32 + rand(Flicker_Light) if @create2 == true
            
             @parallax3.ox = $game_map.display_x * 32 + rand(Flicker_Shadow) if @create3 == true
              @parallax3.oy = $game_map.display_y * 32 + rand(Flicker_Shadow) if @create3 == true
            
             @parallax4.ox = $game_map.display_x * 32  if @create4 == true
              @parallax4.oy = $game_map.display_y * 32  if @create4 == true
            
             if @fixed_p == true
              @parallax.ox = $game_map.parallax_ox(@parallax.bitmap)
              @parallax.oy = $game_map.parallax_oy(@parallax.bitmap)
        else
              @parallax.ox = $game_map.display_x * 32
              @parallax.oy = $game_map.display_y * 32
        end
      end
    end

Ahora si has seguido bien sus pasos debes tener la imagen del ground, light y shadow verdad?
dentro del script de Parallax ya configuraste para que mapas quiere que este script funcione?
Código:
 #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
      Ground = [1, 2, 4 #<=|Id of the map that will use the ground layer

    
   ]
      #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
ID del o los mapas que quieres que tenga el ground activado.
# Ya importaste la tile que te envie a tu proyecto?
Plantilla
# Debes crear un nuevo tile, puedes llamarlo Parallax si quieres, luego debes configurarlo para que los tiles pasables y las direcciones coincidan con los de la plantilla.
# Recuerda que ground es para las imagenes que van debajo del personaje (pega el tronco de los arboles en el ground).
# El Light lo puedes utilizar para colocar las copas de los arboles (asi le hago yo).

creo que eso es lo más basico... así que mira bien por que creo que estas colocando los troncos de los arboles una capa más arriba del nivel del personaje, recuerda que deben ir abajo.

comgerde05
Principiante
Principiante

0/3

Créditos 653

Gracias : 31

http://vision-comgerde.blogspot.com/

Volver arriba Ir abajo

Re: Ayuda con Parallax :c vx ace

Mensaje por Calayax el 2014-03-21, 16:06

khkjhjk Comger, el video habla del Overlay de Yami, ya me bajé el de Pigu anoche y ahora me va mejor, aún así no he probado aún con el ground. Gracias por darte la molestia de responder, me pondré a ver que resulta. Gracias.

Calayax
Soñador
Soñador

0/3

Créditos 470

Gracias : 11

Volver arriba Ir abajo

Re: Ayuda con Parallax :c vx ace

Mensaje por Usuario Oculto el 2014-03-21, 16:55

Me interesa mucho el tema del "parallax mapping" en el RPG Maker Vx Ace, yo utilizo esta técnica con el VX, pero he encontrado ciertos scripts para VX ACE que me hacen desear mapear con imágenes parallax en esta versión.  Podrían hacer una DEMO que contenga lo necesario y dé una explicación -somera o  sustanciosa- sobre la implementación de dichos scripts.  Muchas gracias y disculpen mi atrevimiento, pero estoy ansioso por probarlo en el ACE.  Baila

Usuario Oculto
Soñador
Soñador

0/3

Créditos 631

Gracias : 14

Volver arriba Ir abajo

Re: Ayuda con Parallax :c vx ace

Mensaje por Calayax el 2014-03-21, 17:05

Sería interesante, yo hice un parallax mapping sólo con el sobreado y bueno... Aún no termino de poner lo último pero ya genera un "leve" problema" y es que al mover el personaje se genera un desplazamiento raro de pixeles :/

Calayax
Soñador
Soñador

0/3

Créditos 470

Gracias : 11

Volver arriba Ir abajo

Re: Ayuda con Parallax :c vx ace

Mensaje por Contenido patrocinado Hoy a las 04:34


Contenido patrocinado


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.