module Over

 Map = [map1 = true, map2 = true]

 X = [map1x = 0, map2x = 0]
 Y = [map1y = 0, map2y = 0]

 Direction = [map1d = 0, map2d = 1]
 
 Var = 1

 Nbmap = 1
end

module Bat
  Text = " Combat" ## Texte à modifier !
end

class Scene_Battle
 
  alias new_start start
  alias new_terminate terminate
  alias new_update update
 
  def start
    new_start
    @win = Win_Battle.new
  end
 
  def terminate
    @win.dispose
    new_terminate
  end
 
end

class Win_Battle < Window_Base
 
  def initialize
    super (0, 0, 544, 60)
    refresh
  end
 
  def refresh
    self.contents.draw_text (210, -40, 100, 100, Bat::Text, 0)
  end
end

module X3
  Int = 100          # N° de l'interrupteur qui permet d'afficher le tout !
 
  Gold = 205        # Icone de l'argent !
 
  Noweapon = "Aucune"  # Texte si jamais il n'y a pas d'équipement ------> Pas plus de 5 Lettres !!!" è_é
  Weppp = "Armes" # Texte
 
  Stat = "Statut"

  Actor = 1 # ID du heros
end
class Scene_Map < Scene_Base
 
  alias add_start start
  alias add_terminate terminate
  alias add_update update
 
def start
 
  add_start
 
  @state =
  if $game_switches[X3::Int] == true
 @actor = X3::Actor
 @nbactor = $game_actors[X3::Actor]
 @win1 = State.new(@nbactor)
 @win1.z = 0
 @win1.opacity = 100

 @win2 = Equips.new(@actor)
 @win2.z = 0
 @win2.opacity = 100
 
 @win3 = Gold.new
 @win3.z = 0
 @win3.opacity = 100
 
 @win4 = Level.new(@actor)
 @win4.z = 0
 @win4.opacity = 100
 
 end #if
end # start

def terminate
  if $game_switches[X3::Int] == true
  @win3.dispose
  @win2.dispose
  @win1.dispose
  add_terminate
 end
end # terminate

 def update
  if $game_switches[X3::Int] == true
  @win3.update
  @win2.update
  @win1.update
  end
  add_update
 
 end #update
end #Scene_Map

class State < Window_Base
 
def initialize(actor)
super( 279, 0, 95, 85)
@actor = actor
 refresh
end #initialize

def refresh
 self.contents.clear
  self.contents.draw_text(0, -10, 55, 50, X3::Stat, 0)
  draw_actor_state(@actor, 15, 30)
end #refresh

end #state

class Equips < Window_Base
 
def initialize(actor)
 super(374, 0, 170, 85)
 
 @actor = actor
 refresh
 
end # initialize

def refresh
 self.contents.clear

  self.contents.draw_text(25,-40,100,100, X3::Weppp, 0)
 y = 5
 ya = 25
  @arme = $game_actors[1.to_i].weapon_id    #ID de l'arme
 
  if @arme == 0
    @icon = 0
  else
  @name = $data_weapons[@arme.to_i].name    #Nom de l'arme 
  @icon = $data_weapons[@arme.to_i].icon_index
end#if

if @arme == 0
  @text = X3::Noweapon
 else
@text = @name.to_s
end #if

self.contents.draw_text(0, y,75,65,@text,0)

bitmap = Cache.system("Iconset")
rect = Rect.new(@icon % 16 * 24, @icon / 16 * 24, 24, 24)
self.contents.blt(115, ya, bitmap, rect)



   
end # refresh


end #equips

class Gold < Window_Base
 
  def initialize
    super (459,  341, 85, 75)
    @icone = X3::Gold
    refresh
  end #initialize
 
  def refresh
    @gold = $game_party.gold
    @text1 = @gold.to_s
    self.contents.draw_text(0,-40,100,100, @text1, 0)
    bitmap = Cache.system("Iconset")
    rect = Rect.new(@icone % 16 * 24, @icone / 16 * 24, 24, 24)
  self.contents.blt(33, 0, bitmap, rect)
 
  end
end

class Level < Window_Base
 
  def initialize(actor)
    super(0, 0, 150, 65)
      name = $game_actors[1].name
      level = $game_actors[1].level
     
        acteur = acteur.to_i + 1
        @act = name.to_s +  " : " + level.to_s
        self.contents.draw_text(0, -60, 150, 150, @act, 0)
  end
 
  def refresh
   
  end
end

#==============================================================================
# ** Scene_Battle
#------------------------------------------------------------------------------
#  This class performs battle screen processing.
#==============================================================================

class Scene_Battle < Scene_Base
  #--------------------------------------------------------------------------
  # * Start processing
  #--------------------------------------------------------------------------
  def start
    super
    $game_temp.in_battle = true
    @spriteset = Spriteset_Battle.new
    @message_window = Window_BattleMessage.new
    @action_battlers = []
    create_info_viewport
  end
  #--------------------------------------------------------------------------
  # * Post-Start Processing
  #--------------------------------------------------------------------------
  def post_start
    super
    process_battle_start
  end
  #--------------------------------------------------------------------------
  # * Termination Processing
  #--------------------------------------------------------------------------
  def terminate
    super
    dispose_info_viewport
    @message_window.dispose
    @spriteset.dispose
    unless $scene.is_a?(Scene_Gameover)
      $scene = nil if $BTEST
    end
  end
  #--------------------------------------------------------------------------
  # * Basic Update Processing
  #    main : Call from main update method
  #--------------------------------------------------------------------------
  def update_basic(main = false)
    Graphics.update unless main    # Update game screen
    Input.update unless main        # Update input information
    $game_system.update            # Update timer
    $game_troop.update              # Update enemy group
    @spriteset.update              # Update sprite set
    @message_window.update          # Update message window
  end
  #--------------------------------------------------------------------------
  # * Wait a set amount of time
  #    duration : Wait time (number of frames)
  #    no_fast  : Fast forward disabled
  #    A method for inserting a wait during scene class update processing.
  #    As a rule, update is called once for each frame, but during battle it
  #    can be difficult to grasp the processing flow, so this method is used#
  #    as an exception.
  #--------------------------------------------------------------------------
  def wait(duration, no_fast = false)
    for i in 0...duration
      update_basic
      break if not no_fast and i >= duration / 2 and show_fast?
    end
  end
  #--------------------------------------------------------------------------
  # * Wait Until Message Display has Finished
  #--------------------------------------------------------------------------
  def wait_for_message
    @message_window.update
    while $game_message.visible
      update_basic
    end
  end
  #--------------------------------------------------------------------------
  # * Wait Until Animation Display has Finished
  #--------------------------------------------------------------------------
  def wait_for_animation
    while @spriteset.animation?
      update_basic
    end
  end
  #--------------------------------------------------------------------------
  # * Determine Fast Forward
  #--------------------------------------------------------------------------
  def show_fast?
    return (Input.press?(Input::A) or Input.press?(Input::C))
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    update_basic(true)
    update_info_viewport                  # Update information viewport
    if $game_message.visible
      @info_viewport.visible = false
      @message_window.visible = true
    end
    unless $game_message.visible          # Unless displaying a message
      return if judge_win_loss            # Determine win/loss results
      update_scene_change
      if @target_enemy_window != nil
        update_target_enemy_selection    # Select target enemy
      elsif @target_actor_window != nil
        update_target_actor_selection    # Select target actor
      elsif @skill_window != nil
        update_skill_selection            # Select skill
      elsif @item_window != nil
        update_item_selection            # Select item
      elsif @party_command_window.active
        update_party_command_selection    # Select party command
      elsif @actor_command_window.active
        update_actor_command_selection    # Select actor command
      else
        process_battle_event              # Battle event processing
        process_action                    # Battle action
        process_battle_event              # Battle event processing
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Create Information Display Viewport
  #--------------------------------------------------------------------------
  def create_info_viewport
    @info_viewport = Viewport.new(0, 288, 544, 128)
    @info_viewport.z = 100
    @status_window = Window_BattleStatus.new
    @party_command_window = Window_PartyCommand.new
    @actor_command_window = Window_ActorCommand.new
    @status_window.viewport = @info_viewport
    @party_command_window.viewport = @info_viewport
    @actor_command_window.viewport = @info_viewport
    @status_window.x = 128
    @actor_command_window.x = 544
    @info_viewport.visible = false
  end
  #--------------------------------------------------------------------------
  # * Dispose of Information Display Viewport
  #--------------------------------------------------------------------------
  def dispose_info_viewport
    @status_window.dispose
    @party_command_window.dispose
    @actor_command_window.dispose
    @info_viewport.dispose
  end
  #--------------------------------------------------------------------------
  # * Update Information Display Viewport
  #--------------------------------------------------------------------------
  def update_info_viewport
    @party_command_window.update
    @actor_command_window.update
    @status_window.update
    if @party_command_window.active and @info_viewport.ox > 0
      @info_viewport.ox -= 16
    elsif @actor_command_window.active and @info_viewport.ox < 128
      @info_viewport.ox += 16
    end
  end
  #--------------------------------------------------------------------------
  # * Battle Event Processing
  #--------------------------------------------------------------------------
  def process_battle_event
    loop do
      return if judge_win_loss
      return if $game_temp.next_scene != nil
      $game_troop.interpreter.update
      $game_troop.setup_battle_event
      wait_for_message
      process_action if $game_troop.forcing_battler != nil
      return unless $game_troop.interpreter.running?
      update_basic
    end
  end
  #--------------------------------------------------------------------------
  # * Determine Win/Loss Results
  #--------------------------------------------------------------------------
  def judge_win_loss
    if $game_temp.in_battle
      if $game_party.all_dead?
        process_defeat
        return true
      elsif $game_troop.all_dead?
        process_victory
        return true
      else
        return false
      end
    else
      return true
    end
  end
  #--------------------------------------------------------------------------
  # * End Battle
  #    result : Results (0: win, 1: escape, 2:lose)
  #--------------------------------------------------------------------------
  def battle_end(result)
    if result == 2 and not $game_troop.can_lose
      call_gameover
    else
      $game_party.clear_actions
      $game_party.remove_states_battle
      $game_troop.clear
      if $game_temp.battle_proc != nil
        $game_temp.battle_proc.call(result)
        $game_temp.battle_proc = nil
      end
      unless $BTEST
        $game_temp.map_bgm.play
        $game_temp.map_bgs.play
      end
      $scene = Scene_Map.new
      @message_window.clear
      Graphics.fadeout(30)
    end
    $game_temp.in_battle = false
  end
  #--------------------------------------------------------------------------
  # * Go to Command Input for Next Actor
  #--------------------------------------------------------------------------
  def next_actor
    loop do
      if @actor_index == $game_party.members.size-1
        start_main
        return
      end
      @status_window.index = @actor_index += 1
      @active_battler = $game_party.members[@actor_index]
      if @active_battler.auto_battle
        @active_battler.make_action
        next
      end
      break if @active_battler.inputable?
    end
    start_actor_command_selection
  end
  #--------------------------------------------------------------------------
  # * Go to Command Input of Previous Actor
  #--------------------------------------------------------------------------
  def prior_actor
    loop do
      if @actor_index == 0
        start_party_command_selection
        return
      end
      @status_window.index = @actor_index -= 1
      @active_battler = $game_party.members[@actor_index]
      next if @active_battler.auto_battle
      break if @active_battler.inputable?
    end
    start_actor_command_selection
  end
  #--------------------------------------------------------------------------
  # * Start party command selection
  #--------------------------------------------------------------------------
  def start_party_command_selection
    if $game_temp.in_battle
      @status_window.refresh
      @status_window.index = @actor_index = -1
      @active_battler = nil
      @info_viewport.visible = true
      @message_window.visible = false
      @party_command_window.active = true
      @party_command_window.index = 0
      @actor_command_window.active = false
      $game_party.clear_actions
      if $game_troop.surprise or not $game_party.inputable?
        start_main
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Update Party Command Selection
  #--------------------------------------------------------------------------
  def update_party_command_selection
    if Input.trigger?(Input::C)
      case @party_command_window.index
      when 0  # Fight
        Sound.play_decision
        @status_window.index = @actor_index = -1
        next_actor
      when 1  # Escape
        if $game_troop.can_escape == false
          Sound.play_buzzer
          return
        end
        Sound.play_decision
        process_escape
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Start Actor Command Selection
  #--------------------------------------------------------------------------
  def start_actor_command_selection
    @party_command_window.active = false
    @actor_command_window.setup(@active_battler)
    @actor_command_window.active = true
    @actor_command_window.index = 0
  end
  #--------------------------------------------------------------------------
  # * Update Actor Command Selection
  #--------------------------------------------------------------------------
  def update_actor_command_selection
    if Input.trigger?(Input::B)
      Sound.play_cancel
      prior_actor
    elsif Input.trigger?(Input::C)
      case @actor_command_window.index
      when 0  # Attack
        Sound.play_decision
        @active_battler.action.set_attack
        start_target_enemy_selection
      when 1  # Skill
        Sound.play_decision
        start_skill_selection
      when 2  # Guard
        Sound.play_decision
        @active_battler.action.set_guard
        next_actor
      when 3  # Item
        Sound.play_decision
        start_item_selection
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Start Target Enemy Selection
  #--------------------------------------------------------------------------
  def start_target_enemy_selection
    @target_enemy_window = Window_TargetEnemy.new
    @target_enemy_window.y = @info_viewport.rect.y
    @info_viewport.rect.x += @target_enemy_window.width
    @info_viewport.ox += @target_enemy_window.width
    @actor_command_window.active = false
  end
  #--------------------------------------------------------------------------
  # * End Target Enemy Selection
  #--------------------------------------------------------------------------
  def end_target_enemy_selection
    @info_viewport.rect.x -= @target_enemy_window.width
    @info_viewport.ox -= @target_enemy_window.width
    @target_enemy_window.dispose
    @target_enemy_window = nil
    if @actor_command_window.index == 0
      @actor_command_window.active = true
    end
  end
  #--------------------------------------------------------------------------
  # * Update Target Enemy Selection
  #--------------------------------------------------------------------------
  def update_target_enemy_selection
    @target_enemy_window.update
    if Input.trigger?(Input::B)
      Sound.play_cancel
      end_target_enemy_selection
    elsif Input.trigger?(Input::C)
      Sound.play_decision
      @active_battler.action.target_index = @target_enemy_window.enemy.index
      end_target_enemy_selection
      end_skill_selection
      end_item_selection
      next_actor
    end
  end
  #--------------------------------------------------------------------------
  # * Start Target Actor Selection
  #--------------------------------------------------------------------------
  def start_target_actor_selection
    @target_actor_window = Window_BattleStatus.new
    @target_actor_window.index = 0
    @target_actor_window.active = true
    @target_actor_window.y = @info_viewport.rect.y
    @info_viewport.rect.x += @target_actor_window.width
    @info_viewport.ox += @target_actor_window.width
    @actor_command_window.active = false
  end
  #--------------------------------------------------------------------------
  # * End Target Actor Selection
  #--------------------------------------------------------------------------
  def end_target_actor_selection
    @info_viewport.rect.x -= @target_actor_window.width
    @info_viewport.ox -= @target_actor_window.width
    @target_actor_window.dispose
    @target_actor_window = nil
  end
  #--------------------------------------------------------------------------
  # * Update Target Actor Selection
  #--------------------------------------------------------------------------
  def update_target_actor_selection
    @target_actor_window.update
    if Input.trigger?(Input::B)
      Sound.play_cancel
      end_target_actor_selection
    elsif Input.trigger?(Input::C)
      Sound.play_decision
      @active_battler.action.target_index = @target_actor_window.index
      end_target_actor_selection
      end_skill_selection
      end_item_selection
      next_actor
    end
  end
  #--------------------------------------------------------------------------
  # * Start Skill Selection
  #--------------------------------------------------------------------------
  def start_skill_selection
    @help_window = Window_Help.new
    @skill_window = Window_Skill.new(0, 286, 544, 130, @active_battler)
    @skill_window.help_window = @help_window
    @actor_command_window.active = false
  end
  #--------------------------------------------------------------------------
  # * End Skill Selection
  #--------------------------------------------------------------------------
  def end_skill_selection
    if @skill_window != nil
      @skill_window.dispose
      @skill_window = nil
      @help_window.dispose
      @help_window = nil
    end
    @actor_command_window.active = true
  end
  #--------------------------------------------------------------------------
  # * Update Skill Selection
  #--------------------------------------------------------------------------
  def update_skill_selection
    @skill_window.active = true
    @skill_window.update
    @help_window.update
    if Input.trigger?(Input::B)
      Sound.play_cancel
      end_skill_selection
    elsif Input.trigger?(Input::C)
      @skill = @skill_window.skill
      if @skill != nil
        @active_battler.last_skill_id = @skill.id
      end
      if @active_battler.skill_can_use?(@skill)
        Sound.play_decision
        determine_skill
      else
        Sound.play_buzzer
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Confirm Skill
  #--------------------------------------------------------------------------
  def determine_skill
    @active_battler.action.set_skill(@skill.id)
    @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
  #--------------------------------------------------------------------------
  # * Start Item Selection
  #--------------------------------------------------------------------------
  def start_item_selection
    @help_window = Window_Help.new
    @item_window = Window_Item.new(0, 56, 544, 232)
    @item_window.help_window = @help_window
    @actor_command_window.active = false
  end
  #--------------------------------------------------------------------------
  # * End Item Selection
  #--------------------------------------------------------------------------
  def end_item_selection
    if @item_window != nil
      @item_window.dispose
      @item_window = nil
      @help_window.dispose
      @help_window = nil
    end
    @actor_command_window.active = true
  end
  #--------------------------------------------------------------------------
  # * Update Item Selection
  #--------------------------------------------------------------------------
  def update_item_selection
    @item_window.active = true
    @item_window.update
    @help_window.update
    if Input.trigger?(Input::B)
      Sound.play_cancel
      end_item_selection
    elsif Input.trigger?(Input::C)
      @item = @item_window.item
      if @item != nil
        $game_party.last_item_id = @item.id
      end
      if $game_party.item_can_use?(@item)
        Sound.play_decision
        determine_item
      else
        Sound.play_buzzer
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Confirm Item
  #--------------------------------------------------------------------------
  def determine_item
    @active_battler.action.set_item(@item.id)
    @item_window.active = false
    if @item.need_selection?
      if @item.for_opponent?
        start_target_enemy_selection
      else
        start_target_actor_selection
      end
    else
      end_item_selection
      next_actor
    end
  end
  #--------------------------------------------------------------------------
  # * Battle Start Processing
  #--------------------------------------------------------------------------
  def process_battle_start
    @message_window.clear
    wait(10)
    for name in $game_troop.enemy_names
      text = sprintf(Vocab::Emerge, name)
      $game_message.texts.push(text)
    end
    if $game_troop.preemptive
      text = sprintf(Vocab::Preemptive, $game_party.name)
      $game_message.texts.push(text)
    elsif $game_troop.surprise
      text = sprintf(Vocab::Surprise, $game_party.name)
      $game_message.texts.push(text)
    end
    wait_for_message
    @message_window.clear
    make_escape_ratio
    process_battle_event
    start_party_command_selection
  end
  #--------------------------------------------------------------------------
  # * Create Escape Ratio
  #--------------------------------------------------------------------------
  def make_escape_ratio
    actors_agi = $game_party.average_agi
    enemies_agi = $game_troop.average_agi
    @escape_ratio = 150 - 100 * enemies_agi / actors_agi
  end
  #--------------------------------------------------------------------------
  # * Escape Processing
  #--------------------------------------------------------------------------
  def process_escape
    @info_viewport.visible = false
    @message_window.visible = true
    text = sprintf(Vocab::EscapeStart, $game_party.name)
    $game_message.texts.push(text)
    if $game_troop.preemptive
      success = true
    else
      success = (rand(100) < @escape_ratio)
    end
    Sound.play_escape
    if success
      wait_for_message
      battle_end(1)
    else
      @escape_ratio += 10
      $game_message.texts.push('\.' + Vocab::EscapeFailure)
      wait_for_message
      $game_party.clear_actions
      start_main
    end
  end
  #--------------------------------------------------------------------------
  # * Victory Processing
  #--------------------------------------------------------------------------
  def process_victory
    @info_viewport.visible = false
    @message_window.visible = true
    RPG::BGM.stop
    $game_system.battle_end_me.play
    unless $BTEST
      $game_temp.map_bgm.play
      $game_temp.map_bgs.play
    end
    display_exp_and_gold
    display_drop_items
    display_level_up
    battle_end(0)
  end
  #--------------------------------------------------------------------------
  # * Display Gained Experience and Gold
  #--------------------------------------------------------------------------
  def display_exp_and_gold
    exp = $game_troop.exp_total
    gold = $game_troop.gold_total
    $game_party.gain_gold(gold)
    text = sprintf(Vocab::Victory, $game_party.name)
    $game_message.texts.push('\|' + text)
    if exp > 0
      text = sprintf(Vocab::ObtainExp, exp)
      $game_message.texts.push('\.' + text)
    end
    if gold > 0
      text = sprintf(Vocab::ObtainGold, gold, Vocab::gold)
      $game_message.texts.push('\.' + text)
    end
    wait_for_message
  end
  #--------------------------------------------------------------------------
  # * Display Gained Drop Items
  #--------------------------------------------------------------------------
  def display_drop_items
    drop_items = $game_troop.make_drop_items
    for item in drop_items
      $game_party.gain_item(item, 1)
      text = sprintf(Vocab::ObtainItem, item.name)
      $game_message.texts.push(text)
    end
    wait_for_message
  end
  #--------------------------------------------------------------------------
  # * Display Level Up
  #--------------------------------------------------------------------------
  def display_level_up
    exp = $game_troop.exp_total
    for actor in $game_party.existing_members
      last_level = actor.level
      last_skills = actor.skills
      actor.gain_exp(exp, true)
    end
    wait_for_message
  end
  #--------------------------------------------------------------------------
  # * Defeat Processing
  #--------------------------------------------------------------------------
  def process_defeat
    @info_viewport.visible = false
    @message_window.visible = true
    text = sprintf(Vocab::Defeat, $game_party.name)
    $game_message.texts.push(text)
    wait_for_message
    battle_end(2)
  end
  #--------------------------------------------------------------------------
  # * Execute Screen Switch
  #--------------------------------------------------------------------------
  def update_scene_change
    case $game_temp.next_scene
    when "map"
      call_map
    when "gameover"
      call_gameover
    when "title"
      call_title
    else
      $game_temp.next_scene = nil
    end
  end
  #--------------------------------------------------------------------------
  # * Switch to Map Screen
  #--------------------------------------------------------------------------
  def call_map
    $game_temp.next_scene = nil
    battle_end(1)
  end
  #--------------------------------------------------------------------------
  # * Switch to Game Over Screen
  #--------------------------------------------------------------------------
  def call_gameover
    $game_temp.next_scene = nil
    $scene = Scene_Gameover.new
    @message_window.clear
  end
  #--------------------------------------------------------------------------
  # * Switch to Title Screen
  #--------------------------------------------------------------------------
  def call_title
    $game_temp.next_scene = nil
    $scene = Scene_Title.new
    @message_window.clear
    Graphics.fadeout(60)
  end
  #--------------------------------------------------------------------------
  # * Start Execution of Battle Processing
  #--------------------------------------------------------------------------
  def start_main
    $game_troop.increase_turn
    @info_viewport.visible = false
    @info_viewport.ox = 0
    @message_window.visible = true
    @party_command_window.active = false
    @actor_command_window.active = false
    @status_window.index = @actor_index = -1
    @active_battler = nil
    @message_window.clear
    $game_troop.make_actions
    make_action_orders
    wait(20)
  end
  #--------------------------------------------------------------------------
  # * Create Action Orders
  #--------------------------------------------------------------------------
  def make_action_orders
    @action_battlers = []
    unless $game_troop.surprise
      @action_battlers += $game_party.members
    end
    unless $game_troop.preemptive
      @action_battlers += $game_troop.members
    end
    for battler in @action_battlers
      battler.action.make_speed
    end
    @action_battlers.sort! do |a,b|
      b.action.speed - a.action.speed
    end
  end
  #--------------------------------------------------------------------------
  # * Battle Action Processing
  #--------------------------------------------------------------------------
  def process_action
    return if judge_win_loss
    return if $game_temp.next_scene != nil
    set_next_active_battler
    if @active_battler == nil
      turn_end
      return
    end
    @message_window.clear
    wait(5)
    @active_battler.white_flash = true
    unless @active_battler.action.forcing
      @active_battler.action.prepare
    end
    if @active_battler.action.valid?
      execute_action
    end
    unless @active_battler.action.forcing
      @message_window.clear
      remove_states_auto
      display_current_state
    end
    @active_battler.white_flash = false
    @message_window.clear
  end
  #--------------------------------------------------------------------------
  # * Execute Battle Actions
  #--------------------------------------------------------------------------
  def execute_action
    case @active_battler.action.kind
    when 0  # Basic
      case @active_battler.action.basic
      when 0  # Attack
        execute_action_attack
      when 1  # Guard
        execute_action_guard
      when 2  # Escape
        execute_action_escape
      when 3  # Wait
        execute_action_wait
      end
    when 1  # Skill
      execute_action_skill
    when 2  # Item
      execute_action_item
    end
  end
  #--------------------------------------------------------------------------
  # * End Turn
  #--------------------------------------------------------------------------
  def turn_end
    $game_troop.turn_ending = true
    $game_party.slip_damage_effect
    $game_troop.slip_damage_effect
    $game_party.do_auto_recovery
    $game_troop.preemptive = false
    $game_troop.surprise = false
    process_battle_event
    $game_troop.turn_ending = false
    start_party_command_selection
  end
  #--------------------------------------------------------------------------
  # * Set Next Battler to Act
  #    When the [Force Battle Action] event command is being performed, set
  #    that battler and remove him from the list. Otherwise, get from top of
  #    list. If an actor that is not currently in the party is obtained (may
  #    occur if the index is nil, just after leaving via a battle event, etc.)
  #    it is skipped.
  #--------------------------------------------------------------------------
  def set_next_active_battler
    loop do
      if $game_troop.forcing_battler != nil
        @active_battler = $game_troop.forcing_battler
        @action_battlers.delete(@active_battler)
        $game_troop.forcing_battler = nil
      else
        @active_battler = @action_battlers.shift
      end
      return if @active_battler == nil
      return if @active_battler.index != nil
    end
  end
  #--------------------------------------------------------------------------
  # * Natural Removal of States
  #--------------------------------------------------------------------------
  def remove_states_auto
    last_st = @active_battler.states
    @active_battler.remove_states_auto
    if @active_battler.states != last_st
      wait(5)
      display_state_changes(@active_battler)
      wait(30)
      @message_window.clear
    end
  end
  #--------------------------------------------------------------------------
  # * Show Current State
  #--------------------------------------------------------------------------
  def display_current_state
    state_text = @active_battler.most_important_state_text
    unless state_text.empty?
      wait(5)
      text = @active_battler.name + state_text
      @message_window.add_instant_text(text)
      wait(45)
      @message_window.clear
    end
  end
  #--------------------------------------------------------------------------
  # * Execute Battle Action: Attack
  #--------------------------------------------------------------------------
  def execute_action_attack
    text = sprintf(Vocab::DoAttack, @active_battler.name)
    @message_window.add_instant_text(text)
    targets = @active_battler.action.make_targets
    display_attack_animation(targets)
    wait(20)
    for target in targets
      target.attack_effect(@active_battler)
      display_action_effects(target)
    end
  end
  #--------------------------------------------------------------------------
  # * Execute Battle Action: Guard
  #--------------------------------------------------------------------------
  def execute_action_guard
    text = sprintf(Vocab::DoGuard, @active_battler.name)
    @message_window.add_instant_text(text)
    wait(45)
  end
  #--------------------------------------------------------------------------
  # * Execute Battle Action: Escape
  #--------------------------------------------------------------------------
  def execute_action_escape
    text = sprintf(Vocab::DoEscape, @active_battler.name)
    @message_window.add_instant_text(text)
    @active_battler.escape
    Sound.play_escape
    wait(45)
  end
  #--------------------------------------------------------------------------
  # * Execute Battle Action: Wait
  #--------------------------------------------------------------------------
  def execute_action_wait
    text = sprintf(Vocab::DoWait, @active_battler.name)
    @message_window.add_instant_text(text)
    wait(45)
  end
  #--------------------------------------------------------------------------
  # * Execute Battle Action: Skill
  #--------------------------------------------------------------------------
  def execute_action_skill
    skill = @active_battler.action.skill
    text = @active_battler.name + skill.message1
    @message_window.add_instant_text(text)
    unless skill.message2.empty?
      wait(10)
      @message_window.add_instant_text(skill.message2)
    end
    targets = @active_battler.action.make_targets
    display_animation(targets, skill.animation_id)
    @active_battler.mp -= @active_battler.calc_mp_cost(skill)
    $game_temp.common_event_id = skill.common_event_id
    for target in targets
      target.skill_effect(@active_battler, skill)
      display_action_effects(target, skill)
    end
  end
  #--------------------------------------------------------------------------
  # * Execute Battle Action: Item
  #--------------------------------------------------------------------------
  def execute_action_item
    item = @active_battler.action.item
    text = sprintf(Vocab::UseItem, @active_battler.name, item.name)
    @message_window.add_instant_text(text)
    targets = @active_battler.action.make_targets
    display_animation(targets, item.animation_id)
    $game_party.consume_item(item)
    $game_temp.common_event_id = item.common_event_id
    for target in targets
      target.item_effect(@active_battler, item)
      display_action_effects(target, item)
    end
  end
  #--------------------------------------------------------------------------
  # * Show Animation
  #    targets      : Target array
  #    animation_id : Animation ID (-1: same as normal attack)
  #--------------------------------------------------------------------------
  def display_animation(targets, animation_id)
    if animation_id < 0
      display_attack_animation(targets)
    else
      display_normal_animation(targets, animation_id)
    end
    wait(20)
    wait_for_animation
  end
  #--------------------------------------------------------------------------
  # * Show Attack Animation
  #    targets : Target array
  #    If enemy, play the [Enemy normal attack] sound effect and wait
  #    a moment. If actor, take dual wielding into account (display left hand
  #    weapon reversed)
  #--------------------------------------------------------------------------
  def display_attack_animation(targets)
    if @active_battler.is_a?(Game_Enemy)
      Sound.play_enemy_attack
      wait(15, true)
    else
      aid1 = @active_battler.atk_animation_id
      aid2 = @active_battler.atk_animation_id2
      display_normal_animation(targets, aid1, false)
      display_normal_animation(targets, aid2, true)
    end
    wait_for_animation
  end
  #--------------------------------------------------------------------------
  # * Show Normal Animation
  #    targets      : Target array
  #    animation_id : Animation ID
  #    mirror      : Flip horizontal
  #--------------------------------------------------------------------------
  def display_normal_animation(targets, animation_id, mirror = false)
    animation = $data_animations[animation_id]
    if animation != nil
      to_screen = (animation.position == 3)      # Is the positon "screen"?
      for target in targets.uniq
        target.animation_id = animation_id
        target.animation_mirror = mirror
        wait(20, true) unless to_screen          # If for one, wait
      end
      wait(20, true) if to_screen                # If for all, wait
    end
  end
  #--------------------------------------------------------------------------
  # * Show Action Results
  #    target : Target
  #    obj    : Skill or item
  #--------------------------------------------------------------------------
  def display_action_effects(target, obj = nil)
    unless target.skipped
      line_number = @message_window.line_number
      wait(5)
      display_critical(target, obj)
      display_damage(target, obj)
      display_state_changes(target, obj)
      if line_number == @message_window.line_number
        display_failure(target, obj) unless target.states_active?
      end
      if line_number != @message_window.line_number
        wait(30)
      end
      @message_window.back_to(line_number)
    end
  end
  #--------------------------------------------------------------------------
  # * Show Critical Hit
  #    target : Target
  #    obj    : Skill or item
  #--------------------------------------------------------------------------
  def display_critical(target, obj = nil)
    if target.critical
      if target.actor?
        text = Vocab::CriticalToActor
      else
        text = Vocab::CriticalToEnemy
      end
      @message_window.add_instant_text(text)
      wait(20)
    end
  end
  #--------------------------------------------------------------------------
  # * Show Damage
  #    target : Target
  #    obj    : Skill or item
  #--------------------------------------------------------------------------
  def display_damage(target, obj = nil)
    if target.missed
      display_miss(target, obj)
    elsif target.evaded
      display_evasion(target, obj)
    else
      display_hp_damage(target, obj)
      display_mp_damage(target, obj)
    end
  end
  #--------------------------------------------------------------------------
  # * Show Miss
  #    target : Target
  #    obj    : Skill or item
  #--------------------------------------------------------------------------
  def display_miss(target, obj = nil)
    if obj == nil or obj.physical_attack
      if target.actor?
        text = sprintf(Vocab::ActorNoHit, target.name)
      else
        text = sprintf(Vocab::EnemyNoHit, target.name)
      end
      Sound.play_miss
    else
      text = sprintf(Vocab::ActionFailure, target.name)
    end
    @message_window.add_instant_text(text)
    wait(30)
  end
  #--------------------------------------------------------------------------
  # * Show Escape
  #    target : Target
  #    obj    : Skill or item
  #--------------------------------------------------------------------------
  def display_evasion(target, obj = nil)
    if target.actor?
      text = sprintf(Vocab::ActorEvasion, target.name)
    else
      text = sprintf(Vocab::EnemyEvasion, target.name)
    end
    Sound.play_evasion
    @message_window.add_instant_text(text)
    wait(30)
  end
  #--------------------------------------------------------------------------
  # * Show HP Damage
  #    target : Target
  #    obj    : Skill or item
  #--------------------------------------------------------------------------
  def display_hp_damage(target, obj = nil)
    if target.hp_damage == 0                # No damage
      return if obj != nil and obj.damage_to_mp
      return if obj != nil and obj.base_damage == 0
      fmt = target.actor? ? Vocab::ActorNoDamage : Vocab::EnemyNoDamage
      text = sprintf(fmt, target.name)
    elsif target.absorbed                  # Absorb
      fmt = target.actor? ? Vocab::ActorDrain : Vocab::EnemyDrain
      text = sprintf(fmt, target.name, Vocab::hp, target.hp_damage)
    elsif target.hp_damage > 0              # Damage
      if target.actor?
        text = sprintf(Vocab::ActorDamage, target.name, target.hp_damage)
        Sound.play_actor_damage
        $game_troop.screen.start_shake(5, 5, 10)
      else
        text = sprintf(Vocab::EnemyDamage, target.name, target.hp_damage)
        Sound.play_enemy_damage
        target.blink = true
      end
    else                                    # Recovery
      fmt = target.actor? ? Vocab::ActorRecovery : Vocab::EnemyRecovery
      text = sprintf(fmt, target.name, Vocab::hp, -target.hp_damage)
      Sound.play_recovery
    end
    @message_window.add_instant_text(text)
    wait(30)
  end
  #--------------------------------------------------------------------------
  # * Show MP Damage
  #    target : Target
  #    obj    : Skill or item
  #--------------------------------------------------------------------------
  def display_mp_damage(target, obj = nil)
    return if target.dead?
    return if target.mp_damage == 0
    if target.absorbed                      # Absorb
      fmt = target.actor? ? Vocab::ActorDrain : Vocab::EnemyDrain
      text = sprintf(fmt, target.name, Vocab::mp, target.mp_damage)
    elsif target.mp_damage > 0              # Damage
      fmt = target.actor? ? Vocab::ActorLoss : Vocab::EnemyLoss
      text = sprintf(fmt, target.name, Vocab::mp, target.mp_damage)
    else                                    # Recovery
      fmt = target.actor? ? Vocab::ActorRecovery : Vocab::EnemyRecovery
      text = sprintf(fmt, target.name, Vocab::mp, -target.mp_damage)
      Sound.play_recovery
    end
    @message_window.add_instant_text(text)
    wait(30)
  end
  #--------------------------------------------------------------------------
  # * Show State Change
  #    target : Target
  #    obj    : Skill or item
  #--------------------------------------------------------------------------
  def display_state_changes(target, obj = nil)
    return if target.missed or target.evaded
    return unless target.states_active?
    if @message_window.line_number < 4
      @message_window.add_instant_text("")
    end
    display_added_states(target, obj)
    display_removed_states(target, obj)
    display_remained_states(target, obj)
    if @message_window.last_instant_text.empty?
      @message_window.back_one
    else
      wait(10)
    end
  end
  #--------------------------------------------------------------------------
  # * Show Added State
  #    target : Target
  #    obj    : Skill or item
  #--------------------------------------------------------------------------
  def display_added_states(target, obj = nil)
    for state in target.added_states
      if target.actor?
        next if state.message1.empty?
        text = target.name + state.message1
      else
        next if state.message2.empty?
        text = target.name + state.message2
      end
      if state.id == 1                      # Incapacitated
        target.perform_collapse
      end
      @message_window.replace_instant_text(text)
      wait(20)
    end
  end
  #--------------------------------------------------------------------------
  # * Show Removed State
  #    target : Target
  #    obj    : Skill or item
  #--------------------------------------------------------------------------
  def display_removed_states(target, obj = nil)
    for state in target.removed_states
      next if state.message4.empty?
      text = target.name + state.message4
      @message_window.replace_instant_text(text)
      wait(20)
    end
  end
  #--------------------------------------------------------------------------
  # * Show Unchanged State
  #    target : Target
  #    obj    : Skill or item
  #    Used when trying to put someone to sleep who is already asleep, etc.
  #--------------------------------------------------------------------------
  def display_remained_states(target, obj = nil)
    for state in target.remained_states
      next if state.message3.empty?
      text = target.name + state.message3
      @message_window.replace_instant_text(text)
      wait(20)
    end
  end
  #--------------------------------------------------------------------------
  # * Show Failure
  #    target : Target (actor)
  #    obj    : Skill or item
  #--------------------------------------------------------------------------
  def display_failure(target, obj)
    text = sprintf(Vocab::ActionFailure, target.name)
    @message_window.add_instant_text(text)
    wait(20)
  end
end

#-------------- Description du script ---------------#
=begin


Nom du script : Système Menu/Option
Auteur : Yanfly
Traduction : XxXxX33333
Date de la dernière mise à jour: 2009.05.12
 Niveau: Facile, Normal

 


 
 #-------------- Interêt du script ---------------#

L'option "End Game" est très probablement la plus inutile fonction dans les jeux RPG Maker  VX.
Non seulement il y a des petites fonctionnalités mais en plus, elle ne peuvent reproduire le Alt-F4 et F12.
Ce script remplace "End Game" avec un nouveau menu tout fait et donne au joueur des options familière vu
dans de nombreux RPG d'aujourd'hui, tels que :
- le changement des "Window Skins";
- Modifier le volume;
- Afficher les animations en combat;
- Et ainsi de suite...
 =end
 
#---------------------------- Instructions -------------#


 Mettez ce script au dessus de Main. Il est automatique mis à part quelques trucs.


 - Si vous utilisez les variables 91, 92, 93 et 94, descendez plus bas dans le script et modifiez les variables comme indiquer.
 
 - Si vous utilisez les interrupteurs 91, 92, 93, 95 ou 96, descendez plus bas dans le script et modifiez les interrupteurs comme indiquer.

Télécharger le PACK de Window à cette adresse :
http://go2.wordpress.com/?id=725X1342&site=pockethouse.wordpress.com&url=http%3A%2F%2Fwww.pockethouse.com%2Frpgvx%2Fscripts%2Fmenusystemoptions.txt&sref=http%3A%2F%2Fpockethouse.wordpress.com%2Fvx%2Fmenu-system-options%2F

Dans le dossier Graphics de votre jeu, créez un dossier "Windows" et mettez-y toute les window tdu pack.

 #-------------------------- Compatibilité --------------------------#
 - Fonctionne avec : NeoMessage de Woratana
 
 - Fonctionne avec: Algèbre Moderne de ATS

# - Alias: Game_Player : Tableau de bord (choix, window, volume, etc...)

# - Alias: Window_Base: Afficher les Fenêtres et les messages

# - Alias: Scene_Battle : Reçois les infos des animations

# - Remplace : Scene_End: Tout cela

# - Remplace : Vocab: game_end#

=end

$imported = {} if $imported == nil
$imported["MenuSystemOptions"] = true

module YE
  module SYSTEM
 
  #Nom qui va apparaître dans le menu de votre jeu.
  #Mettez par exemple : "Options"
    TITLE = "Options"
    #---------------------
    #Configuration de la Fenêtre
    #---------------------
 
    #Modifier ici le texte qui va vous dire de changer de couleur de fenêtre
    WINDOW_HELP = "Choisissez votre fenêtre préférée :"
    WINDOW_SKIN = "Window Skin"
 
    #Modifier ici le numéro de la fenêtre par default (voire plus bas)
    DEFAULT_WINDOW = 7
 
    # Numéro de la variable qui stocke le choix de fenêtre du héros.
    WINDOW_VARIABLE = 91
 
    #Voici les numéro de fenêtre.
 
    # ID => "IMG"
    #ID = Numéro de la fenêtre
    #IMG = Nom de l'image dans le dossier "Windows".
    #Dans le jeu, le menu affiche le nom de votre image ! Pensez donc à bien nommez vos images !
 
    WINDOW_HASH ={
    # Window ID => Nom Window comme expliquer plus haut
              1 => "Rouge",
              2 => "Orange",
              3 => "Jaune",
              4 => "Vert",
              5 => "Bleu-Clair",
              6 => "Bleu-Foncé",
              7 => "Bleu",
              8 => "Violet-Foncé",
              9 => "Violet",
            10 => "Rose",
            11 => "Gris",
            12 => "Noir",
    } # Ne supprimez pas ceci !
 
    #---------------------
    # Configuration du Volume
    #---------------------
 
    #Modifier ici les textes d'aide au joueur
    BGM_HELP  = "Musique - L/R = mute"    #Exemple : Musique - L/R = mute
    SFX_HELP  = "Environnement - L/R = mute"        #Exemple : Environement - L/R = mute
    BGS_HELP  = "Animations - L/R = mute"        #Exemple :  Animations - L/R = mute
 
    #Affiche le texte des barres
    BGM_TITLE = "Musique"     
    SFX_TITLE = "Environnement"
    BGS_TITLE = "Animations"
    VOL_MUTE  = "Mute"
 
    #Modifiez ici les numéros des variables utilisées pour le volume
    BGM_VOLUME_VAR  = 92    # Variable
    SFX_VOLUME_VAR  = 93    # Variable
    BGS_VOLUME_VAR  = 94    # Variable
 
    #Modifiez ici les numéros des interupteurs utilisées pour les mutes !
    BGM_MUTE_SWITCH = 92    # Switch
    SFX_MUTE_SWITCH = 93    # Switch
    BGS_MUTE_SWITCH = 94    # Switch
 
    #NE TOUCHER PAS AU NOM !!
 
    # Ceci ajuste les couleurs de dégradé pour les barres de volumes !
    BGM_COLOUR1 = 30
    BGM_COLOUR2 = 31
    SFX_COLOUR1 = 28
    SFX_COLOUR2 = 29
    BGS_COLOUR1 = 20
    BGS_COLOUR2 = 21
 
    #---------------------
    #Choix Animations de Combat
    #---------------------
 
    #Ces textes affiche le choix pour afficher les animations de combats ou pas...
    ANI_TITLE = "Animations"
    ANI_HELP  = "Animations durant le combat"
    ANI_ON    = "Montrer"
    ANI_OFF  = "Cacher"
 
    #Modifiez ici le numéro du switch qui choisi si les animations
    ANI_SWITCH = 91
 
    #---------------------
    # Course Automatique
    #---------------------
 
    #Modifier ici les textes concernant la course automique !
    AUTO_DASH_TITLE = "Course Automatique"
    AUTO_DASH_HELP  = "Course automatique ou manuelle"
    AUTO_DASH_ON    = "Auto"
    AUTO_DASH_OFF  = "Manuel"
 
    #Modifiez ici le numéro de l'interrupteur qui active/desactive la course auto/manuel
    AUTO_DASH_SWITCH = 95
 
    #---------------------
    # Texte Instantané
    #---------------------
 
    #Modifiez ici les textes du choix texte instantané/texte normal
    INSTANT_TEXT_TITLE = "Texte Instantané"
    INSTANT_TEXT_HELP  = "Le texte s'affiche instantanément ou normalement."
    INSTANT_TEXT_ON    = "Instantané"
    INSTANT_TEXT_OFF  = "Normal"
 
    #Modifiez ici le numéro de l'interrupteur du texte instantané
    INSTANT_TEXT_SWITCH = 96
 
    #---------------------
    # AutresTextes
    #---------------------
 
    # Modifiez ici le reste du texte qui s'affiche
    RETURN_TO_TITLE  = "Ecran titre"
    RETURN_TITLE_HELP = "Retour à l'écran titre. Données non-sauvegardées perdues."
    RETURN_TO_MENU    = "Menu"
    RETURN_MENU_HELP  = "Retour au Menu."
 
  end # SYSTEM
end # YE

#===============================================================================
# Fin de l'édition !
#===============================================================================

module Vocab
  def self.game_end
    return YE::SYSTEM::TITLE
  end
end

module Cache
  def self.windows(filename)
    load_bitmap("Graphics/Windows/", filename)
  end
end

module RPG
 
  class BGM < AudioFile
    def play
      if @name.empty?
        Audio.bgm_stop
        @@last = BGM.new
      else
        vol = @volume
        if $game_variables != nil
          vol *= 100 - $game_variables[YE::SYSTEM::BGM_VOLUME_VAR]
          vol /= 100
          vol = [[vol, 0].max, 100].min
          vol = 0 if $game_switches[YE::SYSTEM::BGM_MUTE_SWITCH]
        end
        Audio.bgm_play("Audio/BGM/" + @name, vol, @pitch)
        @@last = self
      end
    end #Play
  end # BGM
 
  class ME < AudioFile
    def play
      if @name.empty?
        Audio.me_stop
      else
        vol = @volume
        if $game_variables != nil
          vol *= 100 - $game_variables[YE::SYSTEM::BGM_VOLUME_VAR]
          vol /= 100
          vol = [[vol, 0].max, 100].min
          vol = 0 if $game_switches[YE::SYSTEM::BGM_MUTE_SWITCH]
        end
        Audio.me_play("Audio/ME/" + @name, vol, @pitch)
      end
    end
  end # ME
 
  class SE < AudioFile
    def play
      unless @name.empty?
        vol = @volume
        if $game_variables != nil
          vol *= 100 - $game_variables[YE::SYSTEM::SFX_VOLUME_VAR]
          vol /= 100
          vol = [[vol, 0].max, 100].min
          vol = 0 if $game_switches[YE::SYSTEM::SFX_MUTE_SWITCH]
        end
        Audio.se_play("Audio/SE/" + @name, vol, @pitch)
      end
    end
    def self.stop
      Audio.se_stop
    end
  end # SE
 
  class BGS < AudioFile
    def play
      if @name.empty?
        Audio.bgs_stop
        @@last = BGS.new
      else
        vol = @volume
        if $game_variables != nil
          vol *= 100 - $game_variables[YE::SYSTEM::BGS_VOLUME_VAR]
          vol /= 100
          vol = [[vol, 0].max, 100].min
          vol = 0 if $game_switches[YE::SYSTEM::BGS_MUTE_SWITCH]
        end
        Audio.bgs_play("Audio/BGS/" + @name, vol, @pitch)
        @@last = self
      end
    end
  end # BGS
 
end # RPG

#===============================================================================
# Game Player
#===============================================================================

class Game_Player < Game_Character
 
  #--------------------------------------------------------------------------
  # alias dash?
  #--------------------------------------------------------------------------
  alias dash_mso dash? unless $@
  def dash?
    if $game_switches[YE::SYSTEM::AUTO_DASH_SWITCH]
      return false if @move_route_forcing
      return false if $game_map.disable_dash?
      return false if in_vehicle?
      return false if Input.press?(Input::A)
      return true
    else
      dash_mso
    end
  end
 
end

#===============================================================================
# Window
#===============================================================================

class Window
 
  #--------------------------------------------------------------------------
  # update windowskin
  #--------------------------------------------------------------------------
  def update_windowskin
    if $game_variables != nil
      winvar = YE::SYSTEM::WINDOW_VARIABLE
      if $game_variables[winvar] == 0
        $game_variables[winvar] = YE::SYSTEM::DEFAULT_WINDOW
      elsif !YE::SYSTEM::WINDOW_HASH.include?($game_variables[winvar])
        $game_variables[winvar] = YE::SYSTEM::DEFAULT_WINDOW
      end
      mso_windowskin = YE::SYSTEM::WINDOW_HASH[$game_variables[winvar]]
    else
      mso_windowskin = YE::SYSTEM::WINDOW_HASH[YE::SYSTEM::DEFAULT_WINDOW]
    end
    self.windowskin = Cache.windows(mso_windowskin)
  end
 
end

#===============================================================================
# Window Base
#===============================================================================

class Window_Base < Window
 
  #--------------------------------------------------------------------------
  # alias initialize
  #--------------------------------------------------------------------------
  alias initialize_window_mso initialize unless $@
  def initialize(x, y, width, height)
    initialize_window_mso(x, y, width, height)
    self.update_windowskin
  end
 
end

#===============================================================================
# Window Message
#===============================================================================

class Window_Message < Window_Selectable
 
  #--------------------------------------------------------------------------
  # alias update show fast
  #--------------------------------------------------------------------------
  alias update_show_fast_mso update_show_fast unless $@
  def update_show_fast
    if $game_switches[YE::SYSTEM::INSTANT_TEXT_SWITCH]
      if self.pause or self.openness < 255
        @show_fast = false
      else
        @show_fast = true
      end
      if @show_fast and @wait_count > 0
        @wait_count -= 1
      end
    else
      update_show_fast_mso
    end
  end

if $worale != nil
  if $worale["NMS"]
  #--------------------------------------------------------------------------
  # alias draw_name
  #--------------------------------------------------------------------------
  alias draw_name_mso draw_name unless $@
  def draw_name(name, x, y)
    draw_name_mso(name, x, y)
    @namebox.update_windowskin
  end
  end
end
 
end

#===============================================================================
# Window System
#===============================================================================

class Window_System < Window_Selectable
 
  #--------------------------------------------------------------------------
  # Initialize
  #--------------------------------------------------------------------------
  def initialize
    super(0, 56, 544, 360)
    @column_max = 1
    self.index = 0
    self.active = true
    refresh
  end
 
  #--------------------------------------------------------------------------
  # Refresh
  #--------------------------------------------------------------------------
  def refresh
    @data = []
    @data.push(0) # Window Skins
    @data.push(1) # Sound Volume/Sound Mute
    @data.push(2) # BGM Volume/BGM Mute
    @data.push(3) # Ambience Volume/Ambience Mute
    @data.push(4) # Battle Animations
    @data.push(5) # Auto-Dash
    @data.push(6) # Instant Text
    @data.push(7) # Return to Title
    @data.push(8) # Return to Menu
    @item_max = @data.size
    self.contents.clear
    for i in 0..@item_max
      self.contents.font.color.alpha = 255
      draw_item(i)
    end
    #---
  end
 
  #--------------------------------------------------------------------------
  # Draw Item
  #--------------------------------------------------------------------------
  def draw_item(index)
    sw = self.width - 32
    dw = sw
    #---
    case index
    when 0
      dx = 0
      dy = 0
      text = YE::SYSTEM::WINDOW_SKIN
      self.contents.draw_text(dx, dy, dw, WLH, text, 1)
      winvar = $game_variables[YE::SYSTEM::WINDOW_VARIABLE]
      text = YE::SYSTEM::WINDOW_HASH[winvar - 2]
      self.contents.draw_text(dx + dw * 0/5, dy + WLH, dw/5, WLH, text, 1)
      text = YE::SYSTEM::WINDOW_HASH[winvar - 1]
      self.contents.draw_text(dx + dw * 1/5, dy + WLH, dw/5, WLH, text, 1)
      text = YE::SYSTEM::WINDOW_HASH[winvar]
      self.contents.draw_text(dx + dw * 2/5, dy + WLH, dw/5, WLH, text, 1)
      text = YE::SYSTEM::WINDOW_HASH[winvar + 1]
      self.contents.draw_text(dx + dw * 3/5, dy + WLH, dw/5, WLH, text, 1)
      text = YE::SYSTEM::WINDOW_HASH[winvar + 2]
      self.contents.draw_text(dx + dw * 4/5, dy + WLH, dw/5, WLH, text, 1)
    when 1
      dx = 0
      dy = WLH * 2
      text = YE::SYSTEM::BGM_TITLE
      self.contents.draw_text(dx + 20, dy, dw/3 - 20, WLH*2, text, 0)
    when 2
      dx = 0
      dy = WLH * 4
      text = YE::SYSTEM::SFX_TITLE
      self.contents.draw_text(dx + 20, dy, dw/3 - 20, WLH*2, text, 0)
    when 3
      dx = 0
      dy = WLH * 6
      text = YE::SYSTEM::BGS_TITLE
      self.contents.draw_text(dx + 20, dy, dw/3 - 20, WLH*2, text, 0)
    when 4
      dx = 0
      dy = WLH * 8
      text = YE::SYSTEM::ANI_TITLE
      self.contents.draw_text(dx + 20, dy, dw/2 - 20, WLH, text, 0)
      if $game_switches[YE::SYSTEM::ANI_SWITCH]
        en1 = false
        en2 = true
      else
        en1 = true
        en2 = false
      end
      text1 = YE::SYSTEM::ANI_ON
      text2 = YE::SYSTEM::ANI_OFF
      self.contents.font.color.alpha = en1 ? 255 : 128
      self.contents.draw_text(sw*1/2, dy, dw/4, WLH, text1, 1)
      self.contents.font.color.alpha = en2 ? 255 : 128
      self.contents.draw_text(sw*3/4, dy, dw/4, WLH, text2, 1)
    #---
    when 5
      dx = 0
      dy = WLH * 9
      text = YE::SYSTEM::AUTO_DASH_TITLE
      self.contents.draw_text(dx + 20, dy, dw/2 - 20, WLH, text, 0)
      if $game_switches[YE::SYSTEM::AUTO_DASH_SWITCH]
        en1 = true
        en2 = false
      else
        en1 = false
        en2 = true
      end
      text1 = YE::SYSTEM::AUTO_DASH_ON
      text2 = YE::SYSTEM::AUTO_DASH_OFF
      self.contents.font.color.alpha = en1 ? 255 : 128
      self.contents.draw_text(sw*1/2, dy, dw/4, WLH, text1, 1)
      self.contents.font.color.alpha = en2 ? 255 : 128
      self.contents.draw_text(sw*3/4, dy, dw/4, WLH, text2, 1)
    #---
    when 6
      dx = 0
      dy = WLH * 10
      text = YE::SYSTEM::INSTANT_TEXT_TITLE
      self.contents.draw_text(dx + 20, dy, dw/2 - 20, WLH, text, 0)
      if $game_switches[YE::SYSTEM::INSTANT_TEXT_SWITCH]
        en1 = true
        en2 = false
      else
        en1 = false
        en2 = true
      end
      text1 = YE::SYSTEM::INSTANT_TEXT_ON
      text2 = YE::SYSTEM::INSTANT_TEXT_OFF
      self.contents.font.color.alpha = en1 ? 255 : 128
      self.contents.draw_text(sw*1/2, dy, dw/4, WLH, text1, 1)
      self.contents.font.color.alpha = en2 ? 255 : 128
      self.contents.draw_text(sw*3/4, dy, dw/4, WLH, text2, 1)
    #---
    when 7
      dx = 0
      dy = WLH * 11
      text = YE::SYSTEM::RETURN_TO_TITLE
      self.contents.draw_text(dx + 20, dy, dw - 20, WLH, text, 0)
    #---
    when 8
      dx = 0
      dy = WLH * 12
      text = YE::SYSTEM::RETURN_TO_MENU
      self.contents.draw_text(dx + 20, dy, dw - 20, WLH, text, 0)
    end
  end
 
  #--------------------------------------------------------------------------
  # Update Cursor
  #--------------------------------------------------------------------------
  def update_cursor
    if @index < 0
      self.cursor_rect.empty
    elsif @index < 4
      self.cursor_rect.set(0, @index * 48, self.width - 32, 48)
    else
      self.cursor_rect.set(0, @index * 24 + 96, self.width - 32, 24)
    end
  end
 
end

#===============================================================================
# Window Volume
#===============================================================================

class Window_Volume < Window_Base
 
  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(wx, wy, ww, wh, var)
    super(wx, wy, ww, wh)
    @var = var
    if @var == YE::SYSTEM::BGM_VOLUME_VAR
      @gc1 = text_color(YE::SYSTEM::BGM_COLOUR1)
      @gc2 = text_color(YE::SYSTEM::BGM_COLOUR2)
      @mute = YE::SYSTEM::BGM_MUTE_SWITCH
    elsif @var == YE::SYSTEM::SFX_VOLUME_VAR
      @gc1 = text_color(YE::SYSTEM::SFX_COLOUR1)
      @gc2 = text_color(YE::SYSTEM::SFX_COLOUR2)
      @mute = YE::SYSTEM::SFX_MUTE_SWITCH
    else
      @gc1 = text_color(YE::SYSTEM::BGS_COLOUR1)
      @gc2 = text_color(YE::SYSTEM::BGS_COLOUR2)
      @mute = YE::SYSTEM::BGS_MUTE_SWITCH
    end
    self.opacity = 0
    refresh
  end
 
  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    sw = self.width - 32
    self.contents.fill_rect(0, 14, sw-80, 20, gauge_back_color)
    gw = sw-84
    gw *= 100 - $game_variables[@var]
    gw /= 100
    gw = [[gw, 0].max, sw-84].min
    self.contents.gradient_fill_rect(2, 16, gw, 16, @gc1, @gc2)
    if $game_switches[@mute]
      text = YE::SYSTEM::VOL_MUTE
    else
      text = sprintf("%d%%", 100 - $game_variables[@var])
    end
    self.contents.draw_text(sw-76, 0, 76, WLH*2, text, 0)
  end
 
end

#===============================================================================
# Modern Algebra ATS Compatibility
#===============================================================================

class Window_FaceBox < Window_Base
unless method_defined?(:initialize)
 
  #--------------------------------------------------------------------------
  # alias initialize
  #--------------------------------------------------------------------------
  alias initialize_fb_mso initialize unless $@
  def initialize
    initialize_fb_mso
    self.update_windowskin
  end
 
end
end

class Window_NameBox < Window_Base
unless method_defined?(:initialize)
 
  #--------------------------------------------------------------------------
  # alias initialize
  #--------------------------------------------------------------------------
  alias initialize_nb_mso initialize unless $@
  def initialize(string = '')
    initialize_nb_mso(string)
    self.update_windowskin
  end
 
end
end

class Window_ChoiceBox < Window_Command
unless method_defined?(:initialize)
 
  #--------------------------------------------------------------------------
  # alias initialize
  #--------------------------------------------------------------------------
  alias initialize_cb_mso initialize unless $@
  def initialize
    initialize_cb_mso
    self.update_windowskin
  end
 
end
end

class Window_Message < Window_Selectable
unless method_defined?(:initialize)
 
  #--------------------------------------------------------------------------
  # alias initialize
  #--------------------------------------------------------------------------
  alias initialize_wm_mso initialize unless $@
  def initialize
    initialize_wm_mso
    self.update_windowskin
  end
 
end
end

#===============================================================================
# Scene_Battle
#===============================================================================

class Scene_Battle < Scene_Base
 
  #--------------------------------------------------------------------------
  # alias display_normal_animation
  #--------------------------------------------------------------------------
  alias display_normal_animation_mso display_normal_animation unless $@
  def display_normal_animation(targets, animation_id, mirror = false)
    return if $game_switches[YE::SYSTEM::ANI_SWITCH] 
    display_normal_animation_mso(targets, animation_id, mirror)
  end
 
end

#===============================================================================
# Scene_End
#===============================================================================

class Scene_End < Scene_Base

  #--------------------------------------------------------------------------
  # Start processing
  #--------------------------------------------------------------------------
  def start
    super
    create_menu_background
    @help_window = Window_Base.new(0, 0, 544, 56)
    @help_window.contents.clear
    #---
    text = YE::SYSTEM::WINDOW_HELP
    @help_window.contents.draw_text(4,  0, 504, 24, text, 0)
    @system_window = Window_System.new
    var = YE::SYSTEM::BGM_VOLUME_VAR
    @bgm_vol_window = Window_Volume.new(160, 104, 384, 80, var)
    var = YE::SYSTEM::SFX_VOLUME_VAR
    @sfx_vol_window = Window_Volume.new(160, 152, 384, 80, var)
    var = YE::SYSTEM::BGS_VOLUME_VAR
    @bgs_vol_window = Window_Volume.new(160, 200, 384, 80, var)
    #---
    @last_index = 100
  end
 
  #--------------------------------------------------------------------------
  # Post-Start Processing
  #--------------------------------------------------------------------------
  def post_start
    super
  end
 
  #--------------------------------------------------------------------------
  # Pre-termination Processing
  #--------------------------------------------------------------------------
  def pre_terminate
    super
  end
 
  #--------------------------------------------------------------------------
  # Termination Processing
  #--------------------------------------------------------------------------
  def terminate
    super
    @help_window.dispose
    @system_window.dispose
    @bgm_vol_window.dispose
    @sfx_vol_window.dispose
    @bgs_vol_window.dispose
    dispose_menu_background
  end
 
  #--------------------------------------------------------------------------
  # Update Help
  #--------------------------------------------------------------------------
  def update_help
    @help_window.contents.clear
    case @system_window.index
    when 0; text = YE::SYSTEM::WINDOW_HELP
    when 1; text = YE::SYSTEM::BGM_HELP
    when 2; text = YE::SYSTEM::SFX_HELP
    when 3; text = YE::SYSTEM::BGS_HELP
    when 4; text = YE::SYSTEM::ANI_HELP
    when 5; text = YE::SYSTEM::AUTO_DASH_HELP
    when 6; text = YE::SYSTEM::INSTANT_TEXT_HELP
    when 7; text = YE::SYSTEM::RETURN_TITLE_HELP
    when 8; text = YE::SYSTEM::RETURN_MENU_HELP
    end
    @help_window.contents.draw_text(4,  0, 504, 24, text, 0)
  end
 
  #--------------------------------------------------------------------------
  # Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    update_menu_background
    @system_window.update
 
    if @last_index != @system_window.index
      @last_index = @system_window.index
      update_help
    end
 
    if Input.trigger?(Input::B)
      Sound.play_cancel
      return_scene
    else
      #---
      if Input.repeat?(Input::LEFT) and @system_window.index == 0
        $game_variables[YE::SYSTEM::WINDOW_VARIABLE] -= 1
        if $game_variables[YE::SYSTEM::WINDOW_VARIABLE] == 0
          $game_variables[YE::SYSTEM::WINDOW_VARIABLE] = 1
        else
          Sound.play_cursor
        end
        @system_window.refresh
        @system_window.update_windowskin
        @help_window.update_windowskin
      elsif Input.repeat?(Input::RIGHT) and @system_window.index == 0
        $game_variables[YE::SYSTEM::WINDOW_VARIABLE] += 1
        if $game_variables[YE::SYSTEM::WINDOW_VARIABLE] >
        YE::SYSTEM::WINDOW_HASH.size
          $game_variables[YE::SYSTEM::WINDOW_VARIABLE] =
          YE::SYSTEM::WINDOW_HASH.size
        else
          Sound.play_cursor
        end
        @system_window.refresh
        @system_window.update_windowskin
        @help_window.update_windowskin
      #---
      elsif Input.repeat?(Input::LEFT) and @system_window.index == 1
        if Input.press?(Input::A)
          $game_variables[YE::SYSTEM::BGM_VOLUME_VAR] += 10
        else
          $game_variables[YE::SYSTEM::BGM_VOLUME_VAR] += 1
        end
        if $game_variables[YE::SYSTEM::BGM_VOLUME_VAR] >= 100
          $game_variables[YE::SYSTEM::BGM_VOLUME_VAR] = 100
        end
        Sound.play_cursor
        @bgm_vol_window.refresh
        RPG::BGM.last.play
        RPG::BGS.last.play
      elsif Input.repeat?(Input::RIGHT) and @system_window.index == 1
        if Input.press?(Input::A)
          $game_variables[YE::SYSTEM::BGM_VOLUME_VAR] -= 10
        else
          $game_variables[YE::SYSTEM::BGM_VOLUME_VAR] -= 1
        end
        if $game_variables[YE::SYSTEM::BGM_VOLUME_VAR] <= 0
          $game_variables[YE::SYSTEM::BGM_VOLUME_VAR] = 0
        end
        Sound.play_cursor
        @bgm_vol_window.refresh
        RPG::BGM.last.play
        RPG::BGS.last.play
      elsif Input.trigger?(Input::L) and @system_window.index == 1
        if $game_switches[YE::SYSTEM::BGM_MUTE_SWITCH]
          $game_switches[YE::SYSTEM::BGM_MUTE_SWITCH] = false
        else
          $game_switches[YE::SYSTEM::BGM_MUTE_SWITCH] = true
        end
        Sound.play_decision
        @bgm_vol_window.refresh
        RPG::BGM.last.play
        RPG::BGS.last.play
      elsif Input.trigger?(Input::R) and @system_window.index == 1
        if $game_switches[YE::SYSTEM::BGM_MUTE_SWITCH]
          $game_switches[YE::SYSTEM::BGM_MUTE_SWITCH] = false
        else
          $game_switches[YE::SYSTEM::BGM_MUTE_SWITCH] = true
        end
        Sound.play_decision
        @bgm_vol_window.refresh
        RPG::BGM.last.play
        RPG::BGS.last.play
      elsif Input.repeat?(Input::LEFT) and @system_window.index == 2
        if Input.press?(Input::A)
          $game_variables[YE::SYSTEM::SFX_VOLUME_VAR] += 10
        else
          $game_variables[YE::SYSTEM::SFX_VOLUME_VAR] += 1
        end
        if $game_variables[YE::SYSTEM::SFX_VOLUME_VAR] >= 100
          $game_variables[YE::SYSTEM::SFX_VOLUME_VAR] = 100
        end
        Sound.play_cursor
        @sfx_vol_window.refresh
      elsif Input.repeat?(Input::RIGHT) and @system_window.index == 2
        if Input.press?(Input::A)
          $game_variables[YE::SYSTEM::SFX_VOLUME_VAR] -= 10
        else
          $game_variables[YE::SYSTEM::SFX_VOLUME_VAR] -= 1
        end
        if $game_variables[YE::SYSTEM::SFX_VOLUME_VAR] <= 0
          $game_variables[YE::SYSTEM::SFX_VOLUME_VAR] = 0
        end
        Sound.play_cursor
        @sfx_vol_window.refresh
      elsif Input.trigger?(Input::L) and @system_window.index == 2
        if $game_switches[YE::SYSTEM::SFX_MUTE_SWITCH]
          $game_switches[YE::SYSTEM::SFX_MUTE_SWITCH] = false
        else
          $game_switches[YE::SYSTEM::SFX_MUTE_SWITCH] = true
        end
        Sound.play_decision
        @sfx_vol_window.refresh
      elsif Input.trigger?(Input::R) and @system_window.index == 2
        if $game_switches[YE::SYSTEM::SFX_MUTE_SWITCH]
          $game_switches[YE::SYSTEM::SFX_MUTE_SWITCH] = false
        else
          $game_switches[YE::SYSTEM::SFX_MUTE_SWITCH] = true
        end
        Sound.play_decision
        @sfx_vol_window.refresh
      elsif Input.repeat?(Input::LEFT) and @system_window.index == 3
        if Input.press?(Input::A)
          $game_variables[YE::SYSTEM::BGS_VOLUME_VAR] += 10
        else
          $game_variables[YE::SYSTEM::BGS_VOLUME_VAR] += 1
        end
        if $game_variables[YE::SYSTEM::BGS_VOLUME_VAR] >= 100
          $game_variables[YE::SYSTEM::BGS_VOLUME_VAR] = 100
        end
        Sound.play_cursor
        @bgs_vol_window.refresh
        RPG::BGM.last.play
        RPG::BGS.last.play
      elsif Input.repeat?(Input::RIGHT) and @system_window.index == 3
        if Input.press?(Input::A)
          $game_variables[YE::SYSTEM::BGS_VOLUME_VAR] -= 10
        else
          $game_variables[YE::SYSTEM::BGS_VOLUME_VAR] -= 1
        end
        if $game_variables[YE::SYSTEM::BGS_VOLUME_VAR] <= 0
          $game_variables[YE::SYSTEM::BGS_VOLUME_VAR] = 0
        end
        Sound.play_cursor
        @bgs_vol_window.refresh
        RPG::BGM.last.play
        RPG::BGS.last.play
      elsif Input.trigger?(Input::L) and @system_window.index == 3
        if $game_switches[YE::SYSTEM::BGS_MUTE_SWITCH]
          $game_switches[YE::SYSTEM::BGS_MUTE_SWITCH] = false
        else
          $game_switches[YE::SYSTEM::BGS_MUTE_SWITCH] = true
        end
        Sound.play_decision
        @bgs_vol_window.refresh
        RPG::BGM.last.play
        RPG::BGS.last.play
      elsif Input.trigger?(Input::R) and @system_window.index == 3
        if $game_switches[YE::SYSTEM::BGS_MUTE_SWITCH]
          $game_switches[YE::SYSTEM::BGS_MUTE_SWITCH] = false
        else
          $game_switches[YE::SYSTEM::BGS_MUTE_SWITCH] = true
        end
        Sound.play_decision
        @bgs_vol_window.refresh
        RPG::BGM.last.play
        RPG::BGS.last.play
      elsif Input.trigger?(Input::LEFT) and @system_window.index == 4
        $game_switches[YE::SYSTEM::ANI_SWITCH] = false
        Sound.play_decision
        @system_window.refresh
      elsif Input.trigger?(Input::RIGHT) and @system_window.index == 4
        $game_switches[YE::SYSTEM::ANI_SWITCH] = true
        Sound.play_decision
        @system_window.refresh
      elsif Input.trigger?(Input::LEFT) and @system_window.index == 5
        $game_switches[YE::SYSTEM::AUTO_DASH_SWITCH] = true
        Sound.play_decision
        @system_window.refresh
      elsif Input.trigger?(Input::RIGHT) and @system_window.index == 5
        $game_switches[YE::SYSTEM::AUTO_DASH_SWITCH] = false
        Sound.play_decision
        @system_window.refresh
      elsif Input.trigger?(Input::LEFT) and @system_window.index == 6
        $game_switches[YE::SYSTEM::INSTANT_TEXT_SWITCH] = true
        Sound.play_decision
        @system_window.refresh
      elsif Input.trigger?(Input::RIGHT) and @system_window.index == 6
        $game_switches[YE::SYSTEM::INSTANT_TEXT_SWITCH] = false
        Sound.play_decision
        @system_window.refresh
      elsif Input.trigger?(Input::C) and @system_window.index == 7
        Sound.play_decision
        RPG::BGM.fade(800)
        RPG::BGS.fade(800)
        RPG::ME.fade(800)
        $scene = Scene_Title.new
        Graphics.fadeout(60)
      elsif Input.trigger?(Input::C) and @system_window.index == 8
        Sound.play_cancel
        return_scene
      end
      #---
    end
  end
 
end

#===============================================================================
#
# Fin du script
#
#===========================================================================

#==============================================================================

# ? [VX] ? Neo-Face System Advance {Version 3.1} + Name Box ?

#------------------------------------------------------------------------------

# ? by Woratana [woratana@hotmail.com]

# ? Thaiware RPG Maker Community

# ? Special Thanks: Mako, Rabu, Yatzumo

#------------------------------------------------------------------------------

# Released on: 20/02/2008

#

# +[Features in NFS Advance (a.k.a. Neo Face System 3)]+

#

# ? For Both Face Systems

# ? 2 Show Face Effects! You can use them together~

# ? [New!] Move Effect << Move Face from outside the screen to inside

# ? Fade Effect << Fade in Face Picture

#

# ? Easier to change face side! Just type \side[side you want] in message box

# (This change will change side for all the next messages until you change face side again)

# (You can still change by call script: $game_message.side = side you want)

#----------------------------------------------------------------------

# ? FACE SIDE [a.k.a. Face Mode Smile]

# ?\side[-1] fance a l'intérieur droite

#\side[0] face a l'intérieur gauche

#\side[1] face a l'extérieur gauche

#\side[2] face a l'exterieur droite

#---------------------------------------------------------------------

#

# ? For Neo Face System

# ? Auto arrange Face Position (You can use any size of face file!)

# ? Choose to use 1 or 8 face(s) per file

#

# ? For Normal Face System

# ? Show face in right side!

#

# ? For Name Box

# ? Edit your name box easily~

# ? Pour modifier la couleur du nom dans la name box:

# $game_message.color = [Red,Green,Blue]

# ? Add text after name, e.g. add ":" after name >>result>> "name:"

# ? Move name box to right side when showing face in right side

# ? Change name text's font/size, and can make it bold and/or has outline

#

# ?
#Pour insérer le nom d'un héro, du héro 1 par exemple:

# \na[Le nom] << e.g. \na[Worale]

#

# ? If you don't want to type same name every time, use this way:

# \nn[name you want] << e.g. \nn[Worale]

# Pour pas toujours taper le nom:
#nn/[nom] à marquer sur le premier message au lieu de na/[nom],
#pour que tous les messages ai ce nom dans cet event

#

#-----------------------------------------------------------------------------

#==============================================================================



class Window_Base

#---------------------------------

# [START] SETUP script PART

#-------------------------------



#------------------------------------------------

# ** NEO-FACE / NORMAL FACE SYSTEM SETUP

#----------------------------------------------

DEFAULT_SIDE = 0 # Default Face Side when game start~



FACE_X_PLUS = 0 # Move Face Horizontally (Left: -, Right: +)

FACE_Y_PLUS = -112 # Move Face Vertically (Up: -, Down: +)

TEXT_X_PLUS = 0 # Move Text Horizontally

CHOICE_INPUT_X_PLUS = 10

# Move Choices Text and Input Number Text Horizontally



MOVE_TEXT = false#true # (true/false)

# Move text to right side of face, when showing face in left side.



#-------------------------------

# ** NEO FACE SYSTEM

#----------------------------

EightFaces_File = false

# For NeoFace System: Use 8 Faces per file (or) 1 Face per file (true/false)



#-------------------------------------

# **SHOW FACE EFFECT

# * For both Face Systems *

#----------------------------------

FADE_EFFECT = true # Turn on/off fade effect (true/false)

FADE_SPEED = 20 # Speed up face's fade effect by increase this number



MOVE_EFFECT = true # Turn on/off "move in" effect (true/false)

MOVE_SPEED = 10 # Speed up face's "move in" effect by increase this number



#------------------------------------

# ** NAME BOX / NAME TEXT SETUP

#----------------------------------


NAMEBOX_SKIN = "Rouge" # Windowskin of Name Box (In folder 'Graphics/System')

NAMEBOX_OPACITY = 255 # Name Box Opacity (Lowest 0 - 255 Highest)

NAMEBOX_BACK_OPACITY = 180 # Name Box Background Opacity



NAMEBOX_X_PLUS = 115#20 # Move Name Box & Text Horizontally (both faces system)

NAMEBOX_X_PLUS_NF = 140 # Addtional Name Box X only for NeoFace Name Box

# When using NeoFace, X Plus will calculate by: NAMEBOX_X_PLUS + NAMEBOX_X_PLUS_NF

NAMEBOX_Y_PLUS = 0 # Move Name Box & Text Vertically



NAMEBOX_TEXT_LENGTH_PER_LETTER = 10 # Length of Text Per Letter (in pixel)

NAMEBOX_TEXT_FONT = "UmePlus Gothic" # Name Text Font's Name

NAMEBOX_TEXT_SIZE = 22 # Name Text Font's Size

NAMEBOX_TEXT_HEIGHT_PLUS = 2 # Increase Name Text Height (For Big Size Text)



NAMEBOX_TEXT_BOLD = false # Make Text in Name Box Bold

NAMEBOX_TEXT_OUTLINE = false # Make Black Outline around Text (Good with Opacity = 0)

NAMEBOX_TEXT_DEFAULT_COLOR = [173,216,230]#[255,255,255] # [Red,Green,Blue]: Name Text Color (RGB)

# You can easily find color code for RGB (RedGreenBlue) color in Google Smile

# You are allow to change color in game by call script:

# $game_message.color = [Red,Green,Blue]



NAMEBOX_TEXT_AFTER_NAME = ":" # Add Text after Name, leave "" to disable.



NAMEBOX_BOX_WIDTH_PLUS = 6 # Increase Name Box Width

NAMEBOX_BOX_HEIGHT_PLUS = 7 # Increase Name Box Height



MOVE_NAMEBOX = true

# (true/false) Move Text Box to Right Side if showing Face in Right side.



#---------------------------------

# [END] SETUP script PART

#-------------------------------

end

$worale = {} if $worale == nil

$worale["NeoFace"] = true

#==============================================================================

# Window_Message

#------------------------------------------------------------------------------

#==============================================================================

class Window_Message

alias msg_ini initialize



#------------------------------------

# EDITED FROM ORIGINAL METHODS

#----------------------------------

def initialize

 
 msg_ini

@face = Sprite.new

@face.z = self.z + 5

@nametxt = Sprite.new

@nametxt.z = self.z + 15

@namebox = nil

@ori_x = 0

@name_text = nil

 
 @NAMEBOX_SKIN = YE::SYSTEM::WINDOW_HASH[$game_variables[YE::SYSTEM::WINDOW_VARIABLE]]

end



alias msg_conspecha convert_special_characters

def convert_special_characters

clear_namebox if @namebox != nil

msg_conspecha



# CHECK FOR CALL NAME BOX/ CALL REPEAT NAME BOX/ CHANGE SIDE

@text.scan(/\\na\[(.*?)\]/)

if $1.to_s != ""

@name_text = $1.to_s

@text.sub!(/\\na\[(.*?)\]/) {}

end



@text.gsub!(/\\nn\[(.*?)\]/) do

$game_message._name = $1.to_s

a = ""

end



@text.scan(/\\side\[([-,0-9]+)\]/)

if $1.to_s != ""

$game_message.side = $1.to_i

@text.sub!(/\\side\[([-,0-9]+)\]/) {}

end



@name_text = $game_message._name if @name_text == nil and $game_message._name != ""

end



def new_page

contents.clear

if @face.bitmap != nil

@face.bitmap.dispose

end

if $game_message.face_name.empty?

@contents_x = TEXT_X_PLUS

else

name = $game_message.face_name

index = $game_message.face_index

# CALL DRAW FACE METHOD

draw_face2(name, self.x, self.y, index)

# CHECK FOR MOVE EFFECT

if MOVE_EFFECT == true

@ori_x = @face.x

if $game_message.side == 0 or $game_message.side == 1

@face.x = 0 - @face.width

else

@face.x = 416 + @face.width

end

end

@contents_x = get_x_face

end

@contents_y = 0

@line_count = 0

@show_fast = false

@line_show_fast = false

@pause_skip = false

contents.font.color = text_color(0)

end



def start_message

@text = ""

for i in 0...$game_message.texts.size

@text += "" if i >= $game_message.choice_start

@text += $game_message.texts[i].clone + "\x00"

end

@item_max = $game_message.choice_max

convert_special_characters

reset_window

new_page

end



def new_line

if $game_message.face_name.empty? or MOVE_TEXT == false

@contents_x = TEXT_X_PLUS

else

@contents_x = get_x_face

end

@contents_x += CHOICE_INPUT_X_PLUS if $game_message.choice_max > 0

@contents_y += WLH

@line_count += 1

@line_show_fast = false

end



def update

super

if @name_text != nil

draw_name(@name_text,self.x,self.y)

end

update_gold_window

update_number_input_window

update_back_sprite

update_show_fast

if @face.bitmap != nil

# UPDATE FADE IN EFFECT

if @face.opacity < 255

@face.opacity += FADE_SPEED

end

# UPDATE MOVE IN EFFECT

if MOVE_EFFECT == true and @ori_x != @face.x

if (@ori_x > @face.x and @face.x + MOVE_SPEED < @ori_x) or (@ori_x < @face.x and @face.x - MOVE_SPEED > @ori_x)

@face.x += MOVE_SPEED if @ori_x > @face.x

@face.x -= MOVE_SPEED if @ori_x < @face.x

else

@face.x = @ori_x

end

end

end

unless @opening or @closing

if @wait_count > 0

@wait_count -= 1

elsif self.pause

input_pause

elsif self.active

input_choice

elsif @number_input_window.visible

input_number

elsif @text != nil

update_message

elsif continue?

start_message

open

$game_message.visible = true

else

close

if @face.bitmap != nil

@face.bitmap.dispose

end

clear_namebox if @namebox != nil

$game_message.visible = @closing

end

end

end



def start_number_input

digits_max = $game_message.num_input_digits_max

number = $game_variables[$game_message.num_input_variable_id]

@number_input_window.digits_max = digits_max

@number_input_window.number = number

if $game_message.face_name.empty? or MOVE_TEXT == false

@number_input_window.x = x - 23

else

case $game_message.side

when 0

@number_input_window.x = (x + 112) - 23

when 1

@number_input_window.x = (x + text_x) - 23

when 2

@number_input_window.x = x - 23

when -1

@number_input_window.x = x - 23

end

end

@number_input_window.x += CHOICE_INPUT_X_PLUS

@number_input_window.y = y + @contents_y

@number_input_window.active = true

@number_input_window.visible = true

@number_input_window.update

end



def update_cursor

if @index >= 0

if $game_message.face_name.empty?

x = TEXT_X_PLUS

else

x = get_x_face

end

y = ($game_message.choice_start + @index) * WLH

# CHANGE WIDTH OF CURSOR FOR CHOICE SELECT

if $game_message.face_name.empty? or MOVE_TEXT == false

facesize = x

else

facesize = get_x_face

facesize += @face.width if $game_message.side == 2

facesize += @face.width + 16 if $game_message.side == -1

end

self.cursor_rect.set(x, y, contents.width - facesize, WLH)

else

self.cursor_rect.empty

end

end

#--------------------------------

# ADDITIONAL METHODS

#------------------------------

# RETURN Text X-Coordinate, DEPENDS ON FACE SIDE

def get_x_face

if MOVE_TEXT == true

case $game_message.side

when 0

return 112 + TEXT_X_PLUS

when 1

return text_x

when 2

return TEXT_X_PLUS

else

return TEXT_X_PLUS

end

else

return TEXT_X_PLUS

end

end



# RETURN Text X-Coordinate for Face Side = 1

def text_x

return @face.width + TEXT_X_PLUS

end



# Clear Name Box & Name Text

def clear_namebox

@nametxt.bitmap.dispose

@namebox.dispose

@namebox = nil

@name_text = nil

end



#--------------------------------------

# DRAW FACE [Both Systems] METHOD

#------------------------------------

def draw_face2(face_name, x, y, index = 0)

if $game_message.side == 0 or $game_message.side == -1 or EightFaces_File == true

# USE 8 FACES PER FILE

bitmap = Cache.face(face_name)

rect = Rect.new(0,0,0,0)

rect.width = (bitmap.width / 4)

rect.height = (bitmap.height / 2)

rect.x = index % 4 * rect.width

rect.y = index / 4 * rect.height

@face.bitmap = Bitmap.new(rect.width,rect.height)

@face.bitmap.blt(0,0,bitmap,rect)

bitmap.dispose

else

# USE 1 FACES PER FILE

@face.bitmap = Cache.face(face_name)

end

# SET X/Y OF FACE DEPENDS ON FACE SIDE

if $game_message.side == 1

@face.mirror = false

@face.x = x + 6

@face.y = y - (@face.height - 123)

elsif $game_message.side == 2

@face.mirror = true

@face.x = x + (538 - @face.width)

@face.y = y - (@face.height - 123)

elsif $game_message.side == 0

@face.mirror = false

@face.x = x + 16

@face.y = y + 16

elsif $game_message.side == -1

@face.mirror = true

@face.x = self.contents.width - @face.width + 16

@face.y = y + 16

end

@face.x += FACE_X_PLUS

@face.y += FACE_Y_PLUS

@face.opacity = 0 if FADE_EFFECT == true

end



#--------------------------------------

# DRAW NAME BOX METHOD

#-----------------------------------

def draw_name(name,x,y)

name = name + NAMEBOX_TEXT_AFTER_NAME

namesize = calculate_name_size(name)

@nametxt.bitmap = Bitmap.new(16 + (namesize * NAMEBOX_TEXT_LENGTH_PER_LETTER), 24 + NAMEBOX_TEXT_HEIGHT_PLUS)

@nametxt.x = x + 8 + NAMEBOX_X_PLUS

@nametxt.x += NAMEBOX_X_PLUS_NF if $game_message.side == 1 or $game_message.side == 2

@nametxt.y = y - 20 + NAMEBOX_Y_PLUS

@nametxt.x = 544 - @nametxt.x - @nametxt.width if MOVE_NAMEBOX == true and ($game_message.side == 2 or $game_message.side == -1)

@namebox = Window.new

@namebox.windowskin = Cache.windows(@NAMEBOX_SKIN)

@namebox.z = self.z + 10

@namebox.opacity = NAMEBOX_OPACITY

@namebox.back_opacity = NAMEBOX_BACK_OPACITY

@namebox.openness = 255

@namebox.x = @nametxt.x - NAMEBOX_BOX_WIDTH_PLUS

@namebox.y = @nametxt.y - NAMEBOX_BOX_HEIGHT_PLUS

@namebox.width = @nametxt.bitmap.width + (NAMEBOX_BOX_WIDTH_PLUS * 2)

@namebox.height = @nametxt.bitmap.height + (NAMEBOX_BOX_HEIGHT_PLUS * 2)

@nametxt.bitmap.font.name = NAMEBOX_TEXT_FONT

@nametxt.bitmap.font.size = NAMEBOX_TEXT_SIZE

@nametxt.bitmap.font.bold = NAMEBOX_TEXT_BOLD

if NAMEBOX_TEXT_OUTLINE == true

# MAKE TEXT OUTLINE

@nametxt.bitmap.font.color = Color.new(0,0,0)

@nametxt.bitmap.draw_text(0,2,@nametxt.bitmap.width,@nametxt.bitmap.height,name,1)

@nametxt.bitmap.draw_text(0,0,@nametxt.bitmap.width,@nametxt.bitmap.height,name,1)

@nametxt.bitmap.draw_text(2,0,@nametxt.bitmap.width,@nametxt.bitmap.height,name,1)

@nametxt.bitmap.draw_text(2,2,@nametxt.bitmap.width,@nametxt.bitmap.height,name,1)

end

@nametxt.bitmap.font.color = Color.new($game_message.color[0],$game_message.color[1],$game_message.color[2])

@nametxt.bitmap.draw_text(1,1,@nametxt.bitmap.width,@nametxt.bitmap.height,name,1)

@name_text = nil

end



# CALCULATE REAL TEXT LENGTH (for Other Languages, e.g. Japanese)

def calculate_name_size(name = "")

name = name.scan(/./)

return name.size

end



end # Window_Message



#==============================================================================

# Game_Message: + store variables

#------------------------------------------------------------------------------

#==============================================================================

class Game_Message

attr_accessor :side, :color, :_name

alias wor_neoface_old_ini initialize

def initialize

@side = Window_Base::DEFAULT_SIDE

@_name = ""

@color = Window_Base::NAMEBOX_TEXT_DEFAULT_COLOR

wor_neoface_old_ini

end

end



#==============================================================================

# END Neo-Face System

# by Woratana (woratana@hotmail)

#==============================================================================