Suporte ao desenvolvimento de jogos!


    Andar em 8 Direções

    Compartilhe
    avatar
    Devilzcore
    Ocasional
    Ocasional

    Mensagens : 213
    Créditos : 83

    Andar em 8 Direções

    Mensagem por Devilzcore em Seg Nov 15, 2010 12:25 pm

    Introdução:


    Script simples que permite ao personagem andar em 8 direções.

    Como Usar:


    É só colocar o script acima de Main.


    Script:

    Código:
    #movimento em 8 direções
    #Script criado por greon


    class Game_Player
    alias d_move_by_input move_by_input
    def move_by_input
        return unless movable?
        return if $game_map.interpreter.running?
        case Input.dir8
    when 1
    move_lower_left
    when 2
    move_down
    when 3
    move_lower_right
    when 4
    move_left
    when 6
    move_right
    when 7
    move_upper_left
    when 8
    move_up
    when 9
    move_upper_right
        end
      end
    end

    Creditos


    Greon

    Dinger Games
    Novato
    Novato

    Mensagens : 6
    Créditos : 1

    Re: Andar em 8 Direções

    Mensagem por Dinger Games em Qua Out 05, 2011 11:16 am

    não ta funcionando o script então achei um esse funciona mesmo

    Código:
    ################################################################################
    ################Passos por pixel.Deixe seu jogo mais realista!!!################
    ################################################################################
    ###############################BY.Iori Yagami###################################
    ################################################################################
    class Game_Player < Game_Character
    UP = 0
    SIDE = 0
    SLANT = true
    attr_reader :walk
    attr_reader :event
    attr_accessor :move_speed
    def initialize
    super
    @walk = 3 #Velocidade do char andando.
    @dash = 4 #Velocidade do char correndo.
    @event = 3 #Velocidade do char evento.
    @dot_m = true #Ativar passos por pixels
    @revise_x = 0 #Posição do Char X(não modifique)
    @revise_y = 0 #Posição do Char Y(não modifique)
    @move == true #Posicionamento automático.
    end
    alias :update_original :update
    def update
    unless moving? or $game_system.map_interpreter.running? or
    @move_route_forcing or $game_temp.message_window_showing
    if @walk != @dash
    if Input.press?(Input::C)
    if @move_speed != @dash
    @move_speed = @dash
    end
    else
    if @move_speed != @walk
    @move_speed = @walk
    end
    end
    end
    end
    if @revise_x == nil and @revise_y == nil
    @revise_x = 0
    @revise_y = 0
    end
    unless @dot_m
    update_original
    return
    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)
    @move_distance = 0 if @move_distance == nil
    @move_distance += Math.sqrt((last_real_x - @real_x) ** 2 +
    (last_real_y - @real_y) ** 2)
    if @move_distance >= 128
    @move_distance %= 128
    increase_steps
    end
    anime_update
    elsif @walk_anime
    @pattern = @original_pattern
    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
    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
    turn_left
    else
    turn_right
    end
    else
    if (last_real_y / 128.0).round > @y
    turn_up
    else
    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
    def moving?
    unless @dot_m
    result = super
    return result
    end
    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
    unless @dot_m
    super
    return
    end
    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 > 0
    unless passable?(x, y, d)
    if @revise_y < 0
    @revise_y = 0
    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 > 0
    @revise_y = 0
    end
    end
    return result
    end
    elsif @revise_y > 0
    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
    # ‰E‚ðŒü‚­
    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 > 0
    @revise_y = 0
    end
    end
    return result
    end
    elsif @revise_y > 0
    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 > 0 and -UP > @revise_y - distance
    @revise_y = 0
    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 > 0 and -UP > @revise_y - distance
    @revise_y = 0
    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 > 0 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 > 0 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 == ((@x * 128 + @revise_x) / 128.0).round and
    event.y == ((@y * 128 + @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
    end
    if @x > (@x + @revise_x / 128.0).round
    @x -= 1
    @revise_x += 128
    end
    if @x < (@x + @revise_x / 128.0).round
    @x += 1
    @revise_x -= 128
    end
    if @y > (@y + @revise_y / 128.0).round
    @y -= 1
    @revise_y += 128
    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 * 2
    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 == 6
    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
    class Game_Character
    def screen_x
    return ((@real_x - $game_map.display_x) / 4).ceil + 16
    end
    def screen_y
    y = ((@real_y - $game_map.display_y) / 4).ceil + 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 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
    class Game_Event < Game_Character
    def start
    if @list.size > 1
    if $game_player.event != 0
    $game_player.move_speed = $game_player.event
    elsif self.trigger == 0
    $game_player.move_speed = $game_player.walk
    end
    @starting = true
    end
    end
    end

      Data/hora atual: Seg Out 15, 2018 8:17 am