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

Domaine concerné: Script
Logiciel utilisé: VX Ace
Bonsoir, je nécéssite de l'aide pour un script.
J'utilise le script de Raizen pour donner des niveaux aux éléments, il est précisé dans le script qu'il permet d'augmenter les dégâts infligés par un élément suivant le niveau de ce dernier, j'ai fais un test en mettant à une attaque une variance de 0 histoire qu'elle n'applique pas des dégâts random lorsque je l'utilise.

le problème, c'est qu'elle applique toujours le même nombre de dégâts, quel que soit le niveau de l'élément.
J'ai bien éssayé de joindre raizen mais il m'est impoossible de répondre à son topic pour une raison que j'ignore.

le script :
#=======================================================
#                Lune Element Level
# Author: Raizen
# Compatible with: RMVXAce
# The script allows to be elemental levels, in which the levels
# grow according to the damage done by them.
# You can make the experience and the damage formula right below.
# The levels increase the damage done by that element.
 
#IMPORTANT: It os not simple to configure the script,
# pay attention to make the best way possible.
 
# Remember, it os possible to change elemental affinitty on the
# database for each class of the characters.
 
# To create new elements, go to the last tab in the database.
 
# It is compatible with most default based battle system.
 
# To call the elements window.
# Script Call: SceneManager.call(Scene_Raizen_Elements)
 
 
module Raizen_Elements
# Choose the elements which will gain exp
# and deliver extra damage.
 
Extra_Damage = [2,3,4,5,6,7]
# Show the element colors which will apear on the window.
# Remember it will follow the same order in the above configuration.
# Color orders (r, g, <img src='http://www.rpgmakervxace.net/public/style_emoticons/<#EMO_DIR#>/cool.png' class='bbc_emoticon' alt='B)' /> r = red, g = green, b = blue
# To get the desired color, you can look on a table
# like the one below.
# http://shibolete.tripod.com/RGB.html
 
Damage_Elements = [
Color.new(255, 0, 0),
Color.new(150, 255, 255),
Color.new(255, 255, 30),
Color.new(50, 50, 255),
Color.new(92, 51, 23),
Color.new(20, 230, 100),]
 
# Same thing as above, but this time put the names
# of each element on the same order.
Name_Elements = [
"Feu",
"Glace",
"Foudre",
"Lumière",
"Mécanique",
"Sanguin",]
 
 
 
 
# Works with only magic? In case it is a weapon
# you can configure here from true or false.
Accept_Weapons = false
 
# experience formula.
# Remember that the levels are gained according to the damage
# caused.
 
def self.formula(level)
  level * level * 200 + 100 # modify this line with the experience formula.
end
 
# extra damage formula.
 
def self.damage(level)
  l = level.to_f
  (l / 10) + 1  # modify this line with the damage formula.
end
 
# Quantity of elements on the database.
 
Size = 10
 
# Nomenclature for level on the Menu.
 
Lv = "Lv."
 
# Name that will appear on the menu.
Elements = "Elements"
 
# Name that will indicate the total element level.
LevelTotal = "Niveau total"
 
end
 
#==========================================================================
# ======================Here Starts the Script===============================
#==========================================================================
 
 
#==============================================================================
# ** Scene_Status
#------------------------------------------------------------------------------
#  Esta classe executa o processamento da tela de atributos.
#==============================================================================
 
class Scene_Raizen_Elements < Scene_MenuBase
 
  #--------------------------------------------------------------------------
  # * Inicialização do processo
  #--------------------------------------------------------------------------
  def start
        super
        @status_window = Window_Raizen_Elements.new(@actor)
        @status_window.set_handler(:cancel,   method(:return_scene))
        @status_window.set_handler(:pagedown, method(:next_actor))
        @status_window.set_handler(:pageup,   method(:prev_actor))
 
  end
  #--------------------------------------------------------------------------
  # * Processo da mudança de herói
  #--------------------------------------------------------------------------
  def on_actor_change
        @status_window.actor = @actor
        @status_window.activate
  end
end
 
 
#==============================================================================
# ** Window_Status
#------------------------------------------------------------------------------
#  Esta janela exibe as especificações completas na janela de atributos.
#==============================================================================
 
class Window_Raizen_Elements  < Window_Selectable
include Raizen_Elements
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #      actor : herói
  #--------------------------------------------------------------------------
  def initialize(actor)
        super(0, 0, Graphics.width, Graphics.height)
        @actor = actor
        refresh
        activate
  end
  #--------------------------------------------------------------------------
  # * Definição de herói
  #      actor : herói
  #--------------------------------------------------------------------------
  def actor=(actor)
        return if @actor == actor
        @actor = actor
        refresh
  end
  #--------------------------------------------------------------------------
  # * Renovação
  #--------------------------------------------------------------------------
  def refresh
        contents.clear
        draw_block1   (line_height * 0)
        draw_block2   (line_height * 2)
        draw_block3   (line_height * 7)
        draw_vert_line (250)
        for n in 0...Extra_Damage.size
        draw_bars(n)
        end
  end
  #--------------------------------------------------------------------------
  # * Desenho do bloco 1
  #      y : coordenada Y
  #--------------------------------------------------------------------------
  def draw_bars(n)
  y = n * 360 / Extra_Damage.size + 40
  contents.fill_rect(300, y, 200, 12, bar_color)
  contents.fill_rect(302, y + 2, 196, 8, line_color)
  x = 196
  e = Extra_Damage[n]
  x *= $affinity_exp[@actor.class_id][e] / Raizen_Elements.formula($affinity_levels[@actor.class_id][e])
  contents.fill_rect(302, y + 2, x, 8, Damage_Elements[n])
  draw_text(310, y - 14, 100, 25, Name_Elements[n], 0)
  draw_text(430, y - 14, 100, 25, Lv, 0)
  draw_text(410, y - 14, 80, 25, $affinity_levels[@actor.class_id][e], 2)
  end
  def draw_block1(y)
        draw_actor_name(@actor, 4, y)
        draw_actor_class(@actor, 128, y)
  end
  #--------------------------------------------------------------------------
  # * Desenho do bloco 1
  #      y : coordenada Y
  #--------------------------------------------------------------------------
   def bar_color
        color = Color.new(0,0,0, 150)
        color
  end
  def draw_block2(y)
        draw_actor_face(@actor, 8, y)
        draw_exp_info(0, 330)
  end
  #--------------------------------------------------------------------------
  # * Desenho do bloco 3
  #      y : coordenada Y
  #--------------------------------------------------------------------------
  def draw_block3(y)
        draw_parameters(32, y)
  end
  #--------------------------------------------------------------------------
  # * Desenho de uma linha horzontal
  #--------------------------------------------------------------------------
  def draw_vert_line(x)
        line_x = x
        contents.fill_rect(line_x, 0, 2, contents_height, line_color)
  end
  #--------------------------------------------------------------------------
  # * Aquisção da cor da linha horizontal
  #--------------------------------------------------------------------------
  def line_color
        color = normal_color
        color.alpha = 48
        color
  end
  #--------------------------------------------------------------------------
  # * Desenho das informações básicas
  #      x : coordenada X
  #      y : coordenada Y
  #--------------------------------------------------------------------------
  def draw_basic_info(x, y)
        draw_actor_icons(@actor, x, y + line_height * 1)
        draw_actor_hp(@actor, x, y + line_height * 2)
        draw_actor_mp(@actor, x, y + line_height * 3)
  end
  #--------------------------------------------------------------------------
  # * Desenho dos parâmetros
  #      x : coordenada X
  #      y : coordenada Y
  #--------------------------------------------------------------------------
  def draw_parameters(x, y)
        6.times {|i| draw_actor_param(@actor, x, y + line_height * i, i + 2) }
  end
  #--------------------------------------------------------------------------
  # * Desenho das informações de experiência
  #      x : coordenada X
  #      y : coordenada Y
  #--------------------------------------------------------------------------
  def draw_exp_info(x, y)
        s1 = 0
        for n in 1...Raizen_Elements::Size
        s1 += $affinity_levels[@actor.class_id][n]
        end
        change_color(system_color)
        draw_text(x, y + line_height * 0, 180, line_height, LevelTotal)
        change_color(normal_color)
        draw_text(x, y + line_height * 1, 180, line_height, s1, 2)
  end
 
  #--------------------------------------------------------------------------
  # * Desenho da descrição
  #      x : coordenada X
  #      y : coordenada Y
  #--------------------------------------------------------------------------
  def draw_description(x, y)
        draw_text_ex(x, y, @actor.description)
  end
end
 
class Game_Actor < Game_Battler
alias raizen_element_initialize initialize
  def initialize(actor_id)
        raizen_element_initialize(actor_id)
        if $affinity_start == nil
          $affinity_levels = []
          $affinity_exp = []
          for i in 1...$data_classes.size
                $affinity_levels[i] = Array.new(Raizen_Elements::Size + 1, 0)
                $affinity_exp[i] = Array.new(Raizen_Elements::Size + 1, 0)
          end
        $affinity_start = true
        end
  end
end
module DataManager
  def self.make_save_contents
        contents = {}
        contents[:system]               = $game_system
        contents[:timer]                 = $game_timer
        contents[:message]         = $game_message
        contents[:switches]       = $game_switches
        contents[:variables]     = $game_variables
        contents[:self_switches] = $game_self_switches
        contents[:actors]               = $game_actors
        contents[:party]                 = $game_party
        contents[:troop]                 = $game_troop
        contents[:map]             = $game_map
        contents[:player]               = $game_player
        contents[:affin]                 = $affinity_levels
        contents[:affinl]               = $affinity_exp
        contents
  end
 
  #--------------------------------------------------------------------------
  # * Extrair conteúdo salvo
  #--------------------------------------------------------------------------
  def self.extract_save_contents(contents)
        $game_system            = contents[:system]
        $game_timer              = contents[:timer]
        $game_message      = contents[:message]
        $game_switches    = contents[:switches]
        $game_variables  = contents[:variables]
        $game_self_switches = contents[:self_switches]
        $game_actors            = contents[:actors]
        $game_party              = contents[:party]
        $game_troop              = contents[:troop]
        $game_map                  = contents[:map]
        $game_player            = contents[:player]
        $affinity_levels        = contents[:affin]
        $affinity_exp      = contents[:affinl]
  end
end
 
class Game_Battler < Game_BattlerBase
  def make_damage_value(user, item)
        value = item.damage.eval(user, self, $game_variables)
        value *= item_element_rate(user, item)
        value *= pdr if item.physical?
        value *= mdr if item.magical?
        value *= rec if item.damage.recover?
        value = apply_critical(value) if @result.critical
        value = apply_variance(value, item.damage.variance)
        value = apply_guard(value)
        if @class_id == nil
        value *= item_element_afinity(user.class_id, user.atk_elements.pop, item)
        value.to_i
        call_exp_element(user.class_id, user.atk_elements.pop, value, item)
        end
        @result.make_damage(value.to_i, item)
  end
  def call_exp_element(id, elem, value, item)
        return if item.damage.element_id < 0 and !Raizen_Elements::Accept_Weapons
        elem = item.damage.element_id if item.damage.element_id > 0
        return unless Raizen_Elements::Extra_Damage.include?(elem)
        $affinity_exp[id][elem] += value
        if $affinity_exp[id][elem] >= Raizen_Elements.formula($affinity_levels[id][elem])
        $affinity_exp[id][elem] = 0
        $affinity_levels[id][elem] += 1
        end
  end
  def item_element_afinity(class_id, item, damage)
  item_damage = item
  return 1 unless item_damage == 0 or Raizen_Elements::Accept_Weapons
  item_damage = damage.damage.element_id if damage.damage.element_id > 0
  value = Raizen_Elements.damage($affinity_levels[class_id][item_damage])
  return value
  end
end