Variables Locales

  • 8 Réponses
  • 395 Vues
*

Hors ligne Leikt

Variables Locales
« le: 24 mai 2017, 10:05:22 »
25/05/2017 : Mise à jour du script mineure
18/04/2018 : Version 2. Refonte pour rendre la variables locales plus faciles à utiliser. Compatible avec la version précédente.

Bonjour à toutes et à tous,

RMXP nous donnes la possibilité de gérer des Interrupteurs locaux, mais qu'en est-il des variables locales ? Résultat, pour faire un personnage qui vous donnes des informations aléatoire sur le monde, ou un personnage qui s'énerve quand on lui parle trop on se retrouve à utiliser des variables de jeu et ça devient rapidement chaotique.

D'où ce plugin. Il permet de gérer des variables locales discrètement et simplement via la commande insérer un script.

Installation
Pour PSDK (Versions supérieures ou égales à 19.255): Télécharger la pièce jointe dans le dossier plugin de votre projet. Disponible ici

Pour PSP 0.9 :
Créer un script au-dessus de Main nommé : Game_SelfVariables, copiez/collez-y ce script
Spoiler
#==============================================================================
# ■ Game_SelfVariables
#------------------------------------------------------------------------------
# Hash gérant les variables locales. Des variables propres à l'évènement,
# Permet de ne pas devoir utiliser de variable de jeu pour gérer ce qui est propre
# à un évènement
# Dans les scrpit, la variable globale $game_self_variables contient les variables
# locales
#==============================================================================
 
class Game_SelfVariables
  #--------------------------------------------------------------------------
  # ● Création
  #--------------------------------------------------------------------------
  def initialize
    @data = {}
  end
  #--------------------------------------------------------------------------
  # ● Get
  #    key : Object, index de la variable à récupérer
  #--------------------------------------------------------------------------
  def [](key)
    return @data[key]
  end
  #--------------------------------------------------------------------------
  # ● Set
  #    key  : Object, index de la variable à modifier
  #    value : Object, information à stocker
  #--------------------------------------------------------------------------
  def []=(key, value)
    @data[key] = value
  end
  #--------------------------------------------------------------------------
  # ● Do
  #    key  : Object, index de la variable à modifier
  #    operation  : Symbol, nom de l'opération à réaliser. Can be empty.
  #    value  : Object, paramètre de l'opération
  #--------------------------------------------------------------------------
  def do(key, operation=nil, value=nil)
@data[key]=0 unless @data.has_key?(key)
case operation
when :set
@data[key]=value
when :del
@data.delete(key)

# Numeric
when :add
@data[key]+=value
when :sub
@data[key]-=value
when :div
@data[key]/=value
when :mul
@data[key]*=value
when :mod
@data[key]=@data[key]%value
when :count
@data[key]+=1
when :uncount
@data[key]-=1

# Boolean
when :toggle
@data[key]=!@data[key]
when :and
@data[key]=(@data[key] and value)
when :or
@data[key]=(@data[key] or value)
when :xor
@data[key]=(@data[key]^value)
end
# Return the data
return @data[key]
  end
end

class Interpreter
def VL(*args)
# Ancienne version de VL
if args[0].is_a?(Object) and (args[1]==nil or args[1].is_a?(Integer))
return $game_self_variables.do([(args[2] ? args[2] : @map_id),(args[1] ? args[1] : @event_id), args[0]])
end
# Nouvelle version
if args[0].is_a?(Symbol) # [var_loc, operation, value]
return $game_self_variables.do([@map_id, @event_id, args[0]], args[1], args[2])
elsif args[1].is_a?(Integer)# [map_id, event_id, var_loc, operation, value]
return $game_self_variables.do([args[0], args[1], args[2]], args[3], args[4])
else # [event_id, var_loc, operation, value]
return $game_self_variables.do([@map_id, args[0], args[1]], args[2], args[3])
end
return nil
end
alias get_local_variable VL
alias LV VL
 
def set_local_variable(id_var, value, id_event = @event_id, id_map = @map_id)
key = [id_map, id_event, id_var]
$game_self_variables[key] = value
end
alias set_VL set_local_variable
alias set_LV set_local_variable
end

Voici les modifications à effectuer dans les autres scripts pour assurer la sauvegarde des variables locales :
Spoiler
Script Scene_Title (celui de RMXP dans la première fournée de script)

Après la ligne 123 :
def command_new_game
   
# 決定 SE を演奏
    $game_system.se_play($data_system.decision_se)
    # BGM を停止
    Audio.bgm_stop
    # プレイ時間計測用のフレームカウントをリセット
    Graphics.frame_count = 0
    # 各種ゲームオブジェクトを作成
    $game_temp          = Game_Temp.new
    $game_system        = Game_System.new
    $game_switches      = Game_Switches.new
    $game_variables    = Game_Variables.new
    $game_self_switches = Game_SelfSwitches.new

Ajoutez :
    $game_self_variables = Game_SelfVariables.new


Script : Scene_Title (celui de PSP en dessous de Systeme General)

Après la ligne 477
def read_save_data(file)
    characters = Marshal.load(file)
    Graphics.frame_count = Marshal.load(file)
    $game_system        = Marshal.load(file)
    $game_switches      = Marshal.load(file)
    $game_variables    = Marshal.load(file)
    $game_self_switches = Marshal.load(file)

Ajouter :
    $game_self_variables = Marshal.load(file)

Après la ligne 458
def read_preview(filename)
    file = File.open(filename, "r")
    time_stamp      = file.mtime
    characters      = Marshal.load(file)
    frame_count    = Marshal.load(file)
    game_system    = Marshal.load(file)
    game_switches  = Marshal.load(file)
    game_variables  = Marshal.load(file)
    total_sec = frame_count / Graphics.frame_rate
   
    # Non utilisé
    game_self_switches = Marshal.load(file)

Ajouter :
    game_self_variables = Marshal.load(file)

Après la ligne 232
def read_preview(filename)
      file = File.open(filename, "r")
      time_stamp      = file.mtime
      characters      = Marshal.load(file)
      frame_count    = Marshal.load(file)
      game_system    = Marshal.load(file)
      game_switches  = Marshal.load(file)
      game_variables  = Marshal.load(file)
      total_sec = frame_count / Graphics.frame_rate
     
      # Non utilisé
      game_self_switches = Marshal.load(file)

Ajouter :
      game_self_variables = Marshal.load(file)



Script : Pokemon_Save (en dessous de Systeme General)

Après la ligne 276
def write_save_data(file)
      characters = []
      for i in 0...$game_party.actors.size
        actor = $game_party.actors[i]
        characters.push([actor.character_name, actor.character_hue])
      end
     
      Marshal.dump(characters, file)
     
      Marshal.dump(Graphics.frame_count, file)
     
      $game_system.save_count += 1
      $game_system.magic_number = $data_system.magic_number
     
      Marshal.dump($game_system, file)
      Marshal.dump($game_switches, file)
      Marshal.dump($game_variables, file)
      Marshal.dump($game_self_switches, file)

Ajouter :
      Marshal.dump($game_self_variables, file)

Utilisation
Tout se passe dans la commande insérer script :
 
VL(map_id, event_id, nom_variable, operation, valeur)

Les arguments
  • map_id (Optionnel) Id de la map dans laquelle se trouve l’événement dont il faut lire/modifier la variable locale. Si l’événement se trouve sur la même map que le héros, ne mettez rien.
  • event_id (Optionnel) Id de l’événement dont il faut lire/modifier la variable locale. Si la fonction est appelée depuis l'événement même, ne mettez rien.
  • nom_variable Nom de la variable à lire/modifier. Ce DOIT etre un Symbol (deux points suivie du mot ) Voici des exemple de nom de variable valides :
:compteur, :jauge_de_colere, :nombre_de_pas, :est_occupe
    Attention cependant : pas d'espace dans le nom, pas d'accents ni de caractères spéciaux. Des lettre et des underscore seulement.[/li]
  • operation (Optionnel) nom de l'opération à réaliser. Les mot-clefs sont définit dans le paragraphe en dessous. Si vous voulez juste voir la valeur de la variable, ne mettez rien.
  • valeur (Optionnel) si vous réaliser une opération et que celle-ci requiert une valeur, c'est ici qu'il faut la préciser. Sinon, ne mettez rien.

Voici donc quelques exemple d'appel de la fonction :
VL(:compteur, :add, 1) #Ajoute 1 à la variable locale :compteur de l’événement appelant la fonction
VL(12, :nombre_de_bonbons_restant, :sub, 1) # Retire un au nombre de bonbons qu'il reste a l'event numero 12 de la map actuelle.
VL(15, 5, :actif, :set, true) # Dis que la variable locale :actif est activé de l'event 5 de la map 15. Remarque : la variable locale est ici utilisé comme un interrupteur local
VL(:compteur)>10 # Peut être utilisé dans une condition d’événement pour tester la variable

Les opérations
Pour récupérer la valeur d'une variable, vous n'aurez pas besoin des deux derniers arguments :
VL(:nombre_de_pas) # Récupère la variable locale :nombre_de_pas de l’événement appelant la fonction
VL(12, :compteur) # Récupère la variable locale :compteur de l'événement 12 de la map actuelle
VL(15, 12, :compteur) # Récupère la variable locale :compteur de l'événement 12 de la map 15
Rien de bien sorcier. Notez cependant que si vous appelez une variable qui n'existe pas, elle vaudra 0 par défaut.

Pour modifier les variables locale, c'est pas sorcier non plus ! Les arguments operation et value vont définir ce que le script devra faire.
Voici la liste des opération possibles

Pour toutes les variables
  • :set : Remplacer la valeur actuelle par la nouvelle.
          value : un objet ruby (nombre, boolean, pokemon, ...
  • :del : Supprime la variable locale.

Pour les variables numériques
  • :add : Ajoute value à la valeur actuelle de la variable.
          value : nombre
  • :sub : Soustrait value à la valeur actuelle de la variable.
          value : nombre
  • :div : Divise la valeur actuelle de la variable par value .
          value : nombre
  • :mul : Multiplie la valeur actuelle de la variable par value .
          value : nombre
  • :mod : Effectue le modulo par value de la valeur actuelle.
          value : nombre
  • :count : Ajoute 1 à la variable
  • :uncount : Retire 1 à la variable

Pour les variables booléenne (True / False)
  • :and : Nouvelle valeur = ancienne_valeur ET value
          value : booleen
  • :or : Nouvelle valeur = ancienne_valeur OU value
          value : booleen
  • :xor : Nouvelle valeur = ancienne_valeur OU EXCLUSIF value
          value : booleen
  • :toggle : Inverse la valeur de la variable (Faux devient Vrai et Vrai devient Faux)

Voici des exemple d'appel d'opérations :
VL(:compteur, :count) # Ajoute un au compteur
VL(:dialogue_aleatoire, :set, rand(6)) # Idéal pour définir une variable aléatoire, comme le dialogue d'un PNJ
VL(:patience, :sub, 1) # Le PNJ perdra sa patience à chaque fois que vous lui parlerez
VL(:est_joyeux, :set, true)
VL(:est_joyeux, :toggle) # Pour un personnage lunatique par exemple

# On peut aussi effectuer des opération multiples
VL(:patience, :sub, VL(15, :nombre_parole)) # Récupère le nombre de fois que vous avez parler à l'event 15 et le soustrait
VL(:dummy, :mod, VL(12, 5, :dummy2, :add, VL(:dummy3, :mul, 5))) # Aucune limite

Voilà comment installer et utiliser les variables locales. C'est très pratique dans beaucoup de situations !

Voyez plutôt cette vidéo avec l'exemple de deux évènements : l'un s'énerve quand on lui parle à répétition, l'autre vous donne des informations aléatoirement.
https://youtu.be/UO-Pr9o1I2s

Crédits
Leikt

[Fichier vieux de plus de 120 jours]
« Modifié: 19 avril 2018, 12:37:16 par Leikt »
 
Utilisateurs ayant remercié ce post : Carchi, Yumekua, Vulvoch, Bentoxx, romnair, Alizia

Variables Locales
« Réponse #1 le: 24 mai 2017, 20:52:10 »
Script assez intéressant, ça pourra en aider plus d'un à faire des PNJ plus développés :3
ln(yo) = <3
 
Utilisateurs ayant remercié ce post : Leikt

*

Hors ligne Bentoxx

Variables Locales
« Réponse #2 le: 24 mai 2017, 21:10:59 »
Sachant que les events ont un nombre d'interrupteur local limité ça peut être vachement intéressant, une discussion ou une action différente selon l'avancer du jeu, sans vraiment de limité !

Le Discord c'est ICI
 
Utilisateurs ayant remercié ce post : Leikt

*

Hors ligne Leikt

Variables Locales
« Réponse #3 le: 25 mai 2017, 00:37:48 »
Techniquement, les variables locales peuvent être utilisées comme de interrupteurs locaux (à la différence qu'elles ne sont pas testée par le système pour définir les pages)
« Modifié: 25 mai 2017, 09:20:11 par Leikt »
 
Utilisateurs ayant remercié ce post : Bentoxx

*

Hors ligne ShotenYT

  • Membre intégré
  • ***
  • 123
  • Remercié: 11 fois
  • Le mapping est un art, l'art et moi ça fait deux.
    • Pokémon Météor
Variables Locales
« Réponse #4 le: 07 juin 2017, 21:21:49 »
Merci pour ce script, je pense que je vais l'utiliser  :)
 

*

Hors ligne Leikt

Variables Locales
« Réponse #5 le: 18 avril 2018, 17:52:33 »
Version 2.0 disponible. Les variables locales sont plus faciles à utiliser dorénavant !
 

Variables Locales
« Réponse #6 le: 18 avril 2018, 19:32:52 »
Est-ce que c'est compatible avec la version précédente ?
ln(yo) = <3
 

*

Hors ligne Leikt

Variables Locales
« Réponse #7 le: 19 avril 2018, 00:14:22 »
J'avais supprimé les anciennes method de l'interpreter. Mais je viens de faire la compatibilité et ait testé avec le code suivant :
set_VL(:nom, 25, 5, 2)
VL(:nom, 5, 2)  # => 25
VL(2, 5, :nom) # => 25
VL(2, 5, :nom, :add, 5) # => 30
get_local_variable(:nom, 5, 2) # => 30
Une différence à prendre en compte, avec la nouvelle version, les noms de variables DOIVENT être des Symbol. plus question de mettre n'importe quoi en clef.
Cela dit, les variables locales sauvegardées restent accessible par VL(Object key, Integer event_id, Integer map_id)

Donc oui, c'est compatible avec la version précédente.
 

Variables Locales
« Réponse #8 le: 19 avril 2018, 10:35:24 »
Cool :)
ln(yo) = <3