#===============================================================================
# ▼ [VX] Formules de calcul personnalisées
#------------------------------------------------------------------------
# Blockade script Library - Formules de calcul personnalisées
# Date : 04/07/2010
# Niveau : Facile/Expert
# Version : 1.0
# Forum d'origine : http://rpg-maker-vx.bbactif.com/forum.htm
# Remerciements spéciaux : Yanfly
#
#  Ce script permet de restaurer certaines formules de calcul du SBS, disparue depuis la
# version 3.4. Aussi, il permet de créer ces propres formules de calcul, avec très très peu de
# connaissance en RGSS2.
#=======================================================================
# ▼ Mises à jour
# -------------------------------------------------------------------------
# ¤ 04/07/2010 -  Version 1.0 - Création du script
#=======================================================================
# ▼ Installation
# --------------------------------------------------------------------------
#  Copiez ce script au dessus de main, et au dessous de tout les scripts qui réécrivent la
#  méthode make_obj_damage_value.
#=======================================================================
# ▼ Utilisation
# --------------------------------------------------------------------------
#  Le script contient les 6 formules de calcul de base du SBS disparue depuis le 3.4. Pour
# appliquer une formule à un sort/objet : allez dans la base de données, et mettez un
# des tags suivants : (x représente un chiffre à rentrer)
# 
#  - <-x% hp max> ou <-x% pdv max>
#  Change la formule de calcul en : (max hp de la cible * x) / 100. C'est à dire inflige un
# pourcentage des HP maximum à la cible (si la cible à 2000 HP max, et que vous mettez
# <50% hp max>, le sort infligera 50% des HP max c'est à dire 1000 HP. Bien sur le - peut
# être changé en +, ce qui soignera la cible. Par exemple <+x% hp max> soignera la cible
# de x % de ses hp max.
#
#  - <-x% mp max>
#  Change la formule de calcul en : (max mp de la cible * x) / 100. C'est à dire inflige un
# pourcentage des MP maximum à la cible (si la cible à 2000 MP max, et que vous mettez
# <25% mp max>, le sort infligera 25% des MP max c'est à dire 500 HP. Attention les
# dégâts seront infligé sur les HP, sauf si vous cochez la case "Modifie les MP" (ce
# principe s'applique à toutes les formules, même personnalisées). Bien sur le - peut
# être changé en +, ce qui soignera la cible.
#
#  - <-x% hp> ou <-x% pdv>
#  Change la formule de calcul en : (hp de la cible * x) / 100. C'est à dire inflige un
# pourcentage des HP à la cible (si la cible à 100 HP , et que vous mettez
# <75% hp>, le sort infligera 75% des HP  c'est à dire 75 HP. Cette formule est la
# même que celle des sorts "Demi" dans final fantasy 7. Bien sur le - peut
# être changé en +, ce qui soignera la cible.
#
#  - <-x% mp>
#  Change la formule de calcul en : (mp de la cible * x) / 100. C'est à dire inflige un
# pourcentage des MP à la cible (si la cible à 200 MP , et que vous mettez
# <50% mp, le sort infligera 50% des MP c'est à dire 100 HP. Je rappelle que les
# dégâts seront infligé sur les HP, sauf si vous cochez la case "Modifie les MP" (ce
# principe s'applique à toutes les formules, même personnalisées). Bien sur le - peut
# être changé en +, ce qui soignera la cible.
#
# - <taux actuel hp>
#  Ce tag permet que la puissance du sort dépende de l'écart des HP actuels et des HP max.
# Plus les HP sont haut, plus le sort s'approche de sa puissance maximale. La formule est
# changée en : (dégâts normaux * hp de l'attaquant)/ hp max de l'attaquant. Si par exemple
# vous avez 1000/2000 HP, et que votre sort fait du 10 000 de dégâts au maximum les dégâts
# seront de 5000 (réduit de 50 %)
#
# - <taux actuel mp>
#  Ce tag permet que la puissance du sort dépende de l'écart des MP actuels et des MP max.
# Plus les MP sont haut, plus le sort s'approche de sa puissance maximale. La formule est
# changée en : (dégâts normaux * mp de l'attaquant) / mp max de l'attaquant. Si par exemple
# vous avez 75/100 MP, et que votre sort fait du 1000 de dégâts au maximum les dégâts
# seront de 750 (réduit de 25 %). Je rappelle une dernière fois que les dégâts seront infligés
# sur les HP, sauf si vous cochez la case "Modifie les MP" (ce principe s'applique à toutes
# les formules, même personnalisées)
#
#  Créer vos propres formules :
# Il faut retenir qu'il y a 2 étapes : la création du tag dans la BDD, puis le codage dans le script. Vous n'avez
# pas besoin de connaissance en RGSS2, je vais tout vous détailler.

# ► Création du tag dans la BDD
#
# Tout d'abord allez dans la base de données, et sélectionnez un sort ou un objet. On va prendre pour exemple
# que vous partez sur un sort, mais le principe pour un objet est le même. On veut par exemple changer la
# formule en : ((x * argent possédé) / nombre de pas effectué) + (attaque de l'attaquant * 2 - défense de l'a cible).
# x est un nombre que vous aimerez choisir dans la base de données car vous allez appliquer cette formule à
# plusieurs sorts de votre base de données. Donc maintenant on à notre formule, on veut la créer dans RMVX.
# Premièrement on choisi une ID à la formule, cette ID doit être supérieure à 6. Pourquoi supérieure à 6 ? Parce
# que les 6 formules de bases fournies avec le script ont pour ID 1,2,3,4,5,6. Donc tout les chiffres/nombres qui
# sont supérieurs à 6 sont valable. Ici on va prendre 7. La formule se construit de cette façon :
#
# <formule id: x,y,z> ou <formule id>
# id est l'ID de votre formule (ici 7)
# x,y,z sont des arguments optionnels.
#
#C e sont des valeurs que vous pouvez retrouver dans votre formule de calcul (regardez par exemple <x% hp>,
# x est retrouvé dans la formule). Vous pouvez avoir une infinité d'arguments, mais ce sont forcément des
# chiffres ou des nombres. Nous voulons un argument la formule sera donc :
#
#<formule 7: 25>
#
# si on veut 25 pour argument (ca aurait très bien pu être 42 ou 456).
# Notre tag est crée, passons au codage !
#----------------------------------------------------------------------------------------------------------------------------------------------------------------
# ► Codage de la formule
#
# La premiére étape est de repérer l'endroit ou vous allez mettre votre code, descendez dans le script jusqu'à trouver
# "Modification des formules", et c'est entre ce commentaire et "Fin de l'édition" que vous allez mettre votre code.
# (une image ici : http://s2.noelshack.com/uploads/images/18820432938483_tutoscript1.png)
# Première chose à faire : faire reconnaitre au script l'ID que vous avez choisie. Pour cela il suffit de mettre
#  when id
# ou id est l'ID de votre formule, ici l'ID est 7.
# Tout ce qui sera en dessous du when, jusqu'au prochain when (ou jusqu'au commentaire) sera pris en compte
# pour la formule d'ID 7. Maintenant on s'attaque au gros morceau ! Alors tout d'abord on à accès à plusieurs
# "données" :
#
# user contient les données relatives à l'attaquant
# self contient les données relatives à la cible qui va recevoir les dégâts
# obj contient les données relatives au sort ou à l'objet
#
# A partir de ces trois variables, on peut récupérer tout un tas d'informations comme l'attaque, la défense, le cout
# en MP du sort. La méthode pour récupérer l'attaque est atk, donc si on veut récupérer l'attaque de l'attaquant
# il suffit de mettre user.atk. Pour récuperer la défense ont sait que la méthode est def : on va procéder par étape
# pour récuperer la défense de la cible. On sait qu'on peut récuperer les données de la cible avec self, la méthode
# est def. Donc pour récupérer la defense de la cible : self.def si on aurait voulu avoir la défense de l'attaquant il
# aurait suffit de mettre user.def. Une fois que vous avez compris ca c'est gagné !
# J'ai mis à votre disposition un petit lexique dans le script avec les principales méthodes, que vous pouvez trouver à
# l'endroit de l'édition des formules.
#
# La formule est toujours stockée dans la variable damage. Donc notre code aura pour forme pour l'instant :
#when 7
# damage = une formule
# "une formule" correspond à votre formule, dans cette exemple :
# ((x * argent possédé) / nombre de pas effectué) + (attaque de l'attaquant * 2 - défense de la cible).
# Vous savez comment on récupère l'attaque de l'attaquant, et la défense de la cible (user.atk, self.def).
# Dans le lexique on voit que l'argent possédé est donnée par $game_party.glod et le nombre de pas par
# $game_party.steps. Mais comment on récupère le paramètre donné dans la BDD, qui correspond au x ici ?
# Il suffit de mettre : obj.data_formule[0] qui récupérera le premier argument, si on avait 2 arguments et
# qu'on veut récupérer le deuxième il aurait fallu mettre obj.data_formule[1]. En fait pour généraliser, c'est la
# position de l'argument (1er,2éme etc..) moins 1. Vous avez tout pour faire votre formule maintenant !
# Essayez de retrouver le code, avant de regarder la forme finale !
#
# when 7
#  damage = ((obj.data_formule[0] * $game_party.gold) / $game_party.steps) + (user.atk * 2 - self.def)
#
# Après ca le script va appliquer la variance, l'effet "défense" si il à été activé et l'ajustement élémentaire. Si vous
# ne voulez pas que la variance soit pas appliquée il suffit de mettre à suivre ignore_variance = true
# Pour ignorer les autres effets c'est la même chose, juste la variable change, jetez un coup d'œil au lexique.
# Votre code final sera donc :
# when 7
#  damage = ((obj.data_formule[0] * $game_party.gold) / $game_party.steps) + (user.atk * 2 - self.def)
#  ignore_variance = true
# Votre formule est crée ! pour en faire une autre il suffit de mettre votre code à la suite de celle la.
# Si vous ne comprenez pas tout, jetez un coup d'œil au formules déjà intégrées ca vous aidera !
#=======================================================================
# ▼ Alias et compatibilité
# --------------------------------------------------------------------------
# ► Alias méthodes :
#  >  Game_Battler : make_obj_damage_value
#-----------------------------------------
# Ce script est compatible avec le système de combat de base, et le SBS version 3.4 minimum.
# Si vous utilisez toujours une version antérieure à la 3.4 vous pouvez upgrader le script, mais
# normalement il est compatible avec les versions antérieure. Néanmoins, je n'assure pas de
# support si vous rencontrez un problème avec des version antérieures à la 3.4.
#===============================================================================

$imported = {} if $imported == nil
$imported["FormulesPersonalisées"] = true

module BSL
    module FCP
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    # TAG_X
    #-------------------------------------------------
    # /!\ Ne touchez qu'a cette section si vous êtes familiers avec les regxp
    # Niveau : Avancé
    # Ici vous pourrez changer les tags qui récupèrent les données dans la partie note
    # des sorts ou des objets. Je vous déconseille vivement de modifier cette partie.
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    # Tag pour la formule en fonction du pourcentage de HP/MP max
    TAG_POURCENTAGEMAX = /<([\+\-]\d+)[ ]*(?:\%)[ ]*(.*)[ ](?:max)>/i
    # Tag pour la formule en fonction du pourcentage de HP/MP
    TAG_POURCENTAGE = /<([\+\-]\d+)[ ]*(?:\%)[ ]*(.*)>/i
    # Tag pour la formule en fonction du nombre de HP/MP de l'attaquant
    TAG_NOWPOWER = /<(?:taux actuel)[ ](.*)>/i
    # Tag général
    TAG_GENERAL = /<(?:formule)[ ](\d+):[ ](\d+(?:\s*,\s*\d+)*)>/i
    # Tag général sdans arguments
    TAG_GENERALNOARG = /<(?:formule)[ ]*(\d+)>/i
  end
end
 

#==============================================================================
# ** Game_Battler
#------------------------------------------------------------------------------
# Class qui gére les combattants.
#==============================================================================
class Game_Battler
  #--------------------------------------------------------------------------
  # * alias method: make_obj_damage_value
  #--------------------------------------------------------------------------
  alias bsl_fcp_make_obj_damage_value make_obj_damage_value
  def make_obj_damage_value(user, obj)
    bsl_fcp_make_obj_damage_value(user, obj)
    return unless obj.id_formule != 0
    # /!\ Ne touchez pas aux valeurs qui suivent
    ignore_variance = false
    ignore_guard = false
    ignore_elements = false
    damage_mp = obj.damage_to_mp
    damage = 0
    case obj.id_formule
    # /!\ Ne touchez pas à la partie d'au dessus
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    # Modification des formules de calcul
    #-------------------------------------------------
    # Niveau : Expert
    # Les formules ci dessous sont celle d'origine avec le script, évitez de les toucher.
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
      when 1 # Inflige un pourcentage des hp max
        pourcentage = obj.data_formule[0]
        damage = (self.maxhp * - pourcentage) / 100
        ignore_variance = true
      when 2 # Inflige un pourcentage des hp
        pourcentage = obj.data_formule[0]
        damage = (self.hp * - pourcentage) / 100
        ignore_variance = true
      when 3 # Inflige un pourcentage des mp max
        pourcentage = obj.data_formule[0]
        damage = (self.maxmp * - pourcentage) / 100
        ignore_variance = true
      when 4 # Inflige un pourcentage des mp
        pourcentage = obj.data_formule[0]
        damage = (self.mp * - pourcentage) / 100
        ignore_variance = true
      when 5 # Plus on à de HP, plus le sort tape fort
        damage = (@hp_damage * user.hp) / user.maxhp
        ignore_variance = true
        ignore_guard = true
        ignore_elements = true
      when 6 # Plus on à de MP, plus le sort tape fort
        damage = (@mp_damage * user.mp) / user.maxmp
        ignore_variance = true
        ignore_guard = true
        ignore_elements = true
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    # Modification des formules de calcul
    #-------------------------------------------------
    # Niveau : Expert
    # Vous pouvez éditer à partir de ce moment.
    #---------------------------------------------------------------------------------------------------------------------------------------------------------------
    # Lexique (incomplet)
    # ------------
    #  > Base
    #  user : user contient les données de l'attaquant
    #  self : self contient les données de la cible
    #  obj : obj contient les données du sort ou de l'objet
    #
    #  > Caractéristiques (applicable à user ou self : x peut-être remplacé par user ou self)
    #    x.maxhp : renvoie les HP maximum
    #    x.maxmp : renvoie les MP maximum
    #    x.hp : renvoie les HP
    #    x.mp : renvoie les MP
    #    x.atk : renvoie l'attaque
    #    x.def : renvoie la défense
    #    x.spi : renvoie l'intelligence
    #    x.agi : renvoie l'agilité
    #    x.hit : renvoie la précision
    #    x.eva : renvoie l'esquive
    #    x.cri : renvoie les critiques
    #   
    #  > Caractéristiques des sorts/objet (applicable qu'a obj)
    #    obj.base_damage : renvoie la base des dommages du sort/objet
    #    obj.variance  : renvoie la variance du sort/objet
    #    obj.atk_f : renvoie l'influence physique
    #    obj.spi_f : renvoie l'influence magique
    #    obj.speed : renvoie la vitesse du sort/objet
    #
    #  > Autres
    #    $game_party.steps : renvoie le nombre de pas
    #    $game_party.gold : renvoie le nombre d'argent possédé
    #    $game_party.items.size : renvoie le nombre d'objets possédé (la quantité individuelle d'objets n'influe pas)
    #    $game_party.members.size : renvoie le nombre de membre dans l'équipe
    #
    #  > Variables propres au script :
    #    @hp_damage : renvoie les dommages aux HP calculés avant l'application de la formule
    #    @mp_damage : renvoie les dommages aux MP calculés avant l'application de la formule
    #      ignore_variance = true : ignore la variance dans le calcul des prochains dégâts
    #      ignore_guard = true : ignore la commande "défense" si elle à été activée
    #      ignore_elements = true : ignore l'ajustement élémentaire
    #      damage_mp = true : inflige les dommages aux MP au lieu des HP
    #
    # Pour finir, les dégâts doivent être stockés dans la variable damage. Ensuite, la variance, la garde et l'ajustement
    # élémentaire est appliqué. Pour empêcher un de ces effets regardez au dessus. Pour récuperer les arguments
    # entrés dans la BDD : obj.data_formule[x-1] (x est la position de l'argument). Par exemple vous mettez un tag
    # <formule 17: 54,36> votre code sera sous la forme :
    #  when 17
    #    arg1 = obj.data_formule[0]  # <= Sera égal à 54
    #    arg2 = obj.data_formule[1]  # <= sera égal à 36
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

   
   
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    # Fin de l'édition
    #-------------------------------------------------
    # Ne touchez pas à ce qui va suivre, sous peine de dysfonctionnement du script, et de
    # dommages éventuels à votre ordinateur.
    #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    end
    damage *= elements_max_rate(obj.element_set)  unless ignore_elements
    damage /= 100 unless ignore_elements
    damage = apply_variance(damage, obj.variance)  unless ignore_variance
    damage = apply_guard(damage)  unless ignore_guard
    if damage_mp
      @mp_damage = damage.to_i
    else
      @hp_damage = damage.to_i
    end
  end
end

#==============================================================================
# ** Scene_Title
#------------------------------------------------------------------------------
#  This class performs the title screen processing.
#==============================================================================
class Scene_Title < Scene_Base
  #--------------------------------------------------------------------------
  # alias method: load_bt_database
  #--------------------------------------------------------------------------
  alias bsl_fcp_load_bt_database load_bt_database unless $@
  def load_bt_database
    bsl_fcp_load_bt_database
    load_bsl_cache
  end
 
  #--------------------------------------------------------------------------
  # alias method: load_database
  #--------------------------------------------------------------------------
  alias bsl_fcp_load_database load_database unless $@
  def load_database
    bsl_fcp_load_database
    load_bsl_cache
  end
 
  #--------------------------------------------------------------------------
  # new method: load_bsl_cache
  # Permet de charger les données dès le lancement
  # du jeu. Merci à Yanfly, à qui j'ai piqué l'idée.
  #--------------------------------------------------------------------------
  def load_bsl_cache
      for obj in ($data_skills + $data_items)
        next if obj.nil?
        obj.load_cache_formules
      end
  end
end


#==============================================================================
# ** RPG::UsableItem
#------------------------------------------------------------------------------
#  Class qui gère les objets/sorts
#==============================================================================
  class RPG::UsableItem
    include BSL::FCP # Inclusion du module
    # Variables
    attr_accessor :data_formule
    attr_accessor :id_formule
    #--------------------------------------------------------------------------
    # * new method : load_cache_formules
    # Charge les données relatives aux formules de calcul.
    #--------------------------------------------------------------------------
    def load_cache_formules
      @id_formule = 0
      @data_formule = []
      # Detection des paramétres définis
      self.note.split(/[\r\n]+/).each { |line|
      case line
        when TAG_POURCENTAGEMAX
          case $2.upcase
            when "HP","PDV"
              @id_formule = 1
            when "MP"
              @id_formule =  3
          end
          @data_formule.push($1.to_i)
        when TAG_POURCENTAGE
          case $2.upcase
            when "HP","PDV"
              @id_formule = 2
            when "MP"
              @id_formule =  4
          end
          @data_formule.push($1.to_i)
        when TAG_NOWPOWER
          case $1.upcase
            when "HP","PDV"
              @id_formule = 5
              p ""
            when "MP"
              @id_formule =  6
              p ""
            end
        when TAG_GENERAL,TAG_GENERALNOARG
          @id_formule = $1.to_i
          $2.scan(/\d+/).each { |num| @data_formule.push(num.to_i) } unless TAG_GENERALNOARG
      end}
    end
 end

#  Le script contient les 6 formules de calcul de base du SBS disparue depuis le 3.4. Pour
# appliquer une formule à un sort/objet : allez dans la base de données, et mettez un
# des tags suivants : (x représente un chiffre à rentrer)
# 
#  - <x% hp max> ou <x% pdv max>
#  Change la formule de calcul en : (max hp de la cible * x) / 100. C'est à dire inflige un
# pourcentage des HP maximum à la cible (si la cible à 2000 HP max, et que vous mettez
# <50% hp max>, le sort infligera 50% des HP max c'est à dire 1000 HP.
#
#  - <x% mp max>
#  Change la formule de calcul en : (max mp de la cible * x) / 100. C'est à dire inflige un
# pourcentage des MP maximum à la cible (si la cible à 2000 MP max, et que vous mettez
# <25% mp max>, le sort infligera 25% des MP max c'est à dire 500 HP. Attention les
# dégâts seront infligé sur les HP, sauf si vous cochez la case "Modifie les MP" (ce
# principe s'applique à toutes les formules, même personnalisées)
#
#  - <x% hp> ou <x% pdv>
#  Change la formule de calcul en : (hp de la cible * x) / 100. C'est à dire inflige un
# pourcentage des HP à la cible (si la cible à 100 HP , et que vous mettez
# <75% hp>, le sort infligera 75% des HP  c'est à dire 75 HP. Cette formule est la
# même que celle des sorts "Demi" dans final fantasy 7.
#
#  - <x% mp>
#  Change la formule de calcul en : (mp de la cible * x) / 100. C'est à dire inflige un
# pourcentage des MP à la cible (si la cible à 200 MP , et que vous mettez
# <50% mp, le sort infligera 50% des MP c'est à dire 100 HP. Je rappelle que les
# dégâts seront infligé sur les HP, sauf si vous cochez la case "Modifie les MP" (ce
# principe s'applique à toutes les formules, même personnalisées)
#
# - <taux actuel hp>
#  Ce tag permet que la puissance du sort dépende de l'écart des HP actuels et des HP max.
# Plus les HP sont haut, plus le sort s'approche de sa puissance maximale. La formule est
# changée en : (dégâts normaux * hp de l'attaquant)/ hp max de l'attaquant. Si par exemple
# vous avez 1000/2000 HP, et que votre sort fait du 10 000 de dégâts au maximum les dégâts
# seront de 5000 (réduit de 50 %)
#
# - <taux actuel mp>
#  Ce tag permet que la puissance du sort dépende de l'écart des MP actuels et des MP max.
# Plus les MP sont haut, plus le sort s'approche de sa puissance maximale. La formule est
# changée en : (dégâts normaux * mp de l'attaquant) / mp max de l'attaquant. Si par exemple
# vous avez 75/100 MP, et que votre sort fait du 1000 de dégâts au maximum les dégâts
# seront de 750 (réduit de 25 %). Je rappelle une dernière fois que les dégâts seront infligés
# sur les HP, sauf si vous cochez la case "Modifie les MP" (ce principe s'applique à toutes
# les formules, même personnalisées)

<formule id: x,y,z> ou <formule id>