Script de combat

#==============================================================================
#
# Бе Ace - Visual Battlers v1.01 de Yanfly
# -- Dernière Mise à Jour: 2012.07.24
# -- Level: Easy
# -- Requires: n/a
# Traduit en Français par 152blackpredator
# Бе Modifié par:
# -- Yami
# -- Kread-Ex
# -- Archeia_Nessiah
#==============================================================================

$imported = {} if $imported.nil?
$imported["YEA-VisualBattlers"] = true

#==============================================================================
# Бе Mises à Jour
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# 2012.12.18 - Vues préselectionnées ajoutées et possibité de changer la direction in-game.
# 2012.07.24 - Fin du scripting.
# 2012.01.05 - Début du scripting.
#
#==============================================================================
# Бе Introduction
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# Ce script ajoute une vue pour tous les héros avec les Charsets de ceux-ci. Les actions et
# les mouvements sont comme Final Fantasy 1, mais il n'y a juste que les déplacements
#linéaires lors des actions.
#
#==============================================================================
# Бе Instructions
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# Pour changer in-game la direction, utilisez la portion de code ci-dessous:
#
#
# $game_system.party_direction = ID de la direction voulue
#
# Pour installer ce script, ouvrez l'éditeur de script copiez/collez le script
# en dessous de Materials mais au-dessus de Main. Oubliez pas de Sauvegarder .
#
#==============================================================================
# Бе Compatibilité
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# Ce script est conçu pour VX Ace. Ce n'est pas recommandé de le lancer
# sur VX sans ajuster (le mot original était adjusting).
#
#==============================================================================

module YEA
 module VISUAL_BATTLERS
   
   #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
   # - Paramètres de localisation des charas -
   #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
   # Ces paramètres sont ajustés pour la Localisation des persos(Party Location). Chaque perso
   # a des coordonées calculées par la formule en dessous. Il y a deux coordonées simples
   # en dessous, changez la PARTY_DIRECTION par l'Index que vous voulez utiliser.
   #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
   PARTY_DIRECTION = 6 # This direction is opposite from actual direction.
   
   PARTY_LOCATION_BASE_COORDINATES ={
   # Index => [base_x, base_y, mod_x, mod_y],
         2 => [   250,    290,    40,     0], #Vue du haut
         4 => [   150,    280,    20,   -20], #Vue à gauche
         3 => [   460,    280,    30,   -10], #Vue à droite
         6 => [   460,    230,    20,    20], #Vue par défaut (à droite)
         8 => [   260,    230,    40,     0], #Vue par derrière (chelou XD)
   } # N'enlevez pas cette ligne!
   
   PARTY_LOCATION_FORMULA_X = "base_x + index * mod_x"
   PARTY_LOCATION_FORMULA_Y = "base_y + index * mod_y"
   
 end # VISUAL_BATTLERS
end # YEA

#==============================================================================
#  Бе  Modifier tout ce qui est passé ce point peut potentiellement causer des
# dommages à votre ordi, incontinence, explosion de la tête de l'utilisateur, coma, mort, et/ou
# mauvaise haleine dont modifiez à vos propres risque. (Note de 152: XD, c'est l'auteur qui a écrit ceci)
#==============================================================================

#==============================================================================
# ? Бе  Direction
#==============================================================================

module Direction
 
 #--------------------------------------------------------------------------
 # self.correct
 #--------------------------------------------------------------------------
 def self.correct(direction)
   case direction
   when 1; return 4
   when 3; return 6
   when 7; return 4
   when 9; return 6
   else; return direction
   end
 end
 
 #--------------------------------------------------------------------------
 # self.opposite
 #--------------------------------------------------------------------------
 def self.opposite(direction)
   case direction
   when 1; return 6
   when 2; return 8
   when 3; return 4
   when 4; return 6
   when 6; return 4
   when 7; return 6
   when 8; return 2
   when 9; return 4
   else; return direction
   end
 end
 
end # Direction

#==============================================================================
# ? Бе  Game_System
#==============================================================================

class Game_System; attr_accessor :party_direction; end

#==============================================================================
# ? Бе  Game_BattleCharacter
#==============================================================================

class Game_BattleCharacter < Game_Character
 
 #--------------------------------------------------------------------------
 # initialize
 #--------------------------------------------------------------------------
 def initialize(actor)
   super()
   setup_actor(actor)
   @move_x_rate = 0
   @move_y_rate = 0
 end
 
 #--------------------------------------------------------------------------
 # setup_actor
 #--------------------------------------------------------------------------
 def setup_actor(actor)
   @actor = actor
   @step_anime = true
   set_graphic(@actor.character_name, @actor.character_index)
   setup_coordinates
   dr = $game_system.party_direction || YEA::VISUAL_BATTLERS::PARTY_DIRECTION
   direction = Direction.opposite(dr)
   set_direction(Direction.correct(direction))
 end
 
 #--------------------------------------------------------------------------
 # sprite=
 #--------------------------------------------------------------------------
 def sprite=(sprite)
   @sprite = sprite
 end
 
 #--------------------------------------------------------------------------
 # setup_coordinates
 #--------------------------------------------------------------------------
 def setup_coordinates
   location = ($game_system.party_direction ||
   YEA::VISUAL_BATTLERS::PARTY_DIRECTION)
   base_x = YEA::VISUAL_BATTLERS::PARTY_LOCATION_BASE_COORDINATES[location][0]
   base_y = YEA::VISUAL_BATTLERS::PARTY_LOCATION_BASE_COORDINATES[location][1]
   mod_x = YEA::VISUAL_BATTLERS::PARTY_LOCATION_BASE_COORDINATES[location][2]
   mod_y = YEA::VISUAL_BATTLERS::PARTY_LOCATION_BASE_COORDINATES[location][3]
   @actor.screen_x = eval(YEA::VISUAL_BATTLERS::PARTY_LOCATION_FORMULA_X)
   @actor.screen_y = eval(YEA::VISUAL_BATTLERS::PARTY_LOCATION_FORMULA_Y)
   @actor.origin_x = @actor.screen_x
   @actor.origin_y = @actor.screen_y
   @actor.create_move_to(screen_x, screen_y, 1)
 end
 
 #--------------------------------------------------------------------------
 # index
 #--------------------------------------------------------------------------
 def index
   return @actor.index
 end
 
 #--------------------------------------------------------------------------
 # screen_x
 #--------------------------------------------------------------------------
 def screen_x
   return @actor.screen_x
 end
 
 #--------------------------------------------------------------------------
 # screen_y
 #--------------------------------------------------------------------------
 def screen_y
   return @actor.screen_y
 end
 
 #--------------------------------------------------------------------------
 # screen_z
 #--------------------------------------------------------------------------
 def screen_z
   return @actor.screen_z
 end
 
end # Game_BattleCharacter

#==============================================================================
# ? Бе  Game_Battler
#==============================================================================

class Game_Battler < Game_BattlerBase
 
 #--------------------------------------------------------------------------
 # public instance variables
 #--------------------------------------------------------------------------
 attr_accessor :moved_back
 attr_accessor :origin_x
 attr_accessor :origin_y
 attr_accessor :screen_x
 attr_accessor :screen_y
 attr_accessor :started_turn
 
 #--------------------------------------------------------------------------
 # alias method: execute_damage
 #--------------------------------------------------------------------------
 alias game_battler_execute_damage_vb execute_damage
 def execute_damage(user)
   game_battler_execute_damage_vb(user)
   if @result.hp_damage > 0
     move_backward(24, 6) unless @moved_back
     @moved_back = true
   end
 end
 
 #--------------------------------------------------------------------------
 # face_opposing_party
 #--------------------------------------------------------------------------
 def face_opposing_party
   direction = ($game_system.party_direction ||
   YEA::VISUAL_BATTLERS::PARTY_DIRECTION)
   character.set_direction(Direction.correct(direction)) rescue 0
 end
 
 #--------------------------------------------------------------------------
 # new method: face_coordinate
 #--------------------------------------------------------------------------
 def face_coordinate(destination_x, destination_y)
   x1 = Integer(@screen_x)
   x2 = Integer(destination_x)
   y1 = Graphics.height - Integer(@screen_y)
   y2 = Graphics.height - Integer(destination_y)
   return if x1 == x2 and y1 == y2
   #---
   angle = Integer(Math.atan2((y2-y1),(x2-x1)) * 1800 / Math::PI)
   if (0..225) === angle or (-225..0) === angle
     direction = 6
   elsif (226..675) === angle
     direction = 9
   elsif (676..1125) === angle
     direction = 8
   elsif (1126..1575) === angle
     direction = 7
   elsif (1576..1800) === angle or (-1800..-1576) === angle
     direction = 4
   elsif (-1575..-1126) === angle
     direction = 1
   elsif (-1125..-676) === angle
     direction = 2
   elsif (-675..-226) === angle
     direction = 3
   end
   #---
   character.set_direction(Direction.correct(direction)) rescue 0
 end
 
 #--------------------------------------------------------------------------
 # create_move_to
 #--------------------------------------------------------------------------
 def create_move_to(destination_x, destination_y, frames = 12)
   @destination_x = destination_x
   @destination_y = destination_y
   frames = [frames, 1].max
   @move_x_rate = [(@screen_x - @destination_x).abs / frames, 2].max
   @move_y_rate = [(@screen_y - @destination_y).abs / frames, 2].max
 end
 
 #--------------------------------------------------------------------------
 # update_move_to
 #--------------------------------------------------------------------------
 def update_move_to
   @move_x_rate = 0 if @screen_x == @destination_x || @move_x_rate.nil?
   @move_y_rate = 0 if @screen_y == @destination_y || @move_y_rate.nil?
   value = [(@screen_x - @destination_x).abs, @move_x_rate].min
   @screen_x += (@destination_x > @screen_x) ? value : -value
   value = [(@screen_y - @destination_y).abs, @move_y_rate].min
   @screen_y += (@destination_y > @screen_y) ? value : -value
 end
 
 #--------------------------------------------------------------------------
 # move_forward
 #--------------------------------------------------------------------------
 def move_forward(distance = 24, frames = 12)
   direction = forward_direction
   move_direction(direction, distance, frames)
 end
 
 #--------------------------------------------------------------------------
 # move_backward
 #--------------------------------------------------------------------------
 def move_backward(distance = 24, frames = 12)
   direction = Direction.opposite(forward_direction)
   move_direction(direction, distance, frames)
 end
 
 #--------------------------------------------------------------------------
 # move_direction
 #--------------------------------------------------------------------------
 def move_direction(direction, distance = 24, frames = 12)
   case direction
   when 1; move_x = distance / -2; move_y = distance /  2
   when 2; move_x = distance *  0; move_y = distance *  1
   when 3; move_x = distance / -2; move_y = distance /  2
   when 4; move_x = distance * -1; move_y = distance *  0
   when 6; move_x = distance *  1; move_y = distance *  0
   when 7; move_x = distance / -2; move_y = distance / -2
   when 8; move_x = distance *  0; move_y = distance * -1
   when 9; move_x = distance /  2; move_y = distance / -2
   else; return
   end
   destination_x = @screen_x + move_x
   destination_y = @screen_y + move_y
   create_move_to(destination_x, destination_y, frames)
 end
 
 #--------------------------------------------------------------------------
 # forward_direction
 #--------------------------------------------------------------------------
 def forward_direction
   return ($game_system.party_direction ||
   YEA::VISUAL_BATTLERS::PARTY_DIRECTION)
 end
 
 #--------------------------------------------------------------------------
 # move_origin
 #--------------------------------------------------------------------------
 def move_origin
   create_move_to(@origin_x, @origin_y)
   face_coordinate(@origin_x, @origin_y)
   @moved_back = false
 end
 
 #--------------------------------------------------------------------------
 # moving?
 #--------------------------------------------------------------------------
 def moving?
   return false if dead? || !exist?
   return @move_x_rate != 0 || @move_y_rate != 0
 end
 
end # Game_Battler

#==============================================================================
# ? Бе  Game_Actor
#==============================================================================

class Game_Actor < Game_Battler
 
 #--------------------------------------------------------------------------
 # overwrite method: use_sprite?
 #--------------------------------------------------------------------------
 def use_sprite?
   return true
 end
 
 #--------------------------------------------------------------------------
 # new method: screen_x
 #--------------------------------------------------------------------------
 def screen_x
   return @screen_x rescue 0
 end
 
 #--------------------------------------------------------------------------
 # new method: screen_y
 #--------------------------------------------------------------------------
 def screen_y
   return @screen_y rescue 0
 end
 
 #--------------------------------------------------------------------------
 # new method: screen_z
 #--------------------------------------------------------------------------
 def screen_z
   return 100
 end
 
 #--------------------------------------------------------------------------
 # new method: sprite
 #--------------------------------------------------------------------------
 def sprite
   index = $game_party.battle_members.index(self)
   return SceneManager.scene.spriteset.actor_sprites[index]
 end
 
 #--------------------------------------------------------------------------
 # new method: character
 #--------------------------------------------------------------------------
 def character
   return sprite.character_base
 end
 
 #--------------------------------------------------------------------------
 # face_opposing_party
 #--------------------------------------------------------------------------
 def face_opposing_party
   dr = $game_system.party_direction || YEA::VISUAL_BATTLERS::PARTY_DIRECTION
   direction = Direction.opposite(dr)
   character.set_direction(Direction.correct(direction)) rescue 0
 end
 
 #--------------------------------------------------------------------------
 # forward_direction
 #--------------------------------------------------------------------------
 def forward_direction
   return Direction.opposite(($game_system.party_direction ||
   YEA::VISUAL_BATTLERS::PARTY_DIRECTION))
 end
 
end # Game_Actor

#==============================================================================
# ? Бе  Game_Enemy
#==============================================================================

class Game_Enemy < Game_Battler
 
 #--------------------------------------------------------------------------
 # new method: sprite
 #--------------------------------------------------------------------------
 def sprite
   return SceneManager.scene.spriteset.enemy_sprites.reverse[self.index]
 end
 
 #--------------------------------------------------------------------------
 # new method: character
 #--------------------------------------------------------------------------
 def character
   return sprite
 end
 
end # Game_Enemy

#==============================================================================
# ? Бе  Game_Troop
#==============================================================================

class Game_Troop < Game_Unit
 
 #--------------------------------------------------------------------------
 # alias method: setup
 #--------------------------------------------------------------------------
 alias game_troop_setup_vb setup
 def setup(troop_id)
   game_troop_setup_vb(troop_id)
   set_coordinates
 end
 
 #--------------------------------------------------------------------------
 # new method: set_coordinates
 #--------------------------------------------------------------------------
 def set_coordinates
   for member in members
     member.origin_x = member.screen_x
     member.origin_y = member.screen_y
     member.create_move_to(member.screen_x, member.screen_y, 1)
   end
 end
 
end # Game_Troop

#==============================================================================
# ? Бе  Sprite_Battler
#==============================================================================

class Sprite_Battler < Sprite_Base
 
 #--------------------------------------------------------------------------
 # public instance_variable
 #--------------------------------------------------------------------------
 attr_accessor :character_base
 attr_accessor :character_sprite
 
 #--------------------------------------------------------------------------
 # alias method: dispose
 #--------------------------------------------------------------------------
 alias sprite_battler_dispose_vb dispose
 def dispose
   dispose_character_sprite
   sprite_battler_dispose_vb
 end
 
 #--------------------------------------------------------------------------
 # new method: dispose_character_sprite
 #--------------------------------------------------------------------------
 def dispose_character_sprite
   @character_sprite.dispose unless @character_sprite.nil?
 end
 
 #--------------------------------------------------------------------------
 # alias method: update
 #--------------------------------------------------------------------------
 alias sprite_battler_update_vb update
 def update
   sprite_battler_update_vb
   return if @battler.nil?
   update_move_to
   update_character_base
   update_character_sprite
 end
 
 #--------------------------------------------------------------------------
 # new method: update_character_base
 #--------------------------------------------------------------------------
 def update_character_base
   return if @character_base.nil?
   @character_base.update
 end
 
 #--------------------------------------------------------------------------
 # new method: update_character_sprite
 #--------------------------------------------------------------------------
 def update_character_sprite
   return if @character_sprite.nil?
   @character_sprite.update
 end
 
 #--------------------------------------------------------------------------
 # new method: update_move_to
 #--------------------------------------------------------------------------
 def update_move_to
   @battler.update_move_to
 end
 
 #--------------------------------------------------------------------------
 # new method: moving?
 #--------------------------------------------------------------------------
 def moving?
   return false if @battler.nil?
   return @battler.moving?
 end
 
end # Sprite_Battler

#==============================================================================
# ? Бе  Sprite_BattleCharacter
#==============================================================================

class Sprite_BattleCharacter < Sprite_Character
 
 #--------------------------------------------------------------------------
 # initialize
 #--------------------------------------------------------------------------
 def initialize(viewport, character = nil)
   super(viewport, character)
   character.sprite = self
 end
 
end # Sprite_BattleCharacter

#==============================================================================
# ? Бе  Spriteset_Battle
#==============================================================================

class Spriteset_Battle
 
 #--------------------------------------------------------------------------
 # public instance_variable
 #--------------------------------------------------------------------------
 attr_accessor :actor_sprites
 attr_accessor :enemy_sprites
 
 #--------------------------------------------------------------------------
 # overwrite method: create_actors
 #--------------------------------------------------------------------------
 def create_actors
   total = $game_party.max_battle_members
   @current_party = $game_party.battle_members.clone
   @actor_sprites = Array.new(total) { Sprite_Battler.new(@viewport1) }
   for actor in $game_party.battle_members
     @actor_sprites[actor.index].battler = actor
     create_actor_sprite(actor)
   end
 end
 
 #--------------------------------------------------------------------------
 # new method: create_actor_sprite
 #--------------------------------------------------------------------------
 def create_actor_sprite(actor)
   character = Game_BattleCharacter.new(actor)
   character_sprite = Sprite_BattleCharacter.new(@viewport1, character)
   @actor_sprites[actor.index].character_base = character
   @actor_sprites[actor.index].character_sprite = character_sprite
   actor.face_opposing_party
 end
 
 #--------------------------------------------------------------------------
 # alias method: update_actors
 #--------------------------------------------------------------------------
 alias spriteset_battle_update_actors_vb update_actors
 def update_actors
   if @current_party != $game_party.battle_members
     dispose_actors
     create_actors
   end
   spriteset_battle_update_actors_vb
 end
 
 #--------------------------------------------------------------------------
 # new method: moving?
 #--------------------------------------------------------------------------
 def moving?
   return battler_sprites.any? {|sprite| sprite.moving? }
 end
 
end # Spriteset_Battle

#==============================================================================
# ? Бе  Scene_Battle
#==============================================================================

class Scene_Battle < Scene_Base
 
 #--------------------------------------------------------------------------
 # public instance variables
 #--------------------------------------------------------------------------
 attr_accessor :spriteset
 
 #--------------------------------------------------------------------------
 # alias method: process_action_end
 #--------------------------------------------------------------------------
 alias scene_battle_process_action_end_vb process_action_end
 def process_action_end
   start_battler_move_origin
   scene_battle_process_action_end_vb
 end
 
 #--------------------------------------------------------------------------
 # alias method: execute_action
 #--------------------------------------------------------------------------
 alias scene_battle_execute_action_vb execute_action
 def execute_action
   start_battler_move_forward
   scene_battle_execute_action_vb
 end
 
 #--------------------------------------------------------------------------
 # new method: start_battler_move_forward
 #--------------------------------------------------------------------------
 def start_battler_move_forward
   return if @subject.started_turn
   @subject.started_turn = true
   @subject.move_forward
   wait_for_moving
 end
 
 #--------------------------------------------------------------------------
 # new method: start_battler_move_origin
 #--------------------------------------------------------------------------
 def start_battler_move_origin
   @subject.started_turn = nil
   move_battlers_origin
   wait_for_moving
   @subject.face_opposing_party rescue 0
 end
 
 #--------------------------------------------------------------------------
 # new method: move_battlers_origin
 #--------------------------------------------------------------------------
 def move_battlers_origin
   for member in all_battle_members
     next if member.dead?
     next unless member.exist?
     member.move_origin
   end
 end
 
 #--------------------------------------------------------------------------
 # new method: wait_for_moving
 #--------------------------------------------------------------------------
 def wait_for_moving
   update_for_wait
   update_for_wait while @spriteset.moving?
 end
 
end # Scene_Battle

#==============================================================================
#
#  Бе  FIN DU SCRIPT
#
#==============================================================================