Apprendre


Vous êtes
nouveau sur
Oniromancie?

Visite guidée
du site


Découvrir
RPG Maker

RM 95
RM 2000/2003
RM XP
RM VX/VX Ace
RM MV/MZ

Apprendre
RPG Maker

Tutoriels
Guides
Making-of

Dans le
Forum

Section Entraide

Jeux: Ketsuro / Tutos: Réaliser un Platformer avec (...) / Tutos: Réaliser un Platformer avec (...) / Scripts: Quest System / Tutos: Créer son système de quêtes en (...) / Chat

Bienvenue
visiteur !




publicité RPG Maker!

Statistiques

Liste des
membres


Contact

Mentions légales

114 connectés actuellement

11221802 visiteurs
depuis l'ouverture

99 visiteurs
aujourd'hui



Barre de séparation

Partenaires

Indiexpo

Akademiya RPG Maker

Hellsoft

Planète Glutko

RPG Maker Détente

Guelnika & E-magination

Kingdom Ultimate

Tous nos partenaires

Devenir
partenaire



Custom Database

[Outil pour les scripteurs] Ce script ne fera rien en lui-même. Il s'agit d'une base de données personnalisable à partir de laquelle un scripteur peut construire de nouvelles données, par exemple pour la gestion de quêtes, téléportations, etc.

Script pour RPG Maker VX Ace
Ecrit par xvw (site de l'auteur)
Publié par xvw (lui envoyer un message privé)
Signaler un script cassé

❤ 0

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.


Portion de code : Tout sélectionner

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
# 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 :

Portion de code : Tout sélectionner

1
2
3
4
5
6
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 :

Portion de code : Tout sélectionner

1
2
3
4
5
6
7
8
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 :

Portion de code : Tout sélectionner

1
2
3
4
5
6
7
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 :

Portion de code : Tout sélectionner

1
2
3
4
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 :

Portion de code : Tout sélectionner

1
2
3
4
5
6
7
8
9
# 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 :

Portion de code : Tout sélectionner

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 :

Portion de code : Tout sélectionner

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 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 :

Portion de code : Tout sélectionner

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.



Aucun commentaire n'a été posté pour le moment.

Suite à de nombreux abus, le post en invités a été désactivé. Veuillez vous inscrire si vous souhaitez participer à la conversation.

Haut de page

Merci de ne pas reproduire le contenu de ce site sans autorisation.
Contacter l'équipe - Mentions légales

Plan du site

Communauté: Accueil | Forum | Chat | Commentaires | News | Flash-news | Screen de la semaine | Sorties | Tests | Gaming-Live | Interviews | Galerie | OST | Blogs | Recherche
Apprendre: Visite guidée | RPG Maker 95 | RPG Maker 2003 | RPG Maker XP | RPG Maker VX | RPG Maker MV | Tutoriels | Guides | Making-of
Télécharger: Programmes | Scripts | Ressources | Packs de ressources | Midis | Eléments séparés | Sprites
Jeux: Au hasard | Notre sélection | Sélection des membres | Tous les jeux | Jeux complets | Le cimetière | RPG Maker 95 | RPG Maker 2000 | RPG Maker 2003 | RPG Maker XP | RPG Maker VX | RPG Maker VX Ace | RPG Maker MV | Autres | Proposer
Ressources RPG Maker 2000/2003: Chipsets | Charsets | Panoramas | Backdrops | Facesets | Battle anims | Battle charsets | Monstres | Systems | Templates
Ressources RPG Maker XP: Tilesets | Autotiles | Characters | Battlers | Window skins | Icônes | Transitions | Fogs | Templates
Ressources RPG Maker VX: Tilesets | Charsets | Facesets | Systèmes
Ressources RPG Maker MV: Tilesets | Characters | Faces | Systèmes | Title | Battlebacks | Animations | SV/Ennemis
Archives: Palmarès | L'Annuaire | Livre d'or | Le Wiki | Divers