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

Auteur : xvw
Logiciel : RPG Maker VX Ace
Nombre de scripts : 1
Source : https://github.com/xvw/RPGMaker/blob/master/CustomDatabase/

Ce script était auparavant connu sous le nom d'Extended_Database, il s'agit d'une version revue en 2015.

Fonctionnalités
Ce script est un outil qui est assez difficile à utiliser pour un néophyte. Il sert à produire plus rapidement d'autres scripts qui reposent sur le stockage et la structuration de données. Cependant, il est possible pour un Event Maker de s'en sortir.

Conditions d'utilisation
Ce script est sous licence MIT/X Consortium License (dite licence X11), soit :
- Le crédit est non obligatoire, tant que vous ne dites pas que vous l'avez fait
- Vous pouvez utiliser ce script dans vos projets commerciaux
- Vous pouvez distribuer le script original ou modifié
- Vous devez conserver le bandeau en haut du script avec la licence et le/les contributeurs
- Si vous créditez les auteurs d'autres scripts dans votre projet, vous devez créditer RME (les ressources doivent être traitées au même niveau de visibilité)

Installation
Copiez le script dans votre éditeur de script Au dessus de Main, dans la rubrique Materials. Vous pouvez lui attribuer un emplacement réservé. Et le nommer comme vous l'entendez. Personnellement, j'ai choisi le nom Autres Bases de données (original :P !).
Je vous conseil de créer un emplacement vide en dessous de ce script qui contiendra le mapping de vos bases de données.

# CUSTOM DATABASE
 
# Système de base de données avancée (et flexible)
# Réalisé par Nuki (sur inspiration du travail de Avygeil et Grim)
 
# Produit deux bases de données, une statique et une dynamique
# Mappe le contenu de la base de données originale de RM
 
# (Les tables de la base de données sont potentiellement statiquement typées)
#==============================================================================
=begin 
 
# MIT License
 
Copyright (c) 2013-2015 xvw
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
 
=end # MIT License
#==============================================================================
# ** Object
#------------------------------------------------------------------------------
#  Ajouts des métiers de conversions
#==============================================================================
 
class Object
  #--------------------------------------------------------------------------
  # * Conversion polymorphe (ne fait rien)
  #--------------------------------------------------------------------------
  def nothing; self; end
  alias :noth :nothing
  #--------------------------------------------------------------------------
  # * Conversion magique en booléen
  #--------------------------------------------------------------------------
  def db_cast_boolean
    return self if self.is_a?(TrueClass) || self.is_a?(FalseClass)
    return false unless self.respond_to?(:to_s)
    value = begin !!eval(self.to_s)
      rescue Exception => exc
        false
      end
  end
  alias :ptbo :db_cast_boolean
end
 
#==============================================================================
# ** Types
#------------------------------------------------------------------------------
#  Proposition d'un système de type minimaliste
#==============================================================================
 
module Types
 
  #--------------------------------------------------------------------------
  # * Singleton
  #--------------------------------------------------------------------------
  class << self
    #--------------------------------------------------------------------------
    # * Construit un type
    #--------------------------------------------------------------------------
    def make(type)
      return CommonDB::TYPES.find{|t|t.match(type)} if type.is_a?(Symbol)
      if type.is_a?(Array)
        return Types::Complex.new(:list, (make(type[1])))
      end
    end
    #--------------------------------------------------------------------------
    # * Inférence d'un type
    #--------------------------------------------------------------------------
    def inference(value)
      return :integer   if value.is_a?(Fixnum)
      return :float     if value.is_a?(Float)
      return :string    if value.is_a?(String)
      return :boolean   if value.is_a?(FalseClass) || value.is_a?(TrueClass)
      if value.is_a?(Array)
        v = value.compact
        return [:list, :poly] if v.length == 0 
        t = inference(v.first)
        return [:list, t] if v.all?{|x| inference(x) == t}
        return [:list, :poly]
      end
      return :poly
    end
  end
 
  #==============================================================================
  # ** Abstract
  #------------------------------------------------------------------------------
  #  Représentation abstraite d'un type
  #==============================================================================
  
  class Abstract
    #--------------------------------------------------------------------------
    # * Variables d'instances
    #--------------------------------------------------------------------------
    attr_accessor :coersion
    attr_accessor :name
    attr_accessor :names
    #--------------------------------------------------------------------------
    # * Constructeur
    #--------------------------------------------------------------------------
    def initialize(name, names, coer)
      @name     = name
      @names    = names 
      coersion  = coer
      if coer.is_a?(Symbol)
        coersion = Proc.new {|x| x.send(coer)}
      end
      @coersion = coersion
    end
    #--------------------------------------------------------------------------
    # * Produit une conversion
    #--------------------------------------------------------------------------
    def cast(x)
      self.coersion.call(x)
    end
    #--------------------------------------------------------------------------
    # * Vérifie qu'un nom correspond au type
    #--------------------------------------------------------------------------
    def match(label)
      return true if label.to_sym ==  @name.to_sym
      return @names.include?(label)
    end
  end
 
  #==============================================================================
  # ** Simple
  #------------------------------------------------------------------------------
  #  Représentation concrète d'un type simple
  #==============================================================================
 
  class Simple < Abstract
    #--------------------------------------------------------------------------
    # * Variables d'instances
    #--------------------------------------------------------------------------
    attr_accessor :is_rgss
    #--------------------------------------------------------------------------
    # * Constructeur
    #--------------------------------------------------------------------------
    def initialize(name, names, coer, rgss = false)
      super(name, names, coer)
      @is_rgss = rgss
    end
    alias :rgss? :is_rgss
  end
 
  #==============================================================================
  # ** Complex
  #------------------------------------------------------------------------------
  #  Représentation concrète d'un type avec subtype
  #==============================================================================
 
  class Complex < Abstract
    #--------------------------------------------------------------------------
    # * Variables d'instances
    #--------------------------------------------------------------------------
    attr_accessor :subtype
    #--------------------------------------------------------------------------
    # * Constructeur
    #--------------------------------------------------------------------------
    def initialize(name, subtype)
      @subtype = subtype
      coersion = ->(subtype,x){x.collect{|y|subtype.cast(y)}}
      super(name, [], coersion.curry.call(@subtype))
    end
  end
 
end 
 
#==============================================================================
# ** CommonDB
#------------------------------------------------------------------------------
#  Fonctionnalités communes
#==============================================================================
 
module CommonDB
  #--------------------------------------------------------------------------
  # * Configuration
  #   Définition du préfixe des tables de la base de données originale
  #--------------------------------------------------------------------------
  RGSS_PREFIX = "VXACE_"
  #--------------------------------------------------------------------------
  # * Micro Structures
  #--------------------------------------------------------------------------
  EmbedData = Struct.new(:name, :const, :container)
  #--------------------------------------------------------------------------
  # * Information de typage
  #--------------------------------------------------------------------------
  TYPES = [
    Types::Simple.new(:integer,   [:int, :integer, :natural, :fixnum],    :to_i),
    Types::Simple.new(:float,     [:float, :double, :real, :numeric],     :to_f),
    Types::Simple.new(:string,    [:string, :text, :raw],                 :to_s),
    Types::Simple.new(:boolean,   [:bool, :boolean, :switch],             :ptbo),
    Types::Simple.new(:poly,      [:poly, :polymorphic, :script, :rgss],  :noth),
    # Types spéciaux (issu du RGSS)
    Types::Simple.new(:actor,     [:actor, :actors, :heroes, :people],    :to_i, true),
    Types::Simple.new(:map,       [:map, :maps, :game_map, :gamemap],     :to_i, true),
    Types::Simple.new(:klass,     [:klass, :actor_type, :classes, :klasses],:to_i, true),
    Types::Simple.new(:skill,     [:kill, :skills, :jutsu],               :to_i, true),
    Types::Simple.new(:item,      [:item, :items, :usable_item],          :to_i, true),
    Types::Simple.new(:weapon,    [:weapon, :weapons],                    :to_i, true),
    Types::Simple.new(:armor,     [:armor, :armors],                      :to_i, true),
    Types::Simple.new(:enemy,     [:enemy, :enemies, :opposant],          :to_i, true),
    Types::Simple.new(:troop,     [:troop, :group, :troops],              :to_i, true),
    Types::Simple.new(:state,     [:state, :statement, :states],          :to_i, true),
    Types::Simple.new(:animtation,[:animtation, :anim],                   :to_i, true),
    Types::Simple.new(:tileset,   [:tileset, :tilesets, :tile, :tiles],   :to_i, true),
    Types::Simple.new(:mapinfo,   [:mapinfo, :mapinfos, :infomap],        :to_i, true)
  ]
  #--------------------------------------------------------------------------
  # * Structures embarquables
  #--------------------------------------------------------------------------
  RGSS_EMBEDABLE = [
    EmbedData.new(:actor,       RPG::Actor,       load_data("Data/Actors.rvdata2")),
    EmbedData.new(:klass,       RPG::Class,       load_data("Data/Classes.rvdata2")),
    EmbedData.new(:skill,       RPG::Skill,       load_data("Data/Skills.rvdata2")),
    EmbedData.new(:item,        RPG::Item,        load_data("Data/Items.rvdata2")),
    EmbedData.new(:weapon,      RPG::Weapon,      load_data("Data/Weapons.rvdata2")),
    EmbedData.new(:armor,       RPG::Armor,       load_data("Data/Armors.rvdata2")),
    EmbedData.new(:enemy,       RPG::Enemy,       load_data("Data/Enemies.rvdata2")),
    EmbedData.new(:troop,       RPG::Troop,       load_data("Data/Troops.rvdata2")),
    EmbedData.new(:state,       RPG::State,       load_data("Data/States.rvdata2")),
    EmbedData.new(:animtation,  RPG::Animation,   load_data("Data/Animations.rvdata2")),
    EmbedData.new(:tileset,     RPG::Tileset,     load_data("Data/Tilesets.rvdata2")),
    EmbedData.new(:mapinfo,     RPG::MapInfo,     load_data("Data/MapInfos.rvdata2")),
  ]
  RGSS_TYPES = [
    :actor, :map, :klass, :item, :weapon, :armor, :enemy, :troop,
    :state, :animtation, :tileset, :mapinfo, :skills
  ]
  #--------------------------------------------------------------------------
  # * Singleton
  #--------------------------------------------------------------------------
  class << self
    #--------------------------------------------------------------------------
    # * Accès à une ressource du RGSS
    #--------------------------------------------------------------------------
    def rgss_access(data, id)
      return load_data(sprintf("Data/Map%03d.rvdata2", id)) if data == :map
      ctn = RGSS_EMBEDABLE.find{|d|d.name == data}
      raise(RuntimeError, "Container invalide") unless ctn
      ctn.container[id]
    end
  end
 
  #==============================================================================
  # ** Table
  #------------------------------------------------------------------------------
  #  Représentation générique d'une table
  #==============================================================================
 
  class Table
    #--------------------------------------------------------------------------
    # * Singleton
    #--------------------------------------------------------------------------
    class << self
      #--------------------------------------------------------------------------
      # * Variables d'instances 
      #--------------------------------------------------------------------------
      attr_accessor :fields
      attr_accessor :classname
      attr_accessor :records
      attr_reader   :primary_key
      alias :schema :fields
      #--------------------------------------------------------------------------
      # * Heritage des vues
      #--------------------------------------------------------------------------
      def inherit(klass)
        unless klass.respond_to?(:schema)
          raise(ArgumentError, "La classe n'est pas une table")
        end
        klass.schema.each do |field, type|
          if type.is_a?(Symbol)
            self.send(type, field)
          else
            self.send(type[0], type[1], field)
          end
        end
        define_primary_key (klass.primary_key)
      end
      #--------------------------------------------------------------------------
      # * Insertion
      #--------------------------------------------------------------------------
      def insert(*args); self.new(*args); end
      #--------------------------------------------------------------------------
      # * Construction d'un champ typé et nommé
      #--------------------------------------------------------------------------
      def handle_field(type, name)
        @records    ||= Hash.new
        @classname  ||= self.to_s.to_sym
        @fields     ||= Hash.new
        @fields[name] = type
        self.instance_variable_set("@#{name}".to_sym, nil)
        if RGSS_TYPES.include?(type)
          accessor = Proc.new do
            instance_var = self.instance_variable_get("@#{name}".to_sym)
            CommonDB.rgss_access(type, instance_var) if instance_var
          end
          self.send(:define_method, name.to_sym, &accessor)
        else
          self.send(:attr_reader, name.to_sym)
        end
        self.send(:attr_writer, name.to_sym)
        return name
      end
      #--------------------------------------------------------------------------
      # * Embarque une liste
      #--------------------------------------------------------------------------
      def list(subtype, name)
        return self.handle_field([:list, subtype], name) if subtype.is_a?(Symbol)
        return self.handle_field(subtype, name)
      end
      #--------------------------------------------------------------------------
      # * Etablit la clé primaire
      #--------------------------------------------------------------------------
      def define_primary_key(key)
        if !@fields.has_key?(key)
          raise(ArgumentError, "Le champ n'existe pas")
        elsif RGSS_TYPES.include?(@fields[key])
          raise(ArgumentError, "Les champs RGSS ne peuvent être des primary_key") 
        else
          @primary_key = key
        end
      end
      alias :pk         :define_primary_key
      alias :define_pk  :define_primary_key
      #--------------------------------------------------------------------------
      # * Enumerable
      #--------------------------------------------------------------------------
      def length; @records.length; end
      def [](prk); @records[prk]; end
      def each(&block); @records.each(&block); end
      alias   :count  :length
      alias   :size   :length
      alias   :all    :records
      include Enumerable
      #--------------------------------------------------------------------------
      # * Construction des champs par types (et alias)
      #--------------------------------------------------------------------------
      TYPES.each do |type|
        self.send(:define_method, type.name, &->(x){handle_field(type.name, x)})
        type.names.select{|u|u != type.name}.each do |name|
          self.send(:alias_method, name, type.name)
        end
      end 
    end # == Fin du Singleton de Table ==
    #--------------------------------------------------------------------------
    # * Initialize souple
    #--------------------------------------------------------------------------
    def initialize(*args)
      self.class.records  ||= hash.new
      if args.length != self.class.fields.length
        msg = "#{self.class.classname}:
          #{args.length} donnés, #{self.class.fields.length} requis"
        raise(ArgumentError, msg) 
      end
      arr_fields = self.class.fields.to_a
      (0...args.length).each do |i|
        current     = args[i]
        name, typen = *arr_fields[i]
        type        = Types.make(typen)
        value       = type.cast(current)
        self.instance_variable_set("@#{name}".to_sym, value)
        index = self.send(self.class.primary_key)
        self.class.records[index] = self
      end
    end
  end # == Fin de Table ==
end # == Fin du module CommonDB ==
 
#==============================================================================
# ** Static
#------------------------------------------------------------------------------
#  Composante relative au traitement de la base de données statique
#==============================================================================
 
module Static 
  #--------------------------------------------------------------------------
  # * Singleton
  #--------------------------------------------------------------------------
  class << self
    #--------------------------------------------------------------------------
    # * Variables d'instances
    #--------------------------------------------------------------------------
    attr_accessor :tables
    Static.tables ||= Hash.new
    private :tables=
    #--------------------------------------------------------------------------
    # * Accès rapide à une table
    #--------------------------------------------------------------------------
    def method_missing(*args)
      name = args[0]
      return Static.tables[name] if Static.tables[name]
      super(*args)
    end 
  end # == Fin du Singleton ==
 
  #==============================================================================
  # ** Table
  #------------------------------------------------------------------------------
  #  Table de la base de données statique
  #==============================================================================
  class Table < CommonDB::Table
    #--------------------------------------------------------------------------
    # * Singleton
    #--------------------------------------------------------------------------
    class << self
      #--------------------------------------------------------------------------
      # * Construit un champ en fonction d'une variable d'instance
      #--------------------------------------------------------------------------
      def dynamic_from_ivar(name, value)
        sym_name = name[1 .. -1].to_sym
        subtype = Types.inference(value)
        return handle_field(subtype, sym_name) if subtype.is_a?(Symbol)
        return list(subtype, sym_name) if subtype.is_a?(Array) && subtype.length == 2 
        return (poly sym_name)
      end
      #--------------------------------------------------------------------------
      # * Etablit la clé primaire
      #--------------------------------------------------------------------------
      def define_primary_key(key)
        super(key)
        Static.tables[self.classname] ||= self
      end
      alias :pk         :define_primary_key
      alias :define_pk  :define_primary_key
    end
  end # == Fin de Table ==
 
  #--------------------------------------------------------------------------
  # * Mapping de la base de données originale
  #--------------------------------------------------------------------------
  CommonDB::RGSS_EMBEDABLE.select{|g|![:map,:mapinfo].include?(g.name)}.each do
    |rgss_struct|
    # mappingb
    const   = rgss_struct.const
    datas   = rgss_struct.container
    datas   = datas.compact if datas.respond_to?(:compact)
    datas   ||= []
    prefix  = CommonDB::RGSS_PREFIX
    name  = "#{prefix}#{rgss_struct.name.upcase}".to_sym
    if datas.length > 0 
      elt = datas.max{|e| e.instance_variables.length}
      temp_class = Class.new(Static::Table) do 
        @classname = name
        elt.instance_variables.each do |value|
          ivar = elt.instance_variable_get(value)
          dynamic_from_ivar(value, ivar)
        end
        define_pk :id
      end
      storage = Object.const_set(name, temp_class)
      # remplissage
      datas.each do |r| 
        entries = Array.new
        storage.fields.each do |iv, t|
          val = r.instance_variable_get("@#{iv}")
          entries << val
        end
        storage.insert(*entries)
      end
    end 
  end # == Fin du mapping statique de la BDD ==
  #--------------------------------------------------------------------------
  # * Cas particulier des maps
  #--------------------------------------------------------------------------
  rgss_mapinfo  = RPG::MapInfo.new
  rgss_map      = RPG::Map.new(100, 100)
  name          = "#{CommonDB::RGSS_PREFIX}MAP".to_sym
  temp_class    = Class.new(Static::Table) do
    @classname = name
    define_pk integer :id
    [rgss_mapinfo,rgss_map].each do |elt|
      elt.instance_variables.each do |value|
        ivar = elt.instance_variable_get(value)
        dynamic_from_ivar(value, ivar)
      end
    end
  end # == Fin du mapping des maps ==
  storage = Object.const_set(name, temp_class)
  # Remplissage
  mapinfos = CommonDB::RGSS_EMBEDABLE.find{|d|d.name == :mapinfo}
  mapinfos.container.each do |i, v|
    entries = [i]
    [v, load_data(sprintf("Data/Map%03d.rvdata2", i))].each do |r|
      r.instance_variables.each do |iv|
        entries << r.instance_variable_get(iv)
      end
    end
    storage.insert(*entries)
  end
 
end # == Fin de Static ==
 
#==============================================================================
# ** Dynamic
#------------------------------------------------------------------------------
#  Composante relative au traitement de la base de données dynamique
#==============================================================================
 
module Dynamic
 
  #--------------------------------------------------------------------------
  # * Singleton
  #--------------------------------------------------------------------------
  class << self
    #--------------------------------------------------------------------------
    # * Variables d'instances
    #--------------------------------------------------------------------------
    attr_accessor :tables
    Dynamic.tables  ||= Hash.new
    #--------------------------------------------------------------------------
    # * Convertit la base de données en hash
    #--------------------------------------------------------------------------
    def to_hash
      data = Hash.new
      Dynamic.tables.each do |name, value|
        data[name] = Hash.new
        value.all.each do |primary, instance|
          data[name][primary] = instance.to_array
        end
      end
      data
    end
    #--------------------------------------------------------------------------
    # * Accès rapide à une table
    #--------------------------------------------------------------------------
    def method_missing(*args)
      name = args[0]
      return Dynamic.tables[name] if Dynamic.tables[name]
      super(*args)
    end 
  end # == Fin du Singleton ==
 
  #==============================================================================
  # ** Table
  #------------------------------------------------------------------------------
  #  Table de la base de données statique
  #==============================================================================
  class Table < CommonDB::Table
    #--------------------------------------------------------------------------
    # * Singleton
    #--------------------------------------------------------------------------
    class << self
      #--------------------------------------------------------------------------
      # * Supprime un champ
      #--------------------------------------------------------------------------
      def delete(pkvalue)
        self.records.delete(pkvalue)
      end
      #--------------------------------------------------------------------------
      # * Supprime selon un prédicat
      #--------------------------------------------------------------------------
      def delete_if(&block)
        self.records.delete_if(&block)
      end
      #--------------------------------------------------------------------------
      # * Vide la table
      #--------------------------------------------------------------------------
      def drop
        self.records = Hash.new
      end
      #--------------------------------------------------------------------------
      # * Etablit la clé primaire
      #--------------------------------------------------------------------------
      def define_primary_key(key)
        super(key)
        Dynamic.tables[self.classname] ||= self
      end
      alias :pk         :define_primary_key
      alias :define_pk  :define_primary_key
    end
    #--------------------------------------------------------------------------
    # * Convertit une instance en tableau
    #--------------------------------------------------------------------------
    def to_array
      data = Array.new
      self.class.fields.each do |name, type|
        data << self.instance_variable_get("@#{name}".to_sym)
      end
      data
    end
  end
 
end # == Fin de Dynamic ==
 
#==============================================================================
# ** DataManager
#------------------------------------------------------------------------------
#  Persistance des données
#==============================================================================
 
module DataManager
  #--------------------------------------------------------------------------
  # * Singleton
  #--------------------------------------------------------------------------
  class << self
    #--------------------------------------------------------------------------
    # * Alias
    #--------------------------------------------------------------------------
    alias :db_make_save_contents    :make_save_contents
    alias :db_extract_save_contents :extract_save_contents
    alias :db_create_game_objects   :create_game_objects
    #--------------------------------------------------------------------------
    # * Create Game Objects
    #--------------------------------------------------------------------------
    def create_game_objects
      db_create_game_objects
      Dynamic.tables.each do |k, t|
        t.drop
      end
    end
    #--------------------------------------------------------------------------
    # * Ajout de sauvegarde de la base de données
    #--------------------------------------------------------------------------
    def make_save_contents
      contents = db_make_save_contents
      contents[:database] = Dynamic.to_hash
      contents
    end
    #--------------------------------------------------------------------------
    # * Ajout du chargement de la base de données
    #--------------------------------------------------------------------------
    def extract_save_contents(contents)
      db_extract_save_contents(contents)
      contents[:database].each do |k, f|
        f.each do |key, a|
          Object.const_get(k).insert(*a)
        end
      end
    end
  end
end

Utilisation

Création d'une table

Il existe deux types de tables. Les tables statiques qui ne sont pas changeables en cours de jeu. En effet, elles représentent des données statiques. On peut créer de la structure que l'on désire et elles servent à représenter des données similaires à celles de la base de données classique de RPG Maker, des objets, des classes, des armes par exemple. Les tables dynamiques elles représentent des données qui changent en cours de route. Des inventaires par exemple.

Créer une table (statique ou dynamique)[/color]
La procédure de création d'une table est presque identique pour les deux types :

class Nom_de_la_table < Type::Table
        type :champ1
        type :champ2
        type :champ3
        define_primary_key :champ1
end

Par exemple, pour la création d'une table Quest, qui représentera des quêtes :

class Quest < Static::Table
        integer :id 
        string :name
        string :description
        integer :gold
        integer :exp
        define_primary_key :id
end

Voici une table de quête qui représente une quête selon un ID, un nom, une déscription, un gain d'or, d'expérience et dont la clé primaire est l'id.
La clé primaire permet l'indexation des enregistrements de la table, elle est obligatoire et doit être un champ existant. Il serait possible de compresser l'écriture de cette manière :

class Quest < Static::Table
        define_pk integer :id 
        string :name
        string :description
        integer :gold
        integer :exp
end

En effet, on peut appeller la fonction de définition de clé primaire directement sur un champ. Et elle possède plusieurs noms : define_primary_key, define_pk ou encore simplement pk.
Pour la version dynamique de cette table, on pourrait proposer :

class Game_Quest < Dynamic::Table
        pk integer :quest_id
        boolean :finished
end

Où la clé primaire serait l'id de la Quête représenté statiquement.
Chaque champ doit impérativement être typé pour qu'a chaque insertion, il y ait une conversion dans le bon type (si possible).

Survol des types possibles
Les types sont une petite coquetterie (mise en place par éthique et moral !) qui permettent plus de fiabilité dans la réalisation d'une base de données. Avant de se lancer dans la création d'une table, il est donc nécéssaire de bien réfléchir à son système de type.

* integer type qui représente les nombre entiers
Autre nom : int natural fixnum

* float type qui représente les nombre à virgule
Autre nom : double real numeric

* string type qui représente les textes
Autre nom : text raw

* boolean type qui représente les booléens (true ou false)
Autre nom : bool switch

* poly type qui une donnée RGSS quelconque (donc un affreux type qui peut prendre n'importe quel type... beurk)
Autre nom : polymorphic script rgss

Types issu du RGSS
Les types du RGSS sont un petit peu particulier, car il stocke juste l'ID d'un élément de la base de données originales et lorsque on les appellent, ils donnent l'objet Ruby s'y réferrant. (C'est un outil pratique pour faire des relations avec la base de données de RM de manière propre)

actor type qui représente un actor (un héros)
klass type qui représente les classes de personnages
item type qui représente les objets
weapon type qui représente les armes
armor type qui représente les armures
enemy type qui représente les enemis
troop type qui représente les groupes d'ennemis
state type qui représente les états
animation type qui représente les animations
tileset type qui représente les tileset
mapinfo type qui représente les infos de map
map type qui représente une map

Comme dit dans l'introduction de cette section, ces types permettent de faciliter l'accès à des données statique de RPG Maker. Ils ne peuvent pas être utilisés comme des clés primaires.

Le type particulier, la Liste
Il arrive parfois qu'un champ doive être une liste de données, pour ça il existe un constructeur de type qui prend une liste :

list :type, :nom : Il est aussi possible d'imbriquer les listes (de faire des listes de listes de listes d'entiers par exemple), mais pour ceux qui ne veulent pas s'embêter avec de la déduction de type, vous n'avez qu'a utiliser l'affreux type polymorphe.

Un dernier exemple pour la route :

# Une table super cheloue
class Table_Louche < Static::Table
        pk integer :id
        string :name
        string :nickname
        boolean :male
        list :integer, :parents_ids
        actor :heroes
end

Connaitre le schéma d'une table
InGame, il est possible de connaitre le schéma d'une table, sans devoir aller le lire dans l'éditeur de script. En effet, il suffit de faire : Table.schema, où Table est le nom de la table. Par exemple, pour notre exemple précédent, il faudrait faire Table_Louche.schema.

Remplir la Base de données

Généralement, la base de données statique ne se remplit que dans un script vierge en dessous du mapping (ou juste en dessous du mapping) et aucune insertion n'est effectuée (car elles ne seraient pas sauvegardées). Quand à la base de données dynamique, il est possible d'effectuer des sauvegarde à tout moment. Pour les deux types de table, la sémantique est identique. Il suffit de faire :

1	Ma_Table.insert(arguments séparés par des virgules)

Il faut obligatoirement que les insertions soient effectuées dans le même ordre que celle de la déclaration des champs dans le schéma de la base de données. Voici par exemple des enregistrement (dans la table Quest créée précédemment) qui sont valides :

# Rappel de la classe Quest
class Quest < Static::Table
        integer :id 
        string :name
        string :description
        integer :gold
        integer :exp
        define_primary_key :id
end
 
# Insertion
Quest.insert(1, "Tuer les slimes", "Il faut tuer 10 slimes", 100, 200)
Quest.insert(2, "Quete du chat", "Il faut trouver le chat de mamy", 10, 20)
Quest.insert(3, "Potion magique", "Faire une potion magique", 100, 200)

Pour représenter des inventaires, il faut suffit de créer une table dynamique et de faire des insertion dedans au fil du jeu

Accès aux champs

Pour cette partie, une connaissance des tableaux/hash est fortemment conseillé

C'est bien mignon de pouvoir faire des insertion, mais si l'on ne peut récupérer des informations d'une table, ça ne sert pas à grand chose :

Nombre d'enregistrement dans une table
Il est très facile de connaitre le nombre d'enregistrement d'une table, il suffit d'utiliser la méthode count sur cette table. Par exemple, pour avoir le nombre de quêtes sauvées : Quest.count.

Accéder à un record en particulier
Pour cela, il suffit de faire : Table[Sa clé primaire]. Par exemple, Quest[1] renverra l'objet Quest (1, "Tuer les slimes", "Il faut tuer 10 slimes", 100, 200). De même, pour accéder à un champ, il suffit de le faire suivre du champ. Si je veux le nom de la Quête 1, je n'ai qu'a faire Quest[1].name.

Itération sur une table
Il est possible d'effectuer une itération sur une table, au moyen de Table.each{|pk, record| faite ce que vous voulez ici}, par exemple, pour afficher le nom de toutes les quêtes via leur clé primaire, il suffit de faire :

1
2
3

Quest.each do |pk, record|
        p "#{pk} -> #{record.name}"
end

L'itération sur une table fonctionne comme l'itération sur un Hash, ou l'index est la clé primaire du record.

Renvoyer tous les records
Il suffit d'utiliser Table.all, par exemple : Quest.all renvoi tous les objets quests.

Cas particuliers dans le mode Dynamique

Comme il a été dit dans les sections précédentes, la base de données dynamique permet, a contrario de la base de données statique de tenir en compte les changements en cours de jeu. Il est donc possible de modifier les enregistrements. Ajouter/Supprimer/Editer des records. La procédure d'insertion est la même que pour la base de données statique. Mais elle peut être utilisée partout et sauvegarde les changements.
* Table.delete(Primary_key) Supprimera de la table le record correspondant à la clée primaire passée en argument.
* Table.delete_if{|pk, record| prédicat} Supprimera de la table tous les records correspondant au prédicat passé en argument.

Par exemple, pour supprimer toutes les quêtes (Game_Quest cette fois) dont l'or rapporté est superieur à 10 :
Game_Quest.delete_if{|pk, rec| Quest[rec.quest_id].gold > 10} (Il s'agit d'une requête composée qui va interroger la table statique Quest).

Pour la modification des champs, il suffit d'accèder au champ et d'en modifier la valeur. Démonstration :

Game_Quest[10].finished = true, la quête dynamique dont l'ID est 10 aura l'attribut finished mis à true. Rien de bien compliqué.
Mapping de la base de données standard

Histoire de faire profiter de la très agréable syntaxe du système de base de données à toutes les données RM, le script construit des tables (statiques) référentes à la base de données standard de RPG Maker. Elles sont préfixées de VXACE_ et leur nom est en majuscule :
VXACE_ACTOR
VXACE_CLASS
VXACE_SKILL
VXACE_ITEM
VXACE_WEAPON
VXACE_ARMOR
VXACE_ENEMY
VXACE_TROOP
VXACE_STATE
VXACE_ANIMATION
VXACE_TILESET
VXACE_MAP

Toutes ces tables sont disponnibles et ont peut leur appliquer les mêmes fonctions qu'aux tables statiques. Pour connaitre leur champ, il suffit de se rendre dans la documentation du module RPG de RPG Maker VX Ace. Leur type a été inféré intelligemment et donc les données sont typées (y comprit les listes).

Spécification de la table VXACE_MAP
Cette table est un peu particulière car elle fusionne les informations de MapInfo et Map. Il est donc possible d'accéder aux champs des deux structures via un seul record. Par exemple, obtenir les notes d'une carte revient à faire : VXACE_MAP[ID].note.

J'espère que vous y trouverez un intérêt. Bien à vous.