¡Bienvenid@ a Mundo Maker!

¿Quieres aprender todo sobre el RPG Maker?



Regístrate y forma parte de Mundo Maker.
Conectarse

Recuperar mi contraseña

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

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

Como puedo hacer un RPG al estilo de los primeros Zelda?

 :: RPG Maker :: Ayuda RPG

Ver el tema anterior Ver el tema siguiente Ir abajo

RPG Maker VX ACE Como puedo hacer un RPG al estilo de los primeros Zelda?

Mensaje por Nog el 2017-01-19, 01:45

Hola amigos, este es mi primer tema en este foro, mi duda es la siguiente y les agradeceria si me pueden ayudar en esto:

Tengo algun tiempo utilizando RPG Maker Ace y he hecho pequeños proyectos con mis amigos, todos ellos de combates por turnos al estilo de los primeros Zelda, pero no tengo idea de como hacer esto y mi amigos tampoco, les agradeceria mucho si me pueden ayudar en algo, mandandome un tutorial o algo por el estilo.
Very Happy Very Happy
avatar
Nog
Iniciado
Iniciado

0/3

Créditos 1

Gracias : 2

Volver arriba Ir abajo

RPG Maker VX ACE Re: Como puedo hacer un RPG al estilo de los primeros Zelda?

Mensaje por Producciones The Golden el 2017-01-19, 02:08

Es un tema bastante complicado... no se puede solucionar en un comentario, busca tutoriales en internet, a continuación de daré las características de eso tipo de juegos:
1) Combates dinámicos/en tiempo real (como quieras decirle) y en mapa.
2) Uso de armas en mapa (obviamente).
3) Enemigos con distintas mecánicas como: movimiento aleatorio, seguimiento del personaje INTELIGENTE (no como el que trae el rpg maker por defecto), lanzamiento de objetos, rangos de visión, distintas faces y partes del cuerpo.
4) Cofres y objetos rompibles en tiempo real (como que abres un cofre en el mapa y de ahí mismo en el mapa sacas el objeto y de dice como se llama).
5) Movimiento por pixeles.
6) Interface con objetos equipados, vida, etc...

Después de todo esto obviamente queda más, te recomiendo jugar al primer Zelda de todos (Overworld) completo y luego The Binding of Isaac ya que es un muy buen juego que imita bastante bien las mecánicas.
De todo lo que dije antes sé hacerlo todo por engine menos lo del mov. por pixeles que necesitas un Script:
SCRIPT:


Código:

#==============================================================================
# Game_Player
#==============================================================================

class Game_Player < Game_Character
UP    = 0                
DOWN  = 0              
SIDE  = 0              
SLANT = false            
#--------------------------------------------------------------------------
attr_reader  :event    
attr_accessor :move_speed  
#--------------------------------------------------------------------------
def update

if @move_speed == nil
@move_speed = 4
end
  if @revise_x == nil and @revise_y == nil
@revise_x = 0
@revise_y = 0
end
if @move_route_forcing
last_moving = moving?
last_real_x = @real_x
last_real_y = @real_y
if (@revise_x != 0 or @revise_y != 0) and not jumping? and @move == true
  if @revise_x != @real_x - @x * 128 or @revise_y != @real_y - @y * 128
    @revise_x = @real_x - @x * 128
    @revise_y = @real_y - @y * 128
  end
  distance1 = 2 ** @move_speed
  distance2 = Math.sqrt(@revise_x ** 2 + @revise_y ** 2)
  if distance1 > distance2
    @real_x = @real_x - @revise_x
    @real_y = @real_y - @revise_y
    @revise_x = 0
    @revise_y = 0
    anime_update
  else
    @real_x -= (distance1 * @revise_x / distance2).round
    @real_y -= (distance1 * @revise_y / distance2).round
    @revise_x = @real_x - @x * 128
    @revise_y = @real_y - @y * 128
    anime_update
  end
else
  super
end
else
@move = false
unless moving? or $game_system.map_interpreter.running? or
        @move_route_forcing or $game_temp.message_window_showing
  @event_run = false
  case Input.dir8
  when 1
    move_lower_left_p
  when 2
    move_down_p
  when 3
    move_lower_right_p
  when 4
    move_left_p
  when 6
    move_right_p
  when 7
    move_upper_left_p
  when 8
    move_up_p
  when 9
    move_upper_right_p
  end
end
last_real_x = @real_x
last_real_y = @real_y
@real_x = @x * 128 + @revise_x
@real_y = @y * 128 + @revise_y
last_moving = moving?
move_on
if (last_real_x != @real_x or last_real_y != @real_y)
  anime_update
else
  @pattern = 0
end
end
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 == true
    if (last_real_x / 128.0).round != @x and
        (last_real_y / 128.0).round != @y
      if @direction == 2 or @direction == 8
        if (last_real_x / 128.0).round > @x
          p 1
          turn_left
        else
          p 2
          turn_right
        end
      else
        if (last_real_y / 128.0).round > @y
          p 3
          turn_up
        else
          p 4
          turn_down
        end
      end
    elsif (last_real_x / 128.0).round > @x
      turn_left
    elsif (last_real_x / 128.0).round < @x
      turn_right
    elsif (last_real_y / 128.0).round > @y
      turn_up
    elsif (last_real_y / 128.0).round < @y
      turn_down
    end
  end
  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
#--------------------------------------------------------------------------
def initialize
@revise_x = 0
@revise_y = 0
@move == false
super
end
#--------------------------------------------------------------------------
def moving?
if @move_route_forcing
if @move == false
  return false
end
super
else
return (@x != (@real_x / 128.0).round or @y != (@real_y / 128.0).round)
end
end
#--------------------------------------------------------------------------
def moving_a?
if @move == false
if (@move_route.list[@move_route_index].code <= 14 or
    @move_route.list[@move_route_index].code == 25)
  @move = true
end
return false
end
moving?
end
#--------------------------------------------------------------------------
def update_jump
@jump_count -= 1
@real_x = (@real_x * @jump_count + @x * 128) / (@jump_count + 1)
@real_y = (@real_y * @jump_count + @y * 128) / (@jump_count + 1)
if @jump_count == 0
@revise_x = 0
@revise_y = 0
end
end
#--------------------------------------------------------------------------
def move_type_custom
if jumping? or moving_a?
return
end
while @move_route_index < @move_route.list.size
command = @move_route.list[@move_route_index]
if command.code == 0
  if @move_route.repeat
    @move_route_index = 0
  end
  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
if command.code <= 14
  case command.code
  when 1
    move_down
  when 2
    move_left
  when 3
    move_right
  when 4
    move_up
  when 5
    move_lower_left
  when 6
    move_lower_right
  when 7
    move_upper_left
  when 8
    move_upper_right
  when 9
    move_random
  when 10
    move_toward_player
  when 11
    move_away_from_player
  when 12
    move_forward
  when 13
    move_backward
  when 14
    jump(command.parameters[0], command.parameters[1])
  end
  if not @move_route.skippable and not moving? and not jumping?
    return
  end
  @move_route_index += 1
  return
end
if command.code == 15
  @wait_count = command.parameters[0] * 2 - 1
  @move_route_index += 1
  return
end
if command.code >= 16 and command.code <= 26
  case command.code
  when 16
    turn_down
  when 17
    turn_left
  when 18
    turn_right
  when 19
    turn_up
  when 20
    turn_right_90
  when 21
    turn_left_90
  when 22
    turn_180
  when 23
    turn_right_or_left_90
  when 24
    turn_random
  when 25
    turn_toward_player
  when 26
    turn_away_from_player
  end
  @move_route_index += 1
  return
end
if command.code >= 27
  case command.code
  when 27
    $game_switches[command.parameters[0]] = true
    $game_map.need_refresh = true
  when 28
    $game_switches[command.parameters[0]] = false
    $game_map.need_refresh = true
  when 29
    @move_speed = command.parameters[0]
  when 30
    @move_frequency = command.parameters[0]
  when 31
    @walk_anime = true
  when 32
    @walk_anime = false
  when 33
    @step_anime = true
  when 34
    @step_anime = false
  when 35
    @direction_fix = true
  when 36
    @direction_fix = false
  when 37
    @through = true
  when 38
    @through = false
  when 39
    @always_on_top = true
  when 40
    @always_on_top = false
  when 41
    @tile_id = 0
    @character_name = command.parameters[0]
    @character_hue = command.parameters[1]
    if @original_direction != command.parameters[2]
      @direction = command.parameters[2]
      @original_direction = @direction
      @prelock_direction = 0
    end
    if @original_pattern != command.parameters[3]
      @pattern = command.parameters[3]
      @original_pattern = @pattern
    end
  when 42
    @opacity = command.parameters[0]
  when 43
    @blend_type = command.parameters[0]
  when 44
    $game_system.se_play(command.parameters[0])
  when 45
    result = eval(command.parameters[0])
  end
  @move_route_index += 1
  return
end
end
end
#--------------------------------------------------------------------------
def move_down_p
turn_down
distance = 2 ** @move_speed
down1(((@x * 128 + @revise_x) / 128.0).round,
    ((@y * 128 + @revise_y) / 128.0).round, distance, true)
end
#--------------------------------------------------------------------------
def down1(x, y, distance, down = false)
result = down2(x, y, distance)
if result == false
@event_run = check_event_trigger_touch(x, y+1)
return result
end
if @revise_x < -SIDE
result = down2(x, y + 1, distance, 4)
result &= down2(x - 1, y, distance)
if result == false
  if down
    move_lower_right_p
    if @revise_x > SIDE
      @revise_x = SIDE
    end
  end
  return result
end
elsif @revise_x > SIDE
result = down2(x, y + 1, distance, 6)
result &= down2(x + 1, y, distance)
if result == false
  if down
    move_lower_left_p
    if @revise_x < -SIDE
      @revise_x = -SIDE
    end
  end
  return result
end
end
@revise_y += distance
return result
end
#--------------------------------------------------------------------------
def down2(x, y, distance, d = 2)
if @revise_y + distance > DOWN
unless passable?(x, y, d)
  if @revise_y < DOWN
    @revise_y = DOWN
  end
  return false
end
end
return true
end
#--------------------------------------------------------------------------
def move_left_p
turn_left
distance = 2 ** @move_speed
left1(((@x * 128 + @revise_x) / 128.0).round,
    ((@y * 128 + @revise_y) / 128.0).round, distance, true)
end
#--------------------------------------------------------------------------
def left1(x, y, distance, left = false)
result = left2(x, y, distance)
if result == false
@event_run = check_event_trigger_touch(x-1, y)
return result
end
if @revise_y < -UP
result = left2(x - 1, y, distance, 8)
result &= left2(x, y - 1, distance)
if result == false
  if left
    move_lower_left_p
    if @revise_y > DOWN
      @revise_y = DOWN
    end
  end
  return result
end
elsif @revise_y > DOWN
result = left2(x - 1, y, distance, 2)
result &= left2(x, y + 1, distance)
if result == false
  if left
    move_upper_left_p
    if @revise_y < -UP
      @revise_y = -UP
    end
  end
  return result
end
end
@revise_x -= distance
return result
end
#--------------------------------------------------------------------------
def left2(x, y, distance, d = 4)
if @revise_x - distance < -SIDE
unless passable?(x, y, d)
  if @revise_x > -SIDE
    @revise_x = -SIDE
  end
  return false
end
end
return true
end
#--------------------------------------------------------------------------
def move_right_p
turn_right
distance = 2 ** @move_speed
right1(((@x * 128 + @revise_x) / 128.0).round,
      ((@y * 128 + @revise_y) / 128.0).round, distance, true)
end
#--------------------------------------------------------------------------
def right1(x, y, distance, right = false)
result = right2(x, y, distance)
if result == false
@event_run = check_event_trigger_touch(x+1, y)
return result
end
if @revise_y < -UP
result = right2(x + 1, y, distance, 8)
result &= right2(x, y - 1, distance)
if result == false
  if right
      move_lower_right_p
  if @revise_y > DOWN
      @revise_y = DOWN
    end
  end
  return result
end
elsif @revise_y > DOWN
result = right2(x + 1, y, distance, 2)
result &= right2(x, y + 1, distance)
if result == false
  if right
    move_upper_right_p
    if @revise_y < -UP
      @revise_y = -UP
    end
  end
  return result
end
end
@revise_x += distance
return result
end
#--------------------------------------------------------------------------
def right2(x, y, distance, d = 6)
if @revise_x + distance > SIDE
unless passable?(x, y, d)
  if @revise_x < SIDE
    @revise_x = SIDE
  end
  return false
end
end
return true
end
#--------------------------------------------------------------------------
def move_up_p
turn_up
distance = 2 ** @move_speed
up1(((@x * 128 + @revise_x) / 128.0).round,
  ((@y * 128 + @revise_y) / 128.0).round, distance, true)
end
#--------------------------------------------------------------------------
def up1(x, y, distance, up = false)
result = up2(x, y, distance)
if result == false
@event_run = check_event_trigger_touch(x, y-1)
return result
end
if @revise_x < -SIDE
result = up2(x, y - 1, distance, 4)
result &= up2(x - 1, y, distance)
if result == false
  if up
    move_upper_right_p
    if @revise_x > SIDE
      @revise_x = SIDE
    end
  end
  return result
end
elsif @revise_x > SIDE
result = up2(x, y - 1, distance, 6)
result &= up2(x + 1, y, distance)
if result == false
  if up
    move_upper_left_p
    if @revise_x < -SIDE
      @revise_x = -SIDE
    end
  end
  return result
end
end
@revise_y -= distance
return result
end
#--------------------------------------------------------------------------
def up2(x, y, distance, d = 8)
if @revise_y - distance < -UP
unless passable?(x, y, d)
  if @revise_y > -UP
    @revise_y = -UP
  end
  return false
end
end
return true
end
#--------------------------------------------------------------------------
def move_lower_left_p
unless @direction_fix
@direction = (@direction == 6 ? 4 : @direction == 8 ? 2 : @direction)
end
distance = (2 ** @move_speed) / Math.sqrt(2)
if @direction == 2
turn_left unless down1(((@x * 128 + @revise_x) / 128.0).round,
                        ((@y * 128 + @revise_y) / 128.0).round, distance)
turn_down if @event_run
unless @event_run
  if last_move?(@real_x, @real_y, 2, distance)
    result = check_event_trigger_here([1,2], false)
    if result == true
      return
    end
  end
  move_on
  if @revise_y > DOWN and -UP > @revise_y - distance
    @revise_y = DOWN
  end
  turn_down unless left1(((@x * 128 + @revise_x) / 128.0).round,
                        ((@y * 128 + @revise_y) / 128.0).round, distance)
  turn_left if @event_run
end
else
turn_down unless left1(((@x * 128 + @revise_x) / 128.0).round,
                        ((@y * 128 + @revise_y) / 128.0).round, distance)
turn_left if @event_run
unless @event_run
  if last_move?(@real_x, @real_y, 4, distance)
    result = check_event_trigger_here([1,2], false)
    if result == true
      return
    end
  end
  move_on
  if  @revise_x + distance> SIDE and -SIDE > @revise_x
    @revise_x = -SIDE
  end
  turn_left unless down1(((@x * 128 + @revise_x) / 128.0).round,
                        ((@y * 128 + @revise_y) / 128.0).round, distance)
  turn_down if @event_run
end
end
end
#--------------------------------------------------------------------------
def move_lower_right_p
unless @direction_fix
@direction = (@direction == 4 ? 6 : @direction == 8 ? 2 : @direction)
end
distance = (2 ** @move_speed) / Math.sqrt(2)
if @direction == 2
turn_right unless down1(((@x * 128 + @revise_x) / 128.0).round,
                        ((@y * 128 + @revise_y) / 128.0).round, distance)
turn_down if @event_run
unless @event_run
  if last_move?(@real_x, @real_y, 2, distance)
    result = check_event_trigger_here([1,2], false)
    if result == true
      return
    end
  end
  move_on
  if @revise_y > DOWN and -UP > @revise_y - distance
    @revise_y = DOWN
  end
  turn_down unless right1(((@x * 128 + @revise_x) / 128.0).round,
                          ((@y * 128 + @revise_y) / 128.0).round, distance)
  turn_right if @event_run
end
else
turn_down unless right1(((@x * 128 + @revise_x) / 128.0).round,
                        ((@y * 128 + @revise_y) / 128.0).round, distance)
turn_right if @event_run
unless @event_run
  if last_move?(@real_x, @real_y, 6, distance)
    result = check_event_trigger_here([1,2], false)
    if result == true
      return
    end
  end
  move_on
  if @revise_x > SIDE and -SIDE > @revise_x - distance
    @revise_x = SIDE
  end
  turn_right unless down1(((@x * 128 + @revise_x) / 128.0).round,
                        ((@y * 128 + @revise_y) / 128.0).round, distance)
  turn_down if @event_run
end
end
end
#--------------------------------------------------------------------------
def move_upper_left_p
unless @direction_fix
@direction = (@direction == 6 ? 4 : @direction == 2 ? 8 : @direction)
end
distance = (2 ** @move_speed) / Math.sqrt(2)
if @direction == 8
turn_left unless up1(((@x * 128 + @revise_x) / 128.0).round,
                      ((@y * 128 + @revise_y) / 128.0).round, distance)
turn_up if @event_run
unless @event_run
  if last_move?(@real_x, @real_y, 8, distance)
    result = check_event_trigger_here([1,2], false)
    if result == true
      return
    end
  end
  move_on
  if @revise_y + distance > DOWN and -UP > @revise_y
    @revise_y = -UP
  end
  turn_up unless left1(((@x * 128 + @revise_x) / 128.0).round,
                        ((@y * 128 + @revise_y) / 128.0).round, distance)
  turn_left if @event_run
end
else
turn_up unless left1(((@x * 128 + @revise_x) / 128.0).round,
                      ((@y * 128 + @revise_y) / 128.0).round, distance)
turn_left if @event_run
unless @event_run
  if last_move?(@real_x, @real_y, 4, distance)
    result = check_event_trigger_here([1,2], false)
    if result == true
      return
    end
  end
  move_on
  if @revise_x > SIDE and -SIDE > @revise_x - distance
    @revise_x = SIDE
  end
  turn_left unless up1(((@x * 128 + @revise_x) / 128.0).round,
                        ((@y * 128 + @revise_y) / 128.0).round, distance)
  turn_up if @event_run
end
end
end
#--------------------------------------------------------------------------
def move_upper_right_p
unless @direction_fix
@direction = (@direction == 4 ? 6 : @direction == 2 ? 8 : @direction)
end
distance = (2 ** @move_speed) / Math.sqrt(2)
if @direction == 8
turn_right unless up1(((@x * 128 + @revise_x) / 128.0).round,
                      ((@y * 128 + @revise_y) / 128.0).round, distance)
turn_up if @event_run
unless @event_run
  if last_move?(@real_x, @real_y, 8, distance)
    result = check_event_trigger_here([1,2], false)
    if result == true
      return
    end
  end
  move_on
  if @revise_y + distance > DOWN and -UP > @revise_y
    @revise_y = -UP
  end
  turn_up unless right1(((@x * 128 + @revise_x) / 128.0).round,
                        ((@y * 128 + @revise_y) / 128.0).round, distance)
  turn_right if @event_run
end
else
turn_up unless right1(((@x * 128 + @revise_x) / 128.0).round,
                      ((@y * 128 + @revise_y) / 128.0).round, distance)
turn_right if @event_run
unless @event_run
  if last_move?(@real_x, @real_y, 6, distance)
    result = check_event_trigger_here([1,2], false)
    if result == true
      return
    end
  end
  move_on
  if @revise_x > SIDE and -SIDE > @revise_x - distance
    @revise_x = SIDE
  end
  turn_right unless up1(((@x * 128 + @revise_x) / 128.0).round,
                        ((@y * 128 + @revise_y) / 128.0).round, distance)
  turn_up if @event_run
end
end
end
#--------------------------------------------------------------------------
def check_event_trigger_here(triggers, run = true)
result = false
if $game_system.map_interpreter.running?
return result
end
for event in $game_map.events.values
if event.x == ((@real_x - @revise_x) / 128.0).round and
    event.y == ((@real_y - @revise_y) / 128.0).round and
    triggers.include?(event.trigger)
  if not event.jumping? and event.over_trigger?
    if event.list.size > 1
      if run == true
        event.start
      end
      result = true
    end
  end
end
end
return result
end
#--------------------------------------------------------------------------
def move_on
if @y < (@y + @revise_y / 128.0).round
@y += 1
@revise_y -= 128
increase_steps
end
if @x > (@x + @revise_x / 128.0).round
@x -= 1
@revise_x += 128
increase_steps
end
if @x < (@x + @revise_x / 128.0).round
@x += 1
@revise_x -= 128
increase_steps
end
if @y > (@y + @revise_y / 128.0).round
@y -= 1
@revise_y += 128
increase_steps
end
end
#--------------------------------------------------------------------------
def anime_update
if @walk_anime
@anime_count += 1.5
elsif @step_anime
@anime_count += 1
end
if @anime_count > 18 - @move_speed = 3.5
if not @step_anime and @stop_count > 0
  @pattern = @original_pattern
else
  @pattern = (@pattern + 1) % 4
end
@anime_count = 0
end
end
#--------------------------------------------------------------------------
alias :moveto_original :moveto
def moveto(x, y)
@revise_x = 0
@revise_y = 0
moveto_original(x, y)
end
#--------------------------------------------------------------------------
def last_move?(x, y, direction, distance)
if direction == 2 or direction == 4
distance *= -1
end
if (direction == 2 or direction == 8) and
  (y / 128.0).round != ((y + distance) / 128.0).round
return true
end
if (direction == 4 or direction == 6) and
  (x / 128.0).round != ((x + distance) / 128.0).round
return true
end
return false
end
end

#==============================================================================
# Game_Character
#==============================================================================

class Game_Character
attr_accessor  :move_speed
#--------------------------------------------------------------------------
def update_move

distance = 2 ** @move_speed
if @x * 128 != @real_x and @y * 128 != @real_y and Game_Player::SLANT
distance /= Math.sqrt(2)
end
if @y * 128 > @real_y
@real_y = [@real_y + distance, @y * 128].min
end
if @x * 128 < @real_x
@real_x = [@real_x - distance, @x * 128].max
end
if @x * 128 > @real_x
@real_x = [@real_x + distance, @x * 128].min
end
if @y * 128 < @real_y
@real_y = [@real_y - distance, @y * 128].max
end
if @walk_anime
@anime_count += 1.5
elsif @step_anime
@anime_count += 1
end
end
end

#==============================================================================
# Game_Event
#==============================================================================

class Game_Event < Game_Character
#--------------------------------------------------------------------------
def start
if @list.size > 1
if $game_player.event != 0
  $game_player.move_speed = $game_player.event
end
@starting = true
end
end
end


Cualquier duda respecto a los engines estoy dispuesto a ayudarte, contácteme por MP.
Eso fue todo... hasta pronto!  Warrior
avatar
Producciones The Golden
Principiante
Principiante

0/3

Créditos 561

Gracias : 51

http://gamerprotown.jimdo.com/

Volver arriba Ir abajo

RPG Maker VX ACE Re: Como puedo hacer un RPG al estilo de los primeros Zelda?

Mensaje por xn1 el 2017-01-20, 01:46

Buscate engines ARPG en los foros. No se para Ace pero para XP, 2k3 y VX hay bastantes. Yo mismo hize un par para 2k3

http://www.mundo-maker.com/t12246-isla-troll-arpg-buscando-beta-testers

http://www.mundo-maker.com/t5462-engine-disparo-a-distancia-juego-corto

Poca tenia uno pero no me acuerdo para que RPG maker
http://www.mundo-maker.com/t3880-adobenchaa-system-arpg-engine-by-poka

Si trabajas en XP y no quieres hacerlo por engines puedes usar el script XAS HERO. Creo que alguien lo adapto al VX
https://rpgmaker.net/games/2517/

Leda tambien habia hecho uno pero para xp
http://www.mundo-maker.com/t9287-xp-arpg-leda

Creo que hay mas en la biblioteca de engines del foro pero me da peresa buscarlo.


avatar
xn1
Soñador
Soñador

0/3

Créditos 180

Gracias : 16

Volver arriba Ir abajo

RPG Maker VX ACE Re: Como puedo hacer un RPG al estilo de los primeros Zelda?

Mensaje por Contenido patrocinado


Contenido patrocinado


Volver arriba Ir abajo

Ver el tema anterior Ver el tema siguiente Volver arriba


 :: RPG Maker :: Ayuda RPG

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