Eekoun
Chevalier (niveau 1)
Messages postés : 74
Date d'inscription : 30/01/2014
Jauge LPC :
 |  Sujet: Extension des notes  Jeu 30 Jan 2014 - 20:26 | |
| Extension des notesPremièrement, ce script est une amélioration du script Typed Entities produit par S4suk3. Je me suis inspiré de sa structure et de son code pour réaliser ma version (tout de même un peu mieux  ). ObjectifIl s'agit d'un script utilitaire pour les scripteurs. En effet, il permet d'ajouter des informations dans la base de données, dans le champ "note" et d'en extraire ces informations en conservant leur type. InstallationCopiez 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 Extension des notes (original  !) Le code - Code:
-
#==============================================================================
# ** NoteTag
#------------------------------------------------------------------------------
# Représente les tags dans les notes
#==============================================================================
module NoteTag
#--------------------------------------------------------------------------
# * Système de type
#--------------------------------------------------------------------------
BoolCoers = ->(x) do
value = begin eval(x) rescue true end
!!value
end
Types = {
int: {ext:[:int, :integer], coers:->(x){x.to_i}},
float: {ext:[:float, :double], coers:->(x){x.to_f}},
string: {ext:[:string, :text], coers:->(x){x.to_s}},
bool: {ext:[:bool, :boolean], coers:BoolCoers},
string_list: {ext:[:strings, :string_list, :texts, :text_list],
coers:->(x) do
x.scan(/[^,|^\s]+/)
end
},
int_list: {ext:[:int_list, :integer_list, :ints, :integers],
coers:->(x) do
x.scan(/[^,|^\s]+/).collect{|i|i.to_i}
end
},
float_list: {ext:[:float_list, :floats],
coers:->(x) do
x.scan(/[^,|^\s]+/).collect{|i|i.to_f}
end
},
bool_list: {ext:[:bool_list, :bools, :booleans, :boolean_list],
coers:->(x) do
x.scan(/[^,|^\s]+/).collect{|i|BoolCoers.(x)}
end
},
}
#--------------------------------------------------------------------------
# * API pour les classes
#--------------------------------------------------------------------------
module API
#--------------------------------------------------------------------------
# * Renvoi les tags de la méthode note
#--------------------------------------------------------------------------
def tags
@note.to_tags
end
end
#--------------------------------------------------------------------------
# * Méthodes publiques
#--------------------------------------------------------------------------
class << self
#--------------------------------------------------------------------------
# * Inférence de type (produit la bonne cellulue en fonction d'un symbole)
#--------------------------------------------------------------------------
def get_coersion(k)
return Types[k][:coers] if Types.has_key?(k)
i = Types.find{|e| e[1][:ext].include?(k)}
return Types[i[0]][:coers] if i
return Types[:string][:coers]
end
#--------------------------------------------------------------------------
# * Convertit une valeur en fonction de son type
#--------------------------------------------------------------------------
def cast(value, type)
get_coersion(type).(value)
end
#--------------------------------------------------------------------------
# * Convertit une ligne en Tag
#--------------------------------------------------------------------------
def convert(line)
return nil unless line =~ /^<.*>$/
if line =~ /^<(.+)>(.*)<\/\w+>/
type = :string
key = $1
value = $2
if key =~ /^(\w+)\s*:\s*(\w+)$/
key, type = $1, $2.to_sym
end
return Simple.new(key, value, type)
end
body = line =~ /^<\s*(.*)\s*\/>$/ && $1
return nil unless body
head, tail = body =~ /^(\w*)/ && [$1, $']
attributes = parse_attributes(tail)
return Complex.new(head, attributes)
end
#--------------------------------------------------------------------------
# * Construit les attributs
#--------------------------------------------------------------------------
def parse_attributes(str, acc = {})
return acc.select do |key, a|
a && a.keyword && a.value
end if !str || str.empty?
type = :string
key, value, tail =
str =~ /^\s*(\w+|\w+:\w+)\s*=\s*\\*"([^\\"]+)\\*"/ && [$1,$2,$']
if key =~ /^(\w+)\s*:\s*(\w+)$/
key, type = $1, $2.to_sym
end
acc[key.to_sym] = Simple.new(key, value, type) if key
parse_attributes(tail, acc)
end
end
#==============================================================================
# ** Simple
#------------------------------------------------------------------------------
# Représente une entité simple
# soit <keyword>valeur</keyword>
# soit <keyword:type>valeur</keyword>
#==============================================================================
class Simple
#--------------------------------------------------------------------------
# * Public instances variables
#--------------------------------------------------------------------------
attr_reader :keyword
attr_reader :value
attr_reader :type
#--------------------------------------------------------------------------
# * Object initialize
#--------------------------------------------------------------------------
def initialize(k, v, t=:string)
@type = t
@keyword = k
@value = NoteTag.cast(v, @type)
end
end
#==============================================================================
# ** Complex
#------------------------------------------------------------------------------
# Représente une entité complexe
# soit <keyword attributA="foo" attributB="bar"/>
# soit <keyword attributA:int="10" attributB:float="1.5"/>
#==============================================================================
class Complex
#--------------------------------------------------------------------------
# * Public instances variables
#--------------------------------------------------------------------------
attr_reader :keyword
attr_reader :attributes
#--------------------------------------------------------------------------
# * Object initialize
#--------------------------------------------------------------------------
def initialize(k, a)
@keyword = k
@attributes = a
end
#--------------------------------------------------------------------------
# * Accessor
#--------------------------------------------------------------------------
def method_missing(m, *rest)
return @attributes[m].value if @attributes.has_key?(m)
raise NoMethodError
end
end
end
#==============================================================================
# ** String
#------------------------------------------------------------------------------
# Ajoute la conversion des lignes en tags
#==============================================================================
class String
#--------------------------------------------------------------------------
# * Conversion d'une chaine un hash de tag
#--------------------------------------------------------------------------
def to_tags
tags = {}
self.split(/\n|\r\n/).each do |ln|
p ln
parsed = NoteTag.convert(ln)
tags[parsed.keyword] = parsed if parsed
end
tags
end
end
#==============================================================================
# ** Ajout des notes aux instances
#------------------------------------------------------------------------------
#==============================================================================
[RPG::BaseItem, RPG::Tileset, RPG::Map].each do |cls|
cls.send(:include, NoteTag::API)
end Construire des tags dans les notesLes tags s'écrivent dans les champs "notes" de la base de données. Ils permettent d'écrire des informations suplémentaires, qu'un scripteur pourra traiter dans un script qui demandera plus d'informations que ceux permis dans la Base de données (dont la structure est statique). Il existe deux types de tags. Les simples et les complexes et il est possible d'en mettre plusieurs par note (dans la base de données) et donc de les cumuler. la seule contrainte est de n'en n'avoir qu'un seul par ligne dans la boite de "note".Tag simplesLes tags simples sont ceux qui ne doivent délivrer qu'une seule information, par exemple : - Code:
-
<red>255</red>
<green>255</green>
<blue>255</blue> Pour ajouter à un élément de la base de données une information sur sa couleur. A noter qu'il est aussi possible de "typer" la valeur d'un tag, par exemple, ici les valeurs seront typées : - Code:
-
<red:int>255</red>
<green:int>255</green>
<blue:int>255</blue> Tags complexesLes tags complexes offrent plusieurs valeurs. Par exemple : - Code:
-
<color red="255" green="255" blue="255" /> Ou encore avec du type : - Code:
-
<color red:int="255" green:int="255" blue:int="255" /> Types autorisésLorsque que l'on force un type (au moyen des : après le nom du tag), les valeurs seront converties dans le bon type. En sachant que parfois, si la valeur n'a rien avoir, par exemple ce tag-ci ahahah transformera la valeur en 0.
Il existe plusieurs type choissable:
int (ou integer) : pour décrire les nombres entiers
float (ou double) : pour décrire les nombres à virgule
bool (ou boolean) : pour décrire les booléens (true ou false)
string (ou text) : pour décrire du texte (une chaine de caractères)
Les listes transforment les champs "1,2,3" en [1,2,3]. Le séparateur est la virgule:
string_list (ou strings, text_list, texts) : pour décrire une liste de texte (séparé par de , )
int_list (ou ints, integer_list, integers) : pour décrire une liste d'entiers (séparé par de , )
float_list (ou floats) : pour décrire une liste de nombre à virgule (utilisant un . comme virgule) (séparé par de , )
bool_list (ou bools, boolean_list, booleans) : pour décrire une liste de booleens (séparé par de , )
Si aucune indication de type n'est spécifié, le type par défaut est le type string.
Récuperer la valeur des tags
Pour les instances qui possèdent l'attribut note, une méthode tags est disponnible. Pour accéder à la valeur d'un tag simple, il suffit de faire mon_objet.tags[:keyword].value. Par exemple, pour obtenir le champ blue dans l'exemple précédent : mon_objet.tags[:blue].value.
Pour un champ complexe, c'est un peu le même procédé, sauf qu'on ne doit pas utiliser la méthode value. Par exemple, pour l'exemple avec color : mon_objet[:color].blue. Grâce au typage, les valeurs sorties sont directement typé comme il le faut (si une indication de typage a été fournie).
Page officielle du script
Si jamais une mise à jours doit être faite, je tâcherai de l'a faire ici mais c'est ici que tout le feedback est dressé :
https://github.com/nukiFW/RPGMaker/tree/master/ExtensionNotes |
|
Zexion
Administrateur
Messages postés : 6228
Date d'inscription : 04/01/2012
Jauge LPC :
| | Sujet: Re: Extension des notes Ven 31 Jan 2014 - 16:52 | |
| Merci pour le partage.
Je t'ai ajouté des points ! |
|
Accueil du Site
Accueil
Rechercher
S'enregistrer
