Voilà un super méga script qui permet d'étendre la base de données avec des fichiers textes :

Code: Tout sélectionner

#===============================================================================
# *** Database Management
#-------------------------------------------------------------------------------
# Auteur  : Åvygeil
#-------------------------------------------------------------------------------
# Ce script permet d'automatiser la création et la gestion de base de données
# à partir de fichiers texte sous un format de sérialisation spécial,
# DBSL (DataBase Serialization Language).
#===============================================================================
 
#===============================================================================
# ** Database
#-------------------------------------------------------------------------------
# Le module qui permet d'automatiquement créer les tables
# de la base de données, et les remplir.
#===============================================================================
module Database
   
  #-----------------------------------------------------------------------------
  # Chargement de la base de données de base.
  #-----------------------------------------------------------------------------
  Actor       = load_data("Data/Actors.rxdata")
  Class       = load_data("Data/Classes.rxdata")
  Skill       = load_data("Data/Skills.rxdata")
  Item        = load_data("Data/Items.rxdata")
  Weapon      = load_data("Data/Weapons.rxdata")
  Armor       = load_data("Data/Armors.rxdata")
  Enemy       = load_data("Data/Enemies.rxdata")
  Troop       = load_data("Data/Troops.rxdata")
  State       = load_data("Data/States.rxdata")
  Animation   = load_data("Data/Animations.rxdata")
  Tileset     = load_data("Data/Tilesets.rxdata")
  CommonEvent = load_data("Data/CommonEvents.rxdata")
  System      = load_data("Data/System.rxdata")
 
  #=============================================================================
  # ** Database::Table
  #-----------------------------------------------------------------------------
  # La classe Table donne une interface pour créer une classe correspondante.
  #=============================================================================
  class Table
   
    #===========================================================================
    # * Database::Table#initialize
    #     table_name  : nom de la table
    #     &block      : bloc de création des colonnes
    #---------------------------------------------------------------------------
    # La méthode initialize crée une nouvelle classe dans le module Database.
    #===========================================================================
    def initialize(table_name, &block)
      @columns = []
      @column_default_vals = []
      block.call(self)
      #-------------------------------------------------------------------------
      # Création de la classe Database::table_name
      #-------------------------------------------------------------------------
      class_table = ::Class.new
      # Constantes table_name::COLUMNS et table_name::COLUMN_DEFAULT_VALS
      class_table.const_set("COLUMNS", @columns)
      class_table.const_set("COLUMN_DEFAULT_VALS", @column_default_vals)
      class_table.class_eval{
        # Pour chaque colonne, on ajoute un accesseur
        for name in class_table.const_get("COLUMNS")
          attr_accessor name
        end
        # Constructeur des objets Database::table_name
        # Chaque champs de l'objet est mis sa valeur par défaut
        define_method("initialize") {
          columns = class_table.const_get("COLUMNS")
          column_default_vals = class_table.const_get("COLUMN_DEFAULT_VALS")
          for i in 0...columns.size
            instance_variable_set("@#{columns[i]}", column_default_vals[i])
          end
        }
        # Méthode qui renvoie la constante COLUMNS
        define_method("columns") {
          return class_table.const_get("COLUMNS")
        }
        # Database::table_name se comporte comme une table de base de données,
        # un objet Enumerable contenant une liste d'objets Database::table_name,
        # sur lequel on peut faire des requetes.
        class << self
          # Accesseur en écriture aux lignes de la table
          def rows=(rs)
            @rows = rs
          end
          # Objet Enumerable
          include Enumerable
          # Méthode each, qu itère sur les lignes de la table
          def each(&block)
            @rows.each(&block)
          end
        end
      }
      # On ajoute la classe créée au module Database.
      Database.const_set(table_name, class_table)
    end
   
    #===========================================================================
    # * Database::Table#column
    #     col_name  : nom de la colonne
    #     col_type  : type de la colonne (integer, string, boolean, array, hash)
    #---------------------------------------------------------------------------
    # Méthode d'ajout d'une colonne à la table.
    #===========================================================================
    def column(col_name, col_type, default_val = nil)
      @columns << col_name
      if default_val.nil?
        @column_default_vals << default_val(col_type)
      else
        @column_default_vals << default_val
      end
    end
   
    #===========================================================================
    # * Database::Table#default_val
    #     col_type  : type
    #---------------------------------------------------------------------------
    # Renvoie une valeur par défaut en fonction du type.
    #===========================================================================
    def default_val(col_type)
      case col_type
      when :integer
        return 0
      when :string
        return ""
      when :boolean
        return false
      when :array
        return []
      when :hash
        return {}
      else
        return nil
      end
    end
    private :default_val
   
  end
 
  #=============================================================================
  # * Database.create_table
  #     table_name  :
  #     &block      : bloc de création des colonnes
  #-----------------------------------------------------------------------------
  # Méthode de création et de remplissage d'une table de la base de données.
  #=============================================================================
  def self.create_table(table_name, &block)
    Table.new(table_name, &block)
    table = self.const_get(table_name)
    if $DEBUG
      Dir.mkdir("#{table_name} Data") rescue nil
      File.open("#{table_name} Data/template.dbsl", "w") do |file|
        file.puts(Serialization.dump(table.new))
      end
      data = []
      for dbsl_file in Dir["#{table_name} Data/*.dbsl"]
        File.open(dbsl_file, "r") do |file|
          obj = Serialization.load(file.read)
          data << obj
        end
      end
      File.open("Data/#{table_name}.rxdata", "wb") do |file|
        Marshal.dump(data, file)
      end
    end
    table.rows = load_data("Data/#{table_name}.rxdata")
  end
 
  #=============================================================================
  # ** Database::Serialization
  #-----------------------------------------------------------------------------
  # Ce module contient les méthodes qui permettent de sauver ou charger
  # des objets au format DBSL.
  #=============================================================================
  module Serialization
   
    #===========================================================================
    # * Database::Serialization.dump
    #     ruby_obj  : un objet Ruby
    #---------------------------------------------------------------------------
    # Renvoie une String représentant l'objet Ruby au format dbsl.
    #===========================================================================
    def self.dump(ruby_obj)
      s = "#{ruby_obj.class}
"
      for var in ruby_obj.columns
        s << "#{var}: #{ruby_obj.method(var).call.to_dbsl}
"
      end
      return s
    end
 
    #===========================================================================
    # * Database::Serialization.load
    #     dbsl_obj  : String représentant un "objet dbsl"
    #---------------------------------------------------------------------------
    # Récupère un objet Ruby à partir de sa description dbsl.
    #===========================================================================
    def self.load(dbsl_obj)
      lines = dbsl_obj.split("
")
      ruby_obj = eval(lines[0] + ".new")
      for line in lines[1..lines.size-1]
        expr = line.split(":")
        ruby_obj.method(expr[0]+"=").call(eval(expr[1]))
      end
      return ruby_obj
    end
   
  end
   
end

#===============================================================================
# ** Représentation DBSL des types de base
#===============================================================================

#===============================================================================
# * Nilclass
#===============================================================================
class NilClass
 
  def to_dbsl
    "nil"
  end
 
end

#===============================================================================
# * TrueClass
#===============================================================================
class TrueClass
 
  def to_dbsl
    "true"
  end
 
end

#===============================================================================
# * FalseClass
#===============================================================================
class FalseClass
 
  def to_dbsl
    "false"
  end
 
end

#===============================================================================
# * Numeric
#===============================================================================
class Numeric
 
  def to_dbsl
    to_s
  end
 
end

#===============================================================================
# * String
#===============================================================================
class String
 
  def to_dbsl
    ""#{to_s}""
  end
 
end

#===============================================================================
# * Symbol
#===============================================================================
class Symbol
 
  def to_dbsl
    ":#{to_s}"
  end
 
end

#===============================================================================
# * Array
#===============================================================================
class Array
 
  def to_dbsl
    s = "["
    if self.size != 0
      for v in self[0...self.size-1]
        s << (v.to_dbsl + ", ")
      end
      s << (self.last.to_dbsl)
    end
    s << "]"
    return s
  end
 
end

#===============================================================================
# * Hash
#===============================================================================
class Hash
 
  def to_dbsl
    s = "{"
    if self.size != 0
      for k in self.keys[0...self.size-1]
        s << ("#{k.to_dbsl} => #{self[k].to_dbsl}, ")
      end
      s << "#{self.keys.last.to_dbsl} => #{self[self.keys.last].to_dbsl}"
    end
    s << "}"
    return s
  end

end


1) Pour créer une nouvelle table :

Code: Tout sélectionner

Database.create_table("MaTable") { |t|
  t.column :champs1, :type1
  t.column :champs2, :type2
  # etc...
}


Cela va créer dans le répertoire du projet un dossier "MaTable Data", contenant un fichier "template.dbsl", qui n'est rien d'autre qu'un fichier texte ouvrable avec le bloc-note.

2) Pour ajouter une ligne dans ta table :
- tu vas dans le dossier "MaTable Data"
- tu copies/colles le template.dsbl
- tu ouvres le nouveau fichier et tu renseignes les champs

3) Pour récupérer des informations de ta table,
Par exemple récupérer le champs 2 à la ligne de champs 1 égal à 42 :

Code: Tout sélectionner

ligne = Database::MaTable.find { |ligne|
  ligne.champs1 == 42
}
champs2 = ligne.champs2


4) Important :
- Le programme sérialise les données des fichiers dbsl dans un fichier "MaTable.rxdata" dans le dossier "Data", fichier qui sera ensuite crypté lors du cryptage du jeu.
- Il est donc recommandé, pour garder la base de données secrètes, de déplacer le dossier "MaTable Data" autre part avant de crypter le jeu.