Faire une magie boomerang

#==============================================================================
# ¦ Magie boomerang v2 par Krazplay
#------------------------------------------------------------------------------
# En plaçant ce scrîpt au-dessus de main il devrait remplacer les définitions
# make_skill_action_result et update_phase4_step4 contenu dans le scrîpt
# Scene_Battle 4 et elements_correct(element_set) du scrîpt Game_Battler 3.
# Donc si vous avez d'autre scripts qui modifient ces définitions il faut copier
# coller les morceaux que j'ai rajouté dans votre définition (les morceaux que
# j'ai ajouté sont précisé dans les commentaires
# Pour que ce scrîpt fontionne il faut créer un statut "Boomerang" à la position
# 20 dans votre database et un attribut (=élément) à la position 17 qui sera
# attribué à à tout les sorts qui ne doivent pas être renvoyés par Boomerang.
# Ce scrîpt est entièrement commenté pour ceux qui veullent apprendre le RUBY ;)
# Pour changer le numéro de l'attribut, c'est ligne 45 et 167
# Pour changer le numéro de l'état boomerang, c'est ligne 49
# Pour changer l'animation du reflet c'est ligne 146
# Krazplay
#==============================================================================
class Scene_Battle

def make_skill_action_result
@skill = $data_skills[@active_battler.current_action.skill_id]
unless @active_battler.current_action.forcing
unless @active_battler.skill_can_use?(@skill.id)
$game_temp.forcing_battler = nil
@phase4_step = 1
return
end
end
@active_battler.sp -= @skill.sp_cost
@status_window.refresh
@help_window.set_text(@skill.name, 1)
@animation1_id = @skill.animation1_id
@animation2_id = @skill.animation2_id
@common_event_id = @skill.common_event_id
set_target_battlers(@skill.scope)

#Début de l'ajout pour faire fonctionner la magie Boomerang par Krazplay

@proteges = []
cibles_potentielles = []
boomerang = 0
# 17 = id de votre élément qui empêche le renvoi
#Si les éléments du skill n'incluent pas l'élément 17 (élément traversant le boomerang)
if not @skill.element_set.include?(17)
# Pour chacun des éléments (monstre ou joueur) dans @target_battlers
for target in @target_battlers
#Si cette cible possède l'état "boomerang" (l'état numéro 20 ds la database)
if target.state?(20) == true
#on met cette cible dans la variable @proteges
@proteges.push(target)
boomerang += 1 # boomerang compte le nombre de cibles avec boomerang
end
end
#On enlève tout ceux qui sont protégés de la variable @target_battlers puisque
#cette variable contient tout ceux qui vont subir l'attaque.
@target_battlers -= @proteges
end
#S'il y a au moins une cible qui possèdait boomerang
if boomerang > 0
#On va determiner, selon qui lance le sort, qui est ses allié et qui est ses amis
if @active_battler.is_a?(Game_Actor)
groupe_ennemi = $game_troop.enemies
groupe_ami = $game_party.actors
else
groupe_ennemi = $game_party.actors
groupe_ami = $game_troop.enemies
end
#Le skill vise un allié ou soi-même
if @skill.scope == 3 or @skill.scope == 7
#On va mettre tt les ennemis qui existent en cible potentielle, puisque si la
#magie visait un allié, elle va rebondir sur un ennemi
for enemy in groupe_ennemi
if enemy.exist?
cibles_potentielles.push(enemy)
end
end
#Si au moins une cible potentielle existe, on va en choisir une au hasard
if cibles_potentielles != []
#hasard est un chiffre entre 0 et le nombre de cibles potentielles
hasard = rand(cibles_potentielles.size)
#Integer supprime tout ce qu'il y a après la virgule, ainsi 1,94 devient 1
hasard = Integer(hasard)
@target_battlers.push(cibles_potentielles[hasard])
#Là ça ne sert pas à grand chose, on supprime la cible choisie des cibles
#potentielles, c'était juste au cas où y aurait un 2ème hasard derrière...
cibles_potentielles.delete(cibles_potentielles[hasard])
end
end
#Plus simple, si le skill vise tout ses alliés, et ben tout les ennemis en profite
if @skill.scope == 4
for enemy in groupe_ennemi
if enemy.exist?
@target_battlers.push(enemy)
end
end
end
#à partir de là c'est l'opération inverse, au lieu de viser un ami on vise un
#ennemi, donc la magie sera renvoyé sur un allié, c'est quasiment la même chose
#que plus haut.
if @skill.scope == 1 #vise un ennemi
for actor in groupe_ami
if actor.exist?
cibles_potentielles.push(actor)
end
end
if cibles_potentielles != []
hasard = rand(cibles_potentielles.size)
hasard = Integer(hasard)
@target_battlers.push(cibles_potentielles[hasard])
cibles_potentielles.delete(cibles_potentielles[hasard])
end
end
if @skill.scope == 2 #vise tout les ennemis
for actor in groupe_ami
if actor.exist?
@target_battlers.push(actor)
end
end
end
end
#Le compact! est assez important, si d'1 manière ou d'1 autre un personnage a été
#mis 2 fois comme cible, cela évite qu'il se prenne 2 fois la magie en supprimant
#les copies, exemple : [1,2,3,5,3,3,2].compact! devient [1,2,3,5]
@target_battlers.compact!
#Toute les cibles se prennent les effets du skill dans la tronche
for target in @target_battlers
target.skill_effect(@active_battler, @skill)
end
#Fin de la modification pour la magie Boomerang par Krazplay
end

#--------------------------------------------------------------------------
# ? ?????? (??????? ???? 4 : ??????????)
#--------------------------------------------------------------------------
def update_phase4_step4
#Ajout magie boomerang par Krazplay
#Là c'est bonus, pour chaque perso qui a été protégé par l'effet boomerang,
#on affiche "Magie renvoyée !" à la place des dégats.
if @proteges != [] and @proteges != nil
for target in @proteges
target.damage = "Magie renvoyée !"
target.damage_pop = true
#Joue une animation sur ceux qui ont renvoyés la magie, ici c'est l'animation
#du skill 54, cad Barrière, ceux qui devrait montrer un bouclier ;)
target.animation_id = $data_skills[54].animation2_id #animation bouclier
end
@proteges = []
end
#Fin de l'ajout magie boomerang par Krazplay
for target in @target_battlers
target.animation_id = @animation2_id
target.animation_hit = (target.damage != "Raté")
end
@wait_count = 8
@phase4_step = 5
end
end



class Game_Battler
def elements_correct(element_set)
#Il ne faut pas que l'élément qui ne peut pas être renvoyé soit considérer comme
#un élément comme les autres, ceci évite qu'il soit pris en compte.
elements = element_set.clone
elements.delete(22)
if elements == []
return 100
end
weakest = -100
for i in elements
weakest = [weakest, self.element_rate(i)].max
end
return weakest
end
end