Partagez
Aller en bas
avatar
tenta
Staffeux retraité

Nombre de messages : 334
Age : 30
Localisation : Canada (Québec)
Distinction : Anti-Boulets suprême!
Date d'inscription : 03/01/2008

[résolu] Probleme avec script Mode 7 Ace.

le Jeu 17 Jan 2013 - 12:33
Bon, de 1. Le script est de MGC

Le script
Code:
#====================================================================
# Mode 7 Ace
# v.1.2
# Auteur : MGC
#
# Il s'agit d'un script de mode 7 basique pour RMVX Ace.
#
# - Permet une inclinaison de la carte de 0° à 89°
# - Toute la carte est inclinée, sans relief. Seuls les évènements
#  paraissent dressés verticalement.
# - L'effet de colorisation à l'horizon est personnalisable.
# - Les tiles animés sont supportés, ainsi que le bouclage de la carte.
# - possibilité de zoomer (de 1:8 à 8:1) quand le mode 7 est activé.
#
# IMPORTANT : SI VOUS RENCONTREZ DU LAG, VEUILLEZ VOUS ASSURER D'AVOIR
# DECOCHER "REDUCE SCREEN FLICKERING" (F1).
#
# Nécessite :
# - le fichier MGC_Mode7_Ace.dll à la racine du projet
# - les 3 fichiers graphiques suivants, déposés dans Pictures/ :
#        - autotiles_data.png
#        - autotiles_data_small.png
#        - autotiles_data_xsmall.png
#
# Configuration :
# - MODE7_MAPS_ID : Contient la liste des id des cartes pour lesquelles
#        le mode 7 est appliqué dès l'entrée sur ces cartes
# - MODE7_DEFAULT_ZOOM : valeur de zoom par défaut qui s'applique dès le
#        passage en mode 7. Compris entre 0.125 et 8.0.
# - MODE7_DEFAULT_ANGLE : valeur d'angle d'inclinaison par défaut qui
#        s'applique dès le passage en mode 7. Compris entre 0 et 89.
# - MODE7_VIEW_LIMIT : nombre de tiles supplémentaires à afficher (en plus
#        des 13 pour la vue normale de la carte en 544 * 416) avant l'horizon.
# - MODE7_FADING_DISTANCE : nombre de tiles avant l'horizon subissant un
#        dégradé de ton et/ou d'opacité.
# - MODE7_FADING_TONE : composantes de couleur R, G, B vers lesquelles tend
#        le dégradé de ton à l'horizon. Chaque composantes peut varier
#        entre -255 et 255.
# - MODE7_FADING_OPACITY : opacité vers laquelle tend le dégradé d'opacité ton
#        à l'horizon. Compris entre 255 (pas de dégradé d'opacité) et 0.
# - MODE7_SCAN_STEP : méthode de rafraîchissement de l'écran :
#        - 1 : l'écran est entièrement redessiné en 1 frame. Déconseillé
#              car extrêmement gourmand en ressources.
#        - 2 : l'écran est redessiné en 2 frames (une ligne de l'écran sur
#              deux est dessinée pour chaque frame).
#        - 3 : l'écran est redessiné en 3 frames (une ligne de l'écran sur
#              trois est dessinée pour chaque frame). Conseillé s'il y a
#              trop de lag.
#
# Utilisation :
# Commandes utilisables comme commandes d'évènement avec Script... :
# - MGC.start_mode7 : lance le mode 7 pour la carte
# - MGC.to_mode7_angle(nouvel angle, durée de transition)
# - MGC.to_mode7_zoom(nouvelle valeur de zoom, durée de transition)
# - MGC.end_mode7 : quitte le mode 7
# - MGC.set_mode7_scan(nouvelle valeur) : modifie le paramètre MODE7_SCAN_STEP
#====================================================================
module MGC
  #--------------------------------------------------------------------------
  # * CONFIGURATION
  #--------------------------------------------------------------------------
  MODE7_MAPS_ID = [1]
  MODE7_DEFAULT_ZOOM = 1.0
  MODE7_DEFAULT_ANGLE = 30
  MODE7_VIEW_LIMIT = 26
  MODE7_FADING_DISTANCE = 13
  MODE7_FADING_TONE = Tone.new(64, 64, 128)
  MODE7_FADING_OPACITY = 0
  MODE7_SCAN_STEP = 2
  #--------------------------------------------------------------------------
  # * Initialisation
  #--------------------------------------------------------------------------
  @mode7_zoom = 1.0
  @mode7_active = false
  #--------------------------------------------------------------------------
  # * Lancement du mode 7
  #--------------------------------------------------------------------------
  def self.start_mode7
    @end_mode7 = false
    @spriteset.start_mode7
  end
  #--------------------------------------------------------------------------
  # * Fin du mode 7
  #--------------------------------------------------------------------------
  def self.end_mode7
    @end_mode7 = true
    self.to_mode7_zoom(1.0, 1)
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut spriteset
  #--------------------------------------------------------------------------
  def self.spriteset=(spriteset)
    @spriteset = spriteset
  end
  #--------------------------------------------------------------------------
  # * Initialisation des données du mode 7
  #--------------------------------------------------------------------------
  def self.initialize_mode7
    self.mode7_angle = $game_system.mode7_angle ? $game_system.mode7_angle :
    MODE7_DEFAULT_ANGLE
    @mode7_angle_duration = 0
    @mode7_zoom = $game_system.mode7_zoom ? $game_system.mode7_zoom :
    MODE7_DEFAULT_ZOOM
    @mode7_zoom_incr = Math.log(@mode7_zoom) / Math.log(2)
    @mode7_zoom_duration = 0
    pivot = (Graphics.height >> 1) + 12
    @mode7_data = [pivot, pivot.to_f / Graphics.height, 1.0, 1.0, 0,
    Graphics.height, 0, 0, 0, 0]
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut mode7_data
  #--------------------------------------------------------------------------
  def self.mode7_data
    return @mode7_data
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut mode7_zoom
  #--------------------------------------------------------------------------
  def self.mode7_zoom
    return @mode7_zoom
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut mode7_angle
  #--------------------------------------------------------------------------
  def self.mode7_angle
    return @mode7_angle
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut mode7_active
  #--------------------------------------------------------------------------
  def self.mode7_active
    return @mode7_active
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut mode7_active
  #--------------------------------------------------------------------------
  def self.mode7_active=(flag)
    $game_system.mode7_active = flag
    @mode7_active = flag
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut mode7_zoom
  #--------------------------------------------------------------------------
  def self.mode7_zoom=(zoom_value)
    unless mode7_zoom == zoom_value
      if zoom_value < 0.125 || zoom_value > 8.0 then return end
      @mode7_zoom = zoom_value
      $game_system.mode7_zoom = @mode7_zoom
      $game_player.center($game_player.x, $game_player.y)
    end
  end
  #--------------------------------------------------------------------------
  # * Incrémentation de la valeur du zoom du mode 7
  #--------------------------------------------------------------------------
  def self.incr_mode7_zoom(val = 0.02)
    @mode7_zoom_incr += val
    new_zoom = 2 ** @mode7_zoom_incr
    self.mode7_zoom = new_zoom
  end
  #--------------------------------------------------------------------------
  # * Pour aller progressivement vers une nouvelle valeur de zoom du mode 7
  #--------------------------------------------------------------------------
  def self.to_mode7_zoom(new_zoom, duration)
    unless mode7_zoom == new_zoom
      if new_zoom < 0.125 || new_zoom > 8.0 then return end
      @mode7_zoom_duration = duration
      target_zoom_incr = Math.log(new_zoom) / Math.log(2)
      @mode7_zoom_step = (target_zoom_incr - @mode7_zoom_incr) / duration
      @target_mode7_zoom = new_zoom
    end
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut mode7_angle
  #--------------------------------------------------------------------------
  def self.mode7_angle=(new_angle)
    unless new_angle == @mode7_angle
      @mode7_angle = [[new_angle, 0].max, 89].min
      @mode7_angle_real = @mode7_angle
      $game_system.mode7_angle = @mode7_angle
    end
  end
  #--------------------------------------------------------------------------
  # * Autre setter pour l'attribut mode7_angle, ne réinitialisant pas @mode7_angle_real
  #--------------------------------------------------------------------------
  def self.set_mode7_angle(new_angle)
    unless new_angle == @mode7_angle
      @mode7_angle = [[new_angle, 0].max, 89].min
      $game_system.mode7_angle = @mode7_angle
    end
  end
  #--------------------------------------------------------------------------
  # * Incrémentation de la valeur de l'angle du mode 7
  #--------------------------------------------------------------------------
  def self.incr_mode7_angle(val = 2)
    @mode7_angle_real += @mode7_angle_step
    self.set_mode7_angle(@mode7_angle_real.to_i)
  end
  #--------------------------------------------------------------------------
  # * Pour aller progressivement vers une nouvelle valeur de l'angle du mode 7
  #--------------------------------------------------------------------------
  def self.to_mode7_angle(new_angle, duration)
    unless @mode7_angle == new_angle
      new_angle = [[new_angle, 0].max, 89].min
      @mode7_angle_duration = duration
      @mode7_angle_step = (new_angle - @mode7_angle).to_f / duration
      @target_mode7_angle = new_angle
    end
  end
  #--------------------------------------------------------------------------
  # * Mise à jour du mode 7
  #--------------------------------------------------------------------------
  def self.update_mode7
    if @mode7_active
      if @mode7_zoom_duration > 0
        @mode7_zoom_duration -= 1
        if @mode7_zoom_duration == 0
          self.mode7_zoom = @target_mode7_zoom
        else
          self.incr_mode7_zoom(@mode7_zoom_step)
        end
      elsif @mode7_angle_duration > 0
        @mode7_angle_duration -= 1
        if @mode7_angle_duration == 0
          self.mode7_angle = @target_mode7_angle
        else
          self.incr_mode7_angle(@mode7_angle_step)
        end
      elsif @end_mode7
        @spriteset.end_mode7
        @end_mode7 = false
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Vérifie si un effet est en cours
  #--------------------------------------------------------------------------
  def self.effect?
    return @mode7_active && (@mode7_zoom_duration > 0 ||
    @mode7_angle_duration > 0)
  end
  #--------------------------------------------------------------------------
  # * Modifie la valeur de la méthode de rafraîchissement de l'écran
  #--------------------------------------------------------------------------
  def self.set_mode7_scan(new_value)
    new_value = [[new_value, 1].max, 3].min
    unless MODE7_SCAN_STEP == new_value
      self.const_set(:MODE7_SCAN_STEP, new_value)
    end
  end
  #==============================================================================
  # ** MGC::Tilemap
  #==============================================================================
  class Mode7_Map
    #--------------------------------------------------------------------------
    # * Attributs
    #--------------------------------------------------------------------------
    attr_reader :viewport, :visible, :ox, :oy, :opacity, :blend_type, :color,
    :tone, :wave_amp, :wave_length, :wave_speed, :wave_phase, :zoom, :map_data,
    :flags
    attr_accessor :bitmaps, :flash_data
    attr_reader :alpha, :parameters
    #--------------------------------------------------------------------------
    # * Constantes
    #--------------------------------------------------------------------------
    RENDER = Win32API.new("MGC_Mode7_Ace", "renderMode7", "l", "l")
    #--------------------------------------------------------------------------
    # * Initialisation
    #--------------------------------------------------------------------------
    def initialize(viewport)
      @viewport = viewport
      self.bitmaps = [0, 0, 0, 0, 0, 0, 0, 0, 0]
      @map_data = 0
      @flags = 0
      self.flash_data = nil
      @cx = Graphics.width >> 1
      @cy = Graphics.height >> 1
      @sprite_render = Sprite.new(viewport)
      @render = Bitmap.new(Graphics.width, Graphics.height)
      @sprite_render.bitmap = @render
      @sprite_render.x = 0
      @sprite_render.y = 0
      @sprite_render.z = 0
      @zoom = 1.0
      @view_limit = MODE7_VIEW_LIMIT << 5
      fading_dist = MODE7_FADING_DISTANCE << 5
      fading_begin = Graphics.height + @view_limit - fading_dist
      m7_data = Table.new(Graphics.width + 6, Graphics.height)
      @parameters = [@render, 0, map_data, bitmaps,
      Cache.picture('autotiles_data'), Cache.picture('autotiles_data_small'),
      Cache.picture('autotiles_data_xsmall'), 0, 0, 0, 0, 0, 0, 0, 4096,
      100, $game_map.loop_horizontal?, $game_map.loop_vertical?, MODE7_SCAN_STEP,
      0, m7_data, 2048, 0, MGC.mode7_data[5], MGC.mode7_data[0], 0, 0, 0, 0, 0,
      fading_begin, fading_dist, MODE7_FADING_TONE.red.to_i,
      MODE7_FADING_TONE.green.to_i, MODE7_FADING_TONE.blue.to_i,
      MODE7_FADING_OPACITY]
      MGC.mode7_data[9] = m7_data
      self.alpha = 0
      self.visible = true
      self.zoom = 1.0
      self.ox = 0
      self.oy = 0
      self.opacity = 255
      self.blend_type = 0
      self.color = Color.new
      self.tone = Tone.new
      self.wave_amp = 0
      self.wave_length = 180
      self.wave_speed = 360
      self.wave_phase = 0.0
      @initialization = true
    end
    #--------------------------------------------------------------------------
    # * Refresh all the parameters dependent on the angle of slant
    #--------------------------------------------------------------------------
    def refresh_alpha
      # angle of slant
      alpha_rad = (Math::PI * alpha) / 180
      cos_alpha_real = Math.cos(alpha_rad)
      sin_alpha_real = Math.sin(alpha_rad)
      cos_alpha = (2048 * cos_alpha_real).to_i
      sin_alpha = (2048 * sin_alpha_real).to_i
      distance_h = MGC.mode7_data[5]
      pivot = MGC.mode7_data[0]
      # h0,  z0 : intermediate values used to calculate the slope
      h0 = (-distance_h * pivot * cos_alpha) / ((distance_h << 11) +
      pivot * sin_alpha) + pivot
      z0 = (distance_h << 11).to_f / ((distance_h << 11) + pivot * sin_alpha)
      # slope
      slope_value = (1.0 - z0) / (pivot - h0)
      slope_value_map = (131072 * slope_value).to_i
      corrective_value = 1.0 - pivot * slope_value
      corrective_value_map = (131072 * corrective_value).to_i
      last_line = ((-pivot - @view_limit) * zoom).to_i
      height_limit = (distance_h * last_line * cos_alpha) /
      ((distance_h << 11) - last_line * sin_alpha) + pivot
      height_limit = [height_limit.to_i, 0].max
      parameters[21] = cos_alpha
      parameters[22] = sin_alpha
      parameters[25] = slope_value_map
      parameters[26] = corrective_value_map
      parameters[27] = height_limit
      parameters[29] = MODE7_SCAN_STEP
      MGC.mode7_data[3] = cos_alpha_real
      MGC.mode7_data[4] = sin_alpha_real
      MGC.mode7_data[6] = slope_value
      MGC.mode7_data[7] = corrective_value
      MGC.mode7_data[8] = height_limit   
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut map_data
    #--------------------------------------------------------------------------
    def map_data=(new_map_data)
      @map_data = new_map_data
      parameters[2] = @map_data
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut flags
    #--------------------------------------------------------------------------
    def flags=(new_flags)
      @flags = new_flags
      parameters[7] = @flags
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut zoom
    #--------------------------------------------------------------------------
    def zoom=(new_zoom)
      unless zoom == new_zoom
        @zoom = new_zoom
        parameters[14] = (4096.0 / new_zoom).to_i
        MGC.mode7_data[2] = new_zoom
        vox = @ox
        @ox = nil
        self.ox = vox
        voy = @oy
        @oy = nil
        self.oy = voy
        @need_refresh = true
        parameters[29] = MODE7_SCAN_STEP
        last_line = ((-parameters[24] - @view_limit) * zoom).to_i
        height_limit = (parameters[23] * last_line * parameters[21]) /
        ((parameters[23] << 11) - last_line * parameters[22]) + parameters[24]
        parameters[27] = [height_limit.to_i, 0].max
        MGC.mode7_data[8] = parameters[27]
      end
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut alpha
    #--------------------------------------------------------------------------
    def alpha=(new_alpha)
      unless new_alpha == alpha
        @alpha = new_alpha
        refresh_alpha
      end
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut shadow_opacity
    #--------------------------------------------------------------------------
    def shadow_opacity=(value)
      @parameters[15] = [[value, 0].max, 255].min
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut visible
    #--------------------------------------------------------------------------
    def visible=(flag)
      @visible = flag
      @sprite_render.visible = flag
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut ox
    #--------------------------------------------------------------------------
    def ox=(new_ox)
      new_ox = new_ox.to_i
      unless new_ox == @ox
        @ox = new_ox
        @need_refresh = true
        parameters[8] = @ox
        parameters[29] = MODE7_SCAN_STEP
      end
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut oy
    #--------------------------------------------------------------------------
    def oy=(new_oy)
      new_oy = new_oy.to_i
      unless new_oy == @oy
        @oy = new_oy
        @need_refresh = true
        parameters[9] = @oy
        parameters[29] = MODE7_SCAN_STEP
      end
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut opacity
    #--------------------------------------------------------------------------
    def opacity=(new_opacity)
      @opacity = new_opacity
      @sprite_render.opacity = new_opacity
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut blend_type
    #--------------------------------------------------------------------------
    def blend_type=(new_blend_type)
      @blend_type = new_blend_type
      @sprite_render.blend_type = new_blend_type
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut color
    #--------------------------------------------------------------------------
    def color=(new_color)
      @color = new_color
      @sprite_render.color = new_color
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut tone
    #--------------------------------------------------------------------------
    def tone=(new_tone)
      @tone = new_tone
      @sprite_render.tone = new_tone
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut wave_amp
    #--------------------------------------------------------------------------
    def wave_amp=(new_wave_amp)
      @wave_amp = new_wave_amp
      @sprite_render.wave_amp = new_wave_amp
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut wave_length
    #--------------------------------------------------------------------------
    def wave_length=(new_wave_length)
      @wave_length = new_wave_length
      @sprite_render.wave_length = new_wave_length
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut wave_speed
    #--------------------------------------------------------------------------
    def wave_speed=(new_wave_speed)
      @wave_speed = new_wave_speed
      @sprite_render.wave_speed = new_wave_speed
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut wave_phase
    #--------------------------------------------------------------------------
    def wave_phase=(new_wave_phase)
      @wave_phase = new_wave_phase
      @sprite_render.wave_phase = new_wave_phase
    end
    #--------------------------------------------------------------------------
    # * Libération de l'instance
    #--------------------------------------------------------------------------
    def dispose
      @render.dispose
      @sprite_render.dispose
    end
    #--------------------------------------------------------------------------
    # * Retourne true si l'instance a été libérée
    #--------------------------------------------------------------------------
    def disposed?
      return @render.disposed?
    end
    #--------------------------------------------------------------------------
    # * Mise à jour, appelée normalement à chaque frame
    #--------------------------------------------------------------------------
    def update
      if @visible
        if parameters[18] != MODE7_SCAN_STEP
          parameters[18] = MODE7_SCAN_STEP
          parameters[19] = 0
          parameters[29] = 0
          @need_refresh = true
        end
        self.alpha = MGC.mode7_angle
        self.zoom = MGC.mode7_zoom
        if Graphics.frame_count & 31 == 0
          parameters[10] += 1
          parameters[10] %= 3
          parameters[29] = MODE7_SCAN_STEP
          unless @need_refresh
            @need_refresh_anim = true
          end
        end
        if parameters[29] > 0 && !@need_refresh && !@need_refresh_anim
          @need_refresh = true
        end
        begin
          if @need_refresh
            parameters[19] += 1
            if parameters[19] == parameters[18]
              parameters[19] = 0
            end
            parameters[11] = 0
            RENDER.call(parameters.__id__)
            parameters[29] -= 1
            if parameters[29] == 0
              @need_refresh = false
            end
          elsif @need_refresh_anim
            parameters[19] += 1
            if parameters[19] == parameters[18]
              parameters[19] = 0
            end
            parameters[11] = 1
            RENDER.call(parameters.__id__)
            parameters[29] -= 1
            if parameters[29] == 0
              @need_refresh_anim = false
            end
          end
          if @initialization && parameters[29] == 0
            @initialization = false
          end
        end while @initialization
        @sprite_render.update
      end
    end
    #--------------------------------------------------------------------------
    # * Flash des couches de la tilemap
    #--------------------------------------------------------------------------
    def flash(color, duration)
      @sprite_render.flash(color, duration)
    end
  end
end

#==============================================================================
# ** Game_System
#==============================================================================
class Game_System
  #--------------------------------------------------------------------------
  # * Attributs
  #--------------------------------------------------------------------------
  attr_accessor :mode7_zoom, :mode7_angle, :mode7_active
end

#==============================================================================
# ** Game_Map
#==============================================================================
class Game_Map
  attr_accessor :start_mode7, :end_mode7
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_m7a
    alias setup_mgc_m7a setup
    alias set_display_pos_mgc_m7a set_display_pos
    alias scroll_down_mgc_m7a scroll_down
    alias scroll_left_mgc_m7a scroll_left
    alias scroll_right_mgc_m7a scroll_right
    alias scroll_up_mgc_m7a scroll_up
    @already_aliased_mgc_m7a = true
  end
  #--------------------------------------------------------------------------
  # * Setup
  #--------------------------------------------------------------------------
  def setup(map_id)
    setup_mgc_m7a(map_id)
    if MGC::MODE7_MAPS_ID.include?(map_id)
      self.start_mode7 = true
    else
      self.end_mode7 = true
    end
  end
  #--------------------------------------------------------------------------
  # * Set Display Position
  #--------------------------------------------------------------------------
  def set_display_pos(x, y)
    if MGC.mode7_active
      if loop_horizontal?
        @display_x = (x + width) % width
      else
        if MGC.mode7_zoom < 1.0 && width * MGC.mode7_zoom < screen_tile_x
          @display_x = (width - screen_tile_x) / 2
        else
          x_min = screen_tile_x * (1.0 / MGC.mode7_zoom - 1.0) / 2
          x_max = width + screen_tile_x * ((1.0 - 1.0 / MGC.mode7_zoom) / 2 - 1)
          x = [x_min, [x, x_max].min].max
          @display_x = x
        end
      end
      if loop_vertical?
        @display_y = (y + height) % height
      else
        if MGC.mode7_zoom < 1.0 && height * MGC.mode7_zoom < screen_tile_y
          @display_y = (height - screen_tile_y) * MGC.mode7_data[1]
        else
          y_min = screen_tile_y * (1.0 / MGC.mode7_zoom - 1.0) * MGC.mode7_data[1]
          y_max = height + screen_tile_y *
          ((1.0 - 1.0 / MGC.mode7_zoom) * (1 - MGC.mode7_data[1]) - 1)
          y = [y_min, [y, y_max].min].max
          @display_y = y
        end
      end
      @parallax_x = x
      @parallax_y = y
    else
      set_display_pos_mgc_m7a(x, y)
    end
  end
  #--------------------------------------------------------------------------
  # * Scroll Down
  #--------------------------------------------------------------------------
  def scroll_down(distance)
    if MGC.mode7_active
      if loop_vertical?
        @display_y += distance
        @display_y %= @map.height
        @parallax_y += distance if @parallax_loop_y
      else
        last_y = @display_y
        if MGC.mode7_zoom < 1.0 && height * MGC.mode7_zoom < screen_tile_y
          @display_y = (height - screen_tile_y) * MGC.mode7_data[1]
        else
          max = height + screen_tile_y *
          ((1.0 - 1.0 / MGC.mode7_zoom) * (1 - MGC.mode7_data[1]) - 1)
          @display_y = [@display_y + distance, max].min
        end
        @parallax_y += @display_y - last_y
      end
    else
      scroll_down_mgc_m7a(distance)
    end
  end
  #--------------------------------------------------------------------------
  # * Scroll Left
  #--------------------------------------------------------------------------
  def scroll_left(distance)
    if MGC.mode7_active
      if loop_horizontal?
        @display_x += @map.width - distance
        @display_x %= @map.width
        @parallax_x -= distance if @parallax_loop_x
      else
        last_x = @display_x
        if MGC.mode7_zoom < 1.0 && width * MGC.mode7_zoom < screen_tile_x
          @display_x = (width - screen_tile_x) / 2
        else
          min = screen_tile_x * (1.0 / MGC.mode7_zoom - 1.0) / 2
          @display_x = [@display_x - distance, min].max
        end
        @parallax_x += @display_x - last_x
      end
    else
      scroll_left_mgc_m7a(distance)
    end
  end
  #--------------------------------------------------------------------------
  # * Scroll Right
  #--------------------------------------------------------------------------
  def scroll_right(distance)
    if MGC.mode7_active
      if loop_horizontal?
        @display_x += distance
        @display_x %= @map.width
        @parallax_x += distance if @parallax_loop_x
      else
        last_x = @display_x
        if MGC.mode7_zoom < 1.0 && width * MGC.mode7_zoom < screen_tile_x
          @display_x = (width - screen_tile_x) / 2
        else
          max = width + screen_tile_x * ((1.0 - 1.0 / MGC.mode7_zoom) / 2 - 1)
          @display_x = [@display_x + distance, max].min
        end
        @parallax_x += @display_x - last_x
      end
    else
      scroll_right_mgc_m7a(distance)
    end
  end
  #--------------------------------------------------------------------------
  # * Scroll Up
  #--------------------------------------------------------------------------
  def scroll_up(distance)
    if MGC.mode7_active
      if loop_vertical?
        @display_y += @map.height - distance
        @display_y %= @map.height
        @parallax_y -= distance if @parallax_loop_y
      else
        last_y = @display_y
        if MGC.mode7_zoom < 1.0 && height * MGC.mode7_zoom < screen_tile_y
          @display_y = (height - screen_tile_y) * MGC.mode7_data[1]
        else
          min = screen_tile_y * (1.0 / MGC.mode7_zoom - 1.0) * MGC.mode7_data[1]
          @display_y = [@display_y - distance, min].max
        end
        @parallax_y += @display_y - last_y
      end
    else
      scroll_up_mgc_m7a(distance)
    end
  end
end

#==============================================================================
# ** Game_CharacterBase
#==============================================================================
class Game_CharacterBase
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :sprite
end

#==============================================================================
# ** Serialisation
#==============================================================================
[:Sprite, :Viewport, :Bitmap, :Font].each {|classname|
  eval(
  "class #{classname}
    def marshal_dump
      return []
    end
    def marshal_load(array)
    end
  end")
}

#==============================================================================
# ** Sprite
#==============================================================================
class Sprite
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_m7a
    alias initialize_mgc_m7a initialize
    alias zoom_x_mgc_m7a= zoom_x=
    alias zoom_y_mgc_m7a= zoom_y=
    alias zoom_x_mgc_m7a zoom_x
    alias zoom_y_mgc_m7a zoom_y
    @already_aliased_mgc_m7a = true
  end
  #--------------------------------------------------------------------------
  # * Initialisation
  #--------------------------------------------------------------------------
  def initialize(*args)
    initialize_mgc_m7a(*args)
    @phase_mode7 = false
    self.zoom_x = 1.0
    self.zoom_y = 1.0
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut zoom_x
  #--------------------------------------------------------------------------
  def zoom_x=(new_zoom_x)
    unless @phase_mode7
      @base_zoom_x = new_zoom_x
    end
    self.zoom_x_mgc_m7a = new_zoom_x
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut zoom_y
  #--------------------------------------------------------------------------
  def zoom_y=(new_zoom_y)
    unless @phase_mode7
      @base_zoom_y = new_zoom_y
    end
    self.zoom_y_mgc_m7a = new_zoom_y
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut zoom_x
  #--------------------------------------------------------------------------
  def zoom_x
    return @base_zoom_x
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut zoom_y
  #--------------------------------------------------------------------------
  def zoom_y
    return @base_zoom_y
  end
  #--------------------------------------------------------------------------
  # * Valeur réelle du zoom_x en prenant en compte le zoom de la carte
  #--------------------------------------------------------------------------
  def zoom_x_real
    return zoom_x_mgc_m7a
  end
  #--------------------------------------------------------------------------
  # * Valeur réelle du zoom_y en prenant en compte le zoom de la carte
  #--------------------------------------------------------------------------
  def zoom_y_real
    return zoom_y_mgc_m7a
  end
end

#==============================================================================
# ** Sprite_Base
#==============================================================================
class Sprite_Base
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_m7a
    alias animation_set_sprites_mgc_m7a_aprite_base animation_set_sprites
    @already_aliased_mgc_m7a = true
  end
  #--------------------------------------------------------------------------
  # * Set Animation Sprite
  #    frame : Frame data (RPG::Animation::Frame)
  #--------------------------------------------------------------------------
  def animation_set_sprites(frame)
    if MGC.mode7_active
      cell_data = frame.cell_data
      @ani_sprites.each_with_index do |sprite, i|
        next unless sprite
        pattern = cell_data[i, 0]
        if !pattern || pattern < 0
          sprite.visible = false
          next
        end
        sprite.bitmap = pattern < 100 ? @ani_bitmap1 : @ani_bitmap2
        sprite.visible = true
        sprite.src_rect.set(pattern % 5 * 192,
          pattern % 100 / 5 * 192, 192, 192)
        if @ani_mirror
          sprite.x = @ani_ox - cell_data[i, 1] * zoom_y_real
          sprite.y = @ani_oy + cell_data[i, 2] * zoom_y_real
          sprite.angle = (360 - cell_data[i, 4])
          sprite.mirror = (cell_data[i, 5] == 0)
        else
          sprite.x = @ani_ox + cell_data[i, 1] * zoom_y_real
          sprite.y = @ani_oy + cell_data[i, 2] * zoom_y_real
          sprite.angle = cell_data[i, 4]
          sprite.mirror = (cell_data[i, 5] == 1)
        end
        sprite.z = self.z + 300 + i
        sprite.ox = 96
        sprite.oy = 96
        sprite.zoom_x = cell_data[i, 3] * zoom_y_real / 100.0
        sprite.zoom_y = cell_data[i, 3] * zoom_y_real / 100.0
        sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
        sprite.blend_type = cell_data[i, 7]
      end
    else
      animation_set_sprites_mgc_m7a_aprite_base(frame)
    end
  end
end

#==============================================================================
# ** Sprite_Character
#==============================================================================
class Sprite_Character < Sprite_Base
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_m7a
    alias initialize_mgc_m7a_aprite_character initialize
    alias update_position_mgc_m7a_aprite_character update_position
    alias update_other_mgc_m7a_aprite_character update_other
    alias update_balloon_mgc_m7a_aprite_character update_balloon
    @already_aliased_mgc_m7a = true
  end
  #--------------------------------------------------------------------------
  # * Object Initialization
  #    character : Game_Character
  #--------------------------------------------------------------------------
  def initialize(viewport, character = nil)
    initialize_mgc_m7a_aprite_character(viewport, character)
    character.sprite = self
  end
  #--------------------------------------------------------------------------
  # * Update Position
  #--------------------------------------------------------------------------
  def update_position
    if MGC.mode7_active
      old_x = x
      old_y = y
      update_mode7
      self.z = @character.screen_z
      move_animation(x - old_x, y - old_y)
    else
      update_position_mgc_m7a_aprite_character
    end
  end
  #--------------------------------------------------------------------------
  # * Update Other
  #--------------------------------------------------------------------------
  def update_other
    update_other_mgc_m7a_aprite_character
    if MGC.mode7_active && visible
      if !@force_mode7_invisible &&
        y >= MGC.mode7_data[8] &&
        (y - height * zoom_y_real) < Graphics.height
      then
        self.visible = true
        if y < Graphics.height
          dat = MGC.mode7_data[9]
          self.opacity += dat[5, y]
          self.tone.set(dat[2, y], dat[3, y], dat[4, y])
        end
      else
        self.visible = false
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Update Position In Mode7
  #--------------------------------------------------------------------------
  def update_mode7
    y_screen = character.screen_y +
    (character.is_a?(Game_Vehicle) ? character.altitude : 0)
    y_init = MGC.mode7_data[2] * (y_screen - MGC.mode7_data[0])
    if y_init < - (MGC::MODE7_VIEW_LIMIT << 5) - MGC.mode7_data[0] ||
      y_init > Graphics.height
    then
      @force_mode7_invisible = true
      return
    else
      @force_mode7_invisible = false
    end
    x_init = MGC.mode7_data[2] * (character.screen_x - (Graphics.width >> 1))
    self.y = (MGC.mode7_data[0] + (MGC.mode7_data[5] * y_init *
    MGC.mode7_data[3]) / (MGC.mode7_data[5] - y_init * MGC.mode7_data[4])).to_i
    zx = MGC.mode7_data[6] * y + MGC.mode7_data[7]
    self.x = ((Graphics.width >> 1) + zx * x_init).to_i
    @phase_mode7 = true
    self.zoom_x = MGC.mode7_data[2] * zx
    self.zoom_y = zoom_x_real
    @phase_mode7 = false
    if character.is_a?(Game_Vehicle)
      self.y -= character.altitude * zoom_y_real
    end
  end
  #--------------------------------------------------------------------------
  # * Update Balloon Icon
  #--------------------------------------------------------------------------
  def update_balloon
    update_balloon_mgc_m7a_aprite_character
    if MGC.mode7_active && @balloon_duration > 0
      @balloon_sprite.y = y - height * zoom_y_real
      @balloon_sprite.zoom_x = zoom_x_real
      @balloon_sprite.zoom_y = zoom_y_real
    end
  end
end

#==============================================================================
# ** Spriteset_Map
#==============================================================================
class Spriteset_Map
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_m7a
    alias initialize_mgc_m7a initialize
    alias create_tilemap_mgc_m7a create_tilemap
    alias update_mgc_m7a update
    alias update_shadow_mgc_m7a update_shadow
    @already_aliased_mgc_m7a = true
  end
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    MGC.spriteset = self
    initialize_mgc_m7a
  end
  #--------------------------------------------------------------------------
  # * Lance le mode 7
  #--------------------------------------------------------------------------
  def start_mode7
    unless @tilemap_mode7
      MGC.initialize_mode7
      @tilemap_classic = @tilemap
      @tilemap_mode7 = MGC::Mode7_Map.new(@viewport1)
      @tilemap_mode7.map_data = $game_map.data
      @tilemap = @tilemap_mode7
      load_tileset
    end
    @tilemap_mode7.visible = true
    @tilemap_classic.visible = false
    @tilemap = @tilemap_mode7
    MGC.mode7_active = true
  end
  #--------------------------------------------------------------------------
  # * Met fin au mode 7
  #--------------------------------------------------------------------------
  def end_mode7
    if @tilemap_mode7
      @tilemap_mode7.visible = false
      @tilemap_classic.visible = true
      @tilemap = @tilemap_classic
    end
    MGC.mode7_active = false
  end
  #--------------------------------------------------------------------------
  # * Create Tilemap
  #--------------------------------------------------------------------------
  def create_tilemap
    create_tilemap_mgc_m7a
    unless $game_system.mode7_active
      MGC.mode7_active = false
    end
    if MGC::MODE7_MAPS_ID.include?($game_map.map_id) ||
      $game_system.mode7_active
    then
      start_mode7
    end
  end
  #--------------------------------------------------------------------------
  # * Update
  #--------------------------------------------------------------------------
  def update
    MGC.update_mode7
    if $game_map.start_mode7
      start_mode7
      $game_map.start_mode7 = false
    elsif $game_map.end_mode7
      end_mode7
      $game_map.end_mode7 = false
    end
    update_mgc_m7a
  end
  #--------------------------------------------------------------------------
  # * Update Airship Shadow Sprite
  #--------------------------------------------------------------------------
  def update_shadow
    if MGC.mode7_active
      airship_sprite = $game_map.airship.sprite
      @shadow_sprite.x = airship_sprite.x
      @shadow_sprite.y = airship_sprite.y + $game_map.airship.altitude *
      airship_sprite.zoom_y_real
      @shadow_sprite.opacity = $game_map.airship.altitude * 8 *
      airship_sprite.opacity
      @shadow_sprite.zoom_x = airship_sprite.zoom_x_real
      @shadow_sprite.zoom_y = airship_sprite.zoom_y_real
      @shadow_sprite.update
    else
      update_shadow_mgc_m7a
    end
  end
end

#==============================================================================
# ** Scene_Map
#==============================================================================
class Scene_Map < Scene_Base
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_m7a
    alias update_call_menu_mgc_m7a update_call_menu
    @already_aliased_mgc_m7a = true
  end
  #--------------------------------------------------------------------------
  # * Determine if Menu is Called due to Cancel Button
  #--------------------------------------------------------------------------
  def update_call_menu
    unless MGC.effect?
      update_call_menu_mgc_m7a
    end
  end
end

Le script permet d'avoir le mode 7 dans les maps que vous voulez.

Mon probleme est
Quand j'appuie sur le boutton New game, Je recois l'erreur de script suivant.

Script 'Mode Ace' line 911: NoMethodError occured.

undefined method `move_animation' for
#


La ligne 911 est
Code:
      move_animation(x - old_x, y - old_y)


Si vous avez besoin de plus de detail, vous n'avez qu'a demander.


Dernière édition par tenta le Sam 25 Mai 2013 - 11:26, édité 1 fois
avatar
tenta
Staffeux retraité

Nombre de messages : 334
Age : 30
Localisation : Canada (Québec)
Distinction : Anti-Boulets suprême!
Date d'inscription : 03/01/2008

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mar 22 Jan 2013 - 16:08
... Il y a quelqun? sa fais 5 jours que j'attend :/
avatar
tenta
Staffeux retraité

Nombre de messages : 334
Age : 30
Localisation : Canada (Québec)
Distinction : Anti-Boulets suprême!
Date d'inscription : 03/01/2008

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mar 26 Mar 2013 - 13:04
Apres 2 mois, toujours pas de reponse :/
avatar
tenta
Staffeux retraité

Nombre de messages : 334
Age : 30
Localisation : Canada (Québec)
Distinction : Anti-Boulets suprême!
Date d'inscription : 03/01/2008

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mar 30 Avr 2013 - 12:41
Bientot 4 mois.......j'aimerais bien avancer mon projet..
avatar
Spytje
Administrateur

Nombre de messages : 5899
Localisation : La terre
Distinction : Spiraliste [Korn']
Forestia : Projet du mois juillet 2014
Papy Pulkigrat [Yama']
Date d'inscription : 16/03/2008

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mar 30 Avr 2013 - 12:55
Une nouvelle version de ton script est dispo peut être devrais-tu tenter de mettre à jour ton projet également et voir si ça corrige ton problème.

LIEN

J'ai téléchargé la démo présente sur le site de l'auteur et elle fonctionne parfaitement.
avatar
tenta
Staffeux retraité

Nombre de messages : 334
Age : 30
Localisation : Canada (Québec)
Distinction : Anti-Boulets suprême!
Date d'inscription : 03/01/2008

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mar 30 Avr 2013 - 13:00
Oui je sait que la demo fonctionne mais bizarrement sa bug quand je le pose dans mon projet. Je vais essayer la nouvelle version! Merci de m'aider!
avatar
Spytje
Administrateur

Nombre de messages : 5899
Localisation : La terre
Distinction : Spiraliste [Korn']
Forestia : Projet du mois juillet 2014
Papy Pulkigrat [Yama']
Date d'inscription : 16/03/2008

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mar 30 Avr 2013 - 13:02
Oui test la nouvelle version et tente, si cella ne fonctionne pas, de déplacer ton script à un autre endroit.

Si cella ne foncionne toujours pas donne moi la liste des scripts que tu utilises.
avatar
tenta
Staffeux retraité

Nombre de messages : 334
Age : 30
Localisation : Canada (Québec)
Distinction : Anti-Boulets suprême!
Date d'inscription : 03/01/2008

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mar 30 Avr 2013 - 13:03
J'avais deja cette version. c'est cette meme version qui me fais cette erreur.
avatar
Spytje
Administrateur

Nombre de messages : 5899
Localisation : La terre
Distinction : Spiraliste [Korn']
Forestia : Projet du mois juillet 2014
Papy Pulkigrat [Yama']
Date d'inscription : 16/03/2008

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mar 30 Avr 2013 - 13:05
Ok c'est parce-que la version postée est 1.2 et celle sur le site de l'auteur 1.4.

Donne moi la liste des scripts que tu utilises.
avatar
tenta
Staffeux retraité

Nombre de messages : 334
Age : 30
Localisation : Canada (Québec)
Distinction : Anti-Boulets suprême!
Date d'inscription : 03/01/2008

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mar 30 Avr 2013 - 13:11
J'utilise les scriptes suivant.

Option
Spoiler:
Code:
#
#==============================================================================
# ▼ Introduction
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# This script replaces the "Game End" option in the Main Menu with a "System"
# menu where the player can adjust various settings in the game. Of them, the
# player can change the window colour, the volume for BGM, BGS, SFX, set
# automatic dashing, message text to display instantly, and speed up battles by
# hiding battle animations.
#
#==============================================================================
# ▼ Instructions
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# To install this script, open up your script editor and copy/paste this script
# to an open slot below ▼ Materials/素材 but above ▼ Main. Remember to save.
#
# -----------------------------------------------------------------------------
# Script Calls - These commands are used with script calls.
# -----------------------------------------------------------------------------
# $game_system.volume_change(:bgm, x)
# $game_system.volume_change(:bgs, x)
# $game_system.volume_change(:sfx, x)
# Unlike the previous Yanfly Engines, this version does not bind volume to a
# variable. Use the script call to change the bgm, bgs, or sfx sound rate by
# x increment. Use a negative value to lower the volume.
#
# $game_system.set_autodash(true)
# $game_system.set_autodash(false)
# Turns autodash on (true) or off (false).
#
# $game_system.set_instantmsg(true)
# $game_system.set_instantmsg(false)
# Turns instant messages on (true) or off (false).
#
# $game_system.set_animations(true)
# $game_system.set_animations(false)
# Turns battle animations on (true) or off (false).
#
#==============================================================================
# ▼ Compatibility
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# This script is made strictly for RPG Maker VX Ace. It is highly unlikely that
# it will run with RPG Maker VX without adjusting.
#
#==============================================================================

module YEA
  module SYSTEM
   
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    # - General Setting -
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    # These are the general settings that govern the System settings. This will
    # change the "Game End" vocab, and disable or enable autodash, instant
    # messages, or animations by default.
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    COMMAND_NAME = "Option"      # Command name used to replace Game End.
    DEFAULT_AUTODASH  = false    # Enable automatic dashing by default?
    DEFAULT_INSTANTMSG = false  # Enable instant message text by default?
    DEFAULT_ANIMATIONS = true    # Enable battle animations by default?
   
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    # - Command Settings -
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    # These settings adjust the commands shown in the command list. Add, remove
    # or rearrange the commands as you see fit. Here's a list of which commands
    # do what:
    #
    # -------------------------------------------------------------------------
    # :command        Description
    # -------------------------------------------------------------------------
    # :blank          Inserts an empty blank space.
    #
    # :window_red      Changes the red tone for all windows.
    # :window_grn      Changes the green tone for all windows.
    # :window_blu      Changes the blue tone for all windows.
    #
    # :volume_bgm      Changes the BGM volume used.
    # :volume_bgs      Changes the BGS volume used.
    # :volume_sfx      Changes the SFX volume used.
    #
    # :autodash        Sets the player to automatically dash.
    # :instantmsg      Sets message text to appear instantly.
    # :animations      Enables battle animations or disables them.
    #
    # :to_title        Returns to the title screen.
    # :shutdown        Shuts down the game.
    #
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    COMMANDS =[
      :window_red,  # Changes the red tone for all windows.
      :window_grn,  # Changes the green tone for all windows.
      :window_blu,  # Changes the blue tone for all windows.
      :volume_bgm,  # Changes the BGM volume used.
      :volume_bgs,  # Changes the BGS volume used.
      :volume_sfx,  # Changes the SFX volume used.
      :blank,
      :autodash,    # Sets the player to automatically dash.
      :instantmsg,  # Sets message text to appear instantly.
      :animations,  # Enables battle animations or disables them.
    # :switch_1,    # Custom Switch 1. Adjust settings below.
    # :switch_2,    # Custom Switch 2. Adjust settings below.
    # :variable_1,  # Custom Variable 1. Adjust settings below.
    # :variable_2,  # Custom Variable 2. Adjust settings below.
      :blank,
      :to_title,    # Returns to the title screen.
      :shutdown,    # Shuts down the game.
    ] # Do not remove this.
   
    #--------------------------------------------------------------------------
    # - Custom Switches -
    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # If you want your game to have system options other than just the ones
    # listed above, you can insert custom switches here to produce such an
    # effect. Adjust the settings here as you see fit.
    #--------------------------------------------------------------------------
    CUSTOM_SWITCHES ={
    # -------------------------------------------------------------------------
    # :switch    => [Switch, Name, Off Text, On Text,
    #                Help Window Description
    #              ], # Do not remove this.
    # -------------------------------------------------------------------------
      :switch_1  => [ 1, "Custom Switch 1", "OFF", "ON",
                    "Help description used for custom switch 1."
                    ],
    # -------------------------------------------------------------------------
      :switch_2  => [ 2, "Custom Switch 2", "OFF", "ON",
                    "Help description used for custom switch 2."
                    ],
    # -------------------------------------------------------------------------
    } # Do not remove this.
   
    #--------------------------------------------------------------------------
    # - Custom Variables -
    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # If you want your game to have system options other than just the ones
    # listed above, you can insert custom variables here to produce such an
    # effect. Adjust the settings here as you see fit.
    #--------------------------------------------------------------------------
    CUSTOM_VARIABLES ={
    # -------------------------------------------------------------------------
    # :variable  => [Switch, Name, Colour1, Colour2, Min, Max,
    #                Help Window Description
    #                ], # Do not remove this.
    # -------------------------------------------------------------------------
      :variable_1 => [ 1, "Custom Variable 1", 9, 1, -100, 100,
                      "Help description used for custom variable 1."
                    ],
    # -------------------------------------------------------------------------
      :variable_2 => [ 2, "Custom Variable 2", 10, 2, -10, 10,
                      "Help description used for custom variable 2."
                    ],
    # -------------------------------------------------------------------------
    } # Do not remove this.
   
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    # - Vocab Settings -
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    # This hash adjusts the vocab used for both the commands and the help
    # description that appears above the command window. Note that for the
    # command help descriptions, you may use text codes. Use \n to linebreak.
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    COMMAND_VOCAB ={
    # -------------------------------------------------------------------------
    # :command    => [Command Name, Option1, Option2
    #                Help Window Description,
    #                ], # Do not remove this.
    # -------------------------------------------------------------------------
      :blank      => ["", "None", "None",
                      ""
                    ], # Do not remove this.
    # -------------------------------------------------------------------------
      :window_red => ["Fenêtre rouge", "None", "None",
                      "Change la couleur rouge de la fenêtre.\n" +
                      "Appuie sur SHIFT pour changer plus rapidement."
                    ], # Do not remove this.
    # -------------------------------------------------------------------------
      :window_grn => ["Fenêtre vert", "None", "None",
                      "Change la couleur vert de la fenêtre.\n" +
                      "appuie sur SHIFT pour changer plus rapidement."
                    ], # Do not remove this.
    # -------------------------------------------------------------------------
      :window_blu => ["Fenêtre Bleu", "None", "None",
                      "Change la couleur bleu pour la fenêtre.\n" +
                      "appuie sur SHIFT pour changer plus rapidement."
                    ], # Do not remove this.
    # -------------------------------------------------------------------------
      :volume_bgm => ["BGM Volume", 12, 4, # Options 1 & 2 are Gauge Colours.
                      "Change le volume utiliser pour la music.\n" +
                      "appuie sur SHIFT pour changer plus rapidement."
                    ], # Do not remove this.
    # -------------------------------------------------------------------------
      :volume_bgs => ["BGS Volume", 13, 5, # Options 1 & 2 are Gauge Colours.
                      "Change le volume utiliser pour l'ambiance.\n" +
                      "appuie sur SHIFT pour changer plus rapidement."
                    ], # Do not remove this.
    # -------------------------------------------------------------------------
      :volume_sfx => ["SFX Volume", 14, 6, # Options 1 & 2 are Gauge Colours.
                      "Change le volume utiliser pour les effet de son.\n" +
                      "appuie sur SHIFT pour changer plus rapidement."
                    ], # Do not remove this.
    # -------------------------------------------------------------------------
      :autodash  => ["Auto-Course", "Non", "Oui",
                      "Si oui, vous courerez toujours sans appuyer sur SHIFT.."
                    ], # Do not remove this.
    # -------------------------------------------------------------------------
      :instantmsg => ["Affichage texte", "Normal", "Instantané",
                      "Pour avoir les messages en instantanée sans attendre."
                    ], # Do not remove this.
    # -------------------------------------------------------------------------
      :animations => ["Animation de combat", "Masquer", "Afficher",
                      "Si masquer, l'animation n'aura pas lieu pendant
les combats"
                    ], # Do not remove this.
    # -------------------------------------------------------------------------
      :to_title  => ["Retourner à l'écran titre", "None", "None",
                      "Revenir à l'écran titre."
                    ], # Do not remove this.
    # -------------------------------------------------------------------------
      :shutdown  => ["Quitter le jeu", "None", "None",
                      "Quitte le jeu."
                    ], # Do not remove this.
    # -------------------------------------------------------------------------
    } # Do not remove this.
   
  end # SYSTEM
end # YEA

#==============================================================================
# ▼ Editting anything past this point may potentially result in causing
# computer damage, incontinence, explosion of user's head, coma, death, and/or
# halitosis so edit at your own risk.
#==============================================================================

#==============================================================================
# ■ Vocab
#==============================================================================

module Vocab
 
  #--------------------------------------------------------------------------
  # overwrite method: self.game_end
  #--------------------------------------------------------------------------
  def self.game_end
    return YEA::SYSTEM::COMMAND_NAME
  end
 
end # Vocab

#==============================================================================
# ■ RPG::BGM
#==============================================================================

class RPG::BGM < RPG::AudioFile
 
  #--------------------------------------------------------------------------
  # overwrite method: play
  #--------------------------------------------------------------------------
  def play(pos = 0)
    if @name.empty?
      Audio.bgm_stop
      @@last = RPG::BGM.new
    else
      volume = @volume
      volume *= $game_system.volume(:bgm) * 0.01 unless $game_system.nil?
      Audio.bgm_play('Audio/BGM/' + @name, volume, @pitch, pos)
      @@last = self.clone
    end
  end
 
end # RPG::BGM

#==============================================================================
# ■ RPG::ME
#==============================================================================

class RPG::ME < RPG::AudioFile
 
  #--------------------------------------------------------------------------
  # overwrite method: play
  #--------------------------------------------------------------------------
  def play
    if @name.empty?
      Audio.me_stop
    else
      volume = @volume
      volume *= $game_system.volume(:bgm) * 0.01 unless $game_system.nil?
      Audio.me_play('Audio/ME/' + @name, volume, @pitch)
    end
  end
 
end # RPG::ME

#==============================================================================
# ■ RPG::BGS
#==============================================================================

class RPG::BGS < RPG::AudioFile
 
  #--------------------------------------------------------------------------
  # overwrite method: play
  #--------------------------------------------------------------------------
  def play(pos = 0)
    if @name.empty?
      Audio.bgs_stop
      @@last = RPG::BGS.new
    else
      volume = @volume
      volume *= $game_system.volume(:bgs) * 0.01 unless $game_system.nil?
      Audio.bgs_play('Audio/BGS/' + @name, volume, @pitch, pos)
      @@last = self.clone
    end
  end
 
end # RPG::BGS

#==============================================================================
# ■ RPG::SE
#==============================================================================

class RPG::SE < RPG::AudioFile
 
  #--------------------------------------------------------------------------
  # overwrite method: play
  #--------------------------------------------------------------------------
  def play
    unless @name.empty?
      volume = @volume
      volume *= $game_system.volume(:sfx) * 0.01 unless $game_system.nil?
      Audio.se_play('Audio/SE/' + @name, volume, @pitch)
    end
  end
 
end # RPG::SE

#==============================================================================
# ■ Game_System
#==============================================================================

class Game_System
 
  #--------------------------------------------------------------------------
  # alias method: initialize
  #--------------------------------------------------------------------------
  alias game_system_initialize_so initialize
  def initialize
    game_system_initialize_so
    init_volume_control
    init_autodash
    init_instantmsg
    init_animations
  end
 
  #--------------------------------------------------------------------------
  # new method: init_volume_control
  #--------------------------------------------------------------------------
  def init_volume_control
    @volume = {}
    @volume[:bgm] = 100
    @volume[:bgs] = 100
    @volume[:sfx] = 100
  end
 
  #--------------------------------------------------------------------------
  # new method: volume
  #--------------------------------------------------------------------------
  def volume(type)
    init_volume_control if @volume.nil?
    return [[@volume[type], 0].max, 100].min
  end
 
  #--------------------------------------------------------------------------
  # new method: volume_change
  #--------------------------------------------------------------------------
  def volume_change(type, increment)
    init_volume_control if @volume.nil?
    @volume[type] += increment
    @volume[type] = [[@volume[type], 0].max, 100].min
  end
 
  #--------------------------------------------------------------------------
  # new method: init_autodash
  #--------------------------------------------------------------------------
  def init_autodash
    @autodash = YEA::SYSTEM::DEFAULT_AUTODASH
  end
 
  #--------------------------------------------------------------------------
  # new method: autodash?
  #--------------------------------------------------------------------------
  def autodash?
    init_autodash if @autodash.nil?
    return @autodash
  end
 
  #--------------------------------------------------------------------------
  # new method: set_autodash
  #--------------------------------------------------------------------------
  def set_autodash(value)
    @autodash = value
  end
 
  #--------------------------------------------------------------------------
  # new method: init_instantmsg
  #--------------------------------------------------------------------------
  def init_instantmsg
    @instantmsg = YEA::SYSTEM::DEFAULT_INSTANTMSG
  end
 
  #--------------------------------------------------------------------------
  # new method: instantmsg?
  #--------------------------------------------------------------------------
  def instantmsg?
    init_instantmsg if @instantmsg.nil?
    return @instantmsg
  end
 
  #--------------------------------------------------------------------------
  # new method: set_instantmsg
  #--------------------------------------------------------------------------
  def set_instantmsg(value)
    @instantmsg = value
  end
 
  #--------------------------------------------------------------------------
  # new method: init_animations
  #--------------------------------------------------------------------------
  def init_animations
    @animations = YEA::SYSTEM::DEFAULT_ANIMATIONS
  end
 
  #--------------------------------------------------------------------------
  # new method: animations?
  #--------------------------------------------------------------------------
  def animations?
    init_animations if @animations.nil?
    return @animations
  end
 
  #--------------------------------------------------------------------------
  # new method: set_animations
  #--------------------------------------------------------------------------
  def set_animations(value)
    @animations = value
  end
 
end # Game_System

#==============================================================================
# ■ Game_Player
#==============================================================================

class Game_Player < Game_Character
 
  #--------------------------------------------------------------------------
  # alias method: dash?
  #--------------------------------------------------------------------------
  alias game_player_dash_so dash?
  def dash?
    if $game_system.autodash?
      return false if @move_route_forcing
      return false if $game_map.disable_dash?
      return false if vehicle
      return !Input.press?(:A)
    else
      return game_player_dash_so
    end
  end
 
end # Game_Player

#==============================================================================
# ■ Scene_Battle
#==============================================================================

class Scene_Battle < Scene_Base
 
  #--------------------------------------------------------------------------
  # alias method: show_fast?
  #--------------------------------------------------------------------------
  alias scene_battle_show_fast_so show_fast?
  def show_fast?
    return true unless $game_system.animations?
    return scene_battle_show_fast_so
  end
 
  #--------------------------------------------------------------------------
  # alias method: show_normal_animation
  #--------------------------------------------------------------------------
  alias scene_battle_show_normal_animation_so show_normal_animation
  def show_normal_animation(targets, animation_id, mirror = false)
    return unless $game_system.animations?
    scene_battle_show_normal_animation_so(targets, animation_id, mirror)
  end
 
end # Scene_Battle

#==============================================================================
# ■ Window_Message
#==============================================================================

class Window_Message < Window_Base
 
  #--------------------------------------------------------------------------
  # alias method: clear_flags
  #--------------------------------------------------------------------------
  alias window_message_clear_flags_so clear_flags
  def clear_flags
    window_message_clear_flags_so
    @show_fast = true if $game_system.instantmsg?
  end
 
end # Window_Message

#==============================================================================
# ■ Window_SystemOptions
#==============================================================================

class Window_SystemOptions < Window_Command
 
  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(help_window)
    @help_window = help_window
    super(0, @help_window.height)
    refresh
  end
 
  #--------------------------------------------------------------------------
  # window_width
  #--------------------------------------------------------------------------
  def window_width; return Graphics.width; end
 
  #--------------------------------------------------------------------------
  # window_height
  #--------------------------------------------------------------------------
  def window_height; return Graphics.height - @help_window.height; end
 
  #--------------------------------------------------------------------------
  # update_help
  #--------------------------------------------------------------------------
  def update_help
    if current_symbol == :custom_switch || current_symbol == :custom_variable
      text = @help_descriptions[current_ext]
    else
      text = @help_descriptions[current_symbol]
    end
    text = "" if text.nil?
    @help_window.set_text(text)
  end
 
  #--------------------------------------------------------------------------
  # ok_enabled?
  #--------------------------------------------------------------------------
  def ok_enabled?
    return true if [:to_title, :shutdown].include?(current_symbol)
    return false
  end
 
  #--------------------------------------------------------------------------
  # make_command_list
  #--------------------------------------------------------------------------
  def make_command_list
    @help_descriptions = {}
    for command in YEA::SYSTEM::COMMANDS
      case command
      when :blank
        add_command(YEA::SYSTEM::COMMAND_VOCAB[command][0], command)
        @help_descriptions[command] = YEA::SYSTEM::COMMAND_VOCAB[command][3]
      when :window_red, :window_grn, :window_blu
        add_command(YEA::SYSTEM::COMMAND_VOCAB[command][0], command)
        @help_descriptions[command] = YEA::SYSTEM::COMMAND_VOCAB[command][3]
      when :volume_bgm, :volume_bgs, :volume_sfx
        add_command(YEA::SYSTEM::COMMAND_VOCAB[command][0], command)
        @help_descriptions[command] = YEA::SYSTEM::COMMAND_VOCAB[command][3]
      when :autodash, :instantmsg, :animations
        add_command(YEA::SYSTEM::COMMAND_VOCAB[command][0], command)
        @help_descriptions[command] = YEA::SYSTEM::COMMAND_VOCAB[command][3]
      when :to_title, :shutdown
        add_command(YEA::SYSTEM::COMMAND_VOCAB[command][0], command)
        @help_descriptions[command] = YEA::SYSTEM::COMMAND_VOCAB[command][3]
      else
        process_custom_switch(command)
        process_custom_variable(command)
      end
    end
  end
 
  #--------------------------------------------------------------------------
  # process_custom_switch
  #--------------------------------------------------------------------------
  def process_custom_switch(command)
    return unless YEA::SYSTEM::CUSTOM_SWITCHES.include?(command)
    name = YEA::SYSTEM::CUSTOM_SWITCHES[command][1]
    add_command(name, :custom_switch, true, command)
    @help_descriptions[command] = YEA::SYSTEM::CUSTOM_SWITCHES[command][4]
  end
 
  #--------------------------------------------------------------------------
  # process_custom_variable
  #--------------------------------------------------------------------------
  def process_custom_variable(command)
    return unless YEA::SYSTEM::CUSTOM_VARIABLES.include?(command)
    name = YEA::SYSTEM::CUSTOM_VARIABLES[command][1]
    add_command(name, :custom_variable, true, command)
    @help_descriptions[command] = YEA::SYSTEM::CUSTOM_VARIABLES[command][6]
  end
 
  #--------------------------------------------------------------------------
  # draw_item
  #--------------------------------------------------------------------------
  def draw_item(index)
    reset_font_settings
    rect = item_rect(index)
    contents.clear_rect(rect)
    case @list[index][:symbol]
    when :window_red, :window_grn, :window_blu
      draw_window_tone(rect, index, @list[index][:symbol])
    when :volume_bgm, :volume_bgs, :volume_sfx
      draw_volume(rect, index, @list[index][:symbol])
    when :autodash, :instantmsg, :animations
      draw_toggle(rect, index, @list[index][:symbol])
    when :to_title, :shutdown
      draw_text(item_rect_for_text(index), command_name(index), 1)
    when :custom_switch
      draw_custom_switch(rect, index, @list[index][:ext])
    when :custom_variable
      draw_custom_variable(rect, index, @list[index][:ext])
    end
  end
 
  #--------------------------------------------------------------------------
  # draw_window_tone
  #--------------------------------------------------------------------------
  def draw_window_tone(rect, index, symbol)
    name = @list[index][:name]
    draw_text(0, rect.y, contents.width/2, line_height, name, 1)
    #---
    dx = contents.width / 2
    tone = $game_system.window_tone
    case symbol
    when :window_red
      rate = (tone.red + 255.0) / 510.0
      colour1 = Color.new(128, 0, 0)
      colour2 = Color.new(255, 0, 0)
      value = tone.red.to_i
    when :window_grn
      rate = (tone.green + 255.0) / 510.0
      colour1 = Color.new(0, 128, 0)
      colour2 = Color.new(0, 255, 0)
      value = tone.green.to_i
    when :window_blu
      rate = (tone.blue + 255.0) / 510.0
      colour1 = Color.new(0, 0, 128)
      colour2 = Color.new(0, 0, 255)
      value = tone.blue.to_i
    end
    draw_gauge(dx, rect.y, contents.width - dx - 48, rate, colour1, colour2)
    draw_text(dx, rect.y, contents.width - dx - 48, line_height, value, 2)
  end
 
  #--------------------------------------------------------------------------
  # draw_volume
  #--------------------------------------------------------------------------
  def draw_volume(rect, index, symbol)
    name = @list[index][:name]
    draw_text(0, rect.y, contents.width/2, line_height, name, 1)
    #---
    dx = contents.width / 2
    case symbol
    when :volume_bgm
      rate = $game_system.volume(:bgm)
    when :volume_bgs
      rate = $game_system.volume(:bgs)
    when :volume_sfx
      rate = $game_system.volume(:sfx)
    end
    colour1 = text_color(YEA::SYSTEM::COMMAND_VOCAB[symbol][1])
    colour2 = text_color(YEA::SYSTEM::COMMAND_VOCAB[symbol][2])
    value = sprintf("%d%%", rate)
    rate *= 0.01
    draw_gauge(dx, rect.y, contents.width - dx - 48, rate, colour1, colour2)
    draw_text(dx, rect.y, contents.width - dx - 48, line_height, value, 2)
  end
 
  #--------------------------------------------------------------------------
  # draw_toggle
  #--------------------------------------------------------------------------
  def draw_toggle(rect, index, symbol)
    name = @list[index][:name]
    draw_text(0, rect.y, contents.width/2, line_height, name, 1)
    #---
    dx = contents.width / 2
    case symbol
    when :autodash
      enabled = $game_system.autodash?
    when :instantmsg
      enabled = $game_system.instantmsg?
    when :animations
      enabled = $game_system.animations?
    end
    dx = contents.width/2
    change_color(normal_color, !enabled)
    option1 = YEA::SYSTEM::COMMAND_VOCAB[symbol][1]
    draw_text(dx, rect.y, contents.width/4, line_height, option1, 1)
    dx += contents.width/4
    change_color(normal_color, enabled)
    option2 = YEA::SYSTEM::COMMAND_VOCAB[symbol][2]
    draw_text(dx, rect.y, contents.width/4, line_height, option2, 1)
  end
 
  #--------------------------------------------------------------------------
  # cursor_right
  #--------------------------------------------------------------------------
  def draw_custom_switch(rect, index, ext)
    name = @list[index][:name]
    draw_text(0, rect.y, contents.width/2, line_height, name, 1)
    #---
    dx = contents.width / 2
    enabled = $game_switches[YEA::SYSTEM::CUSTOM_SWITCHES[ext][0]]
    dx = contents.width/2
    change_color(normal_color, !enabled)
    option1 = YEA::SYSTEM::CUSTOM_SWITCHES[ext][2]
    draw_text(dx, rect.y, contents.width/4, line_height, option1, 1)
    dx += contents.width/4
    change_color(normal_color, enabled)
    option2 = YEA::SYSTEM::CUSTOM_SWITCHES[ext][3]
    draw_text(dx, rect.y, contents.width/4, line_height, option2, 1)
  end
 
  #--------------------------------------------------------------------------
  # draw_custom_variable
  #--------------------------------------------------------------------------
  def draw_custom_variable(rect, index, ext)
    name = @list[index][:name]
    draw_text(0, rect.y, contents.width/2, line_height, name, 1)
    #---
    dx = contents.width / 2
    value = $game_variables[YEA::SYSTEM::CUSTOM_VARIABLES[ext][0]]
    colour1 = text_color(YEA::SYSTEM::CUSTOM_VARIABLES[ext][2])
    colour2 = text_color(YEA::SYSTEM::CUSTOM_VARIABLES[ext][3])
    minimum = YEA::SYSTEM::CUSTOM_VARIABLES[ext][4]
    maximum = YEA::SYSTEM::CUSTOM_VARIABLES[ext][5]
    rate = (value - minimum).to_f / [(maximum - minimum).to_f, 0.01].max
    dx = contents.width/2
    draw_gauge(dx, rect.y, contents.width - dx - 48, rate, colour1, colour2)
    draw_text(dx, rect.y, contents.width - dx - 48, line_height, value, 2)
  end
 
  #--------------------------------------------------------------------------
  # cursor_right
  #--------------------------------------------------------------------------
  def cursor_right(wrap = false)
    cursor_change(:right)
    super(wrap)
  end
 
  #--------------------------------------------------------------------------
  # cursor_left
  #--------------------------------------------------------------------------
  def cursor_left(wrap = false)
    cursor_change(:left)
    super(wrap)
  end
 
  #--------------------------------------------------------------------------
  # cursor_change
  #--------------------------------------------------------------------------
  def cursor_change(direction)
    case current_symbol
    when :window_red, :window_blu, :window_grn
      change_window_tone(direction)
    when :volume_bgm, :volume_bgs, :volume_sfx
      change_volume(direction)
    when :autodash, :instantmsg, :animations
      change_toggle(direction)
    when :custom_switch
      change_custom_switch(direction)
    when :custom_variable
      change_custom_variables(direction)
    end
  end
 
  #--------------------------------------------------------------------------
  # change_window_tone
  #--------------------------------------------------------------------------
  def change_window_tone(direction)
    Sound.play_cursor
    value = direction == :left ? -1 : 1
    value *= 10 if Input.press?(:A)
    tone = $game_system.window_tone.clone
    case current_symbol
    when :window_red; tone.red += value
    when :window_grn; tone.green += value
    when :window_blu; tone.blue += value
    end
    $game_system.window_tone = tone
    draw_item(index)
  end
 
  #--------------------------------------------------------------------------
  # change_window_tone
  #--------------------------------------------------------------------------
  def change_volume(direction)
    Sound.play_cursor
    value = direction == :left ? -1 : 1
    value *= 10 if Input.press?(:A)
    case current_symbol
    when :volume_bgm
      $game_system.volume_change(:bgm, value)
      RPG::BGM::last.play
    when :volume_bgs
      $game_system.volume_change(:bgs, value)
      RPG::BGS::last.play
    when :volume_sfx
      $game_system.volume_change(:sfx, value)
    end
    draw_item(index)
  end
 
  #--------------------------------------------------------------------------
  # change_toggle
  #--------------------------------------------------------------------------
  def change_toggle(direction)
    value = direction == :left ? false : true
    case current_symbol
    when :autodash
      current_case = $game_system.autodash?
      $game_system.set_autodash(value)
    when :instantmsg
      current_case = $game_system.instantmsg?
      $game_system.set_instantmsg(value)
    when :animations
      current_case = $game_system.animations?
      $game_system.set_animations(value)
    end
    Sound.play_cursor if value != current_case
    draw_item(index)
  end
 
  #--------------------------------------------------------------------------
  # change_custom_switch
  #--------------------------------------------------------------------------
  def change_custom_switch(direction)
    value = direction == :left ? false : true
    ext = current_ext
    current_case = $game_switches[YEA::SYSTEM::CUSTOM_SWITCHES[ext][0]]
    $game_switches[YEA::SYSTEM::CUSTOM_SWITCHES[ext][0]] = value
    Sound.play_cursor if value != current_case
    draw_item(index)
  end
 
  #--------------------------------------------------------------------------
  # change_custom_variables
  #--------------------------------------------------------------------------
  def change_custom_variables(direction)
    Sound.play_cursor
    value = direction == :left ? -1 : 1
    value *= 10 if Input.press?(:A)
    ext = current_ext
    var = YEA::SYSTEM::CUSTOM_VARIABLES[ext][0]
    minimum = YEA::SYSTEM::CUSTOM_VARIABLES[ext][4]
    maximum = YEA::SYSTEM::CUSTOM_VARIABLES[ext][5]
    $game_variables[var] += value
    $game_variables[var] = [[$game_variables[var], minimum].max, maximum].min
    draw_item(index)
  end
 
end # Window_SystemOptions

#==============================================================================
# ■ Scene_Menu
#==============================================================================

class Scene_Menu < Scene_MenuBase
 
  #--------------------------------------------------------------------------
  # overwrite method: command_game_end
  #--------------------------------------------------------------------------
  def command_game_end
    SceneManager.call(Scene_System)
  end
 
end # Scene_Menu

#==============================================================================
# ■ Scene_System
#==============================================================================

class Scene_System < Scene_MenuBase
 
  #--------------------------------------------------------------------------
  # start
  #--------------------------------------------------------------------------
  def start
    super
    create_help_window
    create_command_window
  end
 
  #--------------------------------------------------------------------------
  # create_command_window
  #--------------------------------------------------------------------------
  def create_command_window
    @command_window = Window_SystemOptions.new(@help_window)
    @command_window.set_handler(:cancel, method(:return_scene))
    @command_window.set_handler(:to_title, method(:command_to_title))
    @command_window.set_handler(:shutdown, method(:command_shutdown))
  end
 
  #--------------------------------------------------------------------------
  # command_to_title
  #--------------------------------------------------------------------------
  def command_to_title
    fadeout_all
    SceneManager.goto(Scene_Title)
  end
 
  #--------------------------------------------------------------------------
  # command_shutdown
  #--------------------------------------------------------------------------
  def command_shutdown
    fadeout_all
    SceneManager.exit
  end
 
end # Scene_System

#==============================================================================
#
# ▼ End of File
#
#==================================

Je vais devoir y aller post par post...
avatar
tenta
Staffeux retraité

Nombre de messages : 334
Age : 30
Localisation : Canada (Québec)
Distinction : Anti-Boulets suprême!
Date d'inscription : 03/01/2008

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mar 30 Avr 2013 - 13:12
MOG_Enemy_HP

Spoiler:
Code:
#==============================================================================
# +++ MOG - Enemy HP Meter  (v1.1) +++
#==============================================================================
# By Moghunter
# http://www.atelier-rgss.com/
#==============================================================================
# Apresenta um medidor animado com o HP do inimigo.
#==============================================================================
# Para ocultar o HP do inimigo use a TAG abaixo na caixa de notas.
#
# <Hide HP>
#
#==============================================================================
# Serão necessários as imagens.
#
# Battle_Enemy_HP_Layout.png
# Battle_Enemy_HP_Meter.png
#
#
#==============================================================================

#==============================================================================
# ● Histórico (Version History)
#==============================================================================
# v 1.1 - Corrigido o erro de crash randômico. (relativo a dispose de imagem.)
#==============================================================================

module MOG_ENEMY_HP
  #Posição geral do medidor em relação ao battler.
  POSITION_CORRECTION = [0,0]
  #Posição do medidor de HP.
  HP_METER_POSITION = [2,4]
  #Prioridade do medidor na tela.
  PRIORITY_Z = 101 
end

#==============================================================================
# ■ Game Enemy
#==============================================================================
class Game_Enemy < Game_Battler

  attr_accessor :hp_meter_active             
 
  #--------------------------------------------------------------------------
  # ● Initialize
  #--------------------------------------------------------------------------
  alias mog_enemy_hp_initialize initialize
  def initialize(index, enemy_id)
      mog_enemy_hp_initialize(index, enemy_id)
      hide = enemy.note =~ /<Hide HP>/i ? true : false
      @hp_meter_active = [false,hide]
  end 

end

#==============================================================================
# ■ Game_Battler
#==============================================================================
class Game_Battler < Game_BattlerBase
 
  #--------------------------------------------------------------------------
  # ● Item Apply
  #-------------------------------------------------------------------------- 
  alias mog_enemy_hp_item_apply item_apply
  def item_apply(user, item)
      mog_enemy_hp_item_apply(user, item)
      if self.is_a?(Game_Enemy)
          self.hp_meter_active[0] = true if @result.hp_damage != 0
      end
  end

  #--------------------------------------------------------------------------
  # ● Regenerate HP
  #--------------------------------------------------------------------------
  alias mog_enemy_hp_regenerate_hp regenerate_hp
  def regenerate_hp
      mog_enemy_hp_regenerate_hp
      if self.is_a?(Game_Enemy)
        self.hp_meter_active[0] = true if @result.hp_damage != 0     
      end       
  end
   
end
 

#==============================================================================
# ■ Battle_Hud
#==============================================================================
class Enemy_HP
  include MOG_ENEMY_HP
 
  #--------------------------------------------------------------------------
  # ● Initialize
  #--------------------------------------------------------------------------   
  def initialize(viewport = nil,enemy)
      dispose
      @enemy = enemy
      @fade_time = -1
      create_layout   
      create_hp_meter     
      b_pos = [enemy.screen_x - (@layout.width / 2) + POSITION_CORRECTION[0], enemy.screen_y + POSITION_CORRECTION[1] - (@layout.height / 2)]
      @layout.opacity = 0
      @org_pos1 = [b_pos[0],b_pos[1]]
      @layout.x = @org_pos1[0]
      @layout.y = @org_pos1[1]
      @layout.visible = false
      @hp_meter.opacity = 0
      @hp_meter.visible = false
      @org_pos2 = [b_pos[0] + HP_METER_POSITION[0], b_pos[1] + HP_METER_POSITION[1]]
      @hp_meter.x = @org_pos2[0]
      @hp_meter.y = @org_pos2[1]
      @hp_meter.viewport = viewport
      @hp_meter.z = PRIORITY_Z
      @layout.viewport = viewport
      @layout.z = PRIORITY_Z
      @enemy.hp_meter_active[0] = false
      @hide = @enemy.hp_meter_active[1]
  end
 
  #--------------------------------------------------------------------------
  # ● Create HP Meter
  #--------------------------------------------------------------------------       
  def create_layout
      @layout = Sprite.new
      @layout.bitmap = Cache.system("Battle_Enemy_HP_Layout")
  end
   
  #--------------------------------------------------------------------------
  # ● Create HP Meter
  #--------------------------------------------------------------------------     
  def create_hp_meter
      @meter_image = Cache.system("Battle_Enemy_HP_Meter")
      @meter_cw = @meter_image.width
      @meter_ch = @meter_image.height / 2     
      @hp_meter = Sprite.new
      @hp_meter.bitmap = Bitmap.new(@meter_cw,@meter_ch)
      @hp_width_old = @meter_cw * @enemy.hp / @enemy.mhp
    end 
 
  #--------------------------------------------------------------------------
  # ● Hp Flow Update
  #--------------------------------------------------------------------------
  def update_hp_flow
      return if !@layout.visible   
      hp_width = @meter_cw * @enemy.hp / @enemy.mhp
      @hp_meter.bitmap.clear     
      execute_damage_flow(hp_width)
      hp_src_rect = Rect.new(0, 0,hp_width, @meter_ch)
      @hp_meter.bitmap.blt(0,0, @meter_image, hp_src_rect)
  end
   
  #--------------------------------------------------------------------------
  # ● Execute Damage Flow
  #--------------------------------------------------------------------------
  def execute_damage_flow(hp_width)
      n = (@hp_width_old - hp_width).abs * 3 / 100
      damage_flow = [[n, 2].min,0.5].max
      @hp_width_old -= damage_flow
      if @hp_width_old <= hp_width
        @hp_width_old = hp_width
      end 
      src_rect_old = Rect.new(0,@meter_ch,@hp_width_old, @meter_ch)
      @hp_meter.bitmap.blt(0,0, @meter_image, src_rect_old)     
  end   
 
  #--------------------------------------------------------------------------
  # ● Dispose
  #--------------------------------------------------------------------------     
  def dispose
      return if @meter_image == nil
      @layout.bitmap.dispose
      @layout.dispose
      @hp_meter.bitmap.dispose
      @hp_meter.dispose
      @meter_image.dispose
      @meter_image = nil
  end
 
  #--------------------------------------------------------------------------
  # ● Update
  #--------------------------------------------------------------------------     
  def update
      return if @meter_image == nil
      return if @hide
      update_fade   
      update_visible
      update_hp_flow
      refresh if @enemy.hp_meter_active[0]
  end 
 
  #--------------------------------------------------------------------------
  # ● Update Fade
  #--------------------------------------------------------------------------       
  def update_fade
      @fade_time -= 1 if @fade_time > 0
      return if @fade_time != 0
      @layout.opacity -= 10
      @hp_meter.opacity -= 10
      @layout.x += 1
      @hp_meter.x += 1
      @fade_time = -1 if @layout.opacity == 0
  end 
 
  #--------------------------------------------------------------------------
  # ● Update Visible
  #--------------------------------------------------------------------------       
  def update_visible
      return if !@layout.visible
      vis = can_visible?
      @layout.visible = vis
      @hp_meter.visible = vis
  end
 
  #--------------------------------------------------------------------------
  # ● Refresh
  #--------------------------------------------------------------------------         
  def refresh   
      @enemy.hp_meter_active[0] = false
      @layout.opacity = 255
      @hp_meter.opacity = 255   
      @layout.visible = true
      @hp_meter.visible = true
      @fade_time = 60
      @layout.x = @org_pos1[0]
      @layout.y = @org_pos1[1]
      @hp_meter.x = @org_pos2[0]
      @hp_meter.y = @org_pos2[1]     
      hp_width = @meter_cw * @enemy.hp / @enemy.mhp
      @hp_width_old = hp_width if @hp_width_old < hp_width
      update_hp_flow
  end
 
  #--------------------------------------------------------------------------
  # ● Can Visible?
  #--------------------------------------------------------------------------         
  def can_visible?
      return false if @layout.opacity == 0     
      return true
  end
   
end

#==============================================================================
# ■ Spriteset Battle
#==============================================================================
class Spriteset_Battle
 
  #--------------------------------------------------------------------------
  # ● Initialize
  #-------------------------------------------------------------------------- 
  alias mog_enemy_hp_initialize initialize
  def initialize
      mog_enemy_hp_initialize
      create_enemy_hp     
  end
 
  #--------------------------------------------------------------------------
  # ● Create Battle Hud
  #--------------------------------------------------------------------------   
  def create_enemy_hp
      dispose_enemy_hp
      @enemy_hp = []     
      for i in $game_troop.members
          @enemy_hp.push(Enemy_HP.new(@viewport1,i))
      end
  end
 
  #--------------------------------------------------------------------------
  # ● Dispose
  #--------------------------------------------------------------------------     
  alias mog_enemy_hp_dispose dispose
  def dispose
      mog_enemy_hp_dispose
      dispose_enemy_hp
  end 
 
  #--------------------------------------------------------------------------
  # ● Dispose Enemy HP
  #--------------------------------------------------------------------------       
  def dispose_enemy_hp
      return if @enemy_hp == nil
      @enemy_hp.each {|sprite| sprite.dispose }
      @enemy_hp.clear
      @enemy_hp = nil
  end
 
  #--------------------------------------------------------------------------
  # ● Update
  #--------------------------------------------------------------------------       
  alias mog_enemy_hp_update update
  def update
      mog_enemy_hp_update
      update_enemy_hp
  end
 
  #--------------------------------------------------------------------------
  # ● Update Enemy HP
  #--------------------------------------------------------------------------         
  def update_enemy_hp
      return if @enemy_hp == nil
      @enemy_hp.each {|sprite| sprite.update }
  end 
end

$mog_rgss3_enemy_hp_meter = true
avatar
tenta
Staffeux retraité

Nombre de messages : 334
Age : 30
Localisation : Canada (Québec)
Distinction : Anti-Boulets suprême!
Date d'inscription : 03/01/2008

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mar 30 Avr 2013 - 13:13
MOG_AT_System

Spoiler:
Code:
#==============================================================================
# +++ MOG - AT System  (v0.4 Beta) +++
#==============================================================================
# By Moghunter
# http://www.atelier-rgss.com/
#==============================================================================
# Sistema de batalha de turnos em tempo real.
#==============================================================================

#==============================================================================
# ● Histórico (Version History)
#==============================================================================
# v 0.4 - Corrigido o erro de crash randômico. (relativo a dispose de imagem.)
#      - Corrigido o erro de crash randômico. (relativo ao turno.)
#      - Corrigido o bug de travar a tela na execução da mensagem de batalha.
# v 0.3 - Corrigido o Bug da janela de comando ao apertar a tecla Cancel.
#      - Corrigido o Bug de não apresentar a janela de status no começo.
#      - Melhor codificação para aumentar a compatibilidade.
#      - Opção de definir a posição do medidor de AT pelo X&Y do battler.
# v 0.2 - Corrigido o bug da seleção do alvo para ações de cast time.
# v 0.1 - Primeiro lançamento.
#==============================================================================

#==============================================================================
# ● Imagens Necessárias
#==============================================================================
# Serão necessários as imagens:
#
# Battle_AT_Layout.png
# Battle_AT_Meter.png
#
# Na pasta GRAPHICS/SYSTEM/
#
#==============================================================================
# ● AT SYSTEM
#==============================================================================
# A velocidade de AT é baseaddo na agilidade do Battler.
# Em caso de batalhas preventivas (Preemptive) os aliados começarão com AT em
# 80% e os inimigos começarão com AT em 0 (Zero)
# Em batalhas surpresas (Surprise) é o inverso das batalhas preventivas.
# Em batalhas normais todos os battlers começarão com AT em 40%.
#==============================================================================
# ● CAST TIME
#==============================================================================
# Para definir uma habilidade ou item com a função de Cast Time basta definir
# o valor da velocidade (Speed) diferente de 0 (Zero).
#
# NOTA - Não é possível ativar 2 ou mais habilidades com a função Cast Time no
# mesmo turno. (Caso você esteja usando características de Multi Action em
# seu projeto.)
#==============================================================================
module MOG_AT_SYSTEM
  # Tipo de posicionamento da Hud.
  # 0 - Posição fixa.
  # 1 - Posição baseado no valor X e Y do battler.
  HUD_POSITION_TYPE = 0
  #Posição geral (Inicial) da Hud.
  HUD_POSITION = [25,400]
  #Posição do medidor de AT
  AT_METER_POSITION = [29,1]
  #Definição da posição do espaço da HUD entre os membros do grupo.
  #
  #MEMBERS_SPACE = [Horizontal ,Vertical]
  #
  MEMBERS_SPACE = [136,0]
  #Velocidade de animação do medidor de at, defina 0 se não quiser a animação.
  AT_METER_FLOW_SPEED = 3
  #Prioridade da Hud.
  BATTLE_HUD_Z = 0
  #Som quando o sistema AT estiver no maximo
  SE_ACTIVE = "Decision2"
  #Definição do valor de AT para ativar a ação.(Gauge Meter).
  AT_GAUGE_METER = 5000
  # Definição do tipo de duração (Contagem/formula) de um turno.
  # Essa definição influência na ativação dos eventos de batalha.
  # (BATTLE EVENTS)
  #
  # 0 - Duração de um turno é um valor fixo.
  # 1 - Duração de um turno é multiplicado pela quantidade de batllers.
  # 2 - Duração de um turno é baseado na média de agilidade dos battlers.
  #
  TURN_DURATION_TYPE = 1
  # Definição de valor usado para calcular a duração de um turno.
  TURN_DURATION = 60
  # Definição da animação quando o battler usa habilidades de carregamento.
  CAST_ANIMATION = 49
  # Ativar a janela de LOG, deixe desativado se desejar uma batalha mais
  # dinâmica.
  WAIT_LOG_WINDOW = false
  # Ativar a mensagem inicial com os nomes dos inimigos.
  MESSAGE_ENEMY_APPEAR = false
  # Definição da posição da janela de mensagem.
  # 0 - Superior
  # 1 - Centro
  # 2 - Inferior 
  MESSAGE_POSITION = 0
end

#==============================================================================
# ■ Game_System
#==============================================================================
class Game_System
 
  attr_accessor :at_max
 
  #--------------------------------------------------------------------------
  # ● Initialize
  #--------------------------------------------------------------------------       
  alias mog_at_system_initialize initialize
  def initialize
      @at_max = [[MOG_AT_SYSTEM::AT_GAUGE_METER, 999999].min, 100].max
      mog_at_system_initialize
  end
 
end

#==============================================================================
# ■ BattleManager
#==============================================================================
module BattleManager
 
  #--------------------------------------------------------------------------
  # ● Battle Start
  #-------------------------------------------------------------------------- 
  def self.battle_start
      $game_system.battle_count += 1
      $game_party.on_battle_start
      $game_troop.on_battle_start
      if MOG_AT_SYSTEM::MESSAGE_ENEMY_APPEAR
        $game_troop.enemy_names.each do |name|
        $game_message.add(sprintf(Vocab::Emerge, name))
        end
      end
      if @preemptive
        $game_message.add(sprintf(Vocab::Preemptive, $game_party.name))
      elsif @surprise
        $game_message.add(sprintf(Vocab::Surprise, $game_party.name))
      end
      wait_for_message
  end
 
  #--------------------------------------------------------------------------
  # ● Input Start
  #--------------------------------------------------------------------------
  def self.input_start_at(battler)
      if @phase != :input
        @phase = :input
        battler.make_actions
        clear_actor
      end
      return !@surprise && battler.inputable?
  end
 
  #--------------------------------------------------------------------------
  # ● Turn Start
  #--------------------------------------------------------------------------
  def self.turn_start
      @phase = :turn
      clear_actor
      make_action_orders
  end 
 
  #--------------------------------------------------------------------------
  # ● Preemtive Attack
  #-------------------------------------------------------------------------- 
  def self.preemptive_attack
      @preemptive
  end 
 
  #--------------------------------------------------------------------------
  # ● Suprise Attack
  #--------------------------------------------------------------------------   
  def self.surprise_attack
      @surprise
  end   
 
end 

#==============================================================================
# ■ Game Action
#==============================================================================
class Game_Action 
 
  #--------------------------------------------------------------------------
  # ● Prepare
  #--------------------------------------------------------------------------           
  alias mog_at_system_prepare prepare
  def prepare
      mog_at_system_prepare
      set_cast_action
  end
 
  #--------------------------------------------------------------------------
  # ● Set Cast Action
  #--------------------------------------------------------------------------             
  def set_cast_action
      return if forcing
      if @item.object != nil and @item.object.speed != 0 and @subject.at_cast.empty?
        @subject.at_cast = [@item.object,@item.object.speed.abs,@target_index]
        @item.object = nil
        @subject.animation_id = MOG_AT_SYSTEM::CAST_ANIMATION
        @subject.at = 0
        BattleManager.turn_end if @subject.auto_battle?
      elsif !@subject.at_cast.empty?
        if @subject.at_cast[1] == 0
            @item.object = @subject.at_cast[0]
            @target_index = @subject.at_cast[2]           
            @subject.at_cast.clear
        else 
            @item.object = nil
        end
      end 
  end 
 
end


#==============================================================================
# ■ Game Battler Base
#==============================================================================
class Game_BattlerBase 

  #--------------------------------------------------------------------------
  # ● Inputable?
  #--------------------------------------------------------------------------           
  def inputable?
      normal? && !auto_battle? && self.at == $game_system.at_max
  end
 
end

#==============================================================================
# ■ Game_Battler
#==============================================================================
class Game_Battler < Game_BattlerBase
 
  attr_accessor :at
  attr_accessor :at_cast
 
  #--------------------------------------------------------------------------
  # ● Initialize
  #--------------------------------------------------------------------------     
  alias mog_at_system_initialize initialize
  def initialize
      mog_at_system_initialize
      @at = 0
      @at_cast = []
      @at_cast_selectable = true
  end
   
  #--------------------------------------------------------------------------
  # ● At
  #--------------------------------------------------------------------------         
  def at
      n = at_active? ? $game_system.at_max : 0
      return [[@at, n].min, 0].max
  end 
 
  #--------------------------------------------------------------------------
  # ● At Active
  #--------------------------------------------------------------------------           
  def at_active?
      return false if restriction >= 4
      return false if self.hp == 0
      return true
  end 
 
  #--------------------------------------------------------------------------
  # ● Added New State
  #-------------------------------------------------------------------------- 
  alias mog_at_system_add_new_state add_new_state
  def add_new_state(state_id)
      mog_at_system_add_new_state(state_id)
      if restriction == 0 or restriction == 4
        self.at_cast.clear
        self.at = 0
      end 
  end 
 
  #--------------------------------------------------------------------------
  # ● Make Damage Value
  #--------------------------------------------------------------------------
  alias mog_animation_plus_make_damage_value make_damage_value
  def make_damage_value(user, item)
      mog_animation_plus_make_damage_value(user, item)
      self.animation_id = $1.to_i if item.note =~ /<Hit Animation = (\d+)>/i
  end
 
end

#==============================================================================
# ■ Game Enemy
#==============================================================================
class Game_Enemy < Game_Battler
 
  #--------------------------------------------------------------------------
  # ● Tranform
  #-------------------------------------------------------------------------- 
  alias mog_at_system_transform transform
  def transform(enemy_id)
      mog_at_system_transform(enemy_id)
      self.at = 0
      self.at_cast.clear
  end
end 
 
if !MOG_AT_SYSTEM::WAIT_LOG_WINDOW
#==============================================================================
# ■ BattleManager
#==============================================================================
class Window_BattleLog < Window_Selectable

  #--------------------------------------------------------------------------
  # ● Refresh
  #--------------------------------------------------------------------------   
  def refresh
  end 

  #--------------------------------------------------------------------------
  # ● Message Speed
  #--------------------------------------------------------------------------   
  def message_speed
      return 5
  end

end
end

#==============================================================================
# ■ Scene Battle
#==============================================================================
class Scene_Battle < Scene_Base
  include MOG_AT_SYSTEM
 
  #--------------------------------------------------------------------------
  # ● AT Wait
  #--------------------------------------------------------------------------       
  alias mog_at_system_start start
  def start
      reset_at_parameter 
      mog_at_system_start
  end 
   
  #--------------------------------------------------------------------------
  # ● Battle Start
  #--------------------------------------------------------------------------
  def battle_start
      BattleManager.battle_start
      process_event
      set_turn_duration
  end
   
  #--------------------------------------------------------------------------
  # ● Reset AT Parameter
  #-------------------------------------------------------------------------- 
  def reset_at_parameter
      return if @at_phase != nil
      @at_phase = 0
      n_at = $game_system.at_max * 40 / 100
      p_at = $game_system.at_max * 90 / 100
      s_at = 0
      all_battle_members.each do |battler|
          if BattleManager.preemptive_attack
            battler.at = p_at if battler.is_a?(Game_Actor)
            battler.at = s_at if battler.is_a?(Game_Enemy)
          elsif BattleManager.surprise_attack 
            battler.at = p_at if battler.is_a?(Game_Enemy)
            battler.at = s_at if battler.is_a?(Game_Actor)
          else 
            battler.at = n_at
          end
          if battler.at >= $game_system.at_max
            battler.at = $game_system.at_max - 1
          end
          battler.at = 0 if battler.at < 0 
          battler.at_cast.clear
        end
  end

  #--------------------------------------------------------------------------
  # ● Set Turn Duration
  #--------------------------------------------------------------------------
  def set_turn_duration
      max_battlers = all_battle_members.size > 0 ? all_battle_members.size : 1
      case TURN_DURATION_TYPE
        when 1
          n  = TURN_DURATION * max_battlers
        when 2
          turn_sp = 0
          all_battle_members.each do |battler|
              turn_sp += battler.agi
          end 
          n = TURN_DURATION + (turn_sp / max_battlers)
        else
          n = TURN_DURATION
      end
      turn_time_max = [[n, 9999].min, 120].max
      @turn_duration = [0, turn_time_max]
      if @status_window != nil
        @status_window.open
      end 
  end 
 
  #--------------------------------------------------------------------------
  # ● Turn End
  #--------------------------------------------------------------------------
  def turn_end
      @at_phase = 0
      all_battle_members.each do |battler|
        if battler.at >= $game_system.at_max
            battler.at = 0
            battler.on_turn_end
            refresh_status
            @log_window.display_auto_affected_status(battler)
            @log_window.wait_and_clear
        end
      end
      BattleManager.turn_end
  end
   
  #--------------------------------------------------------------------------
  # ● Update Turn Duration
  #--------------------------------------------------------------------------           
  def update_turn_duration
      return if @turn_duration == nil or @turn_duration[0] == nil
      @turn_duration[0] += 1
      if @turn_duration[0] >= @turn_duration[1]
        @turn_duration[0] = 0
        $game_troop.increase_turn
        process_event
      end 
  end
 
  #--------------------------------------------------------------------------
  # ● Update AT System
  #--------------------------------------------------------------------------         
  def update_at_system
      reset_at_parameter if @at_phase == nil
      set_turn_duration if @turn_duration == nil
      return if !can_update_at?
      update_turn_duration
      all_battle_members.each do |battler|
          if !battler.at_cast.empty?
            battler.at_cast[1] -= 1
            if battler.at_cast[1] <= 0
                execute_at_cast(battler)
                break
            end
          else
            battler.at += battler.agi
          end   
          if battler.at >= $game_system.at_max
            update_at_actor(battler)
            update_at_enemy(battler)
            battler.current_action.prepare if battler.current_action
            if battler.at_cast.empty?
                @at_phase = 1
                turn_start if battler.is_a?(Game_Enemy)
            end           
            break
          end 
      end 
  end
   
  #--------------------------------------------------------------------------
  # ● Execute AT CAST
  #--------------------------------------------------------------------------           
  def execute_at_cast(battler)
      @subject = battler
      battler.make_actions 
      turn_start
  end 
 
  #--------------------------------------------------------------------------
  # ● Update AT Actor
  #--------------------------------------------------------------------------           
  def update_at_actor(battler)   
      return if !battler.is_a?(Game_Actor)
      Audio.se_play("Audio/SE/" + SE_ACTIVE,100,100) 
      start_party_command_selection_at(battler)
  end
 
  #--------------------------------------------------------------------------
  # ● Update AT Enemy
  #--------------------------------------------------------------------------           
  def update_at_enemy(battler)   
      return if !battler.is_a?(Game_Enemy)
      battler.make_actions
  end   
 
  #--------------------------------------------------------------------------
  # ● Can Update AT
  #--------------------------------------------------------------------------           
  def can_update_at?
      return false if @at_phase != 0
      return false if $game_message.visible
      return false if BattleManager.in_turn?
      return true
  end   
 
  #--------------------------------------------------------------------------
  # ● Star Party Command Selection at
  #--------------------------------------------------------------------------
  def start_party_command_selection_at(battler)
      unless scene_changing?
        refresh_status
        @status_window.unselect
        @status_window.open
        if BattleManager.input_start_at(battler)
            @actor_command_window.close
            next_command
        else
          turn_start
        end
      end
  end 
 
  #--------------------------------------------------------------------------
  # ● Update Basic
  #--------------------------------------------------------------------------       
  alias mog_at_system_update_basic update_basic
  def update_basic
      mog_at_system_update_basic
      update_at_system
      update_party_command
      $game_message.position = MESSAGE_POSITION
  end
 
  #--------------------------------------------------------------------------
  # ● Update Party Command
  #--------------------------------------------------------------------------     
  def update_party_command
      return if !@party_command_window.active
      return if !@actor_command_window.visible
      return if $game_message.visible
      if Input.trigger?(:B)
        next_command
        Sound.play_cancel
        @party_command_window.active = false
      end 
  end
   
end

#==============================================================================
# ■ AT Meter
#==============================================================================
class AT_Meter
 
  include MOG_AT_SYSTEM
 
  #--------------------------------------------------------------------------
  # ● Initialize
  #--------------------------------------------------------------------------   
  def initialize(actor)
      dispose
      @actor = actor
      if HUD_POSITION_TYPE == 1 and @actor.use_sprite?
        @x = HUD_POSITION[0] +  @actor.screen_x rescue 0
        @y = HUD_POSITION[1] +  @actor.screnn_y rescue 0
      else 
        @x = HUD_POSITION[0] + (MEMBERS_SPACE[0] * @actor.index)
        @y = HUD_POSITION[1] + (MEMBERS_SPACE[1] * @actor.index)       
      end
      pre_cache
      create_layout
      create_at_meter
  end
 
  #--------------------------------------------------------------------------
  # ● Pre Cache
  #--------------------------------------------------------------------------     
  def pre_cache
      @meter = Cache.system("Battle_AT_Meter") 
      @meter_cw = @meter.width / 3
      @meter_ch = @meter.height / 3
  end
 
  #--------------------------------------------------------------------------
  # ● Create Layout
  #--------------------------------------------------------------------------     
  def create_layout
      @layout = Sprite.new
      @layout.bitmap = Cache.system("Battle_AT_Layout")
      @layout.z = BATTLE_HUD_Z
      @layout.x = @x
      @layout.y = @y
  end
 
  #--------------------------------------------------------------------------
  # ● Create AT Meter
  #--------------------------------------------------------------------------     
  def create_at_meter
      @at_meter = Sprite.new
      @at_meter.bitmap = Bitmap.new(@meter_cw,@meter_ch)
      @at_meter.z =  BATTLE_HUD_Z + 50
      @at_meter.x = @x + AT_METER_POSITION[0]
      @at_meter.y = @y + AT_METER_POSITION[1]
      @at_flow = rand(@meter_cw * 2)
      at_flow_update
  end 
 
  #--------------------------------------------------------------------------
  # ● Dispose
  #--------------------------------------------------------------------------   
  def dispose
      return if @layout == nil
      @layout.bitmap.dispose
      @layout.dispose
      @layout = nil
      @at_meter.bitmap.dispose
      @at_meter.dispose
  end 
 
  #--------------------------------------------------------------------------
  # ● Update
  #-------------------------------------------------------------------------- 
  def update
      return if @layout == nil
      at_position
      at_flow_update
  end
 
  #--------------------------------------------------------------------------
  # ● Update
  #--------------------------------------------------------------------------   
  def at_position
      return unless HUD_POSITION_TYPE == 1 and @actor.use_sprite?
      @x = HUD_POSITION[0] +  @actor.screen_x rescue 0
      @y = HUD_POSITION[1] +  @actor.screnn_y rescue 0
      @layout.x = @x
      @layout.y = @y
      @at_meter.x = @x + AT_METER_POSITION[0]
      @at_meter.y = @y + AT_METER_POSITION[1]
  end
   
  #--------------------------------------------------------------------------
  # ● AT Flow Update
  #--------------------------------------------------------------------------
  def at_flow_update
      @at_meter.bitmap.clear
      if !@actor.at_cast.empty?
        max_cast = @actor.at_cast[0].speed.abs != 0 ? @actor.at_cast[0].speed.abs : 1
        at_width = @meter_cw * @actor.at_cast[1] / max_cast
        ch = @meter_ch * 2
      else
        at_width = @meter_cw * @actor.at / $game_system.at_max
        ch = @actor.at < $game_system.at_max ? 0 : @meter_ch
      end 
      src_rect = Rect.new(@at_flow, ch,at_width, @meter_ch)
      @at_meter.bitmap.blt(0,0, @meter, src_rect)
      @at_flow += AT_METER_FLOW_SPEED
      @at_flow = 0 if @at_flow >=  @meter_cw * 2     
  end 
 
end 

#==============================================================================
# ■ Spriteset Battle
#==============================================================================
class Spriteset_Battle
 
  #--------------------------------------------------------------------------
  # ● Initialize
  #--------------------------------------------------------------------------         
  alias mog_at_system_initialize initialize
  def initialize
      mog_at_system_initialize
      create_at_meter
  end 
 
  #--------------------------------------------------------------------------
  # ● Create AT Meter
  #--------------------------------------------------------------------------           
  def create_at_meter
      dispose_at_meter
      @at_meter = []
      for i in $game_party.members
          @at_meter.push(AT_Meter.new(i))
      end     
  end 
 
  #--------------------------------------------------------------------------
  # ● Dispose
  #--------------------------------------------------------------------------     
  alias mog_at_system_dispose dispose
  def dispose
      mog_at_system_dispose
      dispose_at_meter
  end
   
  #--------------------------------------------------------------------------
  # ● Dispose AT Meter
  #--------------------------------------------------------------------------       
  def dispose_at_meter
      return if @at_meter == nil
      @at_meter.each {|sprite| sprite.dispose }
      @at_meter.clear
      @at_meter = nil
  end 
 
  #--------------------------------------------------------------------------
  # ● Update
  #--------------------------------------------------------------------------       
  alias mog_at_system_update update
  def update
      mog_at_system_update
      update_at_meter
  end 
 
  #--------------------------------------------------------------------------
  # ● Update AT Meter
  #--------------------------------------------------------------------------         
  def update_at_meter
      return if @at_meter == nil
      @at_meter.each {|sprite| sprite.update }
  end 
 
end

$mog_rgss3_at_system = true

La raison pourquoi je suis obliger de faire plusieur posts est que je depassais la limite.
avatar
tenta
Staffeux retraité

Nombre de messages : 334
Age : 30
Localisation : Canada (Québec)
Distinction : Anti-Boulets suprême!
Date d'inscription : 03/01/2008

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mar 30 Avr 2013 - 13:17
MOG_Adv_Battle_Hud

Je ne peut pas mettre le script ci-dessus car le script est torp long. :/


Adjust_Limits
Spoiler:
Code:
#==============================================================================
#
# ▼ Yanfly Engine Ace - Adjust Limits v1.00
# -- Last Updated: 2011.12.03
# -- Level: Normal
# -- Requires: n/a
#
#==============================================================================

$imported = {} if $imported.nil?
$imported["YEA-AdjustLimits"] = true

#==============================================================================
# ▼ Updates
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# 2011.12.03 - Finished Script.
# 2011.12.02 - Started Script.
#
#==============================================================================
# ▼ Introduction
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# There exists some limitations in RPG Maker VX Ace that not everybody's fond
# of. With this script, you can easily adjust the limits of each limitation.
# Here's the list of various limits that can be changed:
#
# - Gold Max  - Have more than 99,999,999 gold.
# - Item Max  - Have more than 99 items. Customizable per item, too.
# - Level Max - Exceed 99 levels. Parameters are automatically calculated based
#              on the level 99 and level 98 stats in the class parameters.
# - Stat Max  - Stats can exceed 999. Does not adjust for current formulas.
#
#==============================================================================
# ▼ Instructions
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# To install this script, open up your script editor and copy/paste this script
# to an open slot below ▼ Materials/素材 but above ▼ Main. Remember to save.
#
# -----------------------------------------------------------------------------
# Actor Notetags - These notetags go in the actors notebox in the database.
# -----------------------------------------------------------------------------
# <initial level: x>
# Sets the initial level for the specific actor. Can go above level 99 as long
# as the max level is higher than 99. Default initial level limit is 99.
#
# <max level: x>
# Sets the max level for the specific actor. Can go above level 99 as long as
# the higher limit is defined in the module. Default max level is level 99.
#
# -----------------------------------------------------------------------------
# Class Notetags - These notetags go in the class notebox in the database.
# -----------------------------------------------------------------------------
# <learn at level: x>
# This actually goes inside of the skill learning "notes" box. Replace x with
# the level you wish for the class to learn the skill at. This enables classes
# to learn new skills past level 99.
#
# -----------------------------------------------------------------------------
# Item Notetags - These notetags go in the items notebox in the database.
# -----------------------------------------------------------------------------
# <max limit: x>
# Changes the maximum number of items that can be held from whatever the
# normal amount that can be held. Default amount is 99.
#
# <price: x>
# Changes the price of the item to x. Allows you to go over the price of
# 999,999 gold if your maximum gold exceeds that amount. Default maximum gold
# is 99,999,999 gold.
#
# -----------------------------------------------------------------------------
# Weapon Notetags - These notetags go in the weapons notebox in the database.
# -----------------------------------------------------------------------------
# <max limit: x>
# Changes the maximum number of items that can be held from whatever the
# normal amount that can be held. Default amount is 99.
#
# <price: x>
# Changes the price of the item to x. Allows you to go over the price of
# 999,999 gold if your maximum gold exceeds that amount. Default maximum gold
# is 99,999,999 gold.
#
# <stat: +x>
# <stat: -x>
# Changes the stat bonus of the piece of equipment to yield +x or -x. Allows
# bonus to go over +500 and under -500. Replace stat with one of the following:
# MAXHP, MAXMP, ATK, DEF, MAT, MDF, AGI, LUK
#
# -----------------------------------------------------------------------------
# Armour Notetags - These notetags go in the armours notebox in the database.
# -----------------------------------------------------------------------------
# <max limit: x>
# Changes the maximum number of items that can be held from whatever the
# normal amount that can be held. Default amount is 99.
#
# <price: x>
# Changes the price of the item to x. Allows you to go over the price of
# 999,999 gold if your maximum gold exceeds that amount. Default maximum gold
# is 99,999,999 gold.
#
# <stat: +x>
# <stat: -x>
# Changes the stat bonus of the piece of equipment to yield +x or -x. Allows
# bonus to go over +500 and under -500. Replace stat with one of the following:
# MAXHP, MAXMP, ATK, DEF, MAT, MDF, AGI, LUK
#
# -----------------------------------------------------------------------------
# Enemy Notetags - These notetags go in the enemy notebox in the database.
# -----------------------------------------------------------------------------
# <stat: x>
# Changes the stat of the enemy to x value. Allows going over the database max
# values. Replace stat with one of the following:
# MAXHP, MAXMP, ATK, DEF, MAT, MDF, AGI, LUK, EXP, GOLD
#
# -----------------------------------------------------------------------------
# Script Calls - These commands are used with script calls.
# -----------------------------------------------------------------------------
# gain_gold(x)
# lose_gold(x)
# Causes the player to gain/lose x gold. Allows you to go over 9,999,999 gold.
# Default maximum gold is 99,999,999.
#
# gain_item(x, y)
# lose_item(x, y)
# gain_weapon(x, y)
# lose_weapon(x, y)
# gain_armour(x, y)
# lose_armour(x, y)
# Causes the player to gain/lose x item in y amount. Allows you to go over 99
# quantity. Default quantity is 99.
#
#==============================================================================
# ▼ Compatibility
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# This script is made strictly for RPG Maker VX Ace. It is highly unlikely that
# it will run with RPG Maker VX without adjusting.
#
#==============================================================================

module YEA
  module LIMIT
   
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    # - Gold Settings -
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    # Adjust gold settings here. You can change the maximum amount of gold to
    # whatever you want. In addition to that, you can also adjust whether or
    # not you wish for your gold display to show an icon instead, (and change
    # the font size if needed). If there's too much gold that's to be displayed
    # then you can change the text shown in place of that.
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    GOLD_MAX  = 999999999999999  # Maximum gold.
    GOLD_ICON = 361              # Icon used for gold. Use 0 for text currency.
    GOLD_FONT = 16              # Font size used to display gold.
    TOO_MUCH_GOLD = "A lotta gold!"  # Text used when gold cannot fit.
   
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    # - Item Settings -
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    # Adjust item settings here. You can change the maximum number of items
    # held from 99 to whatever you want. In addition to that, change the prefix
    # used for items when shown in the item display menu (and the font size if
    # needed). Items can have individual maximums through usage of the
    # <max limit: x> notetag.
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    ITEM_MAX  = 10    # The default maximum number of items held each.
    ITEM_FONT = 16      # Font size used to display item quantity.
    SHOP_FONT = 16      # Font size used for shop item costs.
    ITEM_PREFIX = "×%s" # Prefix used for item quantity in item lists.
   
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    # - Parameter Settings -
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    # Adjust the limits for each of the various stats (for MaxHP, MaxMP, ATK,
    # DEF, MAT, and more). Adjust them as you see fit.
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    LEVEL_MAX = 250      # Sets max level to x for those with 99 level limit.
    MAXHP_MAX = 9999999 # Sets MaxHP to something higher than 9999.
    MAXMP_MAX = 9999999 # Sets MaxMP to something higher than 9999.
    PARAM_MAX = 99999  # Sets stat max for something higher than 999.
    EQUIP_FONT = 16    # Changes the default equip window font size.
   
  end # LIMIT
end # YEA

#==============================================================================
# ▼ Editting anything past this point may potentially result in causing
# computer damage, incontinence, explosion of user's head, coma, death, and/or
# halitosis so edit at your own risk.
#==============================================================================

module YEA
  module REGEXP
  module ACTOR
   
    MAX_LEVEL = /<(?:MAX_LEVEL|max level):[ ](\d+)>/i
    INI_LEVEL = /<(?:INITIAL_LEVEL|initial level):[ ](\d+)>/i
   
  end # ACTOR
  module CLASS
   
    LEARN_AT_LV = /<(?:LEARN_AT_LEVEL|learn at level):[ ](\d+)>/i
   
  end # CLASS
  module BASEITEM
   
    PRICE    = /<(?:GOLD|price|COST):[ ](\d+)>/i
    MAX_LIMIT = /<(?:MAX_LIMIT|max limit):[ ](\d+)>/i
    STAT_SET  = /<(.*):[ ]*([\+\-]\d+)>/i
   
  end # BASEITEM
  module ENEMY
   
    STAT_SET  = /<(.*):[ ]*(\d+)>/i
   
  end # ENEMY
  end # REGEXP
end # YEA

#==============================================================================
# ■ Icon
#==============================================================================

module Icon
 
  #--------------------------------------------------------------------------
  # self.gold
  #--------------------------------------------------------------------------
  def self.gold; return YEA::LIMIT::GOLD_ICON; end
   
end # Icon
 
#==============================================================================
# ■ Numeric
#==============================================================================

class Numeric
 
  #--------------------------------------------------------------------------
  # new method: group_digits
  #--------------------------------------------------------------------------
  unless $imported["YEA-CoreEngine"]
  def group; return self.to_s; end
  end # $imported["YEA-CoreEngine"]
   
end # Numeric

#==============================================================================
# ■ DataManager
#==============================================================================

module DataManager
 
  #--------------------------------------------------------------------------
  # alias method: load_database
  #--------------------------------------------------------------------------
  class <<self; alias load_database_al load_database; end
  def self.load_database
    load_database_al
    load_notetags_al
  end
 
  #--------------------------------------------------------------------------
  # new method: load_notetags_al
  #--------------------------------------------------------------------------
  def self.load_notetags_al
    groups = [$data_actors, $data_items, $data_weapons, $data_armors,
      $data_enemies, $data_classes]
    for group in groups
      for obj in group
        next if obj.nil?
        obj.load_notetags_al
      end
    end
  end
 
end # DataManager

#==============================================================================
# ■ RPG::Actor
#==============================================================================

class RPG::Actor < RPG::BaseItem
 
  #--------------------------------------------------------------------------
  # common cache: load_notetags_al
  #--------------------------------------------------------------------------
  def load_notetags_al
    @max_level = YEA::LIMIT::LEVEL_MAX if @max_level == 99
    #---
    self.note.split(/[\r\n]+/).each { |line|
      case line
      #---
      when YEA::REGEXP::ACTOR::MAX_LEVEL
        @max_level = [[$1.to_i, 1].max, YEA::LIMIT::LEVEL_MAX].min
        @ini_level = [@ini_level, @max_level].min
      when YEA::REGEXP::ACTOR::INI_LEVEL
        @ini_level = [[$1.to_i, 1].max, @max_level].min
      #---
      end
    } # self.note.split
    #---
  end
 
end # RPG::Actor

#==============================================================================
# ■ RPG::Class
#==============================================================================

class RPG::Class < RPG::BaseItem
 
  #--------------------------------------------------------------------------
  # new method: above_lv99_params
  #--------------------------------------------------------------------------
  def above_lv99_params(param_id, level)
    return @params[param_id, level] if level <= 99
    n = @params[param_id, 99]
    multiplier = [level - 99, 1].max
    change = (@params[param_id, 99] - @params[param_id, 98]) + 1
    n += change * multiplier
    return n
  end
 
  #--------------------------------------------------------------------------
  # new method: load_notetags_al
  #--------------------------------------------------------------------------
  def load_notetags_al
    for item in @learnings; item.load_notetags_al; end
  end
 
end # RPG::Class

#==============================================================================
# ■ RPG::Class::Learning
#==============================================================================

class RPG::Class::Learning
 
  #--------------------------------------------------------------------------
  # common cache: load_notetags_al
  #--------------------------------------------------------------------------
  def load_notetags_al
    #---
    self.note.split(/[\r\n]+/).each { |line|
      case line
      #---
      when YEA::REGEXP::CLASS::LEARN_AT_LV
        @level = [[$1.to_i, 1].max, YEA::LIMIT::LEVEL_MAX].min
      #---
      end
    } # self.note.split
    #---
  end
 
end # RPG::Class::Learning

#==============================================================================
# ■ RPG::BaseItem
#==============================================================================

class RPG::BaseItem
 
  #--------------------------------------------------------------------------
  # public instance variables
  #--------------------------------------------------------------------------
  attr_accessor :max_limit
 
  #--------------------------------------------------------------------------
  # common cache: load_notetags_al
  #--------------------------------------------------------------------------
  def load_notetags_al
    @max_limit = YEA::LIMIT::ITEM_MAX
    #---
    self.note.split(/[\r\n]+/).each { |line|
      case line
      #---
      when YEA::REGEXP::BASEITEM::PRICE
        @price = [$1.to_i, YEA::LIMIT::GOLD_MAX].min
      when YEA::REGEXP::BASEITEM::MAX_LIMIT
        @max_limit = [$1.to_i, 1].max
      when YEA::REGEXP::BASEITEM::STAT_SET
        case $1.upcase
        when "HP", "MAXHP", "MHP"
          @params[0] = $2.to_i
        when "MP", "MAXMP", "MMP", "SP", "MAXSP", "MSP"
          @params[1] = $2.to_i
        when "ATK"
          @params[2] = $2.to_i
        when "DEF"
          @params[3] = $2.to_i
        when "MAT", "INT", "SPI"
          @params[4] = $2.to_i
        when "MDF", "RES"
          @params[5] = $2.to_i
        when "AGI", "SPD"
          @params[6] = $2.to_i
        when "LUK", "LUCK"
          @params[7] = $2.to_i
        end
      #---
      end
    } # self.note.split
    #---
  end
 
  #--------------------------------------------------------------------------
  # new method: max_limit
  #--------------------------------------------------------------------------
  def max_limit; return @max_limit; end
 
end # RPG::BaseItem

#==============================================================================
# ■ RPG::Enemy
#==============================================================================

class RPG::Enemy < RPG::BaseItem
 
  #--------------------------------------------------------------------------
  # common cache: load_notetags_al
  #--------------------------------------------------------------------------
  def load_notetags_al
    #---
    self.note.split(/[\r\n]+/).each { |line|
      case line
      #---
      when YEA::REGEXP::ENEMY::STAT_SET
        case $1.upcase
        when "HP", "MAXHP", "MHP"
          @params[0] = $2.to_i
        when "MP", "MAXMP", "MMP", "SP", "MAXSP", "MSP"
          @params[1] = $2.to_i
        when "ATK"
          @params[2] = $2.to_i
        when "DEF"
          @params[3] = $2.to_i
        when "MAT", "INT", "SPI"
          @params[4] = $2.to_i
        when "MDF", "RES"
          @params[5] = $2.to_i
        when "AGI", "SPD"
          @params[6] = $2.to_i
        when "LUK", "LUCK"
          @params[7] = $2.to_i
        when "EXP", "XP"
          @exp = $2.to_i
        when "GOLD", "GP"
          @gold = $2.to_i
        end
      #---
      end
    } # self.note.split
    #---
  end
 
end # RPG::Enemy

#==============================================================================
# ■ Game_BattlerBase
#==============================================================================

class Game_BattlerBase
 
  #--------------------------------------------------------------------------
  # overwrite method: param_max
  #--------------------------------------------------------------------------
  def param_max(param_id)
    return YEA::LIMIT::MAXHP_MAX if param_id == 0
    return YEA::LIMIT::MAXMP_MAX if param_id == 1
    return YEA::LIMIT::PARAM_MAX
  end
 
end # Game_BattlerBase

#==============================================================================
# ■ Game_Actor
#==============================================================================

class Game_Actor < Game_Battler
 
  #--------------------------------------------------------------------------
  # overwrite method: param_max
  #--------------------------------------------------------------------------
  def param_max(param_id)
    return super
  end
 
  #--------------------------------------------------------------------------
  # overwrite method: param_base
  #--------------------------------------------------------------------------
  def param_base(param_id)
    return self.class.params[param_id, @level] if @level <= 99
    return self.class.above_lv99_params(param_id, @level)
  end
 
  #--------------------------------------------------------------------------
  # new method: check_levels
  #--------------------------------------------------------------------------
  def check_levels
    last_level = @level
    @level = [[@level, max_level].min, 1].max
    return if @level == last_level
    change_exp(exp_for_level(@level), false)
  end
 
end # Game_Actor

#==============================================================================
# ■ Game_Party
#==============================================================================

class Game_Party < Game_Unit
 
  #--------------------------------------------------------------------------
  # overwrite method: max_gold
  #--------------------------------------------------------------------------
  def max_gold; return YEA::LIMIT::GOLD_MAX; end
 
  #--------------------------------------------------------------------------
  # overwrite method: max_item_number
  #--------------------------------------------------------------------------
  def max_item_number(item); return item.max_limit; end
 
end # Game_Party

#==============================================================================
# ■ Game_Interpreter
#==============================================================================

class Game_Interpreter
 
  #--------------------------------------------------------------------------
  # new method: gain_gold
  #--------------------------------------------------------------------------
  def gain_gold(value); $game_party.gain_gold(value); end
 
  #--------------------------------------------------------------------------
  # new method: lose_gold
  #--------------------------------------------------------------------------
  def lose_gold(value); $game_party.lose_gold(value); end
 
  #--------------------------------------------------------------------------
  # new method: gain_item
  #--------------------------------------------------------------------------
  def gain_item(id, amount)
    return if $data_items[id].nil?
    $game_party.gain_item($data_items[id], amount)
  end
 
  #--------------------------------------------------------------------------
  # new method: lose_item
  #--------------------------------------------------------------------------
  def lose_item(id, amount)
    return if $data_items[id].nil?
    $game_party.lose_item($data_items[id], amount)
  end
 
  #--------------------------------------------------------------------------
  # new method: gain_weapon
  #--------------------------------------------------------------------------
  def gain_weapon(id, amount)
    return if $data_weapons[id].nil?
    $game_party.gain_item($data_weapons[id], amount)
  end
 
  #--------------------------------------------------------------------------
  # new method: lose_weapon
  #--------------------------------------------------------------------------
  def lose_weapon(id, amount)
    return if $data_weapons[id].nil?
    $game_party.lose_item($data_weapons[id], amount)
  end
 
  #--------------------------------------------------------------------------
  # new method: gain_armour
  #--------------------------------------------------------------------------
  def gain_armour(id, amount)
    return if $data_armors[id].nil?
    $game_party.gain_item($data_armors[id], amount)
  end
 
  #--------------------------------------------------------------------------
  # new method: lose_armour
  #--------------------------------------------------------------------------
  def lose_armour(id, amount)
    return if $data_armors[id].nil?
    $game_party.lose_item($data_armors[id], amount)
  end
 
  #--------------------------------------------------------------------------
  # new method: gain_armor
  #--------------------------------------------------------------------------
  def gain_armor(id, amount)
    return if $data_armors[id].nil?
    $game_party.gain_item($data_armors[id], amount)
  end
 
  #--------------------------------------------------------------------------
  # new method: lose_armor
  #--------------------------------------------------------------------------
  def lose_armor(id, amount)
    return if $data_armors[id].nil?
    $game_party.lose_item($data_armors[id], amount)
  end
 
end # Game_Interpreter

#==============================================================================
# ■ Window_Base
#==============================================================================

class Window_Base < Window
 
  #--------------------------------------------------------------------------
  # overwrite method: draw_actor_level
  #--------------------------------------------------------------------------
  def draw_actor_level(actor, dx, dy)
    dw = text_size(Vocab::level_a + YEA::LIMIT::LEVEL_MAX.to_s).width
    change_color(system_color)
    draw_text(dx, dy, dw, line_height, Vocab::level_a)
    change_color(normal_color)
    cx = text_size(Vocab::level_a).width
    draw_text(dx + cx, dy, dw, line_height, actor.level.group, 2)
  end
 
  #--------------------------------------------------------------------------
  # overwrite method: draw_actor_param
  #--------------------------------------------------------------------------
  def draw_actor_param(actor, dx, dy, param_id)
    change_color(system_color)
    draw_text(dx, dy, 120, line_height, Vocab::param(param_id))
    change_color(normal_color)
    draw_text(dx, dy, 156, line_height, actor.param(param_id).group, 2)
  end
 
  #--------------------------------------------------------------------------
  # draw_currency_value
  #--------------------------------------------------------------------------
  def draw_currency_value(value, unit, dx, dy, dw)
    contents.font.size = YEA::LIMIT::GOLD_FONT
    cx = gold_icon?(unit) ? 24 : text_size(unit).width
    change_color(normal_color)
    text = value.group
    text = YEA::LIMIT::TOO_MUCH_GOLD if contents.text_size(text).width > dw-cx
    draw_text(dx, dy, dw - cx - 2, line_height, text, 2)
    change_color(system_color)
    draw_icon(Icon.gold, dx+dw-24, dy) if gold_icon?(unit)
    draw_text(dx, dy, dw, line_height, unit, 2) unless gold_icon?(unit)
    reset_font_settings
  end
 
  #--------------------------------------------------------------------------
  # new method: gold_icon?
  #--------------------------------------------------------------------------
  def gold_icon?(unit)
    return false if unit != Vocab.currency_unit
    return YEA::LIMIT::GOLD_ICON > 0
  end
 
end # Window_Base

#==============================================================================
# ■ Window_ItemList
#==============================================================================

class Window_ItemList < Window_Selectable
 
  #--------------------------------------------------------------------------
  # overwrite method: draw_item_number
  #--------------------------------------------------------------------------
  def draw_item_number(rect, item)
    contents.font.size = YEA::LIMIT::ITEM_FONT
    quantity = $game_party.item_number(item).group
    text = sprintf(YEA::LIMIT::ITEM_PREFIX, quantity)
    draw_text(rect, text, 2)
    reset_font_settings
  end
 
end # Window_ItemList

#==============================================================================
# ■ Window_EquipStatus
#==============================================================================

class Window_EquipStatus < Window_Base
 
  #--------------------------------------------------------------------------
  # overwrite method: draw_item
  #--------------------------------------------------------------------------
  def draw_item(dx, dy, param_id)
    draw_param_name(dx + 4, dy, param_id)
    draw_current_param(dx + 64, dy, param_id) if @actor
    draw_right_arrow(dx + 110, dy)
    draw_new_param(dx + 132, dy, param_id) if @temp_actor
    reset_font_settings
  end
 
  #--------------------------------------------------------------------------
  # overwrite method: draw_param_name
  #--------------------------------------------------------------------------
  def draw_param_name(dx, dy, param_id)
    contents.font.size = YEA::LIMIT::EQUIP_FONT
    change_color(system_color)
    draw_text(dx, dy, contents.width, line_height, Vocab::param(param_id))
  end
 
  #--------------------------------------------------------------------------
  # overwrite method: draw_current_param
  #--------------------------------------------------------------------------
  def draw_current_param(dx, dy, param_id)
    change_color(normal_color)
    draw_text(0, dy, dx+48, line_height, @actor.param(param_id).group, 2)
    reset_font_settings
  end
 
  #--------------------------------------------------------------------------
  # overwrite method: draw_new_param
  #--------------------------------------------------------------------------
  def draw_new_param(dx, dy, param_id)
    contents.font.size = YEA::LIMIT::EQUIP_FONT
    new_value = @temp_actor.param(param_id)
    change_color(param_change_color(new_value - @actor.param(param_id)))
    draw_text(0, dy, contents.width-4, line_height, new_value.group, 2)
    reset_font_settings
  end
 
end # Window_EquipStatus

#==============================================================================
# ■ Window_ShopBuy
#==============================================================================

class Window_ShopBuy < Window_Selectable
 
  #--------------------------------------------------------------------------
  # overwrite method: draw_item
  #--------------------------------------------------------------------------
  def draw_item(index)
    item = @data[index]
    rect = item_rect(index)
    draw_item_name(item, rect.x, rect.y, enable?(item))
    rect.width -= 4
    contents.font.size = YEA::LIMIT::SHOP_FONT
    draw_text(rect, price(item).group, 2)
    reset_font_settings
  end
 
end # Window_ShopBuy

#==============================================================================
# ■ Scene_Load
#==============================================================================

class Scene_Load < Scene_File
 
  #--------------------------------------------------------------------------
  # alias method: on_load_success
  #--------------------------------------------------------------------------
  alias on_load_success_al on_load_success
  def on_load_success
    on_load_success_al
    perform_level_check
  end
 
  #--------------------------------------------------------------------------
  # new method: perform_level_check
  #--------------------------------------------------------------------------
  def perform_level_check
    for i in 1..$data_actors.size
      next if $game_actors[i].nil?
      $game_actors[i].check_levels
    end
  end
 
end # Scene_Load

#==============================================================================
#
# ▼ End of File
#
#==============================================================================
avatar
tenta
Staffeux retraité

Nombre de messages : 334
Age : 30
Localisation : Canada (Québec)
Distinction : Anti-Boulets suprême!
Date d'inscription : 03/01/2008

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mar 30 Avr 2013 - 13:18
MOG_Damage_Popup
Spoiler:
Code:
#==============================================================================
# +++ MOG - DAMAGEPOPUP  (v1.8) +++
#==============================================================================
# By Moghunter
# http://www.atelier-rgss.com/
#==============================================================================
# Apresenta danos dos alvos em imagens.
#==============================================================================
# Será necessário ter a imagem Damage_Number.png na pasta /GRAPHICS/SYSTEM/
#==============================================================================

#==============================================================================
# DAMAGE POPUP ON CHARACTERS (Events)
#==============================================================================
# Basta usar o código abaixo para apresentar o dano nos eventos.
#
# damage_popup(STRING)
#
# STRING = valor do dano (Texto).
#
#
# Para ativar o dano no jogador use o código abaixo
#
# $game_player.damage_popup(STRING)
#
#==============================================================================

#==============================================================================
# ● Histórico (Version History)
#==============================================================================
# v 1.8 - Corrigido o erro de apresentar os textos das condições (Status) quando
#        o battler estiver morto.
# v 1.7 - Melhor codificação e compatibilidade.
# v 1.6 - Corrigido o erro da opacidade do dano em EXP e GOLD.
# v 1.5 - Possibilidade de ativar o dano nos eventos no mapa.
# v 1.4 - Corrigido o erro do efeito drain.
# v 1.3 - Corrigido o erro de crash randômico. (relativo a dispose de imagem.)
# v 1.2 - Corrigido o limite do tamanho da string em palavras longas.
# v 1.1 - Opção de definir a prioridade do dano.
# v 1.0 - Primeiro lançamento.
#==============================================================================

module MOG_DAMAGEPOP
  #Definição do espaço entre a palavra MP/TP e o numero de dano.
  MP_TP_STRING_SPACE = 32
  #Correção da posição do dano.
  DAMAGE_POSITION_CORRECTION = [0 ,0]
  #Apresentar a exp e ouro do inimigo.
  EXP_POPUP = true
  #Definição da prioridade do dano na tela.
  DAMAGE_Z = 60
end

#==============================================================================
# ■ Game_Battler
#==============================================================================
class Game_Battler < Game_BattlerBase
 
  attr_accessor :damage
 
  #--------------------------------------------------------------------------
  # ● Initialize
  #--------------------------------------------------------------------------       
  alias mog_damage_sprite_initialize initialize
  def initialize     
      @damage = []
      mog_damage_sprite_initialize
  end 
   
  #--------------------------------------------------------------------------
  # ● Item Apply
  #-------------------------------------------------------------------------- 
  alias mog_damage_pop_item_apply item_apply
  def item_apply(user, item)
      mog_damage_pop_item_apply(user, item)
      if @result.missed
          self.damage.push(["Missed","Missed"]) if self.hp > 0
      elsif @result.evaded
          self.damage.push(["Evaded","Evaded"]) if self.hp > 0
      end 
  end

  #--------------------------------------------------------------------------
  # ● Regenerate HP
  #--------------------------------------------------------------------------
  alias mog_damage_pop_regenerate_hp regenerate_hp
  def regenerate_hp
      mog_damage_pop_regenerate_hp
      self.damage.push([@result.hp_damage,"HP"]) if @result.hp_damage != 0     
  end

  #--------------------------------------------------------------------------
  # ● Regenerate MP
  #--------------------------------------------------------------------------
  alias mog_damage_pop_regenerate_mp regenerate_mp
  def regenerate_mp
      mog_damage_pop_regenerate_mp
      self.damage.push([@result.mp_damage,"MP"]) if @result.mp_damage != 0
  end
 
  #--------------------------------------------------------------------------
  # ● Regenerate TP
  #--------------------------------------------------------------------------
  alias mog_damage_pop_regenerate_tp regenerate_tp
  def regenerate_tp
      mog_damage_pop_regenerate_tp
      tp_damage = 100 * trg
      self.damage.push([tp_damage,"TP"]) if tp_damage != 0
  end

  #--------------------------------------------------------------------------
  # ● Added New State
  #-------------------------------------------------------------------------- 
  alias mog_damage_pop_add_new_state add_new_state
  def add_new_state(state_id)
      mog_damage_pop_add_new_state(state_id)
      st = $data_states[state_id]
      self.damage.push([st.name.to_s,"States Plus",false,st.icon_index]) if self.hp > 0
  end
 
  #--------------------------------------------------------------------------
  # ● Remove State
  #-------------------------------------------------------------------------- 
  alias mog_damage_pop_remove_state remove_state
  def remove_state(state_id)
      if state?(state_id)
        unless BattleManager.escape? and self.is_a?(Game_Enemy)
            st = $data_states[state_id]
            self.damage.push([st.name.to_s,"States Minus",false,st.icon_index])  if self.hp > 0
        end 
      end
      mog_damage_pop_remove_state(state_id)
  end     
 
  #--------------------------------------------------------------------------
  # ● Update State Turns
  #-------------------------------------------------------------------------- 
  alias mog_damage_popup_update_state_turns update_state_turns
  def update_state_turns
      mog_damage_popup_update_state_turns
      states.each do |state|
        for features in state.features
            if features.data_id == 7 or features.data_id == 8 or
              features.data_id == 9             
              self.damage.push([state.name.to_s + " Effect","States Effect"]) if self.hp > 0
            end 
        end
      end 
  end   
 
  #--------------------------------------------------------------------------
  # ● Execute Damage
  #--------------------------------------------------------------------------   
  alias mog_damage_pop_execute_damage execute_damage
  def execute_damage(user)
      mog_damage_pop_execute_damage(user)
      user.damage.push([-@result.hp_drain,"HP",@result.critical]) if @result.hp_drain != 0
      user.damage.push([-@result.mp_drain,"MP",@result.critical]) if @result.mp_drain != 0
  end 
 
end

#==============================================================================
# ■ BattleManager
#==============================================================================
module BattleManager

  #--------------------------------------------------------------------------
  # ● Escape?
  #--------------------------------------------------------------------------
  def self.escape?
      @phase == nil
  end
 
end 
#==============================================================================
# ■ Game_ActionResult
#==============================================================================
class Game_ActionResult

  #--------------------------------------------------------------------------
  # ● HP Damage Text
  #--------------------------------------------------------------------------
  alias mog_damage_pop_hp_damage_text hp_damage_text
  def hp_damage_text
      if @hp_drain > 0
        @battler.damage.push([@hp_drain,"HP",@critical])
      elsif @hp_damage >= 0
        @battler.damage.push([@hp_damage,"HP",@critical])
      elsif @hp_damage < 0
        @battler.damage.push([@hp_damage,"HP",@critical])
      end   
      mog_damage_pop_hp_damage_text   
  end
 
  #--------------------------------------------------------------------------
  # ● MP Damage Text
  #--------------------------------------------------------------------------
  alias mog_damage_pop_mp_damage_text mp_damage_text
  def mp_damage_text
      if @mp_drain > 0
        @battler.damage.push([@mp_drain,"MP",@critical])
      elsif @mp_damage > 0
        @battler.damage.push([@mp_damage,"MP",@critical])
      elsif @mp_damage < 0 
        @battler.damage.push([@mp_damage,"MP",@critical])
      end   
      mog_damage_pop_mp_damage_text
  end
 
  #--------------------------------------------------------------------------
  # ● TP Damage Text
  #--------------------------------------------------------------------------
  alias mog_damage_pop_tp_damage_text tp_damage_text
  def tp_damage_text
      if @tp_damage > 0
        @battler.damage.push([@tp_damage,"TP",@critical])
      elsif @tp_damage < 0
        @battler.damage.push([@tp_damage,"TP",@critical])
      end   
      mog_damage_pop_tp_damage_text
  end
end

#==============================================================================
# ■ Game Actor
#==============================================================================
class Game_Actor < Game_Battler
 
  #--------------------------------------------------------------------------
  # ● Level UP
  #--------------------------------------------------------------------------       
  alias mog_damage_pop_level_up level_up
  def level_up
      mog_damage_pop_level_up
      @damage.push(["Level UP","Level_UP"])     
  end
end 

#==============================================================================
# ■ Scene_Battle
#==============================================================================
class Scene_Battle < Scene_Base 
 
  #--------------------------------------------------------------------------
  # ● Invoke Counter Attack
  #--------------------------------------------------------------------------       
  alias mog_damage_popup_invoke_counter_attack invoke_counter_attack
  def invoke_counter_attack(target, item)
      mog_damage_popup_invoke_counter_attack(target, item)
      target.damage.push(["Counter","Counter"])
  end 
 
  #--------------------------------------------------------------------------
  # ● Invoke Counter Attack
  #--------------------------------------------------------------------------       
  alias mog_damage_popup_invoke_magic_reflection invoke_magic_reflection
  def invoke_magic_reflection(target, item)
      mog_damage_popup_invoke_magic_reflection(target, item)
      target.damage.push(["Reflection","Reflection"])
  end 
 
end

#==============================================================================
# ■ Damage Sprite
#==============================================================================
class Damage_Sprite < Sprite
  include MOG_DAMAGEPOP
  attr_accessor :duration
 
  #--------------------------------------------------------------------------
  # ● Initialize
  #--------------------------------------------------------------------------     
  def initialize(viewport = nil,x = 0,y = 0,value = 0,index)
      super(viewport)
      dispose
      @image = Cache.system("Damage_Number")     
      @x = x
      @y = y
      @value = value[0]
      @type = value[1]
      @critical = (value[2] and @value.to_i >= 0) ? true : false
      @state_index = value[3]
      @duration = 80 + (10 * index)
      @cw = @image.width / 10
      @ch = @image.height / 7
      @center_x = 0
      @mp_space = (@type == "MP" or @type == "TP") ? MP_TP_STRING_SPACE : 0     
      if @value.is_a?(Numeric)
        create_damage_number
      elsif @value == "Missed" or  @value == "Evaded" 
        create_damage_miss
      else 
        create_damage_string
      end
      self.x =  @x - (@center_x * (@cw / 2)) + DAMAGE_POSITION_CORRECTION[0]
      self.y = @y + DAMAGE_POSITION_CORRECTION[1]
      self.opacity = 1
      zx = self.viewport != nil ? self.viewport.z : 0
      self.z = DAMAGE_Z + zx
      self.visible = false
      damage_dir = rand(2)
      @speed_x = straight_pop? ? 0 : damage_dir == 1 ? -rand(2) : rand(2)
      @speed_y = 0
  end
 
  #--------------------------------------------------------------------------
  # ● Straight Pop
  #--------------------------------------------------------------------------             
  def straight_pop?
      case @type
        when "Gold";        return true
        when "Exp";        return true
        when "Level_UP";    return true
      end
      return false
  end 
 
  #--------------------------------------------------------------------------
  # ● Create Damage Number
  #--------------------------------------------------------------------------           
  def create_damage_miss
      dam = @value == "Missed" ? 5 : 6
      self.bitmap = Bitmap.new(@cw * 5, @ch) 
      src_rect = Rect.new(0, dam * @ch,  @cw * 10, @ch)
      self.bitmap.blt(0, 0, @image, src_rect)
      @center_x += 5
  end
 
  #--------------------------------------------------------------------------
  # ● Create Damage Number
  #--------------------------------------------------------------------------         
  def create_damage_number
      dam = @critical ? @ch * 2 : @value >= 0 ? 0 : @ch
      f = @value >= 0 ? 0 : 1
      number_value = @value.to_s.split(//)
      self.bitmap = Bitmap.new(@mp_space + (@cw * number_value.size),@ch * 4)   
      for r in f...number_value.size       
        number_value_abs = number_value[r].to_i
        src_rect = Rect.new(@cw * number_value_abs, dam, @cw, @ch)
        self.bitmap.blt(@mp_space + (@cw *  r), 0, @image, src_rect)
        @center_x += 1
      end
      if @type == "MP" or @type == "TP"
        ty = @type == "MP" ? 3 : 4
        src_rect = Rect.new(0, @ch * ty, @cw * 10, @ch)
        self.bitmap.blt(0, 0, @image, src_rect)       
        @center_x += 2
      end
      @center_x += 1 if @value < 0
  end 
 
  #--------------------------------------------------------------------------
  # ● Create Damage String
  #--------------------------------------------------------------------------           
  def create_damage_string
      string_size = @value.to_s.split(//)
      @stg_size = string_size.size > 0 ? ((1 + string_size.size) * 24) : 32     
      self.bitmap = Bitmap.new(@stg_size,32)
      self.bitmap.font.size = 28
      self.bitmap.font.bold = true
      if @state_index != nil
        draw_states
      else
        execute_font_color
        damage_string = @value.to_s       
        self.bitmap.draw_text(0, 0, @stg_size, 32, damage_string,0)
      end
  end 
 
  #--------------------------------------------------------------------------
  # ● Execute Font Color
  #--------------------------------------------------------------------------             
  def execute_font_color
      case @type
          when "Gold"
              @duration = 160
              self.bitmap.font.color = Color.new(255,255,100)
          when "Exp"
              @duration = 120
              self.bitmap.font.color = Color.new(0,255,100)
          when "Level_UP"   
              self.bitmap.font.color = Color.new(50,155,255) 
          else 
              self.bitmap.font.color = Color.new(255,255,255)
      end
  end
 
  #--------------------------------------------------------------------------
  # ● Draw States
  #--------------------------------------------------------------------------             
  def draw_states
      icon_image = Cache.system("Iconset")
      if @type == "States Plus"
        self.bitmap.font.color = Color.new(200,150,50)
        damage_string = "+ " + @value.to_s
      elsif @type == "States Minus"
          self.bitmap.font.color = Color.new(100,100,100) 
        damage_string = "- " + @value.to_s
      end       
      rect = Rect.new(@state_index % 16 * 24, @state_index / 16 * 24, 24, 24)
      self.bitmap.blt(0, 0, icon_image, rect) 
      self.bitmap.draw_text(26, 0, @stg_size - 24, 32, damage_string,0)
      @center_x += 5
      icon_image.dispose
      icon_image = nil
  end 
 
  #--------------------------------------------------------------------------
  # ● Dispose
  #--------------------------------------------------------------------------       
  def dispose
      return if @image == nil
      @image.dispose
      @image = nil
      self.bitmap.dispose
      self.bitmap = nil
      @duration = -1
  end 
 
  #--------------------------------------------------------------------------
  # ● Update
  #--------------------------------------------------------------------------       
  def update
      return if self.bitmap == nil   
      @duration -= 1 if @duration > 0
      self.visible = @duration > 80 ? false : true
      case @duration
        when 65..80
            self.opacity += 5
            self.x += @speed_x
            self.y -= 5
            critical_effect(0.05)
        when 50..65 
            self.opacity = 255
            self.y -= 3
            self.x += @speed_x
            critical_effect(0.05)
        when 35..50
            self.opacity = 255
            self.y += 3
            critical_effect(-0.05)
        when 0..35 
            self.opacity -= 7
            self.y -= 1
            critical_effect(-0.05)
      end
      dispose if self.opacity <= 0 
  end
   
  #--------------------------------------------------------------------------
  # ● Critical Effect
  #--------------------------------------------------------------------------         
  def critical_effect(value)
      return if !@critical
      self.zoom_x += value
      self.zoom_y = self.zoom_x     
  end
 
end

#==============================================================================
# ■ Sprite Battle
#==============================================================================
class Sprite_Battler < Sprite_Base
 
  #--------------------------------------------------------------------------
  # ● Initialize
  #--------------------------------------------------------------------------
  alias mog_damagepop_initialize initialize
  def initialize(viewport, battler = nil)
      mog_damagepop_initialize(viewport, battler)
      create_damage_sprite
  end 
   
  #--------------------------------------------------------------------------
  # ● Create Damage Sprite
  #--------------------------------------------------------------------------         
  def create_damage_sprite
      dispose_damage_sprite
      @damage_sprites = []
  end
 
  #--------------------------------------------------------------------------
  # ● Dispose
  #--------------------------------------------------------------------------           
  alias mog_damge_sprite_dispose dispose
  def dispose
      mog_damge_sprite_dispose
      dispose_damage_sprite
  end 
 
  #--------------------------------------------------------------------------
  # ● Dispose Damage Sprite
  #--------------------------------------------------------------------------             
  def dispose_damage_sprite
      return if @damage_sprites == nil
      @damage_sprites.each {|sprite| sprite.dispose }
      @damage_sprites.clear
      @battler.damage.clear if @battler != nil
  end 
 
  #--------------------------------------------------------------------------
  # ● Update
  #--------------------------------------------------------------------------               
  alias mog_damage_sprite_update update
  def update
      mog_damage_sprite_update
      update_damage_sprite
  end
   
  #--------------------------------------------------------------------------
  # ● Create Damage
  #--------------------------------------------------------------------------                   
  def create_damage
      return if !@battler.use_sprite?
      index = 0
      sx = @battler.screen_x != nil ? @battler.screen_x : self.x
      sy = @battler.screen_y != nil ? @battler.screen_y : self.y
      @damage_sprites = [] if @damage_sprites == nil
      for i in @battler.damage
          @damage_sprites.push(Damage_Sprite.new(nil,sx,sy,i,index))
          index += 1
      end
      @battler.damage.clear
  end
 
  #--------------------------------------------------------------------------
  # ● Update Damage Sprite
  #--------------------------------------------------------------------------                 
  def update_damage_sprite
      return if @damage_sprites == nil or @battler == nil
      if @initial_damage == nil
        @initial_damage = true
        @battler.damage.clear
        return
      end     
      create_damage if !@battler.damage.empty?
      if !@damage_sprites.empty?
          clear = 0
          for sprite in @damage_sprites
              sprite.update
              if sprite.duration == 0
                sprite.dispose
              end 
              clear += 1 if sprite.duration > 0
          end
          clear_damage if clear == 0
      end
  end 
 
  #--------------------------------------------------------------------------
  # ● Update Damage Sprite
  #--------------------------------------------------------------------------                   
  def clear_damage
      @damage_sprites.each {|sprite| sprite.dispose }
      @damage_sprites.clear
  end 
 
  #--------------------------------------------------------------------------
  # ● Update Collapse
  #-------------------------------------------------------------------------- 
  alias mog_damage_pop_update_collapse update_collapse
  def update_collapse
      mog_damage_pop_update_collapse
      execute_exp_pop
  end
 
  #--------------------------------------------------------------------------
  # ● Update Instant Collapse
  #-------------------------------------------------------------------------- 
  alias mog_damage_pop_update_instant_collapse update_instant_collapse
  def update_instant_collapse
      mog_damage_pop_update_instant_collapse
      execute_exp_pop
  end   
 
  #--------------------------------------------------------------------------
  # ● Update Boss Collapse
  #-------------------------------------------------------------------------- 
  alias mog_damage_pop_update_boss_collapse update_boss_collapse
  def update_boss_collapse
      mog_damage_pop_update_boss_collapse
      execute_exp_pop
  end
 
  #--------------------------------------------------------------------------
  # ● Execute Exp Pop
  #-------------------------------------------------------------------------- 
  def execute_exp_pop
      return if @dam_exp != nil
      return if !MOG_DAMAGEPOP::EXP_POPUP
      return if @battler.is_a?(Game_Actor)
      @dam_exp = true
      @battler.damage.push(["EXP " + @battler.exp.to_s,"Exp"]) if @battler.exp > 0
      @battler.damage.push([Vocab::currency_unit + " " + @battler.gold.to_s,"Gold"]) if @battler.gold > 0
    end 
 
end


#==============================================================================
# ■ Game Interpreter
#==============================================================================
class Game_Interpreter
 
  #--------------------------------------------------------------------------
  # ● damage Popup
  #--------------------------------------------------------------------------     
  def damage_popup(value,type = nil, critical = false)
      type = (type == nil and value.is_a?(Numeric)) ? "HP" : type
      $game_map.events[@event_id].damage.push([value,type,critical]) if same_map? && @event_id > 0
  end 
 
end 

#==============================================================================
# ■ Game Character
#==============================================================================
class Game_CharacterBase
 
  attr_accessor :damage
 
  #--------------------------------------------------------------------------
  # ● Initialize
  #--------------------------------------------------------------------------   
  alias mog_damage_popup_initialize initialize
  def initialize
      @damage = []
      mog_damage_popup_initialize
  end
 
  #--------------------------------------------------------------------------
  # ● damage Popup
  #--------------------------------------------------------------------------     
  def damage_popup(value,type = nil, critical = false)
      type = (type == nil and value.is_a?(Numeric)) ? "HP" : type
      @damage.push([value,type,critical])
  end
 
end 

#==============================================================================
# ■ Sprite Character
#==============================================================================
class Sprite_Character < Sprite_Base

  #--------------------------------------------------------------------------
  # ● Initialize
  #-------------------------------------------------------------------------- 
  alias mog_damage_popup_initialize initialize
  def initialize(viewport, character = nil)
      mog_damage_popup_initialize(viewport, character)
      create_damage_sprite
  end
 
  #--------------------------------------------------------------------------
  # ● Create Damage Sprite
  #--------------------------------------------------------------------------         
  def create_damage_sprite
      dispose_damage_sprite
      @damage_sprites = []
  end
 
  #--------------------------------------------------------------------------
  # ● Dispose
  #--------------------------------------------------------------------------
  alias mog_damage_popup_dispose dispose
  def dispose
      mog_damage_popup_dispose
      dispose_damage_sprite
  end 
 
  #--------------------------------------------------------------------------
  # ● Dispose Damage Sprite
  #--------------------------------------------------------------------------             
  def dispose_damage_sprite
      return if @damage_sprites == nil
      @damage_sprites.each {|sprite| sprite.dispose }
      @damage_sprites.clear
      @character.damage.clear
      $game_temp.dispose_damage_sprite = false
  end   
 
  #--------------------------------------------------------------------------
  # ● Update
  #-------------------------------------------------------------------------- 
  alias mog_damage_popup_update update
  def update
      mog_damage_popup_update
      update_damage_sprite
  end
 
  #--------------------------------------------------------------------------
  # ● Create Damage
  #--------------------------------------------------------------------------                   
  def create_damage
      index = 0
      sx = self.x
      sy = self.y + @ch
      @damage_sprites = [] if @damage_sprites == nil
      for i in @character.damage
          @damage_sprites.push(Damage_Sprite.new(nil,sx,sy,i,index))
          index += 1
      end
      @character.damage.clear
  end
 
  #--------------------------------------------------------------------------
  # ● Update Damage Sprite
  #--------------------------------------------------------------------------                 
  def update_damage_sprite
      return if @damage_sprites == nil
      if @initial_damage == nil
        @initial_damage = true
        @character.damage.clear
        return
      end     
      create_damage if !@character.damage.empty?
      if !@damage_sprites.empty?
          clear = 0
          for sprite in @damage_sprites
              sprite.update
              if sprite.duration == 0
                sprite.dispose
              end 
              clear += 1 if sprite.duration > 0
          end
          clear_damage if clear == 0
      end
  end   
 
  #--------------------------------------------------------------------------
  # ● Update Damage Sprite
  #--------------------------------------------------------------------------                   
  def clear_damage
      @damage_sprites.each {|sprite| sprite.dispose }
      @damage_sprites.clear
      @character.damage.clear
  end   
 
end

#=============================================================================
# ■ Game_Temp
#=============================================================================
class Game_Temp
 
  attr_accessor :dispose_damage_sprite
 
  #--------------------------------------------------------------------------
  # ● Initialize
  #--------------------------------------------------------------------------         
  alias mog_dispose_damage_initialize initialize
  def initialize
      @dispose_damage_sprite = true
      mog_dispose_damage_initialize
  end
   
end

#=============================================================================
# ■ Scene Manager
#=============================================================================
class << SceneManager
 
  #--------------------------------------------------------------------------
  # ● Call
  #--------------------------------------------------------------------------       
  alias mog_damage_pop_call call
  def call(scene_class)
      $game_temp.dispose_damage_sprite = true
      mog_damage_pop_call(scene_class)
  end
 
end

#=============================================================================
# ■ Scene Map
#=============================================================================
class Scene_Map < Scene_Base

  #--------------------------------------------------------------------------
  # ● Update Scene
  #--------------------------------------------------------------------------         
  alias mog_dispose_damage_sprites_update update_scene
  def update_scene
      @spriteset.dispose_damage_sprites
      mog_dispose_damage_sprites_update
  end

end

#=============================================================================
# ■ Spriteset Map
#=============================================================================
class Spriteset_Map
 
  #--------------------------------------------------------------------------
  # ● Dispose Damage Sprites
  #--------------------------------------------------------------------------           
  def dispose_damage_sprites
      return if !$game_temp.dispose_damage_sprite   
      return if @character_sprites == nil
      @character_sprites.each {|sprite| sprite.dispose_damage_sprite }
      $game_temp.dispose_damage_sprite = false
  end
 
end

#=============================================================================
# ■ Scene Battle
#=============================================================================
class Scene_Battle < Scene_Base
 
  #--------------------------------------------------------------------------
  # ● Update
  #--------------------------------------------------------------------------             
  alias mog_damage_popup_dispose_sprite_update update 
  def update
      @spriteset.dispose_damage_sprites
      mog_damage_popup_dispose_sprite_update
  end 

end

#=============================================================================
# ■ Spriteset Battle
#=============================================================================
class Spriteset_Battle 
 
  #--------------------------------------------------------------------------
  # ● Dispose Damage Sprites
  #--------------------------------------------------------------------------           
  def dispose_damage_sprites
      return if !$game_temp.dispose_damage_sprite   
      battler_sprites.each {|sprite| sprite.dispose_damage_sprite }
      $game_temp.dispose_damage_sprite = false
  end 
 
end

$mog_rgss3_damage_pop = true


J'ai trouvé un moyen pour l'autre script. Le voila.

MOG_Adv_Battle_Hud


Dernière édition par tenta le Mar 30 Avr 2013 - 13:23, édité 1 fois
avatar
Spytje
Administrateur

Nombre de messages : 5899
Localisation : La terre
Distinction : Spiraliste [Korn']
Forestia : Projet du mois juillet 2014
Papy Pulkigrat [Yama']
Date d'inscription : 16/03/2008

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mar 30 Avr 2013 - 13:20
Poste juste leurs noms sinon ils sont facilement trouvable sur le net les scripts Smile
avatar
tenta
Staffeux retraité

Nombre de messages : 334
Age : 30
Localisation : Canada (Québec)
Distinction : Anti-Boulets suprême!
Date d'inscription : 03/01/2008

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mar 30 Avr 2013 - 13:24
Bah trop tard. ^^'

Serieusement je m'excuse pour les posts massive.
avatar
Spytje
Administrateur

Nombre de messages : 5899
Localisation : La terre
Distinction : Spiraliste [Korn']
Forestia : Projet du mois juillet 2014
Papy Pulkigrat [Yama']
Date d'inscription : 16/03/2008

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mar 30 Avr 2013 - 13:28
Pas grave t'étais obligé pour les posts.

J'ai test les scripts que tu m'as donné dans un nouveau projet et ça ne reproduit pas l'erreur.

Si tu veux plus d'aide je dois pouvoir test ton projet directement car la je ne vois pas trop d'ou peut venir le problème.
avatar
tenta
Staffeux retraité

Nombre de messages : 334
Age : 30
Localisation : Canada (Québec)
Distinction : Anti-Boulets suprême!
Date d'inscription : 03/01/2008

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mar 30 Avr 2013 - 21:38
Voila!

http://www.mediafire.com/?0akx2bks0l3mhrf
avatar
Bencoco
Membre

Nombre de messages : 31
Age : 27
Localisation : Alsace
Distinction : aucune
Date d'inscription : 04/03/2012

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mer 1 Mai 2013 - 0:23
Vérifie le script sprite_character si tu as ça :

Code:
def move_animation(dx, dy)
    if @animation && @animation.position != 3
      @ani_ox += dx
      @ani_oy += dy
      @ani_sprites.each do |sprite|
        sprite.x += dx
        sprite.y += dy
      end
    end
  end

sinon ajoute le à la fin du script avant le dernier end

pour plus d'info :

http://www.rpgmakervxace.net/topic/12832-mode-7-error/

c'est en anglais mais c'est exactement ton problème
avatar
Spytje
Administrateur

Nombre de messages : 5899
Localisation : La terre
Distinction : Spiraliste [Korn']
Forestia : Projet du mois juillet 2014
Papy Pulkigrat [Yama']
Date d'inscription : 16/03/2008

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mer 1 Mai 2013 - 0:46
Pas eu le temps de voir mais cella fonctionne avec ce que Bencoco à donné.

Apparemment il y a un soucis avec le script "sprite_character" qui est différent selon la version de RmvxAce.
avatar
tenta
Staffeux retraité

Nombre de messages : 334
Age : 30
Localisation : Canada (Québec)
Distinction : Anti-Boulets suprême!
Date d'inscription : 03/01/2008

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mer 1 Mai 2013 - 4:46
D'ac! je vais aller voir sa dans 20 minutes! je vous mets au courant!
avatar
tenta
Staffeux retraité

Nombre de messages : 334
Age : 30
Localisation : Canada (Québec)
Distinction : Anti-Boulets suprême!
Date d'inscription : 03/01/2008

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mer 1 Mai 2013 - 5:44
Et bien. Le probleme venais vraiment de la commande manquante que tu as mentionné ci-dessus. Merci beaucoup!
avatar
Marioblaz
Membre

Nombre de messages : 66
Age : 21
Localisation : Le château d'Hyrule sous l'océan de la planète de la triforce
Distinction : aucune
Date d'inscription : 03/07/2012

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mer 1 Mai 2013 - 10:12
Bonjours! Dite moi, c'est quoi le mode 7?
avatar
Spytje
Administrateur

Nombre de messages : 5899
Localisation : La terre
Distinction : Spiraliste [Korn']
Forestia : Projet du mois juillet 2014
Papy Pulkigrat [Yama']
Date d'inscription : 16/03/2008

Re: [résolu] Probleme avec script Mode 7 Ace.

le Mer 1 Mai 2013 - 10:37
Ca permet de voir les map inclinées et donne du coup un effet "3d".
avatar
eternien
Membre

Nombre de messages : 49
Localisation : Dans l'espace infinis
Distinction : aucune
Date d'inscription : 14/05/2010

Re: [résolu] Probleme avec script Mode 7 Ace.

le Jeu 2 Mai 2013 - 20:12
Yep, utilisé surtout dans les jeux Super Nes tel que F-Zéro, Mario Kart ou encore FFVI Cool
Contenu sponsorisé

Re: [résolu] Probleme avec script Mode 7 Ace.

Revenir en haut
Permission de ce forum:
Vous ne pouvez pas répondre aux sujets dans ce forum