[RPG-MAKER.FR] Oniromancie: tout l'univers de RPG Maker en français - Les forums - [Scripts] Petites questions connes sur les SCRIPTS!!

def moveto(x,y) wait_frame = 0 loop do wait_frame += 1 Graphics.update SceneManager.scene.spriteset.update if @x < x @x += 1 @direction = 6 elsif @x > x @x -= 1 @direction = 4 end if @y < y @y += 1 @direction = 2 elsif @y > y @y -= 1 @direction = 8 end if x == @x and y == @y break end end end

def create_contents contents.dispose if contents_width > 0 && contents_height > 0 self.contents = Bitmap.new(contents_width, contents_height) else self.contents = Bitmap.new(1, 1) end end

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108

# Pathfinding par Samarium # Méthode "pathfinding" # xfinal : position X de l'arrivé # yfinal : position Y de l'arrivé # Retourne : un tableau de direction (2,4,6,8) ##### def pathfinding(xfinal, yfinal) x = @x y = @y @list_ouvert = {[x, y] => [nil, nil, nil]} calcul_distance_path(xfinal, yfinal, x, y) list_ferme = {[x, y] => [0, @dis_final, @somme_dis, 0]} @dir = [] id = 0 while not (x == xfinal and y == yfinal) # Si les positions ne sont pas valides. return [] if y == nil or x == nil id += 1 for i in 0...4 case i when 0 new_y = y-1 new_x = x when 1 new_y = y new_x = x+1 when 2 new_y = y+1 new_x = x when 3 new_y = y new_x = x-1 end if record_pos_path?([new_x, new_y]) calcul_distance_path(xfinal, yfinal, new_x, new_y) @list_ouvert[[new_x, new_y]] = [@dis_ini, @dis_final, @somme_dis, id] end end @list_ouvert[[x, y]] = [nil, nil, nil] min_dis_final = min_somme_dis = 200 new_value = new_pos = [] @list_ouvert.each do |key, value| if value[2] != nil if value[2] <= min_somme_dis and value[1] <= min_dis_final min_dis_final = value[1] min_somme_dis = value[2] new_value = value new_pos = key end end end list_ferme[new_pos] = new_value x = new_pos[0] y = new_pos[1] end min_dis_ini = 200 while min_dis_ini != 0 min_dis_ini = min_somme_dis = min_dis_id = 200 return [] if y == nil or x == nil for i in 0...4 case i when 0 new_y = y-1 new_x = x dir = 8 when 1 new_y = y new_x = x+1 dir = 4 when 2 new_y = y+1 new_x = x dir = 2 when 3 new_y = y new_x = x-1 dir = 6 end # case value = list_ferme[[new_x, new_y]] list_ferme[[x, y]] = nil if value != nil if value[3] < min_dis_id min_dis_id = value[3] min_dis_ini = value[0] n_dir = dir n_new_x = new_x n_new_y = new_y end # if end # if end # for x = n_new_x y = n_new_y @dir.push(n_dir) end # while return @dir.reverse! end # def def calcul_distance_path(xfinal, yfinal, x, y) @dis_final = (xfinal - x).abs + (yfinal - y).abs @dis_ini = (@x - x).abs + (@y - y).abs @somme_dis = @dis_final + @dis_ini end def record_pos_path?(tab_xy) return true if @tab_move.include?(tab_xy) and not @list_ouvert.include?(tab_xy) return false end

Question 1 :
Ah, tu la veux à gauche ta flèche, tu fais self.ox = blabla

Question 2 :
J'avais fais ça pour mon A-RPG, pour moi il fonctionne très bien, après sur projet vièrge je ne garantis rien.
Il te renvoie un Move_Route (regarde la méthode make_move_route)

class Node
  
  attr_reader   :parent, :x, :y
  attr_accessor :good, :passage, :distance
  
  def initialize(parent, x, y, distance = nil)
    @parent, @x, @y = parent, x, y
    @good = true
    @passage = false
    @distance = distance
  end
  
  def pos?(x, y)
    return (@x == x and @y == y)
  end
  
end
 
class Goal
  
  attr_reader   :x, :y
  
  def initialize(x, y)
    @x, @y = x, y
  end
  
end
 
module Pathfinding
  
  def self.start(event_id, x, y, zone = 0, skippable = false)
    if event_id == 0
      @event = $game_player
    else
      return unless $game_map.events[event_id]
      @event = $game_map.events[event_id]
    end
    @goal = Goal.new(x, y)
    @path = [Node.new(nil, @event.x, @event.y, self.distance(@goal))]
    @move_route = RPG::MoveRoute.new
    @move_route.repeat = false
    @move_route.path = true
    @move_route.x = x
    @move_route.y = y
    @move_route.zone = zone
    @move_route.skippable = skippable
    @zone = zone
    self.make_path
  end
  
  def self.make_path
    begin
    @current_node = @path[0]
    if @current_node.pos?(@goal.x, @goal.y) or 
       (self.passable?(@goal.x, @goal.y) == false and @zone == 0)
      return
    end
    
    loop do
      break if @current_node.pos?(@goal.x, @goal.y)
      if @zone > 0
        break if @current_node.distance <= @zone
      end
      adjacent_nodes = get_adjacent_nodes
      if adjacent_nodes == [nil, nil, nil, nil]
        # retour en arrièrre
        @current_node.good = false
        @current_node = @current_node.parent
      else
        adjacent_nodes.compact!
        nearest = self.node_nearest(adjacent_nodes)
        @path.push(nearest)
        @current_node.passage = true
        @current_node = nearest
      end
    end # fin loop
    rescue
      # passage introuvable
      #print "passage introuvable"
      return
    end
    self.erase_useless_node
  end
  
  def self.erase_useless_node
    # Effacer des nodes mauvais
    for i in 0 ... @path.size-1
      if @path[i].good == false
        @path[i] = nil
      end
    end
    @path.compact!
    # Effacer les nodes qui ralongent le chemin
    for i in 0 ... @path.size-1
      node = @path[i]
      next if node == nil
      nodes = self.find_adjacent_node(node.x, node.y)
      nodes.compact!
      for i in 0 ... nodes.size
        if node.parent == nodes[i] or nodes[i].parent == node
          nodes[i] = nil
        end
      end
      nodes.compact!
      node2 = node_nearest(nodes)
      if node2
        self.erase_to(node,node2)
      end
    end
    @path.compact!
    self.make_move_route
  end
    
  def self.make_move_route
    @move_route.list = []
    for i in 0 ... @path.size-1
      node = @path[i]
      next_node = @path[i+1]
      sx = node.x - next_node.x
      sy = node.y - next_node.y
      if sx == 1 # bas
        @move_route.list.push(RPG::MoveCommand.new(2))
      elsif sx == -1 # gauche
        @move_route.list.push(RPG::MoveCommand.new(3))
      elsif sy == 1 # droite
        @move_route.list.push(RPG::MoveCommand.new(4))
      elsif sy == -1 # haut
        @move_route.list.push(RPG::MoveCommand.new(1))
      end
    end
    @move_route.list.delete_at(0)
    @move_route.list.push(RPG::MoveCommand.new(0))
    @event.force_move_route(@move_route)
  end
 
  def self.passable?(x, y)
    return false if @event.passable?(x, y,0) == false
    for node in @path
      return false if node.pos?(x, y) and (node.good == false or node.passage == true)
    end
    return true
  end
  
  def self.distance(node)
    return Math.hypot(node.x - @goal.x, node.y - @goal.y)
  end
  
  def self.node_at(x, y)
    for node in @path
      next unless node
      return node if node.pos?(x, y)
    end
    return nil
  end
  
  def self.node_nearest(nodes)
    nearest = nodes[0]
    for node in nodes
      if nearest.distance > node.distance
        nearest = node
      elsif nearest.distance == node.distance
        if rand(2) == 0
          nearest = node
        end
      end
    end
    return nearest
  end
  
  def self.erase_to(node,node2)
    start = false
    for i in 0 ... @path.size
      if @path[i] == node
        start = true
        next
      end
      if @path[i] == node2
        break
      end
      if start
        @path[i] = nil
      end
    end
  end
  
  def self.get_adjacent_nodes
    nodes = []
    if self.passable?(@current_node.x+1, @current_node.y)
      node = Node.new(@current_node, @current_node.x+1, @current_node.y)
      node.distance = self.distance(node)
      nodes.push(node)
    else
      nodes.push(nil)
    end
    if self.passable?(@current_node.x-1, @current_node.y)
      node = Node.new(@current_node, @current_node.x-1, @current_node.y)
      node.distance = self.distance(node)
      nodes.push(node)
    else
      nodes.push(nil)
    end
    if self.passable?(@current_node.x, @current_node.y+1)
      node = Node.new(@current_node, @current_node.x, @current_node.y+1)
      node.distance = self.distance(node)
      nodes.push(node)
    else
      nodes.push(nil)
    end
    if self.passable?(@current_node.x, @current_node.y-1)
      node = Node.new(@current_node, @current_node.x, @current_node.y-1)
      node.distance = self.distance(node)
      nodes.push(node)
    else
      nodes.push(nil)
    end
    return nodes
  end
  
  def self.find_adjacent_node(x, y)
    nodes = []
    nodes.push(node_at(x+1,y))
    nodes.push(node_at(x-1,y))
    nodes.push(node_at(x,y+1))
    nodes.push(node_at(x,y-1))
    return nodes
  end
  
end
 
module RPG
  
  class MoveRoute
    
    attr_accessor :repeat
    attr_accessor :skippable
    attr_accessor :wait
    attr_accessor :path
    attr_accessor :x
    attr_accessor :y
    attr_accessor :zone
    
    def initialize
      @repeat = true
      @skippable = false
      @wait = false
      @path = nil
      @x = nil
      @y = nil
      @zone = nil
    end
    
  end
  
end