Une façon de gérer de la 2D isométrique [à améliorer]

There aren't any users online.

• kriss: oui.. je dois faire des demandes pour que google refasse des analyse du site afin de "voir" s'il est tjr malveillant
  Dcembre 08, 2011, 22:47:27
• Leopold: Cool! Mais Firefox me le déclare toujours malveillant...
  Dcembre 08, 2011, 22:30:32
• kriss: réouverture du forum !
  Dcembre 06, 2011, 00:48:58
• Fabien: Coucou facto!! Trop bon de repasser ici
  Septembre 25, 2011, 18:06:22
• Krän: aye ! ^^
  Aot 21, 2011, 23:43:29
• RPG-Man: lol manu
  Aot 20, 2011, 00:24:00
• RPG-Man: JE SUIS REVENU MOUHAHA
  Aot 20, 2011, 00:22:26
• Manucyan: Ca dit quoi un ivrogne dans le noir ? "hé... t'es qui là ?"
  Mai 07, 2011, 18:11:20
• Krän: Il est 2h46 et tout est calme !
  Mai 05, 2011, 01:47:01
• Manucyan: La tronche du bestiaire ? Un pokédex !
  Avril 30, 2011, 21:18:09
• Manucyan: désolé je pensais que tout le monde connaissait le phénomène du rickroll (cf wikipédia)
  Avril 30, 2011, 14:08:48
• kriss: ca merite un ban pour ce lien oO
  Avril 30, 2011, 12:29:51
• RPG-Man: Sale vilain
  Avril 30, 2011, 11:26:31
• Krän: Never gonna give u up, never gonna let u dooowwwn ...
  Avril 28, 2011, 20:29:20
• kriss: en effet mais ce n'est pas normal.. il y a un bug que je dois trouver ^^
  Avril 25, 2011, 10:30:16
• Leopold: Pour la mise à jour, on peut cliquer sur "Refresh" (deux flèches vertes) ou sur "History" (pendule).
  Avril 22, 2011, 21:31:57
• RPG-Man: Manque plus qu'elle se mette à jour toute seule quand on ajoute un message et c'est le must !
  Avril 21, 2011, 20:29:39
• RPG-Man: le shootbox CAY LE BIEN
  Avril 21, 2011, 20:29:14
• kriss: on appel ca une shootbox
  Avril 18, 2011, 16:47:13
• Manucyan: hé mais c'est marrant !
  Avril 17, 2011, 18:03:46

[MGC]

J'ai fait un petit script permettant de gérer certaines cartes en "presque" 2D-isométrique.
"Presque" en 2D-isométrique car les angles ne sont pas exactement à 120°, j'ai utilisé la méthode du tutorial de Titania.

Le maillage vis-à-vis des carreaux de tiles doit être comme ça :


Pour l'instant le script est assez limité, il ne prend en compte que 4 directions de déplacement.


Je suis parti d'un constat : l'isométrie sert à faire des cartes visuellement plus impressionnantes. C'est donc juste une histoire de rendu graphique. J'ai donc eu l'idée de séparer le rendu des cartes des données intrinsèques.
En gros, tous les personnages et évènements évoluent sur une carte classique en allant de case en case vers le haut, la gauche, la droite, ou le bas. En revanche l'affichage est en isométrique, à partir d'une seconde carte dessinée en isométrique.

Il va donc falloir faire deux cartes.
Tout d'abord choisir les dimensions de la carte de données, et créer les contours de la carte en isométrie à partir de ces dimensions. L'origine théorique de la carte (normalement en haut à gauche) doit être placée en haut.

exemple pour une carte 20*16


Si la somme hauteur + largeur de la carte de données est impaire, la hauteur de la carte en isométrique ne sera pas divisible par 32 et il faudra alors arrondir les dimensions au tile supérieur en plaquant la carte en isométrique en haut.

exemple pour une carte 19*16 (bon, d'accord ça n'existe pas, mais c'est pour le principe)


Ensuite vous dessinez votre carte en isométrique comme vous voulez, avec les différentes couches comme il faut bien pour les histoires de priorités de superposition.

L'étape suivante consiste à créer la carte de données en tant que fille de la carte isométrique, et remplir par exemple sa première couche d'éléments qui vont définir la passabilité et les autres données des cases correspondantes sur la carte isométrique (il faut essayer de faire une sorte de rotation à 45° pour bien placer les carreaux).
Par exemple j'ai pris le premier tileset et je me suis servi d'un élément impassable (le marron de la tente) pour définir les endroits inaccessibles sur la carte isométrique : j'aurais pu prendre n'importe quel autre tile impassable.
Je me suis également servi des hautes herbes pour définir des cases "obscurcissantes".



Ensuite tous les évènements seront placés sur cette carte de données.
Les effets de panoramas et brouillards, faisant plutôt partie du "visuel", sont à intégrer dans le chipset de la carte en isométrique.

Evidemment, il y a un script à ajouter comme d'habitude au-dessus de main.
Ce n'est pas de la programmation difficile, c'est surtout des modifications de tout ce qui touche l'affichage (tous les screen_x, screen_y, screen_z, display_x, display_y, les histoires de scrolling...). Le voici :
Script de base : ajouter au dessus de Main

Code:

#---------------------------------------------------------------------------------------------------------------
#---------------------------------------------------------------------------------------------------------------
# ● Script 2D_ISO, créé par MGCaladtogel pour la communauté rpgmakerxp-factory.net
#---------------------------------------------------------------------------------------------------------------
#==============================================================================
# ■ Ajouts, modifications des classes d'origine
#
# indications : $game_map désigne la carte de données
#               $game_map_iso désigne la carte en 2D-isométrique
#==============================================================================

#==============================================================================
# ■ Game_Map
#==============================================================================
class Game_Map
  #--------------------------------------------------------------------------
  # ● Le scrolling doit s'effectuer en fonctions des dimensions de la carte
  #     en isométrique
  #--------------------------------------------------------------------------
  def scroll_down(distance)
    corr = (($game_map.height + $game_map.width)%2 == 0 ? 0 : 4*16)
    @display_y = [@display_y + distance, 128*$game_map_iso.height - 4*480 - corr].min
  end
  #--------------------------------------------------------------------------
  def scroll_right(distance)
    @display_x = [@display_x + distance, 128*$game_map_iso.width - 4 * 640].min
  end
end

#==============================================================================
# ■ Game_Character
#==============================================================================
class Game_Character
  #--------------------------------------------------------------------------
  # ● On change les coordonnées d'affichage des characters à l'écran
  #--------------------------------------------------------------------------
  def screen_x
    return  (@real_x - @real_y)/4 + 32*$game_map.height - 0 - $game_map.display_x/4
  end
  #--------------------------------------------------------------------------
  def screen_y
    y = (@real_y + @real_x) / 8 + 22 - $game_map.display_y/4
    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 screen_z(height = 0)
    if @always_on_top
      return 999
    end
    z = screen_y
    if @tile_id > 0
      return z + $game_map_iso.priorities[@tile_id] * 32
    else
      return z + ((height > 32) ? 31 : 0)
    end
  end
end

#==============================================================================
# ■ Game_Player
#==============================================================================
class Game_Player < Game_Character
  #--------------------------------------------------------------------------
  def center(x, y)
    max_x = ($game_map.width - 20) * 128
    max_y = ($game_map.height - 15) * 128
    max_xy = [max_x, max_y].max
    $game_map.display_x = 2*max_xy
    $game_map.display_y = 2*max_xy
  end
  #--------------------------------------------------------------------------
  # ● Les commandes directionnelles en diagonale sont activées, et on s'arrange
  #     pour que le scrolling se passe bien
  #--------------------------------------------------------------------------
  def update
    last_moving = moving?
    unless moving? or $game_system.map_interpreter.running? or
           @move_route_forcing or $game_temp.message_window_showing
      case Input.dir8
      when 1..2
        move_down
      when 3
        move_right
      when 4
        move_left
      when 7
        move_left
      when 6
        move_right
      when 8..9
        move_up
      end
    end
    last_real_x = @real_x
    last_real_y = @real_y
    super
    disp_y = screen_y + $game_map.display_y/4
    disp_x = screen_x + $game_map.display_x/4
    if CENTER_Y - (4*disp_y - $game_map.display_y) < 0
      $game_map.scroll_down(4*disp_y - $game_map.display_y - CENTER_Y)
    end
    if CENTER_X - (4*disp_x - $game_map.display_x) > 0
      $game_map.scroll_left(CENTER_X - (4*disp_x - $game_map.display_x))
    end
    if CENTER_X - (4*disp_x - $game_map.display_x) < 0
      $game_map.scroll_right(4*disp_x - $game_map.display_x - CENTER_X)
    end
    if CENTER_Y - (4*disp_y - $game_map.display_y) > 0
      $game_map.scroll_up(CENTER_Y - (4*disp_y - $game_map.display_y))
    end
    unless moving?
      if last_moving
        result = check_event_trigger_here([1,2])
        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
end

#==============================================================================
# ■ Scene_Title
#==============================================================================
class Scene_Title
  alias main_orig main
  #--------------------------------------------------------------------------
  # ● Dans MapInfos on va trouver l'identité de la carte parente à la carte
  #     de données (donc l'id de la carte en iso)
  #--------------------------------------------------------------------------
  def main
    $data_map_infos        = load_data("Data/MapInfos.rxdata")
    main_orig
  end
end

#==============================================================================
# ■ Spriteset_Map
#==============================================================================
class Spriteset_Map
  #--------------------------------------------------------------------------
  # ● On va associer à la tilemap, qui gère l'affichage de la carte à l'écran,
  #     les données de la carte en 2D-isométrique
  #--------------------------------------------------------------------------
  def initialize
    @viewport1 = Viewport.new(0, 0, 640, 480)
    @viewport2 = Viewport.new(0, 0, 640, 480)
    @viewport3 = Viewport.new(0, 0, 640, 480)
    @viewport2.z = 200
    @viewport3.z = 5000
    @tilemap = Tilemap.new(@viewport1)
    map_infos = $data_map_infos[$game_map.map_id]
    $game_map_iso = Game_Map.new
    $game_map_iso.setup(map_infos.parent_id)
    @tilemap.tileset = RPG::Cache.tileset($game_map_iso.tileset_name)
    for i in 0..6
      autotile_name = $game_map.autotile_names[i]
      @tilemap.autotiles[i] = RPG::Cache.autotile(autotile_name)
    end
    @tilemap.map_data = $game_map_iso.data
    @tilemap.priorities = $game_map_iso.priorities
    @panorama = Plane.new(@viewport1)
    @panorama.z = -1000
    @fog = Plane.new(@viewport1)
    @fog.z = 3000
    @character_sprites = []
    for i in $game_map.events.keys.sort
      sprite = Sprite_Character.new(@viewport1, $game_map.events[i])
      @character_sprites.push(sprite)
    end
    @character_sprites.push(Sprite_Character.new(@viewport1, $game_player))
    @weather = RPG::Weather.new(@viewport1)
    @picture_sprites = []
    for i in 1..50
      @picture_sprites.push(Sprite_Picture.new(@viewport2,
        $game_screen.pictures[i]))
    end
    @timer_sprite = Sprite_Timer.new
    update
  end
  #--------------------------------------------------------------------------
  # ● Attention : pour ma carte test j'ai fait en sorte que le panorama bouge
  #     de la même façon que la tilemap.
  #     Pour retrouver le déplacement d'origine des panoramas, il faut changer :
  #       @panorama.ox = $game_map.display_x / 4
  #       @panorama.oy = $game_map.display_y / 4
  #     en :
  #       @panorama.ox = $game_map.display_y / 8
  #       @panorama.oy = $game_map.display_y / 8
  #--------------------------------------------------------------------------
  def update
    if @panorama_name != $game_map_iso.panorama_name or
       @panorama_hue != $game_map_iso.panorama_hue
      @panorama_name = $game_map_iso.panorama_name
      @panorama_hue = $game_map_iso.panorama_hue
      if @panorama.bitmap != nil
        @panorama.bitmap.dispose
        @panorama.bitmap = nil
      end
      if @panorama_name != ""
        @panorama.bitmap = RPG::Cache.panorama(@panorama_name, @panorama_hue)
      end
      Graphics.frame_reset
    end
    if @fog_name != $game_map_iso.fog_name or @fog_hue != $game_map_iso.fog_hue
      @fog_name = $game_map_iso.fog_name
      @fog_hue = $game_map_iso.fog_hue
      if @fog.bitmap != nil
        @fog.bitmap.dispose
        @fog.bitmap = nil
      end
      if @fog_name != ""
        @fog.bitmap = RPG::Cache.fog(@fog_name, @fog_hue)
      end
      Graphics.frame_reset
    end
    @tilemap.ox = $game_map.display_x / 4
    @tilemap.oy = $game_map.display_y / 4
    @tilemap.update
    @panorama.ox = $game_map.display_x / 4
    @panorama.oy = $game_map.display_y / 4
    @fog.zoom_x = $game_map_iso.fog_zoom / 100.0
    @fog.zoom_y = $game_map_iso.fog_zoom / 100.0
    @fog.opacity = $game_map_iso.fog_opacity
    @fog.blend_type = $game_map_iso.fog_blend_type
    @fog.ox = $game_map.display_x / 4 + $game_map.fog_ox
    @fog.oy = $game_map.display_y / 4 + $game_map.fog_oy
    @fog.tone = $game_map.fog_tone
    for sprite in @character_sprites
      sprite.update
    end
    @weather.type = $game_screen.weather_type
    @weather.max = $game_screen.weather_max
    @weather.ox = $game_map.display_x / 4
    @weather.oy = $game_map.display_y / 4
    @weather.update
    for sprite in @picture_sprites
      sprite.update
    end
    @timer_sprite.update
    @viewport1.tone = $game_screen.tone
    @viewport1.ox = $game_screen.shake
    @viewport3.color = $game_screen.flash_color
    @viewport1.update
    @viewport3.update
  end
end

#==============================================================================
# ■ Interpreter
#==============================================================================
class Interpreter
  #--------------------------------------------------------------------------
  # ● Commande : "Modifier les propriétés de la carte..."
  #--------------------------------------------------------------------------
  def command_204
    case @parameters[0]
    when 0
      $game_map_iso.panorama_name = @parameters[1]
      $game_map_iso.panorama_hue = @parameters[2]
    when 1
      $game_map_iso.fog_name = @parameters[1]
      $game_map_iso.fog_hue = @parameters[2]
      $game_map_iso.fog_opacity = @parameters[3]
      $game_map_iso.fog_blend_type = @parameters[4]
      $game_map_iso.fog_zoom = @parameters[5]
      $game_map_iso.fog_sx = @parameters[6]
      $game_map_iso.fog_sy = @parameters[7]
    when 2
      $game_map_iso.battleback_name = @parameters[1]
      $game_temp.battleback_name = @parameters[1]
    end
    return true
  end
  #--------------------------------------------------------------------------
  # ● Commande : "Modifier le ton du brouillard..."
  #--------------------------------------------------------------------------
  def command_205
    $game_map_iso.start_fog_tone_change(@parameters[0], @parameters[1] * 2)
    return true
  end
  #--------------------------------------------------------------------------
  # ● Commande : "Modifier l'opacité du brouillard..."
  #--------------------------------------------------------------------------
  def command_206
    $game_map_iso.start_fog_opacity_change(@parameters[0], @parameters[1] * 2)
    return true
  end
end

Add-on : ajouter entre Main et script de base

Attention, ce script réquisitionne des interrupteurs ! (voir page 5 pour plus de précisions)

Ajouts :
- la gestion des déplacements non case par case
- la possibilité de déplacement dans les 8 directions (activable/désactivable par interrupteur)
- la possibilité de courir en gardant B appuyé (activable/désactivable), menu avec Z
- la possibilité de sauter avec le bouton A (activable/désactivable)

La démo est là : http://www.megaupload.com/?d=AYHE6DJJ

[Mysterio]

OMFG O_O
Félicitation, MG (je peux t'appeller MG ?) tu est désormais mon 3ème maître de Ruby.
*se prosterne*
C'est tout simplement incroyable....Ben...Bravo...En fait je sais plus quoi dire....
Bravo.

[MGC]

"Maître de Ruby" ?!
Pourtant ce script est vide : il y a juste quelques petites modifications de méthodes existantes.
Je crois que j'ai passé plus de temps à dessiner la carte...

PS : tu peux m'appeler MG.


EDIT : comme il n'y avait pas assez de code à mon goût, j'ai fait un petit Add-on :

Attention, ce script réquisitionne des interrupteurs ! (voir page 5 pour plus de précisions)

C'est un script à placer sous le premier et qui permet :
- la gestion des déplacements non case par case
- la possibilité de déplacement dans les 8 directions (activable/désactivable par interrupteur)
- la possibilité de courir en gardant B appuyé (activable/désactivable), menu avec Z
- la possibilité de sauter avec le bouton A (activable/désactivable)

La démo est là : http://www.megaupload.com/?d=AYHE6DJJ

Et je met tout de même le script ici :

Code:

#---------------------------------------------------------------------------------------------------------------
# ● Script 2D_ISO Add-On 1, créé par MGCaladtogel pour la communauté rpgmakerxp-factory.net
# Maj 13/08/06
#---------------------------------------------------------------------------------------------------------------
#==============================================================================
# ■ Ajouts, modifications des classes d'origine
#
# indications : ce script doit être placé en-dessous du script 2D_ISO
#    Les éléments ajoutés sont :
# - gestion des déplacements non case par case
# - possibilité de déplacement dans les 8 directions (activable/désactivable)
# - possibilité de courir en gardant B appuyé (activable/désactivable), menu avec Z
# - possibilité de sauter avec le bouton A (activable/désactivable)
#==============================================================================

#==============================================================================
# ■ Scene_Title
#==============================================================================
class Scene_Title
  alias main_origine main
  def main
    ######Vous pouvez changer les valeurs suivantes######
    # Elles correspondent aux numéros d'interrupteurs réquisitionnés par le script
    $num_interrupteur_courir = 1
    $num_interrupteur_sauter = 2
    $num_interrupteur_8directions = 3
    ######Fin de vous pouvez changer les valeurs######
    main_origine
    $game_switches[$num_interrupteur_courir.to_i] = true
    $game_switches[$num_interrupteur_sauter.to_i] = true
    $game_switches[$num_interrupteur_8directions.to_i] = true
  end
end

#==============================================================================
# ■ Game_Character
#==============================================================================
class Game_Character
  attr_accessor :end_press
  attr_accessor :diagonal
  #--------------------------------------------------------------------------
  alias initialize_orig initialize
  def initialize
    initialize_orig
    @x = 0.0
    @y = 0.0
    @real_x = 0.0
    @real_y = 0.0
    @end_press = false
    @diagonal = false
  end
  #--------------------------------------------------------------------------
  def passable?(x, y, d)
    new_x = x + (d == 6 ? 1 : d == 4 ? -1 : 0)
    new_y = y + (d == 2 ? 1 : d == 8 ? -1 : 0)
    unless $game_map.valid?(new_x, new_y)
      return false
    end
    if @through
      return true
    end
    unless $game_map.passable?(x, y, d, self)
      return false
    end
    unless $game_map.passable?(new_x, new_y, 10 - d)
      return false
    end
    for event in $game_map.events.values
      if event.x == new_x and event.y == new_y
        unless event.through
          if self != $game_player
            return false
          end
          if event.character_name != ""
            return false
          end
        end
      end
    end
    if Math.sqrt((new_x-$game_player.x)**2 + (new_y-$game_player.y)**2) < 0.7
      unless $game_player.through
        if @character_name != ""
          return false
        end
      end
    end
    return true
  end
end

#==============================================================================
# ■ Game_Map
#==============================================================================
class Game_Map
  attr_accessor :map
  #--------------------------------------------------------------------------
  def passable_p?(x, y, d, self_event = nil)
    unless valid?(x, y)
      return false
    end
    bit = (1 << (d / 2 - 1)) & 0x0f
    for event in events.values
      m = ((((((event.real_x).to_f)/128)*8).to_i).to_f)/8
      n = ((((((event.real_y).to_f)/128)*8).to_i).to_f)/8
      if event.tile_id >= 0 and event != self_event and
        (m == x) and (n == y) and not event.through
        if @passages[event.tile_id] & bit != 0
          return false
        elsif @passages[event.tile_id] & 0x0f == 0x0f
          return false
        elsif @priorities[event.tile_id] == 0
          return true
        end
      end
    end
    for i in [2, 1, 0]
      tile_id = data[x, y, i]
      if tile_id == nil
        return false
      elsif @passages[tile_id] & bit != 0
        return false
      elsif @passages[tile_id] & 0x0f == 0x0f
        return false
      elsif @priorities[tile_id] == 0
        return true
      end
    end
    return true
  end
end

#==============================================================================
# ■ Game_Event
#==============================================================================
class Game_Event < Game_Character
  def check_event_trigger_touch(x, y)
    if $game_system.map_interpreter.running?
      return
    end
    if @trigger == 2 and Math.sqrt((x-$game_player.x)**2 + (y-$game_player.y)**2) < 0.7
      if not jumping? and not over_trigger?
        start
      end
    end
  end
  #--------------------------------------------------------------------------
  def check_event_trigger_auto
    m = ((((((@real_x).to_f)/128)*8).to_i).to_f)/8
    n = ((((((@real_y).to_f)/128)*8).to_i).to_f)/8
    x = $game_player.x
    y = $game_player.y
    if @trigger == 2 and Math.sqrt((m-x)**2 + (n-y)**2) < 0.7
      if not jumping? and over_trigger?
        start
      end
    end
    if @trigger == 3
      start
    end
  end
end

#==============================================================================
# ■ Game_Player
#==============================================================================
class Game_Player < Game_Character
  attr_accessor :course
  attr_accessor :x
  attr_accessor :y
  attr_accessor :opacity
  attr_accessor :tjs_dessus
  attr_accessor :bloqué_down
  attr_accessor :bloqué_left
  attr_accessor :bloqué_right
  attr_accessor :bloqué_up
  #--------------------------------------------------------------------------
  def initialize
    super
    self.course = false
    self.tjs_dessus = true
    self.bloqué_down = false
    self.bloqué_left = false
    self.bloqué_right = false
    self.bloqué_up = false
  end
  #--------------------------------------------------------------------------
  def mode_course
    self.course = true
  end
  #--------------------------------------------------------------------------
  def mode_marche
    self.course = false
  end
  #--------------------------------------------------------------------------
  def check_event_trigger_here_ISOaddon1(triggers)
    result = false
    if $game_system.map_interpreter.running?
      return result
    end
    for event in $game_map.events.values
      m = ((((((event.real_x).to_f)/128)*8).to_i).to_f)/8
      n = ((((((event.real_y).to_f)/128)*8).to_i).to_f)/8
      if Math.sqrt((m-self.x)**2 + (n-self.y)**2) < 0.7 and triggers.include?(event.trigger)
        if not event.jumping? and event.over_trigger?
          if !self.tjs_dessus or triggers.include?(0)
            event.start
          end
          result = true
          self.tjs_dessus = true
        end
      end
    end
    self.tjs_dessus = false if !result
    return result
  end
  #--------------------------------------------------------------------------
  def check_event_trigger_there_ISOaddon1(triggers)
    result = false
    if $game_system.map_interpreter.running?
      return result
    end
    new_x = @x + (@direction == 6 ? 0.7 : @direction == 4 ? -0.7 : 0)
    new_y = @y + (@direction == 2 ? 0.7 : @direction == 8 ? -0.7 : 0)
    for event in $game_map.events.values
      m = ((((((event.real_x).to_f)/128)*8).to_i).to_f)/8
      n = ((((((event.real_y).to_f)/128)*8).to_i).to_f)/8
      if Math.sqrt((m-new_x)**2 + (n-new_y)**2) < 0.5 and triggers.include?(event.trigger)
        if not event.jumping? and not event.over_trigger?
          event.start
          result = true
        end
      end
    end
    if result == false
      if $game_map.counter?(new_x, new_y)
        new_x += (@direction == 6 ? 0.7 : @direction == 4 ? -0.7 : 0)
        new_y += (@direction == 2 ? 0.7 : @direction == 8 ? -0.7 : 0)
        for event in $game_map.events.values
          m = ((((((event.real_x).to_f)/128)*8).to_i).to_f)/8
          n = ((((((event.real_y).to_f)/128)*8).to_i).to_f)/8
          if Math.sqrt((m-new_x)**2 + (n-new_y)**2) < 0.5 and triggers.include?(event.trigger)
            if not event.jumping? and not event.over_trigger?
              event.start
              result = true
            end
          end
        end
      end
    end
    return result
  end
  #--------------------------------------------------------------------------
  def check_event_trigger_touch_ISOaddon1(x, y)
    result = false
    if $game_system.map_interpreter.running?
      return result
    end
    for event in $game_map.events.values
      m = ((((((event.real_x).to_f)/128)*8).to_i).to_f)/8
      n = ((((((event.real_y).to_f)/128)*8).to_i).to_f)/8
      if Math.sqrt((m-x)**2 + (n-y)**2) < 0.7 and [1,2].include?(event.trigger)
        if not event.jumping? and not event.over_trigger?
          event.start
          result = true
        end
      end
    end
    return result
  end
  #--------------------------------------------------------------------------
  def update
    last_real_x = @real_x
    last_real_y = @real_y
    @move_speed = (@course ? 6 : 4)
    last_moving = moving?
    unless moving? or jumping? or $game_system.map_interpreter.running? or
           @move_route_forcing or $game_temp.message_window_showing
      if $game_switches[$num_interrupteur_8directions.to_i]
        case Input.dir8
        when 2
          move_down_ISOaddon1
          bloqué_down?
        when 4
          move_left_ISOaddon1
          bloqué_left?
        when 6
          move_right_ISOaddon1
          bloqué_right?
        when 8
          move_up_ISOaddon1
          bloqué_up?
        when 1
          move_lower_left_ISOaddon1
        when 3
          move_lower_right_ISOaddon1
        when 7
          move_upper_left_ISOaddon1
        when 9
          move_upper_right_ISOaddon1
        end
      else
        case Input.dir8
        when 1..2
          move_down_ISOaddon1
          bloqué_down?
        when 3
          move_right_ISOaddon1
          bloqué_right?
        when 4
          move_left_ISOaddon1
          bloqué_left?
        when 7
          move_left_ISOaddon1
          bloqué_left?
        when 6
          move_right_ISOaddon1
          bloqué_right?
        when 8..9
          move_up_ISOaddon1
          bloqué_up?
        end
      end
    end
    if jumping?
      update_jump_ISOaddon1
    elsif moving?
      update_move
    else
      update_stop
      @x = (((8*@x).to_i).to_f)/8
      @y = (((8*@y).to_i).to_f)/8
    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
    if @wait_count > 0
      @wait_count -= 1
      return
    end
    if @move_route_forcing
      move_type_custom
      return
    end
    if @starting or lock?
      return
    end
    if @stop_count > (40 - @move_frequency * 2) * (6 - @move_frequency)
      case @move_type
      when 1
        move_type_random
      when 2
        move_type_toward_player
      when 3
        move_type_custom
      end
    end
    disp_y = screen_y + $game_map.display_y/4
    disp_x = screen_x + $game_map.display_x/4
    if CENTER_Y - (4*disp_y - $game_map.display_y) < 0
      $game_map.scroll_down(4*disp_y - $game_map.display_y - CENTER_Y)
    end
    if CENTER_X - (4*disp_x - $game_map.display_x) > 0
      $game_map.scroll_left(CENTER_X - (4*disp_x - $game_map.display_x))
    end
    if CENTER_X - (4*disp_x - $game_map.display_x) < 0
      $game_map.scroll_right(4*disp_x - $game_map.display_x - CENTER_X)
    end
    if CENTER_Y - (4*disp_y - $game_map.display_y) > 0
      $game_map.scroll_up(CENTER_Y - (4*disp_y - $game_map.display_y))
    end
    unless moving?
      if last_moving
        result = check_event_trigger_here_ISOaddon1([1,2])
        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_ISOaddon1([0])
        check_event_trigger_there_ISOaddon1([0,1,2])
      end
    end
  end
  #--------------------------------------------------------------------------
  def move_down_ISOaddon1(turn_enabled = true)
    a = (@course ? 1.5 : 1.0)
    c_d = false
    if @direction == 2 and passable?(@x, @y, 2, a, c_d) and event_pass?(@x, @y, 2, a, c_d)
      turn_down
      @y += a/8
      increase_steps
      self.bloqué_down = false
    else
      check_event_trigger_touch_ISOaddon1(@x, @y+1)
      self.bloqué_down = true if @direction == 2 and event_pass?(@x, @y, 2, a, c_d)
    end
    if turn_enabled and @direction != 2
      turn_down
      self.bloqué_down = false if passable?(@x, @y, 2, a, c_d)
    end
  end
  #--------------------------------------------------------------------------
  def move_left_ISOaddon1(turn_enabled = true)
    a = (@course ? 1.5 : 1.0)
    c_d = false
    if @direction == 4 and passable?(@x, @y, 4, a, c_d) and event_pass?(@x, @y, 4, a, c_d)
      turn_left
      @x -= a/8
      increase_steps
      self.bloqué_left = false
    else
      check_event_trigger_touch_ISOaddon1(@x-1, @y)
      self.bloqué_left = true if @direction == 4 and event_pass?(@x, @y, 4, a, c_d)
    end
    if turn_enabled and @direction != 4
      turn_left
      self.bloqué_left = false if passable?(@x, @y, 4, a, c_d)
    end
  end
  #--------------------------------------------------------------------------
  def move_right_ISOaddon1(turn_enabled = true)
    a = (@course ? 1.5 : 1.0)
    c_d = false
    if @direction == 6 and passable?(@x, @y, 6, a, c_d) and event_pass?(@x, @y, 6, a, c_d)
      turn_right
      @x += a/8
      increase_steps
      self.bloqué_right = false
    else
      check_event_trigger_touch_ISOaddon1(@x+1, @y)
      self.bloqué_right = true if @direction == 6 and event_pass?(@x, @y, 6, a, c_d)
    end
    if turn_enabled and @direction != 6
      turn_right
      self.bloqué_right = false if passable?(@x, @y, 6, a, c_d)
    end
  end
  #--------------------------------------------------------------------------
  def move_up_ISOaddon1(turn_enabled = true)
    a = (@course ? 1.5 : 1.0)
    c_d = false
    if @direction == 8 and passable?(@x, @y, 8, a, c_d) and event_pass?(@x, @y, 8, a, c_d)
      turn_up
      @y -= a/8
      increase_steps
      self.bloqué_up = false
    else
      check_event_trigger_touch_ISOaddon1(@x, @y-1)
      self.bloqué_up = true if @direction == 8 and event_pass?(@x, @y, 8, a, c_d)
    end
    if turn_enabled and @direction != 8
      turn_up
      self.bloqué_up = false if passable?(@x, @y, 8, a, c_d)
    end
  end
  #--------------------------------------------------------------------------
  def move_lower_left_ISOaddon1(turn_enabled = true)
    a = (@course ? 1.5 : 1.0)
    c_d = true
    if @direction == 2 and passable?(@x, @y, 2, a, c_d) and event_pass?(@x, @y, 2, a, c_d)
      turn_lower_left
      @y += a/(8*Math.sqrt(2))
      @x -= a/(8*Math.sqrt(2))
      increase_steps
    else
      check_event_trigger_touch_ISOaddon1(@x-1, @y+1)
    end
    if turn_enabled and @direction != 2
      turn_lower_left
    end
  end
  #--------------------------------------------------------------------------
  def move_lower_right_ISOaddon1(turn_enabled = true)
    a = (@course ? 1.5 : 1.0)
    c_d = true
    if @direction == 6 and passable?(@x, @y, 6, a, c_d) and event_pass?(@x, @y, 6, a, c_d)
      turn_lower_right
      @y += a/(8*Math.sqrt(2))
      @x += a/(8*Math.sqrt(2))
      increase_steps
    else
      check_event_trigger_touch_ISOaddon1(@x+1, @y+1)
    end
    if turn_enabled and @direction != 6
      turn_lower_right
    end
  end
  #--------------------------------------------------------------------------
  def move_upper_left_ISOaddon1(turn_enabled = true)
    a = (@course ? 1.5 : 1.0)
    c_d = true
    if @direction == 4 and passable?(@x, @y, 4, a, c_d) and event_pass?(@x, @y, 4, a, c_d)
      turn_upper_left
      @y -= a/(8*Math.sqrt(2))
      @x -= a/(8*Math.sqrt(2))
      increase_steps
    else
      check_event_trigger_touch_ISOaddon1(@x-1, @y-1)
    end
    if turn_enabled and @direction != 4
      turn_upper_left
    end
  end
  #--------------------------------------------------------------------------
  def move_upper_right_ISOaddon1(turn_enabled = true)
    a = (@course ? 1.5 : 1.0)
    c_d = true
    if @direction == 8 and passable?(@x, @y, 8, a, c_d) and event_pass?(@x, @y, 8, a, c_d)
      turn_upper_right
      @y -= a/(8*Math.sqrt(2))
      @x += a/(8*Math.sqrt(2))
      increase_steps
    else
      check_event_trigger_touch_ISOaddon1(@x+1, @y-1)
    end
    if turn_enabled and @direction != 8
      turn_upper_right
    end
  end
  #--------------------------------------------------------------------------
  def turn_down
    unless @direction_fix
      @diagonal = false
      @direction = 2
      @stop_count = 0
    end
  end
  #--------------------------------------------------------------------------
  def turn_left
    unless @direction_fix
      @diagonal = false
      @direction = 4
      @stop_count = 0
    end
  end
  #--------------------------------------------------------------------------
  def turn_right
    unless @direction_fix
      @diagonal = false
      @direction = 6
      @stop_count = 0
    end
  end
  #--------------------------------------------------------------------------
  def turn_up
    unless @direction_fix
      @diagonal = false
      @direction = 8
      @stop_count = 0
    end
  end
  #--------------------------------------------------------------------------
  def turn_lower_left
    unless @direction_fix
      @diagonal = true
      @direction = 2
      @stop_count = 0
    end
  end
  #--------------------------------------------------------------------------
  def turn_lower_right
    unless @direction_fix
      @diagonal = true
      @direction = 6
      @stop_count = 0
    end
  end
  #--------------------------------------------------------------------------
  def turn_upper_left
    unless @direction_fix
      @diagonal = true
      @direction = 4
      @stop_count = 0
    end
  end
  #--------------------------------------------------------------------------
  def turn_upper_right
    unless @direction_fix
      @diagonal = true
      @direction = 8
      @stop_count = 0
    end
  end
  #--------------------------------------------------------------------------
  def jump_ISOaddon1(x,y)
    @end_press = false
    @jump_peak = 3
    @jump_count = @jump_peak * 2
    @stop_count = 0
  end
  #--------------------------------------------------------------------------
  def update_jump_ISOaddon1
    @end_press = true if !Input.press?(Input::A)
    if Input.press?(Input::A) and !@end_press and @jump_peak != 8
      @jump_peak += 1
      @jump_count += 2
    end
    a = (@course ? 1.2 : 0.8)
    if $game_switches[$num_interrupteur_8directions.to_i]
      case Input.dir8
      when 1
        update_jump_lower_left
      when 2
        update_jump_down
      when 3
        update_jump_lower_right
      when 4
        update_jump_left
      when 6
        update_jump_right
      when 7
        update_jump_upper_left
      when 8
        update_jump_up
      when 9
        update_jump_upper_right
      end
    else
      case Input.dir8
      when 1..2
        update_jump_down
      when 3
        update_jump_right
      when 4
        update_jump_left
      when 6
        update_jump_right
      when 7
        update_jump_left
      when 8..9
        update_jump_up
      end
    end
    @jump_count -= 1
    if @jump_count == 0
      @x = (((8*@x).to_i).to_f)/8
      @y = (((8*@y).to_i).to_f)/8
    end
    @real_x = @x * 128
    @real_y = @y * 128
  end
  #--------------------------------------------------------------------------
  def update_jump_down(turn_enabled = true)
    if turn_enabled
      turn_down
    end
    a = (@course ? 1.2 : 0.8)
    c_d = false
    if passable?(@x, @y, 2, a, c_d) and event_pass?(@x, @y, 2, a, c_d)
      turn_down
      @y += a/8
      increase_steps
    else
      check_event_trigger_touch_ISOaddon1(@x, @y+1)
    end
  end
  #--------------------------------------------------------------------------
  def update_jump_left(turn_enabled = true)
    if turn_enabled
      turn_left
    end
    a = (@course ? 1.2 : 0.8)
    c_d = false
    if passable?(@x, @y, 4, a, c_d) and event_pass?(@x, @y, 4, a, c_d)
      turn_left
      @x -= a/8
      increase_steps
    else
      check_event_trigger_touch_ISOaddon1(@x, @y+1)
    end
  end
  #--------------------------------------------------------------------------
  def update_jump_right(turn_enabled = true)
    if turn_enabled
      turn_right
    end
    a = (@course ? 1.2 : 0.8)
    c_d = false
    if passable?(@x, @y, 6, a, c_d) and event_pass?(@x, @y, 6, a, c_d)
      turn_right
      @x += a/8
      increase_steps
    else
      check_event_trigger_touch_ISOaddon1(@x, @y+1)
    end
  end
  #--------------------------------------------------------------------------
  def update_jump_up(turn_enabled = true)
    if turn_enabled
      turn_up
    end
    a = (@course ? 1.2 : 0.8)
    c_d = false
    if passable?(@x, @y, 8, a, c_d) and event_pass?(@x, @y, 8, a, c_d)
      turn_up
      @y -= a/8
      increase_steps
    else
      check_event_trigger_touch_ISOaddon1(@x, @y+1)
    end
  end
  #--------------------------------------------------------------------------
  def update_jump_lower_left(turn_enabled = true)
    if turn_enabled
      turn_lower_left
    end
    a = (@course ? 1.2 : 0.8)
    c_d = true
    if passable?(@x, @y, 2, a, c_d) and event_pass?(@x, @y, 2, a, c_d)
      turn_lower_left
      @x -= a/(8*Math.sqrt(2))
      @y += a/(8*Math.sqrt(2))
      increase_steps
    else
      check_event_trigger_touch_ISOaddon1(@x-1, @y+1)
    end
  end
  #--------------------------------------------------------------------------
  def update_jump_lower_right(turn_enabled = true)
    if turn_enabled
      turn_lower_right
    end
    a = (@course ? 1.2 : 0.8)
    c_d = true
    if passable?(@x, @y, 6, a, c_d) and event_pass?(@x, @y, 6, a, c_d)
      turn_lower_right
      @x += a/(8*Math.sqrt(2))
      @y += a/(8*Math.sqrt(2))
      increase_steps
    else
      check_event_trigger_touch_ISOaddon1(@x+1, @y+1)
    end
  end
  #--------------------------------------------------------------------------
  def update_jump_upper_left(turn_enabled = true)
    if turn_enabled
      turn_upper_left
    end
    a = (@course ? 1.2 : 0.8)
    c_d = true
    if passable?(@x, @y, 4, a, c_d) and event_pass?(@x, @y, 4, a, c_d)
      turn_upper_left
      @x -= a/(8*Math.sqrt(2))
      @y -= a/(8*Math.sqrt(2))
      increase_steps
    else
      check_event_trigger_touch_ISOaddon1(@x-1, @y-1)
    end
  end
  #--------------------------------------------------------------------------
  def update_jump_upper_right(turn_enabled = true)
    if turn_enabled
      turn_upper_right
    end
    a = (@course ? 1.2 : 0.8)
    c_d = true
    if passable?(@x, @y, 8, a, c_d) and event_pass?(@x, @y, 8, a, c_d)
      turn_upper_right
      @x += a/(8*Math.sqrt(2))
      @y -= a/(8*Math.sqrt(2))
      increase_steps
    else
      check_event_trigger_touch_ISOaddon1(@x+1, @y-1)
    end
  end
  #--------------------------------------------------------------------------
  def passable?(x, y, d, a = 1.0, c_d = false)
    if @through
      return true
    end
    if !c_d
      case d
      when 6
        new_x = (x + a/8 + 0.95).to_i
        new_y = y.to_i
        new_x_2 = new_x
        new_y_2 = (y + 0.95).to_i
      when 4
        return false if x - a/8 < 0
        new_x = (x - a/8).to_i
        new_y = y.to_i
        new_x_2 = new_x
        new_y_2 =  (y + 0.95).to_i
      when 2
        new_x = x.to_i
        new_y = (y + a/8 + 0.95).to_i
        new_x_2 =  (x + 0.95).to_i
        new_y_2 = new_y
      when 8
        return false if y - a/8 < 0
        new_x = x.to_i
        new_y = (y - a/8).to_i
        new_x_2 = (x + 0.95).to_i
        new_y_2 = new_y
      else
        new_x = (x+0.5).to_i
        new_y = (y+0.5).to_i
        new_x_2 = new_x
        new_y_2 = new_y
      end
    else
      case d
      when 6
        new_x = (x + a/(8*Math.sqrt(2)) + 0.95).to_i
        new_y = (y + a/(8*Math.sqrt(2)) + 0.95).to_i
        new_x_2 = (x + a/(8*Math.sqrt(2)) + 0.95).to_i
        new_y_2 = y.to_i
        new_x_3 = x.to_i
        new_y_3 = (y + a/(8*Math.sqrt(2)) + 0.95).to_i
        unless $game_map.passable_p?(new_x_3, new_y_3, d, self)
          return false
        end
      when 4
        return false if (x - a/(8*Math.sqrt(2)) < 0 or y - a/(8*Math.sqrt(2)) < 0)
        new_x = (x - a/(8*Math.sqrt(2))).to_i
        new_y = (y - a/(8*Math.sqrt(2))).to_i
        new_x_2 = (x - a/(8*Math.sqrt(2))).to_i
        new_y_2 = y.to_i
        new_x_3 = x.to_i
        new_y_3 = (y - a/(8*Math.sqrt(2))).to_i
        unless $game_map.passable_p?(new_x_3, new_y_3, d, self)
          return false
        end
      when 2
        return false if x - a/(8*Math.sqrt(2)) < 0
        new_x = (x - a/(8*Math.sqrt(2))).to_i
        new_y = (y + a/(8*Math.sqrt(2)) + 0.95).to_i
        new_x_2 = (x - a/(8*Math.sqrt(2))).to_i
        new_y_2 = y.to_i
        new_x_3 = x.to_i
        new_y_3 = (y + a/(8*Math.sqrt(2)) + 0.95).to_i
        unless $game_map.passable_p?(new_x_3, new_y_3, d, self)
          return false
        end
      when 8
        return false if y - a/(8*Math.sqrt(2)) < 0
        new_x = (x + a/(8*Math.sqrt(2)) + 0.95).to_i
        new_y = (y - a/(8*Math.sqrt(2))).to_i
        new_x_2 = (x + a/(8*Math.sqrt(2)) + 0.95).to_i
        new_y_2 = y.to_i
        new_x_3 = x.to_i
        new_y_3 = (y - a/(8*Math.sqrt(2))).to_i
        unless $game_map.passable_p?(new_x_3, new_y_3, d, self)
          return false
        end
      else
        new_x = (x+0.5).to_i
        new_y = (y+0.5).to_i
        new_x_2 = new_x
        new_y_2 = new_y
      end
    end
    unless $game_map.passable_p?(new_x, new_y, d, self)
      return false
    end
    unless $game_map.passable_p?(new_x_2, new_y_2, d, self)
      return false
    end
    return true
  end
  #--------------------------------------------------------------------------
  def event_pass?(x, y, d, a, c_d)
    if !c_d
      case d
      when 6
        new_x = x + a/8
        new_y = y
      when 4
        new_x = x - a/8
        new_y = y
      when 2
        new_y = y + a/8
        new_x = x
      when 8
        new_y = y - a/8
        new_x = x
      else
        new_x = x
        new_y = y
      end
    else
      case d
      when 6
        new_x = x + a/(8*Math.sqrt(2))
        new_y = y + a/(8*Math.sqrt(2))
      when 4
        new_x = x - a/(8*Math.sqrt(2))
        new_y = y - a/(8*Math.sqrt(2))
      when 2
        new_y = y + a/(8*Math.sqrt(2))
        new_x = x - a/(8*Math.sqrt(2))
      when 8
        new_y = y - a/(8*Math.sqrt(2))
        new_x = x + a/(8*Math.sqrt(2))
      else
        new_x = x
        new_y = y
      end
    end
    for event in $game_map.events.values
      m = ((((((event.real_x).to_f)/128)*8).to_i).to_f)/8
      n = ((((((event.real_y).to_f)/128)*8).to_i).to_f)/8
      if Math.sqrt((m-new_x)**2 + (n-new_y)**2) < 0.7
        unless event.through
          if self != $game_player
            return false
          end
          if event.character_name != ""
            return false
          end
        end
      end
    end
    return true
  end
  #--------------------------------------------------------------------------
  def bloqué_down?
    if self.bloqué_down
      a = (@course ? 1.5 : 1.0)
      new_x = (self.x + 0.500).to_i
      new_y = (self.y + a/8 + 0.95).to_i
      if $game_map.passable_p?(new_x, new_y, @direction, self) and
        !$game_map.passable_p?((self.x).to_i, new_y, @direction, self)
        @direction = 6
        rect_right_ISOaddon1
      else
        new_x = (self.x + 0.495).to_i
        new_y = (self.y + a/8 + 0.95).to_i
        if $game_map.passable_p?((self.x).to_i, new_y, @direction, self) and
          $game_map.passable_p?(new_x, new_y, @direction, self)
          @direction = 4
          rect_left_ISOaddon1
        end
      end
      self.bloqué_down = true
    end
  end
  #--------------------------------------------------------------------------
  def bloqué_up?
    if self.bloqué_up
      a = (@course ? 1.5 : 1.0)
      return if self.y - a/8 < 0
      new_x = (self.x + 0.500).to_i
      new_y = (self.y - a/8).to_i
      if $game_map.passable_p?(new_x, new_y, @direction, self) and
        !$game_map.passable_p?((self.x).to_i, new_y, @direction, self)
        @direction = 6
        rect_right_ISOaddon1
      else
        new_x = (self.x + 0.495).to_i
        new_y = (self.y - a/8).to_i
        if $game_map.passable_p?((self.x).to_i, new_y, @direction, self) and
          $game_map.passable_p?(new_x, new_y, @direction, self)
          @direction = 4
          rect_left_ISOaddon1
        end
      end
      self.bloqué_up = true
    end
  end
  #--------------------------------------------------------------------------
  def bloqué_left?
    if self.bloqué_left
      a = (@course ? 1.5 : 1.0)
      return if self.x - a/8 < 0
      new_x = (self.x - a/8).to_i
      new_y = (self.y + 0.500).to_i
      if $game_map.passable_p?(new_x, new_y, @direction, self) and
        !$game_map.passable_p?(new_x, (self.y).to_i, @direction, self)
        @direction = 2
        rect_down_ISOaddon1
      else
        new_x = (self.x - a/8).to_i
        new_y = (self.y + 0.495).to_i
        if $game_map.passable_p?(new_x, (self.y).to_i, @direction, self) and
          $game_map.passable_p?(new_x, new_y, @direction, self)
          @direction = 8
          rect_up_ISOaddon1
        end
      end
      self.bloqué_left = true
    end
  end
  #--------------------------------------------------------------------------
  def bloqué_right?
    if self.bloqué_right
      a = (@course ? 1.5 : 1.0)
      new_x = (self.x + a/8 + 0.95).to_i
      new_y = (self.y + 0.500).to_i
      if $game_map.passable_p?(new_x, new_y, @direction, self) and
        !$game_map.passable_p?(new_x, (self.y).to_i, @direction, self)
        @direction = 2
        rect_down_ISOaddon1
      else
        new_x = (self.x + a/8 + 0.95).to_i
        new_y = (self.y + 0.495).to_i
        if $game_map.passable_p?(new_x, (self.y).to_i, @direction, self) and
          $game_map.passable_p?(new_x, new_y, @direction, self)
          @direction = 8
          rect_up_ISOaddon1
        end
      end
      self.bloqué_right = true
    end
  end
  #--------------------------------------------------------------------------
  def rect_down_ISOaddon1(turn_enabled = true)
    @x = (((8*@x).to_i).to_f)/8
    @y = (((8*@y).to_i).to_f)/8
    if @direction == 2 and event_pass?(@x, @y, 2, 1.0, false)
      turn_down
      @y += 1.0/8
      increase_steps
    else
      check_event_trigger_touch_ISOaddon1(@x, @y+1)
    end
    if turn_enabled and @direction != 2
      turn_down
    end
  end
  #--------------------------------------------------------------------------
  def rect_left_ISOaddon1(turn_enabled = true)
    @x = (((8*@x).to_i).to_f)/8
    @y = (((8*@y).to_i).to_f)/8
    if @direction == 4 and event_pass?(@x, @y, 4, 1.0, false)
      turn_left
      @x -= 1.0/8
      increase_steps
    else
      check_event_trigger_touch_ISOaddon1(@x-1, @y)
    end
    if turn_enabled and @direction != 4
      turn_left
    end
  end
  #--------------------------------------------------------------------------
  def rect_right_ISOaddon1(turn_enabled = true)
    @x = (((8*@x).to_i).to_f)/8
    @y = (((8*@y).to_i).to_f)/8
    if @direction == 6 and event_pass?(@x, @y, 6, 1.0, false)
      turn_right
      @x += 1.0/8
      increase_steps
    else
      check_event_trigger_touch_ISOaddon1(@x+1, @y)
    end
    if turn_enabled and @direction != 6
      turn_right
    end
  end
  #--------------------------------------------------------------------------
  def rect_up_ISOaddon1(turn_enabled = true)
    @x = (((8*@x).to_i).to_f)/8
    @y = (((8*@y).to_i).to_f)/8
    if @direction == 8 and event_pass?(@x, @y, 8, 1.0, false)
      turn_up
      @y -= 1.0/8
      increase_steps
    else
      check_event_trigger_touch_ISOaddon1(@x, @y-1)
    end
    if turn_enabled and @direction != 8
      turn_up
    end
  end
end

#==============================================================================
# ■ Sprite_Character
#==============================================================================
class Sprite_Character
  alias update_orig update
  def update
    update_orig
    if @character == $game_player
      a=""
      a+="Diag" if !@character.diagonal
      a+="Courir" if @character.course
      a+="Sauter" if @character.jumping?
      self.bitmap = RPG::Cache.character(@character.character_name+a, @character.character_hue)
      @cw = bitmap.width / 4
      @ch = bitmap.height / 4
      self.ox = @cw / 2
      self.oy = @ch
      sx = @character.pattern * @cw
      if !@character.diagonal
        sy = (@character.direction - 2) / 2 * @ch
      else
        dir = @character.direction * 2
        dir -= 10 if dir > 10
        sy = (dir - 2) / 2 * @ch
      end
      self.src_rect.set(sx, sy, @cw, @ch)
    end
  end
end

#==============================================================================
# ■ Scene_Map
#==============================================================================
class Scene_Map
  def update
    loop do
      $game_map.update
      $game_system.map_interpreter.update
      $game_player.update
      $game_system.update
      $game_screen.update
      unless $game_temp.player_transferring
        break
      end
      transfer_player
      if $game_temp.transition_processing
        break
      end
    end
    @spriteset.update
    @message_window.update
    if $game_temp.gameover
      $scene = Scene_Gameover.new
      return
    end
    if $game_temp.to_title
      $scene = Scene_Title.new
      return
    end
    if $game_temp.transition_processing
      $game_temp.transition_processing = false
      if $game_temp.transition_name == ""
        Graphics.transition(20)
      else
        Graphics.transition(40, "Graphics/Transitions/" +
          $game_temp.transition_name)
      end
    end
    if $game_temp.message_window_showing
      return
    end
    if $game_player.encounter_count == 0 and $game_map.encounter_list != []
      unless $game_system.map_interpreter.running? or
             $game_system.encounter_disabled
        n = rand($game_map.encounter_list.size)
        troop_id = $game_map.encounter_list[n]
        if $data_troops[troop_id] != nil
          $game_temp.battle_calling = true
          $game_temp.battle_troop_id = troop_id
          $game_temp.battle_can_escape = true
          $game_temp.battle_can_lose = false
          $game_temp.battle_proc = nil
        end
      end
    end
    if Input.trigger?(Input::Z)
      unless $game_system.map_interpreter.running? or
             $game_system.menu_disabled
        $game_temp.menu_calling = true
        $game_temp.menu_beep = true
      end
    end
    if Input.trigger?(Input::A) and $game_switches[$num_interrupteur_sauter.to_i] and
      !$game_player.jumping?
      $game_player.jump_ISOaddon1(0,0)
    end
    if Input.trigger?(Input::L)
      print($game_player.x, $game_player.y)
    end
    if Input.press?(Input::B) and $game_switches[$num_interrupteur_courir.to_i]
      $game_player.mode_course
    else $game_player.mode_marche
    end
    if $DEBUG and Input.press?(Input::F9)
      $game_temp.debug_calling = true
    end
    unless $game_player.moving?
      if $game_temp.battle_calling
        call_battle
      elsif $game_temp.shop_calling
        call_shop
      elsif $game_temp.name_calling
        call_name
      elsif $game_temp.menu_calling
        call_menu
      elsif $game_temp.save_calling
        call_save
      elsif $game_temp.debug_calling
        call_debug
      end
    end
  end
end

[kriss]

je viens de tester et j'ai donc une question.

Ce script permet, d'apres ce que j'ai vu, de changer le déplacement : au lieu de faire haut/bas/droite/gauche, on se déplace en diagonal...

Je n'ai pas bien compris pourquoi créer 2 maps + ajouter le script au lieu de faire sa map directement en iso + script de déplacement en iso.


Ma question est donc.. qu'est ce qu'on gagne à faire les events dans une map différente de la map de rendu ?
- Est ce que c'est pour simplifier la gestion des passabilités ?
- Y a t'il des fonctionnalités que tu vas ajouter ?

[MGC]

Pour placer les évènements sur la carte de rendu, il faudrait savoir où les placer exactement, car les cases en forme de losange ne correspondent pas aux carreaux de 32*32 pixels initiaux.
Ce système est en effet principalement fait pour les problèmes de passabilités en carte isométrique.
Mais en fait ce script ne permet pas de changer le déplacement : les personnages se déplacent toujours en haut/bas/gauche/droite. C'est juste le rendu à l'écran qui fait penser à du déplacement en diagonal.

[Krazplay]

Je dois avouer que pour faire de l'isométrique bien propre c'est vraiment classe, ça permet de résoudre le problèmes des cases qui ne sont à la base pas faites pour de l'isométrique.

Par contre, la fonction saut était-elle bien utile ? Je n'ai pas vérifié si elle permet vraiment de sauter de petits obstacles, et elle provoque pas mal de bugs graphiques...

Sinon ce n'est qu'un avis personnel, mais il me semble plus naturel que la touche haut nous fasse avancer en haut-droite plutôt que haut dans un jeu en perspective isométrique, je ne sais pas ce que les autres en pense.

Dans tout les cas, et quoi que tu en dises, c'est de l'excellent travail

[kriss]

c'est de mieux en mieux ... (avec le saut c'est vraiment excellent).
Le saut ne permet pas de passer par dessus un personnage , mais je suppose qu'il faudrais le gerer en script (ou event) avec une detection de la collision du hero + de son état (ici "saut") pour déterminer par exemple qu'il peut aller sur un carré de sol (qui serait en hauteur)

J'ai remarqué que lorsque l'on va à droite ou à gauche, le heros semble courrir, contrairement aux autres directions.

Je n'ai pas trouvé la touche pour courrir (c'est Z pour sauter).

Coupler avec le script de plate forme je pense que l'on pourrait faire un jeu tres sympatique: reste à faire les chara et les décors  en iso ^^

Pour les problemes d'event je pense qu'effectivement ton script va s'averer tres utile, car il permet de faire une map avec 1 event activable si le hero passe dessus (c'est un exemple), alors qu'en temps normal il faudrait faire plusieurs events tout autour de l'endroit où on veut faire le test.

Je trouve que c'est du tres bon boulot et ca peut contribuer à voir plus de projets iso

[MGC]

Krazplay -> c'est vrai que le saut ne sert pour l'instant à rien du tout. Mais comme j'envisageais par la suite de peut-être gérer des hauteurs différentes (façon Final Fantasy Tactics), je me suis dit qu'un système de sauts déjà mis en place serait un plus. Et je peux toujours essayer de faire une compatibilité avec mon script de plate-formes.
Mais c'est vrai qu'il y a encore des problèmes de collision.
Pour les touches, je ne sais pas trop quoi prendre : si cela gêne vraiment, je veux bien les changer, mais j'aimerais avoir plusieurs avis.

kriss -> en fait le héros va à la même vitesse dans les 8 directions. Seulement avec la perspective (la carte est un peu écrasée), un carreau vers le bas de l'écran est visuellement plus proche qu'un carreau vers la droite ou la gauche. D'où l'impression de différentes vitesses.
Pour les touches, cela doit être du au fait que je dispose d'un clavier "qwertz" allemand, et je pense qu'il faut que tu redéfinisses les touches (courir est normalement le bouton de menu B, et le menu est accessible par Z (pas au clavier, c'est le bouton de jeu)).
C'est vrai que faire les chara en iso peu sembler assez lourd, mais j'ai bien réussi à en faire quelques uns de potables alors que le dessin n'est pas trop mon point fort.

EDIT : J'ai modifié à peu près tout le système de gestion de collisions, et j'en ai profité pour changer les touches de la manière proposée par Krazplay. Je ne sais pas trop si c'est mieux ou pas.

http://www.megaupload.com/?d=NOGDZVS9

Selon les avis, j'éditerai ou non le script un peu plus haut.

[kriss]

le nouveau déplacement ne me gene pas plus que l'ancien ^^, néansmoins il faudrait redéfinir les animations de saut qui ne sont plus compatible avec le déplacement (un saut en appuyant sur la touche gauche devrait donner gauche/haut, hors ca donne saut à gauche).

Tu as dit que la sensation de vitesse de déplacement à droite et à gauche est due à l'inclinaison : ne serait il pas judicieux alors de reduire en script la vitesse afin que lorsque l'on se déplace dans les 8 directions nous n'ayons pas de sensation de changement de vitesse en fonction de la direction ?

j'ai trouvé la touche pour courrir (X). ^^.

Tu as modifié le systeme de collision .. il y avait des problemes?

Pour mon projet je ne vais pas utiliser d'iso, donc ce n'est pas pour moi que je le dis mais pour d'hypotethiques futurs projets iso :
-  je pense que tu devrais permettre un saut plus grand en mode course
- faire une detection de la hauteur avec la possibilité de sauter sur une case plus haute (si elle n'est pas trop haute)
- il faudrait pouvoir utiliser le pavé numerique, beaucoup plus souple pour l'utilisation des 8 directions

En tout cas chapeau

[MGC]

Bon, juste quelques petites modifications : les touches de saut ont été redéfinies, et comme il était difficile de passer entre deux obstacles (il fallait être pile au milieu), j'ai fait en sorte que pour les quatre directions de base le personnage se déplace automatiquement pour se recentrer (quand il est quand même assez près du centre).

http://www.megaupload.com/?d=32N8KKN0

Le système de collision actuel est plus propre au niveau du script, et je pense qu'il y a moins de bugs de collisions avec les évènements.
Pour l'histoire de changement de vitesses je vais essayer pour voir ce que cela donne.
Pour ce qui est de l'utilisation du pavé numérique, je ne suis pas sûr que cela soit vraiment plus souple (avec 8 touches les doigts doivent plus se déplacer...). Je crois que le plus simple est encore d'acheter un joypad.
Et pour la gestion de la hauteur, cela viendra, mais dans un peu de temps quand même (ça risque d'être pas très simple à coder).

[Bahamuth]

Je ne sais pas si l'on a deja repéré ce bug, mais dans la derniere demo que tu poste, il est impossible d'utiliser la commande Evenement : Deplacer un evenement, cela nous renvoie a une erreur d'argement ( 3 sur 5 ) de Game Actor 3, ligne 42...
Donc voila, a moins d'utiliser le script de path finding, on peut pas deplacer des evenement   :cry: ...
Sinon excellent script, vraiment excellent 

[MGC]

Merci pour avoir signalé ce bug.
J'ai édité les messages précédents avec une version qui, normalement, fonctionne mieux à ce niveau là.

[Siegfried]

Et moi qui était fier de mon tout premier script perso...
J'espère que le tien va résoudre mes problèmes de collision...
( Je vais essayer de fusionner les 2 )

Edit : Je remplace par le tien ! XD
Le mien ne gèrait que le héros...
Par contre, un problème.
Il y aurait possibilité que ça ne le fasse que sur des maps et pas d'autres ?
En gros, lance l'iso par une commande d'appel.
Ca me parait impossible vu le nombre de trucs gèrés...
( Je n'utilise pas l'add-on ).

[MGC]

Impossible ? Pas si sûr...

J'ai un peu modifié le script (enfin pas mal quand même) pour qu'il lance le mode Iso par appel (non compatible avec l'add-on).
Pour l'appeler, il faut que dans le nom de la carte de données il y ait "2DISO".
A part ça il faut aussi que le nom du fichier de character du héros en diagonal soit celui qui n'est pas en diagonal + "Diag".

Voilà le code :

Code:

#---------------------------------------------------------------------------------------------------------------
# ● Script 2D_ISO, créé par MGCaladtogel pour la communauté rpgmakerxp-factory.net
#    maj 16/08/06 avec appel pour le mode Iso
#---------------------------------------------------------------------------------------------------------------
#==============================================================================
# ■ Ajouts, modifications des classes d'origine
#
# indications : $game_map désigne la carte de données
#               $game_map_iso désigne la carte en 2D-isométrique
#==============================================================================

#==============================================================================
# ■ Game_Map
#==============================================================================
class Game_Map
  alias scroll_down_origine scroll_down
  alias scroll_right_origine scroll_right
  #--------------------------------------------------------------------------
  def scroll_down(distance)
    $game_system.isométrie ? scroll_down_iso(distance) : scroll_down_origine(distance)
  end
  #--------------------------------------------------------------------------
  def scroll_right(distance)
    $game_system.isométrie ? scroll_right_iso(distance) : scroll_right_origine(distance)
  end
  #--------------------------------------------------------------------------
  # ● Le scrolling doit s'effectuer en fonctions des dimensions de la carte
  #     en isométrique
  #--------------------------------------------------------------------------
  def scroll_down_iso(distance)
    corr = (($game_map.height + $game_map.width)%2 == 0 ? 0 : 4*16)
    @display_y = [@display_y + distance, 128*$game_map_iso.height - 4*480 - corr].min
  end
  #--------------------------------------------------------------------------
  def scroll_right_iso(distance)
    @display_x = [@display_x + distance, 128*$game_map_iso.width - 4 * 640].min
  end
end

#==============================================================================
# ■ Game_Character
#==============================================================================
class Game_Character
  alias screen_x_origine screen_x
  alias screen_y_origine screen_y
  alias screen_z_origine screen_z
  #--------------------------------------------------------------------------
  def screen_x
    $game_system.isométrie ? screen_x_iso : screen_x_origine
  end
  #--------------------------------------------------------------------------
  def screen_y
    $game_system.isométrie ? screen_y_iso : screen_y_origine
  end
  #--------------------------------------------------------------------------
  def screen_z(height = 0)
    $game_system.isométrie ? screen_z_iso(height) : screen_z_origine(height)
  end
  #--------------------------------------------------------------------------
  # ● On change les coordonnées d'affichage des characters à l'écran
  #--------------------------------------------------------------------------
  def screen_x_iso
    return  (@real_x - @real_y)/4 + 32*$game_map.height - 0 - $game_map.display_x/4
  end
  #--------------------------------------------------------------------------
  def screen_y_iso
    y = (@real_y + @real_x) / 8 + 24 - $game_map.display_y/4
    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 screen_z_iso(height = 0)
    if @always_on_top
      return 999
    end
    z = screen_y
    if @tile_id > 0
      return z + $game_map_iso.priorities[@tile_id] * 32
    else
      return z + ((height > 32) ? 31 : 0)
    end
  end
end

#==============================================================================
# ■ Game_Player
#==============================================================================
class Game_Player < Game_Character
  alias update_origine update
  alias center_origine center
  def update
    $game_system.isométrie ? update_iso : update_origine
  end
  #--------------------------------------------------------------------------
  def center(x, y)
    $game_system.isométrie ? center_iso(x, y) : center_origine(x, y)
  end
  #--------------------------------------------------------------------------
  def center_iso(x, y)
    max_x = ($game_map.width - 20) * 128
    max_y = ($game_map.height - 15) * 128
    max_xy = [max_x, max_y].max
    $game_map.display_x = 2*max_xy
    $game_map.display_y = 2*max_xy
  end
  #--------------------------------------------------------------------------
  # ● Les commandes directionnelles en diagonale sont activées, et on s'arrange
  #     pour que le scrolling se passe bien
  #--------------------------------------------------------------------------
  def update_iso
    last_moving = moving?
    unless moving? or $game_system.map_interpreter.running? or
           @move_route_forcing or $game_temp.message_window_showing
      case Input.dir8
      when 1..2
        move_down
      when 3
        move_right
      when 4
        move_left
      when 7
        move_left
      when 6
        move_right
      when 8..9
        move_up
      end
    end
    last_real_x = @real_x
    last_real_y = @real_y
    if jumping?
      update_jump
    elsif moving?
      update_move
    else
      update_stop
    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
    if @wait_count > 0
      @wait_count -= 1
      return
    end
    if @move_route_forcing
      move_type_custom
      return
    end
    if @starting or lock?
      return
    end
    if @stop_count > (40 - @move_frequency * 2) * (6 - @move_frequency)
      case @move_type
      when 1
        move_type_random
      when 2
        move_type_toward_player
      when 3
        move_type_custom
      end
    end
    disp_y = screen_y + $game_map.display_y/4
    disp_x = screen_x + $game_map.display_x/4
    if CENTER_Y - (4*disp_y - $game_map.display_y) < 0
      $game_map.scroll_down(4*disp_y - $game_map.display_y - CENTER_Y)
    end
    if CENTER_X - (4*disp_x - $game_map.display_x) > 0
      $game_map.scroll_left(CENTER_X - (4*disp_x - $game_map.display_x))
    end
    if CENTER_X - (4*disp_x - $game_map.display_x) < 0
      $game_map.scroll_right(4*disp_x - $game_map.display_x - CENTER_X)
    end
    if CENTER_Y - (4*disp_y - $game_map.display_y) > 0
      $game_map.scroll_up(CENTER_Y - (4*disp_y - $game_map.display_y))
    end
    unless moving?
      if last_moving
        result = check_event_trigger_here([1,2])
        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
end

#==============================================================================
# ■ Scene_Title
#==============================================================================
class Scene_Title
  alias main_orig main
  #--------------------------------------------------------------------------
  # ● Dans MapInfos on va trouver l'identité de la carte parente à la carte
  #     de données (donc l'id de la carte en iso)
  #--------------------------------------------------------------------------
  def main
    $data_map_infos        = load_data("Data/MapInfos.rxdata")
    main_orig
  end
end

#==============================================================================
# ■ Spriteset_Map
#==============================================================================
class Spriteset_Map
  alias update_origine update
  alias initialize_origine initialize
  #--------------------------------------------------------------------------
  def initialize
    map_infos = $data_map_infos[$game_map.map_id]
    $game_system.isométrie = (map_infos.name.include?("2DISO") ? true : false)
    $game_system.isométrie ? initialize_iso : initialize_origine
  end
  #--------------------------------------------------------------------------
  # ● On va associer à la tilemap, qui gère l'affichage de la carte à l'écran,
  #     les données de la carte en 2D-isométrique
  #--------------------------------------------------------------------------
  def initialize_iso
    @viewport1 = Viewport.new(0, 0, 640, 480)
    @viewport2 = Viewport.new(0, 0, 640, 480)
    @viewport3 = Viewport.new(0, 0, 640, 480)
    @viewport2.z = 200
    @viewport3.z = 5000
    @tilemap = Tilemap.new(@viewport1)
    map_infos = $data_map_infos[$game_map.map_id]
    $game_map_iso = Game_Map.new
    $game_map_iso.setup(map_infos.parent_id)
    @tilemap.tileset = RPG::Cache.tileset($game_map_iso.tileset_name)
    for i in 0..6
      autotile_name = $game_map.autotile_names[i]
      @tilemap.autotiles[i] = RPG::Cache.autotile(autotile_name)
    end
    @tilemap.map_data = $game_map_iso.data
    @tilemap.priorities = $game_map_iso.priorities
    @panorama = Plane.new(@viewport1)
    @panorama.z = -1000
    @fog = Plane.new(@viewport1)
    @fog.z = 3000
    @character_sprites = []
    for i in $game_map.events.keys.sort
      sprite = Sprite_Character.new(@viewport1, $game_map.events[i])
      @character_sprites.push(sprite)
    end
    @character_sprites.push(Sprite_Character.new(@viewport1, $game_player))
    @weather = RPG::Weather.new(@viewport1)
    @picture_sprites = []
    for i in 1..50
      @picture_sprites.push(Sprite_Picture.new(@viewport2,
        $game_screen.pictures[i]))
    end
    @timer_sprite = Sprite_Timer.new
    update
  end
  #--------------------------------------------------------------------------
  # ● Attention : pour ma carte test j'ai fait en sorte que le panorama bouge
  #     de la même façon que la tilemap.
  #     Pour retrouver le déplacement d'origine des panoramas, il faut changer :
  #       @panorama.ox = $game_map.display_x / 4
  #       @panorama.oy = $game_map.display_y / 4
  #     en :
  #       @panorama.ox = $game_map.display_y / 8
  #       @panorama.oy = $game_map.display_y / 8
  #--------------------------------------------------------------------------
  def update
    $game_system.isométrie ? update_iso : update_origine
  end
  #--------------------------------------------------------------------------
  def update_iso
    if @panorama_name != $game_map_iso.panorama_name or
       @panorama_hue != $game_map_iso.panorama_hue
      @panorama_name = $game_map_iso.panorama_name
      @panorama_hue = $game_map_iso.panorama_hue
      if @panorama.bitmap != nil
        @panorama.bitmap.dispose
        @panorama.bitmap = nil
      end
      if @panorama_name != ""
        @panorama.bitmap = RPG::Cache.panorama(@panorama_name, @panorama_hue)
      end
      Graphics.frame_reset
    end
    if @fog_name != $game_map_iso.fog_name or @fog_hue != $game_map_iso.fog_hue
      @fog_name = $game_map_iso.fog_name
      @fog_hue = $game_map_iso.fog_hue
      if @fog.bitmap != nil
        @fog.bitmap.dispose
        @fog.bitmap = nil
      end
      if @fog_name != ""
        @fog.bitmap = RPG::Cache.fog(@fog_name, @fog_hue)
      end
      Graphics.frame_reset
    end
    @tilemap.ox = $game_map.display_x / 4
    @tilemap.oy = $game_map.display_y / 4
    @tilemap.update
    @panorama.ox = $game_map.display_x / 4
    @panorama.oy = $game_map.display_y / 4
    @fog.zoom_x = $game_map_iso.fog_zoom / 100.0
    @fog.zoom_y = $game_map_iso.fog_zoom / 100.0
    @fog.opacity = $game_map_iso.fog_opacity
    @fog.blend_type = $game_map_iso.fog_blend_type
    @fog.ox = $game_map.display_x / 4 + $game_map.fog_ox
    @fog.oy = $game_map.display_y / 4 + $game_map.fog_oy
    @fog.tone = $game_map.fog_tone
    for sprite in @character_sprites
      sprite.update
    end
    @weather.type = $game_screen.weather_type
    @weather.max = $game_screen.weather_max
    @weather.ox = $game_map.display_x / 4
    @weather.oy = $game_map.display_y / 4
    @weather.update
    for sprite in @picture_sprites
      sprite.update
    end
    @timer_sprite.update
    @viewport1.tone = $game_screen.tone
    @viewport1.ox = $game_screen.shake
    @viewport3.color = $game_screen.flash_color
    @viewport1.update
    @viewport3.update
  end
end

#==============================================================================
# ■ Interpreter
#==============================================================================
class Interpreter
  #--------------------------------------------------------------------------
  # ● Commande : "Modifier les propriétés de la carte..."
  #--------------------------------------------------------------------------
  def command_204
    map = ($game_system.isométrie ? $game_map_iso : $game_map)
    case @parameters[0]
    when 0
      map.panorama_name = @parameters[1]
      map.panorama_hue = @parameters[2]
    when 1
      map.fog_name = @parameters[1]
      map.fog_hue = @parameters[2]
      map.fog_opacity = @parameters[3]
      map.fog_blend_type = @parameters[4]
      map.fog_zoom = @parameters[5]
      map.fog_sx = @parameters[6]
      map.fog_sy = @parameters[7]
    when 2
      map.battleback_name = @parameters[1]
      $game_temp.battleback_name = @parameters[1]
    end
    return true
  end
  #--------------------------------------------------------------------------
  # ● Commande : "Modifier le ton du brouillard..."
  #--------------------------------------------------------------------------
  def command_205
    map = ($game_system.isométrie ? $game_map_iso : $game_map)
    map.start_fog_tone_change(@parameters[0], @parameters[1] * 2)
    return true
  end
  #--------------------------------------------------------------------------
  # ● Commande : "Modifier l'opacité du brouillard..."
  #--------------------------------------------------------------------------
  def command_206
    map = ($game_system.isométrie ? $game_map_iso : $game_map)
    map.start_fog_opacity_change(@parameters[0], @parameters[1] * 2)
    return true
  end
end

#==============================================================================
# ■ Sprite_Character
#==============================================================================
class Sprite_Character < RPG::Sprite
  alias update_origine update
  def update
    update_origine
    if @character == $game_player
      if $game_system.isométrie
        self.bitmap = RPG::Cache.character(@character.character_name+"Diag", @character.character_hue)
      else
        self.bitmap = RPG::Cache.character(@character.character_name, @character.character_hue)
      end
      @cw = bitmap.width / 4
      @ch = bitmap.height / 4
      self.ox = @cw / 2
      self.oy = @ch
      sx = @character.pattern * @cw
      sy = (@character.direction - 2) / 2 * @ch
      self.src_rect.set(sx, sy, @cw, @ch)
    end
  end
end
 
#==============================================================================
# ■ Game_System
#==============================================================================
class Game_System
  attr_accessor :isométrie
  alias initialize_origine initialize
  def initialize
    initialize_origine
    self.isométrie = false
  end
end

Quand j'ai fait ces modifications, je me suis rendu compte qu'il y avait quelques petits bugs dans le premier script posté (dont tout de même la méthode "center(x, y)" manquante).
Je l'ai donc édité (mais faites attention, les "démos" ne sont pas à jour).

[Arvester]

C'est indécent, un tel niveau en Ruby. :cheesy:

Tous mes compliments, la démo est magnifique, j'attends de voir avec les MAJ...