Partagez
Aller en bas
Blockade
Blockade
Membre

Nombre de messages : 194
Age : 27
Distinction : aucune
Date d'inscription : 06/09/2008

Formules de calcul personnalisées Empty Formules de calcul personnalisées

le Lun 5 Juil 2010 - 17:06
Formules de calcul personnalisées


Auteur : Blockade
Date : 04/07/2010
Version : 1.0
Remerciements spéciaux : Yanfly

Description du script :
- Permet de restaurer les fonctions disparues dans le SBS 3.4
- Permet de créer ces formules personnalisées

­script :
Code:
#===============================================================================
# ▼ [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.
#
#  - <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)
#
#  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


Installation & utilisation
Mettez juste au dessus de main !

Utilisation des 6 formules de bases :

Code:
#  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)

Création d'une formule personnalisée :


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 :
Code:
<formule id: x,y,z> ou <formule id>

id est l'ID de votre formule (ici 7)
x,y,z sont des arguments optionnels. Ce sont des valeurs que vous pouvez retrouver dans votre formule de calcul (regardez par exemple , 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 :
Code:
<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
Code:
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 :
Code:
self.def
si on aurait voulu avoir la défense de l'attaquant il aurait suffit de mettre
Code:
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 :
Code:

 > 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

La formule est toujours stockée dans la variable damage. Donc notre code aura pour forme pour l'instant :
Code:
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 :
Code:
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
Code:
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 !
Le voici :
Spoiler:
Code:
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
Code:
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 :
Code:
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 ! Ou si vous avez des questions n'hésitez pas =)

Petit exercice pour vous entrainer à utiliser ce script :
Donnez le tag, et le code à rentrer pour que le sort aie pour formule :
(x * nombre de membre dans l'équipe) / (l'intelligence de la cible / y)
L'ID sera 45, x et y deux arguments dans la base de données !
Revenir en haut
Permission de ce forum:
Vous ne pouvez pas répondre aux sujets dans ce forum