Système de magie...

Bon voilà en faisant un petit tour sur bbactif ave le compte de notre chère dudu', j'ai trouvé çà !!! C'est énorme, c'est beau, c'est puissant, c'est... c'est simplement... simplement... enfin bon je m'emporte... mais c'est en FRANCAIS !!! Bon, j'ai lu, j'ai vu, j'ai vaincu... il y a pas d'exclu et pas de mention de l'auteur grand dommage l'auteur est ASHKA, a mettre dans vos crédits, c'est obligatoire, Bon voici le script, tout est dedans !

Code:

###################################
#
# Systeme de magie à la Rudora no Hihou
#
###################################
=begin
Le jeu "Rudora no hihou" utilise un systeme de magie unique en son genre.
Le joueur crée lui même ses magies en assemblant des syllabes de maniere à créer une formule magique.
Ce script permet d'integrer un systeme semblable dans votre jeu.
Les competences classiques sont toujours active, vous pouvez donc avoir des competences normales plus des formules.
Il suffit de créer dans l'onglet "Competences" de la base donnée vos syllabes.
Durant le jeu, le joueur aura l'occassion d'assembler plusieurs syllabes pour créer une formule utilisable en combat.
La formule est comme une addition des differentes informations des syllabes.
Ainsi, la puissance de la formule est l'addition des puissances des syllabes.
Même chose pour le cout MP, la vitesse d'execution, ...
Gardez bien ceci en tête au moment de definir vos syllabes.
Vous trouverais ci-dessous differentes options de configurations.
=end
module Rudora
###################################
# Mettre cet interrupteur sur "true" si les competences-syllabes se suivent dans la base de donnée.
Suite = true
# Indiquez ici l'ID de la premiere competence-syllabe
Min = 84
# Indiquez ici l'ID de la derniere competence-syllabe
Max = 140
# Si les competences-syllabes ne se suivent pas, indiquez ici l'ID de toutes les competences-syllabes
Liste = []
###################################
# Si l'interrupteur suivant est sur "true", toutes les competences-syllabes sont accessibles des le depart.
Total = true
# Sinon, indiquez ici les ID de celles qui sont accessibles des le debut.
Acces = []
# Pour en rajouter d'autres en cours de jeu, utiliser en insertion de script la commande suivante :
# $game_party.syllabe |= [ID, ID, ID, ID]
# ou ID est l'ID des competences-syllabes nouvellement accessibles.
###################################
# Ici, vous pouvez configurer le nombre de competences qu'un héros peut créer des le debut du jeu
# ID héros => Nbr de competences
Max_skill = {1 => 4, 2 => 6, 3 => 1, 4 => 0}
# Vous pouvez augmenter ce nombre en cours de jeu grace à l'insertion de script :
# $game_actors[ID_héros].max_skill += 2
# ID_héros designe l'ID du héros qui verra sa limite augmenter, 2 est le nombre de competences qu'il gagne.
# Vous pouvez indexer les nombres de competences créable sur le niveau du héros.
# Pour cela, mettre sur "true" l'interrupteur suivant et configurer la liste se trouvant dessous.
Max_skill_evol = true
Max_skill_evol_liste = Hash.new
# Id du héros = Niveau => Augmentation de la limite
Max_skill_evol_liste[1] = {5 => 2, 10 => 3, 15 => 5}
Max_skill_evol_liste[2] = {5 => 1, 10 => 2, 15 => 3}
Max_skill_evol_liste[3] = {5 => 4, 10 => 5, 15 => 6}
Max_skill_evol_liste[4] = {5 => 5, 10 => 5, 15 => 5}
# Attention, il s'agit d'indiquer l'augmentation, pas le nombre de competence accessibles.
# Il est donc toujours possible d'ajouter ponctuellement d'autres competences grace à l'insertion sus-mentionné.
###################################
# Ici, vous pouvez configurer le nombre de syllabe qu'un héros peut utiliser pour créer une formule magique
# ID du héros => nbr maxi de syllabe utilisable dans une formule
Max_syllabe = {1 => 3, 2 => 4, 3 => 4, 4 => 3}
# Vous pouvez augmenter ce nombre en cours de jeu grace à l'insertion de script suivante :
# $game_actors[ID_héros].max_syllabe += 1
# Ou ID_héros est à remplacer par l'ID du héros qui verra sa limite augmenter et 1 est le gain de syllabe
# Il est également possible d'indexer cette evolution sur le niveau du héros.
# Cela fonctionne de la même maniere que pour la limite des competences à créer.
Max_syllabe_evol = true
Max_syllabe_evol_liste = Hash.new
# Id du héros = Niveau => Augmentation de la limite
Max_syllabe_evol_liste[1] = {5 => 1, 10 => 1, 15 => 1}
Max_syllabe_evol_liste[2] = {20 => 2}
Max_syllabe_evol_liste[3] = {10 => 1, 25 => 1}
Max_syllabe_evol_liste[4] = {10 => 1, 15 => 1, 25 => 1}
# Attention, il s'agit d'indiquer l'augmentation, pas le nombre de syllabes accessibles.
# Il est donc toujours possible d'ajouter ponctuellement d'autres syllabes grace à l'insertion sus-mentionné.
###################################
# L'interrupteur ci-dessous sert à autoriser la repetition de syllabe dans une formule
Repetition = true
###################################
# Reglagles des syllabes
###################################
# Lorsque plusieurs données entre en conflit, la formule aura les données ayant la plus haute priorité.
# Pour donner une priorité à votre syllabe, il suffit d'ecrire dans la note :
# P=5 ( Collé ainsi )
# Cela donnera une priorité de 5 à la syllabe, si rien n'est indiqué la priorité sera de 0.

# La puissance d'attaque de la formule est une addition des puissances d'attaques des syllabes.
# Ainsi la syllabe 1 possede 100 en puissance et la syllabe 2 possede -150 en puissance.
# La formule unissant ces deux syllabes sera un sort de soin de puissance -50.
# Pour créer des formules d'attaques, vous pouvez créer des syllabes spéciales
# ayant comme mots clé dans la note ATK ( en majuscules )
# Cela aura pour effet d'annuler les puissances négatives des autres syllabes.
# Dans l'exemple precedent, si la syllabe 1 a l'effet ATK, la formule aura donc 250 en puissance.
# Le mots clé SOIN a l'effet inverse de ATK.
# C'est-à-dire il augmente l'efficacité des syllabes de guérison ( ici le resultat sera -250 ).

# Les elements de la formules sont basé sur ceux additionné des syllabes.
# Vous avez plusieurs choix de configuration ( valable pour toutes les formules )
# "all" => Tous les elements des syllabes se trouvent dans la formule
# Cela peut donner des formules ayant à la fois l'element "Feu" et l'element "Glace"
# "max" => L'element le plus present dans les syllabes choisit determinera l'element de la formule
# Si l'element Feu est present dans trois syllabes et qu'aucun autre element est present autant de fois
# la formule aura alors l'element Feu et seulement lui ( les autres sont "oubliés" )
# "opp" => Supprime les elements consideré comme opposé.
# Un element "Feu" et un element "Glace" s'annule, deux "Feu" et un "Glace" donneront un "Feu" ...
# Remplissez la table ci-dessous pour definir les oppositions
Tri_element = "all" # choix entre "all" / "max" / "opp"
# Les elements s'oppose deux à deux.
# Feu/Glace Feu/Eau Eclair/Eau Terre/Vent Lumiere/Tenebre
Table_opp = [[9, 10], [9, 12], [11, 12], [13, 14], [15, 16]]
# Si vous utilisez la configuration "max", il est possible d'utiliser un effet "Bonus".
# Pour cela, l'interrupteur ci-dessous doit etre sur "true".
Bonus = true
# A chaque fois qu'un element est present plusieurs fois dans les syllabes, le taux de bonus augmente
# ce qui au final fait augmenter la puissance de la formule
# Dans une configuration "max" ou l'element "Feu" est present 3 fois, le bonus augmentera trois fois
# Effet normal + ( 3 * bonus à 0.5 ) => 1 + 1.5 => Puissance multiplié par 2.5 !!
Taux_bonus = 0.5

# Les etats sont egalement additionnés d'apres la configuration des syllabes.
# Ce qui peut conduire à des choses du genre une formule qui guéri un allié et lui inflige "Poison" ...
# Pour eviter cela, incrivez POS dans la note de l'etat s'il a un effet positif ( augmentation de stats )
# Si rien n'est indiqué, l'etat est consideré comme négatif pour la cible.
# Par defaut, seul les effets positifs seront "lancés" sur un héros, les autres sont "oubliés".
# En mettant le mots clé INV dans la note de la syllabe, l'etat pourra etre inversé.
# Ainsi, dans l'exemple precedent avec la mot INV, la formule guéri et en prime soigne "Poison".
# Sans le mot INV, l'etat "Poison" etant négatif, l'effet sera "oublié".

# Les données numerique ( variance, influence atk / magie, vitesse, coût MP ) sont basé sur l'addition des valeurs.
# Les autres données ( portée, event commun, animation, ... ) sont basé sur la plus haute priorité.
###################################
end
###################################
class Game_Skill
attr_reader :id
attr_reader :icon_index
attr_reader :description
attr_reader :note
def initialize(tab)
@tab = tab
@id = 0
@icon_index = 155
@description = "Formule magique mystique"
@note = ""
end

def name
text = ""
for id in @tab
text += $data_skills[id].name
end
return text.capitalize
end

def speed
result = 0
for id in @tab
result += $data_skills[id].speed
end
return result
end

def type?
atk = 0
soin = 0
for id in @tab
atk += 1 if $data_skills[id].attaque?
soin += 1 if $data_skills[id].soin?
end
if atk > soin
return "atk"
elsif soin > atk
return "soin"
else
return ""
end
end

def base_damage
result = 0
for id in @tab
if type? == "atk"
result += $data_skills[id].base_damage.abs
elsif type? == "soin"
result += (0 - $data_skills[id].base_damage.abs)
else
result += $data_skills[id].base_damage
end
end
result = (result * bonus).round
return result
end

def variance
result = 0
for id in @tab
result += $data_skills[id].variance
end
return result
end

def atk_f
result = 0
for id in @tab
result += $data_skills[id].atk_f
end
return result
end

def spi_f
result = 0
for id in @tab
result += $data_skills[id].spi_f
end
return result
end

def mp_cost
result = 0
for id in @tab
result += $data_skills[id].mp_cost
end
return result
end

def hit
test = @tab.sort {|a, b| $data_skills[a].prior <=> $data_skills[b].prior}
id = test.last
return $data_skills[id].hit
end

def get_number(id)
return element_set_total.find_all {|elt| elt == id }.size
end

def get_max_number
test = {}
tab = []
for id in 0...$data_system.elements.size
test[id] = get_number(id)
tab.push(id) if test[id] > 0
end
tab.sort! {|a, b| test[a] <=> test[b] }
return tab.empty? ? [] : [tab.last]
end

def element_set_total
result = []
for id in @tab
result += $data_skills[id].element_set
end
return result
end

def element_set_all
result = []
for id in @tab
result |= $data_skills[id].element_set
end
return result.compact
end

def element_set
case Rudora::Tri_element
when "all"
return element_set_all
when "max"
return get_max_number
when "opp"
result = element_set_all
for bloc in Rudora::Table_opp
un = get_number(bloc[0])
deux = get_number(bloc[1])
if un > deux
result.delete(bloc[1])
elsif deux > un
result.delete(bloc[0])
end
end
return result
end
end

def bonus
if Rudora::Bonus
if Rudora::Tri_element == "max"
return 1 + (get_number(element_set[0]) * Rudora::Taux_bonus)
end
end
return 1
end

def inverse?
for id in @tab
return true if $data_skills[id].inverse?
end
return false
end

def plus_state_set
result = []
for id in @tab
if for_friend?
for etat in $data_skills[id].plus_state_set
if $data_states[etat].positif?
result.push(etat) unless result.include?(etat)
end
end
else
for etat in $data_skills[id].plus_state_set
unless $data_states[etat].positif?
result.push(etat) unless result.include?(etat)
end
end
if inverse?
for etat in $data_skills[id].minus_state_set
unless $data_states[etat].positif?
result.push(etat) unless result.include?(etat)
end
end
end
end
end
return result
end

[/b]

et la partie 2 :

Code:


def minus_state_set
result = []
for id in @tab
if for_friend?
for etat in $data_skills[id].minus_state_set
unless $data_states[etat].positif?
result.push(etat) unless result.include?(etat)
end
end
if inverse?
for etat in $data_skills[id].plus_state_set
unless $data_states[etat].positif?
result.push(etat) unless result.include?(etat)
end
end
end
else
for etat in $data_skills[id].minus_state_set
if $data_states[etat].positif?
result.push(etat) unless result.include?(etat)
end
end
end
end
return result
end

def scope
test = @tab.sort {|a, b| $data_skills[a].prior <=> $data_skills[b].prior}
id = test.last
return $data_skills[id].scope
end

def animation_id
test = @tab.sort {|a, b| $data_skills[a].prior <=> $data_skills[b].prior}
id = test.last
return $data_skills[id].animation_id
end

def common_event_id
test = @tab.sort {|a, b| $data_skills[a].prior <=> $data_skills[b].prior}
id = test.last
return $data_skills[id].common_event_id
end

def message1
return " lance #{name} !!"
end

def message2
return ""
end

def physical_attack
for id in @tab
test = $data_skills[id].physical_attack
return test if test == true
end
return false
end

def damage_to_mp
for id in @tab
test = $data_skills[id].damage_to_mp
return test if test == true
end
return false
end

def absorb_damage
for id in @tab
test = $data_skills[id].absorb_damage
return test if test == true
end
return false
end

def ignore_defense
for id in @tab
test = $data_skills[id].ignore_defense
return test if test == true
end
return false
end

def occasion
if base_damage > 0
return 1
else
return 0
end
end
#####
def for_opponent?
return [1, 2, 3, 4, 5, 6].include?(scope)
end
def for_friend?
return [7, 8, 9, 10, 11].include?(scope)
end
def for_dead_friend?
return [9, 10].include?(scope)
end
def for_user?
return [11].include?(scope)
end
def for_one?
return [1, 3, 4, 7, 9, 11].include?(scope)
end
def for_two?
return [5].include?(scope)
end
def for_three?
return [6].include?(scope)
end
def for_random?
return [4, 5, 6].include?(scope)
end
def for_all?
return [2, 8, 10].include?(scope)
end
def dual?
return [3].include?(scope)
end
def need_selection?
return [1, 3, 7, 9].include?(scope)
end
def battle_ok?
return [0, 1].include?(occasion)
end
def menu_ok?
return [0, 2].include?(occasion)
end
#####
end
###################################
class String
def decoupe
bloc = []
self.split(/[\r\n]+/).each { |line| bloc.push(line) }
return bloc
end
end
###################################
module RPG
class State
def positif?
text = @note.decoupe
for line in text
if line.include?("POS")
return true
end
end
return false
end
end
class Skill < UsableItem
def prior
text = @note.decoupe
num = 0
for line in text
if line.include?("P=")
num = line.delete("P=")
end
end
return num.to_i
end
def attaque?
text = @note.decoupe
for line in text
if line.include?("ATK")
return true
end
end
return false
end
def soin?
text = @note.decoupe
for line in text
if line.include?("SOIN")
return true
end
end
return false
end
def inverse?
text = @note.decoupe
for line in text
if line.include?("INV")
return true
end
end
return false
end
end
end
###################################
class Game_Party < Game_Unit
attr_accessor :syllabe
alias rudora_init initialize
def initialize
rudora_init
@syllabe = []
if Rudora::Total
if Rudora::Suite
for id in Rudora::Min..Rudora::Max
@syllabe.push(id)
end
else
@syllabe |= Rudora::Liste
end
else
@syllabe |= Rudora::Acces
end
end
end
###################################
class Game_Actor < Game_Battler
attr_accessor :max_skill
attr_accessor :reste_skill
attr_accessor :max_syllabe
alias rudora_setup setup
def setup(actor_id)
@max_skill = 0
@max_skill = Rudora::Max_skill[actor_id] if Rudora::Max_skill.key?(actor_id)
@reste_skill = @max_skill
@max_syllabe = 0
@max_syllabe = Rudora::Max_syllabe[actor_id] if Rudora::Max_syllabe.key?(actor_id)
rudora_setup(actor_id)
@skills.clear
for i in self.class.learnings
learn_skill($data_skills[i.skill_id]) if i.level <= @level
end
clear_extra_values
recover_all
end

def level_up
@level += 1
for learning in self.class.learnings
learn_skill($data_skills[learning.skill_id]) if learning.level == @level
end
if Rudora::Max_skill_evol
if Rudora::Max_skill_evol_liste.key?(@actor_id)
liste = Rudora::Max_skill_evol_liste[@actor_id]
if liste.key?(@level)
@max_skill += liste[@level]
@reste_skill += liste[@level]
end
end
end
if Rudora::Max_syllabe_evol
if Rudora::Max_syllabe_evol_liste.key?(@actor_id)
liste = Rudora::Max_syllabe_evol_liste[@actor_id]
if liste.key?(@level)
@max_syllabe += liste[@level]
end
end
end
end

def skills
return @skills
end

def learn_skill(skill)
unless skill_learn?(skill)
@skills.push(skill)
@skills.sort! {|a,b| a.id <=> b.id}
end
end

def forget_skill(skill)
@skills.delete(skill)
end

def skill_learn?(skill)
return skills.include?(skill)
end

def skill_can_use?(skill)
return false unless skill_learn?(skill)
return false unless skill.is_a?(RPG::Skill) or skill.is_a?(Game_Skill)
return false unless movable?
return false if silent? and skill.spi_f > 0
return false if calc_mp_cost(skill) > mp
if $game_temp.in_battle
return skill.battle_ok?
else
return skill.menu_ok?
end
end
end
###################################
class Game_BattleAction
def skill
if @battler.is_a?(Game_Actor)
return skill? ? @skill_id : nil
else
return skill? ? $data_skills[@skill_id] : nil
end
end
end
###################################
class Scene_Battle < Scene_Base
def determine_skill
@active_battler.action.set_skill(@skill)
@skill_window.active = false
if @skill.need_selection?
if @skill.for_opponent?
start_target_enemy_selection
else
start_target_actor_selection
end
else
end_skill_selection
next_actor
end
end
end
###################################
class Scene_Rudora < Scene_Base
def initialize(rang = 0)
@rang = rang
@actor = $game_party.members[@rang]
end

def start
create_menu_background
@tab = []
@face = Window_Faceset.new(@actor)
@info = Window_Info.new(@actor, nil)
s1 = "Créer une formule"
s2 = "Effacer une formule"
s3 = "Retour"
larg = 250
@choix = Window_Command.new(larg, [s1, s2, s3])
@choix.x = (544 / 2) - (larg / 2)
@choix.y = (416 / 2) - (((3 * 24) + 32) / 2)
@choix.draw_item(0, false) if @actor.reste_skill == 0
@choix.draw_item(1, false) if @actor.reste_skill == @actor.max_skill
@crea = Window_Syllabe.new
@crea.visible = false
@crea.active = false
@supp = Window_Formule.new(@actor)
@supp.visible = false
@supp.active = false
end

def terminate
dispose_menu_background
@face.dispose
@info.dispose
@choix.dispose
@crea.dispose
@supp.dispose
end

def update
update_menu_background
@face.update
@info.update
@choix.update
@crea.update
@supp.update
if @crea.active
update_creation
return
elsif @supp.active
update_supprime
return
end
if Input.trigger?(Input::B)
Sound.play_cancel
$scene = Scene_Menu.new
elsif Input.trigger?(Input::C)
case @choix.index
when 0
if @actor.reste_skill == 0
Sound.play_buzzer
else
Sound.play_decision
@choix.visible = false
@choix.active = false
@crea.visible = true
@crea.active = true
end
when 1
if @actor.reste_skill == @actor.max_skill
Sound.play_buzzer
else
Sound.play_decision
@choix.visible = false
@choix.active = false
@supp.visible = true
@supp.active = true
end
when 2
Sound.play_decision
$scene = Scene_Menu.new
end
elsif Input.trigger?(Input::R)
Sound.play_cursor
@rang += 1
@rang = 0 if @rang == $game_party.members.size
$scene = Scene_Rudora.new(@rang)
elsif Input.trigger?(Input::L)
Sound.play_cursor
@rang -= 1
@rang = ($game_party.members.size - 1) if @rang < 0
$scene = Scene_Rudora.new(@rang)
end
end # def update

def update_creation
if Input.trigger?(Input::B)
Sound.play_cancel
if @tab == []
$scene = Scene_Rudora.new(@rang)
else
@tab.delete(@tab.last)
@info.refresh(@tab)
end
elsif Input.trigger?(Input::C)
if @crea.item.is_a?(Integer)
if @tab.size < @actor.max_syllabe
if Rudora::Repetition
Sound.play_decision
@tab.push(@crea.item)
@info.refresh(@tab)
else
if @tab.include?(@crea.item)
Sound.play_buzzer
else
Sound.play_decision
@tab.push(@crea.item)
@info.refresh(@tab)
end
end
else
Sound.play_buzzer
end
else
if @tab.size == 0
Sound.play_buzzer
else
Sound.play_decision
@actor.learn_skill(Game_Skill.new(@tab))
@actor.reste_skill -= 1
$scene = Scene_Rudora.new(@rang)
end
end
end
end

def update_supprime
if Input.trigger?(Input::B)
Sound.play_cancel
$scene = Scene_Rudora.new(@rang)
elsif Input.trigger?(Input::C)
if @supp.item != nil
Sound.play_decision
@actor.forget_skill(@supp.item)
@actor.reste_skill += 1
@info.refresh(nil)
@supp.refresh
else
Sound.play_buzzer
end
end
end

end # end class
###################################
class Window_Faceset < Window_Base
def initialize(actor)
super(0, 0, 102, 128)
@actor = actor
refresh
end
def refresh
self.contents.clear
if @actor != nil
draw_character(@actor.character_name, @actor.character_index, 35, 48)
self.contents.draw_text(0, 64, 70, 24, @actor.name.to_s, 1)
end
end
end
###################################
class Window_Info < Window_Base
def initialize(actor, formule)
super(102, 0, 544 - 102, 128)
@actor = actor
refresh(formule)
end
def refresh(formule)
self.contents.clear
text = "Q / W => Changer de héros"
self.contents.draw_text(0, 0, 410, 24, text, 1)
text = "Nombre de magie disponibles : " + @actor.reste_skill.to_s + " / " + @actor.max_skill.to_s
self.contents.draw_text(0, 24, 410, 24, text, 1)
text = "Nombre maximum de syllabe par formule : " + @actor.max_syllabe.to_s
self.contents.draw_text(0, 48, 410, 24, text, 1)
if formule != nil
text = "Formule : "
form = ""
for id in formule
form += $data_skills[id].name.to_s if id != nil
end
text += form.capitalize
self.contents.draw_text(0, 72, 410, 24, text, 1)
end
end
end
###################################
class Window_Syllabe < Window_Selectable
def initialize
super(0, 128, 544, 416 - 128)
@column_max = 5
self.index = 0
refresh
end

def item
return @data[self.index]
end

def refresh
@data = []
for id in $game_party.syllabe
@data.push(id)
end
@data.push("Valider")
@item_max = @data.size
create_contents
for i in 0...@item_max
draw_item(i)
end
end

def draw_item(index)
rect = item_rect(index)
self.contents.clear_rect(rect)
item = @data[index]
if item != nil
rect.width -= 4
if item.is_a?(Integer)
text = $data_skills[item].name.upcase.to_s
else
text = item
end
self.contents.draw_text(rect.x, rect.y, rect.width, 24, text, 1)
end
end
end
###################################
class Window_Formule < Window_Selectable
def initialize(actor)
super(0, 128, 544, 416 - 128)
@actor = actor
@column_max = 2
self.index = 0
refresh
end

def item
return @data[self.index]
end

def refresh
@data = []
for item in @actor.skills
@data.push(item) if item.is_a?(Game_Skill)
end
@item_max = @data.size
create_contents
for i in 0...@item_max
draw_item(i)
end
end

def draw_item(index)
rect = item_rect(index)
self.contents.clear_rect(rect)
item = @data[index]
if item != nil
rect.width -= 4
draw_icon(item.icon_index, rect.x, rect.y, true)
self.contents.draw_text(rect.x + 24, rect.y, rect.width - 24, WLH, item.name)
end
end
end
###################################

Je l'avais déjà aperçu, mais pas en français, je crois.

en tout cas, c'est un script vraiment sympa, ça change

Je ne sais pas quand je pourrais m'en servir, mais une chose est sûre : je le retiens ^^

L'auteur est ASHKA pour information =)

Une vraie pièce de collection, je dois dire.
Franchement, c'est une innovation dans le domaine des compétences magiques !
Merci du partage !

Merci Blockade, je rajoute de suite ^^, c'est vrai que c'est pas tonnant que se soit lui, ASHKA est un bon scripteur !

Je comprends pas il faut mettre les deux séparément ou ensembles ?
Sinon ca me met une erreur a la ligne 322

Je viens de modifier la partie deux du code. Je pense que c'est bon. Essais avec cette nouvelle version.

Je suppose qu'il faut les mettre les uns après les autres.

et petit aparté, fait attention à la date où les messages sont postés. Le message avant le tiens est très vieux, c'est un nécro-post.
Enfin je dit ça mais dans le cas actuel il est bénéfique donc il y a aucun problème ^^

il est ou le code ?

Au même endroit. Je l'ai modifié.

Ok merci :-D