Auteur : McCaladtogel

Description :

J’avais il y a pas mal de temps déjà créé un script d’effet de profondeur pour les maps, mais il y avait pas mal de bugs. Ensuite Mewsterus a créé un script analogue, bien plus joli (effet d’escalier réduit, horizon plus lointain), mais avec moins d’options (pas d’animations d’autotiles, pas de répétabilité des cartes…).

J’ai donc décidé d’améliorer mon script pour avoir un script d’effet de profondeur qui tienne vraiment la route.

Les améliorations qu’apporte ce nouveau script :
- pas d’effet de rouleau : les cartes paraissent planes
- pas d’effet d’escalier (chaque ligne de l’écran est gérée indépendamment des autres)
- pour une même qualité, moins de lag
- contient la plupart des options des anciens scripts
- carte se lançant plus rapidement une fois déjà dessinée (plus d’attente en sortant du menu)

NB : (Script édité le 02/05/07 pour avoir un affichage du nom de la carte sans les commandes)

Explications :

Il faut rajouter dans le nom de la carte (façon script de Mewsterus) :

Code: Tout sélectionner

- [M7]  : la carte sera dessinée avec de la profondeur
- [#XX] : degré d'inclinaison de la carte (exemple : [#30] pour une inclinaison de 30 degrés). Si ce terme est omis, l'inclinaison est de 0 degré, c'est-à-dire la carte en vue normale
- [Y]   : la carte se répète en hauteur
- [X]   : la carte se répète en largeur. Contrairement à [Y], cette option demande plus de ressources pendant le jeu (fps plus faible)
- [A]   : active l'animation des autotiles animés (à 4 dessins). Cette option ne demande pas de ressources pendant le jeu, mais augmente de façon très significative le temps de lancement de la carte, ce qui peut provoquer une erreur pour les cartes trop grandes
- [S]   : la carte restera centrée sur le héros, même sur les bords des petites cartes
- [P]   : fixe l'image de panorama par rapport à l'écran
- [B]   : donne un effet d'horizon blanc (comme sur le screenshot)
- [OV]  : réduit l'image du héros sur la carte

La carte en profondeur correspond aux 2 premières couches. La troisième couche est dessinée « verticalement » (pour faire des arbres, une tour, etc.). Deux éléments qu’on veut distincts sur la troisième couche ne doivent pas se toucher car ils seraient interprétés par le script comme un unique sprite. La priorité de superposition est celle des tiles les plus bas dessinant l’élément de troisième couche (donc mettre des « 1 » en bas pour un arbre pour une bonne superposition avec les characters). L’axe de pivot de ces éléments se situe à un demi-carreau du bas.
Les évènements sont toujours dessinés verticalement (axe de pivot à 4 pixels du bas).

Autres commandes : grâce à la commande insérer un script dans un évènement :

$scene.spriteset.tilemap.M7_set (« angle »)
Retrace la carte avec l’angle donné

$scene.spriteset.tilemap.M7_set_p(« angle »)
Retrace la carte progressivement à partir de son angle jusqu’à l’angle donné

$scene.spriteset.tilemap.M7_redraw
Retrace la carte (sert avec les commandes en dessous)

$game_system.opacite = « valeur »
Redéfinit l’opacité des cartes avec profondeur (nécessite de retracer la carte après)

$game_system.couleur = Color.new(« Rouge », « Vert », « Bleu »)
Redéfinit le ton de la carte

$game_system.horizon = « valeur »
Redéfinit la distance d’horizon de la carte. Par défaut à 960 (30 cases derrière)

$game_system.reset
Réinitialise les valeurs au-dessus (utile si le héros change de carte)

Début du script :

Code: Tout sélectionner

#============================================================================
# Script simulant un effet de profondeur pour une carte (façon mode 7),
# créé par MGCaladtogel (22/04/07)
#
#    Instructions :
# Les éléments suivants sont à rajouter dans le nom de la carte :
# [M7]  : la carte sera dessinée avec de la profondeur
# [#XX] : degré d'inclinaison de la carte (exemple : [#30] pour une
# inclinaison de 30 degrés). Si ce terme est omis, l'inclinaison est de
# 0 degré, c'est-à-dire la carte en vue normale
# [Y]   : la carte se répète en hauteur
# [X]   : la carte se répète en largeur. Contrairement à [Y], cette option
# demande plus de ressources pendant le jeu (fps plus faible)
# [A]   : active l'animation des autotiles animés (à 4 dessins). Cette option
# ne demande pas de ressources pendant le jeu, mais augmente de façon très
# significative le temps de lancement de la carte, ce qui peut provoquer une
# erreur pour les cartes trop grandes
# [S]   : la carte restera centrée sur le héros, même sur les bords des
# petites cartes
# [P]   : fixe l'image de panorama par rapport à l'écran
# [B]   : donne un effet d'horizon blanc
# [OV]  : réduit l'image du héros sur la carte
#============================================================================
$data_cartes = load_data("Data/MapInfos.rxdata")
#============================================================================
# ■ RPG::MapInfo
#============================================================================

class RPG::MapInfo
  def name
    return @name.gsub(/[.*]/) {""}
  end
  #--------------------------------------------------------------------------
  def name2
    return @name
  end
end
#============================================================================
# ■ Game_System
#============================================================================
class Game_System
  attr_accessor :M7
  attr_accessor :repeter_x
  attr_accessor :repeter_y
  attr_accessor :tjs_scroll
  attr_accessor :couleur
  attr_accessor :opacite
  attr_accessor :anime
  attr_accessor :hor_blanc
  attr_accessor :angle
  attr_accessor :horizon
  attr_accessor :pano_fixe
  attr_accessor :ov
  attr_accessor :ov_zoom
  #--------------------------------------------------------------------------
  alias initialize_o initialize
  def initialize
    initialize_o
    reset
  end
  #--------------------------------------------------------------------------
  def reset
    self.M7 = false
    self.repeter_x = false
    self.repeter_y = false
    self.tjs_scroll = false
    self.opacite = 255
    self.couleur = Color.new(0,0,0,0)
    self.anime = false
    self.hor_blanc = false
    self.angle = 0
    self.horizon = 960
    self.pano_fixe = false
    self.ov = false
    self.ov_zoom = 0.6
  end
end
#============================================================================
# ■ Tilemap_M7
#============================================================================
class Tilemap_M7
  attr_accessor :autotiles
  attr_accessor :angle
  attr_accessor :dist_h
  attr_accessor :pivot
  attr_accessor :horizon
  #--------------------------------------------------------------------------
  def initialize(viewport)
    @id = $game_map.map_id
    @tabl_anime = []
    @disp_y = $game_map.display_y
    @disp_x = $game_map.display_x
    @hauteur = 32*$game_map.height
    @largeur = 32*$game_map.width
    $larg = @largeur
    $haut = @hauteur
    if RPG::Cache_Carte.en_cache(@id)
      @carte = RPG::Cache_Carte.load(@id)
      @tabl_anime.push(@carte)
      if $game_system.anime
        @carte_2 = RPG::Cache_Carte.load(@id, 1)
        @carte_3 = RPG::Cache_Carte.load(@id, 2)
        @carte_4 = RPG::Cache_Carte.load(@id, 3)
        @tabl_anime.push(@carte_2)
        @tabl_anime.push(@carte_3)
        @tabl_anime.push(@carte_4)
      end
    else
      dessiner_carte
    end
    data_c3 = Data_Couche3.new(viewport)
    @sprites_c3 = data_c3.liste_sprites_C3
    @sprites_c3_anime = data_c3.liste_sprites_C3_anime
    @angle = $game_system.angle
    @dist_h = 480
    @pivot = 256
    @index_anime = 0
    @viewport = viewport
    init_sprites(@angle, @dist_h, @pivot)
  end
  #--------------------------------------------------------------------------
  def dispose
    for sprite in @sprites + @sprites_c3 + @sprites_x
      sprite.dispose
    end
    @sprites.clear
    @sprites_x.clear
    @sprites_c3.clear
    @sprites_c3_anime.clear
    @tabl_anime.clear
    $game_system.angle = @angle
  end
  #--------------------------------------------------------------------------
  def inc
    return if @angle == 88
    @angle = [@angle+2, 88].min
    @sprites.clear
    @sprites_x.clear
    init_sprites(@angle, @dist_h, @pivot)
  end
  #--------------------------------------------------------------------------
  def dec
    return if @angle == 0
    @angle = [@angle-2, 0].max
    @sprites.clear
    @sprites_x.clear
    init_sprites(@angle, @dist_h, @pivot)
  end
  #--------------------------------------------------------------------------
  def M7_set_p(val)
    while val > @angle
      inc
      update
      Graphics.update
    end
    while val < @angle
      dec
      update
      Graphics.update
    end
  end
  #--------------------------------------------------------------------------
  def M7_set(val)
    @angle = [[val, 0].max, 89].min
    @sprites.clear
    @sprites_x.clear
    init_sprites(@angle, @dist_h, @pivot)
    update
    Graphics.update
  end
  #--------------------------------------------------------------------------
  def M7_redraw
    @sprites.clear
    @sprites_x.clear
    init_sprites(@angle, @dist_h, @pivot)
    update
    Graphics.update
  end
  #--------------------------------------------------------------------------
  def init_sprites(a_d, hd, p)
    @horizon = $game_system.horizon
    a = (Math::PI * a_d) / 180
    @sprites = []
    @sprites_x = []
    c = Math.cos(a)
    s = Math.sin(a)
    $hd = hd
    $piv = p
    $cos = c
    $sin = s
    h0 = (-hd*p*c).to_f/(hd+p*s) + p
    z0 = hd.to_f/(hd+p*s)
    $az = (1.0-z0)/(p-h0)
    $bz = 1.0-p*$az
    lh = - p - @horizon
    hlh = (hd*lh*c).to_f/(hd-lh*s) + p
    $hlim = hlh
    for j in 0..479
      next if j < hlh
      i = j - p
      sprite = Sprite.new(@viewport)
      sprite.x = 320
      sprite.y = j
      sprite.z = - 99999
      sprite.lat = (hd*i).to_f/(hd*c+i*s) + p
      sprite.lat_i = (sprite.lat+0.5).to_i
      sprite.lat_i %= @hauteur if $game_system.repeter_y
      sprite.zoom_x = $az*j+$bz
      sprite.long = 2 + (640.to_f / sprite.zoom_x).to_i
      sprite.lon_i = ((642 - sprite.long)/2)
      sprite.lon_i %= @largeur if $game_system.repeter_x
      sprite.lon = (sprite.lon_i).to_f
      sprite.ox = sprite.long / 2
      sprite.bitmap = @carte
      if @disp_x != 0
        sprite.lon += @disp_x / 4
        sprite.lon_i = (sprite.lon).to_i
        sprite.lon_i %= @largeur if $game_system.repeter_x
      end
      if @disp_y != 0
        sprite.lat += @disp_y / 4
        sprite.lat_i = (sprite.lat+0.5).to_i
        sprite.lat_i %= @hauteur if $game_system.repeter_y
      end
      k = j - hlh
      sprite.opacity = $game_system.opacite
      sprite.color = $game_system.couleur
      k = 500/k
      if $game_system.hor_blanc
        sprite.tone = Tone.new(k,k,k)
      end
      sprite.src_rect.set(sprite.lon_i, sprite.lat_i, sprite.long, 1)
      @sprites.push(sprite)
      if $game_system.repeter_x and j < p
        sprite2 = Sprite.new(@viewport)
        sprite2.x = 320
        sprite2.y = j
        sprite2.z = - 99999
        sprite2.lat = sprite.lat
        sprite2.lat_i = sprite.lat_i
        sprite2.zoom_x = sprite.zoom_x
        sprite2.long = sprite.long
        sprite2.lon_i = sprite.lon_i - @largeur
        sprite2.lon = sprite.lon_i - @largeur
        sprite2.ox = sprite.ox
        sprite2.bitmap = @carte
        sprite2.opacity = sprite.opacity
        sprite2.color = sprite.color
        sprite2.tone = sprite.tone
        sprite2.src_rect.set(sprite2.lon_i, sprite2.lat_i, sprite2.long, 1)
        @sprites_x.push(sprite2)
      end
    end
  end
  #--------------------------------------------------------------------------
  def update
    if @disp_y < $game_map.display_y
      diff = $game_map.display_y - @disp_y
      @disp_y += diff
      for sprite in @sprites + @sprites_x
        sprite.lat += diff.to_f / 4
        sprite.lat_i = (sprite.lat+0.5).to_i
        sprite.lat_i %= @hauteur if $game_system.repeter_y
        sprite.src_rect.set(sprite.lon_i, sprite.lat_i, sprite.long, 1)
      end
    end
    if @disp_y > $game_map.display_y
      diff = @disp_y - $game_map.display_y
      @disp_y -= diff
      for sprite in @sprites + @sprites_x
        sprite.lat -= diff.to_f / 4
        sprite.lat_i = (sprite.lat+0.5).to_i
        sprite.lat_i %= @hauteur if $game_system.repeter_y
        sprite.src_rect.set(sprite.lon_i, sprite.lat_i, sprite.long, 1)
      end
    end
    if @disp_x < $game_map.display_x
      diff = $game_map.display_x - @disp_x
      @disp_x += diff
      for sprite in @sprites
        sprite.lon += diff.to_f / 4
        sprite.lon_i = (sprite.lon).to_i
        sprite.lon_i %= @largeur if $game_system.repeter_x
        sprite.src_rect.set(sprite.lon_i, sprite.lat_i, sprite.long, 1)
      end
      for sprite in @sprites_x
        sprite.lon += diff.to_f / 4
        sprite.lon_i = (sprite.lon).to_i
        sprite.lon_i %= @largeur
        sprite.lon_i -= @largeur
        sprite.src_rect.set(sprite.lon_i, sprite.lat_i, sprite.long, 1)
      end
    end
    if @disp_x > $game_map.display_x
      diff = @disp_x - $game_map.display_x
      @disp_x -= diff
      for sprite in @sprites
        sprite.lon -= diff.to_f / 4
        sprite.lon_i = (sprite.lon).to_i
        sprite.lon_i %= @largeur if $game_system.repeter_x
        sprite.src_rect.set(sprite.lon_i, sprite.lat_i, sprite.long, 1)
      end
      for sprite in @sprites_x
        sprite.lon -= diff.to_f / 4
        sprite.lon_i = (sprite.lon).to_i
        sprite.lon_i %= @largeur
        sprite.lon_i -= @largeur
        sprite.src_rect.set(sprite.lon_i, sprite.lat_i, sprite.long, 1)
      end
    end
    for sprite in @sprites_c3
      sprite.update
    end
  end

suite (éditée le 28/04/07 pour mieux prendre en compte les cartes à faible largeur) :

Code: Tout sélectionner

  #--------------------------------------------------------------------------
  def update_anime
    @index_anime += 1
    @index_anime %= 4
    carte = @tabl_anime[@index_anime]
    for sprite in @sprites
      sprite.bitmap = carte
      sprite.src_rect.set(sprite.lon_i, sprite.lat_i, sprite.long, 1)
    end
    for sprite in @sprites_c3_anime
      sprite.update_anime(@index_anime)
    end
  end
  #--------------------------------------------------------------------------
  def dessiner_carte
    data = $game_map.data
    data_anime = Table.new($game_map.width, $game_map.height)
    offset = ($game_system.repeter_x ? 640 : 0)
    @carte = Bitmap.new(@largeur+offset, @hauteur)
    @tabl_anime.push(@carte)
    rect = Rect.new(0, 0, 32, 32)
    self.autotiles = Array.new
    for i in 0..6
      autotile_name = $game_map.autotile_names[i]
      fichier = RPG::Cache.autotile(autotile_name)
      for l in 0..3
        data_autotile = Data_Autotiles.new(fichier,l)
        data_autotile.numero = 4*i + l
        RPG::Cache.save_autotile(data_autotile, data_autotile.numero)
        self.autotiles.push(data_autotile)
      end
    end
    for i in 0...$game_map.height
      for j in 0...$game_map.width
        data_anime[j, i] = 0
        val1 = data[j, i, 0].to_i
        if val1 != 0
          val2 = data[j, i, 1].to_i
          if val2 == 0
            if val1 > 383
              bitmap = RPG::Cache.tile($game_map.tileset_name, val1, 0)
              @carte.blt(32*j, 32*i, bitmap, rect)
              if $game_system.repeter_x and j.between?(0, 19)
                @carte.blt(32*(j+$game_map.width), 32*i, bitmap, rect)
              end
            else
              num = 4*((val1 / 48) - 1)
              bitmap = RPG::Cache.autotile_base(num, val1)
              if self.autotiles[num].anime
                data_anime[j, i] = 1
              end
              @carte.blt(32*j, 32*i, bitmap, rect)
              if $game_system.repeter_x and j.between?(0, 19)
                @carte.blt(32*(j+$game_map.width), 32*i, bitmap, rect)
              end
            end
          else
            bitmap = RPG::Cache_Tile.load(val1, val2)
            @carte.blt(32*j, 32*i, bitmap, rect)
            if $game_system.repeter_x and j.between?(0, 19)
              @carte.blt(32*(j+$game_map.width), 32*i, bitmap, rect)
            end
          end
        end
      end
    end
    RPG::Cache_Carte.save(@id, @carte)
    return if !$game_system.anime
    @carte_2 = @carte.clone
    @carte_3 = @carte.clone
    @carte_4 = @carte.clone
    @tabl_anime.push(@carte_2)
    @tabl_anime.push(@carte_3)
    @tabl_anime.push(@carte_4)
    for i in 0...$game_map.height
      for j in 0...$game_map.width
        next if data_anime[j, i].to_i == 0
        val1 = data[j, i, 0].to_i
        if val1 != 0
          val2 = data[j, i, 1].to_i
          if val2 == 0
            num = 4*((val1 / 48) - 1)
            bitmap_2 = RPG::Cache.autotile_base(num+1, val1)
            bitmap_3 = RPG::Cache.autotile_base(num+2, val1)
            bitmap_4 = RPG::Cache.autotile_base(num+3, val1)
            @carte_2.blt(32*j, 32*i, bitmap_2, rect)
            @carte_3.blt(32*j, 32*i, bitmap_3, rect)
            @carte_4.blt(32*j, 32*i, bitmap_4, rect)
            if $game_system.repeter_x and j.between?(0, 19)
              @carte_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect)
              @carte_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect)
              @carte_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect)
            end
          end
        else
          bitmap_2 = RPG::Cache_Tile.load(val1, val2, 1)
          bitmap_3 = RPG::Cache_Tile.load(val1, val2, 2)
          bitmap_4 = RPG::Cache_Tile.load(val1, val2, 3)
          @carte_2.blt(32*j, 32*i, bitmap_2, rect)
          @carte_3.blt(32*j, 32*i, bitmap_3, rect)
          @carte_4.blt(32*j, 32*i, bitmap_4, rect)
          if $game_system.repeter_x and j.between?(0, 19)
            @carte_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect)
            @carte_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect)
            @carte_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect)
          end
        end
      end
    end
    RPG::Cache_Carte.save(@id, @carte_2, 1)
    RPG::Cache_Carte.save(@id, @carte_3, 2)
    RPG::Cache_Carte.save(@id, @carte_4, 3)
  end
end

#============================================================================
# ■ Game_Map
#============================================================================
class Game_Map
  def scroll_down(distance)
    if $game_system.repeter_y or $game_system.tjs_scroll
      @display_y = @display_y + distance
    else
      @display_y = [@display_y + distance, (self.height - 15) * 128].min
    end
  end
  #--------------------------------------------------------------------------
  def scroll_left(distance)
    if $game_system.repeter_x or $game_system.tjs_scroll
      @display_x = @display_x - distance
    else
      @display_x = [@display_x - distance, 0].max
    end
  end
  #--------------------------------------------------------------------------
  def scroll_right(distance)
    if $game_system.repeter_x or $game_system.tjs_scroll
      @display_x = @display_x + distance
    else
      @display_x = [@display_x + distance, (self.width - 20) * 128].min
    end
  end
  #--------------------------------------------------------------------------
  def scroll_up(distance)
    if $game_system.repeter_y or $game_system.tjs_scroll
      @display_y = @display_y - distance
    else
      @display_y = [@display_y - distance, 0].max
    end
  end
  #--------------------------------------------------------------------------
  def valid?(x, y)
    if $game_system.repeter_x
      if $game_system.repeter_y
        return true
      else
        return (y >= 0 and y < height)
      end
    elsif $game_system.repeter_y
      return (x >= 0 and x < width)
    end
    return (x >= 0 and x < width and y >= 0 and y < height)
  end
  #--------------------------------------------------------------------------
  def passable?(x, y, d, self_event = nil)
    unless valid?(x, y)
      return false
    end
    bit = (1 << (d / 2 - 1)) & 0x0f
    for event in events.values
      if event.tile_id >= 0 and event != self_event and
         event.x == x and event.y == 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 % width, y % height, 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_Character
#============================================================================
class Game_Character
  attr_accessor :x
  attr_accessor :y
  attr_accessor :real_x
  attr_accessor :real_y
  alias update_o update
  def update
    if !((self.x).between?(0,$game_map.width - 1))
      diff = 128*self.x - self.real_x
      if self.is_a?(Game_Player)
        self.num_carte_x += diff / (diff.abs)
      end
      self.x %= $game_map.width
      self.real_x = 128*self.x - diff
    end
    if !((self.y).between?(0,$game_map.height - 1))
      diff = 128*self.y - self.real_y
      if self.is_a?(Game_Player)
        self.num_carte_y += diff / (diff.abs)
      end
      self.y %= $game_map.height
      self.real_y = 128*self.y - diff
    end
    update_o
  end
end

#============================================================================
# ■ Game_Player
#============================================================================
class Game_Player < Game_Character
  attr_accessor :num_carte_x
  attr_accessor :num_carte_y
  alias initialize_o initialize
  def initialize
    initialize_o
    self.num_carte_x = 0
    self.num_carte_y = 0
  end
end

#============================================================================
# ■ Sprite
#============================================================================
class Sprite
  attr_accessor :lat
  attr_accessor :lon
  attr_accessor :lat_i
  attr_accessor :lon_i
  attr_accessor :long
end

#============================================================================
# ■ Sprite_Character
#============================================================================

class Sprite_Character < RPG::Sprite
  def update
    super
    if @tile_id != @character.tile_id or
       @character_name != @character.character_name or
       @character_hue != @character.character_hue
      @tile_id = @character.tile_id
      @character_name = @character.character_name
      @character_hue = @character.character_hue
      if @tile_id >= 384
        self.bitmap = RPG::Cache.tile($game_map.tileset_name,
          @tile_id, @character.character_hue)
        self.src_rect.set(0, 0, 32, 32)
        self.ox = 16
        self.oy = 32
      else
        self.bitmap = RPG::Cache.character(@character.character_name,
          @character.character_hue)
        @cw = bitmap.width / 4
        @ch = bitmap.height / 4
        self.ox = @cw / 2
        self.oy = @ch
        self.oy -= 4 if $game_system.M7
      end
    end
    self.visible = (not @character.transparent)
    if @tile_id == 0
      sx = @character.pattern * @cw
      sy = (@character.direction - 2) / 2 * @ch
      self.src_rect.set(sx, sy, @cw, @ch)
    end
    x = @character.screen_x
    y = @character.screen_y
    y -= $piv + 4 if $game_system.M7
    if $game_system.repeter_y
      h = 32*$game_map.height
      y = (y + h/2) % h - h/2
    end
    if $game_system.M7
      self.y = (($hd*y*$cos).to_f/($hd-y*$sin) + $piv)
      self.zoom_x = $az*self.y+$bz
      self.zoom_y = self.zoom_x
      self.x = 320 + self.zoom_x*(x - 320)
      if $game_system.repeter_x
        offset = ($game_map.width >= 24 ? 64 * self.zoom_x : 0)
        l = 32*$game_map.width * self.zoom_x
        self.x = (self.x + offset) % l - offset
      end
    else
      self.zoom_x = 1.0
      self.zoom_y = 1.0
      self.x = x
      self.y = y
    end
    if @character.is_a?(Game_Player)
      if $game_system.ov
        self.zoom_x *= $game_system.ov_zoom
        self.zoom_y *= $game_system.ov_zoom
      end
    end
    self.z = @character.screen_z(@ch)
    if $game_system.M7
      self.opacity = (self.y < $hlim ? 0 : @character.opacity)
    else
      self.opacity = @character.opacity
    end
    self.blend_type = @character.blend_type
    self.bush_depth = @character.bush_depth
    if @character.animation_id != 0
      animation = $data_animations[@character.animation_id]
      animation(animation, true)
      @character.animation_id = 0
    end
  end
end

#============================================================================
# ■ Sprite_C3
#============================================================================

class Sprite_C3 < Sprite
  attr_accessor :x_map
  attr_accessor :y_map
  attr_accessor :case_y
  attr_accessor :prio
  attr_accessor :anime
  attr_accessor :liste_bmp
  #--------------------------------------------------------------------------
  def update
    y = 32*@y_map - $piv - $game_map.display_y / 4
    if $game_system.repeter_y
      y = (y + $haut/2) % $haut - $haut/2
    end
    self.y = ($hd*y*$cos).to_f/($hd-y*$sin) + $piv
    if self.y < $hlim
      self.opacity = 0
      return
    end
    self.opacity = 255
    self.zoom_x = $az*self.y+$bz
    self.zoom_y = self.zoom_x
    x = 32*@x_map - $game_map.display_x / 4
    self.x = 320 + (self.zoom_x*(x - 320))
    if $game_system.repeter_x
      offset = ($game_map.width >= 24 ? 64 * self.zoom_x : 0)
      l = 32*$game_map.width * self.zoom_x
      self.x = (self.x + offset) % l - offset
    end
    self.z = (128*@case_y - $game_map.display_y + 3) / 4 + 32 + 32*@prio
    return
  end
  #--------------------------------------------------------------------------
  def update_anime(index)
    self.bitmap = @liste_bmp[index]
  end
end

et fin :

Code: Tout sélectionner

#============================================================================
# ■ Spriteset_Map
#============================================================================

class Spriteset_Map
  attr_accessor :tilemap
  #--------------------------------------------------------------------------
  def init_options
    dat = $data_cartes[$game_map.map_id]
    $game_system.M7 = (dat.name2.include?("[M7]") ? true : false)
    $game_system.repeter_x = (dat.name2.include?("[X]") ? true : false)
    $game_system.repeter_y = (dat.name2.include?("[Y]") ? true : false)
    $game_system.tjs_scroll = (dat.name2.include?("[S]") ? true : false)
    $game_system.anime = (dat.name2.include?("[A]") ? true : false)
    $game_system.hor_blanc = (dat.name2.include?("[B]") ? true : false)
    $game_system.pano_fixe = (dat.name2.include?("[P]") ? true : false)
    $game_system.ov = (dat.name2.include?("[OV]") ? true : false)
    if $game_system.M7
      dat.name2 =~ /[#[ ]*([00-99]+)]/i
      $game_system.angle = ($1 == nil ? 0 : $1.to_i)
      $game_system.angle = [[$game_system.angle, 0].max, 89].min
    end
  end
  #--------------------------------------------------------------------------
  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
    init_options
    if $game_system.M7
      @tilemap = Tilemap_M7.new(@viewport1)
    else
      @tilemap = Tilemap.new(@viewport1)
      @tilemap.tileset = RPG::Cache.tileset($game_map.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.data
      @tilemap.priorities = $game_map.priorities
    end
    @panorama = Plane.new(@viewport1)
    @panorama.z = ($game_system.M7 ? -100000 : -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
  #--------------------------------------------------------------------------
  def dispose
    if !$game_system.M7
      @tilemap.tileset.dispose
      for i in 0..6
        @tilemap.autotiles[i].dispose
      end
    end
    @tilemap.dispose
    @panorama.dispose
    @fog.dispose
    for sprite in @character_sprites
      sprite.dispose
    end
    @weather.dispose
    for sprite in @picture_sprites
      sprite.dispose
    end
    @timer_sprite.dispose
    @viewport1.dispose
    @viewport2.dispose
    @viewport3.dispose
  end
  #--------------------------------------------------------------------------
  def update
    if @panorama_name != $game_map.panorama_name or
       @panorama_hue != $game_map.panorama_hue
      @panorama_name = $game_map.panorama_name
      @panorama_hue = $game_map.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.fog_name or @fog_hue != $game_map.fog_hue
      @fog_name = $game_map.fog_name
      @fog_hue = $game_map.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
    if $game_system.M7
      if Graphics.frame_count % 20 == 0 and $game_system.anime
        @tilemap.update_anime
      end
    else
      @tilemap.ox = $game_map.display_x / 4
      @tilemap.oy = $game_map.display_y / 4
    end
    @tilemap.update
    if $game_system.pano_fixe
      @panorama.ox = 0
      @panorama.oy = 0
    elsif $game_system.M7
      @panorama.ox = (128*$game_map.width*$game_player.num_carte_x+
      $game_player.real_x)/8
      @panorama.oy = - (128*$game_map.height*$game_player.num_carte_y+
      $game_player.real_y)/32
    else
      @panorama.ox = $game_map.display_x / 8
      @panorama.oy = $game_map.display_y / 8
    end
    @fog.zoom_x = $game_map.fog_zoom / 100.0
    @fog.zoom_y = $game_map.fog_zoom / 100.0
    @fog.opacity = $game_map.fog_opacity
    @fog.blend_type = $game_map.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

#============================================================================
# ■ Scene_Map
#============================================================================
class Scene_Map
  attr_accessor :spriteset
end

#============================================================================
# ■ Data_Autotiles
#============================================================================

class Data_Autotiles < Bitmap
  $data_creation = [[27,28,33,34],[5,28,33,34],[27,6,33,34],[5,6,33,34],
  [27,28,33,12],[5,28,33,12],[27,6,33,12],[5,6,33,12],[27,28,11,34],
  [5,28,11,34],[27,6,11,34],[5,6,11,34],[27,28,11,12],[5,28,11,12],
  [27,6,11,12],[5,6,11,12],[25,26,31,32],[25,6,31,32],[25,26,31,12],
  [25,6,31,12],[15,16,21,22],[15,16,21,12],[15,16,11,22],[15,16,11,12],
  [29,30,35,36],[29,30,11,36],[5,30,35,36],[5,30,11,36],[39,40,45,46],
  [5,40,45,46],[39,6,45,46],[5,6,45,46],[25,30,31,36],[15,16,45,46],
  [13,14,19,20],[13,14,19,12],[17,18,23,24],[17,18,11,24],[41,42,47,48],
  [5,42,47,48],[37,38,43,44],[37,6,43,44],[13,18,19,24],[13,14,43,44],
  [37,42,43,48],[17,18,47,48],[13,18,43,48],[13,18,43,48]]
  attr_accessor :numero
  attr_accessor :anime
  #--------------------------------------------------------------------------
  def initialize(fichier,l)
    super(8*32, 6*32)
    creer(fichier,l)
  end
  #--------------------------------------------------------------------------
  def creer(fichier,l)
    l = (fichier.width > 96 ? l : 0)
    self.anime = (fichier.width > 96 ? true : false)
    for i in 0..5
      for j in 0..7
        data = $data_creation[8*i+j]
        for nb in data
          nb -= 1
          m = 16 * (nb % 6)
          n = 16 * (nb / 6)
          blt(32*j+m%32, 32*i+n%32, fichier, Rect.new(m+96*l,n,16,16))
        end
      end
    end
  end
end

#============================================================================
# ■ Data_Couche3
#============================================================================

class Data_Couche3
  attr_accessor  :liste_sprites_C3
  attr_accessor  :liste_sprites_C3_anime
  #--------------------------------------------------------------------------
  def initialize(viewport)
    @viewport = viewport
    self.liste_sprites_C3 = []
    self.liste_sprites_C3_anime = []
    @num_tiles = []
    @data3 = Table.new($game_map.width, $game_map.height)
    for i in 0..$game_map.height
      for j in 0..$game_map.width
        @data3[j, i] = $game_map.data[j, i, 2].to_i
      end
    end
    for i in 0..$game_map.height
      for j in 0..$game_map.width
        val = @data3[j, i].to_i
        if val != 0
          @num_tiles.push([j,i])
          fin = 0
          l = 0
          while j+l+1 < $game_map.width and @data3[j+l+1,i].to_i != 0
            @num_tiles.push([j+l+1,i])
            l += 1
          end
          deb = j
          fin = l+j
          indic = true
          ligne = 0
          j2 = j
          while indic
            ligne += 1
            break if i+ligne == $game_map.height
            dep = j2
            l2 = 0
            indic = false
            if l >= 2
              for k in j2+1..j2+l-1
                if @data3[k,i+ligne].to_i != 0
                  if !indic
                    dep = k
                  else
                    l2 = k-dep
                  end
                  indic = true
                  @num_tiles.push([k,i+ligne])
                elsif !indic
                  l2 -= 1
                end
              end
            end
            if @data3[j2+l,i+ligne].to_i != 0
              l2 = j2+l-dep
              indic = true
              @num_tiles.push([j2+l,i+ligne])
              b = 1
              while j2+l+b < $game_map.width and
                @data3[j2+l+b,i+ligne].to_i != 0
                @num_tiles.push([j2+l+b,i+ligne])
                b += 1
                l2 += 1
                if j2+l+b > fin
                  fin = j2+l+b
                end
              end
            end
            if @data3[j2,i+ligne].to_i != 0
              dep2 = dep-j2
              l2 = l2+dep2
              dep = j2
              indic = true
              @num_tiles.push([j2,i+ligne])
              b = 1
              while j2-b >= 0 and @data3[j2-b,i+ligne].to_i != 0
                @num_tiles.push([j2-b,i+ligne])
                b += 1
                l2 += 1
                dep -= 1
                if dep < deb
                  deb = dep
                end
              end
            end
            l = l2
            j2 = dep
          end
          ligne -= 1
          creer_bitmap(i, deb, ligne, fin-deb)
          effacer_donnees
          @num_tiles = []
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  def effacer_donnees
    for num in @num_tiles
      @data3[num[0], num[1]] = 0
    end
  end
  #--------------------------------------------------------------------------
  def creer_bitmap(i, deb, hauteur, largeur)
    bmp = Bitmap.new(32*(1+largeur), 32*(1+hauteur))
    rect = Rect.new(0, 0, 32, 32)
    @num_tiles.sort! {|a, b|  -(a[1] - b[1])}
    sprite = Sprite_C3.new(@viewport)
    sprite.anime = false
    sprite.liste_bmp = []
    for num in @num_tiles
      valeur = @data3[num[0], num[1]].to_i
      if valeur > 383
        bitmap = RPG::Cache.tile($game_map.tileset_name, valeur, 0)
      else
        file = (valeur / 48) - 1
        num_file = 4*file
        if !sprite.anime
          autotile_name = $game_map.autotile_names[file]
          fichier = RPG::Cache.autotile(autotile_name)
          sprite.anime = (fichier.width > 96 ? true : false)
        end
        bitmap = RPG::Cache.autotile_base(num_file, valeur)
      end
      bmp.blt(32*(num[0]-deb), 32*(num[1]-i), bitmap, rect)
    end
    sprite.liste_bmp.push(bmp)
    if sprite.anime
      for j in 1..3
        bmp = Bitmap.new(32*(1+largeur), 32*(1+hauteur))
        for num in @num_tiles
          valeur = @data3[num[0], num[1]].to_i
          if valeur > 383
            bitmap = RPG::Cache.tile($game_map.tileset_name, valeur, 0)
          else
            num_file = 4*((valeur / 48) - 1)
            bitmap = RPG::Cache.autotile_base(num_file + j, valeur)
          end
          bmp.blt(32*(num[0]-deb), 32*(num[1]-i), bitmap, rect)
        end
        sprite.liste_bmp.push(bmp)
      end
    end
    val = @data3[@num_tiles[0][0], @num_tiles[0][1]].to_i
    sprite.prio = $game_map.priorities[val]
    sprite.x_map = (deb.to_f) + bmp.width / 64
    sprite.x_map += 0.5 if largeur % 2 == 0
    sprite.y_map = (i + hauteur).to_f + 0.5
    sprite.case_y = sprite.y_map.to_i
    sprite.oy = bmp.height - 16
    sprite.ox = bmp.width / 2
    sprite.bitmap = sprite.liste_bmp[0]
    self.liste_sprites_C3.push(sprite)
    self.liste_sprites_C3_anime.push(sprite) if sprite.anime
  end
end

#============================================================================
# ■ RPG::Cache_Tile
#============================================================================

module RPG
  module Cache_Tile
    @cache = {}
    #------------------------------------------------------------------------
    def self.load(val1,val2,offset=0)
      if not @cache.include?([val1, val2])
        bmp = Bitmap.new(32, 32)
        rect = Rect.new(0, 0, 32, 32)
        if val1 > 383
          bmp.blt(0, 0, RPG::Cache.tile($game_map.tileset_name, val1, 0), rect)
        else
          num = 4*((val1 / 48) - 1) + offset
          bmp.blt(0, 0, RPG::Cache.autotile_base(num, val1), rect)
        end
        if val2 > 383
          bmp.blt(0, 0, RPG::Cache.tile($game_map.tileset_name, val2, 0), rect)
        else
          num = 4*((val2 / 48) - 1) + offset
          bmp.blt(0, 0, RPG::Cache.autotile_base(num, val2), rect)
        end
        @cache[[val1, val2]] = bmp
      end
      @cache[[val1, val2]]
    end
    #------------------------------------------------------------------------
    def self.clear
      @cache = {}
      GC.start
    end
  end
end

#============================================================================
# ■ RPG::Cache_Carte
#============================================================================

module RPG
  module Cache_Carte
    @cache = {}
    #------------------------------------------------------------------------
    def self.en_cache(map_id)
      return @cache.include?(map_id)
    end
    #------------------------------------------------------------------------
    def self.load(map_id, num = 0)
      return @cache[map_id][num]
    end
    #------------------------------------------------------------------------
    def self.save(map_id, bmp, num = 0)
      @cache[map_id] = [] if !self.en_cache(map_id)
      @cache[map_id][num] = bmp
    end
    #------------------------------------------------------------------------
    def self.clear
      @cache = {}
      GC.start
    end
  end
end

#============================================================================
# ■ RPG::Cache
#============================================================================

module RPG
  module Cache
    def self.autotile_base(num,val)
      key = [num, val]
      if not @cache.include?(key) or @cache[key].disposed?
        @cache[key] = Bitmap.new(32, 32)
        num_tile = val % 48
        sx = 32 * (num_tile % 8)
        sy = 32 * (num_tile / 8)
        rect = Rect.new(sx, sy, 32, 32)
        @cache[key].blt(0, 0, self.load_autotile(num), rect)
      end
        @cache[key]
    end
    #------------------------------------------------------------------------
    def self.save_autotile(bitmap, key)
      @cache[key] = bitmap
    end
    #------------------------------------------------------------------------
    def self.load_autotile(key)
      @cache[key]
    end
  end
end

excellent script!!
j'ai tout de meme une remarque (ou requete) a faire: je pense que ce serait mieux si la condition pour mettre un objet a plat ou en 3d etait le numero de terrain (p.e.:si n° terrain=2 alors pas dde 3d, sinon 3d) j'espere mettre fait comprendre...

Je n'avais pas du tout pensé à utiliser les numéros de terrains (on ne peut pas penser à tout !).
En utilisant plusieurs numéros de terrains, on pourrait même mettre plusieurs éléments verticaux qui se touchent ou chevauchent (des arbres...) sans que le script ne les interprète comme un unique sprite.

Je vais essayer d'implémenter ça.

(cependant je ne suis pas sûr que je ne rencontrerai pas de problèmes et que je puisse le faire rapidement)

Edit : Voilà la nouvelle version !

Les 3 couches sont tracées à plat sauf les tiles ayant pour numéro de terrain 1 ou 2, quelle que soit leur couche.
on peut changer ces valeurs de numéro de terrain ligne 24 :

Code: Tout sélectionner

$num_terrains = [1,2]

Pourquoi 2 numéros ?
Car on peut avec cela se faire toucher 2 éléments verticaux d'une même couche.

Exemple :

En ayant mis comme numéros de terrains :
[spolier][/spoiler]

Couche 1 :
[spolier][/spoiler]

Couche 2 :
[spolier][/spoiler]

Couche 3 :
[spolier][/spoiler]

Résultat :
[spolier][/spoiler]

Le nouveau script (je laisse l'ancien pour l'instant au cas ou celui-ci bugguerait) :
[spolier]

Code: Tout sélectionner

#============================================================================
# Script simulant un effet de profondeur pour une carte (façon mode 7),
# créé par MGCaladtogel (v. 02/05/07)
#
#    Instructions :
# Les éléments suivants sont à rajouter dans le nom de la carte :
# [M7]  : la carte sera dessinée avec de la profondeur
# [#XX] : degré d'inclinaison de la carte (exemple : [#30] pour une
# inclinaison de 30 degrés). Si ce terme est omis, l'inclinaison est de
# 0 degré, c'est-à-dire la carte en vue normale
# [Y]   : la carte se répète en hauteur
# [X]   : la carte se répète en largeur. Contrairement à [Y], cette option
# demande plus de ressources pendant le jeu (fps plus faible)
# [A]   : active l'animation des autotiles animés (à 4 dessins). Cette option
# ne demande pas de ressources pendant le jeu, mais augmente de façon très
# significative le temps de lancement de la carte, ce qui peut provoquer une
# erreur pour les cartes trop grandes
# [S]   : la carte restera centrée sur le héros, même sur les bords des
# petites cartes
# [P]   : fixe l'image de panorama par rapport à l'écran
# [B]   : donne un effet d'horizon blanc
# [OV]  : réduit l'image du héros sur la carte
#============================================================================
$num_terrains = [1,2]
$data_cartes = load_data("Data/MapInfos.rxdata")
#============================================================================
# ■ Game_System
#============================================================================
class Game_System
  attr_accessor :M7
  attr_accessor :repeter_x
  attr_accessor :repeter_y
  attr_accessor :tjs_scroll
  attr_accessor :couleur
  attr_accessor :opacite
  attr_accessor :anime
  attr_accessor :hor_blanc
  attr_accessor :angle
  attr_accessor :horizon
  attr_accessor :pano_fixe
  attr_accessor :ov
  attr_accessor :ov_zoom
  #--------------------------------------------------------------------------
  alias initialize_o initialize
  def initialize
    initialize_o
    reset
  end
  #--------------------------------------------------------------------------
  def reset
    self.M7 = false
    self.repeter_x = false
    self.repeter_y = false
    self.tjs_scroll = false
    self.opacite = 255
    self.couleur = Color.new(0,0,0,0)
    self.anime = false
    self.hor_blanc = false
    self.angle = 0
    self.horizon = 960
    self.pano_fixe = false
    self.ov = false
    self.ov_zoom = 0.6
  end
end
#============================================================================
# ■ Tilemap_M7
#============================================================================
class Tilemap_M7
  attr_accessor :autotiles
  attr_accessor :angle
  attr_accessor :dist_h
  attr_accessor :pivot
  attr_accessor :horizon
  #--------------------------------------------------------------------------
  def initialize(viewport)
    @id = $game_map.map_id
    @tabl_anime = []
    @disp_y = $game_map.display_y
    @disp_x = $game_map.display_x
    @hauteur = 32*$game_map.height
    @largeur = 32*$game_map.width
    $larg = @largeur
    $haut = @hauteur
    if RPG::Cache_Carte.en_cache(@id)
      @carte = RPG::Cache_Carte.load(@id)
      @tabl_anime.push(@carte)
      if $game_system.anime
        @carte_2 = RPG::Cache_Carte.load(@id, 1)
        @carte_3 = RPG::Cache_Carte.load(@id, 2)
        @carte_4 = RPG::Cache_Carte.load(@id, 3)
        @tabl_anime.push(@carte_2)
        @tabl_anime.push(@carte_3)
        @tabl_anime.push(@carte_4)
      end
    else
      dessiner_carte
    end
    data_V = Data_Tiles_Verticaux.new(viewport)
    @sprites_V = data_V.liste_sprites_V
    @sprites_V_anime = data_V.liste_sprites_V_anime
    @angle = $game_system.angle
    @dist_h = 480
    @pivot = 256
    @index_anime = 0
    @viewport = viewport
    init_sprites(@angle, @dist_h, @pivot)
  end
  #--------------------------------------------------------------------------
  def dispose
    for sprite in @sprites + @sprites_V + @sprites_x
      sprite.dispose
    end
    @sprites.clear
    @sprites_x.clear
    @sprites_V.clear
    @sprites_V_anime.clear
    @tabl_anime.clear
    $game_system.angle = @angle
  end
  #--------------------------------------------------------------------------
  def inc
    return if @angle == 88
    @angle = [@angle+2, 88].min
    @sprites.clear
    @sprites_x.clear
    init_sprites(@angle, @dist_h, @pivot)
  end
  #--------------------------------------------------------------------------
  def dec
    return if @angle == 0
    @angle = [@angle-2, 0].max
    @sprites.clear
    @sprites_x.clear
    init_sprites(@angle, @dist_h, @pivot)
  end
  #--------------------------------------------------------------------------
  def M7_set_p(val)
    while val > @angle
      inc
      update
      Graphics.update
    end
    while val < @angle
      dec
      update
      Graphics.update
    end
  end
  #--------------------------------------------------------------------------
  def M7_set(val)
    @angle = [[val, 0].max, 89].min
    @sprites.clear
    @sprites_x.clear
    init_sprites(@angle, @dist_h, @pivot)
    update
    Graphics.update
  end
  #--------------------------------------------------------------------------
  def M7_redraw
    @sprites.clear
    @sprites_x.clear
    init_sprites(@angle, @dist_h, @pivot)
    update
    Graphics.update
  end
  #--------------------------------------------------------------------------
  def init_sprites(a_d, hd, p)
    @horizon = $game_system.horizon
    a = (Math::PI * a_d) / 180
    @sprites = []
    @sprites_x = []
    c = Math.cos(a)
    s = Math.sin(a)
    $hd = hd
    $piv = p
    $cos = c
    $sin = s
    h0 = (-hd*p*c).to_f/(hd+p*s) + p
    z0 = hd.to_f/(hd+p*s)
    $az = (1.0-z0)/(p-h0)
    $bz = 1.0-p*$az
    lh = - p - @horizon
    hlh = (hd*lh*c).to_f/(hd-lh*s) + p
    $hlim = hlh
    for j in 0..479
      next if j < hlh
      i = j - p
      sprite = Sprite.new(@viewport)
      sprite.x = 320
      sprite.y = j
      sprite.z = - 99999
      sprite.lat = (hd*i).to_f/(hd*c+i*s) + p
      sprite.lat_i = (sprite.lat+0.5).to_i
      sprite.lat_i %= @hauteur if $game_system.repeter_y
      sprite.zoom_x = $az*j+$bz
      sprite.long = 2 + (640.to_f / sprite.zoom_x).to_i
      sprite.lon_i = ((642 - sprite.long)/2)
      sprite.lon_i %= @largeur if $game_system.repeter_x
      sprite.lon = (sprite.lon_i).to_f
      sprite.ox = sprite.long / 2
      sprite.bitmap = @carte
      if @disp_x != 0
        sprite.lon += @disp_x / 4
        sprite.lon_i = (sprite.lon).to_i
        sprite.lon_i %= @largeur if $game_system.repeter_x
      end
      if @disp_y != 0
        sprite.lat += @disp_y / 4
        sprite.lat_i = (sprite.lat+0.5).to_i
        sprite.lat_i %= @hauteur if $game_system.repeter_y
      end
      k = j - hlh
      sprite.opacity = $game_system.opacite
      sprite.color = $game_system.couleur
      k = 500/k
      if $game_system.hor_blanc
        sprite.tone = Tone.new(k,k,k)
      end
      sprite.src_rect.set(sprite.lon_i, sprite.lat_i, sprite.long, 1)
      @sprites.push(sprite)
      if $game_system.repeter_x and j < p
        sprite2 = Sprite.new(@viewport)
        sprite2.x = 320
        sprite2.y = j
        sprite2.z = - 99999
        sprite2.lat = sprite.lat
        sprite2.lat_i = sprite.lat_i
        sprite2.zoom_x = sprite.zoom_x
        sprite2.long = sprite.long
        sprite2.lon_i = sprite.lon_i - @largeur
        sprite2.lon = sprite.lon_i - @largeur
        sprite2.ox = sprite.ox
        sprite2.bitmap = @carte
        sprite2.opacity = sprite.opacity
        sprite2.color = sprite.color
        sprite2.tone = sprite.tone
        sprite2.src_rect.set(sprite2.lon_i, sprite2.lat_i, sprite2.long, 1)
        @sprites_x.push(sprite2)
      end
    end
  end
  #--------------------------------------------------------------------------
  def update
    if @disp_y < $game_map.display_y
      diff = $game_map.display_y - @disp_y
      @disp_y += diff
      for sprite in @sprites + @sprites_x
        sprite.lat += diff.to_f / 4
        sprite.lat_i = (sprite.lat+0.5).to_i
        sprite.lat_i %= @hauteur if $game_system.repeter_y
        sprite.src_rect.set(sprite.lon_i, sprite.lat_i, sprite.long, 1)
      end
    end
    if @disp_y > $game_map.display_y
      diff = @disp_y - $game_map.display_y
      @disp_y -= diff
      for sprite in @sprites + @sprites_x
        sprite.lat -= diff.to_f / 4
        sprite.lat_i = (sprite.lat+0.5).to_i
        sprite.lat_i %= @hauteur if $game_system.repeter_y
        sprite.src_rect.set(sprite.lon_i, sprite.lat_i, sprite.long, 1)
      end
    end
    if @disp_x < $game_map.display_x
      diff = $game_map.display_x - @disp_x
      @disp_x += diff
      for sprite in @sprites
        sprite.lon += diff.to_f / 4
        sprite.lon_i = (sprite.lon).to_i
        sprite.lon_i %= @largeur if $game_system.repeter_x
        sprite.src_rect.set(sprite.lon_i, sprite.lat_i, sprite.long, 1)
      end
      for sprite in @sprites_x
        sprite.lon += diff.to_f / 4
        sprite.lon_i = (sprite.lon).to_i
        sprite.lon_i %= @largeur
        sprite.lon_i -= @largeur
        sprite.src_rect.set(sprite.lon_i, sprite.lat_i, sprite.long, 1)
      end
    end
    if @disp_x > $game_map.display_x
      diff = @disp_x - $game_map.display_x
      @disp_x -= diff
      for sprite in @sprites
        sprite.lon -= diff.to_f / 4
        sprite.lon_i = (sprite.lon).to_i
        sprite.lon_i %= @largeur if $game_system.repeter_x
        sprite.src_rect.set(sprite.lon_i, sprite.lat_i, sprite.long, 1)
      end
      for sprite in @sprites_x
        sprite.lon -= diff.to_f / 4
        sprite.lon_i = (sprite.lon).to_i
        sprite.lon_i %= @largeur
        sprite.lon_i -= @largeur
        sprite.src_rect.set(sprite.lon_i, sprite.lat_i, sprite.long, 1)
      end
    end
    for sprite in @sprites_V
      sprite.update
    end
  end
  #--------------------------------------------------------------------------
  def update_anime
    @index_anime += 1
    @index_anime %= 4
    carte = @tabl_anime[@index_anime]
    for sprite in @sprites
      sprite.bitmap = carte
      sprite.src_rect.set(sprite.lon_i, sprite.lat_i, sprite.long, 1)
    end
    for sprite in @sprites_V_anime
      sprite.update_anime(@index_anime)
    end
  end
  #--------------------------------------------------------------------------
  def dessiner_carte
    data = $game_map.data
    data_anime = Table.new($game_map.width, $game_map.height)
    offset = ($game_system.repeter_x ? 640 : 0)
    @carte = Bitmap.new(@largeur+offset, @hauteur)
    @tabl_anime.push(@carte)
    rect = Rect.new(0, 0, 32, 32)
    self.autotiles = Array.new
    for i in 0..6
      autotile_name = $game_map.autotile_names[i]
      fichier = RPG::Cache.autotile(autotile_name)
      for l in 0..3
        data_autotile = Data_Autotiles.new(fichier,l)
        data_autotile.numero = 4*i + l
        RPG::Cache.save_autotile(data_autotile, data_autotile.numero)
        self.autotiles.push(data_autotile)
      end
    end
    for i in 0...$game_map.height
      for j in 0...$game_map.width
        data_anime[j, i] = 0
        val1 = data[j, i, 0].to_i
        val1 = ($num_terrains.include?($game_map.terrain_tags[val1]) ? 0 : val1)
        if val1 != 0
          val2 = data[j, i, 1].to_i
          val2 = ($num_terrains.include?($game_map.terrain_tags[val2]) ? 0 : val2)
          val3 = data[j, i, 2].to_i
          val3 = ($num_terrains.include?($game_map.terrain_tags[val3]) ? 0 : val3)
          if val2 == 0
            if val3 == 0
              if val1 > 383
                bitmap = RPG::Cache.tile($game_map.tileset_name, val1, 0)
                @carte.blt(32*j, 32*i, bitmap, rect)
                if $game_system.repeter_x and j.between?(0, 19)
                  @carte.blt(32*(j+$game_map.width), 32*i, bitmap, rect)
                end
              else
                num = 4*((val1 / 48) - 1)
                bitmap = RPG::Cache.autotile_base(num, val1)
                if self.autotiles[num].anime
                  data_anime[j, i] = 1
                end
                @carte.blt(32*j, 32*i, bitmap, rect)
                if $game_system.repeter_x and j.between?(0, 19)
                  @carte.blt(32*(j+$game_map.width), 32*i, bitmap, rect)
                end
              end
            else
              bitmap = RPG::Cache_Tile.load(val1, val3)
              if val1 < 384
                num = 4*((val1 / 48) - 1)
                data_anime[j, i] = 1 if self.autotiles[num].anime
              end
              if val3 < 384
                num = 4*((val3 / 48) - 1)
                data_anime[j, i] = 1 if self.autotiles[num].anime
              end
              @carte.blt(32*j, 32*i, bitmap, rect)
              if $game_system.repeter_x and j.between?(0, 19)
                @carte.blt(32*(j+$game_map.width), 32*i, bitmap, rect)
              end
            end
          else
            if val3 == 0
              bitmap = RPG::Cache_Tile.load(val1, val2)
              if val1 < 384
                num = 4*((val1 / 48) - 1)
                data_anime[j, i] = 1 if self.autotiles[num].anime
              end
              if val2 < 384
                num = 4*((val2 / 48) - 1)
                data_anime[j, i] = 1 if self.autotiles[num].anime
              end
              @carte.blt(32*j, 32*i, bitmap, rect)
              if $game_system.repeter_x and j.between?(0, 19)
                @carte.blt(32*(j+$game_map.width), 32*i, bitmap, rect)
              end
            else
              bitmap = RPG::Cache_Tile.load2(val1, val2, val3)
              if val1 < 384
                num = 4*((val1 / 48) - 1)
                data_anime[j, i] = 1 if self.autotiles[num].anime
              end
              if val2 < 384
                num = 4*((val2 / 48) - 1)
                data_anime[j, i] = 1 if self.autotiles[num].anime
              end
              if val3 < 384
                num = 4*((val3 / 48) - 1)
                data_anime[j, i] = 1 if self.autotiles[num].anime
              end
              @carte.blt(32*j, 32*i, bitmap, rect)
              if $game_system.repeter_x and j.between?(0, 19)
                @carte.blt(32*(j+$game_map.width), 32*i, bitmap, rect)
              end
            end
          end
        else

[/spoiler]

suite :
[spolier]

Code: Tout sélectionner

          val2 = data[j, i, 1].to_i
          val2 = ($num_terrains.include?($game_map.terrain_tags[val2]) ? 0 : val2)
          val3 = data[j, i, 2].to_i
          val3 = ($num_terrains.include?($game_map.terrain_tags[val3]) ? 0 : val3)
          if val2 == 0
            if val3 != 0
              if val3 > 383
                bitmap = RPG::Cache.tile($game_map.tileset_name, val3, 0)
                @carte.blt(32*j, 32*i, bitmap, rect)
                if $game_system.repeter_x and j.between?(0, 19)
                  @carte.blt(32*(j+$game_map.width), 32*i, bitmap, rect)
                end
              else
                num = 4*((val3 / 48) - 1)
                bitmap = RPG::Cache.autotile_base(num, val3)
                if self.autotiles[num].anime
                  data_anime[j, i] = 1
                end
                @carte.blt(32*j, 32*i, bitmap, rect)
                if $game_system.repeter_x and j.between?(0, 19)
                  @carte.blt(32*(j+$game_map.width), 32*i, bitmap, rect)
                end
              end
            end
          else
            if val3 == 0
              if val2 > 383
                bitmap = RPG::Cache.tile($game_map.tileset_name, val2, 0)
                @carte.blt(32*j, 32*i, bitmap, rect)
                if $game_system.repeter_x and j.between?(0, 19)
                  @carte.blt(32*(j+$game_map.width), 32*i, bitmap, rect)
                end
              else
                num = 4*((val2 / 48) - 1)
                bitmap = RPG::Cache.autotile_base(num, val2)
                if self.autotiles[num].anime
                  data_anime[j, i] = 1
                end
                @carte.blt(32*j, 32*i, bitmap, rect)
                if $game_system.repeter_x and j.between?(0, 19)
                  @carte.blt(32*(j+$game_map.width), 32*i, bitmap, rect)
                end
              end
            else
              bitmap = RPG::Cache_Tile.load(val2, val3)
              if val2 < 384
                num = 4*((val2 / 48) - 1)
                data_anime[j, i] = 1 if self.autotiles[num].anime
              end
              if val3 < 384
                num = 4*((val3 / 48) - 1)
                data_anime[j, i] = 1 if self.autotiles[num].anime
              end
              @carte.blt(32*j, 32*i, bitmap, rect)
              if $game_system.repeter_x and j.between?(0, 19)
                @carte.blt(32*(j+$game_map.width), 32*i, bitmap, rect)
              end
            end
          end
        end
      end
    end
    RPG::Cache_Carte.save(@id, @carte)
    return if !$game_system.anime
    @carte_2 = @carte.clone
    @carte_3 = @carte.clone
    @carte_4 = @carte.clone
    @tabl_anime.push(@carte_2)
    @tabl_anime.push(@carte_3)
    @tabl_anime.push(@carte_4)
    for i in 0...$game_map.height
      for j in 0...$game_map.width
        next if data_anime[j, i].to_i == 0
        val1 = data[j, i, 0].to_i
        val2 = data[j, i, 1].to_i
        val3 = data[j, i, 2].to_i
        if val1 != 0
          if val2 == 0
            if val3 == 0
              num = 4*((val1 / 48) - 1)
              bitmap_2 = RPG::Cache.autotile_base(num+1, val1)
              bitmap_3 = RPG::Cache.autotile_base(num+2, val1)
              bitmap_4 = RPG::Cache.autotile_base(num+3, val1)
              @carte_2.blt(32*j, 32*i, bitmap_2, rect)
              @carte_3.blt(32*j, 32*i, bitmap_3, rect)
              @carte_4.blt(32*j, 32*i, bitmap_4, rect)
              if $game_system.repeter_x and j.between?(0, 19)
                @carte_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect)
                @carte_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect)
                @carte_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect)
              end
            else
              bitmap_2 = RPG::Cache_Tile.load(val1, val3, 1)
              bitmap_3 = RPG::Cache_Tile.load(val1, val3, 2)
              bitmap_4 = RPG::Cache_Tile.load(val1, val3, 3)
              @carte_2.blt(32*j, 32*i, bitmap_2, rect)
              @carte_3.blt(32*j, 32*i, bitmap_3, rect)
              @carte_4.blt(32*j, 32*i, bitmap_4, rect)
              if $game_system.repeter_x and j.between?(0, 19)
                @carte_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect)
                @carte_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect)
                @carte_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect)
              end
            end
          else
            if val3 == 0
              bitmap_2 = RPG::Cache_Tile.load(val1, val2, 1)
              bitmap_3 = RPG::Cache_Tile.load(val1, val2, 2)
              bitmap_4 = RPG::Cache_Tile.load(val1, val2, 3)
              @carte_2.blt(32*j, 32*i, bitmap_2, rect)
              @carte_3.blt(32*j, 32*i, bitmap_3, rect)
              @carte_4.blt(32*j, 32*i, bitmap_4, rect)
              if $game_system.repeter_x and j.between?(0, 19)
                @carte_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect)
                @carte_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect)
                @carte_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect)
              end
            else
              bitmap_2 = RPG::Cache_Tile.load2(val1, val2, val3, 1)
              bitmap_3 = RPG::Cache_Tile.load2(val1, val2, val3, 2)
              bitmap_4 = RPG::Cache_Tile.load2(val1, val2, val3, 3)
              @carte_2.blt(32*j, 32*i, bitmap_2, rect)
              @carte_3.blt(32*j, 32*i, bitmap_3, rect)
              @carte_4.blt(32*j, 32*i, bitmap_4, rect)
              if $game_system.repeter_x and j.between?(0, 19)
                @carte_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect)
                @carte_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect)
                @carte_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect)
              end
            end
          end
        else
          if val2 != 0
            if val3 == 0
              num = 4*((val2 / 48) - 1)
              bitmap_2 = RPG::Cache.autotile_base(num+1, val2)
              bitmap_3 = RPG::Cache.autotile_base(num+2, val2)
              bitmap_4 = RPG::Cache.autotile_base(num+3, val2)
              @carte_2.blt(32*j, 32*i, bitmap_2, rect)
              @carte_3.blt(32*j, 32*i, bitmap_3, rect)
              @carte_4.blt(32*j, 32*i, bitmap_4, rect)
              if $game_system.repeter_x and j.between?(0, 19)
                @carte_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect)
                @carte_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect)
                @carte_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect)
              end
            else
              bitmap_2 = RPG::Cache_Tile.load(val2, val3, 1)
              bitmap_3 = RPG::Cache_Tile.load(val2, val3, 2)
              bitmap_4 = RPG::Cache_Tile.load(val2, val3, 3)
              @carte_2.blt(32*j, 32*i, bitmap_2, rect)
              @carte_3.blt(32*j, 32*i, bitmap_3, rect)
              @carte_4.blt(32*j, 32*i, bitmap_4, rect)
              if $game_system.repeter_x and j.between?(0, 19)
                @carte_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect)
                @carte_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect)
                @carte_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect)
              end
            end
          else
            if val3 != 0
              num = 4*((val3 / 48) - 1)
              bitmap_2 = RPG::Cache.autotile_base(num+1, val3)
              bitmap_3 = RPG::Cache.autotile_base(num+2, val3)
              bitmap_4 = RPG::Cache.autotile_base(num+3, val3)
              @carte_2.blt(32*j, 32*i, bitmap_2, rect)
              @carte_3.blt(32*j, 32*i, bitmap_3, rect)
              @carte_4.blt(32*j, 32*i, bitmap_4, rect)
              if $game_system.repeter_x and j.between?(0, 19)
                @carte_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect)
                @carte_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect)
                @carte_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect)
              end
            end
          end
        end
      end
    end
    RPG::Cache_Carte.save(@id, @carte_2, 1)
    RPG::Cache_Carte.save(@id, @carte_3, 2)
    RPG::Cache_Carte.save(@id, @carte_4, 3)
  end
end

#============================================================================
# ■ Game_Map
#============================================================================
class Game_Map
  def scroll_down(distance)
    if $game_system.repeter_y or $game_system.tjs_scroll
      @display_y = @display_y + distance
    else
      @display_y = [@display_y + distance, (self.height - 15) * 128].min
    end
  end
  #--------------------------------------------------------------------------
  def scroll_left(distance)
    if $game_system.repeter_x or $game_system.tjs_scroll
      @display_x = @display_x - distance
    else
      @display_x = [@display_x - distance, 0].max
    end
  end
  #--------------------------------------------------------------------------
  def scroll_right(distance)
    if $game_system.repeter_x or $game_system.tjs_scroll
      @display_x = @display_x + distance
    else
      @display_x = [@display_x + distance, (self.width - 20) * 128].min
    end
  end
  #--------------------------------------------------------------------------
  def scroll_up(distance)
    if $game_system.repeter_y or $game_system.tjs_scroll
      @display_y = @display_y - distance
    else
      @display_y = [@display_y - distance, 0].max
    end
  end
  #--------------------------------------------------------------------------
  def valid?(x, y)
    if $game_system.repeter_x
      if $game_system.repeter_y
        return true
      else
        return (y >= 0 and y < height)
      end
    elsif $game_system.repeter_y
      return (x >= 0 and x < width)
    end
    return (x >= 0 and x < width and y >= 0 and y < height)
  end
  #--------------------------------------------------------------------------
  def passable?(x, y, d, self_event = nil)
    unless valid?(x, y)
      return false
    end
    bit = (1 << (d / 2 - 1)) & 0x0f
    for event in events.values
      if event.tile_id >= 0 and event != self_event and
         event.x == x and event.y == 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 % width, y % height, 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_Character
#============================================================================
class Game_Character
  attr_accessor :x
  attr_accessor :y
  attr_accessor :real_x
  attr_accessor :real_y
  alias update_o update
  def update
    if !((self.x).between?(0,$game_map.width - 1))
      diff = 128*self.x - self.real_x
      if self.is_a?(Game_Player)
        self.num_carte_x += diff / (diff.abs)
      end
      self.x %= $game_map.width
      self.real_x = 128*self.x - diff
    end
    if !((self.y).between?(0,$game_map.height - 1))
      diff = 128*self.y - self.real_y
      if self.is_a?(Game_Player)
        self.num_carte_y += diff / (diff.abs)
      end
      self.y %= $game_map.height
      self.real_y = 128*self.y - diff
    end
    update_o
  end
end

#============================================================================
# ■ Game_Player
#============================================================================
class Game_Player < Game_Character
  attr_accessor :num_carte_x
  attr_accessor :num_carte_y
  alias initialize_o initialize
  def initialize
    initialize_o
    self.num_carte_x = 0
    self.num_carte_y = 0
  end
end

#============================================================================
# ■ Sprite
#============================================================================
class Sprite
  attr_accessor :lat
  attr_accessor :lon
  attr_accessor :lat_i
  attr_accessor :lon_i
  attr_accessor :long
end

#============================================================================
# ■ Sprite_Character
#============================================================================

class Sprite_Character < RPG::Sprite
  def update
    super
    if @tile_id != @character.tile_id or
       @character_name != @character.character_name or
       @character_hue != @character.character_hue
      @tile_id = @character.tile_id
      @character_name = @character.character_name
      @character_hue = @character.character_hue
      if @tile_id >= 384
        self.bitmap = RPG::Cache.tile($game_map.tileset_name,
          @tile_id, @character.character_hue)
        self.src_rect.set(0, 0, 32, 32)
        self.ox = 16
        self.oy = 32
      else
        self.bitmap = RPG::Cache.character(@character.character_name,
          @character.character_hue)
        @cw = bitmap.width / 4
        @ch = bitmap.height / 4
        self.ox = @cw / 2
        self.oy = @ch
        self.oy -= 4 if $game_system.M7
      end
    end
    self.visible = (not @character.transparent)
    if @tile_id == 0
      sx = @character.pattern * @cw
      sy = (@character.direction - 2) / 2 * @ch
      self.src_rect.set(sx, sy, @cw, @ch)
    end
    x = @character.screen_x
    y = @character.screen_y
    y -= $piv + 4 if $game_system.M7
    if $game_system.repeter_y
      h = 32*$game_map.height
      y = (y + h/2) % h - h/2
    end
    if $game_system.M7
      self.y = (($hd*y*$cos).to_f/($hd-y*$sin) + $piv)
      self.zoom_x = $az*self.y+$bz
      self.zoom_y = self.zoom_x
      self.x = 320 + self.zoom_x*(x - 320)
      if $game_system.repeter_x
        offset = ($game_map.width >= 24 ? 64 * self.zoom_x : 0)
        l = 32*$game_map.width * self.zoom_x
        self.x = (self.x + offset) % l - offset
      end
    else
      self.zoom_x = 1.0
      self.zoom_y = 1.0
      self.x = x
      self.y = y
    end
    if @character.is_a?(Game_Player)
      if $game_system.ov
        self.zoom_x *= $game_system.ov_zoom
        self.zoom_y *= $game_system.ov_zoom
      end
    end
    self.z = @character.screen_z(@ch)
    if $game_system.M7
      self.opacity = (self.y < $hlim ? 0 : @character.opacity)
    else
      self.opacity = @character.opacity
    end
    self.blend_type = @character.blend_type
    self.bush_depth = @character.bush_depth
    if @character.animation_id != 0
      animation = $data_animations[@character.animation_id]
      animation(animation, true)
      @character.animation_id = 0
    end
  end
end

[/spoiler]

suite :
[spolier]

Code: Tout sélectionner

#============================================================================
# ■ Sprite_V (Sprites verticaux)
#============================================================================

class Sprite_V < Sprite
  attr_accessor :x_map
  attr_accessor :y_map
  attr_accessor :case_y
  attr_accessor :prio
  attr_accessor :anime
  attr_accessor :liste_bmp
  #--------------------------------------------------------------------------
  def update
    y = 32*@y_map - $piv - $game_map.display_y / 4
    if $game_system.repeter_y
      y = (y + $haut/2) % $haut - $haut/2
    end
    self.y = ($hd*y*$cos).to_f/($hd-y*$sin) + $piv
    if self.y < $hlim
      self.opacity = 0
      return
    end
    self.opacity = 255
    self.zoom_x = $az*self.y+$bz
    self.zoom_y = self.zoom_x
    x = 32*@x_map - $game_map.display_x / 4
    self.x = 320 + (self.zoom_x*(x - 320))
    if $game_system.repeter_x
      offset = ($game_map.width >= 24 ? 64 * self.zoom_x : 0)
      l = 32*$game_map.width * self.zoom_x
      self.x = (self.x + offset) % l - offset
    end
    self.z = (128*@case_y - $game_map.display_y + 3) / 4 + 32 + 32*@prio
    return
  end
  #--------------------------------------------------------------------------
  def update_anime(index)
    self.bitmap = @liste_bmp[index]
  end
end

#============================================================================
# ■ Spriteset_Map
#============================================================================

class Spriteset_Map
  attr_accessor :tilemap
  #--------------------------------------------------------------------------
  def init_options
    dat = $data_cartes[$game_map.map_id]
    $game_system.M7 = (dat.name2.include?("[M7]") ? true : false)
    $game_system.repeter_x = (dat.name2.include?("[X]") ? true : false)
    $game_system.repeter_y = (dat.name2.include?("[Y]") ? true : false)
    $game_system.tjs_scroll = (dat.name2.include?("[S]") ? true : false)
    $game_system.anime = (dat.name2.include?("[A]") ? true : false)
    $game_system.hor_blanc = (dat.name2.include?("[B]") ? true : false)
    $game_system.pano_fixe = (dat.name2.include?("[P]") ? true : false)
    $game_system.ov = (dat.name2.include?("[OV]") ? true : false)
    if $game_system.M7
      dat.name2 =~ /[#[ ]*([00-99]+)]/i
      $game_system.angle = ($1 == nil ? 0 : $1.to_i)
      $game_system.angle = [[$game_system.angle, 0].max, 89].min
    end
  end
  #--------------------------------------------------------------------------
  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
    init_options
    if $game_system.M7
      @tilemap = Tilemap_M7.new(@viewport1)
    else
      @tilemap = Tilemap.new(@viewport1)
      @tilemap.tileset = RPG::Cache.tileset($game_map.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.data
      @tilemap.priorities = $game_map.priorities
    end
    @panorama = Plane.new(@viewport1)
    @panorama.z = ($game_system.M7 ? -100000 : -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
  #--------------------------------------------------------------------------
  def dispose
    if !$game_system.M7
      @tilemap.tileset.dispose
      for i in 0..6
        @tilemap.autotiles[i].dispose
      end
    end
    @tilemap.dispose
    @panorama.dispose
    @fog.dispose
    for sprite in @character_sprites
      sprite.dispose
    end
    @weather.dispose
    for sprite in @picture_sprites
      sprite.dispose
    end
    @timer_sprite.dispose
    @viewport1.dispose
    @viewport2.dispose
    @viewport3.dispose
  end
  #--------------------------------------------------------------------------
  def update
    if @panorama_name != $game_map.panorama_name or
       @panorama_hue != $game_map.panorama_hue
      @panorama_name = $game_map.panorama_name
      @panorama_hue = $game_map.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.fog_name or @fog_hue != $game_map.fog_hue
      @fog_name = $game_map.fog_name
      @fog_hue = $game_map.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
    if $game_system.M7
      if Graphics.frame_count % 20 == 0 and $game_system.anime
        @tilemap.update_anime
      end
    else
      @tilemap.ox = $game_map.display_x / 4
      @tilemap.oy = $game_map.display_y / 4
    end
    @tilemap.update
    if $game_system.pano_fixe
      @panorama.ox = 0
      @panorama.oy = 0
    elsif $game_system.M7
      @panorama.ox = (128*$game_map.width*$game_player.num_carte_x+
      $game_player.real_x)/8
      @panorama.oy = - (128*$game_map.height*$game_player.num_carte_y+
      $game_player.real_y)/32
    else
      @panorama.ox = $game_map.display_x / 8
      @panorama.oy = $game_map.display_y / 8
    end
    @fog.zoom_x = $game_map.fog_zoom / 100.0
    @fog.zoom_y = $game_map.fog_zoom / 100.0
    @fog.opacity = $game_map.fog_opacity
    @fog.blend_type = $game_map.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

#============================================================================
# ■ Scene_Map
#============================================================================
class Scene_Map
  attr_accessor :spriteset
end

#============================================================================
# ■ Data_Autotiles
#============================================================================

class Data_Autotiles < Bitmap
  $data_creation = [[27,28,33,34],[5,28,33,34],[27,6,33,34],[5,6,33,34],
  [27,28,33,12],[5,28,33,12],[27,6,33,12],[5,6,33,12],[27,28,11,34],
  [5,28,11,34],[27,6,11,34],[5,6,11,34],[27,28,11,12],[5,28,11,12],
  [27,6,11,12],[5,6,11,12],[25,26,31,32],[25,6,31,32],[25,26,31,12],
  [25,6,31,12],[15,16,21,22],[15,16,21,12],[15,16,11,22],[15,16,11,12],
  [29,30,35,36],[29,30,11,36],[5,30,35,36],[5,30,11,36],[39,40,45,46],
  [5,40,45,46],[39,6,45,46],[5,6,45,46],[25,30,31,36],[15,16,45,46],
  [13,14,19,20],[13,14,19,12],[17,18,23,24],[17,18,11,24],[41,42,47,48],
  [5,42,47,48],[37,38,43,44],[37,6,43,44],[13,18,19,24],[13,14,43,44],
  [37,42,43,48],[17,18,47,48],[13,18,43,48],[13,18,43,48]]
  attr_accessor :numero
  attr_accessor :anime
  #--------------------------------------------------------------------------
  def initialize(fichier,l)
    super(8*32, 6*32)
    creer(fichier,l)
  end
  #--------------------------------------------------------------------------
  def creer(fichier,l)
    l = (fichier.width > 96 ? l : 0)
    self.anime = (fichier.width > 96 ? true : false)
    for i in 0..5
      for j in 0..7
        data = $data_creation[8*i+j]
        for nb in data
          nb -= 1
          m = 16 * (nb % 6)
          n = 16 * (nb / 6)
          blt(32*j+m%32, 32*i+n%32, fichier, Rect.new(m+96*l,n,16,16))
        end
      end
    end
  end
end

#============================================================================
# ■ Data_Tiles_Verticaux
#============================================================================

class Data_Tiles_Verticaux
  attr_accessor  :liste_sprites_V
  attr_accessor  :liste_sprites_V_anime
  #--------------------------------------------------------------------------
  def convient?(val, num)
    return ($game_map.terrain_tags[val] == num)
  end
  #--------------------------------------------------------------------------
  def initialize(viewport)
    @viewport = viewport
    self.liste_sprites_V = []
    self.liste_sprites_V_anime = []
    @num_tiles = []
    @dataV = ($game_map.data).clone
    for h in 0..2
      for i in 0..$game_map.height
        for j in 0..$game_map.width
          val = @dataV[j, i, h].to_i
          if $num_terrains.include?($game_map.terrain_tags[val])
            @num_terr = $game_map.terrain_tags[val]
            @num_tiles.push([j,i])
            fin = 0
            l = 0
            while j+l+1 < $game_map.width and
              convient?(@dataV[j+l+1,i,h].to_i, @num_terr)
              @num_tiles.push([j+l+1,i])
              l += 1
            end
            deb = j
            fin = l+j
            indic = true
            ligne = 0
            j2 = j
            while indic
              ligne += 1
              break if i+ligne == $game_map.height
              dep = j2
              l2 = 0
              indic = false
              if l >= 2
                for k in j2+1..j2+l-1
                  if convient?(@dataV[k,i+ligne,h].to_i, @num_terr)
                    if !indic
                      dep = k
                    else
                      l2 = k-dep
                    end
                    indic = true
                    @num_tiles.push([k,i+ligne])
                  elsif !indic
                    l2 -= 1
                  end
                end
              end
              if convient?(@dataV[j2+l,i+ligne,h].to_i, @num_terr)
                l2 = j2+l-dep
                indic = true
                @num_tiles.push([j2+l,i+ligne])
                b = 1
                while j2+l+b < $game_map.width and
                  convient?(@dataV[j2+l+b,i+ligne,h].to_i, @num_terr)
                  @num_tiles.push([j2+l+b,i+ligne])
                  b += 1
                  l2 += 1
                  if j2+l+b > fin
                    fin = j2+l+b
                  end
                end
              end
              if convient?(@dataV[j2,i+ligne,h].to_i, @num_terr)
                dep2 = dep-j2
                l2 = l2+dep2
                dep = j2
                indic = true
                @num_tiles.push([j2,i+ligne])
                b = 1
                while j2-b >= 0 and
                  convient?(@dataV[j2-b,i+ligne,h].to_i, @num_terr)
                  @num_tiles.push([j2-b,i+ligne])
                  b += 1
                  l2 += 1
                  dep -= 1
                  if dep < deb
                    deb = dep
                  end
                end
              end
              l = l2
              j2 = dep
            end
            ligne -= 1
            creer_bitmap(i, deb, ligne, fin-deb, h)
            effacer_donnees(h)
            @num_tiles = []
          end
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  def effacer_donnees(couche)
    for num in @num_tiles
      @dataV[num[0], num[1], couche] = 0
    end
  end
  #--------------------------------------------------------------------------
  def creer_bitmap(i, deb, hauteur, largeur, couche)
    bmp = Bitmap.new(32*(1+largeur), 32*(1+hauteur))
    rect = Rect.new(0, 0, 32, 32)
    @num_tiles.sort! {|a, b|  -(a[1] - b[1])}
    sprite = Sprite_V.new(@viewport)
    sprite.anime = false
    sprite.liste_bmp = []
    for num in @num_tiles
      valeur = @dataV[num[0], num[1], couche].to_i
      if valeur > 383
        bitmap = RPG::Cache.tile($game_map.tileset_name, valeur, 0)
      else
        file = (valeur / 48) - 1
        num_file = 4*file
        if !sprite.anime
          autotile_name = $game_map.autotile_names[file]
          fichier = RPG::Cache.autotile(autotile_name)
          sprite.anime = (fichier.width > 96 ? true : false)
        end
        bitmap = RPG::Cache.autotile_base(num_file, valeur)
      end
      bmp.blt(32*(num[0]-deb), 32*(num[1]-i), bitmap, rect)
    end
    sprite.liste_bmp.push(bmp)
    if sprite.anime
      for j in 1..3
        bmp = Bitmap.new(32*(1+largeur), 32*(1+hauteur))
        for num in @num_tiles
          valeur = @dataV[num[0], num[1], couche].to_i
          if valeur > 383
            bitmap = RPG::Cache.tile($game_map.tileset_name, valeur, 0)
          else
            num_file = 4*((valeur / 48) - 1)
            bitmap = RPG::Cache.autotile_base(num_file + j, valeur)
          end
          bmp.blt(32*(num[0]-deb), 32*(num[1]-i), bitmap, rect)
        end
        sprite.liste_bmp.push(bmp)
      end
    end
    val = @dataV[@num_tiles[0][0], @num_tiles[0][1], couche].to_i
    sprite.prio = $game_map.priorities[val]
    sprite.x_map = (deb.to_f) + bmp.width / 64
    sprite.x_map += 0.5 if largeur % 2 == 0
    sprite.y_map = (i + hauteur).to_f + 0.5
    sprite.case_y = sprite.y_map.to_i
    sprite.oy = bmp.height - 16
    sprite.ox = bmp.width / 2
    sprite.bitmap = sprite.liste_bmp[0]
    self.liste_sprites_V.push(sprite)
    self.liste_sprites_V_anime.push(sprite) if sprite.anime
  end
end

[/spoiler]

fin :
[spolier]

Code: Tout sélectionner

#============================================================================
# ■ RPG::Cache_Tile
#============================================================================

module RPG
  module Cache_Tile
    @cache = {}
    #------------------------------------------------------------------------
    def self.load(val1,val2,offset=0)
      if not @cache.include?([val1, val2, offset])
        bmp = Bitmap.new(32, 32)
        rect = Rect.new(0, 0, 32, 32)
        if val1 > 383
          bmp.blt(0, 0, RPG::Cache.tile($game_map.tileset_name, val1, 0), rect)
        else
          num = 4*((val1 / 48) - 1) + offset
          bmp.blt(0, 0, RPG::Cache.autotile_base(num, val1), rect)
        end
        if val2 > 383
          bmp.blt(0, 0, RPG::Cache.tile($game_map.tileset_name, val2, 0), rect)
        else
          num = 4*((val2 / 48) - 1) + offset
          bmp.blt(0, 0, RPG::Cache.autotile_base(num, val2), rect)
        end
        @cache[[val1, val2, offset]] = bmp
      end
      @cache[[val1, val2, offset]]
    end
    #------------------------------------------------------------------------
    def self.load2(val1,val2,val3,offset=0)
      if not @cache.include?([val1, val2, val3, offset])
        bmp = Bitmap.new(32, 32)
        rect = Rect.new(0, 0, 32, 32)
        if val1 > 383
          bmp.blt(0, 0, RPG::Cache.tile($game_map.tileset_name, val1, 0), rect)
        else
          num = 4*((val1 / 48) - 1) + offset
          bmp.blt(0, 0, RPG::Cache.autotile_base(num, val1), rect)
        end
        if val2 > 383
          bmp.blt(0, 0, RPG::Cache.tile($game_map.tileset_name, val2, 0), rect)
        else
          num = 4*((val2 / 48) - 1) + offset
          bmp.blt(0, 0, RPG::Cache.autotile_base(num, val2), rect)
        end
        if val3 > 383
          bmp.blt(0, 0, RPG::Cache.tile($game_map.tileset_name, val3, 0), rect)
        else
          num = 4*((val3 / 48) - 1) + offset
          bmp.blt(0, 0, RPG::Cache.autotile_base(num, val3), rect)
        end
        @cache[[val1, val2, val3, offset]] = bmp
      end
      @cache[[val1, val2, val3, offset]]
    end
    #------------------------------------------------------------------------
    def self.clear
      @cache = {}
      GC.start
    end
  end
end

#============================================================================
# ■ RPG::Cache_Carte
#============================================================================

module RPG
  module Cache_Carte
    @cache = {}
    #------------------------------------------------------------------------
    def self.en_cache(map_id)
      return @cache.include?(map_id)
    end
    #------------------------------------------------------------------------
    def self.load(map_id, num = 0)
      return @cache[map_id][num]
    end
    #------------------------------------------------------------------------
    def self.save(map_id, bmp, num = 0)
      @cache[map_id] = [] if !self.en_cache(map_id)
      @cache[map_id][num] = bmp
    end
    #------------------------------------------------------------------------
    def self.clear
      @cache = {}
      GC.start
    end
  end
end

#============================================================================
# ■ RPG::Cache
#============================================================================

module RPG
  module Cache
    def self.autotile_base(num,val)
      key = [num, val]
      if not @cache.include?(key) or @cache[key].disposed?
        @cache[key] = Bitmap.new(32, 32)
        num_tile = val % 48
        sx = 32 * (num_tile % 8)
        sy = 32 * (num_tile / 8)
        rect = Rect.new(sx, sy, 32, 32)
        @cache[key].blt(0, 0, self.load_autotile(num), rect)
      end
        @cache[key]
    end
    #------------------------------------------------------------------------
    def self.save_autotile(bitmap, key)
      @cache[key] = bitmap
    end
    #------------------------------------------------------------------------
    def self.load_autotile(key)
      @cache[key]
    end
  end
end

#============================================================================
# ■ RPG::MapInfo
#============================================================================

class RPG::MapInfo
  def name
    return @name.gsub(/[.*]/) {""}
  end
  #--------------------------------------------------------------------------
  def name2
    return @name
  end
end

[/spoiler]

Oui, y'a des bugs. J'arrive pas à l'utiliser.