Mundo Maker
¡Bienvenid@ a Mundo Maker!

¿Quieres aprender todo sobre el RPG Maker?



Regístrate y forma parte de Mundo Maker.

[Colectivo] Hextiles (para XP)

Página 1 de 2. 1, 2  Siguiente

Ver el tema anterior Ver el tema siguiente Ir abajo

RPG Maker XP [Colectivo] Hextiles (para XP)

Mensaje por Wecoc el 2013-08-04, 11:57

Se hicieron ya cinco o seis colectivos gráficos, y dos de musicales, y en general tuvieron éxito (aunque muchos se quedaran a medias de momento, pero bueno al menos la gente participó xD)

Ahora vengo a proponer un colectivo... ¡para scripters! xD

Mi propuesta es hacer un script o serie de scripts funcionales que permitan hacer un juego en hexatiles (o hextiles). Que yo sepa nunca se ha hecho antes, así que sería interesante hacerlo. Es cierto que mapear se convertiría en un reto, pero jolines, es lo que hay xD

Lo propongo para XP porque la mayoría de scripters del foro lo conocen.

Yo solo no sabría hacerlo, es verdad xD, pero no lo propongo para que me lo hagáis por mí, sinó para ver como trabajamos juntos los scripters del foro.

Cosas necesarias en un sistema de Hextiles

- Nuevo tilemap por hexatiles
- Reposición de los eventos y el chara en el mapa
- Scroll de 24, 32 y no de 32, 32 (la x en hexatiles es width - width/4, es decir 24, no 32)
- Movimiento del personaje (como se necesitan 6 direcciones había pensado en usar QWEASD, así sería como el sistema WASD pero ampiado)

Cosas alternativas en un sistema de Hextiles

- Pathfinding con el ratón

barraseparatoriabarraseparatoriabarraseparatoriaorochiibarraseparatoriabarraseparatoriaquehacesleyendoesosoloesunabarraseparatoriabarraseparatoriacadadiaestoymasloco

No empezaré un colectivo sin haber tirado antes una primera piedra, siempre se da algo con lo que empezar.

Hice un pequeño script de tilemap por hexatiles muy sencillo.

Código:
#==============================================================================
# Hextiles
#------------------------------------------------------------------------------
# by Wecoc (inspired on Derk-Jan Karrenbeld's Tilemap)
#------------------------------------------------------------------------------
# La prioridad 2 es la nueva prioridad 1, la prioridad 3 es la 2 y
# así sucesivamente, mientras que la prioridad 1 es de suelo como la 0.
# Hice eso porque la diferencia es que la 1 permite sobrepasar los márgenes
# del hexatile por el hecho de ser un sprite independiente, mientras que la 0
# como es parte del "fondo" de tiles no.
#------------------------------------------------------------------------------
# Los autotiles leen los frames de dos en dos porque cada frame tiene dos
# variedades de autotile según su y.
#==============================================================================

class Tilemap
 attr_reader :tileset
 attr_reader :autotiles
 attr_reader :flash_data
 attr_reader :priorities
 attr_reader :visible
 attr_reader :ox, :oy
 attr_writer :autotiles

 WindowRect = Rect.new(0,0,640,480)
 BitmapRect = Rect.new(0,0,640 + 64, 480 + 64)
 
 BitmapWindowOffsetX = (BitmapRect.width-WindowRect.width)/2/24
 BitmapWindowOffsetY = (BitmapRect.height-WindowRect.height)/2/32

 AutotileLength = 10 # Frames per autotile frame
 
 MAX_MapWidth = 50 # Max of tiles the hextile system supports
 MAX_MapHeight = 50 # Max of tiles the hextile system supports
 
 Autotiles = [
  [ [27, 28, 33, 34], [ 5, 28, 33, 34], [27,  6, 33, 34], [ 5,  6, 33, 34],
    [27, 28, 33, 12], [ 5, 28, 33, 12], [27,  6, 33, 12], [ 5,  6, 33, 12] ],
  [ [27, 28, 11, 34], [ 5, 28, 11, 34], [27,  6, 11, 34], [ 5,  6, 11, 34],
    [27, 28, 11, 12], [ 5, 28, 11, 12], [27,  6, 11, 12], [ 5,  6, 11, 12] ],
  [ [25, 26, 31, 32], [25,  6, 31, 32], [25, 26, 31, 12], [25,  6, 31, 12],
    [15, 16, 21, 22], [15, 16, 21, 12], [15, 16, 11, 22], [15, 16, 11, 12] ],
  [ [29, 30, 35, 36], [29, 30, 11, 36], [ 5, 30, 35, 36], [ 5, 30, 11, 36],
    [39, 40, 45, 46], [ 5, 40, 45, 46], [39,  6, 45, 46], [ 5,  6, 45, 46] ],
  [ [25, 30, 31, 36], [15, 16, 45, 46], [13, 14, 19, 20], [13, 14, 19, 12],
    [17, 18, 23, 24], [17, 18, 11, 24], [41, 42, 47, 48], [ 5, 42, 47, 48] ],
  [ [37, 38, 43, 44], [37,  6, 43, 44], [13, 18, 19, 24], [13, 14, 43, 44],
    [37, 42, 43, 48], [17, 18, 47, 48], [13, 18, 43, 48], [ 1,  2,  7,  8] ]
 ]

 def initialize(viewport = nil, rpgmap = nil)
  @autotiles    = Array.new(6, nil)
  @oldautotiles = Array.new(6, nil)
  @viewport  = viewport ? viewport : Viewport.new(WindowRect)
  @sprite = Sprite.new(@viewport)
  @sprite.bitmap = Bitmap.new(MAX_MapWidth * 24, MAX_MapHeight * 32 + 64)
  @priority_ids    = {}  # Priority ids
  @normal_tiles    = {}  # Non-auto tile bitmaps
  @auto_tiles      = {}  # Autotile bitmaps
  @priority_sprites = []  # Priority Sprites
  @autotile_sprites = []  # Autotile Sprites
  @flashing_sprites = []  # Flashing Sprites
  @disposed  = false
  @visible    = true
  @flashing  = true
  @can_draw  = true
  @ox, @oy = 0, 0
 end

 def sprite_bitmap
  return @sprite.bitmap
 end

 def data_tilesets
  $data_tilesets ||= load_data("Data/Tilesets.rxdata")
 end

 def disposed?
  @disposed
 end

 def dispose
  for sprite in [@sprite] + @normal_tiles.values + @auto_tiles.values + @priority_sprites + @autotile_sprites + @flashing_sprites
    sprite = sprite[0] if sprite.is_a?(Array)
    sprite.dispose if sprite.is_a?(Bitmap)
  end
  @priority_ids    = {}  # Priority ids
  @normal_tiles    = {}  # Non-auto tile bitmaps
  @priority_sprites = []  # Priority Sprites
  @autotile_sprites = []  # Autotile Sprites
  @flashing_sprites = []  # Flashing Sprites
  @disposed = true
 end

 def visible?
  @visible
 end

 def autotiles_changed?
  @oldautotiles != @autotiles
 end

 def visible=(value)
  @visible = value
  for sprite in [@sprite] + @priority_sprites + @autotile_sprites + @flashing_sprites
    sprite = sprite[0] if sprite.is_a?(Array)
    sprite.visible = value
  end
 end

 def tileset=(value)
  return if @tileset == value
  value = value.tileset_name if value.is_a?(RPG::Tileset)
  @tileset = RPG::Cache.tileset(value) if value.is_a?(String)
  @tileset = value if value.is_a?(Bitmap)
  redraw_tileset if @can_draw
 end

 def priorities=(value)
  return if @priorities == value
  @priorities = value
  redraw_priorities if @can_draw
 end

 def flash_data=(*coord, &value)
  return if @flash_data[coord[0],coord[1]] == value
  flashing = !@flash_data[x,y].nil?
  @flash_data[x,y] = value
 end

 def map_data
  @map_data
 end

 def map_data=(value)
  return if @map_data == value
  @map_data = value
  @flash_data = Table.new(@map_data.xsize, @map_data.ysize)
  draw_region if @can_draw and @priorities and @tileset
 end

 def tile_id(x, y, z)
  return map_data[x, y, z]
 end

 def priority(*args)
  return @priorities[args[0]] if args.size == 1
  return @priorities[tile_id(args[0], args[1], args[2])]
 end

 def redraw_tileset
  sprite_bitmap.clear
  @normal_tiles.clear
  @auto_tiles.clear
  (@autotile_sprites + @priority_sprites).each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
  @autotile_sprites.clear; @priority_sprites.clear
  draw_region if @can_draw and @priorities and @tileset
 end

 def redraw_priorities
  (@autotile_sprites + @priority_sprites).each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
  @priority_sprites.clear; @autotile_sprites.clear
  @priority_ids.clear
  for z in 0...3
    for y in 0...map_data.ysize
      for x in 0...map_data.xsize
        next if (id = tile_id(x, y, z)) == 0
        next if (p = priority(id)) == 0
        @priority_ids[id] = p
      end
    end
  end
  draw_region if @can_draw and @priorities and @tileset
 end

 def redraw_autotiles
  @auto_tiles.clear
  @autotile_sprites.each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
  @autotile_sprites.clear
  @oldautotiles = @autotiles
  draw_region if @can_draw and @priorities and @tileset
 end

 def draw_current_region
  left_x = @ox / 24
  top_y = @oy / 32
  @sprite.ox = left_x * 24 + @ox % 24 + 32
  @sprite.oy = top_y * 32 + @oy % 32 + 48
  for i in 0...@priority_sprites.size
    @priority_sprites[i][0].ox = left_x * 24 + @ox % 24 + 32
    @priority_sprites[i][0].oy = top_y * 32 + @oy % 32 + 48
  end
 end

 def draw_region
  left_x = @ox / 24
  top_y = @oy / 32
  @sprite.ox = BitmapWindowOffsetX * 32
  wecoc_y = left_x%2==1 ? 16 : 0
  @sprite.oy = BitmapWindowOffsetY * 32 + wecoc_y
  for x in 0...map_data.xsize+1
    for y in 0...map_data.ysize+1
      for z in 0..2
        draw_tile(x, y , tile_id(x + left_x - BitmapWindowOffsetX,y + top_y - BitmapWindowOffsetY,z), x + left_x - BitmapWindowOffsetX , y + top_y - BitmapWindowOffsetY, z)
      end
    end
  end
  @sprite.update
  Graphics.frame_reset
 end

 def draw_tile(x, y, tile_id, tx, ty, tz, src_bitmap = nil)
  return if x < 0 or y < 0
  return if tile_id == nil
  return draw_autotile(x, y, tile_id, tx, ty, tz, bitmap = bitmap) if tile_id < 384
  if (src_bitmap = @normal_tiles[tile_id]).nil?
    src_bitmap = Bitmap.new(32, 32)
    src_rect = Rect.new((tile_id - 384) % 8 * 32, (tile_id - 384) / 8 * 32,32,32)
    src_bitmap.blt(0, 0, @tileset, src_rect)
    @normal_tiles[tile_id] = src_bitmap
  end
  wecoc_y = x%2==0 ? 16 : 0
  if @priority_ids[tile_id].nil?
    sprite_bitmap.blt(x * 24, y * 32 + wecoc_y, src_bitmap, Rect.new(0,0,32,32))
  else
    sprite = Sprite.new(@viewport)
    sprite.visible = visible
    sprite.bitmap = src_bitmap
    sprite.x = x * 24
    sprite.y = y * 32 + wecoc_y
    sprite.ox = @ox + @ox % 24 + 32
    sprite.oy = @oy + @oy % 32 + 48
    sprite.z = @viewport.z + y * @priority_ids[tile_id] * 32 - 32
    @priority_sprites << [sprite, tx, ty, tz]
  end
 end

 def draw_autotile(x, y, tile_id, tx, ty, tz, src_bitmap = nil)
  return if x < 0 or y < 0
  return if tile_id == nil or tile_id >= 384
  return if tile_id == 0
  autotile = @autotiles[tile_id/48-1]
  return if autotile.nil? or autotile.disposed?
  if autotile.height == 32
    frames = autotile.width / (32 * 2)
  else
    frames = autotile.width / (96 * 2)
  end
  if x%2 == 0
    start_frame = ((Graphics.frame_count/AutotileLength) % frames) + 1
  else
    start_frame = (Graphics.frame_count/AutotileLength) % frames
  end
  if (src_bitmap_array = @auto_tiles[tile_id]).nil?
    @auto_tiles[tile_id] = []
    if autotile.height == 32
      for i in 0...frames*2
        this_frame_bitmap = Bitmap.new(32,32)
        src_rect = Rect.new(i * 32, 0, 32, 32)
        this_frame_bitmap.blt(0, 0, autotile, src_rect)
        @auto_tiles[tile_id] << this_frame_bitmap
      end
      src_bitmap_array = @auto_tiles[tile_id]
    else
      for i in 0...frames*2
        this_frame_bitmap = Bitmap.new(32,32)
        tiles = Autotiles[(tile_id % 48)>>3][(tile_id % 48)&7]
        for j in 0...4
          tile_position = tiles[j] - 1
          src_rect = Rect.new(tile_position % 6 * 16 + i * 96, tile_position / 6 * 16, 16, 16)
          this_frame_bitmap.blt(j % 2 * 16, j / 2 * 16 , autotile, src_rect)
        end
        @auto_tiles[tile_id][i] = this_frame_bitmap
      end
      src_bitmap_array = @auto_tiles[tile_id]
    end
  end
  src_bitmap = src_bitmap_array[start_frame]
  return if src_bitmap.nil?
  wecoc_y = x%2==0 ? 16 : 0
  if @priority_ids[tile_id].nil? and autotile.width == 32
    sprite_bitmap.blt(x * 24, y * 32 + wecoc_y, src_bitmap, Rect.new(0,0,32,32))
  else
    priority = (@priority_ids[tile_id] or 0)
    sprite = Sprite.new(@viewport)
    sprite.visible = visible
    sprite.bitmap = src_bitmap
    sprite.x = x * 24
    sprite.y = y * 32 + wecoc_y
    sprite.ox = @ox + @ox % 24 + 32
    sprite.oy = @oy + @oy % 32 + 48
    sprite.z = @viewport.z + y * priority * 32 - 32
    @autotile_sprites << [sprite, tx, ty, tz, start_frame]
  end
 end

 def get_update_autotile(tile_id, start_frame)
  return if tile_id == nil or tile_id >= 384
  return if tile_id == 0
  autotile = @autotiles[tile_id/48-1]
  return if autotile.nil? or autotile.disposed?
  if autotile.height == 32
    frames = autotile.width / (32 * 2)
  else
    frames = autotile.width / (96 * 2)
  end
 
  current_frame = (Graphics.frame_count/AutotileLength) % frames * 2
  src_bitmap = @auto_tiles[tile_id][current_frame + start_frame]
  return src_bitmap 
 end

 def ox=(value)
  return unless @ox != value
  @ox = value
 end

 def oy=(value)
  return unless @oy != value
  @oy = value
 end

 def update
  redraw_autotiles if autotiles_changed?
  return if not visible?
  update_autotiles if (Graphics.frame_count % AutotileLength) == 0
  draw_current_region
 end

 def update_autotiles
  left_x = @ox / 32
  top_y = @oy / 32
  for sprite in @autotile_sprites
    real_sprite, tx, ty, tz, start_frame = sprite
    tile_id = tile_id(tx, ty, tz)
    real_sprite.bitmap = get_update_autotile(tile_id, start_frame)
  end
 end
end
Ahí el template que he hecho para testear el script:


Última edición por Wecoc el 2013-08-12, 02:52, editado 1 vez
avatar
Wecoc
Administrador
Administrador



Créditos 12211

Gracias : 632

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por orochii el 2013-08-04, 16:52

No sé si iré a hacer algo con el script xD, pero al menos me puse a probarlo. Hay un bug por ahora que sucede cuando empiezas en una posición donde el offset de la pantalla es distinto a cero (osea, cuando empiezas con la pantalla scrolleada).

Hice un mapa de 27x16 (para lograr llenar la pantalla completa con tiles), pero la posición de inicio estaba abajo, y por lo tanto la pantalla iniciaba scrolleada, y resultó (por alguna cosa random xd) en que renderizó dos veces el arbol xD?. Lo extraño es que cuando hago scroll no pasa nada raro, es decir, no es que los tiles se posicionen mal.

Si encuentro ganas intentaré hacer algo :'D, sino me quedo como tester xD,
Orochii Zouveleki
avatar
orochii
Reportero

0/3

Créditos 7724

Gracias : 436

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por Wecoc el 2013-08-04, 17:22

Nah, eso fue una tontería, me dejé un *@ox y un *@oy
xDD

Código:
#==============================================================================
# Hextiles
#------------------------------------------------------------------------------
# by Wecoc (inspired on Derk-Jan Karrenbeld's Tilemap)
#------------------------------------------------------------------------------
# La prioridad 2 es la nueva prioridad 1, la prioridad 3 es la 2 y
# así sucesivamente, mientras que la prioridad 1 es de suelo como la 0.
# Hice eso porque la diferencia es que la 1 permite sobrepasar los márgenes
# del hexatile por el hecho de ser un sprite independiente, mientras que la 0
# como es parte del "fondo" de tiles no.
#------------------------------------------------------------------------------
# Los autotiles leen los frames de dos en dos porque cada frame tiene dos
# variedades de autotile según su y.
#==============================================================================

class Tilemap
  attr_reader :tileset
  attr_reader :autotiles
  attr_reader :flash_data
  attr_reader :priorities
  attr_reader :visible
  attr_reader :ox, :oy
  attr_writer :autotiles

  WindowRect = Rect.new(0,0,640,480)
  BitmapRect = Rect.new(0,0,640 + 64, 480 + 64)
  
  BitmapWindowOffsetX = (BitmapRect.width-WindowRect.width)/2/24
  BitmapWindowOffsetY = (BitmapRect.height-WindowRect.height)/2/32

  AutotileLength = 10 # Frames per autotile frame
  
  MAX_MapWidth = 50 # Max of tiles the hextile system supports
  MAX_MapHeight = 50 # Max of tiles the hextile system supports
  
  Autotiles = [
    [ [27, 28, 33, 34], [ 5, 28, 33, 34], [27,  6, 33, 34], [ 5,  6, 33, 34],
      [27, 28, 33, 12], [ 5, 28, 33, 12], [27,  6, 33, 12], [ 5,  6, 33, 12] ],
    [ [27, 28, 11, 34], [ 5, 28, 11, 34], [27,  6, 11, 34], [ 5,  6, 11, 34],
      [27, 28, 11, 12], [ 5, 28, 11, 12], [27,  6, 11, 12], [ 5,  6, 11, 12] ],
    [ [25, 26, 31, 32], [25,  6, 31, 32], [25, 26, 31, 12], [25,  6, 31, 12],
      [15, 16, 21, 22], [15, 16, 21, 12], [15, 16, 11, 22], [15, 16, 11, 12] ],
    [ [29, 30, 35, 36], [29, 30, 11, 36], [ 5, 30, 35, 36], [ 5, 30, 11, 36],
      [39, 40, 45, 46], [ 5, 40, 45, 46], [39,  6, 45, 46], [ 5,  6, 45, 46] ],
    [ [25, 30, 31, 36], [15, 16, 45, 46], [13, 14, 19, 20], [13, 14, 19, 12],
      [17, 18, 23, 24], [17, 18, 11, 24], [41, 42, 47, 48], [ 5, 42, 47, 48] ],
    [ [37, 38, 43, 44], [37,  6, 43, 44], [13, 18, 19, 24], [13, 14, 43, 44],
      [37, 42, 43, 48], [17, 18, 47, 48], [13, 18, 43, 48], [ 1,  2,  7,  8] ]
  ]

  def initialize(viewport = nil, rpgmap = nil)
    @autotiles    = Array.new(6, nil)
    @oldautotiles = Array.new(6, nil)
    @viewport   = viewport ? viewport : Viewport.new(WindowRect)
    @sprite = Sprite.new(@viewport)
    @sprite.bitmap = Bitmap.new(MAX_MapWidth * 24, MAX_MapHeight * 32 + 64)
    @priority_ids     = {}  # Priority ids
    @normal_tiles     = {}  # Non-auto tile bitmaps
    @auto_tiles       = {}  # Autotile bitmaps
    @priority_sprites = []  # Priority Sprites
    @autotile_sprites = []  # Autotile Sprites
    @flashing_sprites = []  # Flashing Sprites
    @disposed   = false
    @visible    = true
    @flashing   = true
    @can_draw   = true
    @ox, @oy = 0, 0
  end

  def sprite_bitmap
    return @sprite.bitmap
  end

  def data_tilesets
    $data_tilesets ||= load_data("Data/Tilesets.rxdata")
  end

  def disposed?
    @disposed
  end

  def dispose
    for sprite in [@sprite] + @normal_tiles.values + @auto_tiles.values + @priority_sprites + @autotile_sprites + @flashing_sprites
      sprite = sprite[0] if sprite.is_a?(Array)
      sprite.dispose if sprite.is_a?(Bitmap)
    end
    @priority_ids     = {}  # Priority ids
    @normal_tiles     = {}  # Non-auto tile bitmaps
    @priority_sprites = []  # Priority Sprites
    @autotile_sprites = []  # Autotile Sprites
    @flashing_sprites = []  # Flashing Sprites
    @disposed = true
  end

  def visible?
    @visible
  end

  def autotiles_changed?
    @oldautotiles != @autotiles
  end

  def visible=(value)
    @visible = value
    for sprite in [@sprite] + @priority_sprites + @autotile_sprites + @flashing_sprites
      sprite = sprite[0] if sprite.is_a?(Array)
      sprite.visible = value
    end
  end

  def tileset=(value)
    return if @tileset == value
    value = value.tileset_name if value.is_a?(RPG::Tileset)
    @tileset = RPG::Cache.tileset(value) if value.is_a?(String)
    @tileset = value if value.is_a?(Bitmap)
    redraw_tileset if @can_draw
  end

  def priorities=(value)
    return if @priorities == value
    @priorities = value
    redraw_priorities if @can_draw
  end

  def flash_data=(*coord, &value)
    return if @flash_data[coord[0],coord[1]] == value
    flashing = !@flash_data[x,y].nil?
    @flash_data[x,y] = value
  end

  def map_data
    @map_data
  end

  def map_data=(value)
    return if @map_data == value
    @map_data = value
    @flash_data = Table.new(@map_data.xsize, @map_data.ysize)
    draw_region if @can_draw and @priorities and @tileset
  end

  def tile_id(x, y, z)
    return map_data[x, y, z]
  end

  def priority(*args)
    return @priorities[args[0]] if args.size == 1
    return @priorities[tile_id(args[0], args[1], args[2])]
  end

  def redraw_tileset
    sprite_bitmap.clear
    @normal_tiles.clear
    @auto_tiles.clear
    (@autotile_sprites + @priority_sprites).each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
    @autotile_sprites.clear; @priority_sprites.clear
    draw_region if @can_draw and @priorities and @tileset
  end

  def redraw_priorities
    (@autotile_sprites + @priority_sprites).each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
    @priority_sprites.clear; @autotile_sprites.clear
    @priority_ids.clear
    for z in 0...3
      for y in 0...map_data.ysize
        for x in 0...map_data.xsize
          next if (id = tile_id(x, y, z)) == 0
          next if (p = priority(id)) == 0
          @priority_ids[id] = p
        end
      end
    end
    draw_region if @can_draw and @priorities and @tileset
  end

  def redraw_autotiles
    @auto_tiles.clear
    @autotile_sprites.each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
    @autotile_sprites.clear
    @oldautotiles = @autotiles
    draw_region if @can_draw and @priorities and @tileset
  end

  def draw_current_region
    left_x = @ox / 24
    top_y = @oy / 32
    @sprite.ox = left_x * 24 + @ox % 24 + 32
    @sprite.oy = top_y * 32 + @oy % 32 + 48
    for i in 0...@priority_sprites.size
      @priority_sprites[i][0].ox = left_x * 24 + @ox % 24 + 32
      @priority_sprites[i][0].oy = top_y * 32 + @oy % 32 + 48
    end
  end

  def draw_region
    left_x = @ox / 24
    top_y = @oy / 32
    @sprite.ox = BitmapWindowOffsetX * 32
    wecoc_y = left_x%2==1 ? 16 : 0
    @sprite.oy = BitmapWindowOffsetY * 32 + wecoc_y
    for x in 0...map_data.xsize+1
      for y in 0...map_data.ysize+1
        for z in 0..2
          draw_tile(x, y, tile_id(x + left_x - BitmapWindowOffsetX,
          y + top_y - BitmapWindowOffsetY, z),
          x + left_x - BitmapWindowOffsetX,
          y + top_y - BitmapWindowOffsetY, z)
        end
      end
    end
    @sprite.update
    Graphics.frame_reset
  end

  def draw_tile(x, y, tile_id, tx, ty, tz, src_bitmap = nil)
    return if x < 0 or y < 0
    return if tile_id == nil
    return draw_autotile(x, y, tile_id, tx, ty, tz, bitmap = bitmap) if tile_id < 384
    if (src_bitmap = @normal_tiles[tile_id]).nil?
      src_bitmap = Bitmap.new(32, 32)
      src_rect = Rect.new((tile_id - 384) % 8 * 32, (tile_id - 384) / 8 * 32,32,32)
      src_bitmap.blt(0, 0, @tileset, src_rect)
      @normal_tiles[tile_id] = src_bitmap
    end
    wecoc_y = x%2==0 ? 16 : 0
    if @priority_ids[tile_id].nil?
      sprite_bitmap.blt(x * 24 + @ox * 32, y * 32 + wecoc_y + @oy, src_bitmap, Rect.new(0,0,32,32))
    else
      sprite = Sprite.new(@viewport)
      sprite.visible = visible
      sprite.bitmap = src_bitmap
      sprite.x = x * 24 + @ox * 32
      sprite.y = y * 32 + wecoc_y + @oy
      sprite.ox = @ox + @ox % 24 + 32
      sprite.oy = @oy + @oy % 32 + 48
      sprite.z = @viewport.z + y * @priority_ids[tile_id] * 32 - 32
      @priority_sprites << [sprite, tx, ty, tz]
    end
  end

  def draw_autotile(x, y, tile_id, tx, ty, tz, src_bitmap = nil)
    return if x < 0 or y < 0
    return if tile_id == nil or tile_id >= 384
    return if tile_id == 0
    autotile = @autotiles[tile_id/48-1]
    return if autotile.nil? or autotile.disposed?
    if autotile.height == 32
      frames = autotile.width / (32 * 2)
    else
      frames = autotile.width / (96 * 2)
    end
    if x%2 == 0
      start_frame = ((Graphics.frame_count/AutotileLength) % frames) + 1
    else
      start_frame = (Graphics.frame_count/AutotileLength) % frames
    end
    if (src_bitmap_array = @auto_tiles[tile_id]).nil?
      @auto_tiles[tile_id] = []
      if autotile.height == 32
        for i in 0...frames*2
          this_frame_bitmap = Bitmap.new(32,32)
          src_rect = Rect.new(i * 32, 0, 32, 32)
          this_frame_bitmap.blt(0, 0, autotile, src_rect)
          @auto_tiles[tile_id] << this_frame_bitmap
        end
        src_bitmap_array = @auto_tiles[tile_id]
      else
        for i in 0...frames*2
          this_frame_bitmap = Bitmap.new(32,32)
          tiles = Autotiles[(tile_id % 48)>>3][(tile_id % 48)&7]
          for j in 0...4
            tile_position = tiles[j] - 1
            src_rect = Rect.new(tile_position % 6 * 16 + i * 96, tile_position / 6 * 16, 16, 16)
            this_frame_bitmap.blt(j % 2 * 16, j / 2 * 16 , autotile, src_rect)
          end
          @auto_tiles[tile_id][i] = this_frame_bitmap
        end
        src_bitmap_array = @auto_tiles[tile_id]
      end
    end
    src_bitmap = src_bitmap_array[start_frame]
    return if src_bitmap.nil?
    wecoc_y = x%2==0 ? 16 : 0
    if @priority_ids[tile_id].nil? and autotile.width == 32
      sprite_bitmap.blt(x * 24, y * 32 + wecoc_y, src_bitmap, Rect.new(0,0,32,32))
    else
      priority = (@priority_ids[tile_id] or 0)
      sprite = Sprite.new(@viewport)
      sprite.visible = visible
      sprite.bitmap = src_bitmap
      sprite.x = x * 24
      sprite.y = y * 32 + wecoc_y
      sprite.ox = @ox + @ox % 24 + 32
      sprite.oy = @oy + @oy % 32 + 48
      sprite.z = @viewport.z + y * priority * 32 - 32
      @autotile_sprites << [sprite, tx, ty, tz, start_frame]
    end
  end

  def get_update_autotile(tile_id, start_frame)
    return if tile_id == nil or tile_id >= 384
    return if tile_id == 0
    autotile = @autotiles[tile_id/48-1]
    return if autotile.nil? or autotile.disposed?
    if autotile.height == 32
      frames = autotile.width / (32 * 2)
    else
      frames = autotile.width / (96 * 2)
    end
    
    current_frame = (Graphics.frame_count/AutotileLength) % frames * 2
    src_bitmap = @auto_tiles[tile_id][current_frame + start_frame]
    return src_bitmap  
  end

  def ox=(value)
    return unless @ox != value
    @ox = value
  end

  def oy=(value)
    return unless @oy != value
    @oy = value
  end

  def update
    redraw_autotiles if autotiles_changed?
    return if not visible?
    update_autotiles if (Graphics.frame_count % AutotileLength) == 0
    draw_current_region
  end

  def update_autotiles
    left_x = @ox / 32
    top_y = @oy / 32
    for sprite in @autotile_sprites
      real_sprite, tx, ty, tz, start_frame = sprite
      tile_id = tile_id(tx, ty, tz)
      real_sprite.bitmap = get_update_autotile(tile_id, start_frame)
    end
  end
end
avatar
Wecoc
Administrador
Administrador



Créditos 12211

Gracias : 632

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por Noctámbulo el 2013-08-04, 20:22

Me llama mucho la atención, pero, ¿que ventajas o utilidades tendría utilizar este mapeo frente al mapeo cruadrangular?
avatar
Noctámbulo
Principiante
Principiante

1/3

Créditos 299

Gracias : 27

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por Wecoc el 2013-08-09, 22:18

Noctámbulo: Algunos juegos comerciales van con hextiles pero hasta ahora con RPG maker no se puede hacer. Entonces la ventaja más importante es la de darle un toque diferente a tu juego en RPG maker. Evidentemente hacer eso y luego usar el RTP es un poco tonto, solo hice el tileset para poder probar el script, como un template.

Probé también los autotiles, los cuales usan dos frames para cada frame. Es muy complicado autotilear con éste sistema y que quede bien, y también lo es hacer el gráfico del autotile, así que quizá habría que buscar alternativas más sanas.



====

Menudo colectivo... ¿Es que nadie va a colaborar nada? ¬¬

He hecho una pequeña gran modificación al script; 5 líneas. Las 5 primeras.

Código:
#==============================================================================
# Hextiles
#------------------------------------------------------------------------------
# Inspirado en el Tilemap de Derk-Jan Karrenbeld
#------------------------------------------------------------------------------
# Script creado por usuarios de Mundo Maker:
# - Wecoc
#------------------------------------------------------------------------------
# La prioridad 2 es la nueva prioridad 1, la prioridad 3 es la 2 y
# así sucesivamente, mientras que la prioridad 1 es de suelo como la 0.
# Hice eso porque la diferencia es que la 1 permite sobrepasar los márgenes
# del hexatile por el hecho de ser un sprite independiente, mientras que la 0
# como es parte del "fondo" de tiles no.
#------------------------------------------------------------------------------
# Los autotiles leen los frames de dos en dos porque cada frame tiene dos
# variedades de autotile según su y.
#==============================================================================

module HEXA
  WIDTH = 32  # Tamaño del tile. Recomendable número par. Siempre < 32
  HEIGHT = 32 # Tamaño del tile. Recomendable número par. Siempre < 32
  SUPP = 8    # Superposición entre hexágonos, normalmente WIDTH/4.
end

class Tilemap
  attr_reader :tileset
  attr_reader :autotiles
  attr_reader :flash_data
  attr_reader :priorities
  attr_reader :visible
  attr_reader :ox, :oy
  attr_writer :autotiles

  WindowRect = Rect.new(0,0,640,480)
  BitmapRect = Rect.new(0,0,640 + 64, 480 + 64)
  
  BitmapWindowOffsetX = (BitmapRect.width-WindowRect.width)/2/24
  BitmapWindowOffsetY = (BitmapRect.height-WindowRect.height)/2/32

  AutotileLength = 10 # Frames por cada frame del autotile
  
  MAX_MapWidth = 50 # Máximo de tiles que soporta el sistema Hextile
  MAX_MapHeight = 50 # Máximo de tiles que soporta el sistema Hextile
  
  # Orden de las partes del autotile
  Autotiles = [
    [ [27, 28, 33, 34], [ 5, 28, 33, 34], [27,  6, 33, 34], [ 5,  6, 33, 34],
      [27, 28, 33, 12], [ 5, 28, 33, 12], [27,  6, 33, 12], [ 5,  6, 33, 12] ],
    [ [27, 28, 11, 34], [ 5, 28, 11, 34], [27,  6, 11, 34], [ 5,  6, 11, 34],
      [27, 28, 11, 12], [ 5, 28, 11, 12], [27,  6, 11, 12], [ 5,  6, 11, 12] ],
    [ [25, 26, 31, 32], [25,  6, 31, 32], [25, 26, 31, 12], [25,  6, 31, 12],
      [15, 16, 21, 22], [15, 16, 21, 12], [15, 16, 11, 22], [15, 16, 11, 12] ],
    [ [29, 30, 35, 36], [29, 30, 11, 36], [ 5, 30, 35, 36], [ 5, 30, 11, 36],
      [39, 40, 45, 46], [ 5, 40, 45, 46], [39,  6, 45, 46], [ 5,  6, 45, 46] ],
    [ [25, 30, 31, 36], [15, 16, 45, 46], [13, 14, 19, 20], [13, 14, 19, 12],
      [17, 18, 23, 24], [17, 18, 11, 24], [41, 42, 47, 48], [ 5, 42, 47, 48] ],
    [ [37, 38, 43, 44], [37,  6, 43, 44], [13, 18, 19, 24], [13, 14, 43, 44],
      [37, 42, 43, 48], [17, 18, 47, 48], [13, 18, 43, 48], [ 1,  2,  7,  8] ]
  ]

  def initialize(viewport = nil, rpgmap = nil)
    @autotiles    = Array.new(6, nil)
    @oldautotiles = Array.new(6, nil)
    @viewport   = viewport ? viewport : Viewport.new(WindowRect)
    @sprite = Sprite.new(@viewport)
    @sprite.bitmap = Bitmap.new(MAX_MapWidth * (HEXA::WIDTH - HEXA::SUPP),
    MAX_MapHeight * HEXA::HEIGHT + 64)
    @priority_ids     = {}  # IDs de prioridad
    @normal_tiles     = {}  # Tiles normales (no auto) - Array de Bitmaps
    @auto_tiles       = {}  # Autotiles - Array de Bitmaps
    @priority_sprites = []  # Prioridades
    @autotile_sprites = []  # Autotiles
    @flashing_sprites = []  # Flash
    @disposed   = false
    @visible    = true
    @flashing   = true
    @can_draw   = true
    @ox, @oy = 0, 0
  end

  def sprite_bitmap
    return @sprite.bitmap
  end

  def data_tilesets
    $data_tilesets ||= load_data("Data/Tilesets.rxdata")
  end

  def disposed?
    @disposed
  end

  def dispose
    for sprite in [@sprite] + @normal_tiles.values + @auto_tiles.values + @priority_sprites + @autotile_sprites + @flashing_sprites
      sprite = sprite[0] if sprite.is_a?(Array)
      sprite.dispose if sprite.is_a?(Bitmap)
    end
    @priority_ids     = {}  # IDs de prioridad
    @normal_tiles     = {}  # Tiles normales (no auto) - Array de Bitmaps
    @priority_sprites = []  # Prioridades
    @autotile_sprites = []  # Autotiles
    @flashing_sprites = []  # Flash
    @disposed = true
  end

  def visible?
    @visible
  end

  def autotiles_changed?
    @oldautotiles != @autotiles
  end

  def visible=(value)
    @visible = value
    for sprite in [@sprite] + @priority_sprites + @autotile_sprites + @flashing_sprites
      sprite = sprite[0] if sprite.is_a?(Array)
      sprite.visible = value
    end
  end

  def tileset=(value)
    return if @tileset == value
    value = value.tileset_name if value.is_a?(RPG::Tileset)
    @tileset = RPG::Cache.tileset(value) if value.is_a?(String)
    @tileset = value if value.is_a?(Bitmap)
    redraw_tileset if @can_draw
  end

  def priorities=(value)
    return if @priorities == value
    @priorities = value
    redraw_priorities if @can_draw
  end

  def flash_data=(*coord, &value)
    return if @flash_data[coord[0],coord[1]] == value
    flashing = !@flash_data[x,y].nil?
    @flash_data[x,y] = value
  end

  def map_data
    @map_data
  end

  def map_data=(value)
    return if @map_data == value
    @map_data = value
    @flash_data = Table.new(@map_data.xsize, @map_data.ysize)
    draw_region if @can_draw and @priorities and @tileset
  end

  def tile_id(x, y, z)
    return map_data[x, y, z]
  end

  def priority(*args)
    return @priorities[args[0]] if args.size == 1
    return @priorities[tile_id(args[0], args[1], args[2])]
  end

  def redraw_tileset
    sprite_bitmap.clear
    @normal_tiles.clear
    @auto_tiles.clear
    (@autotile_sprites + @priority_sprites).each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
    @autotile_sprites.clear; @priority_sprites.clear
    draw_region if @can_draw and @priorities and @tileset
  end

  def redraw_priorities
    (@autotile_sprites + @priority_sprites).each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
    @priority_sprites.clear; @autotile_sprites.clear
    @priority_ids.clear
    for z in 0...3
      for y in 0...map_data.ysize
        for x in 0...map_data.xsize
          next if (id = tile_id(x, y, z)) == 0
          next if (p = priority(id)) == 0
          @priority_ids[id] = p
        end
      end
    end
    draw_region if @can_draw and @priorities and @tileset
  end

  def redraw_autotiles
    @auto_tiles.clear
    @autotile_sprites.each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
    @autotile_sprites.clear
    @oldautotiles = @autotiles
    draw_region if @can_draw and @priorities and @tileset
  end

  def draw_current_region
    left_x = @ox / (HEXA::WIDTH - HEXA::SUPP)
    top_y = @oy / HEXA::HEIGHT
    @sprite.ox = left_x * (HEXA::WIDTH - HEXA::SUPP) + @ox % (HEXA::WIDTH - HEXA::SUPP) + HEXA::WIDTH
    @sprite.oy = top_y * HEXA::HEIGHT + @oy % HEXA::HEIGHT + (HEXA::HEIGHT + HEXA::HEIGHT/2)
    for i in 0...@priority_sprites.size
      @priority_sprites[i][0].ox = left_x * (HEXA::WIDTH - HEXA::SUPP) + @ox % (HEXA::WIDTH - HEXA::SUPP) + HEXA::WIDTH
      @priority_sprites[i][0].oy = top_y * HEXA::HEIGHT + @oy % HEXA::HEIGHT + (HEXA::HEIGHT + HEXA::HEIGHT/2)
    end
  end

  def draw_region
    left_x = @ox / (HEXA::WIDTH - HEXA::SUPP)
    top_y = @oy / HEXA::HEIGHT
    @sprite.ox = BitmapWindowOffsetX * HEXA::WIDTH
    wecoc_y = left_x%2==1 ? (HEXA::HEIGHT/2) : 0
    @sprite.oy = BitmapWindowOffsetY * HEXA::HEIGHT + wecoc_y
    for x in 0...map_data.xsize+1
      for y in 0...map_data.ysize+1
        for z in 0..2
          if x%2==0
            draw_tile(x, y, tile_id(x + left_x - BitmapWindowOffsetX,
            y + top_y - BitmapWindowOffsetY, z),
            x + left_x - BitmapWindowOffsetX,
            y + top_y - BitmapWindowOffsetY, z)
          end
        end
      end
    end
    for x in 0...map_data.xsize+1
      for y in 0...map_data.ysize+1
        for z in 0..2
          if x%2==1
            draw_tile(x, y, tile_id(x + left_x - BitmapWindowOffsetX,
            y + top_y - BitmapWindowOffsetY, z),
            x + left_x - BitmapWindowOffsetX,
            y + top_y - BitmapWindowOffsetY, z)
          end
        end
      end
    end
    @sprite.update
    Graphics.frame_reset
  end

  def draw_tile(x, y, tile_id, tx, ty, tz, src_bitmap = nil)
    return if x < 0 or y < 0
    return if tile_id == nil
    return draw_autotile(x, y, tile_id, tx, ty, tz, bitmap = bitmap) if tile_id < 384
    if (src_bitmap = @normal_tiles[tile_id]).nil?
      src_bitmap = Bitmap.new(HEXA::WIDTH, HEXA::HEIGHT)
      src_rect = Rect.new((tile_id - 384) % 8 * 32, (tile_id - 384) / 8 * 32, HEXA::WIDTH, HEXA::HEIGHT)
      src_bitmap.blt(0, 0, @tileset, src_rect)
      @normal_tiles[tile_id] = src_bitmap
    end
    wecoc_y = x%2==0 ? (HEXA::HEIGHT/2) : 0
    if @priority_ids[tile_id].nil?
      sprite_bitmap.blt(x * (HEXA::WIDTH - HEXA::SUPP) + @ox * HEXA::WIDTH, y * HEXA::HEIGHT + wecoc_y + @oy,
      src_bitmap, Rect.new(0,0,HEXA::WIDTH,HEXA::HEIGHT))
    else
      sprite = Sprite.new(@viewport)
      sprite.visible = visible
      sprite.bitmap = src_bitmap
      sprite.x = x * (HEXA::WIDTH - HEXA::SUPP) + @ox * HEXA::WIDTH
      sprite.y = y * HEXA::HEIGHT + wecoc_y + @oy
      sprite.ox = @ox + @ox % (HEXA::WIDTH - HEXA::SUPP) + HEXA::WIDTH
      sprite.oy = @oy + @oy % HEXA::HEIGHT + (HEXA::HEIGHT + HEXA::HEIGHT/2)
      sprite.z = @viewport.z + y * @priority_ids[tile_id] * 32 - 32
      @priority_sprites << [sprite, tx, ty, tz]
    end
  end

  def draw_autotile(x, y, tile_id, tx, ty, tz, src_bitmap = nil)
    return if x < 0 or y < 0
    return if tile_id == nil or tile_id >= 384
    return if tile_id == 0
    autotile = @autotiles[tile_id/48-1]
    return if autotile.nil? or autotile.disposed?
    if autotile.height == 32
      frames = autotile.width / (32 * 2)
    else
      frames = autotile.width / (96 * 2)
    end
    if x%2 == 0
      start_frame = ((Graphics.frame_count/AutotileLength) % frames) + 1
    else
      start_frame = (Graphics.frame_count/AutotileLength) % frames
    end
    if (src_bitmap_array = @auto_tiles[tile_id]).nil?
      @auto_tiles[tile_id] = []
      if autotile.height == 32
        for i in 0...frames*2
          this_frame_bitmap = Bitmap.new(HEXA::WIDTH, HEXA::HEIGHT)
         src_rect = Rect.new(i * 32, 0, HEXA::WIDTH, HEXA::HEIGHT)
          this_frame_bitmap.blt(0, 0, autotile, src_rect)
          @auto_tiles[tile_id] << this_frame_bitmap
        end
        src_bitmap_array = @auto_tiles[tile_id]
      else
        for i in 0...frames*2
          this_frame_bitmap = Bitmap.new(HEXA::WIDTH, HEXA::HEIGHT)
          tiles = Autotiles[(tile_id % 48)>>3][(tile_id % 48)&7]
          for j in 0...4
            tile_position = tiles[j] - 1
            src_rect = Rect.new(tile_position % 6 * 16 + i * 96, tile_position / 6 * 16,
            HEXA::WIDTH/2, HEXA::HEIGHT/2)
            this_frame_bitmap.blt(j % 2 * HEXA::WIDTH/2, j / 2 * HEXA::HEIGHT/2 , autotile, src_rect)
          end
          @auto_tiles[tile_id][i] = this_frame_bitmap
        end
        src_bitmap_array = @auto_tiles[tile_id]
      end
    end
    src_bitmap = src_bitmap_array[start_frame]
    return if src_bitmap.nil?
    wecoc_y = x%2==0 ? (HEXA::HEIGHT/2) : 0
    if @priority_ids[tile_id].nil? and autotile.width == 32
      sprite_bitmap.blt(x * (HEXA::WIDTH - HEXA::SUPP), y * HEXA::HEIGHT + wecoc_y,
      src_bitmap, Rect.new(0,0,HEXA::WIDTH,HEXA::HEIGHT))
    else
      priority = (@priority_ids[tile_id] or 0)
      sprite = Sprite.new(@viewport)
      sprite.visible = visible
      sprite.bitmap = src_bitmap
      sprite.x = x * (HEXA::WIDTH - HEXA::SUPP)
      sprite.y = y * HEXA::HEIGHT + wecoc_y
      sprite.ox = @ox + @ox % (HEXA::WIDTH - HEXA::SUPP) + HEXA::WIDTH
      sprite.oy = @oy + @oy % HEXA::HEIGHT + (HEXA::HEIGHT + HEXA::HEIGHT/2)
      sprite.z = @viewport.z + y * priority * HEXA::HEIGHT - HEXA::HEIGHT
      @autotile_sprites << [sprite, tx, ty, tz, start_frame]
    end
  end

  def get_update_autotile(tile_id, start_frame)
    return if tile_id == nil or tile_id >= 384
    return if tile_id == 0
    autotile = @autotiles[tile_id/48-1]
    return if autotile.nil? or autotile.disposed?
    if autotile.height == 32
      frames = autotile.width / (32 * 2)
    else
      frames = autotile.width / (96 * 2)
    end
    
    current_frame = (Graphics.frame_count/AutotileLength) % frames * 2
    src_bitmap = @auto_tiles[tile_id][current_frame + start_frame]
    return src_bitmap  
  end

  def ox=(value)
    return unless @ox != value
    @ox = value
  end

  def oy=(value)
    return unless @oy != value
    @oy = value
  end

  def update
    redraw_autotiles if autotiles_changed?
    return if not visible?
    update_autotiles if (Graphics.frame_count % AutotileLength) == 0
    draw_current_region
  end

  def update_autotiles
    left_x = @ox / HEXA::WIDTH
    top_y = @oy / HEXA::HEIGHT
    for sprite in @autotile_sprites
      real_sprite, tx, ty, tz, start_frame = sprite
      tile_id = tile_id(tx, ty, tz)
      real_sprite.bitmap = get_update_autotile(tile_id, start_frame)
    end
  end
end
Hay un bug con los autotiles y el scroll, cuando empiezas en una posición scrolleada del mapa como hizo Orochii. Para empezar habría que intentar arreglar eso.


Última edición por Wecoc el 2013-08-27, 22:29, editado 2 veces
avatar
Wecoc
Administrador
Administrador



Créditos 12211

Gracias : 632

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por youkai el 2013-08-10, 15:16

Ok wec...creo que me da pena verte solo esforzandote en una de tus paridas XDDDDDDDD Nah mentira, voy a ayudarte un poco y ver que sale de esto.
Cuando este en casa le echo un vistazo a tu script y lo nuevo que has hecho e intentare arreglar ese problema con el scroll de los autotiles.
Horita edito...si es que logro algo XDD
Saludos,
¥oukai
avatar
youkai
Soñador
Soñador

0/3

Créditos 280

Gracias : 10

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por orochii el 2013-08-10, 16:28

Yo había empezado a arreglar lo del posicionamiento del personaje, y estaba tirando tomates a lo del scroll, pero sin ningún fruto (xDD?).
Aquí lo que sirve de lo que hice.
Código:
class Game_Character
#--------------------------------------------------------------------------
  # * Get Screen X-Coordinates
  #--------------------------------------------------------------------------
  def screen_x
    # Get screen coordinates from real coordinates and map display position
    return (@real_x - $game_map.display_x + 3) / 5.33 + 8
  end
  #--------------------------------------------------------------------------
  # * Get Screen Y-Coordinates
  #--------------------------------------------------------------------------
  def screen_y
    # Get screen coordinates from real coordinates and map display position
    y = (@real_y - $game_map.display_y + 3) / 4 + 32
    c = ((@real_x%128)*16/128.0)
    y -= ((@real_x/128)%2==0) ? 16-c : c
    # Make y-coordinate smaller via jump count
    if @jump_count >= @jump_peak
      n = @jump_count - @jump_peak
    else
      n = @jump_peak - @jump_count
    end
    return y - (@jump_peak * @jump_peak - n * n) / 2
  end
end
class Game_Player
  CENTER_X = (320 - 8) * 4  # Center screen x-coordinate * 4
  CENTER_Y = (240 - 8) * 4  # Center screen y-coordinate * 4
end
Igual es que me hice un lío con lo del scroll, así que probablemente lo único que sirva algo es lo del screen_y, y sólo quizá.

Asdflutito =3! x3,
Orochii Zouveleki
avatar
orochii
Reportero

0/3

Créditos 7724

Gracias : 436

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por Wecoc el 2013-08-11, 15:25

Youkai: Ya arreglé eso del autotile, era la misma tontería de antes xD

Código:
#==============================================================================
# Hextiles
#==============================================================================
# Script creado por usuarios de Mundo Maker:
# - Wecoc
#==============================================================================

#==============================================================================
# 1. Hextiles Tilemap
#------------------------------------------------------------------------------
# Inspirado en el Tilemap de Derk-Jan Karrenbeld
#------------------------------------------------------------------------------
# La prioridad 2 es la nueva prioridad 1, la prioridad 3 es la 2 y
# así sucesivamente, mientras que la prioridad 1 es de suelo como la 0.
# Hice eso porque la diferencia es que la 1 permite sobrepasar los márgenes
# del hexatile por el hecho de ser un sprite independiente, mientras que la 0
# como es parte del "fondo" de tiles no.
#------------------------------------------------------------------------------
# Los autotiles leen los frames de dos en dos porque cada frame tiene dos
# variedades de autotile según su y.
#==============================================================================

module HEXA
  WIDTH = 32  # Tamaño del tile. Recomendable número par. Siempre < 32
  HEIGHT = 32 # Tamaño del tile. Recomendable número par. Siempre < 32
  SUPP = 8    # Superposición entre hexágonos, normalmente WIDTH/4.
  QWEASD_SUP = true # Soporte de movimiento con QWEASD
  DIR4_SUP = false # Soporte de movimiento con las teclas de dirección
end

class Tilemap
  attr_reader :tileset
  attr_reader :autotiles
  attr_reader :flash_data
  attr_reader :priorities
  attr_reader :visible
  attr_reader :ox, :oy
  attr_writer :autotiles

  WindowRect = Rect.new(0,0,640,480)
  BitmapRect = Rect.new(0,0,640 + 64, 480 + 64)
 
  BitmapWindowOffsetX = (BitmapRect.width-WindowRect.width)/2/24
  BitmapWindowOffsetY = (BitmapRect.height-WindowRect.height)/2/32

  AutotileLength = 10 # Frames por cada frame del autotile
 
  MAX_MapWidth = 50 # Máximo de tiles que soporta el sistema Hextile
  MAX_MapHeight = 50 # Máximo de tiles que soporta el sistema Hextile
 
  # Orden de las partes del autotile
  Autotiles = [
    [ [27, 28, 33, 34], [ 5, 28, 33, 34], [27,  6, 33, 34], [ 5,  6, 33, 34],
      [27, 28, 33, 12], [ 5, 28, 33, 12], [27,  6, 33, 12], [ 5,  6, 33, 12] ],
    [ [27, 28, 11, 34], [ 5, 28, 11, 34], [27,  6, 11, 34], [ 5,  6, 11, 34],
      [27, 28, 11, 12], [ 5, 28, 11, 12], [27,  6, 11, 12], [ 5,  6, 11, 12] ],
    [ [25, 26, 31, 32], [25,  6, 31, 32], [25, 26, 31, 12], [25,  6, 31, 12],
      [15, 16, 21, 22], [15, 16, 21, 12], [15, 16, 11, 22], [15, 16, 11, 12] ],
    [ [29, 30, 35, 36], [29, 30, 11, 36], [ 5, 30, 35, 36], [ 5, 30, 11, 36],
      [39, 40, 45, 46], [ 5, 40, 45, 46], [39,  6, 45, 46], [ 5,  6, 45, 46] ],
    [ [25, 30, 31, 36], [15, 16, 45, 46], [13, 14, 19, 20], [13, 14, 19, 12],
      [17, 18, 23, 24], [17, 18, 11, 24], [41, 42, 47, 48], [ 5, 42, 47, 48] ],
    [ [37, 38, 43, 44], [37,  6, 43, 44], [13, 18, 19, 24], [13, 14, 43, 44],
      [37, 42, 43, 48], [17, 18, 47, 48], [13, 18, 43, 48], [ 1,  2,  7,  8] ]
  ]

  def initialize(viewport = nil, rpgmap = nil)
    @autotiles    = Array.new(6, nil)
    @oldautotiles = Array.new(6, nil)
    @viewport  = viewport ? viewport : Viewport.new(WindowRect)
    @sprite = Sprite.new(@viewport)
    @sprite.bitmap = Bitmap.new(MAX_MapWidth * (HEXA::WIDTH - HEXA::SUPP),
    MAX_MapHeight * HEXA::HEIGHT + 64)
    @priority_ids    = {}  # IDs de prioridad
    @normal_tiles    = {}  # Tiles normales (no auto) - Array de Bitmaps
    @auto_tiles      = {}  # Autotiles - Array de Bitmaps
    @priority_sprites = []  # Prioridades
    @autotile_sprites = []  # Autotiles
    @flashing_sprites = []  # Flash
    @disposed  = false
    @visible    = true
    @flashing  = true
    @can_draw  = true
    @ox, @oy = 0, 0
  end

  def sprite_bitmap
    return @sprite.bitmap
  end

  def data_tilesets
    $data_tilesets ||= load_data("Data/Tilesets.rxdata")
  end

  def disposed?
    @disposed
  end

  def dispose
    spp = [@sprite] + @normal_tiles.values + @auto_tiles.values +
    @priority_sprites + @autotile_sprites + @flashing_sprites
    for sprite in spp
      sprite = sprite[0] if sprite.is_a?(Array)
      sprite.dispose if sprite.is_a?(Bitmap)
    end
    @priority_ids    = {}  # IDs de prioridad
    @normal_tiles    = {}  # Tiles normales (no auto) - Array de Bitmaps
    @priority_sprites = []  # Prioridades
    @autotile_sprites = []  # Autotiles
    @flashing_sprites = []  # Flash
    @disposed = true
  end

  def visible?
    @visible
  end

  def autotiles_changed?
    @oldautotiles != @autotiles
  end

  def visible=(value)
    @visible = value
    spp = [@sprite] + @priority_sprites + @autotile_sprites + @flashing_sprites
    for sprite in spp
      sprite = sprite[0] if sprite.is_a?(Array)
      sprite.visible = value
    end
  end

  def tileset=(value)
    return if @tileset == value
    value = value.tileset_name if value.is_a?(RPG::Tileset)
    @tileset = RPG::Cache.tileset(value) if value.is_a?(String)
    @tileset = value if value.is_a?(Bitmap)
    redraw_tileset if @can_draw
  end

  def priorities=(value)
    return if @priorities == value
    @priorities = value
    redraw_priorities if @can_draw
  end

  def flash_data=(*coord, &value)
    return if @flash_data[coord[0],coord[1]] == value
    flashing = !@flash_data[x,y].nil?
    @flash_data[x,y] = value
  end

  def map_data
    @map_data
  end

  def map_data=(value)
    return if @map_data == value
    @map_data = value
    @flash_data = Table.new(@map_data.xsize, @map_data.ysize)
    draw_region if @can_draw and @priorities and @tileset
  end

  def tile_id(x, y, z)
    return map_data[x, y, z]
  end

  def priority(*args)
    return @priorities[args[0]] if args.size == 1
    return @priorities[tile_id(args[0], args[1], args[2])]
  end

  def redraw_tileset
    sprite_bitmap.clear
    @normal_tiles.clear
    @auto_tiles.clear
    @autotile_sprites.each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
    @priority_sprites.each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
    @autotile_sprites.clear
    @priority_sprites.clear
    draw_region if @can_draw and @priorities and @tileset
  end

  def redraw_priorities
    @autotile_sprites.each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
    @priority_sprites.each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
    @autotile_sprites.clear
    @priority_sprites.clear
    @priority_ids.clear
    for z in 0...3
      for y in 0...map_data.ysize
        for x in 0...map_data.xsize
          next if (id = tile_id(x, y, z)) == 0
          next if (p = priority(id)) == 0
          @priority_ids[id] = p
        end
      end
    end
    draw_region if @can_draw and @priorities and @tileset
  end

  def redraw_autotiles
    @auto_tiles.clear
    @autotile_sprites.each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
    @autotile_sprites.clear
    @oldautotiles = @autotiles
    draw_region if @can_draw and @priorities and @tileset
  end

  def draw_current_region
    left_x = @ox / (HEXA::WIDTH - HEXA::SUPP)
    top_y = @oy / HEXA::HEIGHT
    sppox = left_x * (HEXA::WIDTH - HEXA::SUPP) +
    @ox % (HEXA::WIDTH - HEXA::SUPP) + HEXA::WIDTH
    sppoy = top_y * HEXA::HEIGHT +
    @oy % HEXA::HEIGHT + (HEXA::HEIGHT + HEXA::HEIGHT/2)
    @sprite.ox = sppox
    @sprite.oy = sppoy
    for i in 0...@priority_sprites.size
      @priority_sprites[i][0].ox = sppox
      @priority_sprites[i][0].oy = sppoy
    end
    for i in 0...@autotile_sprites.size
      @autotile_sprites[i][0].ox = sppox
      @autotile_sprites[i][0].oy = sppoy
    end
  end

  def draw_region
    left_x = @ox / (HEXA::WIDTH - HEXA::SUPP)
    top_y = @oy / HEXA::HEIGHT
    @sprite.ox = BitmapWindowOffsetX * HEXA::WIDTH
    wecoc_y = left_x%2==1 ? (HEXA::HEIGHT/2) : 0
    @sprite.oy = BitmapWindowOffsetY * HEXA::HEIGHT + wecoc_y
    for x in 0...map_data.xsize+1
      for y in 0...map_data.ysize+1
        for z in 0..2
          if x%2==0
            draw_tile(x, y, tile_id(x + left_x - BitmapWindowOffsetX,
            y + top_y - BitmapWindowOffsetY, z),
            x + left_x - BitmapWindowOffsetX,
            y + top_y - BitmapWindowOffsetY, z)
          end
        end
      end
    end
    for x in 0...map_data.xsize+1
      for y in 0...map_data.ysize+1
        for z in 0..2
          if x%2==1
            draw_tile(x, y, tile_id(x + left_x - BitmapWindowOffsetX,
            y + top_y - BitmapWindowOffsetY, z),
            x + left_x - BitmapWindowOffsetX,
            y + top_y - BitmapWindowOffsetY, z)
          end
        end
      end
    end
    @sprite.update
    Graphics.frame_reset
  end

  def draw_tile(x, y, tile_id, tx, ty, tz, src_bitmap = nil)
    return if x < 0 or y < 0
    return if tile_id == nil
    if tile_id < 384
      return draw_autotile(x, y, tile_id, tx, ty, tz, src_bitmap = src_bitmap)
    end
    if (src_bitmap = @normal_tiles[tile_id]).nil?
      src_bitmap = Bitmap.new(HEXA::WIDTH, HEXA::HEIGHT)
      src_rect = Rect.new((tile_id - 384) % 8 * 32, (tile_id - 384) / 8 * 32,
        HEXA::WIDTH, HEXA::HEIGHT)
      src_bitmap.blt(0, 0, @tileset, src_rect)
      @normal_tiles[tile_id] = src_bitmap
    end
    wecoc_y = x%2==0 ? (HEXA::HEIGHT/2) : 0
    if @priority_ids[tile_id].nil?
      sprite_bitmap.blt(x * (HEXA::WIDTH - HEXA::SUPP) + @ox * HEXA::WIDTH,
        y * HEXA::HEIGHT + wecoc_y + @oy, src_bitmap,
        Rect.new(0,0,HEXA::WIDTH,HEXA::HEIGHT))
    else
      sprite = Sprite.new(@viewport)
      sprite.visible = visible
      sprite.bitmap = src_bitmap
      sprite.x = x * (HEXA::WIDTH - HEXA::SUPP) + @ox * HEXA::WIDTH
      sprite.y = y * HEXA::HEIGHT + wecoc_y + @oy
      sprite.ox = @ox + @ox % (HEXA::WIDTH - HEXA::SUPP) + HEXA::WIDTH
      sprite.oy = @oy + @oy % HEXA::HEIGHT + (HEXA::HEIGHT + HEXA::HEIGHT/2)
      sprite.z = @viewport.z + y * @priority_ids[tile_id] * 32 - 32
      @priority_sprites << [sprite, tx, ty, tz]
    end
  end

  def draw_autotile(x, y, tile_id, tx, ty, tz, src_bitmap = nil)
    return if x < 0 or y < 0
    return if tile_id == nil or tile_id >= 384
    return if tile_id == 0
    autotile = @autotiles[tile_id/48-1]
    return if autotile.nil? or autotile.disposed?
    if autotile.height == 32
      frames = autotile.width / (32 * 2)
    else
      frames = autotile.width / (96 * 2)
    end
    return if frames == 0
    if x%2 == 0
      start_frame = ((Graphics.frame_count/AutotileLength) % frames) + 1
    else
      start_frame = (Graphics.frame_count/AutotileLength) % frames
    end
    if (src_bitmap_array = @auto_tiles[tile_id]).nil?
      @auto_tiles[tile_id] = []
      if autotile.height == 32
        for i in 0...frames*2
          this_frame_bitmap = Bitmap.new(HEXA::WIDTH, HEXA::HEIGHT)
          src_rect = Rect.new(i * 32, 0, HEXA::WIDTH, HEXA::HEIGHT)
          this_frame_bitmap.blt(0, 0, autotile, src_rect)
          @auto_tiles[tile_id] << this_frame_bitmap
        end
        src_bitmap_array = @auto_tiles[tile_id]
      else
        for i in 0...frames*2
          this_frame_bitmap = Bitmap.new(HEXA::WIDTH, HEXA::HEIGHT)
          tiles = Autotiles[(tile_id % 48)>>3][(tile_id % 48)&7]
          for j in 0...4
            tile_position = tiles[j] - 1
            src_rect = Rect.new(tile_position % 6 * 16 + i * 96,
              tile_position / 6 * 16, HEXA::WIDTH/2, HEXA::HEIGHT/2)
            this_frame_bitmap.blt(j % 2 * HEXA::WIDTH/2, j / 2 * HEXA::HEIGHT/2,
              autotile, src_rect)
          end
          @auto_tiles[tile_id][i] = this_frame_bitmap
        end
        src_bitmap_array = @auto_tiles[tile_id]
      end
    end
    src_bitmap = src_bitmap_array[start_frame]
    return if src_bitmap.nil?
    wecoc_y = x%2==0 ? (HEXA::HEIGHT/2) : 0
    if @priority_ids[tile_id].nil? # and autotile.width == 32
      sprite_bitmap.blt(x * (HEXA::WIDTH - HEXA::SUPP) + @ox * HEXA::WIDTH,
        y * HEXA::HEIGHT + wecoc_y + @oy, src_bitmap,
        Rect.new(0,0,HEXA::WIDTH,HEXA::HEIGHT))
    else
      priority = (@priority_ids[tile_id] or 0)
      sprite = Sprite.new(@viewport)
      sprite.visible = visible
      sprite.bitmap = src_bitmap
      sprite.x = x * (HEXA::WIDTH - HEXA::SUPP) + @ox * HEXA::WIDTH
      sprite.y = y * HEXA::HEIGHT + wecoc_y + @oy
      sprite.ox = @ox + @ox % (HEXA::WIDTH - HEXA::SUPP) + HEXA::WIDTH
      sprite.oy = @oy + @oy % HEXA::HEIGHT + (HEXA::HEIGHT + HEXA::HEIGHT/2)
      sprite.z = @viewport.z + y * priority * HEXA::HEIGHT - HEXA::HEIGHT
      @autotile_sprites << [sprite, tx, ty, tz, start_frame]
    end
  end

  def get_update_autotile(tile_id, start_frame)
    return if tile_id == nil or tile_id >= 384
    return if tile_id == 0
    autotile = @autotiles[tile_id/48-1]
    return if autotile.nil? or autotile.disposed?
    if autotile.height == 32
      frames = autotile.width / (32 * 2)
    else
      frames = autotile.width / (96 * 2)
    end
    current_frame = (Graphics.frame_count/AutotileLength) % frames * 2
    src_bitmap = @auto_tiles[tile_id][current_frame + start_frame]
    return src_bitmap 
  end

  def ox=(value)
    return unless @ox != value
    @ox = value
  end

  def oy=(value)
    return unless @oy != value
    @oy = value
  end

  def update
    redraw_autotiles if autotiles_changed?
    return if not visible?
    update_autotiles if (Graphics.frame_count % AutotileLength) == 0
    draw_current_region
  end

  def update_autotiles
    left_x = @ox / HEXA::WIDTH
    top_y = @oy / HEXA::HEIGHT
    for sprite in @autotile_sprites
      real_sprite, tx, ty, tz, start_frame = sprite
      tile_id = tile_id(tx, ty, tz)
      real_sprite.bitmap = get_update_autotile(tile_id, start_frame)
    end
  end
end

#==============================================================================#
# 2. QWE-ASD Support
#==============================================================================#

module Input
  GKAS = Win32API.new( "user32", "GetAsyncKeyState", "i", "i" )
  def self.dir6
    if    GKAS.call(0x51).abs&0x8000 == 0x8000  ; return 'Q'
    elsif GKAS.call(0x57).abs&0x8000 == 0x8000  ; return 'W'
    elsif GKAS.call(0x45).abs&0x8000 == 0x8000  ; return 'E'
    elsif GKAS.call(0x41).abs&0x8000 == 0x8000  ; return 'A'
    elsif GKAS.call(0x53).abs&0x8000 == 0x8000  ; return 'S'
    elsif GKAS.call(0x44).abs&0x8000 == 0x8000  ; return 'D'
    else ; return 0
    end
  end
end

class Game_Player < Game_Character
  def update
    last_moving = moving?
    unless moving? or $game_system.map_interpreter.running? or
          @move_route_forcing or $game_temp.message_window_showing
      if HEXA::QWEASD_SUP
        case Input.dir6
        when 'Q'
          move_upper_left
        when 'W'
          move_up
        when 'E'
          move_upper_right
        when 'A'
          move_lower_left
        when 'S'
          move_down
        when 'D'
          move_lower_right
        end
      end
      if HEXA::DIR4_SUP
        case Input.dir4
        when 2
        move_down
        when 4
          @x%2==0 ? move_upper_left : move_lower_left
        when 6
          @x%2==0 ? move_upper_right : move_lower_right
        when 8
          move_up
        end
      end
    end
    last_real_x = @real_x
    last_real_y = @real_y
    super
    if @real_y > last_real_y and @real_y - $game_map.display_y > CENTER_Y
      $game_map.scroll_down(@real_y - last_real_y)
    end
    if @real_x < last_real_x and @real_x - $game_map.display_x < CENTER_X
      $game_map.scroll_left(last_real_x - @real_x)
    end
    if @real_x > last_real_x and @real_x - $game_map.display_x > CENTER_X
      $game_map.scroll_right(@real_x - last_real_x)
    end
    if @real_y < last_real_y and @real_y - $game_map.display_y < CENTER_Y
      $game_map.scroll_up(last_real_y - @real_y)
    end
    unless moving?
      if last_moving
        result = check_event_trigger_here([1,2])
        if result == false
          unless $DEBUG and Input.press?(Input::CTRL)
            if @encounter_count > 0
              @encounter_count -= 1
            end
          end
        end
      end
      if Input.trigger?(Input::C)
        check_event_trigger_here([0])
        check_event_trigger_there([0,1,2])
      end
    end
  end
end
Orochii: Aún no lo he podido mirar pero promete >:D Lo miraré, luego edito y te digo a ver qué tal xD



Edito: He añadido el QWE-ASD Support en el script, era la parte más fácil.
avatar
Wecoc
Administrador
Administrador



Créditos 12211

Gracias : 632

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por Pokepik el 2013-08-11, 22:58

Qué locura XD
Voy a echarte un cable porque te veo muy abandonado en esto.

Código:
#==============================================================================
# ** Game_Character
#==============================================================================

class Game_Character
  
  def moving? # No está hecho
    return (@real_x != @x * 24 * 4 or @real_y != @y * 32 * 4)
  end
  
  def passable?(x, y, d) # No está hecho
    new_x = x + (d == 6 ? 1 : d == 4 ? -1 : 0)
    new_y = y + (d == 2 ? 1 : d == 8 ? -1 : 0)
    return false unless $game_map.valid?(new_x, new_y)
    return true if @through
    return false unless $game_map.passable?(x, y, d, self)
    return false unless $game_map.passable?(new_x, new_y, 10 - d)
    for event in $game_map.events.values
      if event.x == new_x and event.y == new_y
        unless event.through
          return false if self != $game_player
          return false if event.character_name != ""
        end
      end
    end
    if $game_player.x == new_x and $game_player.y == new_y
      unless $game_player.through
        return false if @character_name != ""
      end
    end
    return true
  end

  def moveto(x, y) # No está hecho
    @x = x % $game_map.width
    @y = y % $game_map.height
    @real_x = @x * 24 * 4
    @real_y = @y * 32 * 4
    @prelock_direction = 0
  end

  def screen_x
    return (@real_x - $game_map.display_x + 3) / 4 + 32 / 4
  end

  def screen_y # No está hecho
    y = (@real_y - $game_map.display_y + 3) / 4 + 32
    if @jump_count >= @jump_peak
      n = @jump_count - @jump_peak
    else
      n = @jump_peak - @jump_count
    end
    return y - (@jump_peak * @jump_peak - n * n) / 2
  end

  def bush_depth(depth=12)
    return 0 if @tile_id > 0 or @always_on_top
    if @jump_count == 0 and $game_map.bush?(@x, @y)
      return depth
    else
      return 0
    end
  end

  def update_jump # No está hecho
    @jump_count -= 1
    @real_x = (@real_x * @jump_count + @x * 24 * 4) / (@jump_count + 1)
    @real_y = (@real_y * @jump_count + @y * 32 * 4) / (@jump_count + 1)
  end

  def update_move # No está hecho
    distance = 2 ** @move_speed
    if @y * 32 * 4 > @real_y # Move down
      @real_y = [@real_y + distance, @y * 32 * 4].min
    end
    if @x * 24 * 4 < @real_x # Move left
      @real_x = [@real_x - distance, @x * 24 * 4].max
    end
    if @x * 24 * 4 > @real_x # Move right
      @real_x = [@real_x + distance, @x * 24 * 4].min
    end
    if @y * 32 * 4 < @real_y # Move up
      @real_y = [@real_y - distance, @y * 32 * 4].max
    end
    if @walk_anime
      @anime_count += 1.5
    elsif @step_anime
      @anime_count += 1
    end
  end

  def move_type_random(app=50)
    app = [[100, app].min, 1].max
    case rand(100/app)
      when 0 then move_random # Random
    else
      case rand(2)
        when 0 then move_forward # Forward
        when 1 then @stop_count = 0 # Wait
      end
    end
  end

  def move_lower_left(turn_enabled = true) # No está hecho
    turn_lower_left if turn_enabled
    @direction = 1 unless @direction_fix
    if (passable?(@x, @y, 2) and passable?(@x, @y + 1, 4)) or
       (passable?(@x, @y, 4) and passable?(@x - 1, @y, 2))
      @x -= 1
      @y += 1
      increase_steps
    else
      # check_event_trigger_touch
    end
  end

  def move_lower_right(turn_enabled = true) # No está hecho
    turn_lower_right if turn_enabled
    @direction = 3 unless @direction_fix
    if (passable?(@x, @y, 2) and passable?(@x, @y + 1, 6)) or
       (passable?(@x, @y, 6) and passable?(@x + 1, @y, 2))
      @x += 1
      @y += 1
      increase_steps
    else
      # check_event_trigger_touch
    end
  end

  def move_upper_left(turn_enabled = true) # No está hecho
    turn_upper_left if turn_enabled
    @direction = 5 unless @direction_fix
    if (passable?(@x, @y, 8) and passable?(@x, @y - 1, 4)) or
       (passable?(@x, @y, 4) and passable?(@x - 1, @y, 8))
      @x -= 1
      @y -= 1
      increase_steps
    else
      # check_event_trigger_touch
    end
  end

  def move_upper_right(turn_enabled = true) # No está hecho
    turn_upper_right if turn_enabled
    @direction = 7 unless @direction_fix
    if (passable?(@x, @y, 8) and passable?(@x, @y - 1, 6)) or
       (passable?(@x, @y, 6) and passable?(@x + 1, @y, 8))
      @x += 1
      @y -= 1
      increase_steps
    else
      # check_event_trigger_touch
    end
  end

  def move_random
    move_random_6
  end
  
  def move_random_4
    case rand(4)
      when 0 then move_down(false)
      when 1 then move_left(false)
      when 2 then move_right(false)
      when 3 then move_up(false)
    end
  end
  
  def move_random_6
    case rand(6)
      when 0 then move_down(false)
      when 1 then move_upper_left(false)
      when 2 then move_upper_right(false)
      when 3 then move_lower_left(false)
      when 4 then move_lower_right(false)
     when 5 then move_up(false)
    end
  end
  
  def move_random_4_to_6
    case rand(4)
      when 0 then move_down(false)
      when 1
        case rand(2)
          when 0 then move_upper_left(false)
          when 1 then move_upper_right(false)
        end
      when 2
        case rand(2)
          when 0 then move_lower_left(false)
          when 1 then move_lower_right(false)
        end
      when 3 then move_up(false)
    end
  end

  def move_toward_player
    move_toward_player_4
  end
  
  def move_toward_player_4
    sx = @x - $game_player.x
    sy = @y - $game_player.y
    return if sx == 0 and sy == 0
    abs_sx = sx.abs
    abs_sy = sy.abs
    if abs_sx == abs_sy
      rand(2) == 0 ? abs_sx += 1 : abs_sy += 1
    end
    if abs_sx > abs_sy
      sx > 0 ? move_left : move_right
      if not moving? and sy != 0
        sy > 0 ? move_up : move_down
      end
    else
      sy > 0 ? move_up : move_down
      if not moving? and sx != 0
        sx > 0 ? move_left : move_right
      end
    end
  end
  
  def move_toward_player_6 # No está hecho
    sx = @x - $game_player.x
    sy = @y - $game_player.y
    return if sx == 0 and sy == 0
  end

  def move_away_from_player
    move_away_from_player_4
  end
  
  def move_away_from_player_4
    sx = @x - $game_player.x
    sy = @y - $game_player.y
    return if sx == 0 and sy == 0
    abs_sx = sx.abs
    abs_sy = sy.abs
    if abs_sx == abs_sy
      rand(2) == 0 ? abs_sx += 1 : abs_sy += 1
    end
    if abs_sx > abs_sy
      sx > 0 ? move_right : move_left
      if not moving? and sy != 0
        sy > 0 ? move_down : move_up
      end
    else
      sy > 0 ? move_down : move_up
      if not moving? and sx != 0
        sx > 0 ? move_right : move_left
      end
    end
  end
  
  def move_away_from_player_6 # No está hecho
    sx = @x - $game_player.x
    sy = @y - $game_player.y
    return if sx == 0 and sy == 0
  end
  
  def move_forward
    case @direction
      when 1 then move_lower_left(false)
      when 2 then move_down(false)
      when 3 then move_lower_right(false)
      when 4 then move_left(false)
      when 5 then move_upper_left(false)
      when 6 then move_right(false)
      when 7 then move_upper_right(false)
      when 8 then move_up(false)
    end
  end

  def move_backward
    last_direction_fix = @direction_fix
    @direction_fix = true
    case @direction
      when 1 then move_upper_right(false)
      when 2 then move_up(false)
      when 3 then move_upper_left(false)
      when 4 then move_right(false)
      when 5 then move_lower_right(false)
      when 6 then move_left(false)
      when 7 then move_lower_left(false)
      when 8 then move_down(false)
    end
    @direction_fix = last_direction_fix
  end

  def jump(x_plus, y_plus) # No está hecho
    if x_plus != 0 or y_plus != 0
      if x_plus.abs > y_plus.abs
        x_plus < 0 ? turn_left : turn_right
      else
        y_plus < 0 ? turn_up : turn_down
      end
    end
    new_x = @x + x_plus
    new_y = @y + y_plus
    if (x_plus == 0 and y_plus == 0) or passable?(new_x, new_y, 0)
      straighten
      @x = new_x
      @y = new_y
      distance = Math.sqrt(x_plus * x_plus + y_plus * y_plus).round
      @jump_peak = 10 + distance - @move_speed
      @jump_count = @jump_peak * 2
      @stop_count = 0
    end
  end

  def turn_clock(n=1)
    return if n <= 0 or n > 5
    dir_array = [2, 1, 5, 8, 7, 3]
    return if not dir_array.include?(@direction)
    n.times do
      i = dir_array.index(@direction)
      @direction = dir_array[i+1] != nil ? dir_array[i+1] : dir_array[0]
    end
  end
  
  def turn_anticlock(n=1)
    return if n <= 0 or n > 5
    dir_array = [3, 7, 8, 5, 1, 2]
    return if not dir_array.include?(@direction)
    n.times do
      i = dir_array.index(@direction)
      @direction = dir_array[i+1] != nil ? dir_array[i+1] : dir_array[0]
    end
  end
  
  def turn_lower_left
    unless @direction_fix
      @direction = 1
      @stop_count = 0
    end
  end
  
  def turn_lower_right
    unless @direction_fix
      @direction = 3
      @stop_count = 0
    end
  end
  
  def turn_upper_left
    unless @direction_fix
      @direction = 5
      @stop_count = 0
    end
  end
  
  def turn_upper_right
    unless @direction_fix
      @direction = 7
      @stop_count = 0
    end
  end
  
  def turn_right_90
    turn_clock
  end

  def turn_left_90
    turn_anticlock
  end

  def turn_180
    case @direction
      when 1 then turn_lower_left
      when 2 then turn_down
      when 3 then turn_lower_right
      when 4 then turn_left
      when 5 then turn_upper_left
      when 6 then turn_right
      when 7 then turn_upper_right
      when 8 then turn_up
    end
  end

  def turn_right_or_left_90
    rand(2) == 0 ? turn_clock : turn_anticlock
  end

  def turn_random
    turn_random_6
  end
  
  def turn_random_4
    case rand(4)
      when 0 then turn_down
      when 1 then turn_left
      when 2 then turn_right
      when 3 then turn_up
    end
  end
  
  def turn_random_6
    case rand(6)
      when 0 then turn_down
      when 1 then turn_upper_left
      when 2 then turn_upper_right
      when 3 then turn_lower_left
      when 4 then turn_lower_right
      when 5 then turn_up
    end
  end
  
  def turn_random_4_to_6
    case rand(4)
      when 0 then turn_down
      when 1
        case rand(2)
          when 0 then turn_upper_left(false)
          when 1 then turn_upper_right(false)
        end
      when 2
        case rand(2)
          when 0 then turn_lower_left(false)
          when 1 then turn_lower_right(false)
        end
      when 3 then turn_up(false)
    end
  end  
  
  def turn_toward_player
    turn_toward_player_4
  end
  
  def turn_toward_player_4
    sx = @x - $game_player.x
    sy = @y - $game_player.y
    return if sx == 0 and sy == 0
    if sx.abs > sy.abs
      sx > 0 ? turn_left : turn_right
    else
      sy > 0 ? turn_up : turn_down
    end
  end

  def turn_toward_player_6 # No está hecho
  end
  
  def turn_away_from_player
    turn_away_from_player_4
  end
  
  def turn_away_from_player_4
    sx = @x - $game_player.x
    sy = @y - $game_player.y
    return if sx == 0 and sy == 0
    if sx.abs > sy.abs
      sx > 0 ? turn_right : turn_left
    else
      sy > 0 ? turn_down : turn_up
    end
  end
  
  def turn_away_from_player_6 # No está hecho
  end
end
No es mucho, porque la mayoria son # No está hecho pero es algo.
avatar
Pokepik
Principiante
Principiante

0/3

Créditos 2134

Gracias : 4

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por Wecoc el 2013-08-12, 00:27

¡Gracias Pokepik! :D Caray, hiciste bastante xD

Gracias a eso y a lo que acabo de hacer ya tenemos más cosa hecha, de hecho solo faltan los "No está hecho" esos, pasar este script para que soporte el module HEXA y quitar todos los bugs. También estaría bien hacer un tileset, uno o dos characters y un mapa como demo. Calculo que vamos por un poco más de la mitad ya.

Tenemos 3 scripts

Código:
#==============================================================================
# Hextiles
#==============================================================================
# Script creado por usuarios de Mundo Maker:
# - Wecoc
# - Pokepik
# - Orochii
#==============================================================================
# 1. Hextiles Tilemap
#------------------------------------------------------------------------------
# Inspirado en el Tilemap de Derk-Jan Karrenbeld
#------------------------------------------------------------------------------
# Nota: Los autotiles leen los frames de dos en dos porque cada frame tiene dos
# variedades de autotile según su y.
#==============================================================================

module HEXA
  WIDTH = 32  # Tamaño del tile. Recomendable número par. Siempre < 32
  HEIGHT = 32 # Tamaño del tile. Recomendable número par. Siempre < 32
  SUPP = 8    # Superposición entre hexágonos, normalmente WIDTH/4.
  QWEASD_SUP = true # Soporte de movimiento con QWEASD
  DIR4_SUP = true # Soporte de movimiento con las teclas de dirección
  PRIORITY_FIX = true # Si está activado, la prioridad 1 es de suelo.
end

class Tilemap
  attr_reader :tileset
  attr_reader :autotiles
  attr_reader :flash_data
  attr_reader :priorities
  attr_reader :visible
  attr_reader :ox, :oy
  attr_writer :autotiles

  WindowRect = Rect.new(0,0,640,480)
  BitmapRect = Rect.new(0,0,640 + 64, 480 + 64)
  
  BitmapWindowOffsetX = (BitmapRect.width-WindowRect.width)/2/24
  BitmapWindowOffsetY = (BitmapRect.height-WindowRect.height)/2/32

  AutotileLength = 10 # Frames por cada frame del autotile
  
  MAX_MapWidth = 50 # Máximo de tiles que soporta el sistema Hextile
  MAX_MapHeight = 50 # Máximo de tiles que soporta el sistema Hextile
  
  # Orden de las partes del autotile
  Autotiles = [
    [ [27, 28, 33, 34], [ 5, 28, 33, 34], [27,  6, 33, 34], [ 5,  6, 33, 34],
      [27, 28, 33, 12], [ 5, 28, 33, 12], [27,  6, 33, 12], [ 5,  6, 33, 12] ],
    [ [27, 28, 11, 34], [ 5, 28, 11, 34], [27,  6, 11, 34], [ 5,  6, 11, 34],
      [27, 28, 11, 12], [ 5, 28, 11, 12], [27,  6, 11, 12], [ 5,  6, 11, 12] ],
    [ [25, 26, 31, 32], [25,  6, 31, 32], [25, 26, 31, 12], [25,  6, 31, 12],
      [15, 16, 21, 22], [15, 16, 21, 12], [15, 16, 11, 22], [15, 16, 11, 12] ],
    [ [29, 30, 35, 36], [29, 30, 11, 36], [ 5, 30, 35, 36], [ 5, 30, 11, 36],
      [39, 40, 45, 46], [ 5, 40, 45, 46], [39,  6, 45, 46], [ 5,  6, 45, 46] ],
    [ [25, 30, 31, 36], [15, 16, 45, 46], [13, 14, 19, 20], [13, 14, 19, 12],
      [17, 18, 23, 24], [17, 18, 11, 24], [41, 42, 47, 48], [ 5, 42, 47, 48] ],
    [ [37, 38, 43, 44], [37,  6, 43, 44], [13, 18, 19, 24], [13, 14, 43, 44],
      [37, 42, 43, 48], [17, 18, 47, 48], [13, 18, 43, 48], [ 1,  2,  7,  8] ]
  ]

  def initialize(viewport = nil, rpgmap = nil)
    @autotiles    = Array.new(6, nil)
    @oldautotiles = Array.new(6, nil)
    @viewport   = viewport ? viewport : Viewport.new(WindowRect)
    @sprite = Sprite.new(@viewport)
    @sprite.bitmap = Bitmap.new(MAX_MapWidth * (HEXA::WIDTH - HEXA::SUPP),
    MAX_MapHeight * HEXA::HEIGHT + 64)
    @priority_ids     = {}  # IDs de prioridad
    @normal_tiles     = {}  # Tiles normales (no auto) - Array de Bitmaps
    @auto_tiles       = {}  # Autotiles - Array de Bitmaps
    @priority_sprites = []  # Prioridades
    @autotile_sprites = []  # Autotiles
    @flashing_sprites = []  # Flash
    @disposed   = false
    @visible    = true
    @flashing   = true
    @can_draw   = true
    @ox, @oy = 0, 0
  end

  def sprite_bitmap
    return @sprite.bitmap
  end

  def data_tilesets
    $data_tilesets ||= load_data("Data/Tilesets.rxdata")
  end

  def disposed?
    @disposed
  end

  def dispose
    spp = [@sprite] + @normal_tiles.values + @auto_tiles.values +
   @priority_sprites + @autotile_sprites + @flashing_sprites
    for sprite in spp
      sprite = sprite[0] if sprite.is_a?(Array)
      sprite.dispose if sprite.is_a?(Bitmap)
    end
    @priority_ids     = {}  # IDs de prioridad
    @normal_tiles     = {}  # Tiles normales (no auto) - Array de Bitmaps
    @priority_sprites = []  # Prioridades
    @autotile_sprites = []  # Autotiles
    @flashing_sprites = []  # Flash
    @disposed = true
  end

  def visible?
    @visible
  end

  def autotiles_changed?
    @oldautotiles != @autotiles
  end

  def visible=(value)
    @visible = value
    spp = [@sprite] + @priority_sprites + @autotile_sprites + @flashing_sprites
    for sprite in spp
      sprite = sprite[0] if sprite.is_a?(Array)
      sprite.visible = value
    end
  end

  def tileset=(value)
    return if @tileset == value
    value = value.tileset_name if value.is_a?(RPG::Tileset)
    @tileset = RPG::Cache.tileset(value) if value.is_a?(String)
    @tileset = value if value.is_a?(Bitmap)
    redraw_tileset if @can_draw
  end

  def priorities=(value)
    return if @priorities == value
    @priorities = value
    redraw_priorities if @can_draw
  end

  def flash_data=(*coord, &value)
    return if @flash_data[coord[0],coord[1]] == value
    flashing = !@flash_data[x,y].nil?
    @flash_data[x,y] = value
  end

  def map_data
    @map_data
  end

  def map_data=(value)
    return if @map_data == value
    @map_data = value
    @flash_data = Table.new(@map_data.xsize, @map_data.ysize)
    draw_region if @can_draw and @priorities and @tileset
  end

  def tile_id(x, y, z)
    return map_data[x, y, z]
  end

  def priority(*args)
    return @priorities[args[0]] if args.size == 1
    return @priorities[tile_id(args[0], args[1], args[2])]
  end

  def redraw_tileset
    sprite_bitmap.clear
    @normal_tiles.clear
    @auto_tiles.clear
    @autotile_sprites.each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
    @priority_sprites.each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
    @autotile_sprites.clear
    @priority_sprites.clear
    draw_region if @can_draw and @priorities and @tileset
  end

  def redraw_priorities
    @autotile_sprites.each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
    @priority_sprites.each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
    @autotile_sprites.clear
    @priority_sprites.clear
    @priority_ids.clear
    for z in 0...3
      for y in 0...map_data.ysize
        for x in 0...map_data.xsize
          next if (id = tile_id(x, y, z)) == 0
          next if (p = priority(id)) == 0
          @priority_ids[id] = p
        end
      end
    end
    draw_region if @can_draw and @priorities and @tileset
  end

  def redraw_autotiles
    @auto_tiles.clear
    @autotile_sprites.each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
    @autotile_sprites.clear
    @oldautotiles = @autotiles
    draw_region if @can_draw and @priorities and @tileset
  end

  def draw_current_region
    left_x = @ox / (HEXA::WIDTH - HEXA::SUPP)
    top_y = @oy / HEXA::HEIGHT
    sppox = left_x * (HEXA::WIDTH - HEXA::SUPP) +
    @ox % (HEXA::WIDTH - HEXA::SUPP) + HEXA::WIDTH
    sppoy = top_y * HEXA::HEIGHT +
    @oy % HEXA::HEIGHT + (HEXA::HEIGHT + HEXA::HEIGHT/2)
    @sprite.ox = sppox
    @sprite.oy = sppoy
    for i in 0...@priority_sprites.size
      @priority_sprites[i][0].ox = sppox
      @priority_sprites[i][0].oy = sppoy
    end
    for i in 0...@autotile_sprites.size
      @autotile_sprites[i][0].ox = sppox
      @autotile_sprites[i][0].oy = sppoy
    end
  end

  def draw_region
    left_x = @ox / (HEXA::WIDTH - HEXA::SUPP)
    top_y = @oy / HEXA::HEIGHT
    @sprite.ox = BitmapWindowOffsetX * HEXA::WIDTH
    wecoc_y = left_x%2==1 ? (HEXA::HEIGHT/2) : 0
    @sprite.oy = BitmapWindowOffsetY * HEXA::HEIGHT + wecoc_y
    for x in 0...map_data.xsize+1
      for y in 0...map_data.ysize+1
        for z in 0..2
          if x%2==0
            draw_tile(x, y, tile_id(x + left_x - BitmapWindowOffsetX,
            y + top_y - BitmapWindowOffsetY, z),
            x + left_x - BitmapWindowOffsetX,
            y + top_y - BitmapWindowOffsetY, z)
          end
        end
      end
    end
    for x in 0...map_data.xsize+1
      for y in 0...map_data.ysize+1
        for z in 0..2
          if x%2==1
            draw_tile(x, y, tile_id(x + left_x - BitmapWindowOffsetX,
            y + top_y - BitmapWindowOffsetY, z),
            x + left_x - BitmapWindowOffsetX,
            y + top_y - BitmapWindowOffsetY, z)
          end
        end
      end
    end
    @sprite.update
    Graphics.frame_reset
  end

  def draw_tile(x, y, tile_id, tx, ty, tz, src_bitmap = nil)
    return if x < 0 or y < 0
    return if tile_id == nil
    if tile_id < 384
      return draw_autotile(x, y, tile_id, tx, ty, tz, src_bitmap = src_bitmap)
    end
    if (src_bitmap = @normal_tiles[tile_id]).nil?
      src_bitmap = Bitmap.new(HEXA::WIDTH, HEXA::HEIGHT)
      src_rect = Rect.new((tile_id - 384) % 8 * 32, (tile_id - 384) / 8 * 32,
        HEXA::WIDTH, HEXA::HEIGHT)
      src_bitmap.blt(0, 0, @tileset, src_rect)
      @normal_tiles[tile_id] = src_bitmap
    end
    wecoc_y = x%2==0 ? (HEXA::HEIGHT/2) : 0
    if @priority_ids[tile_id].nil?
      sprite_bitmap.blt(x * (HEXA::WIDTH - HEXA::SUPP) + @ox * HEXA::WIDTH,
        y * HEXA::HEIGHT + wecoc_y + @oy, src_bitmap,
        Rect.new(0,0,HEXA::WIDTH,HEXA::HEIGHT))
    else
      sprite = Sprite.new(@viewport)
      sprite.visible = visible
      sprite.bitmap = src_bitmap
      sprite.x = x * (HEXA::WIDTH - HEXA::SUPP) + @ox * HEXA::WIDTH
      sprite.y = y * HEXA::HEIGHT + wecoc_y + @oy
      sprite.ox = @ox + @ox % (HEXA::WIDTH - HEXA::SUPP) + HEXA::WIDTH
      sprite.oy = @oy + @oy % HEXA::HEIGHT + (HEXA::HEIGHT + HEXA::HEIGHT/2)
      sprite.z = @viewport.z + y * @priority_ids[tile_id] * HEXA::HEIGHT
      if HEXA::PRIORITY_FIX
        sprite.z -= HEXA::HEIGHT
      end
      @priority_sprites << [sprite, tx, ty, tz]
    end
  end

  def draw_autotile(x, y, tile_id, tx, ty, tz, src_bitmap = nil)
    return if x < 0 or y < 0
    return if tile_id == nil or tile_id >= 384
    return if tile_id == 0
    autotile = @autotiles[tile_id/48-1]
    return if autotile.nil? or autotile.disposed?
    if autotile.height == 32
      frames = autotile.width / (32 * 2)
    else
      frames = autotile.width / (96 * 2)
    end
    return if frames == 0
    if x%2 == 0
      start_frame = ((Graphics.frame_count/AutotileLength) % frames) + 1
    else
      start_frame = (Graphics.frame_count/AutotileLength) % frames
    end
    if (src_bitmap_array = @auto_tiles[tile_id]).nil?
      @auto_tiles[tile_id] = []
      if autotile.height == 32
        for i in 0...frames*2
          this_frame_bitmap = Bitmap.new(HEXA::WIDTH, HEXA::HEIGHT)
         src_rect = Rect.new(i * 32, 0, HEXA::WIDTH, HEXA::HEIGHT)
          this_frame_bitmap.blt(0, 0, autotile, src_rect)
          @auto_tiles[tile_id] << this_frame_bitmap
        end
        src_bitmap_array = @auto_tiles[tile_id]
      else
        for i in 0...frames*2
          this_frame_bitmap = Bitmap.new(HEXA::WIDTH, HEXA::HEIGHT)
          tiles = Autotiles[(tile_id % 48)>>3][(tile_id % 48)&7]
          for j in 0...4
            tile_position = tiles[j] - 1
            src_rect = Rect.new(tile_position % 6 * 16 + i * 96,
              tile_position / 6 * 16, HEXA::WIDTH/2, HEXA::HEIGHT/2)
            this_frame_bitmap.blt(j % 2 * HEXA::WIDTH/2, j / 2 * HEXA::HEIGHT/2,
              autotile, src_rect)
          end
          @auto_tiles[tile_id][i] = this_frame_bitmap
        end
        src_bitmap_array = @auto_tiles[tile_id]
      end
    end
    src_bitmap = src_bitmap_array[start_frame]
    return if src_bitmap.nil?
    wecoc_y = x%2==0 ? (HEXA::HEIGHT/2) : 0
    if @priority_ids[tile_id].nil? # and autotile.width == 32
      sprite_bitmap.blt(x * (HEXA::WIDTH - HEXA::SUPP) + @ox * HEXA::WIDTH,
        y * HEXA::HEIGHT + wecoc_y + @oy, src_bitmap,
        Rect.new(0,0,HEXA::WIDTH,HEXA::HEIGHT))
    else
      priority = (@priority_ids[tile_id] or 0)
      sprite = Sprite.new(@viewport)
      sprite.visible = visible
      sprite.bitmap = src_bitmap
      sprite.x = x * (HEXA::WIDTH - HEXA::SUPP) + @ox * HEXA::WIDTH
      sprite.y = y * HEXA::HEIGHT + wecoc_y + @oy
      sprite.ox = @ox + @ox % (HEXA::WIDTH - HEXA::SUPP) + HEXA::WIDTH
      sprite.oy = @oy + @oy % HEXA::HEIGHT + (HEXA::HEIGHT + HEXA::HEIGHT/2)
      sprite.z = @viewport.z + y * priority * HEXA::HEIGHT
      if HEXA::PRIORITY_FIX
        sprite.z -= HEXA::HEIGHT
      end
      @autotile_sprites << [sprite, tx, ty, tz, start_frame]
    end
  end

  def get_update_autotile(tile_id, start_frame)
    return if tile_id == nil or tile_id >= 384
    return if tile_id == 0
    autotile = @autotiles[tile_id/48-1]
    return if autotile.nil? or autotile.disposed?
    if autotile.height == 32
      frames = autotile.width / (32 * 2)
    else
      frames = autotile.width / (96 * 2)
    end
    current_frame = (Graphics.frame_count/AutotileLength) % frames * 2
    src_bitmap = @auto_tiles[tile_id][current_frame + start_frame]
    return src_bitmap  
  end

  def ox=(value)
    return unless @ox != value
    @ox = value
  end

  def oy=(value)
    return unless @oy != value
    @oy = value
  end

  def update
    redraw_autotiles if autotiles_changed?
    return if not visible?
    update_autotiles if (Graphics.frame_count % AutotileLength) == 0
    draw_current_region
  end

  def update_autotiles
    left_x = @ox / HEXA::WIDTH
    top_y = @oy / HEXA::HEIGHT
    for sprite in @autotile_sprites
      real_sprite, tx, ty, tz, start_frame = sprite
      tile_id = tile_id(tx, ty, tz)
      real_sprite.bitmap = get_update_autotile(tile_id, start_frame)
    end
  end
end
Código:
#==============================================================================
# Hextiles
#==============================================================================
# Script creado por usuarios de Mundo Maker:
# - Wecoc
# - Pokepik
# - Orochii
#==============================================================================
# 2. QWE-ASD Support
#==============================================================================#

module Input
  GKAS = Win32API.new( "user32", "GetAsyncKeyState", "i", "i" )
  def self.dir6
    if    GKAS.call(0x51).abs&0x8000 == 0x8000  ; return 'Q'
    elsif GKAS.call(0x57).abs&0x8000 == 0x8000  ; return 'W'
    elsif GKAS.call(0x45).abs&0x8000 == 0x8000  ; return 'E'
    elsif GKAS.call(0x41).abs&0x8000 == 0x8000  ; return 'A'
    elsif GKAS.call(0x53).abs&0x8000 == 0x8000  ; return 'S'
    elsif GKAS.call(0x44).abs&0x8000 == 0x8000  ; return 'D'
    else ; return 0
    end
  end
end

class Game_Player < Game_Character
  def update
    last_moving = moving?
    unless moving? or $game_system.map_interpreter.running? or
           @move_route_forcing or $game_temp.message_window_showing
      if HEXA::QWEASD_SUP or ($DEBUG and Input.press?(Input::CTRL))
        case Input.dir6
        when 'Q'
          move_upper_left
        when 'W'
          move_up
        when 'E'
          move_upper_right
        when 'A'
          move_lower_left
        when 'S'
          move_down
        when 'D'
          move_lower_right
        end
      end
      if HEXA::DIR4_SUP or ($DEBUG and Input.press?(Input::CTRL))
        case Input.dir4
        when 2
         move_down
        when 4
          @x%2==0 ? move_upper_left : move_lower_left
        when 6
          @x%2==0 ? move_upper_right : move_lower_right
        when 8
          move_up
        end
      end
    end
    last_real_x = @real_x
    last_real_y = @real_y
    super
    if @real_y > last_real_y and @real_y - $game_map.display_y > CENTER_Y
      $game_map.scroll_down(@real_y - last_real_y)
    end
    if @real_x < last_real_x and @real_x - $game_map.display_x < CENTER_X
      $game_map.scroll_left(last_real_x - @real_x)
    end
    if @real_x > last_real_x and @real_x - $game_map.display_x > CENTER_X
      $game_map.scroll_right(@real_x - last_real_x)
    end
    if @real_y < last_real_y and @real_y - $game_map.display_y < CENTER_Y
      $game_map.scroll_up(last_real_y - @real_y)
    end
    unless moving?
      if last_moving
        result = check_event_trigger_here([1,2])
        if result == false
          unless $DEBUG and Input.press?(Input::CTRL)
            if @encounter_count > 0
              @encounter_count -= 1
            end
          end
        end
      end
      if Input.trigger?(Input::C)
        check_event_trigger_here([0])
        check_event_trigger_there([0,1,2])
      end
    end
  end
end
Código:
#==============================================================================
# Hextiles
#==============================================================================
# Script creado por usuarios de Mundo Maker:
# - Wecoc
# - Pokepik
# - Orochii
#==============================================================================
# 3. Character Features
#==============================================================================

class Game_Character
  def passable?(x, y, d) # No está hecho
    case d
    when 1 # Lower Left
      new_x = x - 1
      wecoc_y = @x%2==1 ? 1 : 0
      new_y = y + wecoc_y
    when 2 # Down
      new_x = x
      new_y = y + 1
    when 3 # Lower Right
      new_x = x + 1
      wecoc_y = @x%2==1 ? 1 : 0
      new_y = y + wecoc_y
    when 5 # Upper Left
      new_x = x-1
      wecoc_y = @x%2==0 ? 1 : 0
      new_y = y - wecoc_y
    when 7 # Upper Right
      new_x = x+1
      wecoc_y = @x%2==0 ? 1 : 0
      new_y = y - wecoc_y
    when 8 # Up
      new_x = x
      new_y = y - 1
    else
      new_x = x
      new_y = y
    end
    return false unless $game_map.valid?(new_x, new_y)
    if self.is_a?(Game_Player)
      return true if $DEBUG and Input.press?(Input::CTRL)
    end
    return true if @through
    if $game_map.data[x,y,0] == 0 and
      $game_map.data[x,y,1] == 0 and
      $game_map.data[x,y,2] == 0
      return false
    end
    if $game_map.data[new_x,new_y,0] == 0 and
      $game_map.data[new_x,new_y,1] == 0 and
      $game_map.data[new_x,new_y,2] == 0
      return false
    end
    return false unless $game_map.passable?(x, y, 0)
    return false unless $game_map.passable?(new_x, new_y, 0)

    # Falta la pasibilidad por direcciones (la más complicada)
   
    for event in $game_map.events.values
      if event.x == new_x and event.y == new_y
        unless event.through
          return false if self != $game_player
          return false if event.character_name != ""
        end
      end
    end
    if $game_player.x == new_x and $game_player.y == new_y
      unless $game_player.through
        return false if @character_name != ""
      end
    end
    return true
  end

  def moving?
    wecoc_y = @x%2==0 ? 16 : 0
    return (@real_x != @x * 24 * 4 or @real_y != (@y * 32 - wecoc_y) * 4)
  end
 
  def tile_neighbors(x, y, d=0)
    if x%2==1
      array = [[x-1,y+1],[x,y-1],[x+1,y+1],[x,y],[x-1,y],[x,y],[x+1,y],[x,y+1]]
    else
      array = [[x-1,y],[x,y-1],[x+1,y],[x,y],[x-1,y-1],[x,y],[x+1,y-1],[x,y+1]]
    end
    return d==0 ? array : array[d-1]
  end
   
  def ring_tiles(distance)
    get_ring_tiles(self.x, self.y, distance)
  end
 
  def get_ring_tiles(x, y, distance)
    case distance
    when 0 then return [[x, y]]
    when 1 then return tile_neighbors(x,y)
    when 2
      neighbors = tile_neighbors(x,y)
      new_neighbors = []
      for i in 0...neighbors.size
        for j in 1..8
          new_neighbors.push(tile_neighbors(neighbors[i][0], neighbors[i][1], j))
        end
      end
      new_neighbors.uniq!
      for i in 0...neighbors.size
        new_neighbors.delete(neighbors[i])
      end
      new_neighbors.delete([x,y])
      return new_neighbors
    else
      neighbors = get_ring_tiles(x, y, distance-1)
      all_neighbors = []
      for i in 0...distance-1
        all_neighbors.push(get_ring_tiles(x, y, i))
      end
      new_neighbors = []
      for i in 0...neighbors.size
        for j in 1..8
          new_neighbors.push(tile_neighbors(neighbors[i][0], neighbors[i][1], j))
        end
      end
      new_neighbors.uniq!
      for i in 0...neighbors.size
        new_neighbors.delete(neighbors[i])
      end
      for i in 0...all_neighbors.size
        for j in 0...all_neighbors[i].size
          new_neighbors.delete(all_neighbors[i][j])
        end
      end
      new_neighbors.delete([x,y])
      return new_neighbors
    end
  end
 
  def moveto(x, y)
    @x = x % $game_map.width
    @y = y % $game_map.height
    wecoc_y = @x%2==0 ? 16 : 0
    @real_x = @x * 24 * 4
    @real_y = (@y * 32 - wecoc_y) * 4
    @prelock_direction = 0
  end

  def screen_x
    return (@real_x - $game_map.display_x + 3) / 4 + 32 / 4
  end

  def screen_y
    y = (@real_y - $game_map.display_y + 3) / 4 + 32
    if @jump_count >= @jump_peak
      n = @jump_count - @jump_peak
    else
      n = @jump_peak - @jump_count
    end
    return y - (@jump_peak * @jump_peak - n * n) / 2
  end

  def bush_depth(depth=12)
    return 0 if @tile_id > 0 or @always_on_top
    if @jump_count == 0 and $game_map.bush?(@x, @y)
      return depth
    else
      return 0
    end
  end

  def update_jump # No está hecho
    @jump_count -= 1
    @real_x = (@real_x * @jump_count + @x * 24 * 4) / (@jump_count + 1)
    @real_y = (@real_y * @jump_count + @y * 32 * 4) / (@jump_count + 1)
  end

  def update_move
    @false_move_speed = @move_speed if @false_move_speed == nil
    distance = 2 ** @false_move_speed
    wecoc_y = @x%2==0 ? 16 : 0
    if (@y * 32 - wecoc_y) * 4 > @real_y # Move down
      @real_y = [@real_y + distance / 1.5, (@y * 32 - wecoc_y) * 4].min
    end
    if @x * 24 * 4 < @real_x # Move left
      @real_x = [@real_x - distance / 1, @x * 24 * 4].max
    end
    if @x * 24 * 4 > @real_x # Move right
      @real_x = [@real_x + distance / 1, @x * 24 * 4].min
    end
    if (@y * 32 - wecoc_y) * 4 < @real_y # Move up
      @real_y = [@real_y - distance / 1.5, (@y * 32 - wecoc_y) * 4].max
    end
    if @walk_anime
      @anime_count += 1.5
    elsif @step_anime
      @anime_count += 1
    end
  end

  def move_type_random(app=50)
    app = [[100, app].min, 1].max
    case rand(100/app)
      when 0 then move_random # Random
    else
      case rand(2)
        when 0 then move_forward # Forward
        when 1 then @stop_count = 0 # Wait
      end
    end
  end

  def move_up(turn_enabled = true)
    @false_move_speed = @move_speed
    turn_up if turn_enabled
    if passable?(@x, @y, 8)
      turn_up
      @y -= 1
      increase_steps
    else
      check_event_trigger_touch(@x, @y-1)
    end
  end
 
  def move_down(turn_enabled = true)
    @false_move_speed = @move_speed
    turn_down if turn_enabled
    if passable?(@x, @y, 2)
      turn_down
      @y += 1
      increase_steps
    else
      check_event_trigger_touch(@x, @y+1)
    end
  end
 
  def move_lower_left(turn_enabled = true)
    @false_move_speed = @move_speed / 1.33
    turn_lower_left if turn_enabled
    @direction = 1 unless @direction_fix
    if passable?(@x, @y, 1)
      @y += 1 if @x%2==1
      @x -= 1
      increase_steps
    else
      crd = tile_neighbors(@x, @y, 1)
      check_event_trigger_touch(crd[0], crd[1])
    end
  end

  def move_lower_right(turn_enabled = true)
    @false_move_speed = @move_speed / 1.33
    turn_lower_right if turn_enabled
    @direction = 3 unless @direction_fix
    if passable?(@x, @y, 3)
      @y += 1 if @x%2==1
      @x += 1
      increase_steps
    else
      crd = tile_neighbors(@x, @y, 3)
      check_event_trigger_touch(crd[0], crd[1])
    end
  end

  def move_upper_left(turn_enabled = true)
    @false_move_speed = @move_speed / 1.33
    turn_upper_left if turn_enabled
    @direction = 5 unless @direction_fix
    if passable?(@x, @y, 5)
      @y -= 1 if @x%2==0
      @x -= 1
      increase_steps
    else
      crd = tile_neighbors(@x, @y, 5)
      check_event_trigger_touch(crd[0], crd[1])
    end
  end

  def move_upper_right(turn_enabled = true)
    @false_move_speed = @move_speed / 1.33
    turn_upper_right if turn_enabled
    @direction = 7 unless @direction_fix
    if passable?(@x, @y, 7)
      @y -= 1 if @x%2==0
      @x += 1
      increase_steps
    else
      crd = tile_neighbors(@x, @y, 7)
      check_event_trigger_touch(crd[0], crd[1])
    end
  end

  def move_random
    move_random_6
  end
 
  def move_random_4
    case rand(4)
      when 0 then move_down(false)
      when 1 then move_left(false)
      when 2 then move_right(false)
      when 3 then move_up(false)
    end
  end
 
  def move_random_6
    case rand(6)
      when 0 then move_down(false)
      when 1 then move_upper_left(false)
      when 2 then move_upper_right(false)
      when 3 then move_lower_left(false)
      when 4 then move_lower_right(false)
      when 5 then move_up(false)
    end
  end
 
  def move_random_4_to_6
    case rand(4)
      when 0 then move_down(false)
      when 1
        case rand(2)
          when 0 then move_upper_left(false)
          when 1 then move_upper_right(false)
        end
      when 2
        case rand(2)
          when 0 then move_lower_left(false)
          when 1 then move_lower_right(false)
        end
      when 3 then move_up(false)
    end
  end

  def move_toward_player
    move_toward_player_6
  end
 
  def move_toward_player_4
    sx = @x - $game_player.x
    sy = @y - $game_player.y
    return if sx == 0 and sy == 0
    abs_sx = sx.abs
    abs_sy = sy.abs
    if abs_sx == abs_sy
      rand(2) == 0 ? abs_sx += 1 : abs_sy += 1
    end
    if abs_sx > abs_sy
      sx > 0 ? move_left : move_right
      if not moving? and sy != 0
        sy > 0 ? move_up : move_down
      end
    else
      sy > 0 ? move_up : move_down
      if not moving? and sx != 0
        sx > 0 ? move_left : move_right
      end
    end
  end
 
  def move_toward_player_6 # No está hecho
  end

  def move_away_from_player
    move_away_from_player_6
  end
 
  def move_away_from_player_4
    sx = @x - $game_player.x
    sy = @y - $game_player.y
    return if sx == 0 and sy == 0
    abs_sx = sx.abs
    abs_sy = sy.abs
    if abs_sx == abs_sy
      rand(2) == 0 ? abs_sx += 1 : abs_sy += 1
    end
    if abs_sx > abs_sy
      sx > 0 ? move_right : move_left
      if not moving? and sy != 0
        sy > 0 ? move_down : move_up
      end
    else
      sy > 0 ? move_down : move_up
      if not moving? and sx != 0
        sx > 0 ? move_right : move_left
      end
    end
  end
 
  def move_away_from_player_6 # No está hecho
  end
 
  def move_forward
    case @direction
      when 1 then move_lower_left(false)
      when 2 then move_down(false)
      when 3 then move_lower_right(false)
      when 4 then move_left(false)
      when 5 then move_upper_left(false)
      when 6 then move_right(false)
      when 7 then move_upper_right(false)
      when 8 then move_up(false)
    end
  end

  def move_backward
    last_direction_fix = @direction_fix
    @direction_fix = true
    case @direction
      when 1 then move_upper_right(false)
      when 2 then move_up(false)
      when 3 then move_upper_left(false)
      when 4 then move_right(false)
      when 5 then move_lower_right(false)
      when 6 then move_left(false)
      when 7 then move_lower_left(false)
      when 8 then move_down(false)
    end
    @direction_fix = last_direction_fix
  end

  def jump(x_plus, y_plus) # No está hecho
    if x_plus != 0 or y_plus != 0
      if x_plus.abs > y_plus.abs
        x_plus < 0 ? turn_left : turn_right
      else
        y_plus < 0 ? turn_up : turn_down
      end
    end
    new_x = @x + x_plus
    new_y = @y + y_plus
    if (x_plus == 0 and y_plus == 0) or passable?(new_x, new_y, 0)
      straighten
      @x = new_x
      @y = new_y
      distance = Math.sqrt(x_plus * x_plus + y_plus * y_plus).round
      @jump_peak = 10 + distance - @move_speed
      @jump_count = @jump_peak * 2
      @stop_count = 0
    end
  end

  def turn_clock(n=1)
    return if n <= 0 or n > 5
    dir_array = [2, 1, 5, 8, 7, 3]
    return if not dir_array.include?(@direction)
    n.times do
      i = dir_array.index(@direction)
      @direction = dir_array[i+1] != nil ? dir_array[i+1] : dir_array[0]
    end
  end
 
  def turn_anticlock(n=1)
    return if n <= 0 or n > 5
    dir_array = [3, 7, 8, 5, 1, 2]
    return if not dir_array.include?(@direction)
    n.times do
      i = dir_array.index(@direction)
      @direction = dir_array[i+1] != nil ? dir_array[i+1] : dir_array[0]
    end
  end
 
  def turn_lower_left
    unless @direction_fix
      @direction = 1
      @stop_count = 0
    end
  end
 
  def turn_lower_right
    unless @direction_fix
      @direction = 3
      @stop_count = 0
    end
  end
 
  def turn_upper_left
    unless @direction_fix
      @direction = 5
      @stop_count = 0
    end
  end
 
  def turn_upper_right
    unless @direction_fix
      @direction = 7
      @stop_count = 0
    end
  end
 
  def turn_right_90
    turn_clock
  end

  def turn_left_90
    turn_anticlock
  end

  def turn_180
    case @direction
      when 1 then turn_lower_left
      when 2 then turn_down
      when 3 then turn_lower_right
      when 4 then turn_left
      when 5 then turn_upper_left
      when 6 then turn_right
      when 7 then turn_upper_right
      when 8 then turn_up
    end
  end

  def turn_right_or_left_90
    rand(2) == 0 ? turn_clock : turn_anticlock
  end

  def turn_random
    turn_random_6
  end
 
  def turn_random_4
    case rand(4)
      when 0 then turn_down
      when 1 then turn_left
      when 2 then turn_right
      when 3 then turn_up
    end
  end
 
  def turn_random_6
    case rand(6)
      when 0 then turn_down
      when 1 then turn_upper_left
      when 2 then turn_upper_right
      when 3 then turn_lower_left
      when 4 then turn_lower_right
      when 5 then turn_up
    end
  end
 
  def turn_random_4_to_6
    case rand(4)
      when 0 then turn_down
      when 1
        case rand(2)
          when 0 then turn_upper_left(false)
          when 1 then turn_upper_right(false)
        end
      when 2
        case rand(2)
          when 0 then turn_lower_left(false)
          when 1 then turn_lower_right(false)
        end
      when 3 then turn_up(false)
    end
  end 
 
  def turn_toward_player
    turn_toward_player_6
  end
 
  def turn_toward_player_4
    sx = @x - $game_player.x
    sy = @y - $game_player.y
    return if sx == 0 and sy == 0
    if sx.abs > sy.abs
      sx > 0 ? turn_left : turn_right
    else
      sy > 0 ? turn_up : turn_down
    end
  end

  def turn_toward_player_6 # No está hecho
  end
 
  def turn_away_from_player
    turn_away_from_player_6
  end
 
  def turn_away_from_player_4
    sx = @x - $game_player.x
    sy = @y - $game_player.y
    return if sx == 0 and sy == 0
    if sx.abs > sy.abs
      sx > 0 ? turn_right : turn_left
    else
      sy > 0 ? turn_down : turn_up
    end
  end
 
  def turn_away_from_player_6 # No está hecho
  end
end

class Game_Player < Game_Character
 
  CENTER_X = (640 / 2 - 32 / 2) * 4  # Center screen x-coordinate * 4
  CENTER_Y = (480 / 2 - 32 / 2) * 4  # Center screen y-coordinate * 4
 
  def passable?(x, y, d)
    super
  end

  def center(x, y) # No está hecho
    max_x = ($game_map.width - 20) * 32 * 4
    max_y = ($game_map.height - 15) * 32 * 4
    $game_map.display_x = [0, [x * 32 * 4 - CENTER_X, max_x].min].max
    $game_map.display_y = [0, [y * 32 * 4 - CENTER_Y, max_y].min].max
  end

  def check_event_trigger_there(triggers) # No está hecho
    result = false
    return result if $game_system.map_interpreter.running?
    new_x = @x + (@direction == 6 ? 1 : @direction == 4 ? -1 : 0)
    new_y = @y + (@direction == 2 ? 1 : @direction == 8 ? -1 : 0)
    for event in $game_map.events.values
      if event.x == new_x and event.y == new_y and
        triggers.include?(event.trigger)
        if not event.jumping? and not event.over_trigger?
          event.start
          result = true
        end
      end
    end
    if result == false
      if $game_map.counter?(new_x, new_y)
        new_x += (@direction == 6 ? 1 : @direction == 4 ? -1 : 0)
        new_y += (@direction == 2 ? 1 : @direction == 8 ? -1 : 0)
        for event in $game_map.events.values
          if event.x == new_x and event.y == new_y and
            triggers.include?(event.trigger)
            if not event.jumping? and not event.over_trigger?
              event.start
              result = true
            end
          end
        end
      end
    end
    return result
  end
end

class Sprite_Character < RPG::Sprite
  def update
    super
    if @tile_id != @character.tile_id or
      @character_name != @character.character_name or
      @character_hue != @character.character_hue
      @tile_id = @character.tile_id
      @character_name = @character.character_name
      @character_hue = @character.character_hue
      if @tile_id >= 384
        self.bitmap = RPG::Cache.tile($game_map.tileset_name,
          @tile_id, @character.character_hue)
        self.src_rect.set(0, 0, 32, 32)
        self.ox = 16
        self.oy = 32
      else
        self.bitmap = RPG::Cache.character(@character.character_name,
          @character.character_hue)
        @cw = bitmap.width / 4
        @ch = bitmap.height / 6
        self.ox = @cw / 2
        self.oy = @ch
      end
    end
    self.visible = (not @character.transparent)
    if @tile_id == 0
      sx = @character.pattern * @cw
      dir_array = [1, 0, 2, 0, 3, 0, 4, 5]
      sy = dir_array[@character.direction-1] * @ch
      self.src_rect.set(sx, sy, @cw, @ch)
    end
    self.x = @character.screen_x
    self.y = @character.screen_y
    self.z = @character.screen_z(@ch)
    self.opacity = @character.opacity
    self.blend_type = @character.blend_type
    self.bush_depth = @character.bush_depth
    if @character.animation_id != 0
      animation = $data_animations[@character.animation_id]
      animation(animation, true)
      @character.animation_id = 0
    end
  end
end
Este es el template de chara que usé y que como podréis ver funciona, excepto por la pasabilidad.


Como he dicho, vamos por un poco más de la mitad... eso significa que aún queda xD Gente, animaos, que aún estais a tiempo de participar.
avatar
Wecoc
Administrador
Administrador



Créditos 12211

Gracias : 632

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por youkai el 2013-08-12, 20:19

Lo siento wec...pero no me acabo de enterar del todo de como funcionan las matematicas de los hexatiles(tampoco he buscado ninguna referencia para enterarme XDDDD) Por esa razon es que he sido de tan poca ayuda... Fuera de eso, las mates tampoco son mi fuerte en la programacion...yo me decanto mas por la logica.
Si pudieras explicarme como funcionan los calculos(mediante un MP si quieres) entonces debo ser capaz de ayudar :( Perdonen mi incompetencia...
Tambien dime que es lo que falta y ya me pondre a romperme hasta que salga algo....por lo menos estoy seguro que sangre debe salir XDDDD
Saludos,
¥oukai
avatar
youkai
Soñador
Soñador

0/3

Créditos 280

Gracias : 10

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por Wecoc el 2013-08-13, 17:32

Pues te hago un resumen rápido xD

Hay tres invariables básicas en el primer módulo:
WIDTH (32) es el ancho del tile
HEIGHT (32) es el alto del tile
SUPP (8) superposición entre los tiles.

Entonces la X va de 24 en 24. Ese 24 viene de WIDTH - SUPP. No tiene más que eso.
Lo complicado es la Y, la cual va de 32 en 32 (HEIGHT), pero en X pares se le suma 16 (HEIGHT/2). No hay mucha más matemática que esa.

El character como puedes ver tiene 6 direcciones y eso complica un poco las cosas. Esas direcciones son: 2 - Abajo, 1 - Abajo-Izquierda, 3 - Abajo-Derecha, 5 - Arriba-Izquierda, 7 - Arriba-Derecha, 8 - Arriba

Lo que falta es lo siguiente, todo del tercer script excepto lo primero que es del primero.

- Buscar un sistema más óptimo de dibujado de los autotiles. De momento está como siempre pero a la hora de probarlo en el mapa no hay manera humana de hacer que se vea bien.

- La pasabilidad está hecha hasta lo de O y X pero falta lo de las flechitas. Ahí se presenta un problema grave por el hecho de haber 6 direcciones posibles en hexatiles, contra solo 4 flechas en la base de datos. No hay manera fácil de solucionarlo que yo sepa ni tampoco de pasar solo con las 4, de hecho solo se me ocurre una manera complicada de solucionarlo, que es al estilo Pokemon essentials: Hacer que la pantalla de Debug (F9) permita controlar eso in-game como si fuera un plus de esa parte de la Base de Datos, y poner allí las 6 flechitas. Orochii hizo algo muy similar para poner más terrain tags, habría que mirar eso.

- update_jump y jump. No parece complicado, simplemente aún no se ha hecho. Yo mismo lo haré pronto.

- Game Player center y check_event_trigger_there. Nunca he entendido demasiado bien como van esos dos xDD

- A * Pathfinding con el ratón en pantalla (lo de clicar un tile y que el personaje vaya hasta allí), porque moverse con el teclado es un poco liado. Según he leído entre el pathfinding de 4 direcciones y el de 6 no hay demasiada diferencia, aunque claro seguro que habrá que cambiar algo.

- Arreglar posibles bugs.

Creo que no le cambié nada más desde el último post pero como no estoy del todo seguro vuelvo a postear el tercero, la versión más actualizada.

Código:
#==============================================================================
# Hextiles
#==============================================================================
# Script creado por usuarios de Mundo Maker:
# - Wecoc
# - Pokepik
# - Orochii
#==============================================================================
# 3. Character Features
#==============================================================================

class Game_Character
  def passable?(x, y, d) # No está hecho
    case d
    when 1 # Lower Left
      new_x = x - 1
      wecoc_y = @x%2==1 ? 1 : 0
      new_y = y + wecoc_y
    when 2 # Down
      new_x = x
      new_y = y + 1
    when 3 # Lower Right
      new_x = x + 1
      wecoc_y = @x%2==1 ? 1 : 0
      new_y = y + wecoc_y
    when 5 # Upper Left
      new_x = x-1
      wecoc_y = @x%2==0 ? 1 : 0
      new_y = y - wecoc_y
    when 7 # Upper Right
      new_x = x+1
      wecoc_y = @x%2==0 ? 1 : 0
      new_y = y - wecoc_y
    when 8 # Up
      new_x = x
      new_y = y - 1
    else
      new_x = x
      new_y = y
    end
    return false unless $game_map.valid?(new_x, new_y)
    if self.is_a?(Game_Player)
      return true if $DEBUG and Input.press?(Input::CTRL)
    end
    return true if @through
    if $game_map.data[x,y,0] == 0 and
      $game_map.data[x,y,1] == 0 and
      $game_map.data[x,y,2] == 0
      return false
    end
    if $game_map.data[new_x,new_y,0] == 0 and
      $game_map.data[new_x,new_y,1] == 0 and
      $game_map.data[new_x,new_y,2] == 0
      return false
    end
    return false unless $game_map.passable?(x, y, 0)
    return false unless $game_map.passable?(new_x, new_y, 0)

    # Falta la pasibilidad por direcciones (la más complicada)
   
    for event in $game_map.events.values
      if event.x == new_x and event.y == new_y
        unless event.through
          return false if self != $game_player
          return false if event.character_name != ""
        end
      end
    end
    if $game_player.x == new_x and $game_player.y == new_y
      unless $game_player.through
        return false if @character_name != ""
      end
    end
    return true
  end

  def moving?
    wecoc_y = @x%2==0 ? 16 : 0
    return (@real_x != @x * 24 * 4 or @real_y != (@y * 32 - wecoc_y) * 4)
  end
 
  def moveto(x, y)
    @x = x % $game_map.width
    @y = y % $game_map.height
    wecoc_y = @x%2==0 ? 16 : 0
    @real_x = @x * 24 * 4
    @real_y = (@y * 32 - wecoc_y) * 4
    @prelock_direction = 0
  end
 
  def jump(x_plus, y_plus)
    tile_x = @x
    tile_y = @y
    new_tile_x = @x + x_plus
    new_tile_y = @y + y_plus
    straighten
    distance = 0
    if passable?(new_tile_x, new_tile_y, 0)
      turn_toward_tile_6(new_tile_x, new_tile_y)
      distance = Math.sqrt(x_plus * x_plus + y_plus * y_plus).round
      @x = new_tile_x
      @y = new_tile_y
    end
    @jump_peak = 10 + distance - @move_speed
    @jump_count = @jump_peak * 2
    @stop_count = 0
  end
 
  def tile_neighbors(x, y, d=0)
    if x%2==1
      array = [[x-1,y+1],[x,y-1],[x+1,y+1],[x,y],[x-1,y],[x,y],[x+1,y],[x,y+1]]
    else
      array = [[x-1,y],[x,y-1],[x+1,y],[x,y],[x-1,y-1],[x,y],[x+1,y-1],[x,y+1]]
    end
    return d==0 ? array : array[d-1]
  end
   
  def ring_tiles(distance)
    get_ring_tiles(self.x, self.y, distance)
  end
 
  def get_ring_tiles(x, y, distance)
    case distance
    when 0 then return [[x, y]]
    when 1 then return tile_neighbors(x,y)
    when 2
      neighbors = tile_neighbors(x,y)
      new_neighbors = []
      for i in 0...neighbors.size
        for j in 1..8
          new_neighbors.push(tile_neighbors(neighbors[i][0], neighbors[i][1], j))
        end
      end
      new_neighbors.uniq!
      for i in 0...neighbors.size
        new_neighbors.delete(neighbors[i])
      end
      new_neighbors.delete([x,y])
      return new_neighbors
    else
      neighbors = get_ring_tiles(x, y, distance-1)
      all_neighbors = []
      for i in 0...distance-1
        all_neighbors.push(get_ring_tiles(x, y, i))
      end
      new_neighbors = []
      for i in 0...neighbors.size
        for j in 1..8
          new_neighbors.push(tile_neighbors(neighbors[i][0], neighbors[i][1], j))
        end
      end
      new_neighbors.uniq!
      for i in 0...neighbors.size
        new_neighbors.delete(neighbors[i])
      end
      for i in 0...all_neighbors.size
        for j in 0...all_neighbors[i].size
          new_neighbors.delete(all_neighbors[i][j])
        end
      end
      new_neighbors.delete([x,y])
      return new_neighbors
    end
  end
 
  def screen_x
    return (@real_x - $game_map.display_x + 3) / 4 + 32 / 4
  end

  def screen_y
    y = (@real_y - $game_map.display_y + 3) / 4 + 32
    if @jump_count >= @jump_peak
      n = @jump_count - @jump_peak
    else
      n = @jump_peak - @jump_count
    end
    return y - (@jump_peak * @jump_peak - n * n) / 2
  end

  def bush_depth(depth=12)
    return 0 if @tile_id > 0 or @always_on_top
    if @jump_count == 0 and $game_map.bush?(@x, @y)
      return depth
    else
      return 0
    end
  end
 
  def update_jump
    @jump_count -= 1
    wecoc_y = @x%2==0 ? 16 : 0
    @real_x = (@real_x * @jump_count + @x * 24 * 4) / (@jump_count+1)
    @real_y = (@real_y * @jump_count + (@y * 32 - wecoc_y) * 4) / (@jump_count+1)
  end

  def update_move
    @false_move_speed = @move_speed if @false_move_speed == nil
    distance = 2 ** @false_move_speed
    wecoc_y = @x%2==0 ? 16 : 0
    if (@y * 32 - wecoc_y) * 4 > @real_y # Move down
      @real_y = [@real_y + distance / 1.5, (@y * 32 - wecoc_y) * 4].min
    end
    if @x * 24 * 4 < @real_x # Move left
      @real_x = [@real_x - distance / 1, @x * 24 * 4].max
    end
    if @x * 24 * 4 > @real_x # Move right
      @real_x = [@real_x + distance / 1, @x * 24 * 4].min
    end
    if (@y * 32 - wecoc_y) * 4 < @real_y # Move up
      @real_y = [@real_y - distance / 1.5, (@y * 32 - wecoc_y) * 4].max
    end
    if @walk_anime
      @anime_count += 1.5
    elsif @step_anime
      @anime_count += 1
    end
  end

  def move_type_random(app=50)
    app = [[100, app].min, 1].max
    case rand(100/app)
      when 0 then move_random # Random
    else
      case rand(2)
        when 0 then move_forward # Forward
        when 1 then @stop_count = 0 # Wait
      end
    end
  end

  def move_up(turn_enabled = true)
    @false_move_speed = @move_speed
    turn_up if turn_enabled
    if passable?(@x, @y, 8)
      turn_up
      @y -= 1
      increase_steps
    else
      check_event_trigger_touch(@x, @y-1)
    end
  end
 
  def move_down(turn_enabled = true)
    @false_move_speed = @move_speed
    turn_down if turn_enabled
    if passable?(@x, @y, 2)
      turn_down
      @y += 1
      increase_steps
    else
      check_event_trigger_touch(@x, @y+1)
    end
  end
 
  def move_lower_left(turn_enabled = true)
    @false_move_speed = @move_speed / 1.33
    turn_lower_left if turn_enabled
    @direction = 1 unless @direction_fix
    if passable?(@x, @y, 1)
      @y += 1 if @x%2==1
      @x -= 1
      increase_steps
    else
      crd = tile_neighbors(@x, @y, 1)
      check_event_trigger_touch(crd[0], crd[1])
    end
  end

  def move_lower_right(turn_enabled = true)
    @false_move_speed = @move_speed / 1.33
    turn_lower_right if turn_enabled
    @direction = 3 unless @direction_fix
    if passable?(@x, @y, 3)
      @y += 1 if @x%2==1
      @x += 1
      increase_steps
    else
      crd = tile_neighbors(@x, @y, 3)
      check_event_trigger_touch(crd[0], crd[1])
    end
  end

  def move_upper_left(turn_enabled = true)
    @false_move_speed = @move_speed / 1.33
    turn_upper_left if turn_enabled
    @direction = 5 unless @direction_fix
    if passable?(@x, @y, 5)
      @y -= 1 if @x%2==0
      @x -= 1
      increase_steps
    else
      crd = tile_neighbors(@x, @y, 5)
      check_event_trigger_touch(crd[0], crd[1])
    end
  end

  def move_upper_right(turn_enabled = true)
    @false_move_speed = @move_speed / 1.33
    turn_upper_right if turn_enabled
    @direction = 7 unless @direction_fix
    if passable?(@x, @y, 7)
      @y -= 1 if @x%2==0
      @x += 1
      increase_steps
    else
      crd = tile_neighbors(@x, @y, 7)
      check_event_trigger_touch(crd[0], crd[1])
    end
  end

  def move_random
    move_random_6
  end
 
  def move_random_4
    case rand(4)
      when 0 then move_down(false)
      when 1 then move_left(false)
      when 2 then move_right(false)
      when 3 then move_up(false)
    end
  end
 
  def move_random_6
    case rand(6)
      when 0 then move_down(false)
      when 1 then move_upper_left(false)
      when 2 then move_upper_right(false)
      when 3 then move_lower_left(false)
      when 4 then move_lower_right(false)
    when 5 then move_up(false)
    end
  end
 
  def move_random_4_to_6
    case rand(4)
      when 0 then move_down(false)
      when 1
        case rand(2)
          when 0 then move_upper_left(false)
          when 1 then move_upper_right(false)
        end
      when 2
        case rand(2)
          when 0 then move_lower_left(false)
          when 1 then move_lower_right(false)
        end
      when 3 then move_up(false)
    end
  end

  def move_toward_player
    move_toward_tile_6($game_player.x, $game_player.y)
  end
 
  def move_toward_event(event_id)
    event = $game_map.events[event_id]
    move_toward_tile_6(event.x, event.y)
  end
 
  def move_toward_tile_4(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
    abs_sx = sx.abs
    abs_sy = sy.abs
    if abs_sx == abs_sy
      rand(2) == 0 ? abs_sx += 1 : abs_sy += 1
    end
    if abs_sx > abs_sy
      sx > 0 ? move_left : move_right
      if not moving? and sy != 0
        sy > 0 ? move_up : move_down
      end
    else
      sy > 0 ? move_up : move_down
      if not moving? and sx != 0
        sx > 0 ? move_left : move_right
      end
    end
  end
 
  def move_toward_tile_6(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0   
    if sy <= 0
      if sy.abs > (sx.abs * 1.5)
        move_down
      else
        sx < 0 ? move_lower_right : move_lower_left
      end
    else
      if sy.abs > (sx.abs * 1.5)
        move_up
      else
        sx < 0 ? move_upper_right : move_upper_left
      end
    end
  end
   
  def move_away_from_player
    move_away_from_tile_6($game_player.x, $game_player.y)
  end
 
  def move_away_from_event(event_id)
    event = $game_map.events[event_id]
    move_away_from_tile_6(event.x, event.y)
  end
 
  def move_away_from_tile_4(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
    abs_sx = sx.abs
    abs_sy = sy.abs
    if abs_sx == abs_sy
      rand(2) == 0 ? abs_sx += 1 : abs_sy += 1
    end
    if abs_sx > abs_sy
      sx > 0 ? move_right : move_left
      if not moving? and sy != 0
        sy > 0 ? move_down : move_up
      end
    else
      sy > 0 ? move_down : move_up
      if not moving? and sx != 0
        sx > 0 ? move_right : move_left
      end
    end
  end
 
  def move_away_from_tile_6(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0   
    if sy < 0
      if sy.abs > (sx.abs * 1.5)
        move_up
      else
        sx < 0 ? move_upper_left : move_upper_right
      end
    else
      if sy.abs > (sx.abs * 1.5)
        turn_down
      else
        sx < 0 ? move_lower_left : move_lower_right
      end
    end
  end
 
  def move_forward
    case @direction
      when 1 then move_lower_left(false)
      when 2 then move_down(false)
      when 3 then move_lower_right(false)
      when 4 then move_left(false)
      when 5 then move_upper_left(false)
      when 6 then move_right(false)
      when 7 then move_upper_right(false)
      when 8 then move_up(false)
    end
  end

  def move_backward
    last_direction_fix = @direction_fix
    @direction_fix = true
    case @direction
      when 1 then move_upper_right(false)
      when 2 then move_up(false)
      when 3 then move_upper_left(false)
      when 4 then move_right(false)
      when 5 then move_lower_right(false)
      when 6 then move_left(false)
      when 7 then move_lower_left(false)
      when 8 then move_down(false)
    end
    @direction_fix = last_direction_fix
  end
 
  def turn_clock(n=1)
    return if n <= 0 or n > 5
    dir_array = [2, 1, 5, 8, 7, 3]
    return if not dir_array.include?(@direction)
    n.times do
      i = dir_array.index(@direction)
      @direction = dir_array[i+1] != nil ? dir_array[i+1] : dir_array[0]
    end
  end
 
  def turn_anticlock(n=1)
    return if n <= 0 or n > 5
    dir_array = [3, 7, 8, 5, 1, 2]
    return if not dir_array.include?(@direction)
    n.times do
      i = dir_array.index(@direction)
      @direction = dir_array[i+1] != nil ? dir_array[i+1] : dir_array[0]
    end
  end
 
  def turn_lower_left
    unless @direction_fix
      @direction = 1
      @stop_count = 0
    end
  end
 
  def turn_lower_right
    unless @direction_fix
      @direction = 3
      @stop_count = 0
    end
  end
 
  def turn_upper_left
    unless @direction_fix
      @direction = 5
      @stop_count = 0
    end
  end
 
  def turn_upper_right
    unless @direction_fix
      @direction = 7
      @stop_count = 0
    end
  end
 
  def turn_right_90
    turn_clock
  end

  def turn_left_90
    turn_anticlock
  end

  def turn_180
    case @direction
      when 1 then turn_lower_left
      when 2 then turn_down
      when 3 then turn_lower_right
      when 4 then turn_left
      when 5 then turn_upper_left
      when 6 then turn_right
      when 7 then turn_upper_right
      when 8 then turn_up
    end
  end

  def turn_right_or_left_90
    rand(2) == 0 ? turn_clock : turn_anticlock
  end

  def turn_random
    turn_random_6
  end
 
  def turn_random_4
    case rand(4)
      when 0 then turn_down
      when 1 then turn_left
      when 2 then turn_right
      when 3 then turn_up
    end
  end
 
  def turn_random_6
    case rand(6)
      when 0 then turn_down
      when 1 then turn_upper_left
      when 2 then turn_upper_right
      when 3 then turn_lower_left
      when 4 then turn_lower_right
      when 5 then turn_up
    end
  end
 
  def turn_random_4_to_6
    case rand(4)
      when 0 then turn_down
      when 1
        case rand(2)
          when 0 then turn_upper_left(false)
          when 1 then turn_upper_right(false)
        end
      when 2
        case rand(2)
          when 0 then turn_lower_left(false)
          when 1 then turn_lower_right(false)
        end
      when 3 then turn_up(false)
    end
  end 
 
  def turn_toward_player
    turn_toward_tile_6($game_player.x, $game_player.y)
  end
 
  def turn_toward_event(event_id)
    event = $game_map.events[event_id]
    turn_toward_tile_6(event.x, event.y)
  end
 
  def turn_toward_tile_4(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
    if sx.abs > sy.abs
      sx > 0 ? turn_left : turn_right
    else
      sy > 0 ? turn_up : turn_down
    end
  end
 
  def turn_toward_tile_6(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0   
    if sy <= 0
      if sy.abs > (sx.abs * 1.5)
        turn_down
      else
        sx < 0 ? turn_lower_right : turn_lower_left
      end
    else
      if sy.abs > (sx.abs * 1.5)
        turn_up
      else
        sx < 0 ? turn_upper_right : turn_upper_left
      end
    end
  end
 
  def turn_away_from_player
    turn_away_from_tile_6($game_player.x, $game_player.y)
  end
 
  def turn_away_from_event(event_id)
    event = $game_map.events[event_id]
    turn_away_from_tile_6(event.x, event.y)
  end
 
  def turn_away_from_tile_4(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
    if sx.abs > sy.abs
      sx > 0 ? turn_right : turn_left
    else
      sy > 0 ? turn_down : turn_up
    end
  end
 
  def turn_away_from_tile_6(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0   
    if sy < 0
      if sy.abs > (sx.abs * 1.5)
        turn_up
      else
        sx < 0 ? turn_upper_left : turn_upper_right
      end
    else
      if sy.abs > (sx.abs * 1.5)
        turn_down
      else
        sx < 0 ? turn_lower_left : turn_lower_right
      end
    end
  end
end

class Game_Player < Game_Character
 
  CENTER_X = (640 / 2 - 32 / 2) * 4  # Center screen x-coordinate * 4
  CENTER_Y = (480 / 2 - 32 / 2) * 4  # Center screen y-coordinate * 4
 
  def passable?(x, y, d)
    super
  end

  def center(x, y) # No está hecho
    max_x = ($game_map.width - 20) * 32 * 4
    max_y = ($game_map.height - 15) * 32 * 4
    $game_map.display_x = [0, [x * 32 * 4 - CENTER_X, max_x].min].max
    $game_map.display_y = [0, [y * 32 * 4 - CENTER_Y, max_y].min].max
  end

  def check_event_trigger_there(triggers) # No está hecho
    result = false
    return result if $game_system.map_interpreter.running?
    new_x = @x + (@direction == 6 ? 1 : @direction == 4 ? -1 : 0)
    new_y = @y + (@direction == 2 ? 1 : @direction == 8 ? -1 : 0)
    for event in $game_map.events.values
      if event.x == new_x and event.y == new_y and
        triggers.include?(event.trigger)
        if not event.jumping? and not event.over_trigger?
          event.start
          result = true
        end
      end
    end
    if result == false
      if $game_map.counter?(new_x, new_y)
        new_x += (@direction == 6 ? 1 : @direction == 4 ? -1 : 0)
        new_y += (@direction == 2 ? 1 : @direction == 8 ? -1 : 0)
        for event in $game_map.events.values
          if event.x == new_x and event.y == new_y and
            triggers.include?(event.trigger)
            if not event.jumping? and not event.over_trigger?
              event.start
              result = true
            end
          end
        end
      end
    end
    return result
  end
end

class Sprite_Character < RPG::Sprite
  def update
    super
    if @tile_id != @character.tile_id or
      @character_name != @character.character_name or
      @character_hue != @character.character_hue
      @tile_id = @character.tile_id
      @character_name = @character.character_name
      @character_hue = @character.character_hue
      if @tile_id >= 384
        self.bitmap = RPG::Cache.tile($game_map.tileset_name,
          @tile_id, @character.character_hue)
        self.src_rect.set(0, 0, 32, 32)
        self.ox = 16
        self.oy = 32
      else
        self.bitmap = RPG::Cache.character(@character.character_name,
          @character.character_hue)
        @cw = bitmap.width / 4
        @ch = bitmap.height / 6
        self.ox = @cw / 2
        self.oy = @ch
      end
    end
    self.visible = (not @character.transparent)
    if @tile_id == 0
      sx = @character.pattern * @cw
      dir_array = [1, 0, 2, 0, 3, 0, 4, 5]
      sy = dir_array[@character.direction-1] * @ch
      self.src_rect.set(sx, sy, @cw, @ch)
    end
    self.x = @character.screen_x
    self.y = @character.screen_y
    self.z = @character.screen_z(@ch)
    self.opacity = @character.opacity
    self.blend_type = @character.blend_type
    self.bush_depth = @character.bush_depth(16)
    if @character.animation_id != 0
      animation = $data_animations[@character.animation_id]
      animation(animation, true)
      @character.animation_id = 0
    end
  end
end
(para colmo se me ha roto la tecla del ] xD)

Edito: Ya hice lo del jump.

=======

Gracias a Eron, que me ha pasado el código por MP, ya tenemos otro script hecho :D

Código:
#==============================================================================
# Hextiles
#==============================================================================
# Script creado por usuarios de Mundo Maker:
# - Wecoc
# - Pokepik
# - Orochii
# - Eron
#==============================================================================
# 4. Move Route Fix
#==============================================================================

=begin
  1 - Move down
  2 - Move left
  3 - Move right
  4 - Move up
  5 - Move lower left
  6 - Move lower right
  7 - Move upper left
  8 - Move upper right
  9 - Move random (6 dir)
  10 - Move toward player
  11 - Move away from player
  12 - 1 step forward
  13 - 1 step backward
  14 - Jump # => parameters = [x_plus, y_plus]
  15 - Wait # => parameters = [frames]
  
  16 - Turn down
  17 - Turn left
  18 - Turn right
  19 - Turn up
  20 - Turn right (next direction)
  21 - Turn left (prev direction)
  22 - Turn 180 (opp direction)
  23 - Turn right or left (next / prev direction)
  24 - Turn random (6 dir)
  25 - Turn toward player
  26 - Turn away from player
  
  27 - Switch ON # => parameters = [switch_id]
  28 - Switch OFF # => parameters = [switch_id]
  29 - Change speed # => parameters = [speed]
  30 - Change frequency # => parameters = [frequency]
  31 - Move Animation ON
  32 - Move Animation OFF
  33 - Stop Animation ON
  34 - Stop Animation OFF
  35 - Direction fix ON
  36 - Direction fix OFF
  37 - Through ON
  38 - Through OFF
  39 - Always on top ON
  40 - Always on top OFF
  
  41 - Change Graphic
    # => parameters = [character_name, character_hue, direction, pattern]
  42 - Change Opacity # => parameters = [opacity]
  43 - Change Blending # => parameters = [blend_type]
  44 - Play SE # => parameters = [se]
  45 - Script # => parameters = [eval code]
  
  46 - Move Type Random # => parameters = [percent]
  47 - Move random (6 dir, 4 rand)
  48 - Move toward event # => parameters = [event_id]
  49 - Move away from event # => parameters = [event_id]
  50 - Move toward tile # => parameters = [x, y]
  51 - Move away from tile # => parameters = [x, y]
  52 - Jump # => parameters = [new_x, new_y]
  
  53 - Turn right (next * n direction) # => parameters = [n]
  54 - Turn left (prev * n direction) # => parameters = [n]
  55 - Turn lower left
  56 - Turn lower right
  57 - Turn upper left
  58 - Turn upper right
  59 - Turn random (6 dir, 4 rand)
  60 - Turn toward event # => parameters = [event_id]
  61 - Turn away from event # => parameters = [event_id]
  62 - Turn toward tile # => parameters = [x, y]
  63 - Turn away from tile # => parameters = [x, y]
  64 - Change Graphic (to tile) # => parameters = [tile_id]
  65 - Change Graphic (same direction)
    # => parameters = [character_name, character_hue]
=end

class Game_Character
  def execute_code(code, parameters=[])
    if code <= 45 # Default Command Codes
      case code
        when 1  then move_down
        when 2  then move_left
        when 3  then move_right
        when 4  then move_up
        when 5  then move_lower_left
        when 6  then move_lower_right
        when 7  then move_upper_left
        when 8  then move_upper_right
        when 9  then move_random
        when 10 then move_toward_player
        when 11 then move_away_from_player
       when 12 then move_forward
       when 13 then move_backward
       when 14 then jump(parameters[0], parameters[1])
        when 15 then @wait_count = command.parameters[0] * 2 - 1
        
        when 16 then turn_down
       when 17 then turn_left
       when 18 then turn_right
       when 19 then turn_up
       when 20 then turn_right_90
       when 21 then turn_left_90
       when 22 then turn_180
       when 23 then turn_right_or_left_90
       when 24 then turn_random
        when 25 then turn_toward_player
        when 26 then turn_away_from_player
        when 27 then $game_switches[parameters[0]] = true
        when 28 then $game_switches[parameters[0]] = false
        when 29 then @move_speed = parameters[0]
        when 30 then @move_frequency = parameters[0]
        when 31 then @walk_anime = true
        when 32 then @walk_anime = false
        when 33 then @step_anime = true
        when 34 then @step_anime = false
        when 35 then @direction_fix = true
        when 36 then @direction_fix = false
        when 37 then @through = true
        when 38 then @through = false
        when 39 then @always_on_top = true
        when 40 then @always_on_top = false
        when 41
          @tile_id = 0
          @character_name = parameters[0]
          @character_hue = parameters[1]
          if @original_direction != parameters[2]
            @direction = parameters[2]
            @original_direction = @direction
            @prelock_direction = 0
          end
          if @original_pattern != parameters[3]
            @pattern = parameters[3]
            @original_pattern = @pattern
          end
        when 42 then @opacity = parameters[0]
        when 43 then @blend_type = parameters[0]
        when 44 then $game_system.se_play(parameters[0])
        when 45 then result = eval(parameters[0])
      end
    else # code > 45
      case code
        when 46 then move_type_random(parameters[0])
        when 47 then move_random_4_to_6
        when 48 then move_toward_event(parameters[0])
        when 49 then move_away_from_event(parameters[0])
        when 50 then move_toward_tile_6(parameters[0], parameters[1])
        when 51 then move_away_from_tile_6(parameters[0])
        when 52
          x = self.x ; y = self.y
          plus_x = parameters[0] - x ; plus_y = parameters[1] - y
          jump(plus_x. plus_y)
        when 53 then turn_clock(parameters[0])
        when 54 then turn_anticlock(parameters[0])
        when 55 then turn_lower_left
        when 56 then turn_lower_right
        when 57 then turn_upper_left
        when 58 then turn_upper_right
        when 59 then turn_random_4_to_6
        when 60 then turn_toward_event(parameters[0])
        when 61 then turn_away_from_event(parameters[0])
        when 62 then turn_toward_tile_6(parameters[0], parameters[1])
        when 63 then turn_away_from_tile_6(parameters[0], parameters[1])
        when 64
         @tile_id = parameters[0]
        when 65
          @tile_id = 0
          @character_name = parameters[0]
          @character_hue = parameters[1]
        # when ...
      end
    end
  end
  
  def move_type_custom
    return if jumping? or moving?
    while @move_route_index < @move_route.list.size
      command = @move_route.list[@move_route_index]
      if command.code == 0
        @move_route_index = 0 if @move_route.repeat
        unless @move_route.repeat
          if @move_route_forcing and not @move_route.repeat
            @move_route_forcing = false
            @move_route = @original_move_route
            @move_route_index = @original_move_route_index
            @original_move_route = nil
          end
          @stop_count = 0
        end
        return
      end
      execute_code(command.code, command.parameters)
      case command.code
        when 1..14, 46..52
          return if not @move_route.skippable and not moving? and not jumping?
        when 27,28 then $game_map.need_refresh = true
      end
      @move_route_index += 1
    end
  end
end
A ver si puedo explicar bien lo que hace éste script para que lo entendáis... xD
Hace que las rutas (Mover Evento o Crear Ruta) funcionen como siempre, pero además permite hacer lo siguiente: en la parte Script dentro del comando puedes poner execute_code(code, parameters) y eso permite ejecutar el código correspondiente a ese valor. Por ejemplo, si pones execute_code(1) hará "Mover Abajo" (por defecto), y si pones execute_code(52, [10, 9]) hará "Saltar" al tile [10, 9]. De 45 para abajo son los mismos, de 46 hasta de momento 65, son nuevos. Hay toda la lista de qué es cada número al principio del script.


Última edición por Wecoc el 2013-08-27, 22:31, editado 1 vez
avatar
Wecoc
Administrador
Administrador



Créditos 12211

Gracias : 632

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por youkai el 2013-08-13, 20:44

Bueno ya le cogi la vuelta a esto >8D Asi que ya saben...youkai a la carga!! (?) XD
Fuera de bromas...ya hice la parte del check_event_trigger_there y el center. Aqui tienen el codigo...puede ser que se me haya escapado algun gusanito puesto que no probe al detalle XD Pero por lo menos se que funciona XDDDD
Código:
    #==============================================================================
    # Hextiles
    #==============================================================================
    # Script creado por usuarios de Mundo Maker:
    # - Wecoc
    # - Pokepik
    # - Orochii
    #==============================================================================
    # 3. Character Features
    #==============================================================================

    class Game_Character
      def passable?(x, y, d) # No está hecho
        case d
        when 1 # Lower Left
          new_x = x - 1
          wecoc_y = @x%2==1 ? 1 : 0
          new_y = y + wecoc_y
        when 2 # Down
          new_x = x
          new_y = y + 1
        when 3 # Lower Right
          new_x = x + 1
          wecoc_y = @x%2==1 ? 1 : 0
          new_y = y + wecoc_y
        when 5 # Upper Left
          new_x = x-1
          wecoc_y = @x%2==0 ? 1 : 0
          new_y = y - wecoc_y
        when 7 # Upper Right
          new_x = x+1
          wecoc_y = @x%2==0 ? 1 : 0
          new_y = y - wecoc_y
        when 8 # Up
          new_x = x
          new_y = y - 1
        else
          new_x = x
          new_y = y
        end
        return false unless $game_map.valid?(new_x, new_y)
        if self.is_a?(Game_Player)
          return true if $DEBUG and Input.press?(Input::CTRL)
        end
        return true if @through
        if $game_map.data[x,y,0] == 0 and
          $game_map.data[x,y,1] == 0 and
          $game_map.data[x,y,2] == 0
          return false
        end
        if $game_map.data[new_x,new_y,0] == 0 and
          $game_map.data[new_x,new_y,1] == 0 and
          $game_map.data[new_x,new_y,2] == 0
          return false
        end
        return false unless $game_map.passable?(x, y, 0)
        return false unless $game_map.passable?(new_x, new_y, 0)

        # Falta la pasibilidad por direcciones (la más complicada)
     
        for event in $game_map.events.values
          if event.x == new_x and event.y == new_y
            unless event.through
              return false if self != $game_player
              return false if event.character_name != ""
            end
          end
        end
        if $game_player.x == new_x and $game_player.y == new_y
          unless $game_player.through
            return false if @character_name != ""
          end
        end
        return true
      end

      def moving?
        wecoc_y = @x%2==0 ? 16 : 0
        return (@real_x != @x * 24 * 4 or @real_y != (@y * 32 - wecoc_y) * 4)
      end
   
      def moveto(x, y)
        @x = x % $game_map.width
        @y = y % $game_map.height
        wecoc_y = @x%2==0 ? 16 : 0
        @real_x = @x * 24 * 4
        @real_y = (@y * 32 - wecoc_y) * 4
        @prelock_direction = 0
      end
   
      def jump(x_plus, y_plus)
        tile_x = @x
        tile_y = @y
        new_tile_x = @x + x_plus
        new_tile_y = @y + y_plus
        straighten
        distance = 0
        if passable?(new_tile_x, new_tile_y, 0)
          turn_toward_tile_6(new_tile_x, new_tile_y)
          distance = Math.sqrt(x_plus * x_plus + y_plus * y_plus).round
          @x = new_tile_x
          @y = new_tile_y
        end
        @jump_peak = 10 + distance - @move_speed
        @jump_count = @jump_peak * 2
        @stop_count = 0
      end
   
      def tile_neighbors(x, y, d=0)
        if x%2==1
          array = [[x-1,y+1],[x,y-1],[x+1,y+1],[x,y],[x-1,y],[x,y],[x+1,y],[x,y+1]]
        else
          array = [[x-1,y],[x,y-1],[x+1,y],[x,y],[x-1,y-1],[x,y],[x+1,y-1],[x,y+1]]
        end
        return d==0 ? array : array[d-1]
      end
     
      def ring_tiles(distance)
        get_ring_tiles(self.x, self.y, distance)
      end
   
      def get_ring_tiles(x, y, distance)
        case distance
        when 0 then return [[x, y]]
        when 1 then return tile_neighbors(x,y)
        when 2
          neighbors = tile_neighbors(x,y)
          new_neighbors = []
          for i in 0...neighbors.size
            for j in 1..8
              new_neighbors.push(tile_neighbors(neighbors[i][0], neighbors[i][1], j))
            end
          end
          new_neighbors.uniq!
          for i in 0...neighbors.size
            new_neighbors.delete(neighbors[i])
          end
          new_neighbors.delete([x,y])
          return new_neighbors
        else
          neighbors = get_ring_tiles(x, y, distance-1)
          all_neighbors = []
          for i in 0...distance-1
            all_neighbors.push(get_ring_tiles(x, y, i))
          end
          new_neighbors = []
          for i in 0...neighbors.size
            for j in 1..8
              new_neighbors.push(tile_neighbors(neighbors[i][0], neighbors[i][1], j))
            end
          end
          new_neighbors.uniq!
          for i in 0...neighbors.size
            new_neighbors.delete(neighbors[i])
          end
          for i in 0...all_neighbors.size
            for j in 0...all_neighbors[i].size
              new_neighbors.delete(all_neighbors[i][j])
            end
          end
          new_neighbors.delete([x,y])
          return new_neighbors
        end
      end
   
      def screen_x
        return (@real_x - $game_map.display_x + 3) / 4 + 32 / 4
      end

      def screen_y
        y = (@real_y - $game_map.display_y + 3) / 4 + 32
        if @jump_count >= @jump_peak
          n = @jump_count - @jump_peak
        else
          n = @jump_peak - @jump_count
        end
        return y - (@jump_peak * @jump_peak - n * n) / 2
      end

      def bush_depth(depth=12)
        return 0 if @tile_id > 0 or @always_on_top
        if @jump_count == 0 and $game_map.bush?(@x, @y)
          return depth
        else
          return 0
        end
      end
   
      def update_jump
        @jump_count -= 1
        wecoc_y = @x%2==0 ? 16 : 0
        @real_x = (@real_x * @jump_count + @x * 24 * 4) / (@jump_count+1)
        @real_y = (@real_y * @jump_count + (@y * 32 - wecoc_y) * 4) / (@jump_count+1)
      end

      def update_move
        @false_move_speed = @move_speed if @false_move_speed == nil
        distance = 2 ** @false_move_speed
        wecoc_y = @x%2==0 ? 16 : 0
        if (@y * 32 - wecoc_y) * 4 > @real_y # Move down
          @real_y = [@real_y + distance / 1.5, (@y * 32 - wecoc_y) * 4].min
        end
        if @x * 24 * 4 < @real_x # Move left
          @real_x = [@real_x - distance / 1, @x * 24 * 4].max
        end
        if @x * 24 * 4 > @real_x # Move right
          @real_x = [@real_x + distance / 1, @x * 24 * 4].min
        end
        if (@y * 32 - wecoc_y) * 4 < @real_y # Move up
          @real_y = [@real_y - distance / 1.5, (@y * 32 - wecoc_y) * 4].max
        end
        if @walk_anime
          @anime_count += 1.5
        elsif @step_anime
          @anime_count += 1
        end
      end

      def move_type_random(app=50)
        app = [[100, app].min, 1].max
        case rand(100/app)
          when 0 then move_random # Random
        else
          case rand(2)
            when 0 then move_forward # Forward
            when 1 then @stop_count = 0 # Wait
          end
        end
      end

      def move_up(turn_enabled = true)
        @false_move_speed = @move_speed
        turn_up if turn_enabled
        if passable?(@x, @y, 8)
          turn_up
          @y -= 1
          increase_steps
        else
          check_event_trigger_touch(@x, @y-1)
        end
      end
   
      def move_down(turn_enabled = true)
        @false_move_speed = @move_speed
        turn_down if turn_enabled
        if passable?(@x, @y, 2)
          turn_down
          @y += 1
          increase_steps
        else
          check_event_trigger_touch(@x, @y+1)
        end
      end
   
      def move_lower_left(turn_enabled = true)
        @false_move_speed = @move_speed / 1.33
        turn_lower_left if turn_enabled
        @direction = 1 unless @direction_fix
        if passable?(@x, @y, 1)
          @y += 1 if @x%2==1
          @x -= 1
          increase_steps
        else
          crd = tile_neighbors(@x, @y, 1)
          check_event_trigger_touch(crd[0], crd[1])
        end
      end

      def move_lower_right(turn_enabled = true)
        @false_move_speed = @move_speed / 1.33
        turn_lower_right if turn_enabled
        @direction = 3 unless @direction_fix
        if passable?(@x, @y, 3)
          @y += 1 if @x%2==1
          @x += 1
          increase_steps
        else
          crd = tile_neighbors(@x, @y, 3)
          check_event_trigger_touch(crd[0], crd[1])
        end
      end

      def move_upper_left(turn_enabled = true)
        @false_move_speed = @move_speed / 1.33
        turn_upper_left if turn_enabled
        @direction = 5 unless @direction_fix
        if passable?(@x, @y, 5)
          @y -= 1 if @x%2==0
          @x -= 1
          increase_steps
        else
          crd = tile_neighbors(@x, @y, 5)
          check_event_trigger_touch(crd[0], crd[1])
        end
      end

      def move_upper_right(turn_enabled = true)
        @false_move_speed = @move_speed / 1.33
        turn_upper_right if turn_enabled
        @direction = 7 unless @direction_fix
        if passable?(@x, @y, 7)
          @y -= 1 if @x%2==0
          @x += 1
          increase_steps
        else
          crd = tile_neighbors(@x, @y, 7)
          check_event_trigger_touch(crd[0], crd[1])
        end
      end

      def move_random
        move_random_6
      end
   
      def move_random_4
        case rand(4)
          when 0 then move_down(false)
          when 1 then move_left(false)
          when 2 then move_right(false)
          when 3 then move_up(false)
        end
      end
   
      def move_random_6
        case rand(6)
          when 0 then move_down(false)
          when 1 then move_upper_left(false)
          when 2 then move_upper_right(false)
          when 3 then move_lower_left(false)
          when 4 then move_lower_right(false)
          when 5 then move_up(false)
        end
      end
   
      def move_random_4_to_6
        case rand(4)
          when 0 then move_down(false)
          when 1
            case rand(2)
              when 0 then move_upper_left(false)
              when 1 then move_upper_right(false)
            end
          when 2
            case rand(2)
              when 0 then move_lower_left(false)
              when 1 then move_lower_right(false)
            end
          when 3 then move_up(false)
        end
      end

      def move_toward_player
        move_toward_tile_6($game_player.x, $game_player.y)
      end
   
      def move_toward_event(event_id)
        event = $game_map.events[event_id]
        move_toward_tile_6(event.x, event.y)
      end
   
      def move_toward_tile_4(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0
        abs_sx = sx.abs
        abs_sy = sy.abs
        if abs_sx == abs_sy
          rand(2) == 0 ? abs_sx += 1 : abs_sy += 1
        end
        if abs_sx > abs_sy
          sx > 0 ? move_left : move_right
          if not moving? and sy != 0
            sy > 0 ? move_up : move_down
          end
        else
          sy > 0 ? move_up : move_down
          if not moving? and sx != 0
            sx > 0 ? move_left : move_right
          end
        end
      end
   
      def move_toward_tile_6(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0 
        if sy <= 0
          if sy.abs > (sx.abs * 1.5)
            move_down
          else
            sx < 0 ? move_lower_right : move_lower_left
          end
        else
          if sy.abs > (sx.abs * 1.5)
            move_up
          else
            sx < 0 ? move_upper_right : move_upper_left
          end
        end
      end
     
      def move_away_from_player
        move_away_from_tile_6($game_player.x, $game_player.y)
      end
   
      def move_away_from_event(event_id)
        event = $game_map.events[event_id]
        move_away_from_tile_6(event.x, event.y)
      end
   
      def move_away_from_tile_4(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0
        abs_sx = sx.abs
        abs_sy = sy.abs
        if abs_sx == abs_sy
          rand(2) == 0 ? abs_sx += 1 : abs_sy += 1
        end
        if abs_sx > abs_sy
          sx > 0 ? move_right : move_left
          if not moving? and sy != 0
            sy > 0 ? move_down : move_up
          end
        else
          sy > 0 ? move_down : move_up
          if not moving? and sx != 0
            sx > 0 ? move_right : move_left
          end
        end
      end
   
      def move_away_from_tile_6(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0 
        if sy < 0
          if sy.abs > (sx.abs * 1.5)
            move_up
          else
            sx < 0 ? move_upper_left : move_upper_right
          end
        else
          if sy.abs > (sx.abs * 1.5)
            turn_down
          else
            sx < 0 ? move_lower_left : move_lower_right
          end
        end
      end
   
      def move_forward
        case @direction
          when 1 then move_lower_left(false)
          when 2 then move_down(false)
          when 3 then move_lower_right(false)
          when 4 then move_left(false)
          when 5 then move_upper_left(false)
          when 6 then move_right(false)
          when 7 then move_upper_right(false)
          when 8 then move_up(false)
        end
      end

      def move_backward
        last_direction_fix = @direction_fix
        @direction_fix = true
        case @direction
          when 1 then move_upper_right(false)
          when 2 then move_up(false)
          when 3 then move_upper_left(false)
          when 4 then move_right(false)
          when 5 then move_lower_right(false)
          when 6 then move_left(false)
          when 7 then move_lower_left(false)
          when 8 then move_down(false)
        end
        @direction_fix = last_direction_fix
      end
   
      def turn_clock(n=1)
        return if n <= 0 or n > 5
        dir_array = [2, 1, 5, 8, 7, 3]
        return if not dir_array.include?(@direction)
        n.times do
          i = dir_array.index(@direction)
          @direction = dir_array[i+1] != nil ? dir_array[i+1] : dir_array[0]
        end
      end
   
      def turn_anticlock(n=1)
        return if n <= 0 or n > 5
        dir_array = [3, 7, 8, 5, 1, 2]
        return if not dir_array.include?(@direction)
        n.times do
          i = dir_array.index(@direction)
          @direction = dir_array[i+1] != nil ? dir_array[i+1] : dir_array[0]
        end
      end
   
      def turn_lower_left
        unless @direction_fix
          @direction = 1
          @stop_count = 0
        end
      end
   
      def turn_lower_right
        unless @direction_fix
          @direction = 3
          @stop_count = 0
        end
      end
   
      def turn_upper_left
        unless @direction_fix
          @direction = 5
          @stop_count = 0
        end
      end
   
      def turn_upper_right
        unless @direction_fix
          @direction = 7
          @stop_count = 0
        end
      end
   
      def turn_right_90
        turn_clock
      end

      def turn_left_90
        turn_anticlock
      end

      def turn_180
        case @direction
          when 1 then turn_lower_left
          when 2 then turn_down
          when 3 then turn_lower_right
          when 4 then turn_left
          when 5 then turn_upper_left
          when 6 then turn_right
          when 7 then turn_upper_right
          when 8 then turn_up
        end
      end

      def turn_right_or_left_90
        rand(2) == 0 ? turn_clock : turn_anticlock
      end

      def turn_random
        turn_random_6
      end
   
      def turn_random_4
        case rand(4)
          when 0 then turn_down
          when 1 then turn_left
          when 2 then turn_right
          when 3 then turn_up
        end
      end
   
      def turn_random_6
        case rand(6)
          when 0 then turn_down
          when 1 then turn_upper_left
          when 2 then turn_upper_right
          when 3 then turn_lower_left
          when 4 then turn_lower_right
          when 5 then turn_up
        end
      end
   
      def turn_random_4_to_6
        case rand(4)
          when 0 then turn_down
          when 1
            case rand(2)
              when 0 then turn_upper_left(false)
              when 1 then turn_upper_right(false)
            end
          when 2
            case rand(2)
              when 0 then turn_lower_left(false)
              when 1 then turn_lower_right(false)
            end
          when 3 then turn_up(false)
        end
      end
   
      def turn_toward_player
        turn_toward_tile_6($game_player.x, $game_player.y)
      end
   
      def turn_toward_event(event_id)
        event = $game_map.events[event_id]
        turn_toward_tile_6(event.x, event.y)
      end
   
      def turn_toward_tile_4(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0
        if sx.abs > sy.abs
          sx > 0 ? turn_left : turn_right
        else
          sy > 0 ? turn_up : turn_down
        end
      end
   
      def turn_toward_tile_6(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0 
        if sy <= 0
          if sy.abs > (sx.abs * 1.5)
            turn_down
          else
            sx < 0 ? turn_lower_right : turn_lower_left
          end
        else
          if sy.abs > (sx.abs * 1.5)
            turn_up
          else
            sx < 0 ? turn_upper_right : turn_upper_left
          end
        end
      end
   
      def turn_away_from_player
        turn_away_from_tile_6($game_player.x, $game_player.y)
      end
   
      def turn_away_from_event(event_id)
        event = $game_map.events[event_id]
        turn_away_from_tile_6(event.x, event.y)
      end
   
      def turn_away_from_tile_4(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0
        if sx.abs > sy.abs
          sx > 0 ? turn_right : turn_left
        else
          sy > 0 ? turn_down : turn_up
        end
      end
   
      def turn_away_from_tile_6(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0 
        if sy < 0
          if sy.abs > (sx.abs * 1.5)
            turn_up
          else
            sx < 0 ? turn_upper_left : turn_upper_right
          end
        else
          if sy.abs > (sx.abs * 1.5)
            turn_down
          else
            sx < 0 ? turn_lower_left : turn_lower_right
          end
        end
      end
    end

    class Game_Player < Game_Character
   
      CENTER_X = (640 / 2 - 32 / 2) * 4  # Center screen x-coordinate * 4
      CENTER_Y = (480 / 2 - 32 / 2) * 4  # Center screen y-coordinate * 4
   
      def passable?(x, y, d)
        super
      end

      def center(x, y)
        max_x = ($game_map.width - 20) * 32 * 4
        max_y = ($game_map.height - 15) * 32 * 4
        $game_map.display_x = [0, [x * (32 - 8) * 4 - CENTER_X, max_x].min].max
        $game_map.display_y = [0, [y * 32 * 4 - CENTER_Y, max_y].min].max
      end

      def check_event_trigger_there(triggers)
        result = false
        return result if $game_system.map_interpreter.running?
        y_correct = case @direction
        when 2 then 1
        when 8 then -1
        when 1 then @x%2==1 ? 1 : 0
        when 3 then @x%2==1 ? 1 : 0
        when 5 then @x%2==1 ? 0 : -1
        when 7 then @x%2==1 ? 0 : -1
        else; 0
        end
        new_x = @x + (@direction == 6 ? 1 : @direction == 4 ? -1 : @direction == 1 ? -1 : @direction == 3 ? 1 : @direction == 5 ? -1 : @direction == 7 ? 1 : 0)
        new_y = @y + y_correct
        for event in $game_map.events.values
          if event.x == new_x and event.y == new_y and
            triggers.include?(event.trigger)
            if not event.jumping? and not event.over_trigger?
              event.start
              result = true
            end
          end
        end
        if result == false
          if $game_map.counter?(new_x, new_y)
            for event in $game_map.events.values
              if event.x == new_x and event.y == new_y and
                triggers.include?(event.trigger)
                if not event.jumping? and not event.over_trigger?
                  event.start
                  result = true
                end
              end
            end
          end
        end
        return result
      end
    end

    class Sprite_Character < RPG::Sprite
      def update
        super
        if @tile_id != @character.tile_id or
          @character_name != @character.character_name or
          @character_hue != @character.character_hue
          @tile_id = @character.tile_id
          @character_name = @character.character_name
          @character_hue = @character.character_hue
          if @tile_id >= 384
            self.bitmap = RPG::Cache.tile($game_map.tileset_name,
              @tile_id, @character.character_hue)
            self.src_rect.set(0, 0, 32, 32)
            self.ox = 16
            self.oy = 32
          else
            self.bitmap = RPG::Cache.character(@character.character_name,
              @character.character_hue)
            @cw = bitmap.width / 4
            @ch = bitmap.height / 6
            self.ox = @cw / 2
            self.oy = @ch
          end
        end
        self.visible = (not @character.transparent)
        if @tile_id == 0
          sx = @character.pattern * @cw
          dir_array = [1, 0, 2, 0, 3, 0, 4, 5]
          sy = dir_array[@character.direction-1] * @ch
          self.src_rect.set(sx, sy, @cw, @ch)
        end
        self.x = @character.screen_x
        self.y = @character.screen_y
        self.z = @character.screen_z(@ch)
        self.opacity = @character.opacity
        self.blend_type = @character.blend_type
        self.bush_depth = @character.bush_depth(16)
        if @character.animation_id != 0
          animation = $data_animations[@character.animation_id]
          animation(animation, true)
          @character.animation_id = 0
        end
      end
    end
Mientras testeaba el script me di cuenta que faltan unas cuantas cosas mas a parte de las que listaste anteriormente:
- Scroll de los eventos en el mapa cuando camines por mapas mayores a (20;15). De esto me puedo encargar yo...quiza luego me ponga en ello XD
- Scroll del mapa cuando caminas en direcciones no-arriba-abajo(?) XDDD
Eso fue lo que vi mientras hacia mi parte XDD De todas formas vamos ya bastante avanzados...falta poco...XDDD
~~Nos leeremos antes de lo que piensan~~ (?)
avatar
youkai
Soñador
Soñador

0/3

Créditos 280

Gracias : 10

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por Wecoc el 2013-08-13, 21:22

Igualar case, dí que sí xDD He modificado esa parte para hacerla un poco más amena, nada importante.

Código:
#==============================================================================
# Hextiles
#==============================================================================
# Script creado por usuarios de Mundo Maker:
# - Wecoc
# - Pokepik
# - Orochii
# - Eron
# - Youkai
#==============================================================================
# 3. Character Features
#==============================================================================

class Game_Character
  def passable?(x, y, d) # No está hecho
    case d
    when 1 # Lower Left
      new_x = x - 1
      wecoc_y = @x%2==1 ? 1 : 0
      new_y = y + wecoc_y
    when 2 # Down
      new_x = x
      new_y = y + 1
    when 3 # Lower Right
      new_x = x + 1
      wecoc_y = @x%2==1 ? 1 : 0
      new_y = y + wecoc_y
    when 5 # Upper Left
      new_x = x-1
      wecoc_y = @x%2==0 ? 1 : 0
      new_y = y - wecoc_y
    when 7 # Upper Right
      new_x = x+1
      wecoc_y = @x%2==0 ? 1 : 0
      new_y = y - wecoc_y
    when 8 # Up
      new_x = x
      new_y = y - 1
    else
      new_x = x
      new_y = y
    end
    return false unless $game_map.valid?(new_x, new_y)
    if self.is_a?(Game_Player)
      return true if $DEBUG and Input.press?(Input::CTRL)
    end
    return true if @through
    if $game_map.data[x,y,0] == 0 and
      $game_map.data[x,y,1] == 0 and
      $game_map.data[x,y,2] == 0
      return false
    end
    if $game_map.data[new_x,new_y,0] == 0 and
      $game_map.data[new_x,new_y,1] == 0 and
      $game_map.data[new_x,new_y,2] == 0
      return false
    end
    return false unless $game_map.passable?(x, y, 0)
    return false unless $game_map.passable?(new_x, new_y, 0)

    # Falta la pasibilidad por direcciones (la más complicada)
 
   for event in $game_map.events.values
      if event.x == new_x and event.y == new_y
        unless event.through
          return false if self != $game_player
          return false if event.character_name != ""
        end
      end
    end
    if $game_player.x == new_x and $game_player.y == new_y
      unless $game_player.through
        return false if @character_name != ""
      end
    end
    return true
  end

  def moving?
    wecoc_y = @x%2==0 ? 16 : 0
    return (@real_x != @x * 24 * 4 or @real_y != (@y * 32 - wecoc_y) * 4)
  end

  def moveto(x, y)
    @x = x % $game_map.width
    @y = y % $game_map.height
    wecoc_y = @x%2==0 ? 16 : 0
    @real_x = @x * 24 * 4
    @real_y = (@y * 32 - wecoc_y) * 4
    @prelock_direction = 0
  end

  def jump(x_plus, y_plus)
    tile_x = @x
    tile_y = @y
    new_tile_x = @x + x_plus
    new_tile_y = @y + y_plus
    straighten
    distance = 0
    if passable?(new_tile_x, new_tile_y, 0)
      turn_toward_tile_6(new_tile_x, new_tile_y)
      distance = Math.sqrt(x_plus * x_plus + y_plus * y_plus).round
      @x = new_tile_x
      @y = new_tile_y
    end
    @jump_peak = 10 + distance - @move_speed
    @jump_count = @jump_peak * 2
    @stop_count = 0
  end

  def tile_neighbors(x, y, d=0)
    if x%2==1
      array = [[x-1,y+1],[x,y-1],[x+1,y+1],[x,y],[x-1,y],[x,y],[x+1,y],[x,y+1]]
    else
      array = [[x-1,y],[x,y-1],[x+1,y],[x,y],[x-1,y-1],[x,y],[x+1,y-1],[x,y+1]]
    end
    return d==0 ? array : array[d-1]
  end
 
 def ring_tiles(distance)
    get_ring_tiles(self.x, self.y, distance)
  end

  def get_ring_tiles(x, y, distance)
    case distance
    when 0 then return [[x, y]]
    when 1 then return tile_neighbors(x,y)
    when 2
      neighbors = tile_neighbors(x,y)
      new_neighbors = []
      for i in 0...neighbors.size
        for j in 1..8
          new_neighbors.push(tile_neighbors(neighbors[i][0], neighbors[i][1], j))
        end
      end
      new_neighbors.uniq!
      for i in 0...neighbors.size
        new_neighbors.delete(neighbors[i])
      end
      new_neighbors.delete([x,y])
      return new_neighbors
    else
      neighbors = get_ring_tiles(x, y, distance-1)
      all_neighbors = []
      for i in 0...distance-1
        all_neighbors.push(get_ring_tiles(x, y, i))
      end
      new_neighbors = []
      for i in 0...neighbors.size
        for j in 1..8
          new_neighbors.push(tile_neighbors(neighbors[i][0], neighbors[i][1], j))
        end
      end
      new_neighbors.uniq!
      for i in 0...neighbors.size
        new_neighbors.delete(neighbors[i])
      end
      for i in 0...all_neighbors.size
        for j in 0...all_neighbors[i].size
          new_neighbors.delete(all_neighbors[i][j])
        end
      end
      new_neighbors.delete([x,y])
      return new_neighbors
    end
  end

  def screen_x
    return (@real_x - $game_map.display_x + 3) / 4 + 32 / 4
  end

  def screen_y
    y = (@real_y - $game_map.display_y + 3) / 4 + 32
    if @jump_count >= @jump_peak
      n = @jump_count - @jump_peak
    else
      n = @jump_peak - @jump_count
    end
    return y - (@jump_peak * @jump_peak - n * n) / 2
  end

  def bush_depth(depth=12)
    return 0 if @tile_id > 0 or @always_on_top
    if @jump_count == 0 and $game_map.bush?(@x, @y)
      return depth
    else
      return 0
    end
  end

  def update_jump
    @jump_count -= 1
    wecoc_y = @x%2==0 ? 16 : 0
    @real_x = (@real_x * @jump_count + @x * 24 * 4) / (@jump_count+1)
    @real_y = (@real_y * @jump_count + (@y * 32 - wecoc_y) * 4) / (@jump_count+1)
  end

  def update_move
    @false_move_speed = @move_speed if @false_move_speed == nil
    distance = 2 ** @false_move_speed
    wecoc_y = @x%2==0 ? 16 : 0
    if (@y * 32 - wecoc_y) * 4 > @real_y # Move down
      @real_y = [@real_y + distance / 1.5, (@y * 32 - wecoc_y) * 4].min
    end
    if @x * 24 * 4 < @real_x # Move left
      @real_x = [@real_x - distance / 1, @x * 24 * 4].max
    end
    if @x * 24 * 4 > @real_x # Move right
      @real_x = [@real_x + distance / 1, @x * 24 * 4].min
    end
    if (@y * 32 - wecoc_y) * 4 < @real_y # Move up
      @real_y = [@real_y - distance / 1.5, (@y * 32 - wecoc_y) * 4].max
    end
    if @walk_anime
      @anime_count += 1.5
    elsif @step_anime
      @anime_count += 1
    end
  end

  def move_type_random(app=50)
    app = [[100, app].min, 1].max
    case rand(100/app)
      when 0 then move_random # Random
    else
      case rand(2)
        when 0 then move_forward # Forward
        when 1 then @stop_count = 0 # Wait
      end
    end
  end

  def move_up(turn_enabled = true)
    @false_move_speed = @move_speed
    turn_up if turn_enabled
    if passable?(@x, @y, 8)
      turn_up
      @y -= 1
      increase_steps
    else
      check_event_trigger_touch(@x, @y-1)
    end
  end

  def move_down(turn_enabled = true)
    @false_move_speed = @move_speed
    turn_down if turn_enabled
    if passable?(@x, @y, 2)
      turn_down
      @y += 1
      increase_steps
    else
      check_event_trigger_touch(@x, @y+1)
    end
  end

  def move_lower_left(turn_enabled = true)
    @false_move_speed = @move_speed / 1.33
    turn_lower_left if turn_enabled
    @direction = 1 unless @direction_fix
    if passable?(@x, @y, 1)
      @y += 1 if @x%2==1
      @x -= 1
      increase_steps
    else
      crd = tile_neighbors(@x, @y, 1)
      check_event_trigger_touch(crd[0], crd[1])
    end
  end

  def move_lower_right(turn_enabled = true)
    @false_move_speed = @move_speed / 1.33
    turn_lower_right if turn_enabled
    @direction = 3 unless @direction_fix
    if passable?(@x, @y, 3)
      @y += 1 if @x%2==1
      @x += 1
      increase_steps
    else
      crd = tile_neighbors(@x, @y, 3)
      check_event_trigger_touch(crd[0], crd[1])
    end
  end

  def move_upper_left(turn_enabled = true)
    @false_move_speed = @move_speed / 1.33
    turn_upper_left if turn_enabled
    @direction = 5 unless @direction_fix
    if passable?(@x, @y, 5)
      @y -= 1 if @x%2==0
      @x -= 1
      increase_steps
    else
      crd = tile_neighbors(@x, @y, 5)
      check_event_trigger_touch(crd[0], crd[1])
    end
  end

  def move_upper_right(turn_enabled = true)
    @false_move_speed = @move_speed / 1.33
    turn_upper_right if turn_enabled
    @direction = 7 unless @direction_fix
    if passable?(@x, @y, 7)
      @y -= 1 if @x%2==0
      @x += 1
      increase_steps
    else
      crd = tile_neighbors(@x, @y, 7)
      check_event_trigger_touch(crd[0], crd[1])
    end
  end

  def move_random
    move_random_6
  end

  def move_random_4
    case rand(4)
      when 0 then move_down(false)
      when 1 then move_left(false)
      when 2 then move_right(false)
      when 3 then move_up(false)
    end
  end

  def move_random_6
    case rand(6)
      when 0 then move_down(false)
      when 1 then move_upper_left(false)
      when 2 then move_upper_right(false)
      when 3 then move_lower_left(false)
      when 4 then move_lower_right(false)
      when 5 then move_up(false)
    end
  end

  def move_random_4_to_6
    case rand(4)
      when 0 then move_down(false)
      when 1
        case rand(2)
          when 0 then move_upper_left(false)
          when 1 then move_upper_right(false)
        end
      when 2
        case rand(2)
          when 0 then move_lower_left(false)
          when 1 then move_lower_right(false)
        end
      when 3 then move_up(false)
    end
  end

  def move_toward_player
    move_toward_tile_6($game_player.x, $game_player.y)
  end

  def move_toward_event(event_id)
    event = $game_map.events[event_id]
    move_toward_tile_6(event.x, event.y)
  end

  def move_toward_tile_4(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
    abs_sx = sx.abs
    abs_sy = sy.abs
    if abs_sx == abs_sy
      rand(2) == 0 ? abs_sx += 1 : abs_sy += 1
    end
    if abs_sx > abs_sy
      sx > 0 ? move_left : move_right
      if not moving? and sy != 0
        sy > 0 ? move_up : move_down
      end
    else
      sy > 0 ? move_up : move_down
      if not moving? and sx != 0
        sx > 0 ? move_left : move_right
      end
    end
  end

  def move_toward_tile_6(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
   if sy <= 0
      if sy.abs > (sx.abs * 1.5)
        move_down
      else
        sx < 0 ? move_lower_right : move_lower_left
      end
    else
      if sy.abs > (sx.abs * 1.5)
        move_up
      else
        sx < 0 ? move_upper_right : move_upper_left
      end
    end
  end
 
 def move_away_from_player
    move_away_from_tile_6($game_player.x, $game_player.y)
  end

  def move_away_from_event(event_id)
    event = $game_map.events[event_id]
    move_away_from_tile_6(event.x, event.y)
  end

  def move_away_from_tile_4(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
    abs_sx = sx.abs
    abs_sy = sy.abs
    if abs_sx == abs_sy
      rand(2) == 0 ? abs_sx += 1 : abs_sy += 1
    end
    if abs_sx > abs_sy
      sx > 0 ? move_right : move_left
      if not moving? and sy != 0
        sy > 0 ? move_down : move_up
      end
    else
      sy > 0 ? move_down : move_up
      if not moving? and sx != 0
        sx > 0 ? move_right : move_left
      end
    end
  end

  def move_away_from_tile_6(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
   if sy < 0
      if sy.abs > (sx.abs * 1.5)
        move_up
      else
        sx < 0 ? move_upper_left : move_upper_right
      end
    else
      if sy.abs > (sx.abs * 1.5)
        turn_down
      else
        sx < 0 ? move_lower_left : move_lower_right
      end
    end
  end

  def move_forward
    case @direction
      when 1 then move_lower_left(false)
      when 2 then move_down(false)
      when 3 then move_lower_right(false)
      when 4 then move_left(false)
      when 5 then move_upper_left(false)
      when 6 then move_right(false)
      when 7 then move_upper_right(false)
      when 8 then move_up(false)
    end
  end

  def move_backward
    last_direction_fix = @direction_fix
    @direction_fix = true
    case @direction
      when 1 then move_upper_right(false)
      when 2 then move_up(false)
      when 3 then move_upper_left(false)
      when 4 then move_right(false)
      when 5 then move_lower_right(false)
      when 6 then move_left(false)
      when 7 then move_lower_left(false)
      when 8 then move_down(false)
    end
    @direction_fix = last_direction_fix
  end

  def turn_clock(n=1)
    return if n <= 0 or n > 5
    dir_array = [2, 1, 5, 8, 7, 3]
    return if not dir_array.include?(@direction)
    n.times do
      i = dir_array.index(@direction)
      @direction = dir_array[i+1] != nil ? dir_array[i+1] : dir_array[0]
    end
  end

  def turn_anticlock(n=1)
    return if n <= 0 or n > 5
    dir_array = [3, 7, 8, 5, 1, 2]
    return if not dir_array.include?(@direction)
    n.times do
      i = dir_array.index(@direction)
      @direction = dir_array[i+1] != nil ? dir_array[i+1] : dir_array[0]
    end
  end

  def turn_lower_left
    unless @direction_fix
      @direction = 1
      @stop_count = 0
    end
  end

  def turn_lower_right
    unless @direction_fix
      @direction = 3
      @stop_count = 0
    end
  end

  def turn_upper_left
    unless @direction_fix
      @direction = 5
      @stop_count = 0
    end
  end

  def turn_upper_right
    unless @direction_fix
      @direction = 7
      @stop_count = 0
    end
  end

  def turn_right_90
    turn_clock
  end

  def turn_left_90
    turn_anticlock
  end

  def turn_180
    case @direction
      when 1 then turn_lower_left
      when 2 then turn_down
      when 3 then turn_lower_right
      when 4 then turn_left
      when 5 then turn_upper_left
      when 6 then turn_right
      when 7 then turn_upper_right
      when 8 then turn_up
    end
  end

  def turn_right_or_left_90
    rand(2) == 0 ? turn_clock : turn_anticlock
  end

  def turn_random
    turn_random_6
  end

  def turn_random_4
    case rand(4)
      when 0 then turn_down
      when 1 then turn_left
      when 2 then turn_right
      when 3 then turn_up
    end
  end

  def turn_random_6
    case rand(6)
      when 0 then turn_down
      when 1 then turn_upper_left
      when 2 then turn_upper_right
      when 3 then turn_lower_left
      when 4 then turn_lower_right
      when 5 then turn_up
    end
  end

  def turn_random_4_to_6
    case rand(4)
      when 0 then turn_down
      when 1
        case rand(2)
          when 0 then turn_upper_left(false)
          when 1 then turn_upper_right(false)
        end
      when 2
        case rand(2)
          when 0 then turn_lower_left(false)
          when 1 then turn_lower_right(false)
        end
      when 3 then turn_up(false)
    end
  end

  def turn_toward_player
    turn_toward_tile_6($game_player.x, $game_player.y)
  end

  def turn_toward_event(event_id)
    event = $game_map.events[event_id]
    turn_toward_tile_6(event.x, event.y)
  end

  def turn_toward_tile_4(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
    if sx.abs > sy.abs
      sx > 0 ? turn_left : turn_right
    else
      sy > 0 ? turn_up : turn_down
    end
  end

  def turn_toward_tile_6(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
   if sy <= 0
      if sy.abs > (sx.abs * 1.5)
        turn_down
      else
        sx < 0 ? turn_lower_right : turn_lower_left
      end
    else
      if sy.abs > (sx.abs * 1.5)
        turn_up
      else
        sx < 0 ? turn_upper_right : turn_upper_left
      end
    end
  end

  def turn_away_from_player
    turn_away_from_tile_6($game_player.x, $game_player.y)
  end

  def turn_away_from_event(event_id)
    event = $game_map.events[event_id]
    turn_away_from_tile_6(event.x, event.y)
  end

  def turn_away_from_tile_4(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
    if sx.abs > sy.abs
      sx > 0 ? turn_right : turn_left
    else
      sy > 0 ? turn_down : turn_up
    end
  end

  def turn_away_from_tile_6(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
   if sy < 0
      if sy.abs > (sx.abs * 1.5)
        turn_up
      else
        sx < 0 ? turn_upper_left : turn_upper_right
      end
    else
      if sy.abs > (sx.abs * 1.5)
        turn_down
      else
        sx < 0 ? turn_lower_left : turn_lower_right
      end
    end
  end
end

class Game_Player < Game_Character

  CENTER_X = (640 / 2 - 32 / 2) * 4  # Center screen x-coordinate * 4
  CENTER_Y = (480 / 2 - 32 / 2) * 4  # Center screen y-coordinate * 4

  def passable?(x, y, d)
    super
  end

  def center(x, y)
    max_x = ($game_map.width - 20) * 32 * 4
    max_y = ($game_map.height - 15) * 32 * 4
    $game_map.display_x = [0, [x * (32 - 8) * 4 - CENTER_X, max_x].min].max
    $game_map.display_y = [0, [y * 32 * 4 - CENTER_Y, max_y].min].max
  end

  def check_event_trigger_there(triggers)
    result = false
    return result if $game_system.map_interpreter.running?
    y_correct = case @direction
    when 2 then 1
    when 8 then -1
    when 1, 3 then @x%2==1 ? 1 : 0
    when 5, 7 then @x%2==1 ? 0 : -1
    else; 0
    end
    x_correct = case @direction
    when 6, 3, 7 then @x + 1
    when 4, 1, 5 then @x - 1
    else; 0
    end
    new_x = @x + x_correct
    new_y = @y + y_correct
    for event in $game_map.events.values
      if event.x == new_x and event.y == new_y and
        triggers.include?(event.trigger)
        if not event.jumping? and not event.over_trigger?
          event.start
          result = true
        end
      end
    end
    if result == false
      if $game_map.counter?(new_x, new_y)
        for event in $game_map.events.values
          if event.x == new_x and event.y == new_y and
            triggers.include?(event.trigger)
            if not event.jumping? and not event.over_trigger?
              event.start
              result = true
            end
          end
        end
      end
    end
    return result
  end
end

class Sprite_Character < RPG::Sprite
  def update
    super
    if @tile_id != @character.tile_id or
      @character_name != @character.character_name or
      @character_hue != @character.character_hue
      @tile_id = @character.tile_id
      @character_name = @character.character_name
      @character_hue = @character.character_hue
      if @tile_id >= 384
        self.bitmap = RPG::Cache.tile($game_map.tileset_name,
          @tile_id, @character.character_hue)
        self.src_rect.set(0, 0, 32, 32)
        self.ox = 16
        self.oy = 32
      else
        self.bitmap = RPG::Cache.character(@character.character_name,
          @character.character_hue)
        @cw = bitmap.width / 4
        @ch = bitmap.height / 6
        self.ox = @cw / 2
        self.oy = @ch
      end
    end
    self.visible = (not @character.transparent)
    if @tile_id == 0
      sx = @character.pattern * @cw
      dir_array = [1, 0, 2, 0, 3, 0, 4, 5]
      sy = dir_array[@character.direction-1] * @ch
      self.src_rect.set(sx, sy, @cw, @ch)
    end
    self.x = @character.screen_x
    self.y = @character.screen_y
    self.z = @character.screen_z(@ch)
    self.opacity = @character.opacity
    self.blend_type = @character.blend_type
    self.bush_depth = @character.bush_depth(16)
    if @character.animation_id != 0
      animation = $data_animations[@character.animation_id]
      animation(animation, true)
      @character.animation_id = 0
    end
  end
end
En realidad falta más de lo que crees. El scroll no funciona bien hacia ningún lado, por culpa de las modificaciones que hubo que hacer al @real_x y al @real_y. Además no me gusta que el scroll llegue hasta el final, sería mejor que llegara hasta el final - 1 porque si no el último tile siempre se ve feo así:



Además también habría que hacer scroll_lower_left, scroll_lower_right, scroll_upper_left, scroll_upper_right.

Y lo más complicado es lo de la pasabilidad, a parte que muy probablemente para el pathfinding y el mouse necesitaremos scripts ya hechos.

Por cierto estoy haciendo un mapa para cuando esté todo acabado y saquemos demo, pero como veis de momento solo uso el template que me hice y un chara desnudo xD Quizá pida cierta ayuda gráfica más adelante...

=====

Youki, hay algo del event trigger que no acaba de funcionar bien. Si intentas hablar con un evento funciona bien si estás arriba o abajo, pero si intentas hablar desde cualquier otro ángulo lateral no responde.

=====

Eron me comentó que el problema de los autotiles tal y como estan ahora es que aunque haya ampliado el número de tiles al doble para dibujarlos según su x%2, tanto el control de sus tiles vecinos como cada una de sus subpartes siguen siendo leídos de manera axial mientra que se tendrían que leer de manera como él dijo "tridimensional" (aunque yo prefiero llamarlo hexagonal xD). El problema es que la forma de hexágono, a diferencia de la del cuadrado, no se puede subdividir en cuadrados o rectángulos pequeños no superpuestos, eso supondría que tendría que hacerse cada caso del autotile. Esto en tiles cuadrados supondría hacer 48 tiles, pero es que además en tiles hexagonales unos pocos más. Os paso un template del gráfico que se tendría que usar.

Spoiler:


Evidentemente hacer eso es demasiado de locos para cualquier grafista (imaginaos los autotiles animados xD) así que simplemente recomiendo prescindir de los autotiles en este sistema y ya está.
avatar
Wecoc
Administrador
Administrador



Créditos 12211

Gracias : 632

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por MaddManu el 2013-08-14, 01:01

Comento en calidad de espectador para que tengáis en cuenta que hay gente que sigue el proyecto y os lee aunque no contribuya con contenidos. Admiro el trabajo y me parece una de las cosas más significativas que se están haciendo en este foro, desde que estoy en el foro. Sin más, os doy mi apoyo por que se que podéis hacer algo comparable en fama al famoso Mode7. Saludos :)
avatar
MaddManu
Soñador
Soñador

0/3

Créditos 378

Gracias : 5

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por Wecoc el 2013-08-14, 02:04

Gracias MaddManu. Seh, este tipo de cosas deberían hacerse más a menudo xDDD

He hecho alguna cosilla más, a ver. Por ahora voy tirando cosas sencillas porque las complicadas me asustan un poco xD

Código:
#==============================================================================
# Hextiles
#==============================================================================
# Script creado por usuarios de Mundo Maker:
# - Wecoc
# - Pokepik
# - Orochii
# - Eron
# - Youkai
#==============================================================================
# 3. Character Features
#==============================================================================

class Game_Character
  
  attr_accessor   :direction
  attr_accessor   :pattern
  
  def passable?(x, y, d) # No está hecho
    case d
    when 1 # Lower Left
      new_x = x - 1
      wecoc_y = @x%2==1 ? 1 : 0
      new_y = y + wecoc_y
    when 2 # Down
      new_x = x
      new_y = y + 1
    when 3 # Lower Right
      new_x = x + 1
      wecoc_y = @x%2==1 ? 1 : 0
      new_y = y + wecoc_y
    when 5 # Upper Left
      new_x = x-1
      wecoc_y = @x%2==0 ? 1 : 0
      new_y = y - wecoc_y
    when 7 # Upper Right
      new_x = x+1
      wecoc_y = @x%2==0 ? 1 : 0
      new_y = y - wecoc_y
    when 8 # Up
      new_x = x
      new_y = y - 1
    else
      new_x = x
      new_y = y
    end
    return false unless $game_map.valid?(new_x, new_y)
    if self.is_a?(Game_Player)
      return true if $DEBUG and Input.press?(Input::CTRL)
    end
    return true if @through
    if $game_map.data[x,y,0] == 0 and
      $game_map.data[x,y,1] == 0 and
      $game_map.data[x,y,2] == 0
      return false
    end
    if $game_map.data[new_x,new_y,0] == 0 and
      $game_map.data[new_x,new_y,1] == 0 and
      $game_map.data[new_x,new_y,2] == 0
      return false
    end
    return false unless $game_map.passable?(x, y, 0)
    return false unless $game_map.passable?(new_x, new_y, 0)

    # Falta la pasibilidad por direcciones (la más complicada)
 
   for event in $game_map.events.values
      if event.x == new_x and event.y == new_y
        unless event.through
          return false if self != $game_player
          return false if event.character_name != ""
        end
      end
    end
    if $game_player.x == new_x and $game_player.y == new_y
      unless $game_player.through
        return false if @character_name != ""
      end
    end
    return true
  end

  def moving?
    wecoc_y = @x%2==0 ? 16 : 0
    return (@real_x != @x * 24 * 4 or @real_y != (@y * 32 - wecoc_y) * 4)
  end

  def moveto(x, y)
    @x = x % $game_map.width
    @y = y % $game_map.height
    wecoc_y = @x%2==0 ? 16 : 0
    @real_x = @x * 24 * 4
    @real_y = (@y * 32 - wecoc_y) * 4
    @prelock_direction = 0
  end

  def jump(x_plus, y_plus)
    tile_x = @x
    tile_y = @y
    new_tile_x = @x + x_plus
    new_tile_y = @y + y_plus
    straighten
    distance = 0
    if passable?(new_tile_x, new_tile_y, 0)
      turn_toward_tile_6(new_tile_x, new_tile_y)
      distance = Math.sqrt(x_plus * x_plus + y_plus * y_plus).round
      @x = new_tile_x
      @y = new_tile_y
    end
    @jump_peak = 10 + distance - @move_speed
    @jump_count = @jump_peak * 2
    @stop_count = 0
  end

  def tile_neighbors(x, y, d=0)
    if x%2==1
      array = [[x-1,y+1],[x,y-1],[x+1,y+1],[x,y],[x-1,y],[x,y],[x+1,y],[x,y+1]]
    else
      array = [[x-1,y],[x,y-1],[x+1,y],[x,y],[x-1,y-1],[x,y],[x+1,y-1],[x,y+1]]
    end
    return d==0 ? array : array[d-1]
  end
 
 def ring_tiles(distance)
    get_ring_tiles(self.x, self.y, distance)
  end

  def get_ring_tiles(x, y, distance)
    case distance
    when 0 then return [[x, y]]
    when 1 then return tile_neighbors(x,y)
    when 2
      neighbors = tile_neighbors(x,y)
      new_neighbors = []
      for i in 0...neighbors.size
        for j in 1..8
          new_neighbors.push(tile_neighbors(neighbors[i][0], neighbors[i][1], j))
        end
      end
      new_neighbors.uniq!
      for i in 0...neighbors.size
        new_neighbors.delete(neighbors[i])
      end
      new_neighbors.delete([x,y])
      return new_neighbors
    else
      neighbors = get_ring_tiles(x, y, distance-1)
      all_neighbors = []
      for i in 0...distance-1
        all_neighbors.push(get_ring_tiles(x, y, i))
      end
      new_neighbors = []
      for i in 0...neighbors.size
        for j in 1..8
          new_neighbors.push(tile_neighbors(neighbors[i][0], neighbors[i][1], j))
        end
      end
      new_neighbors.uniq!
      for i in 0...neighbors.size
        new_neighbors.delete(neighbors[i])
      end
      for i in 0...all_neighbors.size
        for j in 0...all_neighbors[i].size
          new_neighbors.delete(all_neighbors[i][j])
        end
      end
      new_neighbors.delete([x,y])
      return new_neighbors
    end
  end

  def screen_x
    return (@real_x - $game_map.display_x + 3) / 4 + 32 / 4
  end

  def screen_y
    y = (@real_y - $game_map.display_y + 3) / 4 + 32
    if @jump_count >= @jump_peak
      n = @jump_count - @jump_peak
    else
      n = @jump_peak - @jump_count
    end
    return y - (@jump_peak * @jump_peak - n * n) / 2
  end

  def screen_z(height = 0)
    return 999 if @always_on_top
    z = (@real_y - $game_map.display_y + 3) / 4 + 32
    if @tile_id > 0
      return z + $game_map.priorities[@tile_id] * 32
    else
      return z + ((height > 32) ? 32 - 1 : 0)
    end
  end
  
  def bush_depth(depth=12)
    return 0 if @tile_id > 0 or @always_on_top
    if @jump_count == 0 and $game_map.bush?(@x, @y)
      return depth
    else
      return 0
    end
  end

  def update_jump
    @jump_count -= 1
    wecoc_y = @x%2==0 ? 16 : 0
    @real_x = (@real_x * @jump_count + @x * 24 * 4) / (@jump_count+1)
    @real_y = (@real_y * @jump_count + (@y * 32 - wecoc_y) * 4) / (@jump_count+1)
  end

  def update_move
    @false_move_speed = @move_speed if @false_move_speed == nil
    distance = 2 ** @false_move_speed
    wecoc_y = @x%2==0 ? 16 : 0
    if (@y * 32 - wecoc_y) * 4 > @real_y # Move down
      @real_y = [@real_y + distance / 1.5, (@y * 32 - wecoc_y) * 4].min
    end
    if @x * 24 * 4 < @real_x # Move left
      @real_x = [@real_x - distance / 1, @x * 24 * 4].max
    end
    if @x * 24 * 4 > @real_x # Move right
      @real_x = [@real_x + distance / 1, @x * 24 * 4].min
    end
    if (@y * 32 - wecoc_y) * 4 < @real_y # Move up
      @real_y = [@real_y - distance / 1.5, (@y * 32 - wecoc_y) * 4].max
    end
    if @walk_anime
      @anime_count += 1.5
    elsif @step_anime
      @anime_count += 1
    end
  end

  def move_type_random(app=50)
    app = [[100, app].min, 1].max
    case rand(100/app)
      when 0 then move_random # Random
    else
      case rand(2)
        when 0 then move_forward # Forward
        when 1 then @stop_count = 0 # Wait
      end
    end
  end

  def move_up(turn_enabled = true)
    @false_move_speed = @move_speed
    turn_up if turn_enabled
    if passable?(@x, @y, 8)
      turn_up
      @y -= 1
      increase_steps
    else
      check_event_trigger_touch(@x, @y-1)
    end
  end

  def move_down(turn_enabled = true)
    @false_move_speed = @move_speed
    turn_down if turn_enabled
    if passable?(@x, @y, 2)
      turn_down
      @y += 1
      increase_steps
    else
      check_event_trigger_touch(@x, @y+1)
    end
  end

  def move_lower_left(turn_enabled = true)
    @false_move_speed = @move_speed / 1.33
    turn_lower_left if turn_enabled
    @direction = 1 unless @direction_fix
    if passable?(@x, @y, 1)
      @y += 1 if @x%2==1
      @x -= 1
      increase_steps
    else
      crd = tile_neighbors(@x, @y, 1)
      check_event_trigger_touch(crd[0], crd[1])
    end
  end

  def move_lower_right(turn_enabled = true)
    @false_move_speed = @move_speed / 1.33
    turn_lower_right if turn_enabled
    @direction = 3 unless @direction_fix
    if passable?(@x, @y, 3)
      @y += 1 if @x%2==1
      @x += 1
      increase_steps
    else
      crd = tile_neighbors(@x, @y, 3)
      check_event_trigger_touch(crd[0], crd[1])
    end
  end

  def move_upper_left(turn_enabled = true)
    @false_move_speed = @move_speed / 1.33
    turn_upper_left if turn_enabled
    @direction = 5 unless @direction_fix
    if passable?(@x, @y, 5)
      @y -= 1 if @x%2==0
      @x -= 1
      increase_steps
    else
      crd = tile_neighbors(@x, @y, 5)
      check_event_trigger_touch(crd[0], crd[1])
    end
  end

  def move_upper_right(turn_enabled = true)
    @false_move_speed = @move_speed / 1.33
    turn_upper_right if turn_enabled
    @direction = 7 unless @direction_fix
    if passable?(@x, @y, 7)
      @y -= 1 if @x%2==0
      @x += 1
      increase_steps
    else
      crd = tile_neighbors(@x, @y, 7)
      check_event_trigger_touch(crd[0], crd[1])
    end
  end

  def move_random
    move_random_6
  end

  def move_random_4
    case rand(4)
      when 0 then move_down(false)
      when 1 then move_left(false)
      when 2 then move_right(false)
      when 3 then move_up(false)
    end
  end

  def move_random_6
    case rand(6)
      when 0 then move_down(false)
      when 1 then move_upper_left(false)
      when 2 then move_upper_right(false)
      when 3 then move_lower_left(false)
      when 4 then move_lower_right(false)
      when 5 then move_up(false)
    end
  end

  def move_random_4_to_6
    case rand(4)
      when 0 then move_down(false)
      when 1
        case rand(2)
          when 0 then move_upper_left(false)
          when 1 then move_upper_right(false)
        end
      when 2
        case rand(2)
          when 0 then move_lower_left(false)
          when 1 then move_lower_right(false)
        end
      when 3 then move_up(false)
    end
  end

  def move_toward_player
    move_toward_tile_6($game_player.x, $game_player.y)
  end

  def move_toward_event(event_id)
    event = $game_map.events[event_id]
    move_toward_tile_6(event.x, event.y)
  end

  def move_toward_tile_4(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
    abs_sx = sx.abs
    abs_sy = sy.abs
    if abs_sx == abs_sy
      rand(2) == 0 ? abs_sx += 1 : abs_sy += 1
    end
    if abs_sx > abs_sy
      sx > 0 ? move_left : move_right
      if not moving? and sy != 0
        sy > 0 ? move_up : move_down
      end
    else
      sy > 0 ? move_up : move_down
      if not moving? and sx != 0
        sx > 0 ? move_left : move_right
      end
    end
  end

  def move_toward_tile_6(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
   if sy <= 0
      if sy.abs > (sx.abs * 1.5)
        move_down
      else
        sx < 0 ? move_lower_right : move_lower_left
      end
    else
      if sy.abs > (sx.abs * 1.5)
        move_up
      else
        sx < 0 ? move_upper_right : move_upper_left
      end
    end
  end
 
 def move_away_from_player
    move_away_from_tile_6($game_player.x, $game_player.y)
  end

  def move_away_from_event(event_id)
    event = $game_map.events[event_id]
    move_away_from_tile_6(event.x, event.y)
  end

  def move_away_from_tile_4(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
    abs_sx = sx.abs
    abs_sy = sy.abs
    if abs_sx == abs_sy
      rand(2) == 0 ? abs_sx += 1 : abs_sy += 1
    end
    if abs_sx > abs_sy
      sx > 0 ? move_right : move_left
      if not moving? and sy != 0
        sy > 0 ? move_down : move_up
      end
    else
      sy > 0 ? move_down : move_up
      if not moving? and sx != 0
        sx > 0 ? move_right : move_left
      end
    end
  end

  def move_away_from_tile_6(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
   if sy < 0
      if sy.abs > (sx.abs * 1.5)
        move_up
      else
        sx < 0 ? move_upper_left : move_upper_right
      end
    else
      if sy.abs > (sx.abs * 1.5)
        turn_down
      else
        sx < 0 ? move_lower_left : move_lower_right
      end
    end
  end

  def move_forward
    case @direction
      when 1 then move_lower_left(false)
      when 2 then move_down(false)
      when 3 then move_lower_right(false)
      when 4 then move_left(false)
      when 5 then move_upper_left(false)
      when 6 then move_right(false)
      when 7 then move_upper_right(false)
      when 8 then move_up(false)
    end
  end

  def move_backward
    last_direction_fix = @direction_fix
    @direction_fix = true
    case @direction
      when 1 then move_upper_right(false)
      when 2 then move_up(false)
      when 3 then move_upper_left(false)
      when 4 then move_right(false)
      when 5 then move_lower_right(false)
      when 6 then move_left(false)
      when 7 then move_lower_left(false)
      when 8 then move_down(false)
    end
    @direction_fix = last_direction_fix
  end

  def turn_clock(n=1)
    return if n <= 0 or n > 5
    dir_array = [2, 1, 5, 8, 7, 3]
    return if not dir_array.include?(@direction)
    n.times do
      i = dir_array.index(@direction)
      @direction = dir_array[i+1] != nil ? dir_array[i+1] : dir_array[0]
    end
  end

  def turn_anticlock(n=1)
    return if n <= 0 or n > 5
    dir_array = [3, 7, 8, 5, 1, 2]
    return if not dir_array.include?(@direction)
    n.times do
      i = dir_array.index(@direction)
      @direction = dir_array[i+1] != nil ? dir_array[i+1] : dir_array[0]
    end
  end

  def turn_lower_left
    unless @direction_fix
      @direction = 1
      @stop_count = 0
    end
  end

  def turn_lower_right
    unless @direction_fix
      @direction = 3
      @stop_count = 0
    end
  end

  def turn_upper_left
    unless @direction_fix
      @direction = 5
      @stop_count = 0
    end
  end

  def turn_upper_right
    unless @direction_fix
      @direction = 7
      @stop_count = 0
    end
  end

  def turn_right_90
    turn_clock
  end

  def turn_left_90
    turn_anticlock
  end

  def turn_180
    case @direction
      when 1 then turn_lower_left
      when 2 then turn_down
      when 3 then turn_lower_right
      when 4 then turn_left
      when 5 then turn_upper_left
      when 6 then turn_right
      when 7 then turn_upper_right
      when 8 then turn_up
    end
  end

  def turn_right_or_left_90
    rand(2) == 0 ? turn_clock : turn_anticlock
  end

  def turn_random
    turn_random_6
  end

  def turn_random_4
    case rand(4)
      when 0 then turn_down
      when 1 then turn_left
      when 2 then turn_right
      when 3 then turn_up
    end
  end

  def turn_random_6
    case rand(6)
      when 0 then turn_down
      when 1 then turn_upper_left
      when 2 then turn_upper_right
      when 3 then turn_lower_left
      when 4 then turn_lower_right
      when 5 then turn_up
    end
  end

  def turn_random_4_to_6
    case rand(4)
      when 0 then turn_down
      when 1
        case rand(2)
          when 0 then turn_upper_left(false)
          when 1 then turn_upper_right(false)
        end
      when 2
        case rand(2)
          when 0 then turn_lower_left(false)
          when 1 then turn_lower_right(false)
        end
      when 3 then turn_up(false)
    end
  end

  def turn_toward_player
    turn_toward_tile_6($game_player.x, $game_player.y)
  end

  def turn_toward_event(event_id)
    event = $game_map.events[event_id]
    turn_toward_tile_6(event.x, event.y)
  end

  def turn_toward_tile_4(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
    if sx.abs > sy.abs
      sx > 0 ? turn_left : turn_right
    else
      sy > 0 ? turn_up : turn_down
    end
  end

  def turn_toward_tile_6(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
   if sy <= 0
      if sy.abs > (sx.abs * 1.5)
        turn_down
      else
        sx < 0 ? turn_lower_right : turn_lower_left
      end
    else
      if sy.abs > (sx.abs * 1.5)
        turn_up
      else
        sx < 0 ? turn_upper_right : turn_upper_left
      end
    end
  end

  def turn_away_from_player
    turn_away_from_tile_6($game_player.x, $game_player.y)
  end

  def turn_away_from_event(event_id)
    event = $game_map.events[event_id]
    turn_away_from_tile_6(event.x, event.y)
  end

  def turn_away_from_tile_4(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
    if sx.abs > sy.abs
      sx > 0 ? turn_right : turn_left
    else
      sy > 0 ? turn_down : turn_up
    end
  end

  def turn_away_from_tile_6(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
   if sy < 0
      if sy.abs > (sx.abs * 1.5)
        turn_up
      else
        sx < 0 ? turn_upper_left : turn_upper_right
      end
    else
      if sy.abs > (sx.abs * 1.5)
        turn_down
      else
        sx < 0 ? turn_lower_left : turn_lower_right
      end
    end
  end
end

class Game_Player < Game_Character

  CENTER_X = (640 / 2 - 32 / 2) * 4  # Center screen x-coordinate * 4
  CENTER_Y = (480 / 2 - 32 / 2) * 4  # Center screen y-coordinate * 4

  def passable?(x, y, d)
    super
  end

  def check_event_trigger_there(triggers)
    result = false
    return result if $game_system.map_interpreter.running?
    y_correct = case @direction
    when 2 then 1
    when 8 then -1
    when 1, 3 then @x%2==1 ? 1 : 0
    when 5, 7 then @x%2==1 ? 0 : -1
    else; 0
    end
    x_correct = case @direction
    when 6, 3, 7 then @x + 1
    when 4, 1, 5 then @x - 1
    else; 0
    end
    new_x = @x + x_correct
    new_y = @y + y_correct
    for event in $game_map.events.values
      if event.x == new_x and event.y == new_y and
        triggers.include?(event.trigger)
        if not event.jumping? and not event.over_trigger?
          event.start
          result = true
        end
      end
    end
    if result == false
      if $game_map.counter?(new_x, new_y)
        for event in $game_map.events.values
          if event.x == new_x and event.y == new_y and
            triggers.include?(event.trigger)
            if not event.jumping? and not event.over_trigger?
              event.start
              result = true
            end
          end
        end
      end
    end
    return result
  end
end

class Sprite_Character < RPG::Sprite
  def update
    super
    if @tile_id != @character.tile_id or
      @character_name != @character.character_name or
      @character_hue != @character.character_hue
      @tile_id = @character.tile_id
      @character_name = @character.character_name
      @character_hue = @character.character_hue
      if @tile_id >= 384
        self.bitmap = RPG::Cache.tile($game_map.tileset_name,
          @tile_id, @character.character_hue)
        self.src_rect.set(0, 0, 32, 32)
        self.ox = 16
        self.oy = 32
      else
        self.bitmap = RPG::Cache.character(@character.character_name,
          @character.character_hue)
        @cw = bitmap.width / 4
        @ch = bitmap.height / 6
        self.ox = @cw / 2
        self.oy = @ch
      end
    end
    self.visible = (not @character.transparent)
    if @tile_id == 0
      sx = @character.pattern * @cw
      dir_array = [1, 0, 2, 0, 3, 0, 4, 5]
      sy = dir_array[@character.direction-1] * @ch
      self.src_rect.set(sx, sy, @cw, @ch)
    end
    self.x = @character.screen_x
    self.y = @character.screen_y
    self.z = @character.screen_z(@ch)
    self.opacity = @character.opacity
    self.blend_type = @character.blend_type
    self.bush_depth = @character.bush_depth(16)
    if @character.animation_id != 0
      animation = $data_animations[@character.animation_id]
      animation(animation, true)
      @character.animation_id = 0
    end
  end
end
Código:
#==============================================================================
# Hextiles
#==============================================================================
# Script creado por usuarios de Mundo Maker:
# - Wecoc
# - Pokepik
# - Orochii
# - Eron
# - Youkai
#==============================================================================
# 4. Move Route Fix
#==============================================================================

=begin
  1 - Move down
  2 - Move left
  3 - Move right
  4 - Move up
  5 - Move lower left
  6 - Move lower right
  7 - Move upper left
  8 - Move upper right
  9 - Move random (6 dir)
  10 - Move toward player
  11 - Move away from player
  12 - 1 step forward
  13 - 1 step backward
  14 - Jump # => parameters = [x_plus, y_plus]
  15 - Wait # => parameters = [frames]
 
  16 - Turn down
  17 - Turn left
  18 - Turn right
  19 - Turn up
  20 - Turn right (next direction)
  21 - Turn left (prev direction)
  22 - Turn 180 (opp direction)
  23 - Turn right or left (next / prev direction)
  24 - Turn random (6 dir)
  25 - Turn toward player
  26 - Turn away from player
 
  27 - Switch ON # => parameters = [switch_id]
  28 - Switch OFF # => parameters = [switch_id]
  29 - Change speed # => parameters = [speed]
  30 - Change frequency # => parameters = [frequency]
  31 - Move Animation ON
  32 - Move Animation OFF
  33 - Stop Animation ON
  34 - Stop Animation OFF
  35 - Direction fix ON
  36 - Direction fix OFF
  37 - Through ON
  38 - Through OFF
  39 - Always on top ON
  40 - Always on top OFF
 
  41 - Change Graphic
    # => parameters = [character_name, character_hue, direction, pattern]
  42 - Change Opacity # => parameters = [opacity]
  43 - Change Blending # => parameters = [blend_type]
  44 - Play SE # => parameters = [se]
  45 - Script # => parameters = [eval code]
 
  46 - Move Type Random # => parameters = [percent]
  47 - Move random (6 dir, 4 rand)
  48 - Move toward event # => parameters = [event_id]
  49 - Move away from event # => parameters = [event_id]
  50 - Move toward tile # => parameters = [x, y]
  51 - Move away from tile # => parameters = [x, y]
  52 - Jump # => parameters = [new_x, new_y]
 
  53 - Turn right (next * n direction) # => parameters = [n]
  54 - Turn left (prev * n direction) # => parameters = [n]
  55 - Turn lower left
  56 - Turn lower right
  57 - Turn upper left
  58 - Turn upper right
  59 - Turn random (6 dir, 4 rand)
  60 - Turn toward event # => parameters = [event_id]
  61 - Turn away from event # => parameters = [event_id]
  62 - Turn toward tile # => parameters = [x, y]
  63 - Turn away from tile # => parameters = [x, y]
  64 - Change Graphic (to tile) # => parameters = [tile_id]
  65 - Change Graphic (same direction)
    # => parameters = [character_name, character_hue]
=end

class Game_Character
  def execute_code(code, parameters=[])
    if code <= 45 # Default Command Codes
      case code
        when 1  then move_down
        when 2  then move_left
        when 3  then move_right
        when 4  then move_up
        when 5  then move_lower_left
        when 6  then move_lower_right
        when 7  then move_upper_left
        when 8  then move_upper_right
        when 9  then move_random
        when 10 then move_toward_player
        when 11 then move_away_from_player
        when 12 then move_forward
        when 13 then move_backward
        when 14 then jump(parameters[0], parameters[1])
        when 15 then @wait_count = command.parameters[0] * 2 - 1
       
        when 16 then turn_down
        when 17 then turn_left
        when 18 then turn_right
        when 19 then turn_up
        when 20 then turn_right_90
        when 21 then turn_left_90
        when 22 then turn_180
        when 23 then turn_right_or_left_90
        when 24 then turn_random
        when 25 then turn_toward_player
        when 26 then turn_away_from_player
        when 27 then $game_switches[parameters[0]] = true
        when 28 then $game_switches[parameters[0]] = false
        when 29 then @move_speed = parameters[0]
        when 30 then @move_frequency = parameters[0]
        when 31 then @walk_anime = true
        when 32 then @walk_anime = false
        when 33 then @step_anime = true
        when 34 then @step_anime = false
        when 35 then @direction_fix = true
        when 36 then @direction_fix = false
        when 37 then @through = true
        when 38 then @through = false
        when 39 then @always_on_top = true
        when 40 then @always_on_top = false
        when 41
          @tile_id = 0
          @character_name = parameters[0]
          @character_hue = parameters[1]
          if @original_direction != parameters[2]
            @direction = parameters[2]
            @original_direction = @direction
            @prelock_direction = 0
          end
          if @original_pattern != parameters[3]
            @pattern = parameters[3]
            @original_pattern = @pattern
          end
        when 42 then @opacity = parameters[0]
        when 43 then @blend_type = parameters[0]
        when 44 then $game_system.se_play(parameters[0])
        when 45 then result = eval(parameters[0])
      end
    else # code > 45
      case code
        when 46 then move_type_random(parameters[0])
        when 47 then move_random_4_to_6
        when 48 then move_toward_event(parameters[0])
        when 49 then move_away_from_event(parameters[0])
        when 50 then move_toward_tile_6(parameters[0], parameters[1])
        when 51 then move_away_from_tile_6(parameters[0])
        when 52
          x = self.x ; y = self.y
          plus_x = parameters[0] - x ; plus_y = parameters[1] - y
          jump(plus_x. plus_y)
        when 53 then turn_clock(parameters[0])
        when 54 then turn_anticlock(parameters[0])
        when 55 then turn_lower_left
        when 56 then turn_lower_right
        when 57 then turn_upper_left
        when 58 then turn_upper_right
        when 59 then turn_random_4_to_6
        when 60 then turn_toward_event(parameters[0])
        when 61 then turn_away_from_event(parameters[0])
        when 62 then turn_toward_tile_6(parameters[0], parameters[1])
        when 63 then turn_away_from_tile_6(parameters[0], parameters[1])
        when 64
          @tile_id = parameters[0]
        when 65
          @tile_id = 0
          @character_name = parameters[0]
          @character_hue = parameters[1]
        # when ...
      end
    end
  end
 
  def move_type_custom
    return if jumping? or moving?
    while @move_route_index < @move_route.list.size
      command = @move_route.list[@move_route_index]
      if command.code == 0
        @move_route_index = 0 if @move_route.repeat
        unless @move_route.repeat
          if @move_route_forcing and not @move_route.repeat
            @move_route_forcing = false
            @move_route = @original_move_route
            @move_route_index = @original_move_route_index
            @original_move_route = nil
          end
          @stop_count = 0
        end
        return
      end
      execute_code(command.code, command.parameters)
      case command.code
        when 1..14, 46..52
          return if not @move_route.skippable and not moving? and not jumping?
        when 27,28 then $game_map.need_refresh = true
      end
      @move_route_index += 1
    end
  end
end

# transfer_player
# transfer_event

class Interpreter
  def transfer_player(map_id, x, y, direction=0, freeze = true)
    if $game_temp.player_transferring or
      $game_temp.message_window_showing or
      $game_temp.transition_processing
      return false
    end
    $game_temp.player_transferring = true
    $game_temp.player_new_map_id = map_id
    $game_temp.player_new_x = x
    $game_temp.player_new_y = y
    $game_temp.player_new_direction = direction if direction != 0
    @index += 1
    if freeze
      Graphics.freeze
      $game_temp.transition_processing = true
      $game_temp.transition_name = ""
    end
  end
 
  def command_201
    return true if $game_temp.in_battle
    if @parameters[0] == 0
      map_id = @parameters[1]
      x = @parameters[2]
      y = @parameters[3]
    else
      map_id = $game_variables[@parameters[1]]
      x = $game_variables[@parameters[2]]
      y = $game_variables[@parameters[3]]
    end
    dir = @parameters[4]
    freeze = @parameters[5] == 0 ? true : false
    transfer_player(map_id, x, y, dir, freeze)
    return false
  end
 
  def transfer_event(event, x, y, direction=0, freeze = false)
    event = get_character(event) if event.is_a?(Integer)
    event.moveto(x,y)
    event.direction = direction if direction != 0
    if freeze
      transfer_player($game_map.map_id, $game_player.x, $game_player.y)
      @index -= 1
    end
  end
 
  def command_202
    return true if $game_temp.in_battle
    character = get_character(@parameters[0])
    return true if character == nil
    if @parameters[1] == 0
      x = @parameters[2]
      y = @parameters[3]
    elsif @parameters[1] == 1
      x = $game_variables[@parameters[2]]
      y = $game_variables[@parameters[3]]
    else
      old_x = character.x
      old_y = character.y
      character2 = get_character(@parameters[2])
      x = character2.x
      y = character2.y
      if character2 != nil
        transfer_event(character2, x, y, 0)
      end
    end
    dir = @parameters[4]
    transfer_event(character, x, y, dir)
    return true
  end
end
Teletransportar y Elegir posición de evento funcionan como siempre. Lo que pasa es que el comando no te da todas las direcciones posibles. Así que además creé dos métodos que se llaman tal cual desde el script y que hacen lo mismo que esos dos comandos (de hecho son atajos de los comandos xD)

transfer_player(map_id, x, y, direction, freeze)
Por ejemplo: transfer_player(1, 10, 10, 1, true) teletransporta al personje al mapa 1, tile [10, 10], con dirección 1 (Abajo-Izquierda) y con "Borrado: sí"

transfer_event(event_id, x, y, direction, freeze)
Por ejemplo: transfer_event(1, 5, 7, 5, false) teletransporta al evento 1 al tile [5, 7] con dirección 5 (Arriba-Izquierda) y con "Borrado: no". Tuve que hacer una pequeña trampa para poder poner freeze en eventos xD
avatar
Wecoc
Administrador
Administrador



Créditos 12211

Gracias : 632

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por youkai el 2013-08-14, 04:46

Bueno eso de acoplar los when y usar un case tambien para x no me nacio hacerlo XDDD Estaba mas concentrado en aprenderme el numero de cada direccion y hacer las cosas bien...asi que una vez que termine dije: "Asi funciona, asi se va...ahora para el center" XDDDDDD
=====
Pues wec...mira a ver que violacion de los derechos humanos le has hecho a mi script XDDDDD Lo he testeado en un mapa con unos cuantos eventos(como 10) puestos a lo random y he "hablado" con todos los eventos en todas las direcciones sin problema alguno...
==== Mire el script de wec y...====
Con que:
Código:
    x_correct = case @direction
    when 6, 3, 7 then @x + 1
    when 4, 1, 5 then @x - 1
eh??
Me sorprende que despues siga sirviendo el juego para algo XDDDDDDDDDDD Buena pifia...y me querian hechar las culpas a mi...yo dije que lo habia testeado poco pero que lo habia probado XDDDD
He aqui el arrglo
Código:
    #==============================================================================
    # Hextiles
    #==============================================================================
    # Script creado por usuarios de Mundo Maker:
    # - Wecoc
    # - Pokepik
    # - Orochii
    # - Eron
    # - Youkai
    #==============================================================================
    # 3. Character Features
    #==============================================================================

    class Game_Character
     
      attr_accessor  :direction
      attr_accessor  :pattern
     
      def passable?(x, y, d) # No está hecho
        case d
        when 1 # Lower Left
          new_x = x - 1
          wecoc_y = @x%2==1 ? 1 : 0
          new_y = y + wecoc_y
        when 2 # Down
          new_x = x
          new_y = y + 1
        when 3 # Lower Right
          new_x = x + 1
          wecoc_y = @x%2==1 ? 1 : 0
          new_y = y + wecoc_y
        when 5 # Upper Left
          new_x = x-1
          wecoc_y = @x%2==0 ? 1 : 0
          new_y = y - wecoc_y
        when 7 # Upper Right
          new_x = x+1
          wecoc_y = @x%2==0 ? 1 : 0
          new_y = y - wecoc_y
        when 8 # Up
          new_x = x
          new_y = y - 1
        else
          new_x = x
          new_y = y
        end
        return false unless $game_map.valid?(new_x, new_y)
        if self.is_a?(Game_Player)
          return true if $DEBUG and Input.press?(Input::CTRL)
        end
        return true if @through
        if $game_map.data[x,y,0] == 0 and
          $game_map.data[x,y,1] == 0 and
          $game_map.data[x,y,2] == 0
          return false
        end
        if $game_map.data[new_x,new_y,0] == 0 and
          $game_map.data[new_x,new_y,1] == 0 and
          $game_map.data[new_x,new_y,2] == 0
          return false
        end
        return false unless $game_map.passable?(x, y, 0)
        return false unless $game_map.passable?(new_x, new_y, 0)

        # Falta la pasibilidad por direcciones (la más complicada)
   
      for event in $game_map.events.values
          if event.x == new_x and event.y == new_y
            unless event.through
              return false if self != $game_player
              return false if event.character_name != ""
            end
          end
        end
        if $game_player.x == new_x and $game_player.y == new_y
          unless $game_player.through
            return false if @character_name != ""
          end
        end
        return true
      end

      def moving?
        wecoc_y = @x%2==0 ? 16 : 0
        return (@real_x != @x * 24 * 4 or @real_y != (@y * 32 - wecoc_y) * 4)
      end

      def moveto(x, y)
        @x = x % $game_map.width
        @y = y % $game_map.height
        wecoc_y = @x%2==0 ? 16 : 0
        @real_x = @x * 24 * 4
        @real_y = (@y * 32 - wecoc_y) * 4
        @prelock_direction = 0
      end

      def jump(x_plus, y_plus)
        tile_x = @x
        tile_y = @y
        new_tile_x = @x + x_plus
        new_tile_y = @y + y_plus
        straighten
        distance = 0
        if passable?(new_tile_x, new_tile_y, 0)
          turn_toward_tile_6(new_tile_x, new_tile_y)
          distance = Math.sqrt(x_plus * x_plus + y_plus * y_plus).round
          @x = new_tile_x
          @y = new_tile_y
        end
        @jump_peak = 10 + distance - @move_speed
        @jump_count = @jump_peak * 2
        @stop_count = 0
      end

      def tile_neighbors(x, y, d=0)
        if x%2==1
          array = [[x-1,y+1],[x,y-1],[x+1,y+1],[x,y],[x-1,y],[x,y],[x+1,y],[x,y+1]]
        else
          array = [[x-1,y],[x,y-1],[x+1,y],[x,y],[x-1,y-1],[x,y],[x+1,y-1],[x,y+1]]
        end
        return d==0 ? array : array[d-1]
      end
   
    def ring_tiles(distance)
        get_ring_tiles(self.x, self.y, distance)
      end

      def get_ring_tiles(x, y, distance)
        case distance
        when 0 then return [[x, y]]
        when 1 then return tile_neighbors(x,y)
        when 2
          neighbors = tile_neighbors(x,y)
          new_neighbors = []
          for i in 0...neighbors.size
            for j in 1..8
              new_neighbors.push(tile_neighbors(neighbors[i][0], neighbors[i][1], j))
            end
          end
          new_neighbors.uniq!
          for i in 0...neighbors.size
            new_neighbors.delete(neighbors[i])
          end
          new_neighbors.delete([x,y])
          return new_neighbors
        else
          neighbors = get_ring_tiles(x, y, distance-1)
          all_neighbors = []
          for i in 0...distance-1
            all_neighbors.push(get_ring_tiles(x, y, i))
          end
          new_neighbors = []
          for i in 0...neighbors.size
            for j in 1..8
              new_neighbors.push(tile_neighbors(neighbors[i][0], neighbors[i][1], j))
            end
          end
          new_neighbors.uniq!
          for i in 0...neighbors.size
            new_neighbors.delete(neighbors[i])
          end
          for i in 0...all_neighbors.size
            for j in 0...all_neighbors[i].size
              new_neighbors.delete(all_neighbors[i][j])
            end
          end
          new_neighbors.delete([x,y])
          return new_neighbors
        end
      end

      def screen_x
        return (@real_x - $game_map.display_x + 3) / 4 + 32 / 4
      end

      def screen_y
        y = (@real_y - $game_map.display_y + 3) / 4 + 32
        if @jump_count >= @jump_peak
          n = @jump_count - @jump_peak
        else
          n = @jump_peak - @jump_count
        end
        return y - (@jump_peak * @jump_peak - n * n) / 2
      end

      def screen_z(height = 0)
        return 999 if @always_on_top
        z = (@real_y - $game_map.display_y + 3) / 4 + 32
        if @tile_id > 0
          return z + $game_map.priorities[@tile_id] * 32
        else
          return z + ((height > 32) ? 32 - 1 : 0)
        end
      end
     
      def bush_depth(depth=12)
        return 0 if @tile_id > 0 or @always_on_top
        if @jump_count == 0 and $game_map.bush?(@x, @y)
          return depth
        else
          return 0
        end
      end

      def update_jump
        @jump_count -= 1
        wecoc_y = @x%2==0 ? 16 : 0
        @real_x = (@real_x * @jump_count + @x * 24 * 4) / (@jump_count+1)
        @real_y = (@real_y * @jump_count + (@y * 32 - wecoc_y) * 4) / (@jump_count+1)
      end

      def update_move
        @false_move_speed = @move_speed if @false_move_speed == nil
        distance = 2 ** @false_move_speed
        wecoc_y = @x%2==0 ? 16 : 0
        if (@y * 32 - wecoc_y) * 4 > @real_y # Move down
          @real_y = [@real_y + distance / 1.5, (@y * 32 - wecoc_y) * 4].min
        end
        if @x * 24 * 4 < @real_x # Move left
          @real_x = [@real_x - distance / 1, @x * 24 * 4].max
        end
        if @x * 24 * 4 > @real_x # Move right
          @real_x = [@real_x + distance / 1, @x * 24 * 4].min
        end
        if (@y * 32 - wecoc_y) * 4 < @real_y # Move up
          @real_y = [@real_y - distance / 1.5, (@y * 32 - wecoc_y) * 4].max
        end
        if @walk_anime
          @anime_count += 1.5
        elsif @step_anime
          @anime_count += 1
        end
      end

      def move_type_random(app=50)
        app = [[100, app].min, 1].max
        case rand(100/app)
          when 0 then move_random # Random
        else
          case rand(2)
            when 0 then move_forward # Forward
            when 1 then @stop_count = 0 # Wait
          end
        end
      end

      def move_up(turn_enabled = true)
        @false_move_speed = @move_speed
        turn_up if turn_enabled
        if passable?(@x, @y, 8)
          turn_up
          @y -= 1
          increase_steps
        else
          check_event_trigger_touch(@x, @y-1)
        end
      end

      def move_down(turn_enabled = true)
        @false_move_speed = @move_speed
        turn_down if turn_enabled
        if passable?(@x, @y, 2)
          turn_down
          @y += 1
          increase_steps
        else
          check_event_trigger_touch(@x, @y+1)
        end
      end

      def move_lower_left(turn_enabled = true)
        @false_move_speed = @move_speed / 1.33
        turn_lower_left if turn_enabled
        @direction = 1 unless @direction_fix
        if passable?(@x, @y, 1)
          @y += 1 if @x%2==1
          @x -= 1
          increase_steps
        else
          crd = tile_neighbors(@x, @y, 1)
          check_event_trigger_touch(crd[0], crd[1])
        end
      end

      def move_lower_right(turn_enabled = true)
        @false_move_speed = @move_speed / 1.33
        turn_lower_right if turn_enabled
        @direction = 3 unless @direction_fix
        if passable?(@x, @y, 3)
          @y += 1 if @x%2==1
          @x += 1
          increase_steps
        else
          crd = tile_neighbors(@x, @y, 3)
          check_event_trigger_touch(crd[0], crd[1])
        end
      end

      def move_upper_left(turn_enabled = true)
        @false_move_speed = @move_speed / 1.33
        turn_upper_left if turn_enabled
        @direction = 5 unless @direction_fix
        if passable?(@x, @y, 5)
          @y -= 1 if @x%2==0
          @x -= 1
          increase_steps
        else
          crd = tile_neighbors(@x, @y, 5)
          check_event_trigger_touch(crd[0], crd[1])
        end
      end

      def move_upper_right(turn_enabled = true)
        @false_move_speed = @move_speed / 1.33
        turn_upper_right if turn_enabled
        @direction = 7 unless @direction_fix
        if passable?(@x, @y, 7)
          @y -= 1 if @x%2==0
          @x += 1
          increase_steps
        else
          crd = tile_neighbors(@x, @y, 7)
          check_event_trigger_touch(crd[0], crd[1])
        end
      end

      def move_random
        move_random_6
      end

      def move_random_4
        case rand(4)
          when 0 then move_down(false)
          when 1 then move_left(false)
          when 2 then move_right(false)
          when 3 then move_up(false)
        end
      end

      def move_random_6
        case rand(6)
          when 0 then move_down(false)
          when 1 then move_upper_left(false)
          when 2 then move_upper_right(false)
          when 3 then move_lower_left(false)
          when 4 then move_lower_right(false)
          when 5 then move_up(false)
        end
      end

      def move_random_4_to_6
        case rand(4)
          when 0 then move_down(false)
          when 1
            case rand(2)
              when 0 then move_upper_left(false)
              when 1 then move_upper_right(false)
            end
          when 2
            case rand(2)
              when 0 then move_lower_left(false)
              when 1 then move_lower_right(false)
            end
          when 3 then move_up(false)
        end
      end

      def move_toward_player
        move_toward_tile_6($game_player.x, $game_player.y)
      end

      def move_toward_event(event_id)
        event = $game_map.events[event_id]
        move_toward_tile_6(event.x, event.y)
      end

      def move_toward_tile_4(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0
        abs_sx = sx.abs
        abs_sy = sy.abs
        if abs_sx == abs_sy
          rand(2) == 0 ? abs_sx += 1 : abs_sy += 1
        end
        if abs_sx > abs_sy
          sx > 0 ? move_left : move_right
          if not moving? and sy != 0
            sy > 0 ? move_up : move_down
          end
        else
          sy > 0 ? move_up : move_down
          if not moving? and sx != 0
            sx > 0 ? move_left : move_right
          end
        end
      end

      def move_toward_tile_6(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0
      if sy <= 0
          if sy.abs > (sx.abs * 1.5)
            move_down
          else
            sx < 0 ? move_lower_right : move_lower_left
          end
        else
          if sy.abs > (sx.abs * 1.5)
            move_up
          else
            sx < 0 ? move_upper_right : move_upper_left
          end
        end
      end
   
    def move_away_from_player
        move_away_from_tile_6($game_player.x, $game_player.y)
      end

      def move_away_from_event(event_id)
        event = $game_map.events[event_id]
        move_away_from_tile_6(event.x, event.y)
      end

      def move_away_from_tile_4(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0
        abs_sx = sx.abs
        abs_sy = sy.abs
        if abs_sx == abs_sy
          rand(2) == 0 ? abs_sx += 1 : abs_sy += 1
        end
        if abs_sx > abs_sy
          sx > 0 ? move_right : move_left
          if not moving? and sy != 0
            sy > 0 ? move_down : move_up
          end
        else
          sy > 0 ? move_down : move_up
          if not moving? and sx != 0
            sx > 0 ? move_right : move_left
          end
        end
      end

      def move_away_from_tile_6(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0
      if sy < 0
          if sy.abs > (sx.abs * 1.5)
            move_up
          else
            sx < 0 ? move_upper_left : move_upper_right
          end
        else
          if sy.abs > (sx.abs * 1.5)
            turn_down
          else
            sx < 0 ? move_lower_left : move_lower_right
          end
        end
      end

      def move_forward
        case @direction
          when 1 then move_lower_left(false)
          when 2 then move_down(false)
          when 3 then move_lower_right(false)
          when 4 then move_left(false)
          when 5 then move_upper_left(false)
          when 6 then move_right(false)
          when 7 then move_upper_right(false)
          when 8 then move_up(false)
        end
      end

      def move_backward
        last_direction_fix = @direction_fix
        @direction_fix = true
        case @direction
          when 1 then move_upper_right(false)
          when 2 then move_up(false)
          when 3 then move_upper_left(false)
          when 4 then move_right(false)
          when 5 then move_lower_right(false)
          when 6 then move_left(false)
          when 7 then move_lower_left(false)
          when 8 then move_down(false)
        end
        @direction_fix = last_direction_fix
      end

      def turn_clock(n=1)
        return if n <= 0 or n > 5
        dir_array = [2, 1, 5, 8, 7, 3]
        return if not dir_array.include?(@direction)
        n.times do
          i = dir_array.index(@direction)
          @direction = dir_array[i+1] != nil ? dir_array[i+1] : dir_array[0]
        end
      end

      def turn_anticlock(n=1)
        return if n <= 0 or n > 5
        dir_array = [3, 7, 8, 5, 1, 2]
        return if not dir_array.include?(@direction)
        n.times do
          i = dir_array.index(@direction)
          @direction = dir_array[i+1] != nil ? dir_array[i+1] : dir_array[0]
        end
      end

      def turn_lower_left
        unless @direction_fix
          @direction = 1
          @stop_count = 0
        end
      end

      def turn_lower_right
        unless @direction_fix
          @direction = 3
          @stop_count = 0
        end
      end

      def turn_upper_left
        unless @direction_fix
          @direction = 5
          @stop_count = 0
        end
      end

      def turn_upper_right
        unless @direction_fix
          @direction = 7
          @stop_count = 0
        end
      end

      def turn_right_90
        turn_clock
      end

      def turn_left_90
        turn_anticlock
      end

      def turn_180
        case @direction
          when 1 then turn_lower_left
          when 2 then turn_down
          when 3 then turn_lower_right
          when 4 then turn_left
          when 5 then turn_upper_left
          when 6 then turn_right
          when 7 then turn_upper_right
          when 8 then turn_up
        end
      end

      def turn_right_or_left_90
        rand(2) == 0 ? turn_clock : turn_anticlock
      end

      def turn_random
        turn_random_6
      end

      def turn_random_4
        case rand(4)
          when 0 then turn_down
          when 1 then turn_left
          when 2 then turn_right
          when 3 then turn_up
        end
      end

      def turn_random_6
        case rand(6)
          when 0 then turn_down
          when 1 then turn_upper_left
          when 2 then turn_upper_right
          when 3 then turn_lower_left
          when 4 then turn_lower_right
          when 5 then turn_up
        end
      end

      def turn_random_4_to_6
        case rand(4)
          when 0 then turn_down
          when 1
            case rand(2)
              when 0 then turn_upper_left(false)
              when 1 then turn_upper_right(false)
            end
          when 2
            case rand(2)
              when 0 then turn_lower_left(false)
              when 1 then turn_lower_right(false)
            end
          when 3 then turn_up(false)
        end
      end

      def turn_toward_player
        turn_toward_tile_6($game_player.x, $game_player.y)
      end

      def turn_toward_event(event_id)
        event = $game_map.events[event_id]
        turn_toward_tile_6(event.x, event.y)
      end

      def turn_toward_tile_4(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0
        if sx.abs > sy.abs
          sx > 0 ? turn_left : turn_right
        else
          sy > 0 ? turn_up : turn_down
        end
      end

      def turn_toward_tile_6(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0
      if sy <= 0
          if sy.abs > (sx.abs * 1.5)
            turn_down
          else
            sx < 0 ? turn_lower_right : turn_lower_left
          end
        else
          if sy.abs > (sx.abs * 1.5)
            turn_up
          else
            sx < 0 ? turn_upper_right : turn_upper_left
          end
        end
      end

      def turn_away_from_player
        turn_away_from_tile_6($game_player.x, $game_player.y)
      end

      def turn_away_from_event(event_id)
        event = $game_map.events[event_id]
        turn_away_from_tile_6(event.x, event.y)
      end

      def turn_away_from_tile_4(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0
        if sx.abs > sy.abs
          sx > 0 ? turn_right : turn_left
        else
          sy > 0 ? turn_down : turn_up
        end
      end

      def turn_away_from_tile_6(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0
      if sy < 0
          if sy.abs > (sx.abs * 1.5)
            turn_up
          else
            sx < 0 ? turn_upper_left : turn_upper_right
          end
        else
          if sy.abs > (sx.abs * 1.5)
            turn_down
          else
            sx < 0 ? turn_lower_left : turn_lower_right
          end
        end
      end
    end

    class Game_Player < Game_Character

      CENTER_X = (640 / 2 - 32 / 2) * 4  # Center screen x-coordinate * 4
      CENTER_Y = (480 / 2 - 32 / 2) * 4  # Center screen y-coordinate * 4

      def passable?(x, y, d)
        super
      end

      def check_event_trigger_there(triggers)
        result = false
        return result if $game_system.map_interpreter.running?
        y_correct = case @direction
        when 2 then 1
        when 8 then -1
        when 1, 3 then @x%2==1 ? 1 : 0
        when 5, 7 then @x%2==1 ? 0 : -1
        else; 0
        end
        x_correct = case @direction
        when 6, 3, 7 then 1
        when 4, 1, 5 then -1
        else; 0
        end
        new_x = @x + x_correct
        new_y = @y + y_correct
        for event in $game_map.events.values
          if event.x == new_x and event.y == new_y and
            triggers.include?(event.trigger)
            if not event.jumping? and not event.over_trigger?
              event.start
              result = true
            end
          end
        end
        if result == false
          if $game_map.counter?(new_x, new_y)
            for event in $game_map.events.values
              if event.x == new_x and event.y == new_y and
                triggers.include?(event.trigger)
                if not event.jumping? and not event.over_trigger?
                  event.start
                  result = true
                end
              end
            end
          end
        end
        return result
      end
    end

    class Sprite_Character < RPG::Sprite
      def update
        super
        if @tile_id != @character.tile_id or
          @character_name != @character.character_name or
          @character_hue != @character.character_hue
          @tile_id = @character.tile_id
          @character_name = @character.character_name
          @character_hue = @character.character_hue
          if @tile_id >= 384
            self.bitmap = RPG::Cache.tile($game_map.tileset_name,
              @tile_id, @character.character_hue)
            self.src_rect.set(0, 0, 32, 32)
            self.ox = 16
            self.oy = 32
          else
            self.bitmap = RPG::Cache.character(@character.character_name,
              @character.character_hue)
            @cw = bitmap.width / 4
            @ch = bitmap.height / 6
            self.ox = @cw / 2
            self.oy = @ch
          end
        end
        self.visible = (not @character.transparent)
        if @tile_id == 0
          sx = @character.pattern * @cw
          dir_array = [1, 0, 2, 0, 3, 0, 4, 5]
          sy = dir_array[@character.direction-1] * @ch
          self.src_rect.set(sx, sy, @cw, @ch)
        end
        self.x = @character.screen_x
        self.y = @character.screen_y
        self.z = @character.screen_z(@ch)
        self.opacity = @character.opacity
        self.blend_type = @character.blend_type
        self.bush_depth = @character.bush_depth(16)
        if @character.animation_id != 0
          animation = $data_animations[@character.animation_id]
          animation(animation, true)
          @character.animation_id = 0
        end
      end
    end
NOTA: Arregle el de tu ultimo post...asi que todo esta actualizado...
Por cierto...que hiciste ahi?? No tengo muchas ganas de jugar a "encuentra las 5 diferencias" XDDDD

Por otra parte queria decir algo...no se si es que queda pendiente o solo me pasa a mi....mirenlo por ustedes mismos:

Es asi como se me ve un mapa de 20x15 con todo el piso de yerba...a ustedes les pasa igual? Por el arbol y los semihumanos(XD) no se preocupen mucho XDD
avatar
youkai
Soñador
Soñador

0/3

Créditos 280

Gracias : 10

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por Wecoc el 2013-08-14, 14:51

Manda juevos, si lo puse así tan raro es porque tú hiciste lo mismo con la y xDD Y vale, con el tuyo sí lo detecta desde los lados, pero la dirección no es la correcta y por eso lo toqué (claro que luego la cagué poniendo esos @x de más, pero... minúcias... xD) Si tú hablas con el evento desde arriba-derecha o desde arriba-izquierda, el evento en vez de mirarte mira hacia abajo.

Y lo que no entiendo es por qué siempre tabulas tanto tus scripts, ¿es que usas gémini o así? xD

Lo otro que dices, pues sí, es normal; dado que ya no se dibujan de 32 en 32 sinó de 24 en 24, claro entonces si se quiere conservar la resolución de 640 x 480 los mapas pequeños principales serían de 27x16 (creo) en vez de 20x15 dados esos valores, pero claro el módule HEXA está por algo.

He decidido por fin implementar el module al tercer script, a todo excepto la parte de Game_Player. Por lo demás está todo igual.

Código:
#==============================================================================
# Hextiles
#==============================================================================
# Script creado por usuarios de Mundo Maker:
# - Wecoc
# - Pokepik
# - Orochii
# - Eron
# - Youkai
#==============================================================================
# 3. Character Features
#==============================================================================

class Game_Character
 
 attr_accessor  :direction
  attr_accessor  :pattern
 
 def passable?(x, y, d) # No está hecho
    case d
    when 1 # Lower Left
      new_x = x - 1
      wecoc_y = @x%2==1 ? 1 : 0
      new_y = y + wecoc_y
    when 2 # Down
      new_x = x
      new_y = y + 1
    when 3 # Lower Right
      new_x = x + 1
      wecoc_y = @x%2==1 ? 1 : 0
      new_y = y + wecoc_y
    when 5 # Upper Left
      new_x = x-1
      wecoc_y = @x%2==0 ? 1 : 0
      new_y = y - wecoc_y
    when 7 # Upper Right
      new_x = x+1
      wecoc_y = @x%2==0 ? 1 : 0
      new_y = y - wecoc_y
    when 8 # Up
      new_x = x
      new_y = y - 1
    else
      new_x = x
      new_y = y
    end
    return false unless $game_map.valid?(new_x, new_y)
    if self.is_a?(Game_Player)
      return true if $DEBUG and Input.press?(Input::CTRL)
    end
    return true if @through
    if $game_map.data[x,y,0] == 0 and
      $game_map.data[x,y,1] == 0 and
      $game_map.data[x,y,2] == 0
      return false
    end
    if $game_map.data[new_x,new_y,0] == 0 and
      $game_map.data[new_x,new_y,1] == 0 and
      $game_map.data[new_x,new_y,2] == 0
      return false
    end
    return false unless $game_map.passable?(x, y, 0)
    return false unless $game_map.passable?(new_x, new_y, 0)

    # Falta la pasibilidad por direcciones (la más complicada)

    for event in $game_map.events.values
      if event.x == new_x and event.y == new_y
        unless event.through
          return false if self != $game_player
          return false if event.character_name != ""
        end
      end
    end
    if $game_player.x == new_x and $game_player.y == new_y
      unless $game_player.through
        return false if @character_name != ""
      end
    end
    return true
  end

  def moving?
    wecoc_y = @x%2==0 ? (HEXA::HEIGHT / 2) : 0
    return (@real_x != @x * (HEXA::WIDTH - HEXA::SUPP) * 4 or
      @real_y != (@y * HEXA::HEIGHT - wecoc_y) * 4)
  end

  def moveto(x, y)
    @x = x % $game_map.width
    @y = y % $game_map.height
    wecoc_y = @x%2==0 ? (HEXA::HEIGHT / 2) : 0
    @real_x = @x * (HEXA::WIDTH - HEXA::SUPP) * 4
    @real_y = (@y * HEXA::HEIGHT - wecoc_y) * 4
    @prelock_direction = 0
  end

  def jump(x_plus, y_plus)
    tile_x = @x
    tile_y = @y
    new_tile_x = @x + x_plus
    new_tile_y = @y + y_plus
    straighten
    distance = 0
    if passable?(new_tile_x, new_tile_y, 0)
      turn_toward_tile_6(new_tile_x, new_tile_y)
      distance = Math.sqrt(x_plus * x_plus + y_plus * y_plus).round
      @x = new_tile_x
      @y = new_tile_y
    end
    @jump_peak = 10 + distance - @move_speed
    @jump_count = @jump_peak * 2
    @stop_count = 0
  end

  def tile_neighbors(x, y, d=0)
    if x%2==1
      array = [[x-1,y+1],[x,y-1],[x+1,y+1],[x,y],[x-1,y],[x,y],[x+1,y],[x,y+1]]
    else
      array = [[x-1,y],[x,y-1],[x+1,y],[x,y],[x-1,y-1],[x,y],[x+1,y-1],[x,y+1]]
    end
    return d==0 ? array : array[d-1]
  end

  def ring_tiles(distance)
    get_ring_tiles(self.x, self.y, distance)
  end

  def get_ring_tiles(x, y, distance)
    case distance
    when 0 then return [[x, y]]
    when 1 then return tile_neighbors(x,y)
    when 2
      neighbors = tile_neighbors(x,y)
      new_neighbors = []
      for i in 0...neighbors.size
        for j in 1..8
          new_neighbors.push(tile_neighbors(neighbors[i][0], neighbors[i][1], j))
        end
      end
      new_neighbors.uniq!
      for i in 0...neighbors.size
        new_neighbors.delete(neighbors[i])
      end
      new_neighbors.delete([x,y])
      return new_neighbors
    else
      neighbors = get_ring_tiles(x, y, distance-1)
      all_neighbors = []
      for i in 0...distance-1
        all_neighbors.push(get_ring_tiles(x, y, i))
      end
      new_neighbors = []
      for i in 0...neighbors.size
        for j in 1..8
          new_neighbors.push(tile_neighbors(neighbors[i][0], neighbors[i][1], j))
        end
      end
      new_neighbors.uniq!
      for i in 0...neighbors.size
        new_neighbors.delete(neighbors[i])
      end
      for i in 0...all_neighbors.size
        for j in 0...all_neighbors[i].size
          new_neighbors.delete(all_neighbors[i][j])
        end
      end
      new_neighbors.delete([x,y])
      return new_neighbors
    end
  end

  def screen_x
    return (@real_x - $game_map.display_x + 3) / 4 + HEXA::WIDTH / 4
  end

  def screen_y
    y = (@real_y - $game_map.display_y + 3) / 4 + HEXA::HEIGHT
    if @jump_count >= @jump_peak
      n = @jump_count - @jump_peak
    else
      n = @jump_peak - @jump_count
    end
    return y - (@jump_peak * @jump_peak - n * n) / 2
  end

  def screen_z(height = 0)
    return 999 if @always_on_top
    z = (@real_y - $game_map.display_y + 3) / 4 + HEXA::HEIGHT
    if @tile_id > 0
      return z + $game_map.priorities[@tile_id] * HEXA::HEIGHT
    else
      return z + ((height > HEXA::HEIGHT) ? HEXA::HEIGHT - 1 : 0)
    end
  end
 
 def bush_depth(depth=12)
    return 0 if @tile_id > 0 or @always_on_top
    if @jump_count == 0 and $game_map.bush?(@x, @y)
      return depth
    else
      return 0
    end
  end

  def update_jump
    @jump_count -= 1
    wecoc_y = @x%2==0 ? (HEXA::HEIGHT / 2) : 0
    @real_x = (@real_x * @jump_count +
      @x * (HEXA::WIDTH - HEXA::SUPP) * 4) / (@jump_count+1)
    @real_y = (@real_y * @jump_count +
      (@y * HEXA::HEIGHT - wecoc_y) * 4) / (@jump_count+1)
  end

  def update_move
    @false_move_speed = @move_speed if @false_move_speed == nil
    distance = 2 ** @false_move_speed
    wecoc_y = @x%2==0 ? (HEXA::HEIGHT / 2) : 0
    if (@y * 32 - wecoc_y) * 4 > @real_y # Move down
      @real_y = [@real_y + distance / 1.5, (@y * HEXA::HEIGHT - wecoc_y) * 4].min
    end
    if @x * 24 * 4 < @real_x # Move left
      @real_x = [@real_x - distance, @x * (HEXA::WIDTH - HEXA::SUPP) * 4].max
    end
    if @x * 24 * 4 > @real_x # Move right
      @real_x = [@real_x + distance, @x * (HEXA::WIDTH - HEXA::SUPP) * 4].min
    end
    if (@y * 32 - wecoc_y) * 4 < @real_y # Move up
      @real_y = [@real_y - distance / 1.5, (@y * HEXA::HEIGHT - wecoc_y) * 4].max
    end
    if @walk_anime
      @anime_count += 1.5
    elsif @step_anime
      @anime_count += 1
    end
  end

  def move_type_random(app=50)
    app = [[100, app].min, 1].max
    case rand(100/app)
      when 0 then move_random # Random
    else
      case rand(2)
        when 0 then move_forward # Forward
        when 1 then @stop_count = 0 # Wait
      end
    end
  end

  def move_up(turn_enabled = true)
    @false_move_speed = @move_speed
    turn_up if turn_enabled
    if passable?(@x, @y, 8)
      turn_up
      @y -= 1
      increase_steps
    else
      check_event_trigger_touch(@x, @y-1)
    end
  end

  def move_down(turn_enabled = true)
    @false_move_speed = @move_speed
    turn_down if turn_enabled
    if passable?(@x, @y, 2)
      turn_down
      @y += 1
      increase_steps
    else
      check_event_trigger_touch(@x, @y+1)
    end
  end

  def move_lower_left(turn_enabled = true)
    quo = HEXA::HEIGHT.quo(HEXA::WIDTH - HEXA::SUPP)
    @false_move_speed = @move_speed / quo
    turn_lower_left if turn_enabled
    @direction = 1 unless @direction_fix
    if passable?(@x, @y, 1)
      @y += 1 if @x%2==1
      @x -= 1
      increase_steps
    else
      crd = tile_neighbors(@x, @y, 1)
      check_event_trigger_touch(crd[0], crd[1])
    end
  end

  def move_lower_right(turn_enabled = true)
    quo = HEXA::HEIGHT.quo(HEXA::WIDTH - HEXA::SUPP)
    @false_move_speed = @move_speed / quo
    turn_lower_right if turn_enabled
    @direction = 3 unless @direction_fix
    if passable?(@x, @y, 3)
      @y += 1 if @x%2==1
      @x += 1
      increase_steps
    else
      crd = tile_neighbors(@x, @y, 3)
      check_event_trigger_touch(crd[0], crd[1])
    end
  end

  def move_upper_left(turn_enabled = true)
    quo = HEXA::HEIGHT.quo(HEXA::WIDTH - HEXA::SUPP)
    @false_move_speed = @move_speed / quo
    turn_upper_left if turn_enabled
    @direction = 5 unless @direction_fix
    if passable?(@x, @y, 5)
      @y -= 1 if @x%2==0
      @x -= 1
      increase_steps
    else
      crd = tile_neighbors(@x, @y, 5)
      check_event_trigger_touch(crd[0], crd[1])
    end
  end

  def move_upper_right(turn_enabled = true)
    quo = HEXA::HEIGHT.quo(HEXA::WIDTH - HEXA::SUPP)
    @false_move_speed = @move_speed / quo
    turn_upper_right if turn_enabled
    @direction = 7 unless @direction_fix
    if passable?(@x, @y, 7)
      @y -= 1 if @x%2==0
      @x += 1
      increase_steps
    else
      crd = tile_neighbors(@x, @y, 7)
      check_event_trigger_touch(crd[0], crd[1])
    end
  end

  def move_random
    move_random_6
  end

  def move_random_4
    case rand(4)
      when 0 then move_down(false)
      when 1 then move_left(false)
      when 2 then move_right(false)
      when 3 then move_up(false)
    end
  end

  def move_random_6
    case rand(6)
      when 0 then move_down(false)
      when 1 then move_upper_left(false)
      when 2 then move_upper_right(false)
      when 3 then move_lower_left(false)
      when 4 then move_lower_right(false)
      when 5 then move_up(false)
    end
  end

  def move_random_4_to_6
    case rand(4)
      when 0 then move_down(false)
      when 1
        case rand(2)
          when 0 then move_upper_left(false)
          when 1 then move_upper_right(false)
        end
      when 2
        case rand(2)
          when 0 then move_lower_left(false)
          when 1 then move_lower_right(false)
        end
      when 3 then move_up(false)
    end
  end

  def move_toward_player
    move_toward_tile_6($game_player.x, $game_player.y)
  end

  def move_toward_event(event_id)
    event = $game_map.events[event_id]
    move_toward_tile_6(event.x, event.y)
  end

  def move_toward_tile_4(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
    abs_sx = sx.abs
    abs_sy = sy.abs
    if abs_sx == abs_sy
      rand(2) == 0 ? abs_sx += 1 : abs_sy += 1
    end
    if abs_sx > abs_sy
      sx > 0 ? move_left : move_right
      if not moving? and sy != 0
        sy > 0 ? move_up : move_down
      end
    else
      sy > 0 ? move_up : move_down
      if not moving? and sx != 0
        sx > 0 ? move_left : move_right
      end
    end
  end

  def move_toward_tile_6(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
  if sy <= 0
      if sy.abs > (sx.abs * 1.5)
        move_down
      else
        sx < 0 ? move_lower_right : move_lower_left
      end
    else
      if sy.abs > (sx.abs * 1.5)
        move_up
      else
        sx < 0 ? move_upper_right : move_upper_left
      end
    end
  end

def move_away_from_player
    move_away_from_tile_6($game_player.x, $game_player.y)
  end

  def move_away_from_event(event_id)
    event = $game_map.events[event_id]
    move_away_from_tile_6(event.x, event.y)
  end

  def move_away_from_tile_4(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
    abs_sx = sx.abs
    abs_sy = sy.abs
    if abs_sx == abs_sy
      rand(2) == 0 ? abs_sx += 1 : abs_sy += 1
    end
    if abs_sx > abs_sy
      sx > 0 ? move_right : move_left
      if not moving? and sy != 0
        sy > 0 ? move_down : move_up
      end
    else
      sy > 0 ? move_down : move_up
      if not moving? and sx != 0
        sx > 0 ? move_right : move_left
      end
    end
  end

  def move_away_from_tile_6(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
  if sy < 0
      if sy.abs > (sx.abs * 1.5)
        move_up
      else
        sx < 0 ? move_upper_left : move_upper_right
      end
    else
      if sy.abs > (sx.abs * 1.5)
        turn_down
      else
        sx < 0 ? move_lower_left : move_lower_right
      end
    end
  end

  def move_forward
    case @direction
      when 1 then move_lower_left(false)
      when 2 then move_down(false)
      when 3 then move_lower_right(false)
      when 4 then move_left(false)
      when 5 then move_upper_left(false)
      when 6 then move_right(false)
      when 7 then move_upper_right(false)
      when 8 then move_up(false)
    end
  end

  def move_backward
    last_direction_fix = @direction_fix
    @direction_fix = true
    case @direction
      when 1 then move_upper_right(false)
      when 2 then move_up(false)
      when 3 then move_upper_left(false)
      when 4 then move_right(false)
      when 5 then move_lower_right(false)
      when 6 then move_left(false)
      when 7 then move_lower_left(false)
      when 8 then move_down(false)
    end
    @direction_fix = last_direction_fix
  end

  def turn_clock(n=1)
    return if n <= 0 or n > 5
    dir_array = [2, 1, 5, 8, 7, 3]
    return if not dir_array.include?(@direction)
    n.times do
      i = dir_array.index(@direction)
      @direction = dir_array[i+1] != nil ? dir_array[i+1] : dir_array[0]
    end
  end

  def turn_anticlock(n=1)
    return if n <= 0 or n > 5
    dir_array = [3, 7, 8, 5, 1, 2]
    return if not dir_array.include?(@direction)
    n.times do
      i = dir_array.index(@direction)
      @direction = dir_array[i+1] != nil ? dir_array[i+1] : dir_array[0]
    end
  end

  def turn_lower_left
    unless @direction_fix
      @direction = 1
      @stop_count = 0
    end
  end

  def turn_lower_right
    unless @direction_fix
      @direction = 3
      @stop_count = 0
    end
  end

  def turn_upper_left
    unless @direction_fix
      @direction = 5
      @stop_count = 0
    end
  end

  def turn_upper_right
    unless @direction_fix
      @direction = 7
      @stop_count = 0
    end
  end

  def turn_right_90
    turn_clock
  end

  def turn_left_90
    turn_anticlock
  end

  def turn_180
    case @direction
      when 1 then turn_lower_left
      when 2 then turn_down
      when 3 then turn_lower_right
      when 4 then turn_left
      when 5 then turn_upper_left
      when 6 then turn_right
      when 7 then turn_upper_right
      when 8 then turn_up
    end
  end

  def turn_right_or_left_90
    rand(2) == 0 ? turn_clock : turn_anticlock
  end

  def turn_random
    turn_random_6
  end

  def turn_random_4
    case rand(4)
      when 0 then turn_down
      when 1 then turn_left
      when 2 then turn_right
      when 3 then turn_up
    end
  end

  def turn_random_6
    case rand(6)
      when 0 then turn_down
      when 1 then turn_upper_left
      when 2 then turn_upper_right
      when 3 then turn_lower_left
      when 4 then turn_lower_right
      when 5 then turn_up
    end
  end

  def turn_random_4_to_6
    case rand(4)
      when 0 then turn_down
      when 1
        case rand(2)
          when 0 then turn_upper_left(false)
          when 1 then turn_upper_right(false)
        end
      when 2
        case rand(2)
          when 0 then turn_lower_left(false)
          when 1 then turn_lower_right(false)
        end
      when 3 then turn_up(false)
    end
  end

  def turn_toward_player
    turn_toward_tile_6($game_player.x, $game_player.y)
  end

  def turn_toward_event(event_id)
    event = $game_map.events[event_id]
    turn_toward_tile_6(event.x, event.y)
  end

  def turn_toward_tile_4(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
    if sx.abs > sy.abs
      sx > 0 ? turn_left : turn_right
    else
      sy > 0 ? turn_up : turn_down
    end
  end

  def turn_toward_tile_6(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
  if sy <= 0
      if sy.abs > (sx.abs * 1.5)
        turn_down
      else
        sx < 0 ? turn_lower_right : turn_lower_left
      end
    else
      if sy.abs > (sx.abs * 1.5)
        turn_up
      else
        sx < 0 ? turn_upper_right : turn_upper_left
      end
    end
  end

  def turn_away_from_player
    turn_away_from_tile_6($game_player.x, $game_player.y)
  end

  def turn_away_from_event(event_id)
    event = $game_map.events[event_id]
    turn_away_from_tile_6(event.x, event.y)
  end

  def turn_away_from_tile_4(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
    if sx.abs > sy.abs
      sx > 0 ? turn_right : turn_left
    else
      sy > 0 ? turn_down : turn_up
    end
  end

  def turn_away_from_tile_6(x, y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0
  if sy < 0
      if sy.abs > (sx.abs * 1.5)
        turn_up
      else
        sx < 0 ? turn_upper_left : turn_upper_right
      end
    else
      if sy.abs > (sx.abs * 1.5)
        turn_down
      else
        sx < 0 ? turn_lower_left : turn_lower_right
      end
    end
  end
end

class Game_Player < Game_Character

  CENTER_X = (640 / 2 - 32 / 2) * 4  # Center screen x-coordinate * 4
  CENTER_Y = (480 / 2 - 32 / 2) * 4  # Center screen y-coordinate * 4

  def passable?(x, y, d)
    super
  end

  def check_event_trigger_there(triggers)
    result = false
    return result if $game_system.map_interpreter.running?
    y_correct = case @direction
    when 2 then 1
    when 8 then -1
    when 1, 3 then @x%2==1 ? 1 : 0
    when 5, 7 then @x%2==1 ? 0 : -1
    else; 0
    end
    x_correct = case @direction
    when 6, 3, 7 then 1
    when 4, 1, 5 then -1
    else; 0
    end
    new_x = @x + x_correct
    new_y = @y + y_correct
    for event in $game_map.events.values
      if event.x == new_x and event.y == new_y and
        triggers.include?(event.trigger)
        if not event.jumping? and not event.over_trigger?
          event.start
          result = true
        end
      end
    end
    if result == false
      if $game_map.counter?(new_x, new_y)
        for event in $game_map.events.values
          if event.x == new_x and event.y == new_y and
            triggers.include?(event.trigger)
            if not event.jumping? and not event.over_trigger?
              event.start
              result = true
            end
          end
        end
      end
    end
    return result
  end
end

class Sprite_Character < RPG::Sprite
  def update
    super
    if @tile_id != @character.tile_id or
      @character_name != @character.character_name or
      @character_hue != @character.character_hue
      @tile_id = @character.tile_id
      @character_name = @character.character_name
      @character_hue = @character.character_hue
      if @tile_id >= 384
        self.bitmap = RPG::Cache.tile($game_map.tileset_name,
          @tile_id, @character.character_hue)
        self.src_rect.set(0, 0, HEXA::WIDTH, HEXA::HEIGHT)
        self.ox = HEXA::WIDTH / 2
        self.oy = HEXA::HEIGHT
      else
        self.bitmap = RPG::Cache.character(@character.character_name,
          @character.character_hue)
        @cw = bitmap.width / 4
        @ch = bitmap.height / 6
        self.ox = @cw / 2
        self.oy = @ch
      end
    end
    self.visible = (not @character.transparent)
    if @tile_id == 0
      sx = @character.pattern * @cw
      dir_array = [1, 0, 2, 0, 3, 0, 4, 5]
      sy = dir_array[@character.direction-1] * @ch
      self.src_rect.set(sx, sy, @cw, @ch)
    end
    self.x = @character.screen_x
    self.y = @character.screen_y
    self.z = @character.screen_z(@ch)
    self.opacity = @character.opacity
    self.blend_type = @character.blend_type
    self.bush_depth = @character.bush_depth(16)
    if @character.animation_id != 0
      animation = $data_animations[@character.animation_id]
      animation(animation, true)
      @character.animation_id = 0
    end
  end
end
avatar
Wecoc
Administrador
Administrador



Créditos 12211

Gracias : 632

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por Pokepik el 2013-08-15, 15:18

¿Como es que te sale esa parte en blanco debajo, Youka?

Wecón, he intentado solucionar lo del scroll y no se qué hiciste ahí pero no me gusta nada, no pude hacer más que empeorar lo que ya había XD Creo que no es culpa del scroll sinó del tilemap.

Tampoco me gusta eso del primer script donde pone:
Código:
MAX_MapWidth = 50
MAX_MapHeight = 50
¿Eso por qué? Mi no entender XD
Habría que buscar la manera de que no haya límite de tamaño, o al menos que no sea tan bajo.
Cuando el carajo vuela grajo... Ay no; "Cuando el bajo vuela frío, es que hablando me he hecho un lío".

Estaba pensando que quizá sería bueno hacer que si un evento tuviera en el nombre 4x_ su gráfico fuera de 4 direcciones y no de 6, y en cualquier diagonal se mostrara de lado.
avatar
Pokepik
Principiante
Principiante

0/3

Créditos 2134

Gracias : 4

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por Wecoc el 2013-08-15, 23:28

Pokepik: Lo del scroll es cosa del @real_y y el @real_x, antes de tocar esos el mapa scrolleaba bien.

Sí, a mí tampoco me gusta eso del MAX_MapWidth y el MAX_MapHeight, venía con el script que adapté y no supe quitarlo, habría que hacerlo. Eso viene de que crea el bitmap antes de cargar el mapa, y claro, entonces no sabe a qué width y height crearla, y lo hace con la del supuesto mayor mapa posible. Claro si ahí pones un número grande para que no haya un límite tan estrecho supongo que luego habrá lag....

Esa cagada de que el evento no miraba al héroe no era del check_event_trigger_there sinó del turn_toward_tile_6, la estoy mirando ahora. Eso significa que el move_toward_tile_6, el move_away_from_tile_6 y el turn_away_from_tile_6 tampoco estan completamente bien; todos estos funcionan mal a x pares.
avatar
Wecoc
Administrador
Administrador



Créditos 12211

Gracias : 632

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por youkai el 2013-08-17, 02:11

Bueno yo decidi dedicar el dia de hoy a la programacion y los resultados fueron:
- Ya no hace falta usar los tontos MAX_MapWidth y MAX_MapHeight. El bitmap se crea en dependencia del tamaño del mapa. Hemos roto los limites (?) XDDDD
- Y el plato fuerte......ya hice la parte de los bloqueos de paso y demas :) Me tomo mas tiempo entender bien como funcionaba el sistema de bits, el << y todo lo referente que hacer el script XDDD Como dijo wec, para poner la pasabilidad hay que hacerlo desde el juego(aprietas F5 en el mapa y te sale la escena para eso ^^ Lo hubiera puesto en el debug pero nah...no estaba pa' eso XDDDD)
Tambien debo decir que la configuracion de los bloqueos de paso se guarda en un .rxdata a parte...si lo pongo dentro del mismo Tileset creo que cada vez que abran la BD se peta todo XDD
Aqui los scripts:

El limit breaker del Tilemap:

Código:
   #==============================================================================
    # Hextiles
    #==============================================================================
    # Script creado por usuarios de Mundo Maker:
    # - Wecoc
    # - Pokepik
    # - Orochii
    #==============================================================================
    # 1. Hextiles Tilemap
    #------------------------------------------------------------------------------
    # Inspirado en el Tilemap de Derk-Jan Karrenbeld
    #------------------------------------------------------------------------------
    # Nota: Los autotiles leen los frames de dos en dos porque cada frame tiene dos
    # variedades de autotile según su y.
    #==============================================================================

    #==============================================================================
    # ** Spriteset_Map
    #------------------------------------------------------------------------------
    #  This class brings together map screen sprites, tilemaps, etc.
    #  It's used within the Scene_Map class.
    #==============================================================================
    
    class Spriteset_Map
      #--------------------------------------------------------------------------
      # * Object Initialization
      #--------------------------------------------------------------------------
      def initialize
        # Make viewports
        @viewport1 = Viewport.new(0, 0, 640, 480)
        @viewport2 = Viewport.new(0, 0, 640, 480)
        @viewport3 = Viewport.new(0, 0, 640, 480)
        @viewport2.z = 200
        @viewport3.z = 5000
        # Make tilemap
        @tilemap = Tilemap.new(@viewport1, [$game_map.width, $game_map.height])
        @tilemap.tileset = RPG::Cache.tileset($game_map.tileset_name)
        for i in 0..6
          autotile_name = $game_map.autotile_names[i]
          @tilemap.autotiles[i] = RPG::Cache.autotile(autotile_name)
        end
        @tilemap.map_data = $game_map.data
        @tilemap.priorities = $game_map.priorities
        # Make panorama plane
        @panorama = Plane.new(@viewport1)
        @panorama.z = -1000
        # Make fog plane
        @fog = Plane.new(@viewport1)
        @fog.z = 3000
        # Make character sprites
        @character_sprites = []
        for i in $game_map.events.keys.sort
          sprite = Sprite_Character.new(@viewport1, $game_map.events[i])
          @character_sprites.push(sprite)
        end
        @character_sprites.push(Sprite_Character.new(@viewport1, $game_player))
        # Make weather
        @weather = RPG::Weather.new(@viewport1)
        # Make picture sprites
        @picture_sprites = []
        for i in 1..50
          @picture_sprites.push(Sprite_Picture.new(@viewport2,
            $game_screen.pictures[i]))
        end
        # Make timer sprite
        @timer_sprite = Sprite_Timer.new
        # Frame update
        update
      end
    end
    
    module HEXA
      WIDTH = 32  # Tamaño del tile. Recomendable número par. Siempre < 32
      HEIGHT = 32 # Tamaño del tile. Recomendable número par. Siempre < 32
      SUPP = 8    # Superposición entre hexágonos, normalmente WIDTH/4.
      QWEASD_SUP = true # Soporte de movimiento con QWEASD
      DIR4_SUP = true # Soporte de movimiento con las teclas de dirección
      PRIORITY_FIX = true # Si está activado, la prioridad 1 es de suelo.
    end

    class Tilemap
      attr_reader :tileset
      attr_reader :autotiles
      attr_reader :flash_data
      attr_reader :priorities
      attr_reader :visible
      attr_reader :ox, :oy
      attr_writer :autotiles

      WindowRect = Rect.new(0,0,640,480)
      BitmapRect = Rect.new(0,0,640 + 64, 480 + 64)
      
      BitmapWindowOffsetX = (BitmapRect.width-WindowRect.width)/2/24
      BitmapWindowOffsetY = (BitmapRect.height-WindowRect.height)/2/32

      AutotileLength = 10 # Frames por cada frame del autotile
      
      # Orden de las partes del autotile
      Autotiles = [
        [ [27, 28, 33, 34], [ 5, 28, 33, 34], [27,  6, 33, 34], [ 5,  6, 33, 34],
          [27, 28, 33, 12], [ 5, 28, 33, 12], [27,  6, 33, 12], [ 5,  6, 33, 12] ],
        [ [27, 28, 11, 34], [ 5, 28, 11, 34], [27,  6, 11, 34], [ 5,  6, 11, 34],
          [27, 28, 11, 12], [ 5, 28, 11, 12], [27,  6, 11, 12], [ 5,  6, 11, 12] ],
        [ [25, 26, 31, 32], [25,  6, 31, 32], [25, 26, 31, 12], [25,  6, 31, 12],
          [15, 16, 21, 22], [15, 16, 21, 12], [15, 16, 11, 22], [15, 16, 11, 12] ],
        [ [29, 30, 35, 36], [29, 30, 11, 36], [ 5, 30, 35, 36], [ 5, 30, 11, 36],
          [39, 40, 45, 46], [ 5, 40, 45, 46], [39,  6, 45, 46], [ 5,  6, 45, 46] ],
        [ [25, 30, 31, 36], [15, 16, 45, 46], [13, 14, 19, 20], [13, 14, 19, 12],
          [17, 18, 23, 24], [17, 18, 11, 24], [41, 42, 47, 48], [ 5, 42, 47, 48] ],
        [ [37, 38, 43, 44], [37,  6, 43, 44], [13, 18, 19, 24], [13, 14, 43, 44],
          [37, 42, 43, 48], [17, 18, 47, 48], [13, 18, 43, 48], [ 1,  2,  7,  8] ]
      ]

      def initialize(viewport = nil, mapwh = nil)
        @autotiles    = Array.new(6, nil)
        @oldautotiles = Array.new(6, nil)
        @viewport   = viewport ? viewport : Viewport.new(WindowRect)
        @sprite = Sprite.new(@viewport)
        @sprite.bitmap = Bitmap.new(mapwh[0] * (HEXA::WIDTH) + 32,  #- HEXA::SUPP
        mapwh[1] * HEXA::HEIGHT + 64)
        @priority_ids     = {}  # IDs de prioridad
        @normal_tiles     = {}  # Tiles normales (no auto) - Array de Bitmaps
        @auto_tiles       = {}  # Autotiles - Array de Bitmaps
        @priority_sprites = []  # Prioridades
        @autotile_sprites = []  # Autotiles
        @flashing_sprites = []  # Flash
        @disposed   = false
        @visible    = true
        @flashing   = true
        @can_draw   = true
        @ox, @oy = 0, 0
      end

      def sprite_bitmap
        return @sprite.bitmap
      end

      def data_tilesets
        $data_tilesets ||= load_data("Data/Tilesets.rxdata")
      end

      def disposed?
        @disposed
      end

      def dispose
        spp = [@sprite] + @normal_tiles.values + @auto_tiles.values +
       @priority_sprites + @autotile_sprites + @flashing_sprites
        for sprite in spp
          sprite = sprite[0] if sprite.is_a?(Array)
          sprite.dispose if sprite.is_a?(Bitmap)
        end
        @priority_ids     = {}  # IDs de prioridad
        @normal_tiles     = {}  # Tiles normales (no auto) - Array de Bitmaps
        @priority_sprites = []  # Prioridades
        @autotile_sprites = []  # Autotiles
        @flashing_sprites = []  # Flash
        @disposed = true
      end

      def visible?
        @visible
      end

      def autotiles_changed?
        @oldautotiles != @autotiles
      end

      def visible=(value)
        @visible = value
        spp = [@sprite] + @priority_sprites + @autotile_sprites + @flashing_sprites
        for sprite in spp
          sprite = sprite[0] if sprite.is_a?(Array)
          sprite.visible = value
        end
      end

      def tileset=(value)
        return if @tileset == value
        value = value.tileset_name if value.is_a?(RPG::Tileset)
        @tileset = RPG::Cache.tileset(value) if value.is_a?(String)
        @tileset = value if value.is_a?(Bitmap)
        redraw_tileset if @can_draw
      end

      def priorities=(value)
        return if @priorities == value
        @priorities = value
        redraw_priorities if @can_draw
      end

      def flash_data=(*coord, &value)
        return if @flash_data[coord[0],coord[1]] == value
        flashing = !@flash_data[x,y].nil?
        @flash_data[x,y] = value
      end

      def map_data
        @map_data
      end

      def map_data=(value)
        return if @map_data == value
        @map_data = value
        @flash_data = Table.new(@map_data.xsize, @map_data.ysize)
        draw_region if @can_draw and @priorities and @tileset
      end

      def tile_id(x, y, z)
        return map_data[x, y, z]
      end

      def priority(*args)
        return @priorities[args[0]] if args.size == 1
        return @priorities[tile_id(args[0], args[1], args[2])]
      end

      def redraw_tileset
        sprite_bitmap.clear
        @normal_tiles.clear
        @auto_tiles.clear
        @autotile_sprites.each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
        @priority_sprites.each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
        @autotile_sprites.clear
        @priority_sprites.clear
        draw_region if @can_draw and @priorities and @tileset
      end

      def redraw_priorities
        @autotile_sprites.each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
        @priority_sprites.each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
        @autotile_sprites.clear
        @priority_sprites.clear
        @priority_ids.clear
        for z in 0...3
          for y in 0...map_data.ysize
            for x in 0...map_data.xsize
              next if (id = tile_id(x, y, z)) == 0
              next if (p = priority(id)) == 0
              @priority_ids[id] = p
            end
          end
        end
        draw_region if @can_draw and @priorities and @tileset
      end

      def redraw_autotiles
        @auto_tiles.clear
        @autotile_sprites.each { |sprite| sprite[0].dispose if !sprite[0].disposed? }
        @autotile_sprites.clear
        @oldautotiles = @autotiles
        draw_region if @can_draw and @priorities and @tileset
      end

      def draw_current_region
        left_x = @ox / (HEXA::WIDTH - HEXA::SUPP)
        top_y = @oy / HEXA::HEIGHT
        sppox = left_x * (HEXA::WIDTH - HEXA::SUPP) +
        @ox % (HEXA::WIDTH - HEXA::SUPP) + HEXA::WIDTH
        sppoy = top_y * HEXA::HEIGHT +
        @oy % HEXA::HEIGHT + (HEXA::HEIGHT + HEXA::HEIGHT/2)
        @sprite.ox = sppox
        @sprite.oy = sppoy
        for i in 0...@priority_sprites.size
          @priority_sprites[i][0].ox = sppox
          @priority_sprites[i][0].oy = sppoy
        end
        for i in 0...@autotile_sprites.size
          @autotile_sprites[i][0].ox = sppox
          @autotile_sprites[i][0].oy = sppoy
        end
      end

      def draw_region
        left_x = @ox / (HEXA::WIDTH - HEXA::SUPP)
        top_y = @oy / HEXA::HEIGHT
        @sprite.ox = BitmapWindowOffsetX * HEXA::WIDTH
        wecoc_y = left_x%2==1 ? (HEXA::HEIGHT/2) : 0
        @sprite.oy = BitmapWindowOffsetY * HEXA::HEIGHT + wecoc_y
        for x in 0...map_data.xsize+1
          for y in 0...map_data.ysize+1
            for z in 0..2
              if x%2==0
                draw_tile(x, y, tile_id(x + left_x - BitmapWindowOffsetX,
                y + top_y - BitmapWindowOffsetY, z),
                x + left_x - BitmapWindowOffsetX,
                y + top_y - BitmapWindowOffsetY, z)
              end
            end
          end
        end
        for x in 0...map_data.xsize+1
          for y in 0...map_data.ysize+1
            for z in 0..2
              if x%2==1
                draw_tile(x, y, tile_id(x + left_x - BitmapWindowOffsetX,
                y + top_y - BitmapWindowOffsetY, z),
                x + left_x - BitmapWindowOffsetX,
                y + top_y - BitmapWindowOffsetY, z)
              end
            end
          end
        end
        @sprite.update
        Graphics.frame_reset
      end

      def draw_tile(x, y, tile_id, tx, ty, tz, src_bitmap = nil)
        return if x < 0 or y < 0
        return if tile_id == nil
        if tile_id < 384
          return draw_autotile(x, y, tile_id, tx, ty, tz, src_bitmap = src_bitmap)
        end
        if (src_bitmap = @normal_tiles[tile_id]).nil?
          src_bitmap = Bitmap.new(HEXA::WIDTH, HEXA::HEIGHT)
          src_rect = Rect.new((tile_id - 384) % 8 * 32, (tile_id - 384) / 8 * 32,
            HEXA::WIDTH, HEXA::HEIGHT)
          src_bitmap.blt(0, 0, @tileset, src_rect)
          @normal_tiles[tile_id] = src_bitmap
        end
        wecoc_y = x%2==0 ? (HEXA::HEIGHT/2) : 0
        if @priority_ids[tile_id].nil?
          sprite_bitmap.blt(x * (HEXA::WIDTH - HEXA::SUPP) + @ox * HEXA::WIDTH,
            y * HEXA::HEIGHT + wecoc_y + @oy, src_bitmap,
            Rect.new(0,0,HEXA::WIDTH,HEXA::HEIGHT))
        else
          sprite = Sprite.new(@viewport)
          sprite.visible = visible
          sprite.bitmap = src_bitmap
          sprite.x = x * (HEXA::WIDTH - HEXA::SUPP) + @ox * HEXA::WIDTH
          sprite.y = y * HEXA::HEIGHT + wecoc_y + @oy
          sprite.ox = @ox + @ox % (HEXA::WIDTH - HEXA::SUPP) + HEXA::WIDTH
          sprite.oy = @oy + @oy % HEXA::HEIGHT + (HEXA::HEIGHT + HEXA::HEIGHT/2)
          sprite.z = @viewport.z + y * @priority_ids[tile_id] * HEXA::HEIGHT
          if HEXA::PRIORITY_FIX
            sprite.z -= HEXA::HEIGHT
          end
          @priority_sprites << [sprite, tx, ty, tz]
        end
      end

      def draw_autotile(x, y, tile_id, tx, ty, tz, src_bitmap = nil)
        return if x < 0 or y < 0
        return if tile_id == nil or tile_id >= 384
        return if tile_id == 0
        autotile = @autotiles[tile_id/48-1]
        return if autotile.nil? or autotile.disposed?
        if autotile.height == 32
          frames = autotile.width / (32 * 2)
        else
          frames = autotile.width / (96 * 2)
        end
        return if frames == 0
        if x%2 == 0
          start_frame = ((Graphics.frame_count/AutotileLength) % frames) + 1
        else
          start_frame = (Graphics.frame_count/AutotileLength) % frames
        end
        if (src_bitmap_array = @auto_tiles[tile_id]).nil?
          @auto_tiles[tile_id] = []
          if autotile.height == 32
            for i in 0...frames*2
              this_frame_bitmap = Bitmap.new(HEXA::WIDTH, HEXA::HEIGHT)
             src_rect = Rect.new(i * 32, 0, HEXA::WIDTH, HEXA::HEIGHT)
              this_frame_bitmap.blt(0, 0, autotile, src_rect)
              @auto_tiles[tile_id] << this_frame_bitmap
            end
            src_bitmap_array = @auto_tiles[tile_id]
          else
            for i in 0...frames*2
              this_frame_bitmap = Bitmap.new(HEXA::WIDTH, HEXA::HEIGHT)
              tiles = Autotiles[(tile_id % 48)>>3][(tile_id % 48)&7]
              for j in 0...4
                tile_position = tiles[j] - 1
                src_rect = Rect.new(tile_position % 6 * 16 + i * 96,
                  tile_position / 6 * 16, HEXA::WIDTH/2, HEXA::HEIGHT/2)
                this_frame_bitmap.blt(j % 2 * HEXA::WIDTH/2, j / 2 * HEXA::HEIGHT/2,
                  autotile, src_rect)
              end
              @auto_tiles[tile_id][i] = this_frame_bitmap
            end
            src_bitmap_array = @auto_tiles[tile_id]
          end
        end
        src_bitmap = src_bitmap_array[start_frame]
        return if src_bitmap.nil?
        wecoc_y = x%2==0 ? (HEXA::HEIGHT/2) : 0
        if @priority_ids[tile_id].nil? # and autotile.width == 32
          sprite_bitmap.blt(x * (HEXA::WIDTH - HEXA::SUPP) + @ox * HEXA::WIDTH,
            y * HEXA::HEIGHT + wecoc_y + @oy, src_bitmap,
            Rect.new(0,0,HEXA::WIDTH,HEXA::HEIGHT))
        else
          priority = (@priority_ids[tile_id] or 0)
          sprite = Sprite.new(@viewport)
          sprite.visible = visible
          sprite.bitmap = src_bitmap
          sprite.x = x * (HEXA::WIDTH - HEXA::SUPP) + @ox * HEXA::WIDTH
          sprite.y = y * HEXA::HEIGHT + wecoc_y + @oy
          sprite.ox = @ox + @ox % (HEXA::WIDTH - HEXA::SUPP) + HEXA::WIDTH
          sprite.oy = @oy + @oy % HEXA::HEIGHT + (HEXA::HEIGHT + HEXA::HEIGHT/2)
          sprite.z = @viewport.z + y * priority * HEXA::HEIGHT
          if HEXA::PRIORITY_FIX
            sprite.z -= HEXA::HEIGHT
          end
          @autotile_sprites << [sprite, tx, ty, tz, start_frame]
        end
      end

      def get_update_autotile(tile_id, start_frame)
        return if tile_id == nil or tile_id >= 384
        return if tile_id == 0
        autotile = @autotiles[tile_id/48-1]
        return if autotile.nil? or autotile.disposed?
        if autotile.height == 32
          frames = autotile.width / (32 * 2)
        else
          frames = autotile.width / (96 * 2)
        end
        current_frame = (Graphics.frame_count/AutotileLength) % frames * 2
        src_bitmap = @auto_tiles[tile_id][current_frame + start_frame]
        return src_bitmap  
      end

      def ox=(value)
        return unless @ox != value
        @ox = value
      end

      def oy=(value)
        return unless @oy != value
        @oy = value
      end

      def update
        redraw_autotiles if autotiles_changed?
        return if not visible?
        update_autotiles if (Graphics.frame_count % AutotileLength) == 0
        draw_current_region
      end

      def update_autotiles
        left_x = @ox / HEXA::WIDTH
        top_y = @oy / HEXA::HEIGHT
        for sprite in @autotile_sprites
          real_sprite, tx, ty, tz, start_frame = sprite
          tile_id = tile_id(tx, ty, tz)
          real_sprite.bitmap = get_update_autotile(tile_id, start_frame)
        end
      end
    end
Y el tochoscript de los bloqueos de paso XDD

Código:
#==============================================================================
# ** Scene_Title
#------------------------------------------------------------------------------
#  This class performs title screen processing.
#==============================================================================

class Scene_Title
  def main
    # If battle test
    if $BTEST
      battle_test
      return
    end
    # Load database
    $data_actors        = load_data("Data/Actors.rxdata")
    $data_classes       = load_data("Data/Classes.rxdata")
    $data_skills        = load_data("Data/Skills.rxdata")
    $data_items         = load_data("Data/Items.rxdata")
    $data_weapons       = load_data("Data/Weapons.rxdata")
    $data_armors        = load_data("Data/Armors.rxdata")
    $data_enemies       = load_data("Data/Enemies.rxdata")
    $data_troops        = load_data("Data/Troops.rxdata")
    $data_states        = load_data("Data/States.rxdata")
    $data_animations    = load_data("Data/Animations.rxdata")
    $data_tilesets      = load_data("Data/Tilesets.rxdata")
    $data_common_events = load_data("Data/CommonEvents.rxdata")
    $data_system        = load_data("Data/System.rxdata")
    if FileTest.exist?("Data/Passages.rxdata")
      passages = load_data("Data/Passages.rxdata")
      $data_tilesets.each_index{|i|
      next if i == 0
      $data_tilesets[i].passages = passages[i]}
    else
      passages = [nil]
      $data_tilesets.each{|tileset|
      next if tileset.nil?
      (384...tileset.passages.xsize).each {|d|
      if tileset.passages[d] & 0x40 == 0x40 && tileset.passages[d] & 0x80 == 0x80
        tileset.passages[d] = 0x40 + 0x80
        next
      elsif tileset.passages[d] & 0x40 == 0x40
        tileset.passages[d] = 0x40
        next
      elsif tileset.passages[d] & 0x80 == 0x80
        tileset.passages[d] = 0x80
        next
      end
      tileset.passages[d] = 0}
      passages.push(tileset.passages)}
      save_data(passages, "Data/Passages.rxdata")
    end    
    # Make system object
    $game_system = Game_System.new
    # Make title graphic
    @sprite = Sprite.new
    @sprite.bitmap = RPG::Cache.title($data_system.title_name)
    # Make command window
    s1 = "New Game"
    s2 = "Continue"
    s3 = "Shutdown"
    @command_window = Window_Command.new(192, [s1, s2, s3])
    @command_window.back_opacity = 160
    @command_window.x = 320 - @command_window.width / 2
    @command_window.y = 288
    # Continue enabled determinant
    # Check if at least one save file exists
    # If enabled, make @continue_enabled true; if disabled, make it false
    @continue_enabled = false
    for i in 0..3
      if FileTest.exist?("Save#{i+1}.rxdata")
        @continue_enabled = true
      end
    end
    # If continue is enabled, move cursor to "Continue"
    # If disabled, display "Continue" text in gray
    if @continue_enabled
      @command_window.index = 1
    else
      @command_window.disable_item(1)
    end
    # Play title BGM
    $game_system.bgm_play($data_system.title_bgm)
    # Stop playing ME and BGS
    Audio.me_stop
    Audio.bgs_stop
    # Execute transition
    Graphics.transition
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Frame update
      update
      # Abort loop if screen is changed
      if $scene != self
        break
      end
    end
    # Prepare for transition
    Graphics.freeze
    # Dispose of command window
    @command_window.dispose
    # Dispose of title graphic
    @sprite.bitmap.dispose
    @sprite.dispose
  end
end

#==============================================================================
# ** Scene_Map
#------------------------------------------------------------------------------
#  This class performs map screen processing.
#==============================================================================
class Scene_Map
  alias hexapassage_map_update update
  def update
    hexapassage_map_update
    if $DEBUG and Input.press?(Input::F5)
      $scene = Tileset_Passage.new
    end
  end
end

class Tileset_Cursor < Window_Selectable
  attr_accessor :tileset_id
  def initialize
    super(344, 0, 296, 480)
    @index = 0
    @tileset_id = 1
    refresh
    self.back_opacity = 0
  end
  
  def refresh
    if self.contents != nil
      self.contents.clear
      @arrows.clear
    end
    bitmap = RPG::Cache.tileset($data_tilesets[@tileset_id].tileset_name)
    self.contents = @arrows = Bitmap.new(bitmap.width + 1, bitmap.height + 1)
    @item_max = (bitmap.width / 32) * (bitmap.height / 32)
    @column_max = bitmap.width / 32
    (@column_max + 1).times{|c|
    self.contents.fill_rect(c * 32, 0, 1, bitmap.height, Color.new(0,0,0))}
    (@item_max / @column_max + 1).times {|c|
    self.contents.fill_rect(0, c * 32, bitmap.width, 1, Color.new(0,0,0))}
    0.upto(@item_max) {|n|
   draw_passages(n)}
  end
  
  def draw_passages(n)
    dir_array = ["1", "2", "4", "8", "16", "32"]
    tileset_p = $data_tilesets[@tileset_id].passages[384+n]
    rect = Rect.new(0,0,32,32)
    if tileset_p == 0
      dir_array.each{|name|
      bitmap = Bitmap.new("Graphics/Dirs/" + name)
      @arrows.blt(n % @column_max * 32, n / @column_max * 32, bitmap, rect)}
      return
    end
    if tileset_p & 1 == 0
      bitmap = Bitmap.new("Graphics/Dirs/1")
      @arrows.blt(n % @column_max * 32, n / @column_max * 32, bitmap, rect)
    end
    if tileset_p & 2 == 0
      bitmap = Bitmap.new("Graphics/Dirs/2")
      @arrows.blt(n % @column_max * 32, n / @column_max * 32, bitmap, rect)
    end
    if tileset_p & 4 == 0
      bitmap = Bitmap.new("Graphics/Dirs/4")
      @arrows.blt(n % @column_max * 32, n / @column_max * 32, bitmap, rect)
    end
    if tileset_p & 8 == 0
      bitmap = Bitmap.new("Graphics/Dirs/8")
      @arrows.blt(n % @column_max * 32, n / @column_max * 32, bitmap, rect)
    end
    if tileset_p & 16 == 0
      bitmap = Bitmap.new("Graphics/Dirs/16")
      @arrows.blt(n % @column_max * 32, n / @column_max * 32, bitmap, rect)
    end
    if tileset_p & 32 == 0
      bitmap = Bitmap.new("Graphics/Dirs/32")
      @arrows.blt(n % @column_max * 32, n / @column_max * 32, bitmap, rect)
    end
  end
  #--------------------------------------------------------------------------
  # * Update Cursor Rectangle
  #--------------------------------------------------------------------------
  def update_cursor_rect
    # If cursor position is less than 0
    if @index < 0
      self.cursor_rect.empty
      return
    end
    # Get current row
    row = @index / @column_max
    # If current row is before top row
    if row < self.top_row
      # Scroll so that current row becomes top row
      self.top_row = row
    end
    # If current row is more to back than back row
    if row > self.top_row + (self.page_row_max - 1)
      # Scroll so that current row becomes back row
      self.top_row = row - (self.page_row_max - 1)
    end
    # Calculate cursor width
    cursor_width = 32
    # Calculate cursor coordinates
    x = @index % @column_max * 32
    y = @index / @column_max * 32 - self.oy
    # Update cursor rectangle
    self.cursor_rect.set(x, y, cursor_width, 32)
  end
end

class Window_Tuto < Window_Base
  def initialize
    super(0, 0, 344, 480)
    self.contents = Bitmap.new(width - 32, height - 32)
    refresh
  end
  
  def refresh
    self.contents.clear
    y = 36
    self.contents.draw_text(4, 4, 344, 32, "C: Selecciona tile a modificar")
    self.contents.draw_text(4, y, 344, 32, "QWEASD: Direcciones a modificar")
    self.contents.draw_text(4, y*2, 344, 32, "Ctrl: Pagina anterior")
    self.contents.draw_text(4, y*3, 344, 32, "Alt: Pagina siguiente")
    self.contents.draw_text(4, y*4, 320, 32, "X: Salir|Bloquear paso|Desbloquear paso")
  end
end

class Tileset_Passage
  def main
    @dummy_window = Window_Base.new(344, 0, 296, 480)
    @dummy_window.z = -2000
    @intruction_window = Window_Tuto.new
    @tileset_cursor = Tileset_Cursor.new
    bitmap = RPG::Cache.tileset($data_tilesets[@tileset_cursor.tileset_id].tileset_name)
    @tileset_sprite = Sprite.new
    @tileset_sprite.bitmap = bitmap
    @tileset_sprite.x += 360
    @tileset_sprite.y += 16
    @tileset_passages = $data_tilesets[@tileset_cursor.tileset_id].passages
    # Execute transition
    Graphics.transition
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Frame update
      update
      # Abort loop if screen is changed
      if $scene != self
        break
      end
    end
    # Prepare for transition
    Graphics.freeze
    # Dispose of command window
    @tileset_cursor.dispose
    @dummy_window.dispose
    # Dispose of title graphic
    @tileset_sprite.bitmap.dispose
    @tileset_sprite.dispose
  end
  
  def update
    @tileset_cursor.update
    @tileset_sprite.oy = @tileset_cursor.oy
    if Input.trigger?(Input::ALT) && @tileset_cursor.active
      @tileset_cursor.tileset_id += 1
      if $data_tilesets[@tileset_cursor.tileset_id].nil?
        @tileset_cursor.tileset_id = 1
      end
      @tileset_passages = $data_tilesets[@tileset_cursor.tileset_id].passages
      bitmap = RPG::Cache.tileset($data_tilesets[@tileset_cursor.tileset_id].tileset_name)
      @tileset_sprite.bitmap = bitmap
      @tileset_sprite.oy = @tileset_cursor.oy = 0
      @tileset_cursor.refresh
      return
    elsif Input.trigger?(Input::CTRL) && @tileset_cursor.active
      @tileset_cursor.tileset_id -= 1
      if $data_tilesets[@tileset_cursor.tileset_id].nil?
        @tileset_cursor.tileset_id = $data_tilesets.size - 1
      end
      @tileset_passages = $data_tilesets[@tileset_cursor.tileset_id].passages
      bitmap = RPG::Cache.tileset($data_tilesets[@tileset_cursor.tileset_id].tileset_name)
      @tileset_sprite.bitmap = bitmap
      @tileset_sprite.oy = @tileset_cursor.oy = 0
      @tileset_cursor.refresh
      return
    elsif Input.trigger?(Input::B) && @tileset_cursor.active
      passages = [nil]
      $data_tilesets.each{|tile|
      next if tile.nil?
      passages.push(tile.passages)}
      save_data(passages, "Data/Passages.rxdata")
      $scene = Scene_Map.new
      return
    elsif Input.trigger?(Input::C) && @tileset_cursor.active
      @tileset_cursor.active = false
      return
    end
    if !@tileset_cursor.active
      update_passage_selection
    end
  end
      
  def update_passage_selection
    if Input.trigger?(Input::C)
      @tileset_cursor.active = true
      return
    end
    if Input.trigger?(Input::B)
      @tileset_passages[384 + @tileset_cursor.index] =
     @tileset_passages[384 + @tileset_cursor.index] != 0x3f ? 0x3f : 0
      @tileset_cursor.refresh
    end
    case Input.dir6
    when 'E'
      if @tileset_passages[384 + @tileset_cursor.index] & 16 == 0
        @tileset_passages[384 + @tileset_cursor.index] += 16
      else
        @tileset_passages[384 + @tileset_cursor.index] -= 16
      end
      @tileset_cursor.refresh
    when 'W'
      if @tileset_passages[384 + @tileset_cursor.index] & 32 == 0
        @tileset_passages[384 + @tileset_cursor.index] += 32
      else
        @tileset_passages[384 + @tileset_cursor.index] -= 32
      end
      @tileset_cursor.refresh
    when 'S'
      if @tileset_passages[384 + @tileset_cursor.index] & 1 == 0
        @tileset_passages[384 + @tileset_cursor.index] += 1
      else
        @tileset_passages[384 + @tileset_cursor.index] -= 1
      end
      @tileset_cursor.refresh
    when 'A'
      if @tileset_passages[384 + @tileset_cursor.index] & 2 == 0
        @tileset_passages[384 + @tileset_cursor.index] += 2
      else
        @tileset_passages[384 + @tileset_cursor.index] -= 2
      end
      @tileset_cursor.refresh
    when 'D'
      if @tileset_passages[384 + @tileset_cursor.index] & 4 == 0
        @tileset_passages[384 + @tileset_cursor.index] += 4
      else
        @tileset_passages[384 + @tileset_cursor.index] -= 4
      end
      @tileset_cursor.refresh
    when 'Q'
      if @tileset_passages[384 + @tileset_cursor.index] & 8 == 0
        @tileset_passages[384 + @tileset_cursor.index] += 8
      else
        @tileset_passages[384 + @tileset_cursor.index] -= 8
      end
      @tileset_cursor.refresh
    end
  end
end

class Game_Map
  def passable?(x, y, d, self_event = nil)
    # If coordinates given are outside of the map
    unless valid?(x, y)
      # impassable
      return false
    end
    # Change direction (0,2,4,6,8,10) to obstacle bit (0,1,2,4,8,0)
    bit = (1 << (d / 2 - 1)) & 0x3f
    # Loop in all events
    for event in events.values
      # If tiles other than self are consistent with coordinates
      if event.tile_id >= 0 and event != self_event and
         event.x == x and event.y == y and not event.through
        # If obstacle bit is set
        if @passages[event.tile_id] & bit != 0
          # impassable
          return false
        # If obstacle bit is set in all directions
        elsif @passages[event.tile_id] & 0x3f == 0x3f
          # impassable
          return false
        # If priorities other than that are 0
        elsif @priorities[event.tile_id] == 0
          # passable
          return true
        end
      end
    end
    # Loop searches in order from top of layer
    for i in [2, 1, 0]
      # Get tile ID
      tile_id = data[x, y, i]
      # Tile ID acquistion failure
      if tile_id == nil
        # impassable
        return false
      # If obstacle bit is set
      elsif @passages[tile_id] & bit != 0
        # impassable
        return false
      # If obstacle bit is set in all directions
      elsif @passages[tile_id] & 0x3f == 0x3f
        # impassable
        return false
      # If priorities other than that are 0
      elsif @priorities[tile_id] == 0
        # passable
        return true
      end
    end
    # passable
    return true
  end
end


Última edición por youkai el 2013-08-17, 08:18, editado 1 vez
avatar
youkai
Soñador
Soñador

0/3

Créditos 280

Gracias : 10

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por youkai el 2013-08-17, 08:20

En continuacion al primer tema...me imagine que no cabria pero bueh...como el foro lo posteo pense que no habria lio(creo que UM te dice cuando no cabe XDDDD)

Tambien cambie los numeros de las direcciones porque usar 1, 3, 5 y 7 no sirve para nada :( Los cambie por numeros mas potables: 4, 6, 8, 10. Si, como ya no se camina para los lados pues use sus valores...seria una cagada dejarlos sin uso XDDDD
Aqui estan las modificaciones que le hice tambien al Game_Character:
Código:
    #==============================================================================
    # Hextiles
    #==============================================================================
    # Script creado por usuarios de Mundo Maker:
    # - Wecoc
    # - Pokepik
    # - Orochii
    # - Eron
    # - Youkai
    #==============================================================================
    # 3. Character Features
    #==============================================================================

    class Game_Character
   
    attr_accessor  :direction
      attr_accessor  :pattern
      # 2 - abajo
      # 12 - arriba
      # 4 | 1 - izquierda abajo
      # 6 | 3 - derecha abajo
      # 8 | 5 - izquierda arriba
      # 10 | 7 - derecha arriba
    def passable?(x, y, d) # No está hecho
        case d
        when 4 # Lower Left
          new_x = x - 1
          wecoc_y = @x%2==1 ? 1 : 0
          new_y = y + wecoc_y
        when 2 # Down
          new_x = x
          new_y = y + 1
        when 6 # Lower Right
          new_x = x + 1
          wecoc_y = @x%2==1 ? 1 : 0
          new_y = y + wecoc_y
        when 8 # Upper Left
          new_x = x-1
          wecoc_y = @x%2==0 ? 1 : 0
          new_y = y - wecoc_y
        when 10 # Upper Right
          new_x = x+1
          wecoc_y = @x%2==0 ? 1 : 0
          new_y = y - wecoc_y
        when 12 # Up
          new_x = x
          new_y = y - 1
        else
          new_x = x
          new_y = y
        end
        return false unless $game_map.valid?(new_x, new_y)
        if self.is_a?(Game_Player)
          return true if $DEBUG and Input.press?(Input::CTRL)
        end
        return true if @through
        if $game_map.data[x,y,0] == 0 and
          $game_map.data[x,y,1] == 0 and
          $game_map.data[x,y,2] == 0
          return false
        end
        if $game_map.data[new_x,new_y,0] == 0 and
          $game_map.data[new_x,new_y,1] == 0 and
          $game_map.data[new_x,new_y,2] == 0
          return false
        end
        return false unless $game_map.passable?(x, y, d)
        return false unless $game_map.passable?(new_x, new_y, d)

        for event in $game_map.events.values
          if event.x == new_x and event.y == new_y
            unless event.through
              return false if self != $game_player
              return false if event.character_name != ""
            end
          end
        end
        if $game_player.x == new_x and $game_player.y == new_y
          unless $game_player.through
            return false if @character_name != ""
          end
        end
        return true
      end

      def moving?
        wecoc_y = @x%2==0 ? (HEXA::HEIGHT / 2) : 0
        return (@real_x != @x * (HEXA::WIDTH - HEXA::SUPP) * 4 or
          @real_y != (@y * HEXA::HEIGHT - wecoc_y) * 4)
      end

      def moveto(x, y)
        @x = x % $game_map.width
        @y = y % $game_map.height
        wecoc_y = @x%2==0 ? (HEXA::HEIGHT / 2) : 0
        @real_x = @x * (HEXA::WIDTH - HEXA::SUPP) * 4
        @real_y = (@y * HEXA::HEIGHT - wecoc_y) * 4
        @prelock_direction = 0
      end

      def jump(x_plus, y_plus)
        tile_x = @x
        tile_y = @y
        new_tile_x = @x + x_plus
        new_tile_y = @y + y_plus
        straighten
        distance = 0
        if passable?(new_tile_x, new_tile_y, 0)
          turn_toward_tile_6(new_tile_x, new_tile_y)
          distance = Math.sqrt(x_plus * x_plus + y_plus * y_plus).round
          @x = new_tile_x
          @y = new_tile_y
        end
        @jump_peak = 10 + distance - @move_speed
        @jump_count = @jump_peak * 2
        @stop_count = 0
      end

      def tile_neighbors(x, y, d=0)
        if x%2==1
          array = [[x-1,y+1],[x,y-1],[x+1,y+1],[x,y],[x-1,y],[x,y],[x+1,y],[x,y+1]]
        else
          array = [[x-1,y],[x,y-1],[x+1,y],[x,y],[x-1,y-1],[x,y],[x+1,y-1],[x,y+1]]
        end
        return d==0 ? array : array[d-1]
      end

      def ring_tiles(distance)
        get_ring_tiles(self.x, self.y, distance)
      end

      def get_ring_tiles(x, y, distance)
        case distance
        when 0 then return [[x, y]]
        when 1 then return tile_neighbors(x,y)
        when 2
          neighbors = tile_neighbors(x,y)
          new_neighbors = []
          for i in 0...neighbors.size
            for j in 1..8
              new_neighbors.push(tile_neighbors(neighbors[i][0], neighbors[i][1], j))
            end
          end
          new_neighbors.uniq!
          for i in 0...neighbors.size
            new_neighbors.delete(neighbors[i])
          end
          new_neighbors.delete([x,y])
          return new_neighbors
        else
          neighbors = get_ring_tiles(x, y, distance-1)
          all_neighbors = []
          for i in 0...distance-1
            all_neighbors.push(get_ring_tiles(x, y, i))
          end
          new_neighbors = []
          for i in 0...neighbors.size
            for j in 1..8
              new_neighbors.push(tile_neighbors(neighbors[i][0], neighbors[i][1], j))
            end
          end
          new_neighbors.uniq!
          for i in 0...neighbors.size
            new_neighbors.delete(neighbors[i])
          end
          for i in 0...all_neighbors.size
            for j in 0...all_neighbors[i].size
              new_neighbors.delete(all_neighbors[i][j])
            end
          end
          new_neighbors.delete([x,y])
          return new_neighbors
        end
      end

      def screen_x
        return (@real_x - $game_map.display_x + 3) / 4 + HEXA::WIDTH / 4
      end

      def screen_y
        y = (@real_y - $game_map.display_y + 3) / 4 + HEXA::HEIGHT
        if @jump_count >= @jump_peak
          n = @jump_count - @jump_peak
        else
          n = @jump_peak - @jump_count
        end
        return y - (@jump_peak * @jump_peak - n * n) / 2
      end

      def screen_z(height = 0)
        return 999 if @always_on_top
        z = (@real_y - $game_map.display_y + 3) / 4 + HEXA::HEIGHT
        if @tile_id > 0
          return z + $game_map.priorities[@tile_id] * HEXA::HEIGHT
        else
          return z + ((height > HEXA::HEIGHT) ? HEXA::HEIGHT - 1 : 0)
        end
      end
   
    def bush_depth(depth=12)
        return 0 if @tile_id > 0 or @always_on_top
        if @jump_count == 0 and $game_map.bush?(@x, @y)
          return depth
        else
          return 0
        end
      end

      def update_jump
        @jump_count -= 1
        wecoc_y = @x%2==0 ? (HEXA::HEIGHT / 2) : 0
        @real_x = (@real_x * @jump_count +
          @x * (HEXA::WIDTH - HEXA::SUPP) * 4) / (@jump_count+1)
        @real_y = (@real_y * @jump_count +
          (@y * HEXA::HEIGHT - wecoc_y) * 4) / (@jump_count+1)
      end

      def update_move
        @false_move_speed = @move_speed if @false_move_speed == nil
        distance = 2 ** @false_move_speed
        wecoc_y = @x%2==0 ? (HEXA::HEIGHT / 2) : 0
        if (@y * 32 - wecoc_y) * 4 > @real_y # Move down
          @real_y = [@real_y + distance / 1.5, (@y * HEXA::HEIGHT - wecoc_y) * 4].min
        end
        if @x * 24 * 4 < @real_x # Move left
          @real_x = [@real_x - distance, @x * (HEXA::WIDTH - HEXA::SUPP) * 4].max
        end
        if @x * 24 * 4 > @real_x # Move right
          @real_x = [@real_x + distance, @x * (HEXA::WIDTH - HEXA::SUPP) * 4].min
        end
        if (@y * 32 - wecoc_y) * 4 < @real_y # Move up
          @real_y = [@real_y - distance / 1.5, (@y * HEXA::HEIGHT - wecoc_y) * 4].max
        end
        if @walk_anime
          @anime_count += 1.5
        elsif @step_anime
          @anime_count += 1
        end
      end

      def move_type_random(app=50)
        app = [[100, app].min, 1].max
        case rand(100/app)
          when 0 then move_random # Random
        else
          case rand(2)
            when 0 then move_forward # Forward
            when 1 then @stop_count = 0 # Wait
          end
        end
      end

      def move_up(turn_enabled = true)
        @false_move_speed = @move_speed
        turn_up if turn_enabled
        if passable?(@x, @y, 12)
          turn_up
          @y -= 1
          increase_steps
        else
          check_event_trigger_touch(@x, @y-1)
        end
      end

      def move_down(turn_enabled = true)
        @false_move_speed = @move_speed
        turn_down if turn_enabled
        if passable?(@x, @y, 2)
          turn_down
          @y += 1
          increase_steps
        else
          check_event_trigger_touch(@x, @y+1)
        end
      end

      def move_lower_left(turn_enabled = true)
        quo = HEXA::HEIGHT.quo(HEXA::WIDTH - HEXA::SUPP)
        @false_move_speed = @move_speed / quo
        turn_lower_left if turn_enabled
        @direction = 4 unless @direction_fix
        if passable?(@x, @y, 4)
          @y += 1 if @x%2==1
          @x -= 1
          increase_steps
        else
          check_event_trigger_touch(@x - 1, @y + 1)
        end
      end

      def move_lower_right(turn_enabled = true)
        quo = HEXA::HEIGHT.quo(HEXA::WIDTH - HEXA::SUPP)
        @false_move_speed = @move_speed / quo
        turn_lower_right if turn_enabled
        @direction = 6 unless @direction_fix
        if passable?(@x, @y, 6)
          @y += 1 if @x%2==1
          @x += 1
          increase_steps
        else
          check_event_trigger_touch(@x + 1, @y + 1)
        end
      end

      def move_upper_left(turn_enabled = true)
        quo = HEXA::HEIGHT.quo(HEXA::WIDTH - HEXA::SUPP)
        @false_move_speed = @move_speed / quo
        turn_upper_left if turn_enabled
        @direction = 8 unless @direction_fix
        if passable?(@x, @y, 8)
          @y -= 1 if @x%2==0
          @x -= 1
          increase_steps
        else
          check_event_trigger_touch(@x - 1, @y)
        end
      end

      def move_upper_right(turn_enabled = true)
        quo = HEXA::HEIGHT.quo(HEXA::WIDTH - HEXA::SUPP)
        @false_move_speed = @move_speed / quo
        turn_upper_right if turn_enabled
        @direction = 10 unless @direction_fix
        if passable?(@x, @y, 10)
          @y -= 1 if @x%2==0
          @x += 1
          increase_steps
        else
          check_event_trigger_touch(@x + 1, @y)
        end
      end

      def move_random
        move_random_6
      end

      def move_random_4
        case rand(4)
          when 0 then move_down(false)
          when 1 then move_left(false)
          when 2 then move_right(false)
          when 3 then move_up(false)
        end
      end

      def move_random_6
        case rand(6)
          when 0 then move_down(false)
          when 1 then move_upper_left(false)
          when 2 then move_upper_right(false)
          when 3 then move_lower_left(false)
          when 4 then move_lower_right(false)
          when 5 then move_up(false)
        end
      end

      def move_random_4_to_6
        case rand(4)
          when 0 then move_down(false)
          when 1
            case rand(2)
              when 0 then move_upper_left(false)
              when 1 then move_upper_right(false)
            end
          when 2
            case rand(2)
              when 0 then move_lower_left(false)
              when 1 then move_lower_right(false)
            end
          when 3 then move_up(false)
        end
      end

      def move_toward_player
        move_toward_tile_6($game_player.x, $game_player.y)
      end

      def move_toward_event(event_id)
        event = $game_map.events[event_id]
        move_toward_tile_6(event.x, event.y)
      end

      def move_toward_tile_4(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0
        abs_sx = sx.abs
        abs_sy = sy.abs
        if abs_sx == abs_sy
          rand(2) == 0 ? abs_sx += 1 : abs_sy += 1
        end
        if abs_sx > abs_sy
          sx > 0 ? move_left : move_right
          if not moving? and sy != 0
            sy > 0 ? move_up : move_down
          end
        else
          sy > 0 ? move_up : move_down
          if not moving? and sx != 0
            sx > 0 ? move_left : move_right
          end
        end
      end

      def move_toward_tile_6(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0
      if sy <= 0
          if sy.abs > (sx.abs * 1.5)
            move_down
          else
            sx < 0 ? move_lower_right : move_lower_left
          end
        else
          if sy.abs > (sx.abs * 1.5)
            move_up
          else
            sx < 0 ? move_upper_right : move_upper_left
          end
        end
      end

    def move_away_from_player
        move_away_from_tile_6($game_player.x, $game_player.y)
      end

      def move_away_from_event(event_id)
        event = $game_map.events[event_id]
        move_away_from_tile_6(event.x, event.y)
      end

      def move_away_from_tile_4(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0
        abs_sx = sx.abs
        abs_sy = sy.abs
        if abs_sx == abs_sy
          rand(2) == 0 ? abs_sx += 1 : abs_sy += 1
        end
        if abs_sx > abs_sy
          sx > 0 ? move_right : move_left
          if not moving? and sy != 0
            sy > 0 ? move_down : move_up
          end
        else
          sy > 0 ? move_down : move_up
          if not moving? and sx != 0
            sx > 0 ? move_right : move_left
          end
        end
      end

      def move_away_from_tile_6(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0
      if sy < 0
          if sy.abs > (sx.abs * 1.5)
            move_up
          else
            sx < 0 ? move_upper_left : move_upper_right
          end
        else
          if sy.abs > (sx.abs * 1.5)
            turn_down
          else
            sx < 0 ? move_lower_left : move_lower_right
          end
        end
      end

      def move_forward
        case @direction
          when 1 then move_lower_left(false)
          when 2 then move_down(false)
          when 3 then move_lower_right(false)
          when 4 then move_left(false)
          when 5 then move_upper_left(false)
          when 6 then move_right(false)
          when 7 then move_upper_right(false)
          when 8 then move_up(false)
        end
      end

      def move_backward
        last_direction_fix = @direction_fix
        @direction_fix = true
        case @direction
          when 1 then move_upper_right(false)
          when 2 then move_up(false)
          when 3 then move_upper_left(false)
          when 4 then move_right(false)
          when 5 then move_lower_right(false)
          when 6 then move_left(false)
          when 7 then move_lower_left(false)
          when 8 then move_down(false)
        end
        @direction_fix = last_direction_fix
      end

      def turn_clock(n=1)
        return if n <= 0 or n > 5
        dir_array = [2, 4, 8, 12, 10, 6]
        return if not dir_array.include?(@direction)
        n.times do
          i = dir_array.index(@direction)
          @direction = dir_array[i+1] != nil ? dir_array[i+1] : dir_array[0]
        end
      end

      def turn_anticlock(n=1)
        return if n <= 0 or n > 5
        dir_array = [6, 10, 12, 8, 4, 2]
        return if not dir_array.include?(@direction)
        n.times do
          i = dir_array.index(@direction)
          @direction = dir_array[i+1] != nil ? dir_array[i+1] : dir_array[0]
        end
      end

      #--------------------------------------------------------------------------
      # * Turn Up
      #--------------------------------------------------------------------------
      def turn_up
        unless @direction_fix
          @direction = 12
          @stop_count = 0
        end
      end

      def turn_lower_left
        unless @direction_fix
          @direction = 4
          @stop_count = 0
        end
      end

      def turn_lower_right
        unless @direction_fix
          @direction = 6
          @stop_count = 0
        end
      end

      def turn_upper_left
        unless @direction_fix
          @direction = 8
          @stop_count = 0
        end
      end

      def turn_upper_right
        unless @direction_fix
          @direction = 10
          @stop_count = 0
        end
      end

      def turn_right_90
        turn_clock
      end

      def turn_left_90
        turn_anticlock
      end

      def turn_180
        case @direction
          when 2 then turn_down
          when 4 then turn_lower_left
          when 6 then turn_lower_right
          when 8 then turn_upper_left
          when 10 then turn_upper_right
          when 12 then turn_up
        end
      end

      def turn_right_or_left_90
        rand(2) == 0 ? turn_clock : turn_anticlock
      end

      def turn_random
        turn_random_6
      end

      def turn_random_4
        case rand(4)
          when 0 then turn_down
          when 1 then turn_left
          when 2 then turn_right
          when 3 then turn_up
        end
      end

      def turn_random_6
        case rand(6)
          when 0 then turn_down
          when 1 then turn_upper_left
          when 2 then turn_upper_right
          when 3 then turn_lower_left
          when 4 then turn_lower_right
          when 5 then turn_up
        end
      end

      def turn_random_4_to_6
        case rand(4)
          when 0 then turn_down
          when 1
            case rand(2)
              when 0 then turn_upper_left(false)
              when 1 then turn_upper_right(false)
            end
          when 2
            case rand(2)
              when 0 then turn_lower_left(false)
              when 1 then turn_lower_right(false)
            end
          when 3 then turn_up(false)
        end
      end

      def turn_toward_player
        turn_toward_tile_6($game_player.x, $game_player.y)
      end

      def turn_toward_event(event_id)
        event = $game_map.events[event_id]
        turn_toward_tile_6(event.x, event.y)
      end

      def turn_toward_tile_4(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0
        if sx.abs > sy.abs
          sx > 0 ? turn_left : turn_right
        else
          sy > 0 ? turn_up : turn_down
        end
      end

      def turn_toward_tile_6(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0
      if sy <= 0
          if sy.abs > (sx.abs * 1.5)
            turn_down
          else
            sx < 0 ? turn_lower_right : turn_lower_left
          end
        else
          if sy.abs > (sx.abs * 1.5)
            turn_up
          else
            sx < 0 ? turn_upper_right : turn_upper_left
          end
        end
      end

      def turn_away_from_player
        turn_away_from_tile_6($game_player.x, $game_player.y)
      end

      def turn_away_from_event(event_id)
        event = $game_map.events[event_id]
        turn_away_from_tile_6(event.x, event.y)
      end

      def turn_away_from_tile_4(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0
        if sx.abs > sy.abs
          sx > 0 ? turn_right : turn_left
        else
          sy > 0 ? turn_down : turn_up
        end
      end

      def turn_away_from_tile_6(x, y)
        sx = @x - x
        sy = @y - y
        return if sx == 0 and sy == 0
      if sy < 0
          if sy.abs > (sx.abs * 1.5)
            turn_up
          else
            sx < 0 ? turn_upper_left : turn_upper_right
          end
        else
          if sy.abs > (sx.abs * 1.5)
            turn_down
          else
            sx < 0 ? turn_lower_left : turn_lower_right
          end
        end
      end
    end

    class Game_Player < Game_Character

      CENTER_X = (640 / 2 - 32 / 2) * 4  # Center screen x-coordinate * 4
      CENTER_Y = (480 / 2 - 32 / 2) * 4  # Center screen y-coordinate * 4

      def center(x, y)
        max_x = ($game_map.width - 20) * 32 * 4
        max_y = ($game_map.height - 15) * 32 * 4
        $game_map.display_x = [0, [x * (32 - 8) * 4 - CENTER_X, max_x].min].max
        $game_map.display_y = [0, [y * 32 * 4 - CENTER_Y, max_y].min].max
      end

      def passable?(x, y, d)
        super
      end

      def check_event_trigger_there(triggers)
        result = false
        return result if $game_system.map_interpreter.running?
        y_correct = case @direction
        when 2 then 1
        when 12 then -1
        when 4, 6 then @x%2==1 ? 1 : 0
        when 8, 10 then @x%2==1 ? 0 : -1
        else; 0
        end
        x_correct = case @direction
        when 6, 10 then 1
        when 4, 8 then -1
        else; 0
        end
        new_x = @x + x_correct
        new_y = @y + y_correct
        for event in $game_map.events.values
          if event.x == new_x and event.y == new_y and
            triggers.include?(event.trigger)
            if not event.jumping? and not event.over_trigger?
              event.start
              result = true
            end
          end
        end
        if result == false
          if $game_map.counter?(new_x, new_y)
            for event in $game_map.events.values
              if event.x == new_x and event.y == new_y and
                triggers.include?(event.trigger)
                if not event.jumping? and not event.over_trigger?
                  event.start
                  result = true
                end
              end
            end
          end
        end
        return result
      end
    end

    class Sprite_Character < RPG::Sprite
      def update
        super
        if @tile_id != @character.tile_id or
          @character_name != @character.character_name or
          @character_hue != @character.character_hue
          @tile_id = @character.tile_id
          @character_name = @character.character_name
          @character_hue = @character.character_hue
          if @tile_id >= 384
            self.bitmap = RPG::Cache.tile($game_map.tileset_name,
              @tile_id, @character.character_hue)
            self.src_rect.set(0, 0, HEXA::WIDTH, HEXA::HEIGHT)
            self.ox = HEXA::WIDTH / 2
            self.oy = HEXA::HEIGHT
          else
            self.bitmap = RPG::Cache.character(@character.character_name,
              @character.character_hue)
            @cw = bitmap.width / 4
            @ch = bitmap.height / 6
            self.ox = @cw / 2
            self.oy = @ch
          end
        end
        self.visible = (not @character.transparent)
        if @tile_id == 0
          sx = @character.pattern * @cw
          dir_array = [1, 0, 2, 0, 3, 0, 4, 5]
          sy = (@character.direction - 2) / 2 * @ch # dir_array[@character.direction-1] * @ch
          self.src_rect.set(sx, sy, @cw, @ch)
        end
        self.x = @character.screen_x
        self.y = @character.screen_y
        self.z = @character.screen_z(@ch)
        self.opacity = @character.opacity
        self.blend_type = @character.blend_type
        self.bush_depth = @character.bush_depth(16)
        if @character.animation_id != 0
          animation = $data_animations[@character.animation_id]
          animation(animation, true)
          @character.animation_id = 0
        end
      end
    end
Bueno wec, ahi esta todo...despues veremos lo que falta que ahora voy directo a la cama XDDD
Saludos,
¥oukai
avatar
youkai
Soñador
Soñador

0/3

Créditos 280

Gracias : 10

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por Wecoc el 2013-08-17, 17:43

La verdad es que con esa reescritura de las direcciones te cargaste el tile_neighbors y el get_ring completamente así que habrá que volver a hacerlos.

Haciendo el tile_neighbors tal y como estaba antes pero con las nuevas direcciones queda un poco feo (muchos 0), y no quería usar hash porque es más lento si no me equivoco.

Código:
  def tile_neighbors(x, y, d=0)
    if x%2==1
      array = [0,[x,y-1],0,[x-1,y+1],0,[x+1,y+1],0,[x-1,y],0,[x+1,y],0,[x,y+1]]
    else
      array = [0,[x,y-1],0,[x-1,y],0,[x+1,y],0,[x-1,y-1],0,[x+1,y-1],0,[x,y+1]]
    end
    return d==0 ? array.reject {|x| x == 0} : array[d-1]
  end
Además el get_ring soy incapaz de rehacerlo de modo que lo lea bien como antes, así que hay que volver a hacerlo del todo.

¿Y en el x_correct = case @direction no faltan números en esos case ahora? Antes había tres direcciones a cada uno y ahora solo dos.

Hasta ahora me iba bien lo de la pasabilidad con X y con O y lo que me fallaba era la de direcciones, ahora me fallan las dos.

Me faltan un montón de gráficos Dirs por lo que no puedo probar el nuevo script...
Ah, y lo de las direcciones event_trigger que dije en el último post sigue fallando igual.

Vamos, que hay más bugs que antes. No se si es porque estamos avanzando, o porque estamos retrocediendo xD
avatar
Wecoc
Administrador
Administrador



Créditos 12211

Gracias : 632

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por youkai el 2013-08-21, 20:26

Bueno wec...ya tengo todo lo de mi script arreglado y bastante optimizado(aun quedan algunas cosillas por hacer) lo que tengo un pequeño problema el cual es la causa de no haber puesto las Dirs todavia(de todas formas las dirs las puedes hacer tu mismo si quieres, son solo flechitas XDDD)....no tengo internet!! T_T Espero que de aqui a 1 o 2 dias ya se solucione el problema pero por ahora nada...

Los problemas con el tile_neighbors y get_ring(que la verdad que no se para que existen...) se los dejo a ustedes...

En el x_correct antes habian mas numeros porque a parte de usar las direcciones diagonales tenia puesta tambien las laterales que no se usaban de nada. Ahora cambie las laterales por diagonales y ajuste todo quedando nada mas las 4 direcciones diagonales.

La pasabilidad con X y O en ese primer script que puse no sirve...lo tienes que modificar desde el juego. En la version que tengo lista ya puedes trabajar con X y O desde la BD.

El check_event_trigger_there te sigue dando problemas?? A mi la verdad que nunca me ha funcionado mal :S Mira a ver no hayas vuelto a hacer de las tuyas con mi script XDDDD

Eso es todo...cuando tenga recuperada la conexion termino lo que empece porque ahora tengo un pequeño tiempo de internet de casualidad bien lejos de mi casa XDDDDD
Saludos,
¥oukai
avatar
youkai
Soñador
Soñador

0/3

Créditos 280

Gracias : 10

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por youkai el 2013-08-24, 00:48

Disculpen de doble pero es por una causa justa...es para poner la actualizacion del script XDDDDD
Código:
#==============================================================================
# ** Scene_Title
#------------------------------------------------------------------------------
#  This class performs title screen processing.
#==============================================================================

class Scene_Title
  def main
    # If battle test
    if $BTEST
      battle_test
      return
    end
    # Load database
    $data_actors        = load_data("Data/Actors.rxdata")
    $data_classes      = load_data("Data/Classes.rxdata")
    $data_skills        = load_data("Data/Skills.rxdata")
    $data_items        = load_data("Data/Items.rxdata")
    $data_weapons      = load_data("Data/Weapons.rxdata")
    $data_armors        = load_data("Data/Armors.rxdata")
    $data_enemies      = load_data("Data/Enemies.rxdata")
    $data_troops        = load_data("Data/Troops.rxdata")
    $data_states        = load_data("Data/States.rxdata")
    $data_animations    = load_data("Data/Animations.rxdata")
    $data_tilesets      = load_data("Data/Tilesets.rxdata")
    $data_common_events = load_data("Data/CommonEvents.rxdata")
    $data_system        = load_data("Data/System.rxdata")
    if FileTest.exist?("Data/Passages.rxdata")
      if $DEBUG
        passages = load_data("Data/Passages.rxdata")
        $data_tilesets.each_index{|i|
        next if i == 0
        (384...$data_tilesets[i].passages.xsize).each {|d|
        if $data_tilesets[i].passages[d] & 0xc0 == 0xc0 && passages[i][d] & 0xc0 == 0
          passages[i][d] += 0xc0
          next
        elsif $data_tilesets[i].passages[d] & 0x40 == 0x40 && passages[i][d] & 0x40 == 0
          passages[i][d] += 0x40
          next
        elsif $data_tilesets[i].passages[d] & 0x80 == 0x80 && passages[i][d] & 0x80 == 0
          passages[i][d] += 0x80
          next
        end
        if $data_tilesets[i].passages[d] & 0xc0 == 0 && passages[i][d] & 0xc0 == 0xc0
          passages[i][d] -= 0xc0
          next
        elsif $data_tilesets[i].passages[d] & 0x40 == 0 && passages[i][d] & 0x40 == 0x40
          passages[i][d] -= 0x40
          next
        elsif $data_tilesets[i].passages[d] & 0x80 == 0 && passages[i][d] & 0x80 == 0x80
          passages[i][d] -= 0x80
          next
        end
        }
        $data_tilesets[i].passages = passages[i]}
        save_data(passages, "Data/Passages.rxdata")
      end
    else
      if $DEBUG
        passages = [nil]
        $data_tilesets.each{|tileset|
        next if tileset.nil?
        (384...tileset.passages.xsize).each {|d|
        if tileset.passages[d] & 0xc0 == 0xc0
          if tileset.passages[d] & 0x0f == 0x0f
            tileset.passages[d] = 0xc0 + 0x3f
          else
            tileset.passages[d] = 0xc0
          end
          next
        elsif tileset.passages[d] & 0x40 == 0x40
          if tileset.passages[d] & 0x0f == 0x0f
            tileset.passages[d] = 0x40 + 0x3f
          else
            tileset.passages[d] = 0x40
          end
          next
        elsif tileset.passages[d] & 0x80 == 0x80
          if tileset.passages[d] & 0x0f == 0x0f
            tileset.passages[d] = 0x80 + 0x3f
          else
            tileset.passages[d] = 0x80
          end
          next
        end
        tileset.passages[d] = 0}
        passages.push(tileset.passages)}
        save_data(passages, "Data/Passages.rxdata")
      end
    end
    unless $DEBUG
      passages = load_data("Data/Passages.rxdata")
      $data_tilesets.each_index{|i|
      next if i == 0
      $data_tilesets[i].passages = passages[i]}
    end
    # Make system object
    $game_system = Game_System.new
    # Make title graphic
    @sprite = Sprite.new
    @sprite.bitmap = RPG::Cache.title($data_system.title_name)
    # Make command window
    s1 = "New Game"
    s2 = "Continue"
    s3 = "Shutdown"
    @command_window = Window_Command.new(192, [s1, s2, s3])
    @command_window.back_opacity = 160
    @command_window.x = 320 - @command_window.width / 2
    @command_window.y = 288
    # Continue enabled determinant
    # Check if at least one save file exists
    # If enabled, make @continue_enabled true; if disabled, make it false
    @continue_enabled = false
    for i in 0..3
      if FileTest.exist?("Save#{i+1}.rxdata")
        @continue_enabled = true
      end
    end
    # If continue is enabled, move cursor to "Continue"
    # If disabled, display "Continue" text in gray
    if @continue_enabled
      @command_window.index = 1
    else
      @command_window.disable_item(1)
    end
    # Play title BGM
    $game_system.bgm_play($data_system.title_bgm)
    # Stop playing ME and BGS
    Audio.me_stop
    Audio.bgs_stop
    # Execute transition
    Graphics.transition
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Frame update
      update
      # Abort loop if screen is changed
      if $scene != self
        break
      end
    end
    # Prepare for transition
    Graphics.freeze
    # Dispose of command window
    @command_window.dispose
    # Dispose of title graphic
    @sprite.bitmap.dispose
    @sprite.dispose
  end
end

#==============================================================================
# ** Scene_Map
#------------------------------------------------------------------------------
#  This class performs map screen processing.
#==============================================================================
class Scene_Map
  alias hexapassage_map_update update
  def update
    hexapassage_map_update
    if $DEBUG and Input.press?(Input::F5)
      $scene = Tileset_Passage.new
    end
  end
end

class Tileset_Cursor < Window_Selectable
  attr_accessor :tileset_id
  def initialize
    super(344, 0, 296, 480)
    @index = 0
    @tileset_id = 1
    refresh
    self.back_opacity = 0
  end
 
  def refresh
    if self.contents != nil
      self.contents.clear
      @arrows.clear
    end
    bitmap = RPG::Cache.tileset($data_tilesets[@tileset_id].tileset_name)
    self.contents = @arrows = Bitmap.new(bitmap.width + 1, bitmap.height + 1)
    @item_max = (bitmap.width / 32) * (bitmap.height / 32)
    @column_max = bitmap.width / 32
    (@column_max + 1).times{|c|
    self.contents.fill_rect(c * 32, 0, 1, bitmap.height, Color.new(0,0,0))}
    (@item_max / @column_max + 1).times {|c|
    self.contents.fill_rect(0, c * 32, bitmap.width, 1, Color.new(0,0,0))}
    0.upto(@item_max) {|n|
    draw_passages(n)}
  end
 
  def draw_passages(n)
    dir_array = ["1", "2", "4", "8", "16", "32"]
    tileset_p = $data_tilesets[@tileset_id].passages[384+n]
    rect = Rect.new(0,0,32,32)
    if tileset_p == 0
      dir_array.each{|name|
      bitmap = Bitmap.new("Graphics/Dirs/" + name)
      @arrows.blt(n % @column_max * 32, n / @column_max * 32, bitmap, rect)}
      return
    end
    if tileset_p & 1 == 0
      bitmap = Bitmap.new("Graphics/Dirs/1")
      @arrows.blt(n % @column_max * 32, n / @column_max * 32, bitmap, rect)
    end
    if tileset_p & 2 == 0
      bitmap = Bitmap.new("Graphics/Dirs/2")
      @arrows.blt(n % @column_max * 32, n / @column_max * 32, bitmap, rect)
    end
    if tileset_p & 4 == 0
      bitmap = Bitmap.new("Graphics/Dirs/4")
      @arrows.blt(n % @column_max * 32, n / @column_max * 32, bitmap, rect)
    end
    if tileset_p & 8 == 0
      bitmap = Bitmap.new("Graphics/Dirs/8")
      @arrows.blt(n % @column_max * 32, n / @column_max * 32, bitmap, rect)
    end
    if tileset_p & 16 == 0
      bitmap = Bitmap.new("Graphics/Dirs/16")
      @arrows.blt(n % @column_max * 32, n / @column_max * 32, bitmap, rect)
    end
    if tileset_p & 32 == 0
      bitmap = Bitmap.new("Graphics/Dirs/32")
      @arrows.blt(n % @column_max * 32, n / @column_max * 32, bitmap, rect)
    end
  end
  #--------------------------------------------------------------------------
  # * Update Cursor Rectangle
  #--------------------------------------------------------------------------
  def update_cursor_rect
    # If cursor position is less than 0
    if @index < 0
      self.cursor_rect.empty
      return
    end
    # Get current row
    row = @index / @column_max
    # If current row is before top row
    if row < self.top_row
      # Scroll so that current row becomes top row
      self.top_row = row
    end
    # If current row is more to back than back row
    if row > self.top_row + (self.page_row_max - 1)
      # Scroll so that current row becomes back row
      self.top_row = row - (self.page_row_max - 1)
    end
    # Calculate cursor width
    cursor_width = 32
    # Calculate cursor coordinates
    x = @index % @column_max * 32
    y = @index / @column_max * 32 - self.oy
    # Update cursor rectangle
    self.cursor_rect.set(x, y, cursor_width, 32)
  end
end

class Window_Tuto < Window_Base
  def initialize
    super(0, 0, 344, 480)
    self.contents = Bitmap.new(width - 32, height - 32)
    refresh
  end
 
  def refresh
    self.contents.clear
    y = 36
    self.contents.draw_text(4, 4, 344, 32, "C: Selecciona tile a modificar")
    self.contents.draw_text(4, y, 344, 32, "QWEASD: Direcciones a modificar")
    self.contents.draw_text(4, y*2, 344, 32, "Ctrl: Pagina anterior")
    self.contents.draw_text(4, y*3, 344, 32, "Alt: Pagina siguiente")
    self.contents.draw_text(4, y*4, 320, 32, "X: Salir|Bloquear paso|Desbloquear paso")
  end
end

class Tileset_Passage
  def main
    @dummy_window = Window_Base.new(344, 0, 296, 480)
    @dummy_window.z = -2000
    @intruction_window = Window_Tuto.new
    @tileset_cursor = Tileset_Cursor.new
    bitmap = RPG::Cache.tileset($data_tilesets[@tileset_cursor.tileset_id].tileset_name)
    @tileset_sprite = Sprite.new
    @tileset_sprite.bitmap = bitmap
    @tileset_sprite.x += 360
    @tileset_sprite.y += 16
    @tileset_passages = $data_tilesets[@tileset_cursor.tileset_id].passages
    # Execute transition
    Graphics.transition
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Frame update
      update
      # Abort loop if screen is changed
      if $scene != self
        break
      end
    end
    # Prepare for transition
    Graphics.freeze
    # Dispose of command window
    @tileset_cursor.dispose
    @dummy_window.dispose
    @intruction_window.dispose
    # Dispose of title graphic
    @tileset_sprite.bitmap.dispose
    @tileset_sprite.dispose
  end
 
  def update
    @tileset_cursor.update
    @tileset_sprite.oy = @tileset_cursor.oy
    if Input.trigger?(Input::ALT) && @tileset_cursor.active
      @tileset_cursor.tileset_id += 1
      if $data_tilesets[@tileset_cursor.tileset_id].nil?
        @tileset_cursor.tileset_id = 1
      end
      @tileset_passages = $data_tilesets[@tileset_cursor.tileset_id].passages
      bitmap = RPG::Cache.tileset($data_tilesets[@tileset_cursor.tileset_id].tileset_name)
      @tileset_sprite.bitmap = bitmap
      @tileset_sprite.oy = @tileset_cursor.oy = 0
      @tileset_cursor.refresh
      return
    elsif Input.trigger?(Input::CTRL) && @tileset_cursor.active
      @tileset_cursor.tileset_id -= 1
      if $data_tilesets[@tileset_cursor.tileset_id].nil?
        @tileset_cursor.tileset_id = $data_tilesets.size - 1
      end
      @tileset_passages = $data_tilesets[@tileset_cursor.tileset_id].passages
      bitmap = RPG::Cache.tileset($data_tilesets[@tileset_cursor.tileset_id].tileset_name)
      @tileset_sprite.bitmap = bitmap
      @tileset_sprite.oy = @tileset_cursor.oy = 0
      @tileset_cursor.refresh
      return
    elsif Input.trigger?(Input::B) && @tileset_cursor.active
      passages = [nil]
      $data_tilesets.each{|tile|
      next if tile.nil?
      passages.push(tile.passages)}
      save_data(passages, "Data/Passages.rxdata")
      $scene = Scene_Map.new
      return
    elsif Input.trigger?(Input::C) && @tileset_cursor.active
      @tileset_cursor.active = false
      return
    end
    if !@tileset_cursor.active
      update_passage_selection
    end
  end
     
  def update_passage_selection
    if Input.trigger?(Input::C)
      @tileset_cursor.active = true
      return
    end
    if Input.trigger?(Input::B)
      @tileset_passages[384 + @tileset_cursor.index] =
      @tileset_passages[384 + @tileset_cursor.index] != 0x3f ? 0x3f : 0
      @tileset_cursor.refresh
    end
    case Input.dir6
    when 'E'
      if @tileset_passages[384 + @tileset_cursor.index] & 16 == 0
        @tileset_passages[384 + @tileset_cursor.index] += 16
      else
        @tileset_passages[384 + @tileset_cursor.index] -= 16
      end
      @tileset_cursor.refresh
    when 'W'
      if @tileset_passages[384 + @tileset_cursor.index] & 32 == 0
        @tileset_passages[384 + @tileset_cursor.index] += 32
      else
        @tileset_passages[384 + @tileset_cursor.index] -= 32
      end
      @tileset_cursor.refresh
    when 'S'
      if @tileset_passages[384 + @tileset_cursor.index] & 1 == 0
        @tileset_passages[384 + @tileset_cursor.index] += 1
      else
        @tileset_passages[384 + @tileset_cursor.index] -= 1
      end
      @tileset_cursor.refresh
    when 'A'
      if @tileset_passages[384 + @tileset_cursor.index] & 2 == 0
        @tileset_passages[384 + @tileset_cursor.index] += 2
      else
        @tileset_passages[384 + @tileset_cursor.index] -= 2
      end
      @tileset_cursor.refresh
    when 'D'
      if @tileset_passages[384 + @tileset_cursor.index] & 4 == 0
        @tileset_passages[384 + @tileset_cursor.index] += 4
      else
        @tileset_passages[384 + @tileset_cursor.index] -= 4
      end
      @tileset_cursor.refresh
    when 'Q'
      if @tileset_passages[384 + @tileset_cursor.index] & 8 == 0
        @tileset_passages[384 + @tileset_cursor.index] += 8
      else
        @tileset_passages[384 + @tileset_cursor.index] -= 8
      end
      @tileset_cursor.refresh
    end
  end
end

class Game_Map
  def passable?(x, y, d, self_event = nil)
    # If coordinates given are outside of the map
    unless valid?(x, y)
      # impassable
      return false
    end
    # Change direction (0,2,4,6,8,10) to obstacle bit (0,1,2,4,8,0)
    bit = (1 << (d / 2 - 1)) & 0x3f
    # Loop in all events
    for event in events.values
      # If tiles other than self are consistent with coordinates
      if event.tile_id >= 0 and event != self_event and
        event.x == x and event.y == y and not event.through
        # If obstacle bit is set
        if @passages[event.tile_id] & bit != 0
          # impassable
          return false
        # If obstacle bit is set in all directions
        elsif @passages[event.tile_id] & 0x3f == 0x3f
          # impassable
          return false
        # If priorities other than that are 0
        elsif @priorities[event.tile_id] == 0
          # passable
          return true
        end
      end
    end
    # Loop searches in order from top of layer
    for i in [2, 1, 0]
      # Get tile ID
      tile_id = data[x, y, i]
      # Tile ID acquistion failure
      if tile_id == nil
        # impassable
        return false
      # If obstacle bit is set
      elsif @passages[tile_id] & bit != 0
        # impassable
        return false
      # If obstacle bit is set in all directions
      elsif @passages[tile_id] & 0x3f == 0x3f
        # impassable
        return false
      # If priorities other than that are 0
      elsif @priorities[tile_id] == 0
        # passable
        return true
      end
    end
    # passable
    return true
  end
end
La verdad no trae ninguna caracteristica nueva...lo que hice fue corregir bugs solamente...
Y aqui estan las famosas dirs XDDDDD
Dirs
Bueno...seguire intentado cosas a ver en que resultan XD
Saludos,
¥oukai
avatar
youkai
Soñador
Soñador

0/3

Créditos 280

Gracias : 10

Volver arriba Ir abajo

RPG Maker XP Re: [Colectivo] Hextiles (para XP)

Mensaje por Contenido patrocinado


Contenido patrocinado


Volver arriba Ir abajo

Página 1 de 2. 1, 2  Siguiente

Ver el tema anterior Ver el tema siguiente Volver arriba


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