[RPG-MAKER.FR] Oniromancie: tout l'univers de RPG Maker en français

class Game_Battler #-------------------------------------------------------------------------- # * Change HP # hp : new HP #-------------------------------------------------------------------------- def hp=(hp) @hp = [[hp, maxhp].min, 0].max for i in 1...$data_states.size if $data_states[i].zero_hp if self.dead? add_state(i) # ID des monstres if self.is_a?(Game_Enemy) and [1,2,3,4].include?(id) # ce que tu veux faire end else remove_state(i) end end end end 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

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

file = File.open("Save4.rxdata", "rb") # Read character data for drawing save file characters = Marshal.load(file) # Read frame count for measuring play time Graphics.frame_count = Marshal.load(file) # Read each type of game object $game_system = Marshal.load(file) $game_switches = Marshal.load(file) $game_variables = Marshal.load(file) $game_self_switches = Marshal.load(file) $game_screen = Marshal.load(file) $game_actors = Marshal.load(file) $game_party = Marshal.load(file) $game_troop = Marshal.load(file) $game_map = Marshal.load(file) $game_player = Marshal.load(file) # If magic number is different from when saving # (if editing was added with editor) if $game_system.magic_number != $data_system.magic_number # Load map $game_map.setup($game_map.map_id) $game_player.center($game_player.x, $game_player.y) end # Refresh party members $game_party.refresh file.close $scene = Scene_Map.new

x = 320 y = 240 rayon = 100 angle = 0 pas = 1/rayon.to_f color = Color.new(255,255,255) while angle < Math::PI sprite_x = x - Math.cos(angle)*rayon sprite_y = y - Math.sin(angle)*rayon @sprite.bitmap.fill_rect(sprite_x, sprite_y, 1, 2*(y - sprite_y), color) angle += pas end

class Game_Character def vision(event_id, distance) event = (event_id == 0 ? $game_player : $game_map.events[event_id]) sx = @x - event.x sy = @y - event.y return false if @direction == 2 and sy >= 0 return false if @direction == 4 and sx <= 0 return false if @direction == 6 and sx >= 0 return false if @direction == 8 and sy <= 0 if Math.hypot(sx, sy) <= distance return true end return false end end

x = 320 y = 240 rayon = 200 angle = 0 pas = 1/rayon.to_f while angle < 2*Math::PI sprite_x = x + Math.cos(angle)*rayon sprite_y = y + Math.sin(angle)*rayon @sprite.bitmap.set_pixel(sprite_x, sprite_y, Color.new(255,255,255)) angle += pas end