[RMXP] Advanced Input et Database Management - Avygeil

Bonjour ou bonsoir,

Avygeil m'a donné la permission de poster ici son Database Management, je poste le script et sur son utilisation.
Ce script n'étant que sur XP, ne comptez pas sur nous pour l'adapter sur VX ou VX.ace. Puis, je crois que Grim l'avait fait dans son Event Extender (ou un truc comme ça).

Lexique:

1 : Database Management : A quoi ça sert ?
2 : Super cool. Qu'est-ce qu'il faut pour l'utiliser ?
3 : Ouais, mais ça ne fonctionne pas...
4 : Bon je suis sûr que j'ai loupé un truc...
5 : Et pour utiliser les tables custom dans les scripts ?
6 : Tu veux nous dire autre chose ?

PS : ce sujet sera en plusieures parties pour faciliter la lecture et pour mieux s'y retrouver (et aussi parce que le message d'origine est trop long).

1 - Database Management : A quoi ça sert ?

Le Database Management permet, entre autre, à étendre la base de données de RMXP, et même de la contourner, pour faire quelque chose de plus spécifique, hors des limitations de la base de données de base.
Par exemple, vous voulez faire le jeu de carte de FF8, mais importer vos propres images ? Database Management peut le faire. Vous pourrez même mettre les valeurs que vous voulez dedans.
Vous voulez d'autres attributs en combat ? C'est aussi possible avec le Database Management.

2 - Super cool. Qu'est-ce qu'il faut pour l'utiliser ?

Tout d'abord, il faut insérer entre le Scene_debug et Main ce script-là. Il s'agit de l'Advanced Input (aussi d'Avygeil).

Code:: #===============================================================================
# *** Advanced Input
#-------------------------------------------------------------------------------
# Auteur : Åvygeil
#-------------------------------------------------------------------------------
# Ce script permet de gérer facilement les touches du clavier.
#===============================================================================

#===============================================================================
# ** Keyboard
#-------------------------------------------------------------------------------
# Ce module contient les constantes correspondant aux touches du clavier.
#===============================================================================
module Keyboard

#=============================================================================
# ** Key
#-----------------------------------------------------------------------------
# Cette classe modélise une combinaison de touches du clavier.
#=============================================================================
class Key

attr_reader :code # le code de la combinaison de touche

#===========================================================================
# * initialize
# code : le code de la touche
#===========================================================================
def initialize(code)
@code = code
end

#===========================================================================
# * &
# key : une autre combinaison de touches
#---------------------------------------------------------------------------
# Renvoie une combinaison de touches qui correspond
# à la touche self ET la touche key.
#===========================================================================
def &(key)
code = @code + key.code
return Key.new(code)
end

#===========================================================================
# * |
# key : une autre combinaison de touches
#---------------------------------------------------------------------------
# Renvoie une combinaison de touches qui correspond
# à la touche self OU la touche key.
#===========================================================================
def |(key)
code = []
for c1 in @code
for c2 in key.code
code << c1+c2
end
end
return Key.new(code)
end

end

#-----------------------------------------------------------------------------
# Définition des touches
#-----------------------------------------------------------------------------
BACK = Key.new([[0x08]])
TAB = Key.new([[0x09]])
ENTER = Key.new([[0x0D]])
SHIFT = Key.new([[0x10]])
ALT_GR = Key.new([[0x11]])
PAUSE = Key.new([[0x13]])
CAPS_LOCK = Key.new([[0x14]])
ESCAPE = Key.new([[0x1B]])
SPACE = Key.new([[0x20]])
PAGE_UP = Key.new([[0x21]])
PAGE_DOWN = Key.new([[0x22]])
PAGE_END = Key.new([[0x23]])
HOME = Key.new([[0x24]])
LEFT = Key.new([[0x25]])
UP = Key.new([[0x26]])
RIGHT = Key.new([[0x27]])
DOWN = Key.new([[0x28]])

PRINT_SCREEN = Key.new([[0x2C]])
INSERT = Key.new([[0x2D]])
DELETE = Key.new([[0x2E]])

A_GRAVE = Key.new([[0x30]])
AMPERSAND = Key.new([[0x31]])
E_ACUTE = Key.new([[0x32]])
DOUBLE_QUOTE = Key.new([[0x33]])
SIMPLE_QUOTE = Key.new([[0x34]])
OPENING_PARENTHESIS = Key.new([[0x35]])
DASH = Key.new([[0x36]])
E_GRAVE = Key.new([[0x37]])
UNDERSCORE = Key.new([[0x38]])
C_CEDIL = Key.new([[0x39]])

A = Key.new([[0x41]])
B = Key.new([[0x42]])
C = Key.new([[0x43]])
D = Key.new([[0x44]])
E = Key.new([[0x45]])
F = Key.new([[0x46]])
G = Key.new([[0x47]])
H = Key.new([[0x48]])
I = Key.new([[0x49]])
J = Key.new([[0x4A]])
K = Key.new([[0x4B]])
L = Key.new([[0x4C]])
M = Key.new([[0x4D]])
N = Key.new([[0x4E]])
O = Key.new([[0x4F]])
P = Key.new([[0x50]])
Q = Key.new([[0x51]])
R = Key.new([[0x52]])
S = Key.new([[0x53]])
T = Key.new([[0x54]])
U = Key.new([[0x55]])
V = Key.new([[0x56]])
W = Key.new([[0x57]])
X = Key.new([[0x58]])
Y = Key.new([[0x59]])
Z = Key.new([[0x5A]])

WINDOWS = Key.new([[0x5B]])

F1 = Key.new([[0x70]])
F2 = Key.new([[0x71]])
F3 = Key.new([[0x72]])
F4 = Key.new([[0x73]])
F5 = Key.new([[0x74]])
F6 = Key.new([[0x75]])
F7 = Key.new([[0x76]])
F8 = Key.new([[0x77]])
F9 = Key.new([[0x78]])
F10 = Key.new([[0x79]])
F11 = Key.new([[0x7A]])
F12 = Key.new([[0x7B]])

LEFT_SHIFT = Key.new([[0xA0]])
RIGHT_SHIFT = Key.new([[0xA0]])
CTRL = Key.new([[0xA2]])
ALT = Key.new([[0xA4]])

DOLLAR = Key.new([[0xBA]])
COMMA = Key.new([[0xBC]])
EQUAL = Key.new([[0xBB]])
SEMICOLON = Key.new([[0xBE]])
COLON = Key.new([[0xBF]])
U_GRAVE = Key.new([[0xC0]])
CLOSING_PARENTHESIS = Key.new([[0xDB]])
ASTERISK = Key.new([[0xDC]])
CIRCUMFLEX = Key.new([[0xDD]])
SQUARE = Key.new([[0xDE]])
EXCLAMATION_MARK = Key.new([[0xDF]])
LESS_THAN = Key.new([[0xE2]])

NUM_LOCK = Key.new([[0x90]])

ZERO = Key.new([[0x60]])
ONE = Key.new([[0x61]])
TWO = Key.new([[0x62]])
THREE = Key.new([[0x63]])
FOUR = Key.new([[0x64]])
FIVE = Key.new([[0x65]])
SIX = Key.new([[0x66]])
SEVEN = Key.new([[0x67]])
EIGHT = Key.new([[0x68]])
NINE = Key.new([[0x69]])
PLUS = Key.new([[0x6B]])
MINUS = Key.new([[0x6D]])
TIMES = Key.new([[0x6A]])
DIVIDE = Key.new([[0x6F]])
DECIMAL = Key.new([[0x6E]])

#=============================================================================
# * self.update
#-----------------------------------------------------------------------------
# Mise à jour de l'état du clavier.
#=============================================================================
def self.update
if not @keyboard_init
@caps_lock = false
@num_lock = true
@grave = false
@trema = false
@circumflex = false
@keyboard_init = true
end
if Input.trigger?(CAPS_LOCK)
@caps_lock = !@caps_lock
end
if Input.trigger?(NUM_LOCK)
@num_lock = !@num_lock
end
if Input.trigger?(E_GRAVE) and alt_gr?
@grave = true
end
if Input.trigger?(CIRCUMFLEX)
caps? ? @trema = true : @circumflex = true
end
end

#=============================================================================
# * self.caps?
#-----------------------------------------------------------------------------
# Renvoie si le mode majuscule est enclenché.
#=============================================================================
def self.caps?
return Input.press?(SHIFT) ? !@caps_lock : @caps_lock
end

#=============================================================================
# * self.num_lock?
#-----------------------------------------------------------------------------
# Renvoie si le mode majuscule est enclenché.
#=============================================================================
def self.num_lock?
return @num_lock
end

#=============================================================================
# * self.alt_gr?
#-----------------------------------------------------------------------------
# Renvoie si le mode alternate graphics est enclenché.
#=============================================================================
def self.alt_gr?
return Input.press?(ALT_GR)
end

#=============================================================================
# * self.number
#-----------------------------------------------------------------------------
# Renvoie le chiffre pressé.
#=============================================================================
def self.number
if (caps? and Input.trigger?(A_GRAVE)) or
(num_lock? and Input.trigger?(ZERO))
return "0"
end
if (caps? and Input.trigger?(AMPERSAND)) or
(num_lock? and Input.trigger?(ONE))
return "1"
end
if (caps? and Input.trigger?(E_ACUTE)) or
(num_lock? and Input.trigger?(TWO))
return "2"
end
if (caps? and Input.trigger?(DOUBLE_QUOTE)) or
(num_lock? and Input.trigger?(THREE))
return "3"
end
if (caps? and Input.trigger?(SIMPLE_QUOTE)) or
(num_lock? and Input.trigger?(FOUR))
return "4"
end
if (caps? and Input.trigger?(OPENING_PARENTHESIS)) or
(num_lock? and Input.trigger?(FIVE))
return "5"
end
if (caps? and Input.trigger?(DASH)) or
(num_lock? and Input.trigger?(SIX))
return "6"
end
if (caps? and Input.trigger?(E_GRAVE)) or
(num_lock? and Input.trigger?(SEVEN))
return "7"
end
if (caps? and Input.trigger?(UNDERSCORE)) or
(num_lock? and Input.trigger?(EIGHT))
return "8"
end
if (caps? and Input.trigger?(C_CEDIL)) or
(num_lock? and Input.trigger?(NINE))
return "9"
end
if (not caps? and Input.trigger?(DASH)) or
(num_lock? and Input.trigger?(MINUS))
return "-"
end
return ""
end

#=============================================================================
# * self.letter
#-----------------------------------------------------------------------------
# Renvoie la lettre pressée.
#=============================================================================
def self.letter
if Input.trigger?(TAB)
return "" if alt_gr?
return " "
end
if Input.trigger?(SPACE)
return "" if alt_gr?
return " "
end
if Input.trigger?(A_GRAVE)
return "@" if alt_gr?
return "0" if caps?
return "à"
end
if Input.trigger?(AMPERSAND)
return "" if alt_gr?
return "1" if caps?
return "&"
end
if Input.trigger?(E_ACUTE)
return "" if alt_gr?
return "2" if caps?
return "é"
end
if Input.trigger?(DOUBLE_QUOTE)
return "#" if alt_gr?
return "3" if caps?
return "\""
end
if Input.trigger?(SIMPLE_QUOTE)
return "{" if alt_gr?
return "4" if caps?
return "'"
end
if Input.trigger?(OPENING_PARENTHESIS)
return "[" if alt_gr?
return "5" if caps?
return "("
end
if Input.trigger?(DASH)
return "|" if alt_gr?
return "6" if caps?
return "-"
end
if Input.trigger?(E_GRAVE)
return "" if alt_gr?
return "7" if caps?
return "è"
end
if Input.trigger?(UNDERSCORE)
return "\\" if alt_gr?
return "8" if caps?
return "_"
end
if Input.trigger?(C_CEDIL)
return "^" if alt_gr?
return "9" if caps?
return "ç"
end
if Input.trigger?(A)
return "" if alt_gr?
return "A" if caps?
if @grave
@grave = false
return "à"
end
if @trema
@trema = false
return "ä"
end
if @circumflex
@circumflex = false
return "â"
end
return "a"
end
if Input.trigger?(B)
return "" if alt_gr?
return "B" if caps?
return "b"
end
if Input.trigger?(C)
return "" if alt_gr?
return "C" if caps?
return "c"
end
if Input.trigger?(D)
return "" if alt_gr?
return "D" if caps?
return "d"
end
if Input.trigger?(E)
return "€" if alt_gr?
return "E" if caps?
if @grave
@grave = false
return "è"
end
if @trema
@trema = false
return "ë"
end
if @circumflex
@circumflex = false
return "ê"
end
return "e"
end
if Input.trigger?(F)
return "" if alt_gr?
return "F" if caps?
return "f"
end
if Input.trigger?(G)
return "" if alt_gr?
return "G" if caps?
return "g"
end
if Input.trigger?(H)
return "" if alt_gr?
return "H" if caps?
return "h"
end
if Input.trigger?(I)
return "" if alt_gr?
return "I" if caps?
if @grave
@grave = false
return "ì"
end
if @trema
@trema = false
return "ï"
end
if @circumflex
@circumflex = false
return "î"
end
return "i"
end
if Input.trigger?(J)
return "" if alt_gr?
return "J" if caps?
return "j"
end
if Input.trigger?(K)
return "" if alt_gr?
return "K" if caps?
return "k"
end
if Input.trigger?(L)
return "" if alt_gr?
return "L" if caps?
return "l"
end
if Input.trigger?(M)
return "" if alt_gr?
return "M" if caps?
return "m"
end
if Input.trigger?(N)
return "" if alt_gr?
return "N" if caps?
return "n"
end
if Input.trigger?(O)
return "" if alt_gr?
return "O" if caps?
if @grave
@grave = false
return "ò"
end
if @trema
@trema = false
return "ö"
end
if @circumflex
@circumflex = false
return "ô"
end
return "o"
end
if Input.trigger?(P)
return "" if alt_gr?
return "P" if caps?
return "p"
end
if Input.trigger?(Q)
return "" if alt_gr?
return "Q" if caps?
return "q"
end
if Input.trigger?(R)
return "" if alt_gr?
return "R" if caps?
return "r"
end
if Input.trigger?(S)
return "" if alt_gr?
return "S" if caps?
return "s"
end
if Input.trigger?(T)
return "" if alt_gr?
return "T" if caps?
return "t"
end
if Input.trigger?(U)
return "" if alt_gr?
return "U" if caps?
if @grave
@grave = false
return "ù"
end
if @trema
@trema = false
return "ü"
end
if @circumflex
@circumflex = false
return "û"
end
return "u"
end
if Input.trigger?(V)
return "" if alt_gr?
return "V" if caps?
return "v"
end
if Input.trigger?(W)
return "" if alt_gr?
return "W" if caps?
return "w"
end
if Input.trigger?(X)
return "" if alt_gr?
return "X" if caps?
return "x"
end
if Input.trigger?(Y)
return "" if alt_gr?
return "Y" if caps?
return "y"
end
if Input.trigger?(Z)
return "" if alt_gr?
return "Z" if caps?
return "z"
end
if Input.trigger?(DOLLAR)
return "¤" if alt_gr?
return "£" if caps?
return "$"
end
if Input.trigger?(COMMA)
return "" if alt_gr?
return "?" if caps?
return ","
end
if Input.trigger?(EQUAL)
return "}" if alt_gr?
return "+" if caps?
return "="
end
if Input.trigger?(SEMICOLON)
return "" if alt_gr?
return "." if caps?
return ";"
end
if Input.trigger?(COLON)
return "" if alt_gr?
return "/" if caps?
return ":"
end
if Input.trigger?(U_GRAVE)
return "" if alt_gr?
return "%" if caps?
return "ù"
end
if Input.trigger?(CLOSING_PARENTHESIS)
return "]" if alt_gr?
return "°" if caps?
return ")"
end
if Input.trigger?(ASTERISK)
return "" if alt_gr?
return "µ" if caps?
return "*"
end
if Input.trigger?(SQUARE)
return "" if alt_gr?
return "" if caps?
return "²"
end
if Input.trigger?(EXCLAMATION_MARK)
return "" if alt_gr?
return "§" if caps?
return "!"
end
if Input.trigger?(LESS_THAN)
return "" if alt_gr?
return ">" if caps?
return "<"
end
if num_lock?
if Input.trigger?(ZERO)
return "0"
end
if Input.trigger?(ONE)
return "1"
end
if Input.trigger?(TWO)
return "2"
end
if Input.trigger?(THREE)
return "3"
end
if Input.trigger?(FOUR)
return "4"
end
if Input.trigger?(FIVE)
return "5"
end
if Input.trigger?(SIX)
return "6"
end
if Input.trigger?(SEVEN)
return "7"
end
if Input.trigger?(EIGHT)
return "8"
end
if Input.trigger?(NINE)
return "9"
end
if Input.trigger?(PLUS)
return "+"
end
if Input.trigger?(MINUS)
return "-"
end
if Input.trigger?(TIMES)
return "*"
end
if Input.trigger?(DIVIDE)
return "/"
end
if Input.trigger?(DECIMAL)
return "."
end
end
return ""
end

end

#===============================================================================
# ** Input
#-------------------------------------------------------------------------------
# On redéfinit entièrement le module Input en se servant de la Win32API.
#===============================================================================
module Input

#-----------------------------------------------------------------------------
# Utilisation de la Win32API pour gérer les touches
#-----------------------------------------------------------------------------
@@GetKeyboardState = Win32API.new("user32","GetKeyboardState", ['p'],'i')
@@keyboard_state = Array.new(256, 0)
@@old_keyboard_state = Array.new(256, 0)

#=============================================================================
# * self.update
#-----------------------------------------------------------------------------
# Mise à jour de l'état des entrées
#=============================================================================
def self.update
for i in 0...@@keyboard_state.size
@@old_keyboard_state[i] = @@keyboard_state[i]
end
buf = 0.chr * 256
@@GetKeyboardState.call(buf)
@@keyboard_state = buf.unpack("C256")
Keyboard.update
end

#=============================================================================
# * self.trigger?
# key : touche
#-----------------------------------------------------------------------------
# Teste si on appuie une fois sur une touche
#=============================================================================
def self.trigger?(key)
for c1 in key.code
b2 = false
for c2 in c1
if (@@keyboard_state[c2] & 0b10000000 != 0 and
@@old_keyboard_state[c2] & 0b10000000 == 0)
b2 = true
end
end
if b2 == false
return false
end
end
return true
end

#=============================================================================
# * self.press?
# key : touche
#-----------------------------------------------------------------------------
# Teste si on appuie sur une touche de manière continue
#=============================================================================
def self.press?(key)
for c1 in key.code
b2 = false
for c2 in c1
if (@@keyboard_state[c2] & 0b10000000 != 0)
b2 = true
end
end
if b2 == false
return false
end
end
return true
end

#=============================================================================
# * self.repeat?
# key : touche
#-----------------------------------------------------------------------------
# Teste si on appuie sur une touche de manière répétée
#=============================================================================
def self.repeat?(key)
if self.trigger?(key)
@@count = 0
return true
end
if self.press?(key)
@@count = (@@count+1)%Graphics.frame_rate
return @@count == 0
end
return false
end

@@count = 0

#=============================================================================
# * self.dir4
#-----------------------------------------------------------------------------
# Teste 4 touches directionnelles
#=============================================================================
def self.dir4
return 2 if press?(Input::DOWN)
return 4 if press?(Input::LEFT)
return 6 if press?(Input::RIGHT)
return 8 if press?(Input::UP)
return 0
end

#=============================================================================
# * self.dir8
#-----------------------------------------------------------------------------
# Teste 8 touches directionnelles
#=============================================================================
def self.dir8
return 1 if press?(Input::DOWN) and press?(Input::LEFT)
return 3 if press?(Input::DOWN) and press?(Input::RIGHT)
return 7 if press?(Input::UP) and press?(Input::LEFT)
return 9 if press?(Input::UP) and press?(Input::RIGHT)
return dir4
end

#=============================================================================
# * self.basic_keys
#-----------------------------------------------------------------------------
# Renvoie un objet Hash qui associe un code de touche utilisé par RMXP
# à un objet Key standard défini dans le module Input
#=============================================================================
def self.basic_keys
{
2 => Input::DOWN,
4 => Input::LEFT,
6 => Input::RIGHT,
8 => Input::UP,
11 => Input::A,
12 => Input::B,
13 => Input::C,
14 => Input::X,
15 => Input::Y,
16 => Input::Z,
17 => Input::L,
18 => Input::R,
21 => Input::SHIFT,
22 => Input::CTRL,
23 => Input::ALT,
25 => Input::F5,
26 => Input::F6,
27 => Input::F7,
28 => Input::F8,
29 => Input::F9
}
end

end

#===============================================================================
# ** Interpreter
#-------------------------------------------------------------------------------
# On redéfinit les méthodes de gestion du clavier
# pour les commandes d'évènements
#===============================================================================
class Interpreter

#=============================================================================
# * input_button
#=============================================================================
def input_button
n = 0
Input.basic_keys.each do |code, key|
if Input.trigger?(key)
n = code
end
end
if n > 0
$game_variables[@button_input_variable_id] = n
$game_map.need_refresh = true
@button_input_variable_id = 0
end
end

#=============================================================================
# * command_111
#=============================================================================
def command_111
result = false
case @parameters[0]
when 0
result = ($game_switches[@parameters[1]] == (@parameters[2] == 0))
when 1
value1 = $game_variables[@parameters[1]]
if @parameters[2] == 0
value2 = @parameters[3]
else
value2 = $game_variables[@parameters[3]]
end
case @parameters[4]
when 0
result = (value1 == value2)
when 1
result = (value1 >= value2)
when 2
result = (value1 <= value2)
when 3
result = (value1 > value2)
when 4
result = (value1 < value2)
when 5
result = (value1 != value2)
end
when 2
if @event_id > 0
key = [$game_map.map_id, @event_id, @parameters[1]]
if @parameters[2] == 0
result = ($game_self_switches[key] == true)
else
result = ($game_self_switches[key] != true)
end
end
when 3
if $game_system.timer_working
sec = $game_system.timer / Graphics.frame_rate
if @parameters[2] == 0
result = (sec >= @parameters[1])
else
result = (sec <= @parameters[1])
end
end
when 4
actor = $game_actors[@parameters[1]]
if actor != nil
case @parameters[2]
when 0
result = ($game_party.actors.include?(actor))
when 1
result = (actor.name == @parameters[3])
when 2
result = (actor.skill_learn?(@parameters[3]))
when 3
result = (actor.weapon_id == @parameters[3])
when 4
result = (actor.armor1_id == @parameters[3] or
actor.armor2_id == @parameters[3] or
actor.armor3_id == @parameters[3])
when 5
result = (actor.state?(@parameters[3]))
end
end
when 5
enemy = $game_troop.enemies[@parameters[1]]
if enemy != nil
case @parameters[2]
when 0
result = (enemy.exist?)
when 1
result = (enemy.state?(@parameters[3]))
end
end
when 6
character = get_character(@parameters[1])
if character != nil
result = (character.direction == @parameters[2])
end
when 7
if @parameters[2] == 0
result = ($game_party.gold >= @parameters[1])
else
result = ($game_party.gold <= @parameters[1])
end
when 8
result = ($game_party.item_number(@parameters[1]) > 0)
when 9
result = ($game_party.weapon_number(@parameters[1]) > 0)
when 10
result = ($game_party.armor_number(@parameters[1]) > 0)
when 11
result = (Input.press?(Input.basic_keys[@parameters[1]]))
when 12
result = eval(@parameters[1])
end
@branch[@list[@index].indent] = result
if @branch[@list[@index].indent] == true
@branch.delete(@list[@index].indent)
return true
end
return command_skip
end

end

Juste dessous(toujours entre Scene_Debug et Main, mais dessous l'Advanced Input), insérez le Database Management.

Code:: #===============================================================================
# *** Database Management
#-------------------------------------------------------------------------------
# Auteur : Åvygeil
#-------------------------------------------------------------------------------
# Un script pour étendre facilement la base de données.
#===============================================================================

#===============================================================================
# ** Database
#===============================================================================
module Database

#=============================================================================
# ** Database::Type
#-----------------------------------------------------------------------------
# La super-classe de tous les types de la Database.
#=============================================================================
class Type

class << self

#=========================================================================
# * Database::Type.===
#=========================================================================
def ===(type)
type.ancestors.include?(self)
end

#=========================================================================
# * Database::Type.default_value
#=========================================================================
def default_value
nil
end

end

end

#=============================================================================
# ** Database::Boolean
#=============================================================================
class Boolean < Type

class << self

#=========================================================================
# * Database::Boolean.default_value
#=========================================================================
def default_value
true
end

end

end

#=============================================================================
# ** Database::Integer
#=============================================================================
class Integer < Type

class << self

#=========================================================================
# * Database::Integer.default_value
#=========================================================================
def default_value
0
end

end

end

#=============================================================================
# ** Database::String
#=============================================================================
class String < Type

class << self

#=========================================================================
# * Database::String.default_value
#=========================================================================
def default_value
""
end

end

end

#=============================================================================
# ** Database::File
#=============================================================================
class File < Type

class << self

attr_accessor :dir # le répertoire du fichier

#=========================================================================
# * Database::File.[]
# dir : le répertoire
#=========================================================================
def [](dir)
c = Class.new(Database::File)
c.dir = dir
return c
end

#=========================================================================
# * Database::File.default_value
#=========================================================================
def default_value
""
end

end

end

#=============================================================================
# ** Database::Table
#-----------------------------------------------------------------------------
# La super-classes des tables de RMXP et de l'utilisateurs.
#=============================================================================
class Table < Type

class << self

include Enumerable

attr_reader :rows # les lignes de la table

#=========================================================================
# * Database::Table.name
#-------------------------------------------------------------------------
# Renvoie le nom de la table.
#=========================================================================
alias database_name name
def name
return database_name.gsub("Database::", "")
end

#=========================================================================
# * Database::Table.load
#-------------------------------------------------------------------------
# Permet de charger la table.
#=========================================================================
def load
@rows = load_data("Data/#{self.name}.rxdata")
rescue
@rows = [nil]
end

#=========================================================================
# * Database::Table.[]
# id : index
#-------------------------------------------------------------------------
# Renvoie la ligne d'id id.
#=========================================================================
def [](id)
return @rows[id]
end

#=========================================================================
# * Database::Table.each
# &block : l'action à réaliser sur toutes les lignes
#-------------------------------------------------------------------------
# Rend la table Enumerable.
#=========================================================================
def each(&block)
@rows[1...@rows.length].each(&block)
end

#=========================================================================
# * Database::Table.size
#-------------------------------------------------------------------------
# Renvoie la taille de la table.
#=========================================================================
def size
return @rows.length
end

#=========================================================================
# * Database::Table.default_value
#=========================================================================
def default_value
0
end

end

end

#=============================================================================
# ** Database::CustomTable
#-----------------------------------------------------------------------------
# La super-classes des tables de l'utilisateurs.
#=============================================================================
class CustomTable < Table

#=============================================================================
# ** Database::CustomTable::Column
#=============================================================================
class Column

attr_reader :name # le nom de la colonne
attr_reader :type # le type de la colonne
attr_reader :default_value # la valeur par défaut de la colonne

#=========================================================================
# * initialize
# name : le nom de la colonne
# type : le type de la colonne
# options : les options de la colonne
#=========================================================================
def initialize(name, type, options)
@name = name
@type = type
@default_value = options[:default].nil? ? @type.default_value : options[:default]
end

end

class << self

attr_reader :columns # les colonnes

#=========================================================================
# * Database::CustomTable.add_column
# name : le nom de la colonne
# type : le type de la colonne
# options : les options de la colonne
#-------------------------------------------------------------------------
# Renvoie la taille de la table.
#=========================================================================
def add_column(name, type, options={})
@columns ||= []
@columns << Column.new(name, type, options)
attr_accessor name
end

#=========================================================================
# * Database::CustomTable.column
#-------------------------------------------------------------------------
# Forme raccourcie de add_column
#=========================================================================
alias column add_column

#=========================================================================
# * Database::CustomTable.new_row
#-------------------------------------------------------------------------
# Ajoute une nouvelle ligne à la table et la renvoie.
#=========================================================================
def new_row
row = self.new
for column in @columns
row.method("#{column.name}=").call(column.default_value)
end
row.id = self.size
@rows << row
return row
end

#=========================================================================
# * Database::CustomTable.delete_last_row
#-------------------------------------------------------------------------
# Supprime la dernière ligne de la table
#=========================================================================
def delete_last_row
return if @rows.size == 1
@rows.pop
end

#=========================================================================
# * Database::CustomTable.load
#-------------------------------------------------------------------------
# Permet de charger la table.
#=========================================================================
def load
super
for i in 1...@rows.size
@rows[i].copy_row(@rows[i])
end
end

#=========================================================================
# * Database::CustomTable.save
#-------------------------------------------------------------------------
# Sauve la table.
#=========================================================================
def save
::File.open("Data/#{self.name}.rxdata", 'wb') do |file|
Marshal.dump(@rows, file)
end
end

end

#=========================================================================
# * copy_row
# row : la ligne à copier
#-------------------------------------------------------------------------
# Copie les champs d'une autre ligne
#=========================================================================
def copy_row(row)
for column in row.type.columns
if column.name != :id
value = row.method("#{column.name}").call
value = value.nil? ? column.default_value : value
self.method("#{column.name}=").call(value)
end
end
end

end

@@tables = [] # les tables utilisateurs

#=============================================================================
# * Database.create_table
# table_name : le nom de la table
# &block : instructions de création
#-----------------------------------------------------------------------------
# Crée une table utilisateur.
#=============================================================================
def self.create_table(table_name, &block)
table = ::Class.new(self::CustomTable)
table.column :id, Database::Integer
table.column :name, Database::String, :default => "New row"
block.call(table)
self.const_set(table_name, table)
@@tables << table
table.load
end

#=============================================================================
# * Database.drop_table
# table_name : le nom de la table
#-----------------------------------------------------------------------------
# Supprime une table utilisateur.
#=============================================================================
def self.drop_table(table_name)
@@tables.delete_if { |table| table.name == table_name }
::File.delete("Data/#{table_name}.rxdata") rescue nil
end

#=============================================================================
# * Database.create_table_mimic
# table_name : le nom de la table
#-----------------------------------------------------------------------------
# Crée une table pour mapper la base de données RMXP.
#=============================================================================
def self.create_table_mimic(table_name)
table = ::Class.new(self::Table)
self.const_set(table_name, table)
table.load
end

#=============================================================================
# * Database.tables
#-----------------------------------------------------------------------------
# Renvoie la liste des tables utilisateurs.
#=============================================================================
def self.tables
@@tables
end

#=============================================================================
# * Database.save
#-----------------------------------------------------------------------------
# Sauve la base de données.
#=============================================================================
def self.save
for table in @@tables
table.save
end
end

#-----------------------------------------------------------------------------
# Mapping de la base de données RMXP.
#-----------------------------------------------------------------------------
create_table_mimic("Actors")
create_table_mimic("Classes")
create_table_mimic("Skills")
create_table_mimic("Items")
create_table_mimic("Weapons")
create_table_mimic("Armors")
create_table_mimic("Enemies")
create_table_mimic("Troops")
create_table_mimic("States")
create_table_mimic("Animations")
create_table_mimic("Tilesets")
create_table_mimic("CommonEvents")

end

Il vous faut aussi le Database Editor pour que vous puissiez éditer vous-même vos bases de données.

Code:: #===============================================================================
# *** Database Editor
#-------------------------------------------------------------------------------
# Auteur : Åvygeil
#-------------------------------------------------------------------------------
# Une Scene qui permet d'éditer les tables de l'utilisateur
# dans la base de données.
#===============================================================================

#===============================================================================
# ** Scene_Database
#===============================================================================
class Scene_Database

#=============================================================================
# ** Scene_Database::Window_Command
#-----------------------------------------------------------------------------
# Permet de commencer à éditer la base de données,
# de la sauver et de revenir sur la map.
#=============================================================================
class Window_Command < ::Window_Command

#===========================================================================
# * initialize
#===========================================================================
def initialize
super(100, ["Edit", "Save", "Quit"])
end

end

#=============================================================================
# ** Scene_Database::Window_Table
#-----------------------------------------------------------------------------
# Permet de sélectionner une table de la base de données.
#=============================================================================
class Window_Table < Window_Selectable

#===========================================================================
# * initialize
#===========================================================================
def initialize
super(100, 0, 200, 480)
@item_max = Database.tables.size
self.contents = Bitmap.new(width-32, @item_max * 32 + 32)
self.contents.font.name = $fontface
self.contents.font.size = $fontsize
@column_max = 1
refresh
self.active = false
self.index = -1
self.visible = true
end

#===========================================================================
# * refresh
#===========================================================================
def refresh
self.contents.clear
for i in 0...@item_max
rect = Rect.new(4, 32*i, self.contents.width-8, 32)
self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
self.contents.draw_text(rect, Database.tables[i].name)
end
end

end

#=============================================================================
# ** Scene_Database::Window_Row
#-----------------------------------------------------------------------------
# Permet de sélectionner une ligne d'une table.
#=============================================================================
class Window_Row < Window_Selectable

#===========================================================================
# * initialize
#===========================================================================
def initialize(table)
super(300, 0, 340, 480)
@table = table
@column_max = 1
refresh
self.active = false
self.index = -1
self.visible = false
end

#===========================================================================
# * value
#===========================================================================
def value
row = @table.rows[self.index+1]
return row ? row.id : 0
end

#===========================================================================
# * value=
#===========================================================================
def value=(id)
if id == 0
self.index = 0
else
self.index = id -1
end
end

#===========================================================================
# * refresh
#===========================================================================
def refresh
if self.contents != nil
self.contents.dispose
self.contents = nil
end
self.contents = Bitmap.new(width-32, @table.size * 32)
self.contents.font.name = $fontface
self.contents.font.size = $fontsize
@item_max = @table.size
for i in 1..@item_max
row = @table.rows[i]
text = row ? "#{row.id} - #{row.name}" : ""
rect = Rect.new(4, 32*(i-1), self.contents.width-8, 32)
self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
self.contents.draw_text(rect, text)
end
end

end

#=============================================================================
# ** Scene_Database::Window_Table
#-----------------------------------------------------------------------------
# Permet de sélectionner un champs d'une ligne.
#=============================================================================
class Window_Field < Window_Selectable

#===========================================================================
# * initialize
#===========================================================================
def initialize(row)
super(0, 0, 640, 480)
@row = row
@item_max = row.type.columns.size - 1
self.contents = Bitmap.new(width-32, @item_max * 32 + 32)
self.contents.font.name = $fontface
self.contents.font.size = $fontsize
@column_max = 1
refresh
self.active = true
self.index = 0
self.visible = true
end

#===========================================================================
# * refresh
#===========================================================================
def refresh
self.contents.clear
for i in 0...@item_max
rect = Rect.new(4, 32*i, self.contents.width-8, 32)
self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
column = @row.type.columns[i+1]
field = @row.method(column.name).call
column_type = column.type
case column_type
when Database::Table
id = field
if id == 0
self.contents.draw_text(rect, "#{column.name} : ")
else
name = column_type[field].name
self.contents.draw_text(rect, "#{column.name} : #{id} - #{name}")
end
else
self.contents.draw_text(rect, "#{column.name} : #{field}")
end
end
end

end

#=============================================================================
# ** Scene_Database::Window_Help
#=============================================================================
class Window_Help < Window_Base

#===========================================================================
# * initialize
#===========================================================================
def initialize
super(0, 320, 300, 160)
self.z = 3000
self.contents = Bitmap.new(width-32, height-32)
self.contents.font.name = $fontface
self.contents.font.size = $fontsize
self.visible = false
refresh
end

#===========================================================================
# * refresh
#===========================================================================
def refresh
self.contents.clear
self.contents.draw_text(4,00,300,32,"A : Add a new row")
self.contents.draw_text(4,32,300,32,"D : Delete the last row")
self.contents.draw_text(4,64,300,32,"N : Copy the selected row")
self.contents.draw_text(4,96,300,32,"V : Paste the copied row")
end

end

#=============================================================================
# * initialize
#=============================================================================
def initialize(table_index = -1, row_id = 0)
@table_index = table_index
@row_id = row_id
end

#=============================================================================
# * main
#=============================================================================
def main
@command_window = Window_Command.new
@table_window = Window_Table.new
@row_window = nil
@row_windows = []
@table_scenes = []
for table in Database.tables
@row_windows << Window_Row.new(table)
@table_scenes << Scene_Table(table)
end
@help_window = Window_Help.new
if @table_index != -1
@command_window.active = false
@table_window.active = true
@table_window.index = @table_index
end
if @row_id != 0
@table_window.active = false
@row_window = @row_windows[@table_window.index]
@row_window.active = true
@row_window.index = @row_id - 1
@row_window.visible = true
@help_window.visible = true
end
Graphics.transition
loop do
Graphics.update
Input.update
update
if $scene != self
break
end
end
Graphics.freeze
@command_window.dispose
@table_window.dispose
for row_window in @row_windows
row_window.dispose
end
@help_window.dispose
end

#=============================================================================
# * update
#=============================================================================
def update
@command_window.update
@table_window.update
@row_window.update if @row_window != nil
@help_window.update
if @command_window.active
update_command
return
end
if @table_window.active
update_table
return
end
if @row_window != nil and @row_window.active
update_row
return
end
end

#=============================================================================
# * update_command
#=============================================================================
def update_command
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
$scene = Scene_Map.new
return
end
if Input.trigger?(Input::C)
case @command_window.index
when 0
$game_system.se_play($data_system.decision_se)
@command_window.active = false
@table_window.active = true
@table_window.index = 0
when 1
$game_system.se_play($data_system.save_se)
Database.save
when 2
$game_system.se_play($data_system.cancel_se)
$scene = Scene_Map.new
end
return
end
end

#=============================================================================
# * update_table
#=============================================================================
def update_table
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
@table_window.active = false
@table_window.index = -1
@command_window.active = true
return
end
if Input.trigger?(Input::C)
table = Database.tables[@table_window.index]
unless table != nil
$game_system.se_play($data_system.buzzer_se)
return
end
$game_system.se_play($data_system.decision_se)
@table_window.active = false
@row_window = @row_windows[@table_window.index]
@row_window.active = true
@row_window.index = 0
@row_window.visible = true
@help_window.visible = true
return
end
end

#=============================================================================
# * update_row
#=============================================================================
def update_row
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
@row_window.active = false
@row_window.index = -1
@row_window.visible = false
@row_window = nil
@help_window.visible = false
@table_window.active = true
return
end
if Input.trigger?(Input::C)
row = Database.tables[@table_window.index][@row_window.index+1]
unless row != nil
$game_system.se_play($data_system.buzzer_se)
return
end
$game_system.se_play($data_system.decision_se)
$scene = @table_scenes[@table_window.index].new(row.id)
return
end
if Input.trigger?(Input::DATABASE_ADD_ROW)
$game_system.se_play($data_system.shop_se)
Database.tables[@table_window.index].new_row
@row_window.refresh
return
end
if Input.trigger?(Input::DATABASE_DELETE_ROW)
$game_system.se_play($data_system.cancel_se)
Database.tables[@table_window.index].delete_last_row
@row_window.refresh
return
end
if Input.trigger?(Input::DATABASE_COPY_ROW)
$game_system.se_play($data_system.decision_se)
@copy_row = Database.tables[@table_window.index][@row_window.index+1]
return
end
if Input.trigger?(Input::DATABASE_PASTE_ROW)
return if @copy_row == nil
$game_system.se_play($data_system.decision_se)
row = Database.tables[@table_window.index][@row_window.index+1]
row.copy_row(@copy_row)
@row_window.refresh
return
end
end

end

#===============================================================================
# ** Scene_Table
# table : une table
#-------------------------------------------------------------------------------
# Permet de créer dynamiquement la scène d'édition des lignes de la table.
#===============================================================================
def Scene_Table(table)

#=============================================================================
# ** La classe créée dynamiquement.
#=============================================================================
Class.new {

class << self
attr_accessor :table_index # l'indice de la table
end

self.table_index = Database.tables.index(table)

#===========================================================================
# * initialize
#===========================================================================
def initialize(row_id)
@table = Database.tables[self.class.table_index]
@row_id = row_id
end

#===========================================================================
# * main
#===========================================================================
def main
@row = @table[@row_id]
@field_window = Scene_Database::Window_Field.new(@row)
@value_windows = []
for i in 1...@table.columns.size
column_type = @table.columns[i].type
case column_type
when Database::Boolean
@value_windows << Window_BooleanField.new(0,0)
when Database::Integer
@value_windows << Window_IntegerField.new(0,0,640)
when Database::String
@value_windows << Window_TextField.new(0,0,640)
when Database::File
@value_windows << Window_FileChooser.new(0,0,640,column_type.dir)
when Database::Table
@value_windows << Scene_Database::Window_Row.new(column_type)
end
end
@value_window = nil
Graphics.transition
loop do
Graphics.update
Input.update
update
if $scene != self
break
end
end
Graphics.freeze
@field_window.dispose
for window in @value_windows
window.dispose
end
end

#===========================================================================
# * update
#===========================================================================
def update
@field_window.update
@value_window.update if @value_window != nil
if @field_window.active
update_field
return
end
if @value_window != nil
update_value
return
end
end

#===========================================================================
# * update_field
#===========================================================================
def update_field
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
$scene = Scene_Database.new(self.class.table_index, @row_id)
return
end
if Input.trigger?(Input::C)
column = @table.columns[@field_window.index+1]
value = @row.method(column.name).call
@field_window.active = false
@value_window = @value_windows[@field_window.index]
@value_window.z = 1000
@value_window.value = value
@value_window.refresh
@value_window.active = true
@value_window.visible = true
return
end
end

#===========================================================================
# * update_value
#===========================================================================
def update_value
if Input.trigger?(Keyboard::ESCAPE)
$game_system.se_play($data_system.cancel_se)
@value_window.active = false
@value_window.visible = false
@value_window = nil
@field_window.active = true
return
end
if Input.trigger?(Keyboard::ENTER)
$game_system.se_play($data_system.decision_se)
value = @value_window.value
@value_window.active = false
@value_window.visible = false
@value_window = nil
column = @table.columns[@field_window.index+1]
@row.method("#{column.name}=").call(value)
@field_window.refresh
@field_window.active = true
return
end
end

}
end

#===============================================================================
# ** Scene_Map
#-------------------------------------------------------------------------------
# On permet à l'éditeur de base de données de s'ouvrir en appuyant sur
# la touche OPEN_DATABASE_EDITOR (F8 par défaut)
#===============================================================================
class Scene_Map

#=============================================================================
# * update
#=============================================================================
alias database_update update
def update
if $DEBUG and Input.trigger?(Input::OPEN_DATABASE_EDITOR)
$game_system.se_play($data_system.decision_se)
$scene = Scene_Database.new
end
database_update
end

end

Et le Database Editor Customization pour appeler le Database Management en test (F12 sur l'éditeur de RM). La touche par défaut, quand le jeu test est en cours, est F8. Mais on verra ça après.

Code:: #===============================================================================
# *** Database Editor Customization
#-------------------------------------------------------------------------------
# Auteur : Åvygeil
#-------------------------------------------------------------------------------
# Personnalisation des touches du Database Editor
#===============================================================================

Input::OPEN_DATABASE_EDITOR = Keyboard::F8
Input::DATABASE_ADD_ROW = Keyboard::A
Input::DATABASE_DELETE_ROW = Keyboard::D
Input::DATABASE_COPY_ROW = Keyboard::N
Input::DATABASE_PASTE_ROW = Keyboard::V

C'est tout pour cette partie.

3 - Ouais, mais ça ne fonctionne pas...

Parce que vous ne me laissez pas finir. Ce script ne crée pas des bases de données comme ça, simplement parce que vous le pensez. Il faut aussi définir la base de données que vous voulez créer. Bah ouais, jusqu'à maintenant, on n'a pas encore créé d'ordinateurs qui relie la pensée des utilisateurs avec les machines.

Pour créer une base de données, il faut créer un nouveau script (dessous le Database Management, mais avant le Main) comme ceci :

Code:: Database.create_table("Nom_de_votre_Table"){ |t|
t.column :Nom_de_la_colonne1, Database::Integer
t.column :Nom_de_la_colonne2, Database::String
t.column :Nom_de_la_colonne3, Database::File["Graphics/Object"]
t.column :Nom_de_la_colonne4, Database::Float
t.column :Nom_de_la_colonne5, Database::Boolean
t.column :Nom_de_la_colonne6, Database::Table_Creee_Avant
...
}

Bon, je vais vous expliquer le truc, ligne par ligne....

Database.create_table("Nom_de_votre_Table"){ |t| crée la table en question. Toute table comporte des colonnes (ou des champs, si vous préférez). Dans la table, le |t| est simplement le raccourci pour les éléments de cette table. En règle générale, on laisse t.

t.column :Nom_de_la_colonne1, Database::Integer dit que dans cette table, cette colonne qui a pour nom 'Nom-de_la_colonne1' a comme type de champ un entier (Integer). En entier, ça comprend 0, 1, 2 etc...

t.column :Nom_de_la_colonne2, Database::String dit que dans cette table, cette colonne qui a pour nom 'Nom-de_la_colonne2' a comme type de champ une chaîne de caractères (String). C'est des lettres...

t.column :Nom_de_la_colonne3, Database::File["Graphics/Object"] dit que dans cette table, cette colonne qui a pour nom 'Nom-de_la_colonne3' a comme type de champ un fichier (File["adresse_dossier_parent/adresse_du_dossier"]). Quand vous créerez un objet dans cette table, vous pourrez lui dire d'aller chercher un fichier spécifique à l'adresse donnée... Dans l'exemple, la table va chercher dans le dossier Graphics le dossier Object

Spoiler:

t.column :Nom_de_la_colonne4, Database::Float dit que dans cette table, cette colonne qui a pour nom 'Nom-de_la_colonne4' a comme type de champ un flottant (Float). En entier, ça comprend 0.0, 1.2, 2.3 etc... Bref, les chiffres à virgule.

t.column :Nom_de_la_colonne5, Database::Boolean dit que dans cette table, cette colonne qui a pour nom 'Nom-de_la_colonne5' a comme type de champ un booléen (Boolean). Un booléen n'a que deux valeurs : true (vrai) ou false (faux). Notamment, les booléens sont utilisés par les interrupteurs. Et ouais :p

t.column :Nom_de_la_colonne6, Database::Table_Creee_Avant dit que dans cette table, cette colonne qui a pour nom 'Nom_de_la_colonne6' a comme type une Table qui a pour nom Table_Creee_Avant. Et oui, vous pouvez aussi faire le lien avec d'autres tables! Pour ça, il faut indiquer le nom de la table. De plus, il faut que la Table appelée soit créée avant la table qui appelle.

... est que vous pouvez mettre autant de champ que vous voulez. S'il vous plait, ne le mettez pas dans la table, parce que ça ne fonctionnera pas (et que ça me donnera bien l'occasion de vous traitez de sac)...

} ferme la table créée. ATTENTION, ELLE EST OBLIGATOIRE!!!!!!!

4 - Bon je suis sûr que j'ai loupé un truc...

Vous avez créé une table ? Parfait. Maintenant, vous allez lancer le projet avec F12 (pas avec le game.exe !). Faites Nouveau ou Nouvelle Partie, peu importe. Puis, quand vous le pourrez (quand vous pouvez manipuler votre perso), appuyez sur la touche F8.

[RMXP] Advanced Input et Database Management - Avygeil Dbm01

[RMXP] Advanced Input et Database Management - Avygeil Dbm01

Miracle, il y a toutes les tables que vous avez créé!!!

Allez dans une table...

[RMXP] Advanced Input et Database Management - Avygeil Dbm02

Et appuyez sur A pour créer un nouvel objet de la table (attention, ce n'est pas un nouveau champ!!). Ca vous fera : New Row. Et si vous rentrez dedans, vous pouvez éditer l'élément sélectionné.

[RMXP] Advanced Input et Database Management - Avygeil Dbm03

[RMXP] Advanced Input et Database Management - Avygeil Dbm03

Appuyez sur X/esc pour sortir de l'objet sélectionné.

Vous pouvez aussi supprimer un objet ou faire un copier-coller. Appuyez sur X/esc pour sortir de la table etc...

Attention, avant de sortir du Database Management, c'est-à-dire quand vous êtes sur cet écran :

[RMXP] Advanced Input et Database Management - Avygeil Dbm01

Allez sur Save pour tout enregistrer de votre Base de Données. Sinon, tout votre boulot sera perdu.

5 - Et pour utiliser les tables custom dans les scriptss ?

Pour utiliser les tables custom (ou du moins, les objets de la table custom), voici le code :

Code:: variable = Database::Table_de_Donnees.find { |objet|
objet.champ == parametre_demande
}

Pour expliquer ce code, je vais aller en plusieures étapes :

Vous demandez à trouver dans la base de donnée Table_de_Donnees ( Database::Table_de_Donnees.find )
Un objet dans la base de donnée ( |objet| ). Ici, peu importe le nom.
Qui a pour le champ demandé ( objet.champ )
Un paramètre demandé.
Et vous le stockez dans la variable locale variable.

Pour prendre un exemple, admettons que vous voulez trouver un objet selon l'id (qui est généralement un entier et qui doit être unique pour chaque objet!)

Code:: variable = Database::Table_de_Donnees.find { |objet|
objet.id == 1
}

Dans ce code-là, je demande à ce que la variable locale variable soit une copie de l'objet de la table Table_de_Donnees et qui a pour id (objet.id) 1.

Voilà pour la base. Après, c'est à vous de vous débrouillez.

6 - Tu veux nous dire autre chose ?

Rien pour ma part, si ce n'est bonne utilisation de cet outil qui ne va plus vous quittez une fois que vous savez l'utiliser.

Pour Avygeil, un petit crédit ne serait pas du luxe... Parce que ça, ce n'est pas un menu, c'est une extension des jeux que vous pouvez faire.

Ah si... Raboulez les points pour moi :p

Script très utile et en effet sur VX il y a le script extender qui couvre plus ou moins les mêmes fonctions. Par contre je n'ai pas encore eu le courage de me pencher dessus.

Merci pour le tuto qui permet un bon départ dans le domaine avec quelques explications et bases. Et hop points !

Un gros merci pour ce super partage.
Je vais essayer de m'en servir, ça à l'air d'être typiquement le genre de truc qui peut épargner des dizaines/centaines de conditions d'événement. xD

» [XP] Database Management v1
» [XP] [VX] [VX Ace] Input Ultimate 2
» Vieux RMXP -> Récent RMXP
» [RMxp] BSA
» RMXP ou VX Ace ?