¡Bienvenid@ a Mundo Maker!

¿Quieres aprender todo sobre el RPG Maker?



Regístrate y forma parte de Mundo Maker.
Conectarse

Recuperar mi contraseña

Temas importantes
----------------------------------------
Páginas con recursos RPG Maker
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
Últimos temas
» Tutorial Interactivo [Uso de interruptores]
por Ledai Hoy a las 16:58

» Necesito Script
por Elian84 Hoy a las 04:44

» Holaaa a tod@s!!!
por chronoMxx Hoy a las 03:41

» [AYUDA]Hootshot de moghunter
por Rudy_kinneas Hoy a las 01:06

» El poder oculto (Segunda entrega)
por alex1633 Ayer a las 23:18

» Hola mucho gusto
por Hk Diamond Ayer a las 13:49

» SoraDeathss se presenta!
por chronoMxx Ayer a las 07:50

» {AYUDA}Blizz-ABS Script
por chronoMxx Ayer a las 06:45

» las cosas como son...
por Bleuw Ayer a las 04:18

» Busco artistas graficos para proyecto serio
por Rudy_kinneas 2016-12-02, 20:52

Afiliados
Estadísticas
Tenemos 3381 miembros registrados.
El último usuario registrado es Hk Diamond.

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

Puzzle deslizable

 :: RPG Maker :: Scripts

Ver el tema anterior Ver el tema siguiente Ir abajo

Puzzle deslizable

Mensaje por Metalero el 2011-02-06, 03:43

Bueno, makeros y makeras, estos dias se me dio por hacer un remake (muy mejorado) de un viejo script que habia posteado aca hace mucho (los users mas viejos deben recordarlo).
En principio iba a ser un retoque, pero bueno, termine rehaciendo todo el codigo por completo XD

El script es un minijuego del conocido Puzzle deslizable (ese que le falta una pieza, la cual deja un espacio para poder deslizar y ordenar las restantes).

Propiedades:
* Una de las grandes mejoras respecto al script anterior, es que a diferencia de este, uno solo carga la imagen enteria y el script se encarga de recortarlo (antes habia que hacer manualmente los recortes)
* A raiz de lo anterior se puede, con la misma imagen, hacer diferentes puzzles, cambiando la cantidad de filas y columnas
* No necesita ser cuadrado, es decir 3 x 3, 4 x4, si no que pueden ser puzzles rectangulares.
* Es extremadamente facil de setear y usar
* Requiere un minimo de 3 imagenes (imagen principal, fondo, cursor) y 1 cancion (musica de fondo)
* Cuando el puzzle es resuelto se ejecuta una cancion de victoria y una serie de flashes bastante esteticos y genericos (no queria hacer nada raro ni complicado, si no algo que mas o menos le guste a todos)
* Cuando el puzzle es resuelto, una switch se pone en TRUE

Instrucciones:
* Pegar el script sobre main
* Para llamarlo, hacer una llamada de script mediante evento con la siguiente linea:
Código:

$scene = Scene_Puzzle.new(Image_Filename,  Background_Filename, Background_Music, Rows, Columns)
* Donde:
---Image_Filename : nombre de la imagen principal
---Background_Filename : nombre de la imagen de fondo
---Background_Music : nombre de la musica de fondo
---Rows : numero de filas del puzzle
---Columns : numero de columnas del puzzle

(NOTA: las imagenes deben estar en una carpeta llamada Puzzles, dentro de la carpeta Pictures ( Graphics\Pictures\Puzzles ) )

Ej :
Código:

$scene = Scene_Puzzle.new("HeroeCaido", "Fondo", "002-Battle02", 3, 3)

* Dentro de dicha carpte (Puzzles) debe haber una imagen llamada "Pointer", que sera el "Puntero" o "Cursor" que manejamos para resolver el puzzle
Este cursor, es un cuadrado, que se ajusta al tamaño de las piezas automaticamente (es decir, no esta hecho para que pongan una manito, o una flechita)

* Para cambiar cosas que son fijas van a las lineas que dicen:
Código:

    @move_sound = "064-Swing03"
    @no_move_sound = "004-System04"
    @switch_id = 19

--- @move_sound = sonido que se ejecuta al mover las piezas
--- @no_move_sound = sonido que se ejecuta al tratar de mover una pieza que no puede moverse
--- @switch_id = id del switch que se pone en TRUE cuando se resuelve el puzzle
(NOTA: al iniciar el puzzle, este switch se pone automaticamente en FALSE)

* Disfrutar

Screen: (Yo no puedo verla en el foro, pero desde la pagina donde esta alojada la veo perfecto)
Spoiler:

_Script_:
Spoiler:

Código:

#-------------------------------------------------------------------------------
#Dissplacement Puzzle Game
#Ropecabezas De Desplazamiento
#-------------------------------------------------------------------------------
#Made By Juan (Metalero) Leiva
#Hecho Por Juan (Metalero) Leiva
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------

#-------------------------------------------------------------------------------
# * Main Puzzle Scene
#-------------------------------------------------------------------------------

class Scene_Puzzle
  #-----------------------------------------------------------------------------
  # * Initialize
  #-----------------------------------------------------------------------------
  def initialize(image_name, bimage_name,background_music, rows, columns, ox = -1, oy = -1)
   
    fade = Plane.new(Viewport.new(0, 0, 640, 480))
    fade.bitmap = Bitmap.new(640, 480)
    fade.bitmap.fill_rect(0, 0, 640, 480, Color.new(0, 0, 0, 255))
    Graphics.update
   
    @background = Sprite.new
    @background.bitmap = RPG::Cache.picture("Puzzles/" + bimage_name)
   

    image = RPG::Cache.picture("Puzzles/" + image_name)

    @pieces = []
   
    for i in 0...rows*columns
      piece = Piece.new(image, rows, columns, i, ox, oy)
      @pieces.push(piece)
    end
   
    @pieces[rows*columns-1].visible = false
    @pieces[rows*columns-1].active = false
   
    @pointer = Pointer.new(@pieces[0].x - 1, @pieces[0].y - 1,
                          (image.width.to_f / columns + 2),
                          (image.height.to_f / rows + 2),
                          rows, columns)
    @pointer.visible = false                     
                         
   
   
    @rows = rows
    @columns = columns
   
    @background_music = background_music
   
    image.dispose
   
    Audio.bgm_play("Audio/BGM/" + @background_music)
    Audio.me_play("Audio/ME/009-Fanfare03")
    Audio.me_stop
   
   
    fade.bitmap.dispose
    fade.dispose
  end
 
  #-----------------------------------------------------------------------------
  # * main
  #-----------------------------------------------------------------------------
  def main
    @phase = 0
    @disorder_count = 0
    @disorder_times = @rows * @columns * 10#@rows ** 2 + @columns ** 2
   
    @void_piece = [@columns - 1, @rows - 1]
    @last_disorder_dir = -1
   
    @move_sound = "064-Swing03"
    @no_move_sound = "004-System04"
    @switch_id = 19
   
    @fade = Plane.new(Viewport.new(0, 0, 640, 480))
    @fade.bitmap = Bitmap.new(640, 480)
    @fade.bitmap.fill_rect(0, 0, 640, 480, Color.new(255, 255, 220, 0))
    @fade_op = 0
   
    $game_switches[@switch_id] = false
    @accommodated = false
 
   
    Graphics.transition
    loop do
      Graphics.update
      Input.update
      update
      if $scene != self
        break
      end
    end
    Graphics.freeze
   
    @background.bitmap.dispose
    @background.dispose
   
    @pointer.bitmap.dispose
    @pointer.dispose
   
     
    for piece in @pieces
      piece.bitmap.dispose
      piece.dispose
    end
   
    @fade.bitmap.dispose
    @fade.dispose
    Audio.bgm_stop
  end
 
  #-----------------------------------------------------------------------------
  # * update
  #-----------------------------------------------------------------------------
  def update
    if Input.trigger?(Input::B)
      $scene = Scene_Map.new
    end
     
    for piece in @pieces
      if @phase == 0
        piece.fast_update
      else
        piece.update
      end
    end
    @pointer.update
   
    for piece in @pieces
      if piece.is_moving
        return
      end
    end
   
    if @pointer.is_moving
      return
    end
   
    case @phase
    when 0
      disorder
      @disorder_count += 1
      if @disorder_count >= @disorder_times
        @phase += 1
        @pointer.visible = true
      end
    when 1
      #move cursor
      if Input.repeat?(Input::RIGHT)
        px = @pointer.index[0]
        py = @pointer.index[1]
        px += 1
        px %= @columns
       
        @pointer.index = [px, py]
      end
      if Input.repeat?(Input::LEFT)
        px = @pointer.index[0]
        py = @pointer.index[1]
        px += @columns - 1
        px %= @columns
        @pointer.index = [px, py]
      end
      if Input.repeat?(Input::DOWN)
        px = @pointer.index[0]
        py = @pointer.index[1]
        py += 1
        py %= @rows
        @pointer.index = [px, py]
      end
      if Input.repeat?(Input::UP)
        px = @pointer.index[0]
        py = @pointer.index[1]
        py += @rows - 1
        py %= @rows
        @pointer.index = [px, py]
      end
     
      #move piece
      if Input.trigger?(Input::C)
        if !move(@pointer.index)
          Audio.se_play("Audio/SE/" + @no_move_sound, 70)
        end
      end
     
      #Win?
      win_count = 0
      for piece in @pieces
        win_count += piece.correct_position? == true ? 1 : 0
      end
      if win_count >= @pieces.size
        @phase += 1
        @pointer.visible = false
        Audio.bgm_stop
        Audio.me_play("Audio/ME/009-Fanfare03")
       
       
      end
      when 2
        for piece in @pieces
          piece.accommodate
        end
        @pieces[@rows*@columns-1].visible = true
        $game_switches[@switch_id] = true
        p @switch_id
        p $game_switches[@switch_id]
        @phase += 1
      when 3
        @fade_op += 5
        @fade.bitmap.fill_rect(0, 0, 640, 480, Color.new(255, 255, 255, @fade_op))
        if @fade_op >= 255
          @fade_op = 255
          @phase += 1
        end
      when 4
        @fade_op -= 5
        @fade.bitmap.fill_rect(0, 0, 640, 480, Color.new(@fade_op, @fade_op, @fade_op, 255))
        if @fade_op < 0
          @fade_op = 0
          $scene = Scene_Map.new
        end
    end
   
  end
 
  #-----------------------------------------------------------------------------
  # * disorder
  #-----------------------------------------------------------------------------
  def disorder

    result = false
   
    while !result
      dir = rand(4)
      if dir == (@last_disorder_dir + 2) % 4
        next
      end
     
      @last_disorder_dir = dir
     
      case  dir
      when 0 #right
        x = @void_piece[0] + 1
        y = @void_piece[1]
        if move([x, y])
          result = true
          break
        end

      when 2 #left
        x = @void_piece[0] - 1
        y = @void_piece[1]
        if move([x, y])
          result = true
          break
        end
       
      when 1 #down
        x = @void_piece[0]
        y = @void_piece[1] + 1
        if move([x, y])
          result = true
          break
        end
       
      when 3 #up
        x = @void_piece[0]
        y = @void_piece[1] - 1
        if move([x, y])
          result = true
          break
        end
       
      end
    end


  end
  #-----------------------------------------------------------------------------
  # * move piece
  #-----------------------------------------------------------------------------
  def move(index)

    return false if index[0] < 0
    return false if index[0] >= @columns
    return false if index[1] < 0
    return false if index[1] >= @rows
    return false if (index[0] - @void_piece[0]).abs + (index[1] - @void_piece[1]).abs > 1

   
    for piece in @pieces
      if piece.index == index
        piece.index = @void_piece
        @void_piece = index
        Audio.se_play("Audio/SE/" + @move_sound, 70, 150 - rand(100))
        return true
      end
    end
   
    return false
  end
  #-----------------------------------------------------------------------------
end

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

#-------------------------------------------------------------------------------
# * Puzzle Object
#-----------------------------------------------------------------------------
class Puzzle_Object < Sprite
  attr_reader :index
  attr_accessor :is_moving
  attr_accessor :active
  #-----------------------------------------------------------------------------
  # * Initialize
  #-----------------------------------------------------------------------------
  def initialize
    super
 
    @index = [-1, -1]

    @init_x = -1
    @init_y = -1
    @width = -1
    @height = -1
    @speed = -1
    @current_speed_x = 0
    @current_speed_y = 0
       
    @is_moving = false
    @rows = -1
    @columns = -1
   
    @active = true
  end
 
  #-----------------------------------------------------------------------------
  # * update
  #-----------------------------------------------------------------------------
  def update
   
    if !@is_moving or !@active
      return
    end
   
     
    #Move Right
    if self.x < virtual_pos[0]
      self.x += (@width / (8 / @speed)) * @current_speed_x
    end
   
    #Move Left
    if self.x > virtual_pos[0]
      self.x -= (@width / (8 / @speed)) * @current_speed_x
    end
   
    #Move Down
    if self.y < virtual_pos[1]
      self.y += (@height / (8 / @speed)) * @current_speed_y

    end
   
    #Move Left
    if self.y > virtual_pos[1]
      self.y -= (@height / (8 / @speed)) * @current_speed_y
    end
   
    #Correct Pos
    if (self.x - virtual_pos[0]).abs <  @width / (8 / @speed)
      self.x = virtual_pos[0]
    end
   
    if (self.y - virtual_pos[1]).abs <  @height / (8 / @speed)
      self.y = virtual_pos[1]
    end
   
    if self.x == virtual_pos[0] && self.y == virtual_pos[1]
      @is_moving = false
    end
   
  end
  #-----------------------------------------------------------------------------
  # * Fast update
  #-----------------------------------------------------------------------------
  def fast_update
   
    if !@is_moving or !@active
      return
    end
   
     
    #Move Right
    if self.x < virtual_pos[0]
      self.x += @width
    end
   
    #Move Left
    if self.x > virtual_pos[0]
      self.x -= @width
    end
   
    #Move Down
    if self.y < virtual_pos[1]
      self.y += @height

    end
   
    #Move Left
    if self.y > virtual_pos[1]
      self.y -= @height
    end
   
    #Correct Pos
    if (self.x - virtual_pos[0]).abs <  @width / (8 / @speed)
      self.x = virtual_pos[0]
    end
   
    if (self.y - virtual_pos[1]).abs <  @height / (8 / @speed)
      self.y = virtual_pos[1]
    end
   
    if self.x == virtual_pos[0] && self.y == virtual_pos[1]
      @is_moving = false
    end
   
  end
  #-----------------------------------------------------------------------------
  # * Index
  #----------------------------------------------------------------------------- 
  def index=(id)
    if @is_moving or !@active
      return
    end
   
    @is_moving = true
    @index = id
   
    @current_speed_x = (self.x - virtual_pos[0]).abs / @width
    @current_speed_y = (self.y - virtual_pos[1]).abs / @height
  end
  #-----------------------------------------------------------------------------
  # * virtual_pos
  #-----------------------------------------------------------------------------
  def virtual_pos
    x = @init_x + @index[0] * @width.to_i
    y = @init_y + @index[1] * @height.to_i

    return [x.to_i,y.to_i]
  end
  #-----------------------------------------------------------------------------
end

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

#-------------------------------------------------------------------------------
# * Piece Class
#-------------------------------------------------------------------------------

class Piece < Puzzle_Object
  #-----------------------------------------------------------------------------
  # * Initialize
  #-----------------------------------------------------------------------------
  def initialize(bitmap, rows, columns, index, ox, oy)
    super()
   
    width = bitmap.width / columns
    height = bitmap.height / rows
   
    xid = index % columns
    yid = index / columns
   
    self.bitmap = Bitmap.new(width, height)
    self.bitmap.blt(0, 0, bitmap, Rect.new(xid*width, yid*height, width, height))
   
    @index = [xid, yid]
   
    @real_index = @index
   
    if ox == -1
      self.x = (640 - ((width + 2) * columns)) / 2 + (width + 2) * xid
      @init_x = (640 - ((width + 2) * columns)) / 2
    else
      @init_x = ox
      self.x = (width + 2) * xid + ox
    end
   
    if oy == -1
      self.y = (480 - ((height + 2) * rows)) / 2 + (height + 2) * yid
      @init_y = (480 - ((height + 2) * rows)) / 2
    else
      @init_y = oy
      self.y = (height + 2) * yid + oy
    end
   
    @width = width+2
    @height = height+2
   
    @speed = 4
    @current_speed = @speed
   
    @is_moving = false
    @rows = rows
    @columns = columns
   
    @original_index = @index.dup
   
    @real_position_x = self.x + 2.0 * (((@columns.to_f - 1 ) / 2.0) - xid)
    @real_position_y = self.y + 2.0 * (((@rows.to_f - 1 ) / 2.0) - yid)
  end
 
  def correct_position?
    if @index == @original_index
      return true
    end
    return false
  end 
 
  def accommodate
    self.x = @real_position_x
    self.y = @real_position_y
  end
end

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

 
#-----------------------------------------------------------------------------
# * Pointer Class
#-----------------------------------------------------------------------------
class Pointer < Puzzle_Object
  #-----------------------------------------------------------------------------
  # * Initialize
  #-----------------------------------------------------------------------------
  def initialize(x ,y ,w ,h, rows, columns)
    super()

    @init_x = x
    @init_y = y
   
    self.bitmap = Bitmap.new(w,h)
    self.bitmap = RPG::Cache.picture("Puzzles/Pointer")
   
   
    self.zoom_x = w / self.bitmap.width
    self.zoom_y = h / self.bitmap.height
   
    self.x = x
    self.y = y
   
    @width = w
    @height = h
   
    @speed = 2
    @current_speed = @speed
    @index = [0, 0]
       
    @is_moving = false
   
    @rows = rows
    @columns = columns
  end
end

Demo:

megaupload.com DA4PWNYP
(NOTA: despues de subirlo, me acrode que olvide de detener la musica de fondo, esta arreglado en el script, pero en el demo no)

Esucho criticas, opiniones y sugerencias.

PD: la primera vez que lo prueben, (a menos que sea un problema de mi Maker) tarda en cargar, de la misma forma que tarda en cargar cada vez el juego debe cargar un tema antes de reproducirlo. No se si ocurrira lo mimo con los formatos que soportan streaming, pero es una de las cosas me mas me molestan del maker.


Última edición por Metalero el 2011-02-06, 18:09, editado 1 vez

_________________

Metalero
Administrador
Administrador



Créditos 1715

Gracias : 98

Volver arriba Ir abajo

Re: Puzzle deslizable

Mensaje por Chronno el 2011-02-06, 04:19

Interesante, alguna rect por aqui otra rect por alla un par bitmaps y tenemos un puzzle rapido y con buena estetica.
me gusta.
Gran idea :D

Chronno
Soñador
Soñador

0/3

Créditos 158

Gracias : 2

Volver arriba Ir abajo

Re: Puzzle deslizable

Mensaje por Gitto el 2011-02-15, 01:51

puede que parezca tonta la pregunta pero ¿como hago apra que ocurra una cosa al terminar el puzzle correctamente?

Gitto
Iniciado
Iniciado

0/3

Créditos 4

Gracias : 2

Volver arriba Ir abajo

Re: Puzzle deslizable

Mensaje por Metalero el 2011-02-15, 19:50


* Cuando el puzzle es resuelto, una switch se pone en TRUE

La respuesta es tan facil como eso. El switch que hayas seteado, se pondra en TRUE si ganas el minijuego, luego desde el maker haces lo que queiras en base a ese switch.

_________________

Metalero
Administrador
Administrador



Créditos 1715

Gracias : 98

Volver arriba Ir abajo

Re: Puzzle deslizable

Mensaje por Contenido patrocinado Hoy a las 20:23


Contenido patrocinado


Volver arriba Ir abajo

Ver el tema anterior Ver el tema siguiente Volver arriba


 :: RPG Maker :: Scripts

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