#◆◇◆◇◆  アクティブレベルアップVXA ver 1.05  ◇◆◇◆◇
# 開発者用・高速数字描写機構 ver 1.11 以降必須
#  サポート掲示板 http://www2.ezbbs.net/21/minto-aaa/
#   by みんと

=begin

■ 更新履歴

○ ver 1.05（2013/09/24）
一定の条件下で戦闘不能でも演出が行われていたミスを修正

○ ver 1.04（2012/10/14）
99レベル未満の最高レベルに対応

○ ver 1.03（2012/03/11）
戦闘不能でも演出が行われていたミスを修正

○ ver 1.02（2012/01/29）
入手アイテムの表示をID順に仕様変更

○ ver 1.01（2012/01/21）
多人数PTで落ちるミスを修正

○ ver 1.00（2012/01/20）
公開

■ 説明

なるべく下の方にセクションを作成し、
本スクリプトを導入してください。

戦闘終了時のリザルト表示を
カシャカシャEXP獲得表示に変更します。
ゲージもアクティブで変動し、
いっぱいになったらレベルアップします。

また、その際は専用のグラフィックに変更されます。

画像はサンプルのものを使用していただいて構いません。

演出はCボタン（Enterキー）でカットできます。

=end

#==============================================================================
# ☆ MINTO
#------------------------------------------------------------------------------
#   様々なフラグを扱うメインモジュールです。
#==============================================================================

module MINTO
  
  # アクティブレベルアップVXを有効化 （ true で有効 / false で無効 ）
  RGSS["Active_Lv_UpVX"] = true
  
end

# アクティブレベルアップVXが有効な場合に以降の処理を実行する
if MINTO::RGSS["Active_Lv_UpVX"] == true then

#==============================================================================
# ☆ カスタマイズ
#------------------------------------------------------------------------------
#   機能のカスタマイズをここで行います。
#==============================================================================

module MINTO
  
  # 使用する顔グラグラフィックファイル名
  # Face_Name[ID] = ["通常時のファイル末尾名", "LVUP時のファイル末尾名"]
  # すべてピクチャーフォルダを参照します。
  # ※ ファイル名は機械的に参照します。
  # たとえば、Face_Name[1] = ["普", "笑"]と設定し、
  # ファイル名がActor1でインデックスが0の場合、
  # 実際のファイル名は Actor1_0普, Actor1_0笑 となります。
  # 原則、全アクター分設定してください。
  # nil の場合は「現在の設定グラフィック」を参照します。
  Face_Name = [] # 変更しない
  Face_Name[1] = [nil, nil]
  Face_Name[2] = [nil, nil]
  Face_Name[3] = [nil, nil]
  Face_Name[4] = [nil, nil]
  Face_Name[5] = [nil, nil]
  Face_Name[6] = [nil, nil]
  Face_Name[7] = [nil, nil]
  Face_Name[8] = [nil, nil]
  Face_Name[9] = [nil, nil]
  
  # 確保するメンバーサイズ
  # 他サイトさんの戦闘メンバー拡張スクリプトを導入している場合は、
  # その最大数を設定してください
  Max_Size = 4
  
  # 演出用の最終レベル
  #（他サイトさんのレベル限界変更スクリプトを導入している場合は、
  # その最終値を入力してください）
  Final_Level = 99
  
  # 空EXPゲージの名前
  Base_EXP_Gauge = "gauge" 
  
  # 本体EXPゲージの名前
  A_EXP_Gauge = "gauge_exp2"
  
  # 演出時間フレーム
  #（1秒間が基本的に60フレームです。
  # ただし、入手EXPがそれ未満の場合はEXP分のフレーム時間になります）
  LVUP_Frame = 300
  
  # ゲージ加算SE（[ファイル名, ボリューム, ピッチ）
  # ※ マシンスペックが高くないと、おそらく処理落ちします
  #    不要な場合はSE名に "" を設定してください
  Gauge_SE = ["Decision1", 80, 400]
  
  # LVUP時に鳴らすSE（[ファイル名, ボリューム, ピッチ）
  LVUP_SE = ["Up4", 100, 150]
  
  #--------------------------------------------------------------------------
  # ● KGC Softwareスクリプトの検索
  #    key : スクリプトキー
  #--------------------------------------------------------------------------
  def self.search_kgc(key)
    # 指定されたスクリプトが有効かどうか調べる
    $imported != nil and $imported[key] == true
  end
end
#==============================================================================
# ■ Mint_Picture_Number
#------------------------------------------------------------------------------
# 　ピクチャー数字のスプライト表示を扱うクラスです。
#   このクラスは数値の高速再描写に特化したクラスとなっています。
#==============================================================================

class Mint_Picture_Number
  #--------------------------------------------------------------------------
  # ● ストリングポップ
  #    string : 求められた文字列のピクチャーの名前
  #    x_plus : 外部からのX座標の調整用
  #    y_plus : 外部からのY座標の調整用 
  #--------------------------------------------------------------------------
  def string_pop(string = "", x_plus = 0, y_plus = 0)
    # string が無効なら処理を終了
    return if string == ""
    # 配列の nil をなくす
    #@string_pop_sprite.compact!
    #@string_pop_duration.compact!
    # スプライトを生成
    string_pop_sprite = Sprite.new
    # 画像を描写
    if Scene_Menu.method_defined?("snapshot_for_background") then
      string_pop_sprite.bitmap = Cache.picture(string)
    else
      string_pop_sprite.bitmap = RPG::Cache.picture(string)
    end
    # 座標データを代入
    string_pop_sprite.x = @x.to_i + x_plus
    string_pop_sprite.y = @y.to_i + y_plus
    string_pop_sprite.z = 10001
    # 配列の先頭にシフト
    @string_pop_sprite.push(string_pop_sprite)
    @string_pop_duration.push(40)
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #    battler : バトラー
  #--------------------------------------------------------------------------
  def update(battler = nil)
    # 1つでもストリングポップが表示中の場合
    if @string_pop_sprite.size >= 1
      # 表示中のストリングポップを1つずつ処理する
      for i in 0...@string_pop_sprite.size
        # ストリングポップを代入
        string = @string_pop_sprite[i]
        # スプライトが無効な場合
        if string.nil?
          # 次の処理へ
          next
        end
        # 不透明度が0の場合
        if string.opacity <= 0
          # ストリングポップを解放
          #dispose_string_pop(i)
          # 次の処理へ
          next
        end
        # カウントを減らす
        @string_pop_duration[i] -= 1
        # 残りカウントに応じて分岐
        case @string_pop_duration[i]
        when 36..39
          string.y -= 4
          string.blend_type = 1
        when 33..37
          string.y -= 2
          string.blend_type = 1
        when 32..34
          string.y += 2
          string.blend_type = 0
        when 25..32
          string.y += 4
          string.blend_type = 0
        end
        # 透明度をカウントに応じて下げる
        string.opacity = 255 - ((12 - @string_pop_duration[i]) * 26)
      end
      # 配列の nil を無くす
      #@string_pop_sprite.compact!
      #@string_pop_duration.compact!
    end
  end
end
#==============================================================================
# ■ MINTO_Number
#------------------------------------------------------------------------------
# 　ピクチャーよる数字の表示を扱うモジュールです。
#   このモジュールは数値の高速描写に特化したモジュールとなっています。
#==============================================================================

module MINTO_Number
  #--------------------------------------------------------------------------
  # ● 定数
  #--------------------------------------------------------------------------
  WIDHT  = -4 # 横幅調節値
  HEIGHT = 24 # 1カラーの高さ
  #--------------------------------------------------------------------------
  # ● 数字の描写
  #    x      : 描写先 X 座標
  #    y      : 描写先 Y 座標
  #    number : 描写する数字
  #    bitmap : 使用するビットマップ
  #    color  : 使用するカラーインデックス
  #    text   : 使用する画像ファイル名
  #--------------------------------------------------------------------------
  def self.draw_number(x, y, number, bitmap, color = 0, text = "String02")
    # ピクチャーの読み込み
    picture = Cache.picture(text)
    # ピクチャーの基本の横幅を取得する
    width_base = picture.width / 10.0
    # 求められた数字を一文字ずつ配列にする
    array = number.to_s.split(//)
    # ループ処理（イテレータ）
    (0...array.size).each do |i|
      # 描写座標を計算
      draw_x = array[i].to_i * width_base
      draw_y = HEIGHT * color
      # 描写座標を取得する
      rect = Rect.new(draw_x, draw_y, width_base, HEIGHT)
      # 数字を描写
      bitmap.blt(x + (i * (width_base + WIDHT)), y + 4, picture, rect)
    end
  end
end
#==============================================================================
# ■ Mint_Gauge_System_Active
#------------------------------------------------------------------------------
# 　ピクチャーゲージのスプライト表示を扱うクラスです。
#   このクラスはゲージの高速再描写に特化したクラスとなっています。
#==============================================================================

class Mint_Gauge_System_Active
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #    gauge : ゲージ画像
  #--------------------------------------------------------------------------
  def initialize(x, y, z = 500, type = 0)
    # 空ゲージを読み込む
    gauge_base = Cache.picture(MINTO::Base_EXP_Gauge)
    # 空ゲージ用のスプライトを作成
    @sprite_gauge_base = Sprite.new
    # 座標を設定
    @sprite_gauge_base.x = x
    @sprite_gauge_base.y = y
    @sprite_gauge_base.z = z
    # スプライトを作成
    @sprite = @sprite_gauge_base.dup
    @sprite.x -= 16
    @sprite.y -= 16
    @sprite.z += 1
    @sprite.bitmap = Bitmap.new(64, 32)
    @sprite.bitmap.font.color.set(0, 200, 250)
    # 空ゲージを描写
    @sprite_gauge_base.bitmap = gauge_base
    # 本体ゲージを読み込む
    @gauge = gauge_initialize(type)
    # 本体ゲージ用の配列を作成
    @sprite_gauge = [Sprite.new]
    (1..6).each do |i|
      # 本体ゲージ用のスプライトを作成
      @sprite_gauge[i] = Sprite.new
      # 座標を設定
      @sprite_gauge[i].x = (x - i) + 8
      @sprite_gauge[i].y = y + i
      @sprite_gauge[i].z = z
    end
  end
  #--------------------------------------------------------------------------
  # ● ゲージ用ビットマップの作成
  #--------------------------------------------------------------------------
  def gauge_initialize(type)
    # タイプに応じて分岐
    case type
    when 0
      # ゲージの読み込み
      gauge = Cache.picture(MINTO::A_EXP_Gauge)
    end
    # 本体ゲージ用のスプライトを作成
    sprite_gauge = []
    (1..100).each do |i|
      # 本体ゲージ用のビットマップを作成
      sprite_gauge[i] = Bitmap.new(i, 1)
      # 本体ゲージ用の描写範囲を計算
      dest_rect = Rect.new(0, 0, i, 1)
      sprite_gauge[i].stretch_blt(dest_rect, gauge, gauge.rect)
    end
    return sprite_gauge
  end
  #--------------------------------------------------------------------------
  # ● 解放
  #--------------------------------------------------------------------------
  def dispose
    # スプライトを解放
    for s in @sprite_gauge
      s.dispose
    end
    @sprite_gauge_base.bitmap.dispose
    @sprite_gauge_base.dispose
    @sprite.bitmap.dispose
    @sprite.dispose
  end
  #--------------------------------------------------------------------------
  # ● 縁文字描写
  #--------------------------------------------------------------------------
  def draw_frame_text(x, y, width, height, text, ag = 0)
    # 元の色を保存
    ori_color = @sprite.bitmap.font.color.clone
    # 縁の色を定義
    @sprite.bitmap.font.color.set(0, 0, 0)
    # 縁文字を描写
    @sprite.bitmap.draw_text(x-1, y, width, height, text, ag)
    @sprite.bitmap.draw_text(x+1, y, width, height, text, ag)
    @sprite.bitmap.draw_text(x, y-1, width, height, text, ag)
    @sprite.bitmap.draw_text(x, y+1, width, height, text, ag)
    # 元の色に戻す
    @sprite.bitmap.font.color = ori_color
    # 本体の文字を描写
    @sprite.bitmap.draw_text(x, y, width, height, text, ag)
  end
  #--------------------------------------------------------------------------
  # ● 可視状態の取得
  #--------------------------------------------------------------------------
  def visible
    # 先頭の可視状態を返す
    return @sprite_gauge[1].visible
  end
  #--------------------------------------------------------------------------
  # ● 可視状態の変更
  #    visible : 新しい可視状態
  #--------------------------------------------------------------------------
  def visible=(visible)
    # 可視状態の変更（イテレータ）
    (1..6).each{|i| @sprite_gauge[i].visible = visible}
    @sprite_gauge_base.visible = visible
  end
  #--------------------------------------------------------------------------
  # ● レートの設定
  #    rate : ゲージの減少率
  #--------------------------------------------------------------------------
  def set_rate(rate)
    rate = [[rate, 100].min, 0].max
    # ゲージを実際に描写
    @sprite_gauge[1].bitmap = @gauge[rate]
    @sprite_gauge[2].bitmap = @gauge[rate]
    @sprite_gauge[3].bitmap = @gauge[rate]
    @sprite_gauge[4].bitmap = @gauge[rate]
    @sprite_gauge[5].bitmap = @gauge[rate]
    @sprite_gauge[6].bitmap = @gauge[rate]
  end
end
#==============================================================================
# ■ Game_Temp
#------------------------------------------------------------------------------
# 　セーブデータに含まれない、一時的なデータを扱うクラスです。このクラスのイン
# スタンスは $game_temp で参照されます。
#==============================================================================

class Game_Temp
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_accessor :after_battle_phase       # アフターバトルフェーズ中フラグ
end
#==============================================================================
# ■ Game_Actor
#------------------------------------------------------------------------------
# 　アクターを扱うクラスです。このクラスは Game_Actors クラス ($game_actors)
# の内部で使用され、Game_Party クラス ($game_party) からも参照されます。
#==============================================================================

class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # ● EXPリストの取得
  #--------------------------------------------------------------------------
  def exp_list
    return @exp_list
  end
  #--------------------------------------------------------------------------
  # ● 経験値の獲得（経験獲得率を考慮）
  #--------------------------------------------------------------------------
  def gain_exp(exp)
    last_exp = self.exp
    change_exp(self.exp + (exp * final_exp_rate).to_i, true)
    @exp_gain = (last_exp < self.exp)
  end
  #--------------------------------------------------------------------------
  # ● EXP獲得可能判定
  #--------------------------------------------------------------------------
  def exp_gain?
    return ((@exp_gain) and not dead?)
  end
  #--------------------------------------------------------------------------
  # ● ゲージ用のEXP_NEXT の取得
  #--------------------------------------------------------------------------
  def minto_next_exp(lv, exp)
    exp_rate = exp_for_level(lv + 1) - exp_for_level(lv)
    next_exp = exp_for_level(lv + 1) - exp
    rate = (next_exp * 100) / exp_rate
    if exp_for_level(lv + 1) == 0
      rate = 100
    end
    return 100 - rate
  end
  #--------------------------------------------------------------------------
  # ● 次のレベルまでの EXP 取得
  #--------------------------------------------------------------------------
  def next_rest_exp2(lv, exp)
    return exp_for_level(lv + 1) > 0 ? (exp_for_level(lv + 1) - exp) : 0
  end
  #--------------------------------------------------------------------------
  # ● 次のレベルの経験値を取得
  #--------------------------------------------------------------------------
  def next_level_exp
    exp_for_level(@level + 1)
  end
  #--------------------------------------------------------------------------
  # ○ AP 獲得（KGC[EquipLearnSkill]再定義）
  #    ap   : AP の増加量
  #    show : マスタースキル表示フラグ
  #--------------------------------------------------------------------------
  def gain_ap(ap, show)
    # 最終スキルを記憶
    last_full_ap_skills = full_ap_skills
    # 装備品により習得しているスキルに AP を加算
    equipment_skills(true).each do |skill|
      # APの変更
      change_ap(skill, skill_ap(skill.id) + ap)
    end
    # マスタースキル表示フラグが有効で、且つスキル要素が異なっている場合
    if show == true and (last_full_ap_skills != full_ap_skills) then
      # メソッドを返す（スキル習得）
      return true
    end
    # メソッドを返す（スキル未習得）
    return false
  end
  #--------------------------------------------------------------------------
  # ○ マスターしたスキルの表示（KGC[EquipLearnSkill]再定義）
  #    new_skills : 新しくマスターしたスキルの配列
  #--------------------------------------------------------------------------
  def display_full_ap_skills(new_skills)
    # 無効化（処理を行わない）
    return
  end
end
#==============================================================================
# ■ Game_Troop
#------------------------------------------------------------------------------
# 　敵グループおよび戦闘に関するデータを扱うクラスです。バトルイベントの処理も
# 行います。このクラスのインスタンスは $game_troop で参照されます。
#==============================================================================

class Game_Troop < Game_Unit
  #--------------------------------------------------------------------------
  # ● 全滅判定の取得
  #--------------------------------------------------------------------------
  def all_dead?
    # スーパークラスの処理に以降
    bool = super
    # 勝利確定の場合
    if bool then
      # アフターバトルフェーズ中でない場合
      unless $game_temp.after_battle_phase then
        # アフターバトルフェーズを予約する
        $game_temp.after_battle_phase = true
        # アフターバトルフェーズ準備
        SceneManager.scene.reservation_after_battle_phase
      end
    end
    # メソッドを返す
    return bool
  end
  #--------------------------------------------------------------------------
  # ● ドロップアイテムの配列作成）
  #    forcing : 強制フラグ
  #--------------------------------------------------------------------------
  def make_drop_items(forcing = false)
    # 強制フラグがオフの場合
    if forcing == false then
      # メソッドを返す
      return []
    end
    return dead_members.inject([]) {|r, enemy| r += enemy.make_drop_items }
  end
end
#==============================================================================
# ■ Game_Message
#------------------------------------------------------------------------------
# 　文章や選択肢などを表示するメッセージウィンドウの状態を扱うクラスです。この
# クラスのインスタンスは $game_message で参照されます。
#==============================================================================

class Game_Message
  #--------------------------------------------------------------------------
  # ● テキストの追加
  #--------------------------------------------------------------------------
  alias :minto_rgss3_3_add :add
  def add(text)
    # アフターバトルフェーズが予約されている場合
    if $game_temp.after_battle_phase
      # メソッドを返す
      return
    end
    # 元の処理を実行
    minto_rgss3_3_add(text)
  end
end
#==============================================================================
# ■ Window_BattleMessage
#------------------------------------------------------------------------------
# 　戦闘中に表示するメッセージウィンドウです。通常のメッセージウィンドウの機能
# に加え、戦闘進行のナレーションを表示する機能を持ちます。
#==============================================================================

class Window_BattleMessage < Window_Message
  #--------------------------------------------------------------------------
  # ● 可視状態の変更
  #    visible : 新しい可視状態
  #--------------------------------------------------------------------------
  def visible=(visible)
    # アフターバトルフェーズ中の場合
    if $game_temp.after_battle_phase == true then
      # スーパークラスを実行（文章の無効化）
      super(visible)
      # メッセージを不可視にする
      $game_message.visible = false
      # メッセージとそれに係わるフラグを無効化
      $game_message.texts.clear
    # アフターバトルフェーズ中でない場合
    else
      # スーパークラスを実行（通常の処理）
      super(visible)
    end
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  alias :update_Active_Lv_UpVX :update
  def update
    # 元の処理を実行
    update_Active_Lv_UpVX
    # アフターバトルフェーズ中の場合
    if $game_temp.after_battle_phase == true then
      # ウィンドウを可視状態にする
      self.visible = true
    end
  end
end
#==============================================================================
# ■ Window_BattleResult
#------------------------------------------------------------------------------
# 　バトル終了時に、獲得した EXP やゴールドなどを表示するウィンドウです。
#==============================================================================

class Window_BattleResult < Window_Base
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #     exp       : EXP
  #     gold      : ゴールド
  #     treasures : トレジャー
  #--------------------------------------------------------------------------
  def initialize(exp, gold, treasures, ap, gage_window)
    super(320, 0, 224, 416)
    self.opacity = 255
    self.z = 0x270f
    # 各データを保管
    @exp = [exp, 999999].min
    @gold = [gold, 999999].min
    @ap = ap
    @puls = 0
    @items = {}
    @gage_window = gage_window
    # 文字の表示形式を調節
    self.contents.font.italic = true
    # テキストの配列を作成
    text_array = ["EXP", Vocab::currency_unit]
    # APが0以外の場合
    if @ap != 0 then
      # 用語[AP]を追加
      text_array << "AP"
      @puls = 48
    end
    # ループ処理
    for i in 0...text_array.size do
      # テキストを取得
      text = text_array[i]
      # テキスト表示
      frame_text(4, 8 + 50 * i, 224, 25, text, system_color)
      # アンダーライン描写
      self.contents.fill_rect(4, 40 + 50 * i, 224, 1, system_color)
    end
    # 文字の表示形式を戻す
    self.contents.font.italic = false
    # 入手アイテムが1つでも存在する場合
    if treasures.to_a != [] then
      # 入手アイテムをIDが低い順にソート
      treasures.sort! do |a, b|
        if b.id > a.id
          -1
        else
          +1
        end
      end
      # ループ処理
      for item in treasures do
        # 無効な個数の場合
        if @items[item] == nil then
          # 個数を初期化
          @items[item] = 0
        end
        # 個数を加算
        @items[item] += 1
        # アイテムを入手
        $game_party.gain_item(item, 1)
        #msgbox item.name
      end
      # 重複するアイテムを削除
      treasures.uniq!
      # トレジャー用のテキストを表示
      frame_text(4, 24 * 4 + @puls, 256, 24, "入手アイテム", system_color)
      # 入手アイテム名のY座標
      y = 24 * 5 + @puls
      # ループ処理
      for item in treasures do
        # 入手アイテムを描写
        draw_item_name(item, 4, y)
        y += 24
      end
    end
    refresh
  end
  #--------------------------------------------------------------------------
  # ● 縁文字描写
  #--------------------------------------------------------------------------
  def frame_text(x, y, width, height, text, color, ag = 0)
    self.contents.font.color.set(0, 0, 0)
    self.contents.font.shadow = false
    self.contents.draw_text(x-1, y, width, height, text, ag)
    self.contents.draw_text(x+1, y, width, height, text, ag)
    self.contents.draw_text(x, y-1, width, height, text, ag)
    self.contents.draw_text(x, y+1, width, height, text, ag)
    self.contents.font.color = color
    self.contents.draw_text(x, y, width, height, text, ag)
  end
  #--------------------------------------------------------------------------
  # ● アイテム名の描画
  #     item : アイテム
  #     x    : 描画先 X 座標
  #     y    : 描画先 Y 座標
  #--------------------------------------------------------------------------
  def draw_item_name(item, x, y)
    # 無効なアイテムの場合
    if item == nil then
      # メソッドを返す
      return
    end
    # アイテムのアイコンを描写
    draw_icon(item.icon_index, x, y, true)
    # アイテム名を縁取りして描写
    frame_text(x + 28, y, 112, 24, item.name, normal_color)
    # 対象アイテムを2つ以上入手している場合
    if @items[item] >= 2 then
      # アイテムの入手個数を描写
      frame_text(-24, y, 188, 24, "×", normal_color, 2)
      frame_text(0, y, 188, 24, @items[item].to_s, normal_color, 2)
    end
  end
  #--------------------------------------------------------------------------
  # ● リフレッシュ
  #--------------------------------------------------------------------------
  def refresh
    self.openness = 1
    @gage_window.openness = 1
    @gage_window.visible = true
    # 16フレーム待つ
    16.times do
      # ウィンドウを開く
      self.openness += 16
      @gage_window.openness += 16
      # ゲーム画面を更新
      Graphics.update
    end
    # EXPを描写
    MINTO_Number.draw_number(96, 4, @exp, self.contents, 1)
    # ゴールドを描写
    MINTO_Number.draw_number(96, 52, @gold, self.contents, 1)
    # APが0以外の場合
    if @ap != 0 then
      # APを描写
      MINTO_Number.draw_number(96, 100, @ap, self.contents, 1)
    end
    # ゲージウィンドウをリフレッシュ
    @gage_window.refresh_exp
  end
end
#==============================================================================
# ■ Window_Active_Exp
#------------------------------------------------------------------------------
# 　獲得したEXPに応じて、ゲージを変動させるウィンドウです。
#==============================================================================

class Window_Active_Exp < Window_Base
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #    exp : EXP
  #--------------------------------------------------------------------------
  def initialize(exp, skills, last_exp, last_level)
    super(0, 0, 320, 416)
    edge = Cache.picture("Blue_Edge")
    @exp = exp
    # EXP表示用の配列を作成
    @text = []
    # LV表示用の配列を作成
    @lv = []
    # EXPゲージ用の配列
    @exp_gauge = []
    # スキル保存用の配列
    @skills = []
    # 最終EXP用の配列
    @last_exp = last_exp
    # 最終レベル用の配列
    @last_level = last_level
    # ループ処理
    for i in 0...$game_party.all_members.size.to_m(MINTO::Max_Size) do
      # 配列を初期化
      @skills[i] = []
      # ループ処理
      for id in 0...skills[i].size do
        # スキルが有効な場合
        if skills[i] != nil and skills[i][id] != nil then
          # 最終スキルの配列の複製を作成
          @skills[i] << skills[i][id].id
        end
      end
    end
    # 演出スキップフラグをクリア
    @skip = false
    self.opacity = 255
    self.z = 9999
    # スプライトを作成
    @sprite = Sprite.new
    # スプライトのビットマップを作成
    @sprite.bitmap = Bitmap.new(width - 32, height - 32)
    # スプライトのデータを設定
    @sprite.x = self.x + 16
    @sprite.y = self.y + 16
    @sprite.z = 10000
    # グラフィック用のスプライトを作成
    @sprite3 = @sprite.dup
    @sprite3.z = 9999
    @sprite3.bitmap = Bitmap.new(width - 32, 416)
    @sprite3.visible = false
    # ループ処理
    for i in 0...$game_party.all_members.size.to_m(MINTO::Max_Size) do
      dest_rect = Rect.new(0, 16 + (96 * i), 352 * 81 / 100, 108 * 81 / 100)
      @sprite3.bitmap.stretch_blt(dest_rect, edge, edge.rect)
    end
    # グラフィック用のスプライトを作成
    @sprite2 = @sprite.dup
    @sprite2.z = 9999
    @sprite2.bitmap = Bitmap.new(width - 32, height - 32)
  end
  #--------------------------------------------------------------------------
  # ● プラス座標の取得
  #--------------------------------------------------------------------------
  def puls_y
    size = MINTO::Max_Size
    return (96.0 * (4.0 / size.to_f)).to_i
  end
  #--------------------------------------------------------------------------
  # ● 修正座標の取得
  #    y : Y座標
  #--------------------------------------------------------------------------
  def y_pass(y)
    size = MINTO::Max_Size
    return (y * (4.0 / size.to_f)).to_i
  end
  #--------------------------------------------------------------------------
  # ● スプライトの作成
  #--------------------------------------------------------------------------
  def sprite_set
    # パーティー人数分だけ繰り返す
    for i in 0...$game_party.all_members.size.to_m(MINTO::Max_Size) do
      # アクターを取得
      actor = $game_party.all_members[i]
      # 座標を取得
      y = i * puls_y
      # アクター名を描写
      frame_text(4, y, 164, 24, actor.name, normal_color)
      # 用語を描写
      frame_text(12, y + y_pass(36), 64, 24, "LV", system_color)
      frame_text(128, y + y_pass(66), 64, 24, "NEXT", system_color, 2)
    end
  end
  #--------------------------------------------------------------------------
  # ● 顔グラフィックの描画
  #     face_name  : 顔グラフィック ファイル名
  #     face_index : 顔グラフィック インデックス
  #     x          : 描画先 X 座標
  #     y          : 描画先 Y 座標
  #     size       : 表示サイズ
  #--------------------------------------------------------------------------
  def draw_face(face_name, face_index, x, y, size = puls_y)
    rect = Rect.new(0, 0, 0, 0)
    rect.x = (face_index % 4 * 96 + (96 - size) / 2)
    rect.y = (face_index / 4 * 96 + (96 - size) / 2)
    rect.width = puls_y.to_m(96)
    rect.height = puls_y.to_m(96)
    # 対象の範囲を消す
    @sprite2.bitmap.fill_rect(x, y, puls_y, puls_y, Color.new(0, 0, 0, 0))
    @sprite2.bitmap.blt(x + 76, y, Cache.face(face_name), rect)
  end
  #--------------------------------------------------------------------------
  # ● グラフィックの作成
  #    actor : アクター
  #    x     : 描写先のX座標
  #    y     : 描写先のY座標
  #    index : インデックス
  #    type  : 描写タイプ
  #--------------------------------------------------------------------------
  def graphic_set(actor, x, y, index, type)
    # 顔グラフィックの配列
    face = []
    # 顔グラフィック末尾名が有効な場合
    unless MINTO::Face_Name[actor.id][type].nil? then
      # ファイル名を作成
      file_name = "#{actor.face_name}_#{actor.face_index}"
      # ファイル末尾名を取得
      file_name += MINTO::Face_Name[actor.id][type]
      # 顔グラフィックを読み込む
      face[index] = Cache.picture(file_name)
      # 対象の範囲を消す
      rect = Rect.new(x, y, puls_y, puls_y)
      @sprite2.bitmap.fill_rect(rect, Color.new(0, 0, 0, 0))
      # 顔グラフィックを描写
      @sprite2.bitmap.blt(x, y, face[index], Rect.new(0, 0, puls_y, puls_y))
    # 顔グラフィック末尾名が無効な場合
    else
      # 現在の設定グラフィックを描写
      draw_face(actor.face_name, actor.face_index, x, y)
    end
  end
  #--------------------------------------------------------------------------
  # ● 縁文字描写
  #--------------------------------------------------------------------------
  def frame_text(x, y, width, height, text, color, ag = 0)
    @sprite.bitmap.font.color.set(0, 0, 0)
    @sprite.bitmap.font.shadow = false
    @sprite.bitmap.draw_text(x-1, y, width, height, text, ag)
    @sprite.bitmap.draw_text(x+1, y, width, height, text, ag)
    @sprite.bitmap.draw_text(x, y-1, width, height, text, ag)
    @sprite.bitmap.draw_text(x, y+1, width, height, text, ag)
    @sprite.bitmap.font.color = color
    @sprite.bitmap.draw_text(x, y, width, height, text, ag)
  end
  #--------------------------------------------------------------------------
  # ● リフレッシュEXP
  #--------------------------------------------------------------------------
  def refresh_exp
    # 可視フラグをオン
    self.visible = true
    @sprite3.visible = true
    # 用語を描写
    sprite_set
    # 更新フレーム数を作成
    thyme = @exp < MINTO::LVUP_Frame ? @exp.abs : MINTO::LVUP_Frame
    rate_p = @exp < MINTO::LVUP_Frame ? @exp.abs : MINTO::LVUP_Frame
    # EXPの配列
    exp = []
    # LVの配列
    last_lv = []
    # 最終EXPの配列
    last_exp = []
    # レベルアップフラグ
    level_up = []
    # パーティー人数分だけ繰り返す
    for i in 0...$game_party.all_members.size.to_m(MINTO::Max_Size) do
      actor = $game_party.all_members[i]
      # 座標を取得
      x = 160
      y = i * puls_y
      # LV表示用のピクチャー数字を作成
      @lv[i] = Mint_Picture_Number.new(52, y + y_pass(52), 2, 10000)
      # NEXT_EXP表示用のピクチャー数字を作成
      @text[i] = Mint_Picture_Number.new(x + 40, y + y_pass(82), 6, 10000)
      # EXPゲージを作成
      @exp_gauge[i] = Mint_Gauge_System_Active.new(x + 8, 
      y + y_pass(102), 9999)
      # 最終LevelとEXPを代入
      last_lv[i] = @last_level[i].to_i
      last_exp[i] = @last_exp[i].to_i
      # EXPの獲得が可能な場合
      if actor.exp_gain? then
        # 入手EXPがLVUP_Frame以上なら、LVUP_Frameで割ってその余りを求める
        if @exp > MINTO::LVUP_Frame then
          last_exp[i] += @exp % MINTO::LVUP_Frame
          # 経験値2倍の場合
          if actor.final_exp_rate >= 2
            # 倍率補正を考慮
            for to_loop in 0...(actor.final_exp_rate - 1) do
              last_exp[i] += @exp % MINTO::LVUP_Frame
            end
          end
        end
      end
      # グラフィックを描写
      graphic_set(actor, 0, y, actor.id, 0)
    end
    # 更新フレームがなくなるまで繰り返す
    thyme.times do
      # グラフィックをクリア
      @sprite2.bitmap.clear
      # Cボタンが押された場合
      if Input.trigger?(Input::C)
        # スキップフラグをオン
        @skip = true
      end
      # スキップしない場合
      if @skip != true then
        # ゲージ加算SEが有効な場合
        if MINTO::Gauge_SE[0] != "" then
          # SEデータを代入
          data = MINTO::Gauge_SE
          # ゲージ加算SEを演奏
          Audio.se_play("Audio/SE/#{data[0]}", data[1], data[2])
        end
      end
      # パーティー人数分だけ繰り返す
      for i in 0...$game_party.all_members.size.to_m(MINTO::Max_Size) do
        # アクターを代入
        actor = $game_party.all_members[i]
        # EXPの獲得が可能な場合
        if actor.exp_gain? and last_lv[i] < MINTO::Final_Level then
          # 描写用のEXPを加算
          last_exp[i] += (@exp / rate_p)
          # 経験値倍率補正がある場合
          if actor.final_exp_rate >= 2
            # 倍率補正を考慮
            for to_loop in 0...(actor.final_exp_rate - 1) do
              last_exp[i] += (@exp / rate_p)
            end
          end
        end
        # NEXT_EXPを取得
        next_p = actor.next_rest_exp2(last_lv[i], last_exp[i])
        # NEXT_EXPが文字列ではない場合
        if next_p.is_a?(Numeric) then
          # 最低値を0に設定
          next_p = next_p.to_min(0)
          # アクターのマザーデータを取得
          d_actor = $data_actors[actor.id]
          # 最終レベルを代入
          final_level = MINTO::Final_Level
          # レベルアップが可能な場合
          # （NEXT_EXPが0で且つ、最終レベルがMAXレベル未満の場合）
          if next_p == 0 and last_lv[i] < final_level then
            # 描写用のLVを加算
            last_lv[i] += 1
            # スキル習得判定
            for skill in actor.class.learnings do
              # レベル条件を満たしている場合
              if last_lv[i] >= skill.level then
                # 最終スキルに存在しない場合
                unless @skills[i].include?(skill.skill_id) then
                  # 最終スキルに保存
                  @skills[i].push(skill.skill_id)
                  # NewSkill表示
                  @lv[i].string_pop("NewSkill", 144, y_pass(-32))
                end
              end
            end
            # スキップしない場合
            if @skip != true then
              # SEデータを代入
              data = MINTO::LVUP_SE
              # SEを演奏する
              Audio.se_play("Audio/SE/#{data[0]}", data[1], data[2])
            end
            # 限界レベルを取得
            last_lv[i] = [last_lv[i], final_level].min
            # LVUP表示
            @lv[i].string_pop("lvup", 144)
            # レベルアップフラグを設定
            level_up[i] = true
          end
          # レベルアップが有効な場合
          if level_up[i] == true then
            # グラフィックを描写
            graphic_set(actor, 0, (i * puls_y), actor.id, 1)
          else
            # グラフィックを描写
            graphic_set(actor, 0, (i * puls_y), actor.id, 0)
          end
        end
        # ゲージの長さを算出
        n = actor.next_rest_exp2(last_lv[i], last_exp[i])
        rate = actor.minto_next_exp(last_lv[i], last_exp[i]).to_max(0, 100)
        # ゲージを更新
        @exp_gauge[i].set_rate(rate)
        # NEXT_EXPを描写
        @text[i].set_text(n.to_min(0))
        # 最終レベルを描写
        @lv[i].set_text(last_lv[i])
        # LVUP表示を更新
        @lv[i].update
      end
      # スキップフラグがオフの場合
      if @skip == false then
        # ゲーム画面を更新
        Graphics.update
        # 入力情報を更新
        Input.update
      end
    end
    # 必須ウェイトタイム（変更しない）
    thyme = 0
    # パーティー人数分だけ繰り返す
    for i in 0...$game_party.all_members.size.to_m(MINTO::Max_Size) do
      # LVUP表示カウントを取得する
      size = @lv[i].string_pop_duration.size
      count = @lv[i].string_pop_duration[size - 1].to_i
      # thyme より count の方が高ければ thyme を上書き
      if count > thyme then
        thyme = count
      end
    end
    # 必須ウェイトタイムが1以上の限り更新する
    while thyme >= 1 do
      # パーティー人数分だけ繰り返す
      for i in 0...$game_party.all_members.size.to_m(MINTO::Max_Size) do
        # LVUP表示を更新
        @lv[i].update
      end
      # カウントを減らす
      thyme -= 1
      # ゲーム画面を更新
      Graphics.update
    end
    # 入力情報を更新
    Input.update
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新（スキル習得）
  #    learning_skill : 新たにスキルを習得したかどうかのフラグ
  #--------------------------------------------------------------------------
  def update_skill(learning_skill)
    # SkillLearningSE演奏フラグ
    learning = 0
    # パーティー人数分だけ繰り返す
    for i in 0...$game_party.all_members.size.to_m(MINTO::Max_Size) do
      # アクターを代入
      actor = $game_party.all_members[i]
      # EXPの獲得が可能な場合
      if $game_party.existing_members.include?(actor) then
        # スキル数が増えている場合
        if learning_skill[actor] == true then
          # SkillLearning表示
          @lv[i].string_pop("learning", -64, y_pass(-32))
          # SEを演奏する
          learning = 1
        end
      end
    end
    # 一人でもスキルを習得した場合
    if learning == 1 then
      # SEデータを代入
      data = MINTO::LVUP_SE
      # SEを演奏する
      Audio.se_play("Audio/SE/#{data[0]}", data[1], data[2])
    end
    # 必須ウェイトタイム（変更しない）
    thyme = 0
    # パーティー人数分だけ繰り返す
    for i in 0...$game_party.all_members.size.to_m(MINTO::Max_Size) do
      # LVUP表示カウントを取得する
      count = @lv[i].string_pop_duration[0].to_i
      # thyme より count の方が高ければ thyme を上書き
      if count > thyme then
        thyme = count
      end
    end
    # ループ処理（必須ウェイトタイム）
    thyme.times do
      # パーティー人数分だけ繰り返す
      for i in 0...$game_party.all_members.size.to_m(MINTO::Max_Size) do
        # LVUP表示を更新
        @lv[i].update
      end
      # ゲーム画面を更新
      Graphics.update
    end
    # 入力情報を更新
    Input.update
  end
  #--------------------------------------------------------------------------
  # ● 解放
  #--------------------------------------------------------------------------
  def dispose
    # ループ処理
    for sprite in @text + @lv + @exp_gauge do
      # 特殊スプライトを解放
      sprite.dispose
    end
    # スプライトを解放
    @sprite.bitmap.dispose
    @sprite.dispose
    @sprite2.bitmap.dispose
    @sprite2.dispose
    @sprite3.bitmap.dispose
    @sprite3.dispose
    # スーパークラスを実行
    super
  end
end
#==============================================================================
# ■ Scene_Menu
#------------------------------------------------------------------------------
# 　メニュー画面の処理を行うクラスです。
#==============================================================================

class Scene_Menu < Scene_MenuBase
  #--------------------------------------------------------------------------
  # ● 背景として使うためのスナップショット作成
  #--------------------------------------------------------------------------
  def snapshot_for_background
  end
end
#==============================================================================
# ■ Scene_Battle
#------------------------------------------------------------------------------
# 　バトル画面の処理を行うクラスです。
#==============================================================================

class Scene_Battle < Scene_Base
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_reader   :last_exp                 # 最終EXP
  attr_reader   :last_level               # 最終レベル
  attr_reader   :last_skills              # 最終スキルの配列
  attr_accessor :active_gauge_window      # ゲージウィンドウ
  #--------------------------------------------------------------------------
  # ● 終了処理
  #--------------------------------------------------------------------------
  alias :terminate_Active_Lv_UpVX :terminate
  def terminate
    # アクティブゲージウィンドウが有効な場合
    if @active_gauge_window != nil then
      # アクティブゲージウィンドウを解放
      @active_gauge_window.dispose
      # バトルリザルトウィンドウを解放
      @result_window.dispose
    end
    # アフターバトルフェーズをクリア
    $game_temp.after_battle_phase = false
    # 元の処理を実行
    terminate_Active_Lv_UpVX
  end
  #--------------------------------------------------------------------------
  # ● 終了前処理
  #--------------------------------------------------------------------------
  alias :minto_rgss3_3_pre_terminate :pre_terminate
  def pre_terminate
    # アフターバトルフェーズ中の場合
    if $game_temp.after_battle_phase == true then
      # アフターバトルフェーズの開始
      start_after_battle_phase
      # ループ処理
      loop do
        # ゲーム画面を更新
        Graphics.update
        # 入力情報を更新
        Input.update
        # C ボタンが押された場合
        if Input.trigger?(Input::C) == true then
          break
        end
      end
    end
    # 元の処理を実行
    minto_rgss3_3_pre_terminate
  end
  #--------------------------------------------------------------------------
  # ● アフターバトルフェーズの準備
  #--------------------------------------------------------------------------
  def reservation_after_battle_phase
    # 最終EXPとレベルを初期化
    @last_exp = []
    @last_level = []
    # 最終スキルの配列
    @last_skills = []
    # パーティー人数分だけ繰り返す
    for i in 0...$game_party.all_members.size.to_m(MINTO::Max_Size) do
      # アクターを取得
      actor = $game_party.all_members[i]
      # 最終EXPを保存
      @last_exp[i] = actor.exp.to_i
      # 最終レベルを保存
      @last_level[i] = actor.level.to_i
      # 最終スキルの取得
      @last_skills[i] = actor.skills.dec
    end
    # リザルトデータを記憶
    @exp = $game_troop.exp_total
    @gold = $game_troop.gold_total
    @drop_items = $game_troop.make_drop_items(true)
    @ap = 0
  end
  #--------------------------------------------------------------------------
  # ● アフターバトルフェーズの開始
  #--------------------------------------------------------------------------
  def start_after_battle_phase
    # アクティブゲージウィンドウを作成
    @active_gauge_window = Window_Active_Exp.new(@exp, @last_skills, 
    @last_exp, @last_level)
    # バトルリザルトウィンドウを作成
    @result_window = Window_BattleResult.new(@exp, @gold, @drop_items, @ap,
    @active_gauge_window)
  end
end

end