module SLNC # <-- Mon module personnel qui contient les paramètres pour la plupart de mes scripts
 
 #---------------------------------------------------------
 # GESTION DES ELEMENTARITES
 #---------------------------------------------------------
 
 #---------------------------------------------------------
 # UTILISATION
 #---------------------------------------------------------
 # * Placez au-dessus de Main
 # * Activez une seule des deux méthodes proposées aux lignes 90 et 107
 # * Modifiez si besoin le tableau des valeurs des résistances à la ligne 120
 #---------------------------------------------------------

 #---------------------------------------------------------
 # EXPLICATIONS :
 #---------------------------------------------------------
 # Vous voulez une gestion un peu plus réaliste des résistances élémentaires ?
 #
 # J'ai toujours trouvé étrange la gestion des  résistances de RMVX (qui prend systématiquement la plus grande valeur et maximise ainsi les dommages), qui permet
 # par exemple d'achever un ennemi invulnérable au feu (uniquement) avec une attaque physique de feu.
 #
 # Ce script propose deux systèmes qui permettent, en plus de modifier les valeurs des niveaux de résistance, de
 # mieux (enfin c'est mon avis) gérer les résistances en cas d'attaques multi-élémentaires.
 #
 # METHODE 1 : MULTIPLICATION (activée par défaut dans ce script)
 # Pour reprendre l'exemple de l'attaque physique de feu à 2 éléments (Physique + Feu), si l'ennemi est insensible au
 # feu, il sera également insensible à cette attaque.
 #
 # METHODE 2 : MOYENNE
 # Dans le même exemple, si la résistance physique de l'ennemi est normale (100%), la valeur finale sera la moyenne
 # des deux résistances, soit (0 + 100) / 2, soit 50.
 #
 # Lisez les exemples ci-dessous pour choisir d'activer ou non une de ces deux méthodes (je n'ai pas essayé
 # d'activer les deux, je ne suis pas sûr que ça entraîne une erreur, mais par contre vous aurez sûrement des
 # résultats un peu bizarre, donc je ne vous conseille pas de le faire...)
 #
 # Grâce à ce script, vous pouvez par exemple différenciez les attaques magiques et physiques élémentaires, par
 # exemple Feu (Souffle enflammé par exemple) // Magie + Feu (Flamme par exemple) // Physique + Feu (Pyro-attaque
 # par exemple).
 #---------------------------------------------------------
 # ATTENTION :
 # Vu la nature de ce script, il rendra les combats un peu plus difficiles (notamment face aux boss ou aux ennemis
 # élémentaires).
 # Vous serez donc peut-être amenés à revoir la difficulté de vos combats.
 #---------------------------------------------------------

 #---------------------------------------------------------
 # METHODE 1 : MULTIPLICATION
 #---------------------------------------------------------
 # 1°) Si un seul des éléments a pour résistance 0, l'attaque vaut 0 (quelque soient les autres éléments)
 # 2°) Si un élément a pour résistance -100 :
 #     - la première fois, le résultat est multiplié par -1 (dégâts absorbés)
 #     - ensuite, le résultat est multiplé par 2 (dégâts absorbés doublés)
 # 3°) Toutes les autres résistances s'appliquent ensuite :
 #     - en cas de dégâts subis, les résistances se multiplient entre elles
 #     - en cas de dégâts absorbés, elles se divisent entre elles
 #
 # Exemples :
 # On prend ici en compte les valeurs par défaut :
 # A = 200 / B = 150 / C = 100 / D = 50 / E = 0 / F = -100
 # Supposons une attaque fixe de 100, avec Spi F = 0 et Att F = 0
 #
 # E + A =        pas de dégâts car E = 0%
 # E + F =        pas de dégâts car E = 0%
 # F =               dégâts absorbés de 100
 # Jusque là, c'est normal.
 #
 # F x 2 =         dégâts absorbés de 200 (100 * (-1) * 2)
 # Ici, le calcul n'est bien sûr pas de (-1) * (-1), ce qui donnerait un résultat positif
 # F x 3 =         dégâts absorbés de 400 (100 * (-1) * 2 * 2)
 # F x 10 =       dégâts absorbés de 51200 (100 * (-1) * 2 ^ 9)
 # ...
 #
 # A + B =                     dégâts subis de 300 (100 * 200% * 150%)
 # A + D =                    dégâts subis de 100 (100 * 200% * 50%)
 # A + B + C + D =      dégâts subis de 150 (100 * 200% * 150% * 100% * 50%)
 # A x 10 =                    dégâts subis de 102400 (100 * 200% ^ 10) !!
 # A x 10 + E =             pas de dégâts car E = 0% !!
 # ...
 #
 # Mais
 # F + A =         dégâts absorbés de 50 (100 * (-1) / 200%)
 # F + C =         dégâts absorbés de 200 (100 * (-1) / 50%)
 # ...
 #---------------------------------------------------------
 # Pour désactiver cette méthode, mettez "false" (sans les guillemets) ici :
 RESIST_MULTIPLE = true
 #---------------------------------------------------------
 
 #---------------------------------------------------------
 # METHODE 2 : MOYENNE
 #---------------------------------------------------------
 # Fait la moyenne de toutes les valeurs quelles qu'elles soient.
 #
 # Exemple :
 # On prend ici en compte les valeurs par défaut :
 # A = 200 / B = 150 / C = 100 / D = 50 / E = 0 / F = -100
 # Supposons une attaque fixe de 100, avec Spi F = 0 et Att F = 0
 #
 # A + D =                                                              attaque de (200 + 50) / 2 = 125
 # Je pense que cet exemple suffit puisque cette méthode est tout de même beaucoup moins "complexe".
 #---------------------------------------------------------
 # Pour activer cette méthode, mettez "true" (sans les guillemets) ici :
 RESIST_MOYENNE = false
 #---------------------------------------------------------
 
 #---------------------------------------------------------
 # PARAMETRES :
 #---------------------------------------------------------
 # Niveaux de résistance :
 # Définir ici les résistances qui remplacent celles de base
 # Ne changez pas la première valeur.
 # Vaut à la fois pour les alliés et les ennemis
 # Exprimé en %
 # Je vous conseille de garder C = 100 pour ne pas avoir à modifier trop de paramètres dans votre database
 #                                     A      B      C     D   E     F
 RESISTANCES = [0,200, 150, 100, 50, 0, -100]
 #---------------------------------------------------------
 # FIN DES PARAMETRES
 #---------------------------------------------------------
end

class Game_Battler
 
 def elements_max_rate(element_set)
   return 100 if element_set.empty?
   rate_list = []
   for element_id in element_set
     rate_list.push(element_rate(element_id))
   end
   
   if SLNC::RESIST_MULTIPLE     # METHODE N° 1
   result = 100
   for rate in rate_list                         # 1er tour : définit si l'attaque est positive, négative ou nulle
     next if rate == nil
     if rate == 0                                    # Si la valeur vaut 0
       return 0                                       # L'attaque vaut 0
     elsif rate < 0                                  # Si la valeur est négative
       if result < 0                                 # Si le résultat est déjà négatif
         result *= 2                                 # Augmente le taux d'absorption
       else
         result *= -1                               # Sinon, inverse le résultat (absorption)
       end
     end
   end
   
   for rate in rate_list                         # 2eme tour : définit la valeur finale
     next if rate == nil
     next if rate <= 0                             # Ne prend plus en compte les valeurs nulles ou négatives
     if result < 0
       result *= 100
       result /= rate
     else
       result *= rate
       result /= 100
     end
   end
   
   elsif SLNC::RESIST_MOYENNE # METHODE N° 2
     result = 0
     for rate in rate_list
       next if rate == nil
       result += rate
     end
     result /= rate_list.nitems              #Calcule la moyenne
     
   else                                                    #METHODE PAR DEFAUT
     result = rate_list.max                    #Prend la valeur maximale
   end
   
 return result
 end
end

class Game_Actor
 
 def element_rate(element_id)
   rank = self.class.element_ranks[element_id]
   result = SLNC::RESISTANCES[rank]
   for armor in armors.compact
     result /= 2 if armor.element_set.include?(element_id)
   end
   for state in states
     result /= 2 if state.element_set.include?(element_id)
   end
   return result
 end
end

class Game_Enemy
 
 def element_rate(element_id)
   rank = enemy.element_ranks[element_id]
   result = SLNC::RESISTANCES[rank]
   for state in states
     result /= 2 if state.element_set.include?(element_id)
   end
   return result
 end
end