#=========================================================
# Weapon Level System Script                           
#        by Akin                                       
#  Traduction française (partielle) : Blockade                                                     
#=========================================================
# Quand l'arme gagne un niveau ces stats augmente   
# Pour ouvrir la fenêtre d'amélioration :                       
# "$scene = Scene_Weapons_Upgrade.new"           
#                                                       
# Cherchez A34sZ1A pour trouver les formules utilisées   
# pour calculer les nombre de points donnés lors d'une amélioration   
# et pour le prix de l'amélioration               
#                                                       
# Le script utilise Window_Confirm class scripté par 
# Prexus                                                                                                   
#=========================================================

# C'est la classe window confirm scripté par Pexus
class Window_Confirm < Window_Selectable
  def initialize(index = -1)
    super(192, 168, 160, 80)
    create_contents
    @item_max = 2
    @column_max = 2
    self.index = index
    self.active = false
    self.openness = 0
    refresh
  end
  #--------------------------------------------------------------------------
  def refresh
    for i in 0..@item_max
      rect = item_rect(i)
      self.contents.clear_rect(rect)
    end
    self.contents.draw_text(0, 0, self.contents.width, WLH, "Confirmation?", 1)
    rect = item_rect(0)
    self.contents.draw_text(rect, "Oui", 1)
    rect = item_rect(1)
    self.contents.draw_text(rect, "Non", 1)
  end
  #--------------------------------------------------------------------------
  def item_rect(index)
    rect = Rect.new(0, 0, 0, 0)
    rect.width = (contents.width + @spacing) / @column_max - @spacing
    rect.height = WLH
    rect.x = index % @column_max * (rect.width + @spacing)
    rect.y = (index / @column_max * WLH) + WLH
    return rect
  end
end

# Ce module donne un niveau supplémentaire pour chaque arme
module RPG
  class Weapon < BaseItem
  attr_accessor :level
  alias akin_weapon_level_system_ini initialize
    def initialize
      akin_weapon_level_system_ini
      @level = 1
    end
  end
end

# Ce module calcule le niveau supplémentaire de chaque arme
module Akin_Weapons
  def self.level_up(weapon_input)
    if weapon_input.level == nil or weapon_input.level == 0
      weapon_input.level = 1
    end
    weapon_input.level += 1
   
    #--------Fonctions niveau supplémentaire-------------A34sZ1A -----------------------
    # Les stats augmentent de 20 % de leur valeur précédente + 1
    # A chaque niveau supplémentaire cette formule est appliquée
    # Soyez sure que vous renvoyez un entier grâce à "Integer()"
    # Si vous modifiez la fonction, une autre à besoin d'être changée
    # cherchez  BZ8q1
    weapon_input.atk = Integer(weapon_input.atk * 1.2 + 1)
    weapon_input.def = Integer(weapon_input.def * 1.2 + 1)
    weapon_input.spi = Integer(weapon_input.spi * 1.2 + 1)
    weapon_input.agi = Integer(weapon_input.agi * 1.2 + 1)
    #-------Fin des fonctions niveau supplémentaire-----------------------------------------
  end
end

#------------------------------------------------------------------------------
#  Ajoute des méthodes  à window_base pour afficher l'icône de l'arme équipée
#==============================================================================

class Window_Base < Window
  def draw_actor_weapon(actor, x, y)
    self.contents.font.color = power_up_color
    self.contents.draw_text(x, y, 96, WLH, "Equipé :")
    self.contents.font.color = normal_color
    n = actor.weapon_id
    equiped_weapon = $data_weapons[n]
    if equiped_weapon == nil
      self.contents.draw_text(x + 8, y + WLH, 192, WLH, "Aucun")
    else
      self.contents.draw_text(x + 8, y + WLH, 192, WLH, equiped_weapon.name)
      if equiped_weapon.level == nil or equiped_weapon.level == 0
        $data_weapons[n].level = 1
        equiped_weapon = $data_weapons[n]
      end
      self.contents.font.color = system_color
      self.contents.draw_text(x + 8, y + WLH * 2, 112, WLH, "Arme Niv. :")
      self.contents.font.color = normal_color
      self.contents.draw_text(x + 120, y + WLH * 2, 64, WLH, equiped_weapon.level)
    end
  end
end

#==============================================================================
# ** Window_Char_WeaponStatus
#------------------------------------------------------------------------------
#  Cette fenêtre affiche chaque arme des joueurs, le niveau des armes sur l'écran
#==============================================================================

class Window_Char_WeaponStatus < Window_Selectable
  #--------------------------------------------------------------------------
  # * Initialisation de l'objet
  #    x : Coordonnée X de la fenêtre
  #    y : Coordonnée Y de la fenêtre
  #--------------------------------------------------------------------------
  def initialize(x, y)
    super(x, y, 384, 416)
    refresh
    self.active = false
    self.index = -1
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    @item_max = $game_party.members.size
    for actor in $game_party.members
      draw_actor_face(actor, 2, actor.index * 96 + 2, 92)
      x = 104
      y = actor.index * 96 + WLH / 2
      draw_actor_name(actor, x, y)
      draw_actor_class(actor, x, y + WLH * 2)
      draw_actor_level(actor, x, y + WLH * 1)
      draw_actor_weapon(actor, x + 96, y)
    end
  end
  #--------------------------------------------------------------------------
  # * Update cursor
  #--------------------------------------------------------------------------
  def update_cursor
    if @index < 0              # No cursor
      self.cursor_rect.empty
    elsif @index < @item_max    # Normal
      self.cursor_rect.set(0, @index * 96, contents.width, 96)
    elsif @index >= 100        # Self
      self.cursor_rect.set(0, (@index - 100) * 96, contents.width, 96)
    else                        # All
      self.cursor_rect.set(0, 0, contents.width, @item_max * 96)
    end
  end
end

#==============================================================================
# ** Window_Akin_Price
#------------------------------------------------------------------------------
#  Cette fenêtre affiche le prix de l'amélioration
#=============================================================================

class Window_Akin_Price < Window_Base
  #--------------------------------------------------------------------------
  # * Initialisation de l'objet
  #    x : Coordonnée X de la fenêtre
  #    y : Coordonnée Y de la fenêtre
  #--------------------------------------------------------------------------
  def initialize(x, y, price = 0)
    super(x, y, 160, 72)
    @price = price
    refresh(@price)
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh(price)
    self.contents.clear
    self.contents.draw_text(0, -4, 80, 24, "Prix")
    draw_currency_value(price, 4, 12, 120)
  end
end


#==============================================================================
# ** Window_WeapUpgradeStatus
#------------------------------------------------------------------------------
#  Cette fenêtre vous indique ce que l'amélioration fera a votre arme
#==============================================================================

class Window_WeapUpgradeStatus < Window_Base
  #--------------------------------------------------------------------------
  # * Initialisation de l'objet
  #    x : Coordonnée X de la fenêtre
  #    y : Coordonnée Y de la fenêtre
  #    actor : Héros
  #--------------------------------------------------------------------------
  def initialize(x, y, weapon)
    super(x, y, 160, WLH * 4 + 32)
    @weapon = weapon
    refresh(@weapon)
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh(weapon)
    @weapon = weapon
    unless @weapon == nil
      self.contents.clear
      draw_parameter(0, 0, 0)
      draw_parameter(0, WLH * 1, 1)
      draw_parameter(0, WLH * 2, 2)
      draw_parameter(0, WLH * 3, 3)
    end
  end
  #--------------------------------------------------------------------------
  # * Paramètres après l'équipement
  #    new_atk : Attaque après l'équipement
  #    new_def : Défense après l'équipement
  #    new_spi : Esprit/Intelligence  après l'équipement
  #    new_agi : Agilité après l'équipement
  #--------------------------------------------------------------------------
  def set_new_stats(new_atk, new_def, new_spi, new_agi)
    if @new_atk != new_atk or @new_def != new_def or
      @new_spi != new_spi or @new_agi != new_agi
      @new_atk = new_atk
      @new_def = new_def
      @new_spi = new_spi
      @new_agi = new_agi
      refresh(@weapon)
    end
  end
  #--------------------------------------------------------------------------
  # * Get Post Equip Parameter Drawing Color
  #    old_value : parameter before equipment change
  #    new_value : parameter after equipment change
  #--------------------------------------------------------------------------
  def new_parameter_color(old_value, new_value)
    if new_value > old_value      # Get stronger
      return power_up_color
    elsif new_value == old_value  # No change
      return normal_color
    else                          # Get weaker
      return power_down_color
    end
  end
  #--------------------------------------------------------------------------
  # * Afficher les paramètres
  #    x    :  draw spot x-coordinate
  #    y    : draw spot y-coordinate
  #    type : type du paramètre (0 - 3)
  #--------------------------------------------------------------------------
  def draw_parameter(x, y, type)
    case type
    when 0
      name = "For."  # inscrivez Ici ce qui correspond à la Force (5 Caractères Max.)
      value = @weapon.atk
      new_value = @new_atk
    when 1
      name = "Def." # inscrivez Ici  ce qui correspond à la Défense (5 Caractères Max.)
      value = @weapon.def
      new_value = @new_def
    when 2
      name = "Int." # inscrivez Ici  ce qui correspond à la Intelligence (5 Caractères Max.)
      value = @weapon.spi
      new_value = @new_spi
    when 3
      name = "Agi." # inscrivez Ici  ce qui correspond à la Agilité (5 Caractères Max.)
      value = @weapon.agi
      new_value = @new_agi
    end
    self.contents.font.color = system_color
    self.contents.draw_text(x + 4, y, 80, WLH, name)
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 50, y, 30, WLH, value, 2)
    self.contents.font.color = system_color
    self.contents.draw_text(x + 79, y, 20, WLH, ">", 1)
    if new_value != nil
      self.contents.font.color = new_parameter_color(value, new_value)
      self.contents.draw_text(x + 98, y, 30, WLH, new_value, 2)
    end
  end
end

#==============================================================================
# ** Scene_Weapons_Upgrade
#------------------------------------------------------------------------------
#  Cette classe indique le processus d'amélioration de l'arme
#==============================================================================

class Scene_Weapons_Upgrade < Scene_Base
  #--------------------------------------------------------------------------
  # * Initialisation de l'objet
  #    weapon_up_index : Position initiale du curseur de commande
  #--------------------------------------------------------------------------
  def initialize(weapon_up_index = 0, player_index = 0)
    @weapon_up_index = weapon_up_index
    @actor_index = player_index
    @actor = $game_party.members[player_index]
    n = @actor.weapon_id
    @weapon = $data_weapons[n]
  end
  #--------------------------------------------------------------------------
  # * Démarrage du processus
  #--------------------------------------------------------------------------
  def start
    super
    create_menu_background
    create_select_window
    @gold_window = Window_Gold.new(384, 360)
    @character_window = Window_Char_WeaponStatus.new(0, 0)
    @header_window = Window_Base.new(384, 0, 160, 80)
    #--------Shop Heading --------------------A34sZ1A -----------------------
    @header_window.contents.draw_text(0, 0, 128, 24, "Choisissez l'arme", 1)
    @header_window.contents.draw_text(0, 24, 128, 24, "à améliorer", 1)
    #--------Shop Heading End ----------------A34sZ1A -----------------------
    @upgrade_window = Window_WeapUpgradeStatus.new(384, 160, @weapon)
    @upgrade_window.visible = false
    @price_window = Window_Akin_Price.new(384, 288, 0)
    @price_window.visible = false
    @confirm_window = Window_Confirm.new
    @confirm_window.visible = false
  end
  #--------------------------------------------------------------------------
  # * Fin du processus
  #--------------------------------------------------------------------------
  def terminate
    super
    dispose_menu_background
    @select_window.dispose
    @gold_window.dispose
    @character_window.dispose
    @header_window.dispose
    @upgrade_window.dispose
    @price_window.dispose
    @confirm_window.dispose
    $game_party.last_actor_index = 0
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    update_menu_background
    @select_window.update
    @gold_window.update
    @character_window.update
    @confirm_window.update
    if @select_window.active
      @upgrade_window.visible = false
      @price_window.visible = false
      update_select_selection
    elsif @character_window.active
      @upgrade_window.visible = true
      @price_window.visible = true
      update_actor_selection
      update_weapon_upgrade
    elsif @confirm_window.active
      update_confirm_window_selection
    end
  end
  #--------------------------------------------------------------------------
  # * Création d'une fenêtre de confirmation
  #--------------------------------------------------------------------------
  def create_select_window
  #--------Textes du menus -------------A34sZ1A ------------------------
    s1 = "Améliorer"
    s2 = "Quitter"
  #------- Fin----------------------------------------------------------------------
    @select_window = Window_Command.new(160, [s1, s2])
    @select_window.x = 384
    @select_window.y = 80
    @select_window.index = @weapon_up_index
  end
  #--------------------------------------------------------------------------
  # * Update Command Selection
  #--------------------------------------------------------------------------
  def update_select_selection
    if Input.trigger?(Input::B)
      Sound.play_cancel
      return_scene
    elsif Input.trigger?(Input::C)
      Sound.play_decision
      case @select_window.index
      when 0      # Upgrade
        start_actor_selection
      when 1      # Back
        return_scene
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Start Actor Selection
  #--------------------------------------------------------------------------
  def start_actor_selection
    @select_window.active = false
    @character_window.active = true
    @character_window.index = 0
  end
  #--------------------------------------------------------------------------
  # * End Actor Selection
  #--------------------------------------------------------------------------
  def end_actor_selection
    @select_window.active = true
    @character_window.active = false
    @character_window.index = -1
  end
  #--------------------------------------------------------------------------
  # * Update Actor Selection
  #--------------------------------------------------------------------------
  def update_actor_selection
    if Input.trigger?(Input::B)
      @upgrade_window.visible = false
      @price_window.visible = false
      Sound.play_cancel
      end_actor_selection
    elsif Input.trigger?(Input::C)
      $game_party.last_actor_index = @character_window.index
      upgrade_weapon($game_party.last_actor_index)
    end
  end
  #--------------------------------------------------------------------------
  # * Update Confirm Window
  #--------------------------------------------------------------------------
  def update_confirm_window_selection
    if Input.trigger?(Input::B)
      Sound.play_cancel
      @confirm_window.active = false
      @confirm_window.visible = false
      @confirm_window.index = 0
      @character_window.active = true
      @confirm_window.close
    elsif Input.trigger?(Input::C)
      if @confirm_window.index == 0 # Yes
        @confirm_window.active = false
        @confirm_window.visible = false
        @confirm_window.index = 0
        @character_window.active = true
        Sound.play_use_skill
        player_index = @character_window.index
        @actor = $game_party.members[player_index]
        n = @actor.weapon_id
        equiped_weapon = $data_weapons[n]
        $game_party.lose_gold(@price)
        Akin_Weapons.level_up(equiped_weapon)
        @character_window.refresh
        @gold_window.refresh
      elsif @confirm_window.index == 1 # No
        Sound.play_cancel
        @confirm_window.active = false
        @confirm_window.visible = false
        @confirm_window.index = 0
        @character_window.active = true
        @confirm_window.close
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Update Upgrade Window
  #--------------------------------------------------------------------------
  def update_weapon_upgrade
    player_index = @character_window.index
    @actor = $game_party.members[player_index]
    n = @actor.weapon_id
    @weapon = $data_weapons[n]
    unless @weapon == nil
      #--------Formule des prix -------------A34sZ1A -----------------------
      # Les prix augmentent de 20 % de leur valeur précédente + 1
      # La valeur est affiché dans la fenêtre
      # Soyez sur que la valeur soit un entier en utilisant ".to_i"
      # Si vous modifiez la fonction, une autre à besoin d'être changée
      # cherchez  SER23
      temp = Math.exp(@weapon.level / 1.7)
      @price = 100 * @weapon.level + temp
      @price = @price.to_i
      #-------Fin de la formule des prix ---------------------------------------------
      @upgrade_window.refresh(@weapon)
      @price_window.refresh(@price)
      @upgrade_window.visible = true
      @price_window.visible = true
      if @weapon.level < 20
        #--------Fonctions niveau supplémentaire------BZ8q1-------A34sZ1A -----------------------
        # Les niveaux augmentent de 20 % de leur valeur précédente + 1
        #  Faites que cette formule soit la même que celle mise pour  le niveau supplémentaire
        # La valeur est affiché dans la fenêtre
        # Soyez sur que la valeur soit un entier en utilisant "Integer()"
        after_atk = Integer(@weapon.atk * 1.2 + 1)
        after_def = Integer(@weapon.def * 1.2 + 1)
        after_spi = Integer(@weapon.spi * 1.2 + 1)
        after_agi = Integer(@weapon.agi * 1.2 + 1)
        #-------Fin des fonctions niveau supplémentaire-----------------------------------------
        @upgrade_window.set_new_stats(after_atk, after_def, after_spi, after_agi)
      else
        @upgrade_window.set_new_stats(@weapon.atk, @weapon.def, @weapon.spi, @weapon.agi)
        @price_window.refresh("/ ")
      end
    else
      @upgrade_window.visible = false
      @price_window.visible = false
    end
  end
  #--------------------------------------------------------------------------
  # * Upgrade Weapon Selected
  #--------------------------------------------------------------------------
  def upgrade_weapon(player_index)
    @actor = $game_party.members[player_index]
    n = @actor.weapon_id
    equiped_weapon = $data_weapons[n]
    if equiped_weapon == nil
      Sound.play_buzzer
    else
      #--------Formule des prix ----SER23---------A34sZ1A -------------------
      # Les niveaux augmentent de 20 % de leur valeur précédente + 1
      # Faites que cette formule soit la même que celle mise pour  la formule des prix
      #  La valeur est affiché dans la fenêtre
      # Soyez sur que la valeur soit un entier en utilisant ".to_i"
      temp = Math.exp(@weapon.level / 1.7)
      @price = 100 * @weapon.level + temp
      @price = @price.to_i
      #-------Fin de la Formule des prix ---------------------------------------------
     
      #--------Niveau maximum de l'arme-------------A34sZ1A -----------------------
      # Changer le nombre après"if equiped_weapon.level >="
      # en le niveau maximum que l'arme peut atteindre
      if equiped_weapon.level >= 20
      #--------Fin niveau maximum de l'arme---- ---A34sZ1A -----------------------
        Sound.play_buzzer
      elsif @price > $game_party.gold
        Sound.play_buzzer
      else
        Sound.play_decision
        @confirm_window.visible = true
        @character_window.active = false
        @confirm_window.open
        @confirm_window.index = 0
        @confirm_window.active = true
      end
        @character_window.refresh
    end
  end
 
  #--------------------------------------------------------------------------
  # * Retour à la map
  #--------------------------------------------------------------------------
  def return_scene
    #--------Fin du retour-------------A34sZ1A -----------------------
    # Éditez cette ligne de code si vous voulez  utiliser ce système par
    # le menu principal
    #$scene = Scene_Menu.new(0) # Changez ce nombre pour placer le curseur dans le menu
    $scene = Scene_Map.new
  end
end


# Cela édite la classe Scene_File pour ajouter une option de sauvegarde et de chargement des niveaux des armes.
class Scene_File < Scene_Base
  #-------------------------------Alias List
  alias akin_weaps_write_save_data write_save_data
  alias akin_weaps_read_save_data read_save_data
 
  def write_save_data(file)
   akin_weaps_write_save_data(file)
   Marshal.dump($data_weapons,        file)
  end
 
  def read_save_data(file)
   akin_weaps_read_save_data(file)
   $data_weapons        = Marshal.load(file)
  end
end

#===============================================================
# ● [VX] ◦ Neo Save System with Unlimited save slots ◦ □
#--------------------------------------------------------------
# ◦ by Woratana [woratana@hotmail.com]
# ◦ Thaiware RPG Maker Community
# ◦ Released on: 04/05/2008
# ◦ Version: 1.0
#--------------------------------------------------------------
# ◦ Credit: - Andreas21 and Cybersam for Screenshot Script
# - Traduction du module Wora_NSS : Blockade
# - RPG Revolution for hosted screenshot DLL file.
#--------------------------------------------------------------
# ◦ Requirement: screenshot.dll by Andreas21.
# You can download it from:
# http://www.rpgrevolution.com/users/woratana/DLL_file/
# Put it in project folder. (folder that has Game.exe)
#--------------------------------------------------------------
# ◦ Features:
# - Slot de sauvegardes illimités, vous pouvez choisir le nombre de slots.
# - Vous pouvez integrer une image de fond.
# - Choisisez le nom des sauvegardes, le dossier ou seront stocké vos fichiers de sauvegardes
# - Choisisez les informations que vous vouler afficher
# - Texte des titres d'information éditables
# - Inclus Screenshot de la map actuelle, possibilité de choisir l'extension du fichier image.
# - Enlevez le texte que vous ne voulez pas du nom des maps (e.g. tags pour script spécial)
# - Choissiez les maps que vous ne voulez pasque leurs nom apparaissent
# - Inclus confirmation de sauvegarde
#=================================================================

module Wora_NSS
  #==========================================================================
  # * START NEO SAVE SYSTEM - SETUP
  #--------------------------------------------------------------------------
  NSS_WINDOW_OPACITY = 255 # Opacitée de TOUTES les fenêtres (De  0 à 255)
  # Vous pouvez la mettre a 0, si vous voulez utliser une image de fond
  NSS_IMAGE_BG = "" # Image de fond, a placer dans le dossier "picture" mettre le nom de l'image a la place des "".
  # Si vous ne voulez pas d'image de fond, mettez ""
  NSS_IMAGE_BG_OPACITY = 255 # Opacité de l'image de fond
 
  MAX_SAVE_SLOT = 50 # Nombre maximum de Slot.
  SLOT_NAME = 'Partie {id}'
  # Nom des slots ( Montrés dans le menu de sauvegarde) Utilisez {id} pour l'ID du slot
  SAVE_FILE_NAME = 'Save{id}.rvdata'
  # Nom du fichier de sauvegarde ( dans votre dossier du jeu)
  #  Utilisez {id} pour l'ID du slot
  SAVE_PATH = ""
  # Chemin d'accés pour le dossier, ou sont stocké les fichiers de sauvegardes,
  # ( 'Save/'  pour qu'ils soient stocké dans un dossier nommné Save qui se trouve a la racine de votre jeu ( Ou se trouve le game.exe)
  # Mettez "" pour l'emplacement d'origine
 
  SAVED_SLOT_ICON = 133 # Numéro de l'icone pour une partie sauveagrdée
  EMPTY_SLOT_ICON = 141 # Numéro de l'icone pour un slot vide
 
  IMAGE_FILETYPE = '.png' # IType de l'image pour le screenshot sauvegardé
  # '.bmp', ou '.jpg', ou '.png'
 
  EMPTY_SLOT_TEXT = 'VIDE' # Texte quand le slot est vide
 
  # Remplacer true par false pour desactiver
 
  DRAW_GOLD = true # Afficher l'argent
  DRAW_PLAYTIME = true # Afficher le temps de jeu
  DRAW_LOCATION = true # Affichier la localisation
  DRAW_FACE = true # Affichier le faceset des heros
  DRAW_LEVEL = false # Afficher le level des heros
  DRAW_NAME = true # Afficher le nom des heros
 
  PLAYTIME_TEXT = 'Temps de jeu: '
  GOLD_TEXT = 'Argent : '
  LOCATION_TEXT = 'Localisation : '
  LV_TEXT = 'Niv. '
 
  MAP_NAME_TEXT_SUB = %w{}
  # Texte que vous voulez enlever du nom de la map,
  # e.g. %w{[LN] [DA]} enléve '[LN]' et '[DA]' du nom de la map
  MAP_NO_NAME_LIST = [] # ID of Map that will not show map name, e.g. [1,2,3]
  MAP_NO_NAME_NAME = '??????????' # What you will use to call map in no name list
 
  MAP_BORDER = Color.new(0,0,0,200) # Couleur de la bordure du Screenshoot de la Map(Rouge,Vert,Bleu,Opacité)
  FACE_BORDER = Color.new(0,0,0,200) # Face border color
 
  ## SAVE CONFIRMATION WINDOW ##
  SFC_Text_Confirm = 'Sauvegarder' #Texte pour confirmer la sauvegarde
  SFC_Text_Cancel = 'Annuler' # Texte pour annuler le remplacement de la ssauvegarde
  SFC_Window_Width = 270 # Taille de la fenêtre de comfirmation
  SFC_Window_X_Offset = 0  # Position horrizontale de la fenêtre de confirmation ( 0 au milieu)
  SFC_Window_Y_Offset =  0 # Position verticale de la fenêtre de confirmation ( 0 au milieu)
  #----------------------------------------------------------------------
  # END NEO SAVE SYSTEM - SETUP
  #=========================================================================

  #-------------------------------------------------------------
  # Screenshot V2 by Andreas21 and Cybersam
  #-------------------------------------------------------------
  @screen = Win32API.new 'screenshot', 'Screenshot', %w(l l l l p l l), ''
  @readini = Win32API.new 'kernel32', 'GetPrivateProfileStringA', %w(p p p p l p), 'l'
  @findwindow = Win32API.new 'user32', 'FindWindowA', %w(p p), 'l'
  module_function
  def self.shot(file_name)
    case IMAGE_FILETYPE
    when '.bmp'; typid = 0
    when '.jpg'; typid = 1
    when '.png'; typid = 2
    end
    # Get Screenshot
    filename = file_name + IMAGE_FILETYPE
    @screen.call(0, 0, Graphics.width, Graphics.height, filename, self.handel,
    typid)
  end
  def self.handel
    game_name = "\0" * 256
    @readini.call('Game','Title','',game_name,255,".\\Game.ini")
    game_name.delete!("\0")
    return @findwindow.call('RGSS Player',game_name)
  end
end

class Scene_File < Scene_Base
  include Wora_NSS
  attr_reader :window_slotdetail
  #--------------------------------------------------------------------------
  # * Start processing
  #--------------------------------------------------------------------------
  def start
    super
    create_menu_background
    if NSS_IMAGE_BG != ''
      @bg = Sprite.new
      @bg.bitmap = Cache.picture(NSS_IMAGE_BG)
      @bg.opacity = NSS_IMAGE_BG_OPACITY
    end
    @help_window = Window_Help.new
    command = []
    (1..MAX_SAVE_SLOT).each do |i|
      command << SLOT_NAME.clone.gsub!(/\{ID\}/i) { i.to_s }
    end
    @window_slotdetail = Window_NSS_SlotDetail.new
    @window_slotlist = Window_SlotList.new(160, command)
    @window_slotlist.y = @help_window.height
    @window_slotlist.height = Graphics.height - @help_window.height
    @help_window.opacity = NSS_WINDOW_OPACITY
    @window_slotdetail.opacity = @window_slotlist.opacity = NSS_WINDOW_OPACITY
   
    # Create Folder for Save file
  if SAVE_PATH != ''
    Dir.mkdir(SAVE_PATH) if !FileTest.directory?(SAVE_PATH)
  end
    if @saving
      @index = $game_temp.last_file_index
      @help_window.set_text(Vocab::SaveMessage)
    else
      @index = self.latest_file_index
      @help_window.set_text(Vocab::LoadMessage)
      (1..MAX_SAVE_SLOT).each do |i|
        @window_slotlist.draw_item(i-1, false) if !@window_slotdetail.file_exist?(i)
      end
    end
    @window_slotlist.index = @index
    # Draw Information
    @last_slot_index = @window_slotlist.index
    @window_slotdetail.draw_data(@last_slot_index + 1)
  end
  #--------------------------------------------------------------------------
  # * Termination Processing
  #--------------------------------------------------------------------------
  def terminate
    super
    dispose_menu_background
    unless @bg.nil?
      @bg.bitmap.dispose
      @bg.dispose
    end
    @window_slotlist.dispose
    @window_slotdetail.dispose
    @help_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    if !@confirm_window.nil?
      @confirm_window.update
      if Input.trigger?(Input::C)
        if @confirm_window.index == 0
          determine_savefile
          @confirm_window.dispose
          @confirm_window = nil
        else
          Sound.play_cancel
          @confirm_window.dispose
          @confirm_window = nil
        end
      elsif Input.trigger?(Input::B)
      Sound.play_cancel
      @confirm_window.dispose
      @confirm_window = nil
      end
    else
      update_menu_background
      @window_slotlist.update
      if @window_slotlist.index != @last_slot_index
        @last_slot_index = @window_slotlist.index
        @window_slotdetail.draw_data(@last_slot_index + 1)
      end
      @help_window.update
      update_savefile_selection
    end
  end
  #--------------------------------------------------------------------------
  # * Update Save File Selection
  #--------------------------------------------------------------------------
  def update_savefile_selection
    if Input.trigger?(Input::C)
      if @saving and @window_slotdetail.file_exist?(@last_slot_index + 1)
        Sound.play_decision
        text1 = SFC_Text_Confirm
        text2 = SFC_Text_Cancel
        @confirm_window = Window_Command.new(SFC_Window_Width,[text1,text2])
        @confirm_window.x = ((544 - @confirm_window.width) / 2) + SFC_Window_X_Offset
        @confirm_window.y = ((416 - @confirm_window.height) / 2) + SFC_Window_Y_Offset
      else
        determine_savefile
      end
    elsif Input.trigger?(Input::B)
      Sound.play_cancel
      return_scene
    end
  end
  #--------------------------------------------------------------------------
  # * Execute Save
  #--------------------------------------------------------------------------
  def do_save
    File.rename(SAVE_PATH + 'temp' + IMAGE_FILETYPE,
    make_filename(@last_slot_index).gsub(/\..*$/){ '_ss' } + IMAGE_FILETYPE)
    file = File.open(make_filename(@last_slot_index), "wb")
    write_save_data(file)
    file.close
    $scene = Scene_Map.new
  end
  #--------------------------------------------------------------------------
  # * Execute Load
  #--------------------------------------------------------------------------
  def do_load
    file = File.open(make_filename(@last_slot_index), "rb")
    read_save_data(file)
    file.close
    $scene = Scene_Map.new
    RPG::BGM.fade(1500)
    Graphics.fadeout(60)
    Graphics.wait(40)
    @last_bgm.play
    @last_bgs.play
  end
  #--------------------------------------------------------------------------
  # * Confirm Save File
  #--------------------------------------------------------------------------
  def determine_savefile
    if @saving
      Sound.play_save
      do_save
    else
      if @window_slotdetail.file_exist?(@last_slot_index + 1)
        Sound.play_load
        do_load
      else
        Sound.play_buzzer
        return
      end
    end
    $game_temp.last_file_index = @last_slot_index
  end
  #--------------------------------------------------------------------------
  # * Create Filename
  #    file_index : save file index (0-3)
  #--------------------------------------------------------------------------
  def make_filename(file_index)
    return SAVE_PATH + SAVE_FILE_NAME.gsub(/\{ID\}/i) { (file_index + 1).to_s }
  end
  #--------------------------------------------------------------------------
  # * Select File With Newest Timestamp
  #--------------------------------------------------------------------------
  def latest_file_index
    latest_index = 0
    latest_time = Time.at(0)
    (1..MAX_SAVE_SLOT).each do |i|
      file_name = make_filename(i - 1)
      next if !@window_slotdetail.file_exist?(i)
      file_time = File.mtime(file_name)
      if file_time > latest_time
        latest_time = file_time
        latest_index = i - 1
      end
    end
    return latest_index
  end
end

class Window_SlotList < Window_Command
  #--------------------------------------------------------------------------
  # * Draw Item
  #--------------------------------------------------------------------------
  def draw_item(index, enabled = true)
    rect = item_rect(index)
    rect.x += 4
    rect.width -= 8
    icon_index = 0
    self.contents.clear_rect(rect)
    if $scene.window_slotdetail.file_exist?(index + 1)
      icon_index = Wora_NSS::SAVED_SLOT_ICON
    else
      icon_index = Wora_NSS::EMPTY_SLOT_ICON
    end
    if !icon_index.nil?
      rect.x -= 4
      draw_icon(icon_index, rect.x, rect.y, enabled) # Draw Icon
      rect.x += 26
      rect.width -= 20
    end
    self.contents.clear_rect(rect)
    self.contents.font.color = normal_color
    self.contents.font.color.alpha = enabled ? 255 : 128
    self.contents.draw_text(rect, @commands[index])
  end
 
  def cursor_down(wrap = false)
    if @index < @item_max - 1 or wrap
      @index = (@index + 1) % @item_max
    end
  end

  def cursor_up(wrap = false)
    if @index > 0 or wrap
      @index = (@index - 1 + @item_max) % @item_max
    end
  end
end

class Window_NSS_SlotDetail < Window_Base
  include Wora_NSS
  def initialize
    super(160, 56, 384, 360)
    @data = []
    @exist_list = []
    @bitmap_list = {}
    @map_name = []
  end

  def draw_data(slot_id)
    contents.clear # 352, 328
    load_save_data(slot_id) if @data[slot_id].nil?
    if @exist_list[slot_id]
      save_data = @data[slot_id]
      # DRAW SCREENSHOT~
      contents.fill_rect(0,30,352,160, MAP_BORDER)
      if save_data['ss']
        bitmap = get_bitmap(save_data['ss_path'])
        rect = Rect.new((Graphics.width-348)/2,(Graphics.height-156)/2,348,156)
        contents.blt(2,32,bitmap,rect)
      end
    if DRAW_GOLD
      # DRAW GOLD
      gold_textsize = contents.text_size(save_data['gamepar'].gold).width
      goldt_textsize = contents.text_size(GOLD_TEXT).width
      contents.font.color = system_color
      contents.draw_text(0, 0, goldt_textsize, WLH, GOLD_TEXT)
      contents.draw_text(goldt_textsize + gold_textsize,0,200,WLH, Vocab::gold)
      contents.font.color = normal_color
      contents.draw_text(goldt_textsize, 0, gold_textsize, WLH, save_data['gamepar'].gold)
    end
    if DRAW_PLAYTIME
      # DRAW PLAYTIME
      hour = save_data['total_sec'] / 60 / 60
      min = save_data['total_sec'] / 60 % 60
      sec = save_data['total_sec'] % 60
      time_string = sprintf("%02d:%02d:%02d", hour, min, sec)
      pt_textsize = contents.text_size(PLAYTIME_TEXT).width
      ts_textsize = contents.text_size(time_string).width
      contents.font.color = system_color
      contents.draw_text(contents.width - ts_textsize - pt_textsize, 0,
      pt_textsize, WLH, PLAYTIME_TEXT)
      contents.font.color = normal_color
      contents.draw_text(0, 0, contents.width, WLH, time_string, 2)
    end
    if DRAW_LOCATION
      # DRAW LOCATION
      lc_textsize = contents.text_size(LOCATION_TEXT).width
      mn_textsize = contents.text_size(save_data['map_name']).width
      contents.font.color = system_color
      contents.draw_text(0, 190, contents.width,
      WLH, LOCATION_TEXT)
      contents.font.color = normal_color
      contents.draw_text(lc_textsize, 190, contents.width, WLH,
      save_data['map_name'])
    end
      # DRAW FACE & Level & Name
      save_data['gamepar'].members.each_index do |i|
        actor = save_data['gamepar'].members[i]
        face_x_base = (i*80) + (i*8)
        face_y_base = 216
        lvn_y_plus = 10
        lv_textsize = contents.text_size(actor.level).width
        lvt_textsize = contents.text_size(LV_TEXT).width
      if DRAW_FACE
        # Draw Face
        contents.fill_rect(face_x_base, face_y_base, 84, 84, FACE_BORDER)
        draw_face(actor.face_name, actor.face_index, face_x_base + 2,
        face_y_base + 2, 80)
      end
      if DRAW_LEVEL
        # Draw Level
        contents.font.color = system_color
        contents.draw_text(face_x_base + 2 + 80 - lv_textsize - lvt_textsize,
        face_y_base + 2 + 80 - WLH + lvn_y_plus, lvt_textsize, WLH, LV_TEXT)
        contents.font.color = normal_color
        contents.draw_text(face_x_base + 2 + 80 - lv_textsize,
        face_y_base + 2 + 80 - WLH + lvn_y_plus, lv_textsize, WLH, actor.level)
      end
      if DRAW_NAME
        # Draw Name
        contents.draw_text(face_x_base, face_y_base + 2 + 80 + lvn_y_plus - 6, 84,
        WLH, actor.name, 1)
      end
      end
    else
      contents.draw_text(0,0, contents.width, contents.height - WLH, EMPTY_SLOT_TEXT, 1)
    end
  end
 
  def load_save_data(slot_id)
    file_name = make_filename(slot_id)
    if file_exist?(slot_id) or FileTest.exist?(file_name)
      @exist_list[slot_id] = true
      @data[slot_id] = {}
      # Start load data
      file = File.open(file_name, "r")
      @data[slot_id]['time'] = file.mtime
      @data[slot_id]['char'] = Marshal.load(file)
      @data[slot_id]['frame'] = Marshal.load(file)
      @data[slot_id]['last_bgm'] = Marshal.load(file)
      @data[slot_id]['last_bgs'] = Marshal.load(file)
      @data[slot_id]['gamesys'] = Marshal.load(file)
      @data[slot_id]['gamemes'] = Marshal.load(file)
      @data[slot_id]['gameswi'] = Marshal.load(file)
      @data[slot_id]['gamevar'] = Marshal.load(file)
      @data[slot_id]['gameselfvar'] = Marshal.load(file)
      @data[slot_id]['gameactor'] = Marshal.load(file)
      @data[slot_id]['gamepar'] = Marshal.load(file)
      @data[slot_id]['gametro'] = Marshal.load(file)
      @data[slot_id]['gamemap'] = Marshal.load(file)
      @data[slot_id]['total_sec'] = @data[slot_id]['frame'] / Graphics.frame_rate
      @data[slot_id]['ss_path'] = file_name.gsub(/\..*$/){'_ss'} + IMAGE_FILETYPE
      @data[slot_id]['ss'] = FileTest.exist?(@data[slot_id]['ss_path'])
      @data[slot_id]['map_name'] = get_mapname(@data[slot_id]['gamemap'].map_id)
      file.close
    else
      @exist_list[slot_id] = false
      @data[slot_id] = -1
    end
  end

  def make_filename(file_index)
    return SAVE_PATH + SAVE_FILE_NAME.gsub(/\{ID\}/i) { (file_index).to_s }
  end
 
  def file_exist?(slot_id)
    return @exist_list[slot_id] if !@exist_list[slot_id].nil?
    @exist_list[slot_id] = FileTest.exist?(make_filename(slot_id))
    return @exist_list[slot_id]
  end

  def get_mapname(map_id)
    if @map_data.nil?
      @map_data = load_data("Data/MapInfos.rvdata")
    end
    if @map_name[map_id].nil?
      if MAP_NO_NAME_LIST.include?(map_id)
        @map_name[map_id] = MAP_NO_NAME_NAME
      else
        @map_name[map_id] = @map_data[map_id].name
        MAP_NAME_TEXT_SUB.each_index do |i|
          @map_name[map_id].sub!(MAP_NAME_TEXT_SUB[i], '')
        end
      end
    end
    return @map_name[map_id]
  end
 
  def get_bitmap(path)
    if !@bitmap_list.include?(path)
      @bitmap_list[path] = Bitmap.new(path)
    end
    return @bitmap_list[path]
  end
 
  def dispose
    @bitmap_list.each {|i| i[1].dispose }
    super
  end
end

class Scene_Title < Scene_Base
  def check_continue
    file_name = Wora_NSS::SAVE_PATH + Wora_NSS::SAVE_FILE_NAME.gsub(/\{ID\}/i) { '*' }
    @continue_enabled = (Dir.glob(file_name).size > 0)
  end
end

class Scene_Map < Scene_Base
  alias wora_nss_scemap_ter terminate
  def terminate
    Wora_NSS.shot(Wora_NSS::SAVE_PATH + 'temp')
    wora_nss_scemap_ter
  end
end
#======================================================================
# END - NEO SAVE SYSTEM by Woratana

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/

#_/ ? ??????? - KGC_LargeParty ? VX ?

#_/ ? Last update : 2008/02/06 ?

#_/----------------------------------------------------------------------------

#_/ 5?????????????????????

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/



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

# ? ???????? - Customize ?

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



module KGC

module LargeParty

# ? ?????????????????

# ??????? ON/OFF ???????? ??/??? ????????

PARTYFORM_SWITCH = 1

# ? ?????????????????????

# ??????????????????????????????????

BATTLE_PARTYFORM_SWITCH = 1

# ? ?????????????

# true ?????????????????????????????????

# ???? ON ??????

DEFAULT_PARTYFORM_ENABLED = true



# ? ????????? (??????)

# 5 Nombre mximum dans les combats. (pas plus de 5)

MAX_BATTLE_MEMBERS = 5

# ? ???????????

# Game_Party::MAX_MEMBERS ????????

# 100 ?????? [Window_MenuStatus] ???????

MAX_MEMBERS = 99



# ? ??????????????

# ???????????????????????????

FORBID_CHANGE_SHIFT_FIXED = false



# ? ??????????

# ????????? Color.new(0, 0, 0, 0)

STAND_BY_COLOR = Color.new(0, 0, 0, 128)

# ? ??????????

FIXED_COLOR = Color.new(255, 128, 64, 96)

# ? ?????????

SELECTED_COLOR = Color.new(64, 255, 128, 128)



# ? ????????? (???????)

# ????????????????????????????????

# ???????? nil

MENU_PARTYFORM_BUTTON = Input::A

# ? ??????????????????????

# ???????????????????????

# ?????????????«????????????» ?????????

USE_MENU_PARTYFORM_COMMAND = true

# ? ????????????????????

VOCAB_MENU_PARTYFORM = "Formation"



# ? ???????????????????

# ????????????????????(???????)???

USE_BATTLE_PARTYFORM = true

# ? ?????????????????

VOCAB_BATTLE_PARTYFORM = "Changer"



# ? ???????????????? [?, ??]

# ???????????????????????????????

PARTY_FORM_CHARACTER_SIZE = [40, 48]

# ? ????????????????????????????

BATTLE_MEMBER_BLANK_TEXT = "VIDE"

# ? ???????????????????????

# ???????????????????????

# ???? 1 ????????

PARTY_MEMBER_WINDOW_ROW_MAX = 2

# ? ??????????????????????????????

SHOW_BATTLE_MEMBER_IN_PARTY = false

# ? ??????????????????????????????

PARTY_MEMBER_BLANK_TEXT = "-"



# ? ??????????????????

CAPTION_WINDOW_WIDTH = 192

# ? ???????????????????????

BATTLE_MEMBER_CAPTION = "En combat"



if SHOW_BATTLE_MEMBER_IN_PARTY

# ? ?????????????????????????

# SHOW_BATTLE_MEMBER_IN_PARTY = true ???

PARTY_MEMBER_CAPTION = "Equipe"

else

# ? ?????????????????????????

# SHOW_BATTLE_MEMBER_IN_PARTY = false ???

PARTY_MEMBER_CAPTION = "Réserve"

end



# ? ???????????

CONFIRM_WINDOW_WIDTH = 160

# ? ?????????????

# ??????·??????????????

CONFIRM_WINDOW_COMMANDS = ["Confirmer", "Annuler", "Retour"]



# ? ???????????????????????????????

# ?????????????????????????????

# ?????????????? nil ????

# «????????????»?????????????????

SHOP_STATUS_SCROLL_BUTTON = Input::A



# ? ????????????????:‰(??? 1‰=0.1%)?

# 500 ?? 50.0% ???

STAND_BY_EXP_RATE = 500

# ? ?????????????????????????

# false ???????????????????

SHOW_STAND_BY_LEVEL_UP = true

end

end



#???????????????????????????????????????



$imported = {} if $imported == nil

$imported["LargeParty"] = true



#???????????????????????????????????????



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

# ? KGC::Commands

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



module KGC::Commands

# ??????????

SORT_BY_ID = 0 # ID?

SORT_BY_NAME = 1 # ???

SORT_BY_LEVEL = 2 # ????



module_function

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

# ? ?????????????

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

def call_partyform

return if $game_temp.in_battle

$game_temp.next_scene = :partyform

end

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

# ? ????????????

# value : ?? (????????????????)

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

def set_max_battle_member_count(value = nil)

$game_party.max_battle_member_count = value

end

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

# ? ??????????

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

def party_full?

return $game_party.full?

end

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

# ? ???????????

# enabled : ????? (??? : true)

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

def permit_partyform(enabled = true)

$game_switches[KGC::LargeParty::PARTYFORM_SWITCH] = enabled

end

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

# ? ???????????????

# enabled : ????? (??? : true)

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

def permit_battle_partyform(enabled = true)

$game_switches[KGC::LargeParty::BATTLE_PARTYFORM_SWITCH] = enabled

end

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

# ? ????????????

# actor_id : ???? ID

# fixed : ????? (??? : true)

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

def fix_actor(actor_id, fixed = true)

$game_party.fix_actor(actor_id, fixed)

end

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

# ? ????

# ????? index1 ??? index2 ????????

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

def change_party_shift(index1, index2)

$game_party.change_shift(index1, index2)

end

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

# ? ?????? (??)

# sort_type : ????? (SORT_BY_xxx)

# reverse : true ????

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

def sort_party_member(sort_type = SORT_BY_ID, reverse = false)

$game_party.sort_member(sort_type, reverse)

end

end



class Game_Interpreter

include KGC::Commands

end



#???????????????????????????????????????



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

# ¦ Vocab

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



module Vocab

# ????????????? (????)

def self.partyform

return KGC::LargeParty::VOCAB_MENU_PARTYFORM

end



# ????????????? (??)

def self.partyform_battle

return KGC::LargeParty::VOCAB_BATTLE_PARTYFORM

end

end



#???????????????????????????????????????



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

# ¦ Game_Actor

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



class Game_Actor < Game_Battler

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

# ? ?????????????

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

def party_index

return $game_party.all_members.index(self)

end

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

# ? ?????????

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

def battle_member?

return $game_party.battle_members.include?(self)

end

end



#???????????????????????????????????????



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

# ¦ Game_Party

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



class Game_Party

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

# ? ??

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

MAX_MEMBERS = KGC::LargeParty::MAX_MEMBERS # ????????

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

# ? ?????????

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

alias initialize_KGC_LargeParty initialize

def initialize

initialize_KGC_LargeParty



@max_battle_member_count = nil

@battle_member_count = 0

@fixed_actors = []

end

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

# ? ???????????

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

def max_battle_member_count

if @max_battle_member_count == nil

return KGC::LargeParty::MAX_BATTLE_MEMBERS

else

return @max_battle_member_count

end

end

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

# ? ???????????

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

def max_battle_member_count=(value)

if value.is_a?(Integer)

value = [value, 1].max

end

@max_battle_member_count = value

end

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

# ? ?????????

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

def battle_member_count

if @battle_member_count == nil

@battle_member_count = @actors.size

end

@battle_member_count =

[@battle_member_count, @actors.size, max_battle_member_count].min

return @battle_member_count

end

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

# ? ?????????

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

def battle_member_count=(value)

@battle_member_count = [[value, 0].max,

@actors.size, max_battle_member_count].min

end

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

# ? ???????

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

alias members_KGC_LargeParty members

def members

return ($game_temp.in_battle ? battle_members : members_KGC_LargeParty)

end

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

# ? ????????

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

def all_members

return members_KGC_LargeParty

end

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

# ? ?????????

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

def battle_members

result = []

battle_member_count.times { |i| result << $game_actors[@actors[i]] }

return result

end

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

# ? ?????????

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

def stand_by_members

return (all_members - battle_members)

end

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

# ? ?????????

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

def fixed_members

result = []

@fixed_actors.each { |i| result << $game_actors[i] }

return result

end

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

# ? ?????????????

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

alias setup_starting_members_KGC_LargeParty setup_starting_members

def setup_starting_members

setup_starting_members_KGC_LargeParty



self.battle_member_count = @actors.size

end

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

# ? ?????????????????

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

alias setup_battle_test_members_KGC_LargeParty setup_battle_test_members

def setup_battle_test_members

setup_battle_test_members_KGC_LargeParty



self.battle_member_count = @actors.size

end

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

# ? ?????????

# new_member : ???????

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

def set_member(new_member)

@actors = []

new_member.each { |actor| @actors << actor.id }

end

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

# ? ???????????

# new_member : ?????????

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

def set_battle_member(new_member)

new_battle_member = []

new_member.each { |actor|

@actors.delete(actor.id)

new_battle_member << actor.id

}

@actors = new_battle_member + @actors

self.battle_member_count = new_member.size

end

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

# ? ????????????????

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

def partyform_enable?

return $game_switches[KGC::LargeParty::PARTYFORM_SWITCH]

end

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

# ? ????????????????????

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

def battle_partyform_enable?

return false unless partyform_enable?

return $game_switches[KGC::LargeParty::BATTLE_PARTYFORM_SWITCH]

end

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

# ? ??????????

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

def full?

return (@actors.size >= MAX_MEMBERS)

end

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

# ? ?????????

# actor_id : ????????? ID

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

def actor_fixed?(actor_id)

return @fixed_actors.include?(actor_id)

end

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

# ? ????????

# actor_id : ???? ID

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

alias add_actor_KGC_LargeParty add_actor

def add_actor(actor_id)

last_size = @actors.size



add_actor_KGC_LargeParty(actor_id)



if last_size < @actors.size

self.battle_member_count += 1

end

end

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

# ? ????????????

# actor_id : ???? ID

# fixed : ????? (??? : false)

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

def fix_actor(actor_id, fixed = false)

unless @actors.include?(actor_id)

return

end



if fixed

# ??

unless @fixed_actors.include?(actor_id)

@fixed_actors << actor_id

unless battle_members.include?($game_actors[actor_id])

self.battle_member_count += 1

end

end

# ????

apply_force_launch

else

# ????

@fixed_actors.delete(actor_id)

end

$game_player.refresh

end

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

# ? ??????

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

def apply_force_launch

@actors -= @fixed_actors

@actors = @fixed_actors + @actors

end

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

# ? ?????? (??)

# sort_type : ????? (SORT_BY_xxx)

# reverse : true ????

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

def sort_member(sort_type = KGC::Commands::SORT_BY_ID,

reverse = false)

# ???????

b_actors = battle_members

actors = all_members - b_actors

f_actors = fixed_members

# ????????????

if KGC::LargeParty::FORBID_CHANGE_SHIFT_FIXED

actors -= f_actors

b_actors -= f_actors

end

# ???

case sort_type

when KGC::Commands::SORT_BY_ID # ID?

actors.sort! { |a, b| a.id <=> b.id }

b_actors.sort! { |a, b| a.id <=> b.id }

when KGC::Commands::SORT_BY_NAME # ???

actors.sort! { |a, b| a.name <=> b.name }

b_actors.sort! { |a, b| a.name <=> b.name }

when KGC::Commands::SORT_BY_LEVEL # ????

actors.sort! { |a, b| a.level <=> b.level }

b_actors.sort! { |a, b| a.level <=> b.level }

end

# ??

if reverse

actors.reverse!

b_actors.reverse!

end

# ??????????????

if KGC::LargeParty::FORBID_CHANGE_SHIFT_FIXED

actors = f_actors + actors

b_actors = f_actors + b_actors

end

# ??

set_member(actors)

set_battle_member(b_actors)



apply_force_launch

$game_player.refresh

end

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

# ? ????

# ??????? index1 ??? index2 ????????

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

def change_shift(index1, index2)

size = @actors.size

if index1 >= size || index2 >= size

return

end

buf = @actors[index1]

@actors[index1] = @actors[index2]

@actors[index2] = buf

$game_player.refresh

end

end



#???????????????????????????????????????



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

# ¦ Window_Command

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



class Window_Command < Window_Selectable

unless method_defined?(:add_command)

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

# ? ???????

# ?????????

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

def add_command(command)

@commands << command

@item_max = @commands.size

item_index = @item_max - 1

refresh_command

draw_item(item_index)

return item_index

end

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

# ? ???????????

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

def refresh_command

buf = self.contents.clone

self.height = [self.height, row_max * WLH + 32].max

create_contents

self.contents.blt(0, 0, buf, buf.rect)

buf.dispose

end

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

# ? ???????

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

def insert_command(index, command)

@commands.insert(index, command)

@item_max = @commands.size

refresh_command

refresh

end

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

# ? ???????

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

def remove_command(command)

@commands.delete(command)

@item_max = @commands.size

refresh

end

end

end



#???????????????????????????????????????



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

# ¦ Window_MenuStatus

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



class Window_MenuStatus < Window_Selectable

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

# ? ??

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

STATUS_HEIGHT = 96 # ???????????

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

# ? ??????????

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

def create_contents

self.contents.dispose

self.contents = Bitmap.new(width - 32,

[height - 32, row_max * STATUS_HEIGHT].max)

end

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

# ? ???????

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

def top_row

return self.oy / STATUS_HEIGHT

end

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

# ? ???????

# row : ????????

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

def top_row=(row)

super(row)

self.oy = self.oy / WLH * STATUS_HEIGHT

end

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

# ? 1 ??????????????

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

def page_row_max

return (self.height - 32) / STATUS_HEIGHT

end

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

# ? ????????????

# index : ????

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

def item_rect(index)

rect = super(index)

rect.height = STATUS_HEIGHT

rect.y = index / @column_max * STATUS_HEIGHT

return rect

end

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

# ? ??????

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

def refresh

@item_max = $game_party.all_members.size

create_contents

fill_stand_by_background

draw_member

end

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

# ? ??????????

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

def draw_member

for actor in $game_party.members

draw_actor_face(actor, 2, actor.party_index * 96 + 2, 92)

x = 104

y = actor.party_index * 96 + WLH / 2

draw_actor_name(actor, x, y)

draw_actor_class(actor, x + 120, y)

draw_actor_level(actor, x, y + WLH * 1)

draw_actor_state(actor, x, y + WLH * 2)

draw_actor_hp(actor, x + 120, y + WLH * 1)

draw_actor_mp(actor, x + 120, y + WLH * 2)

end

end

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

# ? ?????????????

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

def fill_stand_by_background

color = KGC::LargeParty::STAND_BY_COLOR

dy = STATUS_HEIGHT * $game_party.battle_members.size

dh = STATUS_HEIGHT * $game_party.stand_by_members.size

if dh > 0

self.contents.fill_rect(0, dy, self.width - 32, dh, color)

end

end

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

# ? ???????

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

def update_cursor

if @index < 0 # ??????

self.cursor_rect.empty

elsif @index < @item_max # ??

super

elsif @index >= 100 # ??

self.cursor_rect.set(0, (@index - 100) * STATUS_HEIGHT,

contents.width, STATUS_HEIGHT)

else # ??

self.cursor_rect.set(0, 0, contents.width, @item_max * STATUS_HEIGHT)

end

end

end



#???????????????????????????????????????



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

# ¦ Window_ShopStatus

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



class Window_ShopStatus < Window_Base

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

# ? ??????????

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

def create_contents

self.contents.dispose

self.contents = Bitmap.new(width - 32,

WLH * ($game_party.members.size + 1) * 2)

end

end



#???????????????????????????????????????



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

# ¦ Window_BattleStatus

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



class Window_BattleStatus < Window_Selectable

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

# ? ??????????

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

def create_contents

self.contents.dispose

self.contents = Bitmap.new(width - 32,

[WLH * $game_party.members.size, height - 32].max)

end

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

# ? ??????

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

alias refresh_KGC_LargeParty refresh

def refresh

create_contents



refresh_KGC_LargeParty

end

end



#???????????????????????????????????????



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

# ? Window_PartyFormCaption

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

#  ??????????????????????????????????

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



class Window_PartyFormCaption < Window_Base

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

# ? ?????????

# caption : ??????????

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

def initialize(caption = "")

super(0, 0, KGC::LargeParty::CAPTION_WINDOW_WIDTH, WLH + 32)

self.z = 1500

@caption = caption

refresh

end

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

# ? ??????

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

def refresh

self.contents.clear

self.contents.draw_text(0, 0, width - 32, WLH, @caption)

end

end



#???????????????????????????????????????



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

# ? Window_PartyFormMember

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

#  ??????????????????????????

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



class Window_PartyFormMember < Window_Selectable

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

# ? ??

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

DRAW_SIZE = KGC::LargeParty::PARTY_FORM_CHARACTER_SIZE

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

# ? ??????????

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

attr_accessor :selected_index # ??????????

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

# ? ?????????

# x : ?????? X ??

# y : ?????? Y ??

# width : ???????

# height : ????????

# spacing : ??????????????

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

def initialize(x, y, width, height, spacing = 8)

super(x, y, width, height, spacing)

self.z = 1000

end

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

# ? ??????????

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

def create_contents

self.contents.dispose

self.contents = Bitmap.new(width - 32,

[height - 32, row_max * DRAW_SIZE[1]].max)

end

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

# ? ???????

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

def top_row

return self.oy / DRAW_SIZE[1]

end

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

# ? ???????

# row : ????????

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

def top_row=(row)

super(row)

self.oy = self.oy / WLH * DRAW_SIZE[1]

end

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

# ? 1 ??????????????

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

def page_row_max

return (self.height - 32) / DRAW_SIZE[1]

end

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

# ? ????????????

# index : ????

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

def item_rect(index)

rect = super(index)

rect.width = DRAW_SIZE[0]

rect.height = DRAW_SIZE[1]

rect.y = index / @column_max * DRAW_SIZE[1]

return rect

end

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

# ? ????????

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

def actor

return @actors[self.index]

end

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

# ? ??????

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

def refresh

self.contents.clear

restore_member_list

draw_member

end

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

# ? ?????????

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

def restore_member_list

# ??????

end

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

# ? ??????

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

def draw_member

# ??????

end

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

# ? ????????

# index : ????

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

def draw_empty_actor(index)

# ??????

end

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

# ? ?????????

# index : ????

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

def draw_fixed_back(index)

rect = item_rect(index)

self.contents.fill_rect(rect, KGC::LargeParty::FIXED_COLOR)

end

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

# ? ??????????

# index : ????

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

def draw_selected_back(index)

rect = item_rect(index)

self.contents.fill_rect(rect, KGC::LargeParty::SELECTED_COLOR)

end

end



#???????????????????????????????????????



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

# ? Window_PartyFormBattleMember

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

#  ????????????????????????????

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



class Window_PartyFormBattleMember < Window_PartyFormMember

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

# ? ??????????

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

attr_accessor :selected_index # ??????????

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

# ? ?????????

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

def initialize

super(0, 0, 64, DRAW_SIZE[1] + 32)

column_width = DRAW_SIZE[0] + @spacing

nw = [column_width * $game_party.max_battle_member_count + 32,

Graphics.width].min

self.width = nw



@item_max = $game_party.max_battle_member_count

@column_max = width / column_width

@selected_index = nil

create_contents

refresh

self.active = true

self.index = 0

end

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

# ? ?????????

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

def restore_member_list

@actors = $game_party.battle_members

end

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

# ? ??????

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

def draw_member

@item_max.times { |i|

actor = @actors[i]

if actor == nil

draw_empty_actor(i)

else

if i == @selected_index

draw_selected_back(i)

elsif $game_party.actor_fixed?(actor.id)

draw_fixed_back(i)

end

rect = item_rect(i)

draw_actor_graphic(actor,

rect.x + DRAW_SIZE[0] / 2,

rect.y + DRAW_SIZE[1] - 4)

end

}

end

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

# ? ????????

# index : ????

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

def draw_empty_actor(index)

rect = item_rect(index)

self.contents.font.color = system_color

self.contents.draw_text(rect, KGC::LargeParty::BATTLE_MEMBER_BLANK_TEXT, 1)

self.contents.font.color = normal_color

end

end



#???????????????????????????????????????



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

# ? Window_PartyFormAllMember

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

#  ???????????????????????????

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



class Window_PartyFormAllMember < Window_PartyFormMember

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

# ? ?????????

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

def initialize

super(0, 0, 64, 64)

restore_member_list

@item_max = $game_party.all_members.size



# ???????

column_width = DRAW_SIZE[0] + @spacing

sw = [@item_max * column_width + 32, Graphics.width].min

@column_max = (sw - 32) / column_width

sh = ([@item_max - 1, 0].max / @column_max + 1) * DRAW_SIZE[1] + 32

sh = [sh, DRAW_SIZE[1] * KGC::LargeParty::PARTY_MEMBER_WINDOW_ROW_MAX + 32].min



# ??·?????

self.y += DRAW_SIZE[1] + 32

self.width = sw

self.height = sh



create_contents

refresh

self.active = false

self.index = 0

end

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

# ? ???????????????????

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

def actor_index

return @index_offset + self.index

end

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

# ? ?????????

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

def restore_member_list

if KGC::LargeParty::SHOW_BATTLE_MEMBER_IN_PARTY

@actors = $game_party.all_members

@index_offset = 0

else

@actors = $game_party.stand_by_members

@index_offset = $game_party.battle_members.size

end

end

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

# ? ??????

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

def draw_member

@item_max.times { |i|

actor = @actors[i]

if actor == nil

draw_empty_actor(i)

next

end



if $game_party.actor_fixed?(actor.id)

draw_fixed_back(i)

end

rect = item_rect(i)

opacity = ($game_party.battle_members.include?(actor) ? 96 : 255)

draw_actor_graphic(actor,

rect.x + DRAW_SIZE[0] / 2,

rect.y + DRAW_SIZE[1] - 4,

opacity)

}

end

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

# ? ???????????????

# actor : ????

# x : ??? X ??

# y : ??? Y ??

# opacity : ????

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

def draw_actor_graphic(actor, x, y, opacity = 255)

draw_character(actor.character_name, actor.character_index, x, y, opacity)

end

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

# ? ???????????

# character_name : ???????? ?????

# character_index : ???????? ??????

# x : ??? X ??

# y : ??? Y ??

# opacity : ????

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

def draw_character(character_name, character_index, x, y, opacity = 255)

return if character_name == nil

bitmap = Cache.character(character_name)

sign = character_name[/^[\!\$]./]

if sign != nil and sign.include?('$')

cw = bitmap.width / 3

ch = bitmap.height / 4

else

cw = bitmap.width / 12

ch = bitmap.height / 8

end

n = character_index

src_rect = Rect.new((n%4*3+1)*cw, (n/4*4)*ch, cw, ch)

self.contents.blt(x - cw / 2, y - ch, bitmap, src_rect, opacity)

end

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

# ? ????????

# index : ????

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

def draw_empty_actor(index)

rect = item_rect(index)

self.contents.font.color = system_color

self.contents.draw_text(rect, KGC::LargeParty::PARTY_MEMBER_BLANK_TEXT, 1)

self.contents.font.color = normal_color

end

end



#???????????????????????????????????????



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

# ? Window_PartyFormStatus

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

#  ????????????????????????????????

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



class Window_PartyFormStatus < Window_Base

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

# ? ?????????

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

def initialize

super(0, 0, 384, 128)

self.z = 1000

@actor = nil

refresh

end

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

# ? ??????

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

def set_actor(actor)

if @actor != actor

@actor = actor

refresh

end

end

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

# ? ??????

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

def refresh

self.contents.clear

if @actor == nil

return

end



draw_actor_face(@actor, 0, 0)

dx = 104

draw_actor_name(@actor, dx, 0)

draw_actor_level(@actor, dx, WLH * 1)

draw_actor_hp(@actor, dx, WLH * 2)

draw_actor_mp(@actor, dx, WLH * 3)

4.times { |i|

draw_actor_parameter(@actor, dx + 128, WLH * i, i, 120)

}

end

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

# ? ??????

# actor : ????

# x : ??? X ??

# y : ??? Y ??

# type : ?????? (0~3)

# width : ???

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

def draw_actor_parameter(actor, x, y, type, width = 156)

case type

when 0

parameter_name = Vocab::atk

parameter_value = actor.atk

when 1

parameter_name = Vocab::def

parameter_value = actor.def

when 2

parameter_name = Vocab::spi

parameter_value = actor.spi

when 3

parameter_name = Vocab::agi

parameter_value = actor.agi

end

nw = width - 36

self.contents.font.color = system_color

self.contents.draw_text(x, y, nw, WLH, parameter_name)

self.contents.font.color = normal_color

self.contents.draw_text(x + nw, y, 36, WLH, parameter_value, 2)

end

end



#???????????????????????????????????????



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

# ? Window_PartyFormControl

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

#  ??????????????????????????

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



class Window_PartyFormControl < Window_Base

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

# ? ??

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

MODE_BATTLE_MEMBER = 0

MODE_SHIFT_CHANGE = 1

MODE_PARTY_MEMBER = 2

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

# ? ?????????

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

def initialize

super(0, 0, Graphics.width - 384, 128)

self.z = 1000

@mode = MODE_BATTLE_MEMBER

refresh

end

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

# ? ?????

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

def mode=(value)

@mode = value

refresh

end

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

# ? ??????

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

def refresh

self.contents.clear

case @mode

when MODE_BATTLE_MEMBER # ??????

buttons = [

"Maj: Enlever",

"Echapp: Finir",

"Espace: Confirmer",

"A: Echanger"

]

when MODE_SHIFT_CHANGE # ????

buttons = [

"Echapp: Annuler",

"Espace: Confirmer",

""

]

when MODE_PARTY_MEMBER # ????????

buttons = [

"Echapp: Retour",

"Entrée: Confirmer"

]

else

return

end



buttons.each_with_index { |c, i|

self.contents.draw_text(0, WLH * i, width - 32, WLH, c)

}

end

end



#???????????????????????????????????????



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

# ¦ Scene_Title

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



class Scene_Title < Scene_Base

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

# ? ??????????????

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

alias create_game_objects_KGC_LargeParty create_game_objects

def create_game_objects

create_game_objects_KGC_LargeParty



if KGC::LargeParty::DEFAULT_PARTYFORM_ENABLED

$game_switches[KGC::LargeParty::PARTYFORM_SWITCH] = true

$game_switches[KGC::LargeParty::BATTLE_PARTYFORM_SWITCH] = true

end

end

end



#???????????????????????????????????????



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

# ¦ Scene_Map

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



class Scene_Map < Scene_Base

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

# ? ?????????

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

alias update_scene_change_KGC_LargeParty update_scene_change

def update_scene_change

return if $game_player.moving? # ??????????



if $game_temp.next_scene == :partyform

call_partyform

return

end



update_scene_change_KGC_LargeParty

end

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

# ? ??????????????

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

def call_partyform

$game_temp.next_scene = nil

$scene = Scene_PartyForm.new(0, Scene_PartyForm::HOST_MAP)

end

end



#???????????????????????????????????????



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

# ¦ Scene_Menu

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



class Scene_Menu < Scene_Base

if KGC::LargeParty::USE_MENU_PARTYFORM_COMMAND

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

# ? ????????????

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

alias create_command_window_KGC_LargeParty create_command_window

def create_command_window

create_command_window_KGC_LargeParty



return if $imported["CustomMenuCommand"]



@__command_partyform_index =

@command_window.add_command(Vocab.partyform)

@command_window.draw_item(@__command_partyform_index,

$game_party.partyform_enable?)

if @command_window.oy > 0

@command_window.oy -= Window_Base::WLH

end

@command_window.index = @menu_index

end

end

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

# ? ?????????

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

alias update_command_selection_KGC_LargeParty update_command_selection

def update_command_selection

current_menu_index = @__command_partyform_index

call_partyform_flag = false



if Input.trigger?(Input::C)

case @command_window.index

when @__command_partyform_index # ??????

call_partyform_flag = true

end

# ???????????

elsif KGC::LargeParty::MENU_PARTYFORM_BUTTON != nil &&

Input.trigger?(KGC::LargeParty::MENU_PARTYFORM_BUTTON)

call_partyform_flag = true

current_menu_index = @command_window.index if current_menu_index == nil

end



# ???????????

if call_partyform_flag

if $game_party.members.size == 0 || !$game_party.partyform_enable?

Sound.play_buzzer

return

end

Sound.play_decision

$scene = Scene_PartyForm.new(current_menu_index)

return

end



update_command_selection_KGC_LargeParty

end

end



#???????????????????????????????????????



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

# ¦ Scene_Shop

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



unless $imported["HelpExtension"]

class Scene_Shop < Scene_Base

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

# ? ??????

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

alias udpate_KGC_LargeParty update

def update

# ???????

if !@command_window.active &&

KGC::LargeParty::SHOP_STATUS_SCROLL_BUTTON != nil &&

Input.press?(KGC::LargeParty::SHOP_STATUS_SCROLL_BUTTON)

super

update_menu_background

update_scroll_status

return

else

@status_window.cursor_rect.empty

end



udpate_KGC_LargeParty

end

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

# ? ??????????????????

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

def update_scroll_status

# ??????????????????

@status_window.cursor_rect.width = @status_window.contents.width

@status_window.cursor_rect.height = @status_window.height - 32

@status_window.update



if Input.press?(Input::UP)

@status_window.oy = [@status_window.oy - 4, 0].max

elsif Input.press?(Input::DOWN)

max_pos = [@status_window.contents.height -

(@status_window.height - 32), 0].max

@status_window.oy = [@status_window.oy + 4, max_pos].min

end

end

end

end



#???????????????????????????????????????



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

# ? Scene_PartyForm

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

#  ????????????????????

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



class Scene_PartyForm < Scene_Base

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

# ? ??

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

CAPTION_OFFSET = 40 # ????????????????

HOST_MENU = 0 # ????? : ????

HOST_MAP = 1 # ????? : ???

HOST_BATTLE = 2 # ????? : ??

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

# ? ?????????

# menu_index : ?????????????

# host_scene : ????? (0..???? 1..??? 2..??)

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

def initialize(menu_index = 0, host_scene = HOST_MENU)

@menu_index = menu_index

@host_scene = host_scene

end

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

# ? ????

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

def start

super

create_menu_background



create_windows

create_confirm_window

adjust_window_location



# ???????????

@battle_actors = $game_party.battle_members.dup

@party_actors = $game_party.all_members.dup

end

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

# ? ????????

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

def create_windows

# ???????????

@battle_member_window = Window_PartyFormBattleMember.new

@party_member_window = Window_PartyFormAllMember.new

@status_window = Window_PartyFormStatus.new

@status_window.set_actor(@battle_member_window.actor)



# ????????????

@battle_member_caption_window =

Window_PartyFormCaption.new(KGC::LargeParty::BATTLE_MEMBER_CAPTION)

@party_member_caption_window =

Window_PartyFormCaption.new(KGC::LargeParty::PARTY_MEMBER_CAPTION)

@control_window = Window_PartyFormControl.new

end

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

# ? ??????????

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

def create_confirm_window

commands = KGC::LargeParty::CONFIRM_WINDOW_COMMANDS

@confirm_window =

Window_Command.new(KGC::LargeParty::CONFIRM_WINDOW_WIDTH, commands)

@confirm_window.index = 0

@confirm_window.x = (Graphics.width - @confirm_window.width) / 2

@confirm_window.y = (Graphics.height - @confirm_window.height) / 2

@confirm_window.z = 2000

@confirm_window.openness = 0

@confirm_window.active = false

end

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

# ? ??????????

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

def adjust_window_location

# ???????

base_x = [@battle_member_window.width, @party_member_window.width].max

base_x = [(Graphics.width - base_x) / 2, 0].max

base_y = @battle_member_window.height + @party_member_window.height +

@status_window.height + CAPTION_OFFSET * 2

base_y = [(Graphics.height - base_y) / 2, 0].max



# ???????????????

@battle_member_window.x = base_x

@battle_member_window.y = base_y + CAPTION_OFFSET

@party_member_window.x = base_x

@party_member_window.y = @battle_member_window.y +

@battle_member_window.height + CAPTION_OFFSET

@status_window.x = 0

@status_window.y = @party_member_window.y + @party_member_window.height



# ????????????????

@battle_member_caption_window.x = [base_x - 16, 0].max

@battle_member_caption_window.y = @battle_member_window.y - CAPTION_OFFSET

@party_member_caption_window.x = [base_x - 16, 0].max

@party_member_caption_window.y = @party_member_window.y - CAPTION_OFFSET

@control_window.x = @status_window.width

@control_window.y = @status_window.y

end

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

# ? ????

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

def terminate

super

dispose_menu_background

@battle_member_window.dispose

@party_member_window.dispose

@status_window.dispose

@battle_member_caption_window.dispose

@party_member_caption_window.dispose

@control_window.dispose

@confirm_window.dispose

end

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

# ? ????????????

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

def create_menu_background

super

@menuback_sprite.z = 500

end

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

# ? ???????

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

def return_scene

case @host_scene

when HOST_MENU

$scene = Scene_Menu.new(@menu_index)

when HOST_MAP

$scene = Scene_Map.new

when HOST_BATTLE

$scene = Scene_Battle.new

end

$game_player.refresh

end

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

# ? ??????

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

def update

super

update_menu_background

update_window

if @battle_member_window.active

update_battle_member

elsif @party_member_window.active

update_party_member

elsif @confirm_window.active

update_confirm

end

end

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

# ? ???????

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

def update_window

@battle_member_window.update

@party_member_window.update

@status_window.update

@battle_member_caption_window.update

@party_member_caption_window.update

@control_window.update

@confirm_window.update

end

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

# ? ????????

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

def refresh_window

@battle_member_window.refresh

@party_member_window.refresh

end

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

# ? ?????? (????????????????????)

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

def update_battle_member

@status_window.set_actor(@battle_member_window.actor)

if Input.trigger?(Input::A)

if @battle_member_window.selected_index == nil # ????????

actor = @battle_member_window.actor

# ???????????

if actor == nil || $game_party.actor_fixed?(actor.id)

Sound.play_buzzer

return

end

# ???????

Sound.play_decision

actors = $game_party.battle_members

actors.delete_at(@battle_member_window.index)

$game_party.set_battle_member(actors)

refresh_window

end

elsif Input.trigger?(Input::B)

if @battle_member_window.selected_index == nil # ????????

# ????????????

Sound.play_cancel

show_confirm_window

else # ?????

# ??????

Sound.play_cancel

@battle_member_window.selected_index = nil

@battle_member_window.refresh

@control_window.mode = Window_PartyFormControl::MODE_BATTLE_MEMBER

end

elsif Input.trigger?(Input::C)

if @battle_member_window.selected_index == nil # ????????

actor = @battle_member_window.actor

# ???????????

if actor != nil && $game_party.actor_fixed?(actor.id)

Sound.play_buzzer

return

end

# ??????????????????

Sound.play_decision

@battle_member_window.active = false

@party_member_window.active = true

@control_window.mode = Window_PartyFormControl::MODE_PARTY_MEMBER

else # ?????

unless can_change_shift?(@battle_member_window.actor)

Sound.play_buzzer

return

end

# ??????

Sound.play_decision

index1 = @battle_member_window.selected_index

index2 = @battle_member_window.index

change_shift(index1, index2)

@control_window.mode = Window_PartyFormControl::MODE_BATTLE_MEMBER

end

elsif Input.trigger?(Input::X)

# ??????????

unless can_change_shift?(@battle_member_window.actor)

Sound.play_buzzer

return

end

if @battle_member_window.selected_index == nil # ????????

# ??????

Sound.play_decision

@battle_member_window.selected_index = @battle_member_window.index

@battle_member_window.refresh

@control_window.mode = Window_PartyFormControl::MODE_SHIFT_CHANGE

else # ?????

# ??????

Sound.play_decision

index1 = @battle_member_window.selected_index

index2 = @battle_member_window.index

change_shift(index1, index2)

@control_window.mode = Window_PartyFormControl::MODE_BATTLE_MEMBER

end

end

end

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

# ? ????????

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

def can_change_shift?(actor)

# ???????????????????????????

if actor == nil ||

(KGC::LargeParty::FORBID_CHANGE_SHIFT_FIXED &&

$game_party.actor_fixed?(actor.id))

return false

end

return true

end

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

# ? ????

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

def change_shift(index1, index2)

# ???????

$game_party.change_shift(index1, index2)

# ??????????????

@battle_member_window.selected_index = nil

refresh_window

end

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

# ? ?????? (??????????????????)

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

def update_party_member

@status_window.set_actor(@party_member_window.actor)

if Input.trigger?(Input::B)

Sound.play_cancel

# ????????????????

@battle_member_window.active = true

@party_member_window.active = false

@control_window.mode = Window_PartyFormControl::MODE_BATTLE_MEMBER

elsif Input.trigger?(Input::C)

actor = @party_member_window.actor

# ??????????????????

if $game_party.battle_members.include?(actor)

Sound.play_buzzer

return

end

# ?????????

Sound.play_decision

actors = $game_party.all_members

battle_actors = $game_party.battle_members

if @battle_member_window.actor != nil

actors[@party_member_window.actor_index] = @battle_member_window.actor

actors[@battle_member_window.index] = actor

$game_party.set_member(actors.compact)

end

battle_actors[@battle_member_window.index] = actor

$game_party.set_battle_member(battle_actors.compact)

refresh_window

# ????????????????

@battle_member_window.active = true

@party_member_window.active = false

@control_window.mode = Window_PartyFormControl::MODE_BATTLE_MEMBER

end

end

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

# ? ?????? (????????????????)

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

def update_confirm

if Input.trigger?(Input::B)

Sound.play_cancel

hide_confirm_window

elsif Input.trigger?(Input::C)

case @confirm_window.index

when 0 # ????

# ????????????

if $game_party.battle_members.size == 0

Sound.play_buzzer

return

end

Sound.play_decision

return_scene

when 1 # ????

Sound.play_decision

# ??????????????

$game_party.set_member(@party_actors)

$game_party.set_battle_member(@battle_actors)

return_scene

when 2 # ?????

Sound.play_cancel

hide_confirm_window

end

end

end

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

# ? ??????????

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

def show_confirm_window

if @battle_member_window.active

@last_active_window = @battle_member_window

else

@last_active_window = @party_member_window

end

@battle_member_window.active = false

@party_member_window.active = false



@confirm_window.draw_item(0, $game_party.battle_members.size > 0)

@confirm_window.open

@confirm_window.active = true

end

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

# ? ???????????

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

def hide_confirm_window

@confirm_window.active = true

@confirm_window.close

@last_active_window.active = true

end

end



#???????????????????????????????????????



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

# ¦ Scene_Battle

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



class Scene_Battle < Scene_Base

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

# ? ?????????????????

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

alias wait_for_message_KGC_LargeParty wait_for_message

def wait_for_message

return if @ignore_wait_for_message # ?????????????????



wait_for_message_KGC_LargeParty

end

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

# ? ?????????

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

alias display_level_up_KGC_LargeParty display_level_up

def display_level_up

@ignore_wait_for_message = true



display_level_up_KGC_LargeParty



exp = $game_troop.exp_total * KGC::LargeParty::STAND_BY_EXP_RATE / 1000

$game_party.stand_by_members.each { |actor|

if actor.exist?

actor.gain_exp(exp, KGC::LargeParty::SHOW_STAND_BY_LEVEL_UP)

end

}

@ignore_wait_for_message = false

wait_for_message

end

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

# ? ?????????????

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

alias start_party_command_selection_KGC_LargeParty start_party_command_selection

def start_party_command_selection

if $game_temp.in_battle

@status_window.index = 0

end



start_party_command_selection_KGC_LargeParty

end



if KGC::LargeParty::USE_BATTLE_PARTYFORM

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

# ? ?????????????

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

alias create_info_viewport_KGC_LargeParty create_info_viewport

def create_info_viewport

create_info_viewport_KGC_LargeParty



@__command_partyform_index =

@party_command_window.add_command(Vocab.partyform_battle)

@party_command_window.draw_item(@__command_partyform_index,

$game_party.battle_partyform_enable?)

end

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

# ? ?????????????

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

alias update_party_command_selection_KGC_LargeParty update_party_command_selection

def update_party_command_selection

if Input.trigger?(Input::C)

case @party_command_window.index

when @__command_partyform_index # ??????

unless $game_party.battle_partyform_enable?

Sound.play_buzzer

return

end

Sound.play_decision

process_partyform

return

end

end



update_party_command_selection_KGC_LargeParty

end

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

# ? ?????????

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

def process_partyform

Graphics.freeze

snapshot_for_background

$scene = Scene_PartyForm.new(0, Scene_PartyForm::HOST_BATTLE)

$scene.main

$scene = self

@status_window.refresh

perform_transition

end

end

end