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

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

[VXA] Movimiento pixel por pixel (BETA)

 :: RPG Maker :: Scripts

Ver el tema anterior Ver el tema siguiente Ir abajo

[VXA] Movimiento pixel por pixel (BETA)

Mensaje por orochii el 2014-05-30, 04:42

Movimiento pixel por pixel
Autor: Orochii Zouveleki, versión 0.5b (RGSS3)

Introducción:
Hoy me puse a pensar en lo que una vez había hecho (o empezado, o estado editando o algo así, no recuerdo :VVVV) Wecoc, que era una reescritura del sistema de colisiones del maker. Y bueno, me dio por intentar algo con eso xD. Un movimiento por pixel, donde las colisiones se definen en una imagen.
La diferencia de "mi método", es que estoy parseando un bitmap a modo de string. Estoy leyendo la información no desde la clase Bitmap del maker (que es horrible y estúpidamente lenta), sino leyendo el bitmap como un String, y parseando la información a mano. :B. Gracias Wikipedia, por tener la estructura base de un bitmap.

Por ello, y por mis limitaciones de tiempo, esfuerzo y aburrimiento, el script sólo soporta BMPs de 1bpp (aka blanco y negro). Pero creo es suficiente. Ya para parsear PNG necesitaría ojear la implementación de zlib, y parsear el PNG, y eso me da profunda pereza.

Características:
  • Reemplaza tilemap por parallax mapping. Soporta dos capas por el momento, una inferior y una superior.
  • Movimiento por pixel, con una imagen para determinar colisiones. Úsese sólo BMP a 1bpp, por favor. No hice soporte para nada más porque BMP es lo más fácil de parsear...
  • Cajas de colisiones para eventos y el jugador. Wii.


Instrucciones:
Pegar el script sobre Main. Luego de eso, no hay muchas opciones, pero sí algunas cosas que les pueden servir para personalizar las cosas.
- Al comienzo del script, hay un minimódulo llamado OZPM_Config. Hay una sóla cosa, y es las propiedades de la caja de colisión del personaje principal. De paso les explico cómo funcionan las cajas de colisiones aquí...

- Luego para cambiar la caja de colisión de un evento, se usa un comentario:
Código:
<collision_box: x y ancho alto>



Este comentario se carga al haber un cambio de página en el evento. Por lo que puede cambiar la caja de colisión automáticamente al activarse un interruptor al mismo tiempo que el gráfico.
- También se puede cambiar la caja de colisión de cualquier evento con este comando en un llamar script dentro de un mover evento:
Código:
@collision_box.set(x,y,ancho,alto)



- Aparte se puede usar:
Código:
$game_map.events[n].collision_box.set(x,y,ancho,alto)




COLISIONES CON EL MAPA
Ahora bien, las colisiones con el mapa. Éste sistema usa imágenes para determinar por dónde se puede pasar. Les pongo el ejemplo que viene con la demo.
Este es el parallax:
El parallax es la imagen principal. Funciona como cualquier parallax. Toma nota del nombre del parallax que usas, porque se usará para cargar a las otras 2 imágenes.

Ejemplo nombre de archivo: nombreParallax
Esta es la capa de colisiones:
La capa de colisiones es un bitmap en blanco y negro. Asegúrate de guardarlo en blanco y negro sólamente (es decir, 1bpp), sino el juego hará cosas raras, xD.

El blanco es por donde puedes pasar. El negro es por donde NO puedes pasar.
Ejemplo nombre de archivo: nombreParallax_c (asegúrate que sea BMP)
Y esta es la capa superior:
La capa superior es lo que queda por encima de todo, como las fogs del RMXP o una picture. Se usa para algunos elementos que quieras que pasen sobre el personaje SIEMPRE.

Ejemplo nombre de archivo: nombreParallax_t
¿Cómo trabajar en estos mapas?:
La idea es que al trabajar en los mapas, empieces trabajando en algo como Photoshop o Graphics Gale, o lo que te guste, preferiblemente que tenga soporte para varias capas.

Dentro de tu programa de preferencia podrás ya hacer una capa de suelo, detallarla y tal, luego crear una capa superior, y por último crear una capa y pintar todo por donde no quieres que pase el personaje con negro. Luego guardas cada capa por separado, y voilà. Lo bueno de las capas es que podrás ir viendo un poco más claramente cómo quedará todo :V.

Lo vuelvo a repetir xD. Asegúrate de guardar la capa de colisiones como un BMP de un sólo bit de color (blanco y negro). Sino, dará errores raros. Y no me sentiré responsable por ello ;D.

Script:
Código:
module OZPM_Config
  # Caja de colisión del héroe
  #                x    y  ancho alto
  COLLISION_BOX = [0,  0,  32,  32]
 
  # Opacidad de la caja superior
  UPPERLAYER_OPACITY = 128
end

#==============================================================================
# ** Game_Map
#------------------------------------------------------------------------------
#  This class handles maps. It includes scrolling and passage determination
# functions. The instance of this class is referenced by $game_map.
#==============================================================================

class Game_Map
  #--------------------------------------------------------------------------
  # * Setup
  #--------------------------------------------------------------------------
  alias ozpm_setup setup
  def setup(map_id)
    ozpm_setup(map_id)
    parse_collision_map
  end
  def parse_collision_map
    begin
      str = File.open("Graphics/Parallaxes/"+$game_map.parallax_name+"_c.bmp"){|file|
        file.readlines()[0]
      }
      a = str.slice(18,4)
      @pixel_coll_w = 0
      mult = 1
      a.each_byte{ |byte|
        @pixel_coll_w += byte*mult
        mult *= 256
      }
      b = str.slice(22,4)
      @pixel_coll_h = 0
      mult = 1
      b.each_byte{ |byte|
        @pixel_coll_h += byte*mult
        mult *= 256
      }
      c = str.slice(10,4)
      pix_ary_off = 0
      mult = 1
      c.each_byte{ |byte|
        pix_ary_off += byte*mult
        mult *= 256
      }
      print pix_ary_off
      str.slice!(0,pix_ary_off)
      print "Collision Bitmap Size: "+@pixel_coll_w.to_s+" x "+@pixel_coll_h.to_s
      @pixel_coll_data = []
      str.each_byte{|byte| @pixel_coll_data.push(byte) }
    rescue
      @pixel_coll_w = width * 32
      @pixel_coll_h = height * 32
      size = @pixel_coll_w/8 * @pixel_coll_h
      @pixel_coll_data = Array.new(size){ 0 }
    end
  end
  #--------------------------------------------------------------------------
  # * Calculate X Coordinate of Parallax Display Origin
  #--------------------------------------------------------------------------
  def parallax_ox(bitmap)
    if @parallax_loop_x
      @parallax_x * 32
    else
      w1 = [bitmap.width - Graphics.width, 0].max
      w2 = [width * 32 - Graphics.width, 1].max
      @parallax_x * 32 * w1 / w2
    end
  end
  #--------------------------------------------------------------------------
  # * Calculate Y Coordinate of Parallax Display Origin
  #--------------------------------------------------------------------------
  def parallax_oy(bitmap)
    if @parallax_loop_y
      @parallax_y * 32
    else
      h1 = [bitmap.height - Graphics.height, 0].max
      h2 = [height * 32 - Graphics.height, 1].max
      @parallax_y * 32 * h1 / h2
    end
  end
  #--------------------------------------------------------------------------
  # * Calculate X Coordinate After Loop Adjustment
  #--------------------------------------------------------------------------
  def round_x(x)
    loop_horizontal? ? (x + width) % width : x
  end
  #--------------------------------------------------------------------------
  # * Calculate Y Coordinate After Loop Adjustment
  #--------------------------------------------------------------------------
  def round_y(y)
    loop_vertical? ? (y + height) % height : y
  end
  #--------------------------------------------------------------------------
  # * Calculate X Coordinate Shifted One Tile in Specific Direction
  #  (No Loop Adjustment)
  #--------------------------------------------------------------------------
  def x_with_direction(x, d)
    x + (d == 6 ? 0.1 : d == 4 ? -0.1 : 0)
  end
  #--------------------------------------------------------------------------
  # * Calculate Y Coordinate Shifted One Tile in Specific Direction
  #  (No Loop Adjustment)
  #--------------------------------------------------------------------------
  def y_with_direction(y, d)
    y + (d == 2 ? 0.1 : d == 8 ? -0.1 : 0)
  end
  #--------------------------------------------------------------------------
  # * Calculate X Coordinate Shifted One Tile in Specific Direction
  #  (With Loop Adjustment)
  #--------------------------------------------------------------------------
  def round_x_with_direction(x, d)
    x + (d == 6 ? 0.1 : d == 4 ? -0.1 : 0)
  end
  #--------------------------------------------------------------------------
  # * Calculate Y Coordinate Shifted One Tile in Specific Direction
  #  (With Loop Adjustment)
  #--------------------------------------------------------------------------
  def round_y_with_direction(y, d)
    y + (d == 2 ? 0.1 : d == 8 ? -0.1 : 0)
  end
  #--------------------------------------------------------------------------
  # * Determine Valid Coordinates
  #--------------------------------------------------------------------------
  def valid?(x, y)
    x >= 0 && x <= width-1 && y >= 0 && y <= height-1
  end
  #--------------------------------------------------------------------------
  # * Determine Passability of Normal Character
  #    d:  direction (2,4,6,8)
  #    Determines whether the tile at the specified coordinates is passable
  #    in the specified direction.
  #--------------------------------------------------------------------------
 
  def sec_passable?(x, y, d)
    #check_passage(x, y, (1 << (d / 2 - 1)) & 0x0f)
   
    #the line width
    line_w = @pixel_coll_w / 8
   
    #let's pass them to actual 1-1 coordinates instead of tile coords.
    xx = x.to_i
    yy = (@pixel_coll_h - y).to_i #bitmaps are inverted vertically, hence this
   
    #get the sector
    sector = @pixel_coll_data[xx/8 + yy*line_w]
    #calculate the bit to be checked
    bit = 2 ** (xx%8)
   
    #and so...
    return sector&bit==0
  end
 
  def passable?(x, y, d)
    #check_passage(x, y, (1 << (d / 2 - 1)) & 0x0f)
   
    #the line width
    line_w = @pixel_coll_w / 8
   
    #let's pass them to actual 1-1 coordinates instead of tile coords.
    xx = (x*32).to_i
    yy = (@pixel_coll_h - (y*32)).to_i #bitmaps are inverted vertically, hence this
   
    #get the sector
    sector = @pixel_coll_data[xx/8 + yy*line_w]
    #calculate the bit to be checked
    bit = 2 ** (xx%8)
   
    #and so...
    return sector&bit==0
  end
  #--------------------------------------------------------------------------
  # * Determine if Airship can Land
  #--------------------------------------------------------------------------
  def airship_land_ok?(x, y)
    check_passage(x, y, 0x0800) && check_passage(x, y, 0x0f)
  end
  #--------------------------------------------------------------------------
  # * Determine Flag for All Layers at Specified Coordinates
  #--------------------------------------------------------------------------
  def layered_tiles_flag?(x, y, bit)
    layered_tiles(x.floor, y.floor).any? {|tile_id| tileset.flags[tile_id] & bit != 0 }
  end
  #--------------------------------------------------------------------------
  # * Determine if Ladder
  #--------------------------------------------------------------------------
  def ladder?(x, y)
    valid?(x, y) && layered_tiles_flag?(x.floor, y.floor, 0x20)
  end
  #--------------------------------------------------------------------------
  # * Determine if Bush
  #--------------------------------------------------------------------------
  def bush?(x, y)
    valid?(x, y) && layered_tiles_flag?(x.floor, y.floor, 0x40)
  end
  #--------------------------------------------------------------------------
  # * Determine if Counter
  #--------------------------------------------------------------------------
  def counter?(x, y)
    valid?(x, y) && layered_tiles_flag?(x.floor, y.floor, 0x80)
  end
  #--------------------------------------------------------------------------
  # * Determine if Damage Floor
  #--------------------------------------------------------------------------
  def damage_floor?(x, y)
    valid?(x, y) && layered_tiles_flag?(x.floor, y.floor, 0x100)
  end
  #--------------------------------------------------------------------------
  # * Get Terrain Tag
  #--------------------------------------------------------------------------
  def terrain_tag(x, y)
    return 0 unless valid?(x, y)
    layered_tiles(x.floor, y.floor).each do |tile_id|
      tag = tileset.flags[tile_id] >> 12
      return tag if tag > 0
    end
    return 0
  end
  #--------------------------------------------------------------------------
  # * Get Region ID
  #--------------------------------------------------------------------------
  def region_id(x, y)
    valid?(x, y) ? @map.data[x.floor, y.floor, 3] >> 8 : 0
  end
end

#==============================================================================
# ** Game_CharacterBase
#------------------------------------------------------------------------------
#  This base class handles characters. It retains basic information, such as
# coordinates and graphics, shared by all characters.
#==============================================================================

class Game_CharacterBase
  attr_accessor :collision_box
  #--------------------------------------------------------------------------
  # * Initialize Public Member Variables
  #--------------------------------------------------------------------------
  alias ozpm_init_public_members init_public_members
  def init_public_members
    ozpm_init_public_members
    @collision_box = Rect.new(0,0,32,32)
  end
  #--------------------------------------------------------------------------
  # * Determine if Passable
  #    d : Direction (2,4,6,8)
  #--------------------------------------------------------------------------
  def passable?(x, y, d)
    x2 = $game_map.round_x_with_direction(x, d)
    y2 = $game_map.round_y_with_direction(y, d)
    dx = dy = 0
    return false unless $game_map.valid?(x2, y2)
    return true if @through || debug_through?
    case d
    when 2
      yy = @collision_box.height+@collision_box.y
      dx = 0
      dy = 0.1
      (@collision_box.x .. @collision_box.width+@collision_box.x).each{|xx|
        return false unless sec_map_passable?(x*32+xx, y*32+yy, d)
        return false unless sec_map_passable?(x*32+xx+dx, y*32+yy+dy, d)
      }
    when 4
      xx = 0
      dx = -0.1
      dy = 0
      (@collision_box.y .. @collision_box.height+@collision_box.y).each{|yy|
        return false unless sec_map_passable?(x*32+xx, y*32+yy, d)
        return false unless sec_map_passable?(x*32+xx+dx, y*32+yy+dy, d)
      }
    when 6
      xx = @collision_box.width+@collision_box.x
      dx = 0.1
      dy = 0
      (@collision_box.y .. @collision_box.height+@collision_box.y).each{|yy|
        return false unless sec_map_passable?(x*32+xx, y*32+yy, d)
        return false unless sec_map_passable?(x*32+xx+dx, y*32+yy+dy, d)
      }
    when 8
      yy = 0
      dx = 0
      dy = -0.1
      (@collision_box.x .. @collision_box.width+@collision_box.x).each{|xx|
        return false unless sec_map_passable?(x*32+xx, y*32+yy, d)
        return false unless sec_map_passable?(x*32+xx+dx, y*32+yy+dy, d)
      }
    end
    return false if collide_with_characters?(x, y)
    return false if collide_with_characters?(x+dx, y+dy)
    return true
  end
  #--------------------------------------------------------------------------
  # * A copy of "Map is Passable", it uses 1x1 coords instead of tile coords.
  #    d : Direction (2,4,6,8)
  #--------------------------------------------------------------------------
  def sec_map_passable?(x, y, d)
    $game_map.sec_passable?(x, y, d)
  end
  #--------------------------------------------------------------------------
  # * Detect Collision with Event
  #--------------------------------------------------------------------------
  def collide_with_events?(x, y)
    $game_map.events.each{|i,ev|
      next if ev==self
      if (ev.normal_priority? || self.is_a?(Game_Event))
        return true if check_bbox(ev,x,y)
      end
    }
    return false
  end
  #--------------------------------------------------------------------------
  # * Checks if there is collision between collision boxes
  #--------------------------------------------------------------------------
  def check_bbox(ev,x,y)
    x1 = @collision_box.x + (x * 32)
    y1 = @collision_box.y + (y * 32)
    x2 = @collision_box.width + x1
    y2 = @collision_box.height + y1
    ex1 = ev.collision_box.x + (ev.x * 32)
    ey1 = ev.collision_box.y + (ev.y * 32)
    ex2 = ev.collision_box.width + ex1
    ey2 = ev.collision_box.height + ey1
    return ((x1 <= ex1 && ex1 <= x2) && (y1 <= ey1 && ey1 <= y2)) ||
            ((x1 <= ex2 && ex2 <= x2) && (y1 <= ey2 && ey2 <= y2)) ||
            ((x1 <= ex1 && ex1 <= x2) && (y1 <= ey2 && ey2 <= y2)) ||
            ((x1 <= ex2 && ex2 <= x2) && (y1 <= ey1 && ey1 <= y2)) ||
            ((ex1 <= x1 && x1 <= ex2) && (ey1 <= y1 && y1 <= ey2)) ||
            ((ex1 <= x2 && x2 <= ex2) && (ey1 <= y2 && y2 <= ey2)) ||
            ((ex1 <= x1 && x1 <= ex2) && (ey1 <= y2 && y2 <= ey2)) ||
            ((ex1 <= x2 && x2 <= ex2) && (ey1 <= y1 && y1 <= ey2))
  end
  def reset_collision_box
    @collision_box.set(0,0,32,32)
  end
end

#==============================================================================
# ** Game_Player
#------------------------------------------------------------------------------
#  This class handles the player. It includes event starting determinants and
# map scrolling functions. The instance of this class is referenced by
# $game_player.
#==============================================================================

class Game_Player < Game_Character
  alias ozpm_initialize initialize
  def initialize
    ozpm_initialize
    @collision_box.set(*OZPM_Config::COLLISION_BOX)
  end
  #--------------------------------------------------------------------------
  # * Trigger Map Event
  #    triggers : Trigger array
  #    normal  : Is priority set to [Same as Characters] ?
  #--------------------------------------------------------------------------
  def start_map_event(x, y, triggers, normal)
    return if $game_map.interpreter.running?
    $game_map.events.each do |i, event|
      return unless check_bbox(event, x, y)
      if event.trigger_in?(triggers) && event.normal_priority? == normal
        event.start
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Processing of Movement via Input from Directional Buttons
  #--------------------------------------------------------------------------
  def move_by_input
    return if !movable? || $game_map.interpreter.running?
    case Input.dir8
    when 1
      move_diagonal(4,2)
    when 3
      move_diagonal(6,2)
    when 7
      move_diagonal(4,8)
    when 9
      move_diagonal(6,8)
    else
      move_straight(Input.dir4)
    end
    #move_straight(Input.dir4) if Input.dir4 > 0
  end
  #--------------------------------------------------------------------------
  # * Get Encounter Progress Value
  #--------------------------------------------------------------------------
  def encounter_progress_value
    value = $game_map.bush?(@x, @y) ? 0.2 : 0.1
    value *= 0.5 if $game_party.encounter_half?
    value *= 0.5 if in_ship?
    value
  end
end

#==============================================================================
# ** Game_Follower
#------------------------------------------------------------------------------
#  This class handles followers. A follower is an allied character, other than
# the front character, displayed in the party. It is referenced within the
# Game_Followers class.
#==============================================================================

class Game_Follower < Game_Character
  #--------------------------------------------------------------------------
  # * Pursue Preceding Character
  #--------------------------------------------------------------------------
  def chase_preceding_character
    unless moving?
      sx = distance_x_from(@preceding_character.x)
      sy = distance_y_from(@preceding_character.y)
      if sx.abs >= 0.5 && sy.abs >= 0.5
        move_diagonal(sx > 0 ? 4 : 6, sy > 0 ? 8 : 2)
      elsif sx.abs >= 0.5
        move_straight(sx > 0 ? 4 : 6)
      elsif sy.abs >= 0.5
        move_straight(sy > 0 ? 8 : 2)
      end
    end
  end
end

#==============================================================================
# ** Game_Followers
#------------------------------------------------------------------------------
#  This is a wrapper for a follower array. This class is used internally for
# the Game_Player class.
#==============================================================================

class Game_Followers
  def collide?(ev, x, y)
    #visible_folloers.any? {|follower| follower.pos?(x, y) }
    visible_folloers.any? {|follower| follower.check_bbox(ev,x,y) }
  end
end

#==============================================================================
# ** Game_Event
#------------------------------------------------------------------------------
#  This class handles events. Functions include event page switching via
# condition determinants and running parallel process events. Used within the
# Game_Map class.
#==============================================================================

class Game_Event < Game_Character
  #--------------------------------------------------------------------------
  # * Detect Collision with Player (Including Followers)
  #--------------------------------------------------------------------------
  def collide_with_player_characters?(x, y)
    if normal_priority? # && $game_player.collide?(x, y)
      return check_bbox($game_player,x,y)
    end
  end
  #--------------------------------------------------------------------------
  # * Clear Event Page Settings
  #--------------------------------------------------------------------------
  alias ozpm_clear_page_settings clear_page_settings
  def clear_page_settings
    ozpm_clear_page_settings
    reset_collision_box
  end
  #--------------------------------------------------------------------------
  # * Set Up Event Page Settings
  #--------------------------------------------------------------------------
  alias ozpm_setup_page_settings setup_page_settings
  def setup_page_settings
    ozpm_setup_page_settings
    check_coll_data
  end
  #--------------------------------------------------------------------------
  # * Determine if Touch Event is Triggered
  #--------------------------------------------------------------------------
  def check_event_trigger_touch(x, y)
    return if $game_map.interpreter.running?
    if @trigger == 2 && check_bbox($game_player, x, y)#$game_player.pos?(x, y)
      start if !jumping? && normal_priority?
    end
  end
  #--------------------------------------------------------------------------
  # * Looks for collision data at any commentary command at the actual page.
  #  If there are two comments with the proper tag <collision_box: n n n n>
  #  last one will be the one in effect.
  #--------------------------------------------------------------------------
  def check_coll_data
    @list.each{ |command|
      if (command.code == 108)||(command.code == 408)
        command.parameters[0] =~ /<(?:COLLISION_BOX|collision_box):[ ]((?:-|)\d+)[ ]((?:-|)\d+)[ ]((?:-|)\d+)[ ]((?:-|)\d+)>/i
        if $1&&$2&&$3&&$4
          print "Sausage\n"
          @collision_box.set($1.to_i, $2.to_i, $3.to_i, $4.to_i)
        end
      end
    }
  end
end

#==============================================================================
# ** Spriteset_Map
#------------------------------------------------------------------------------
#  This class brings together map screen sprites, tilemaps, etc. It's used
# within the Scene_Map class.
#==============================================================================

class Spriteset_Map
  #--------------------------------------------------------------------------
  # * Create Tilemap - Punch in da face.
  #--------------------------------------------------------------------------
  def create_tilemap;;end
  #--------------------------------------------------------------------------
  # * Create Parallax
  #--------------------------------------------------------------------------
  def create_parallax
    @parallax = Sprite.new(@viewport1)
    @top_parallax = Sprite.new(@viewport1)
    @parallax.z = -100
    @top_parallax.z = 1000
  end
  #--------------------------------------------------------------------------
  # * Free Tilemap
  #--------------------------------------------------------------------------
  def dispose_tilemap;;end
  #--------------------------------------------------------------------------
  # * Free Parallax
  #--------------------------------------------------------------------------
  def dispose_parallax
    @parallax.bitmap.dispose if @parallax.bitmap
    @parallax.dispose
    @top_parallax.bitmap.dispose if @top_parallax.bitmap
    @top_parallax.dispose
  end
  #--------------------------------------------------------------------------
  # * Update Tileset - Punch in da faez.
  #--------------------------------------------------------------------------
  def update_tileset;;end
  #--------------------------------------------------------------------------
  # * Update Tilemap - Punch in da faez.
  #--------------------------------------------------------------------------
  def update_tilemap;;end
  #--------------------------------------------------------------------------
  # * Update Parallax
  #--------------------------------------------------------------------------
  def update_parallax
    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)
      @top_parallax.bitmap.dispose if @top_parallax.bitmap
      @top_parallax.bitmap = Cache.parallax(@parallax_name+"_t") rescue nil
      @top_parallax.opacity = OZPM_Config::UPPERLAYER_OPACITY
     
      Graphics.frame_reset
    end
    @parallax.ox = $game_map.parallax_ox(@parallax.bitmap)
    @parallax.oy = $game_map.parallax_oy(@parallax.bitmap)
    @top_parallax.ox = $game_map.parallax_ox(@parallax.bitmap)
    @top_parallax.oy = $game_map.parallax_oy(@parallax.bitmap)
  end
end




Demo:
https://dl.dropboxusercontent.com/u/13006190/OZ%27s%20PM.7z
Ésta demo es funcional, al menos para ciertos tipos de juegos. Los vehículos no funcionan bien, y el tren de charas tiene algunos problemas, que creo que mejor dicho necesitan reimplementar una partecita del sistema xd (funciona, pero hay un non-crashing bug, digamos xD). Por ahora los dejo así :V.

Licencia:
CC SA - Libre uso para comercial o no comercial. Derivados deben ser compartidos de la misma forma.

FAQ:
Ninguna por el momento.

Ufffff (ffffff), espero no haberme olvidado nada, pero en fin, salut.

orochii
Caballero Shiro
Caballero Shiro

0/3

Créditos 6045

Gracias : 266

http://drekirokr.weebly.com/

Volver arriba Ir abajo

Re: [VXA] Movimiento pixel por pixel (BETA)

Mensaje por orochii el 2014-05-31, 18:20

Por si acaso a alguien no le importa, he actualizado el post, ahora es más plug and play como a todos no les gusta :V.

Y ya está lo de las colisiones. No sé, si alguien quiere probar, y wea, pos pruebe y wea. :V. Si no les interesa, lo dejo morir, total ya tiene lo que a mí me interesa que tenga xD.

orochii
Caballero Shiro
Caballero Shiro

0/3

Créditos 6045

Gracias : 266

http://drekirokr.weebly.com/

Volver arriba Ir abajo

Re: [VXA] Movimiento pixel por pixel (BETA)

Mensaje por Metalero el 2014-05-31, 19:14

Lo testee y pareceria funcionar bastante bien... al menos no vi ningun fallo en el demo (tampoco me esforcé mucho por encontrar uno XD)

Lo unico que se me ocurre que se le podria agregar y supongo que no seria tan dificil, es la posibilidad de setear con alguna constante el movimiento minimo en pixeles. O sea, en lugar de que este fijado en 1 pixel, tener la posibilidad de que el paso sea de no se... 8 pixeles por ejemplo.

Personalmente, para un rpg con animacion de movimiento de chara como el maker, el movimiento a pixel se ve feo, pero si uno permite que se pueda mover un poco mas (el Golden Sun tenia algo asi me parece), queda basante bueno, por que el paso no es ni muy grande ni muy chico.

Supongo que para cambiar esto habria que modificar ese "0.1" que anda dando vueltas por ahi.

Buen aporte!

_________________

Metalero
Administrador
Administrador



Créditos 1715

Gracias : 98

Volver arriba Ir abajo

Re: [VXA] Movimiento pixel por pixel (BETA)

Mensaje por Usuario Oculto el 2014-05-31, 20:01

Orochii, gracias por el script, justo ahora que he adquirido el ACE de manera legítima, tengo ganas de compilar una biblioteca de scripts, en especial aquellos con licencia libre para comerciar. ; )

Lo probaré y si encuentro algo que comentar, lo haré.

Usuario Oculto
Soñador
Soñador

0/3

Créditos 631

Gracias : 14

Volver arriba Ir abajo

Re: [VXA] Movimiento pixel por pixel (BETA)

Mensaje por Trequiell el 2014-05-31, 21:01

Hola Orochii.
Me ha parecido muy interesante el script.
Digámos que solo quiero hacer uso de la característica de la caja de colisiones.

Como podría hacer ésto?.

Gracias por el aporte compañero.

Trequiell
Soñador
Soñador

0/3

Créditos 138

Gracias : 21

Volver arriba Ir abajo

Re: [VXA] Movimiento pixel por pixel (BETA)

Mensaje por orochii el 2014-05-31, 21:44

@Metalero: Pos... lo que podría hacer es ponerle soporte de 8 direcciones a los gráficos, y de paso soporte para cualquier # de frames/dirección. Quiza parseando el nombre del archivo, como de costumbre xD. En fin, es un buen punto.

@Usuario Oculto: Adelante, la distribución nunca está mal (?).

@Trequiell: El problema de sólo usar la parte de colisiones es que está pensada en funcionar con el movimiento por pixel, para hacerla de forma que funcione con el movimiento por tiles, sería no hacer caja de colisiones, sino una propiedad (?) de ancho/alto en tiles. Digamos que no es algo que contemple este script.

Salut.

orochii
Caballero Shiro
Caballero Shiro

0/3

Créditos 6045

Gracias : 266

http://drekirokr.weebly.com/

Volver arriba Ir abajo

Re: [VXA] Movimiento pixel por pixel (BETA)

Mensaje por Contenido patrocinado Hoy a las 05:03


Contenido patrocinado


Volver arriba Ir abajo

Ver el tema anterior Ver el tema siguiente Volver arriba


 :: RPG Maker :: Scripts

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