Ace 스크립트

이 스크립트를 사용하면 전투화면을 RPGXP처럼 만들 수 있습니다.

 

전투화면이 RPGXP 전투화면 스타일이 됩니다.

 

첫번째 스크립트

 

================첫번째 스크립트(모듈 아래에 삽입하세요.)======================

 

==============================================================================

# ★ RGSS3-Extension

# LNX11a_XPスタイルバトル

#  戦闘画面をRPGツクールXP準拠のものに変更します。

#

#  version   : 1.12 (15/02/08)

#  author    : ももまる

#  reference : http://peachround.blog.fc2.com/blog-entry-9.html

#

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

 

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

# ■ LNXスクリプト導入情報

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

$lnx_include = {} if $lnx_include == nil

$lnx_include[:lnx11a] = 112 # version

p "OK:LNX11a_XPスタイルバトル ver1.12"

 

module LNX11

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

  # ● 正規表現

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

  # アクター:バトラーグラフィック = "ファイル名"

  RE_BATTLER = /(?:バトラーグラフィック|battler_graphic)\s*=\s*"([^"]*)"/i

  # アイテム/スキル:使用時アニメ = アニメーションID

  RE_USE_ANIMATION = /(?:使用時アニメ|use_animation)\s*=\s*(\d+)/i

  # アイテム/スキル:ヘルプ説明 = "説明文"

  RE_SHORT_DESCRIPTION =/(?:ヘルプ説明|short_description)\s*=\s*"([^"]*)"/i

  # アイテム/スキル:ヘルプ非表示

  RE_USABLEITEM_NO_DISPLAY = /(?:ヘルプ非表示|no_display)/i

  # アイテム/スキル:使用時追加ウェイト = duration

  RE_DISPLAY_WAIT = /(?:使用時追加ウェイト|display_wait)\s*=\s*(\d+)/i

  # アイテム/スキル:終了時追加ウェイト = duration

  RE_END_WAIT = /(?:終了時追加ウェイト|end_wait)\s*=\s*(\d+)/i

  # 敵キャラ:通常攻撃アニメ = アニメーションID

  RE_ATK_ANIMATION = /(?:通常攻撃アニメ|atk_animation)\s*=\s*(\d+)/i

  # ステート:ステートアニメ = アニメーションID

  RE_STATE_ANIMATION = /(?:ステートアニメ|state_animation)\s*=\s*(\d+)/i

  # ステート:ポップアップ表示名 = "表示名"

  RE_STATE_DISPLAY = /(?:ポップアップ表示名|display_name)\s*=\s*"([^"]*)"/i

  # ステート:ポップアップ非表示

  RE_STATE_NO_DISPLAY = /(?:ポップアップ非表示|no_display)/i

  # ステート:付加ポップアップ非表示

  RE_STATE_ADD_NO_DISPLAY = /(?:付加ポップアップ非表示|add_no_display)/i

  # ステート:解除ポップアップ非表示

  RE_STATE_REM_NO_DISPLAY = /(?:解除ポップアップ非表示|remove_no_display)/i

  # ステート:有利なステート

  RE_STATE_ADVANTAGE = /(?:有利なステート|advantage_state)/i

  # ステート:ポップアップタイプ = type_id

  RE_STATE_TYPE = /(?:ポップアップタイプ|popup_type)\s*=\s*(\d+)/i

  # ステート:付加ポップアップタイプ = type_id

  RE_STATE_ADD_TYPE = /(?:付加ポップアップタイプ|add_popup_type)\s*=\s*(\d+)/i

  # ステート:解除ポップアップタイプ = type_id

  RE_STATE_REM_TYPE=/(?:解除ポップアップタイプ|remove_popup_type)\s*=\s*(\d+)/i

  # ステート:修飾文字非表示

  RE_STATE_NO_DECORATION = /(?:修飾文字非表示|no_decoration)/i

  # ステート:付加修飾文字非表示

  RE_STATE_ADD_NO_DECORATION = /(?:付加修飾文字非表示|add_no_decoration)/i

  # ステート:解除修飾文字非表示

  RE_STATE_REM_NO_DECORATION = /(?:解除修飾文字非表示|remove_no_decoration)/i

  # <<ver1.10>>

  # ステート:付加ポップアップ表示名 = "表示名"

  RE_STATE_ADD_DISPLAY = 

  /(?:付加ポップアップ表示名|add_display_name)\s*=\s*"([^"]*)"/i

  # ステート:解除ポップアップ表示名 = "表示名"

  RE_STATE_REM_DISPLAY = 

  /(?:解除ポップアップ表示名|remove_display_name)\s*=\s*"([^"]*)"/i

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

  # ● バトルステータス更新

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

  # LNX11.バトルステータス更新

  def self.battle_status_refresh

    $game_temp.battle_status_refresh

  end

  def self.バトルステータス更新

    self.battle_status_refresh

  end  

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

  # ● アクターエリア表示/非表示

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

  # LNX11.アクターエリア表示

  def self.actor_area_show

    self.actor_show

    self.status_show

    self.actor_bg_show

  end

  def self.アクターエリア表示

    self.actor_area_show

  end

  # LNX11.アクターエリア非表示

  def self.actor_area_hide

    self.actor_hide

    self.status_hide

    self.actor_bg_hide

  end

  def self.アクターエリア非表示

    self.actor_area_hide

  end

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

  # ● アクター表示/非表示

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

  # LNX11.アクター表示

  def self.actor_show

    $game_party.actor_invisible = false

  end

  def self.アクター表示

    self.actor_show

  end

  # LNX11.アクター非表示

  def self.actor_hide

    $game_party.actor_invisible = true

  end

  def self.アクター非表示

    self.actor_hide

  end

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

  # ● バトルステータス表示/非表示

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

  # LNX11.バトルステータス表示

  def self.status_show

    $game_party.status_invisible = false

    self.battle_status_refresh

  end

  def self.バトルステータス表示

    self.status_show

  end

  # LNX11.バトルステータス非表示

  def self.status_hide

    $game_party.status_invisible = true

    self.battle_status_refresh

  end

  def self.バトルステータス非表示

    self.status_hide

  end

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

  # ● アクター背景表示/非表示

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

  # LNX11.アクター背景表示

  def self.actor_bg_show

    $game_party.actor_bg_invisible = false

  end

  def self.アクター背景表示

    self.actor_bg_show

  end

  # LNX11.アクター背景非表示

  def self.actor_bg_hide

    $game_party.actor_bg_invisible = true

  end

  def self.アクター背景非表示

    self.actor_bg_hide

  end  

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

  # ● バトラーグラフィックのスクリプト指定

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

  # LNX11.バトラーグラフィック(id, filename)

  def self.battler_graphic(id ,filename)

    if id.is_a?(Numeric) && filename.is_a?(String)

      p "LNX11a:バトラーグラフィックを変更しました:ID#{id} #{filename}"

      $game_actors[id].battler_graphic_name = filename

    else

      errormes =  "LNX11a:バトラーグラフィック指定の引数が正しくありません。"

      p errormes, "LNX11a:バトラーグラフィックの指定は行われませんでした。"

      msgbox errormes

    end

  end

  def self.バトラーグラフィック(id ,filename)

    self.battler_graphic(id ,filename)

  end

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

  # ● 任意のポップアップを生成

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

  # LNX11.ポップアップ(battler, popup, type, color, deco)

  def self.make_popup(battler, popup, type = 0, color = :hp_damage, deco = nil)

    return unless $game_party.in_battle

    target = self.battler_search(battler)

    unless target.is_a?(Game_Battler)

      p "LNX11a:任意のポップアップの生成に失敗しました。バトラー指定が"

      p "LNX11a:間違っているか、バトラーが存在していない可能性があります。"

      return

    end

    $game_temp.popup_data.popup_custom(target, popup, type, color, deco)   

  end

  def self.ポップアップ(battler, popup, type=0, color=:hp_damage, deco=nil)

    self.make_popup(battler, popup, type, color, deco)

  end

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

  # ● バトラー指定

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

  def self.battler_search(val)

    if val.is_a?(String)

      # 名前指定

      a = ($game_party.members + $game_troop.members).find {|b| b.name == val }

      return a

    elsif val.is_a?(Array)

      # インデックス指定

      case val[0]

      when :actor ; return $game_party.members[val[1]]

      when :enemy ; return $game_troop.members[val[1]]

      else        ; return nil

      end

    else

      # オブジェクト

      return val

    end

  end

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

  # ● バトルログプッシュ

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

  # LNX11.バトルログ(text)

  def self.battle_log_push(text)

    return unless $game_party.in_battle

    case BATTLELOG_TYPE

    when 0..1 # バトルログ

      BattleManager.log_window.add_text(text)

    when 2 # 簡易ヘルプ表示

      BattleManager.helpdisplay_set(text, 0)

    end

  end

  def self.バトルログ(text)

    self.battle_log_push(text)

  end

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

  # ● バトルログ消去

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

  # LNX11.バトルログ消去

  def self.battle_log_clear

    return unless $game_party.in_battle

    case BATTLELOG_TYPE

    when 0 # バトルログ

      BattleManager.log_window.clear

    when 1 # 蓄積型

      BattleManager.log_window.clear

      $game_temp.battlelog_clear = true

      self.battle_wait(1)

    when 2 # 簡易ヘルプ

      BattleManager.helpdisplay_clear(0)

    end

  end

  def self.バトルログ消去

    self.battle_log_clear

  end

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

  # ● バトルウェイト

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

  # LNX11.バトルウェイト(duration)

  def self.battle_wait(duration)

    return unless $game_party.in_battle

    BattleManager.log_window.abs_wait(duration)

  end

  def self.バトルウェイト(duration)

    self.battle_wait(duration)

  end

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

  # ● 設定値

  #  ※ 設定を変更する場合、LNX11aconf を使用してください。

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

  # <<ver1.00>>

  if !$lnx_include[:lnx11aconf] || 

     $lnx_include[:lnx11aconf] && $lnx_include[:lnx11aconf] < 100

  DEFAULT_BATTLER_GRAPHIC = 0

  DEFAULT_BG_COLOR        = [Color.new(0, 0, 0, 0), Color.new(0, 0, 0, 0)]

  ACTOR_SCREEN_TONE       = false

  TP_POPUP_TYPE           = 1

  INDEXZERO_NO_POPUP      = true

  ACTOR_BACKGROUND        = 2

  ACTOR_BACKGROUND_HEIGHT = 112

  ACTOR_BG_GRADIENT_COLOR = [Color.new(0, 0, 0, 96), Color.new(0, 0, 0, 224)]

  BATTLELOG_TYPE  =  1

  STORAGE_LINE_NUMBER     = 6

  STORAGE_LINE_HEIGHT     = 20

  STORAGE_UP_MESSAGE_TIME = 90

  STORAGE_TURNEND_CLEAR   = true

  STORAGE_OFFSET = {:x => 0, :y => 6}

  STORAGE_FONT   = {:size => 20, :out_color => Color.new(0, 0, 0, 192)}

  STORAGE_GRADIENT_COLOR = [Color.new(0, 0, 0, 128), Color.new(0, 0, 0, 0)]

  POPUP_ADD_WAIT          = 6

  HELPDISPLAY_TYPE        = 1

  HELPDISPLAT_WAIT        = 20

  HELPDISPLAT_END_WAIT    = 24

  HELPDISPLAY_DESCRIPTION = {:size => 20, :delimiter => " "}

  MESSAGE_TYPE  =  2

  MESSAGE_WINDOW_BACKGROUND  = 1

  MESSAGE_WINDOW_POSITION    = 0

  MESSAGE_WAIT = {:battle_start => [120, false], :victory   => [ 60, false], 

                  :defeat       => [120, false], :escape    => [120, false], 

                  :drop_item    => [ 60,  true], :levelup   => [ 60,  true]}

  MESSAGE_WINDOW_ENEMY_NAMES = false

  LEVELUP_SE  = RPG::SE.new("Up4", 90, 100)

  DROPITEM_SE = RPG::SE.new("Item3", 80, 125)

  ACTOR_CENTERING  =  true

  ACTOR_SPACING_ADJUST = 32

  ACTOR_OFFSET  = {:x => -16, :y => 0}

  ACTOR_PADDING = {:side => 4, :bottom => 8}

  SCREEN_ANIMATION_OFFSET = 128

  STATUS_OFFSET = {:x => 64, :y => -12}

  STATUS_SIDE_PADDING   = 6

  STATUS_WIDTH          = 72

  STATUS_AUTOADJUST     = true

  STATUS_LINE_HEIGHT    = 22

  STATUS_NAME_SIZE      = 20

  STATUS_PARAM_SIZE     = 23

  STATUS_GAUGE_OPACITY  = 192

  ACTOR_COMMAND_NOSCROLL   = true

  ACTOR_COMMAND_HORIZON    = false

  ACTOR_COMMAND_ALIGNMENT  = 0

  ACTOR_COMMAND_WIDTH      = 128

  ACTOR_COMMAND_POSITION   = 0

  ACTOR_COMMAND_Y_POSITION = 0

  ACTOR_COMMAND_OFFSET  = {:x => 0, :y => -16}

  PARTY_COMMAND_HORIZON   = true

  PARTY_COMMAND_ALIGNMENT = 1

  PARTY_COMMAND_WIDTH     = Graphics.width

  PARTY_COMMAND_XY        = {:x => 0, :y => 0}

  CURSOR_NAME       = ""

  CURSOR_TONE     = Tone.new(-34, 0, 68)

  CURSOR_ANI_SPEED  = 3

  CURSOR_SPEED      = 3

  CURSOR_BLINK      = true

  CURSOR_MINMAX     = {:min => 48, :max => Graphics.height}

  CURSOR_OFFSET     = {:x => 0, :y => 0}

  HELP_ACTOR_PARAM = {:hp => true ,:mp => true ,:tp => true ,:state => true }

  HELP_ENEMY_PARAM = {:hp => false,:mp => false,:tp => false,:state => true }

  HELP_PARAM_WIDTH    = 72

  RANDOMSCOPE_DISPLAY = 1

  ACTOR_POPUP_POSITION   = 3

  ENEMY_POPUP_POSITION   = 1

  LEVELUP_POPUP_POSITION = 3

  ACTOR_POPUP_Y     =  -100

  LEVELUP_POPUP_Y   =  -112

  NUMBER_FONT   =  ["Arial Black", "VL Gothic"]

  TEXT_FONT     =  ["Arial Black", "VL Gothic"]

  TEXT_FONT_MCS =  ["VL Gothic"]

  LARGE_NUMBER  =  {:fontsize => 38, :spacing => -4, :line_height => 26}

  SMALL_NUMBER  =  {:fontsize => 28, :spacing => -4, :line_height => 20}

  TEXT_SIZERATE     = {:normal => 0.8, :left_right => 0.7, :top_bottom => 0.6}

  TEXT_SIZERATE_MCS = 0.9

  DECORATION_NUMBER = { 

  :critical    => ["CRITICAL", 8], :weakness    => ["WEAKNESS", 8],

  :resist      => ["RESIST"  , 8], :mp_damage   => ["\mp"     , 4],

  :mp_plus     => ["\mp+"    , 4], :mp_minus    => ["\mp-"    , 4],

  :tp_plus     => ["\tp+"    , 4], :tp_minus    => ["\tp-"    , 4]}

  DECORATION_TEXT = {

  :add_state   => "+%s",      :rem_state   => "-%s",

  :add_buff    => "%s UP",    :add_debuff  => "%s DOWN",

  :rem_buff    => "-%s Buff"}

  POPUP_VOCAB = {

  :miss        => "MISS!",      :counter     => "Counter",

  :reflection  => "Reflection", :substitute  => "Substitute",

  :levelup     => "LEVELUP!"}

  POPUP_VOCAB_PARAMS = [

  "MAX\hp","MAX\mp","ATK","DEF","MATK","MDEF","AGI","LUCK"]

  POPUP_COLOR = {

  :hp_damage     => [Color.new(255, 255, 255), Color.new(  0,   0,   0)],

  :critical      => [Color.new(255, 255,  80), Color.new(224,  32,   0)],

  :weakness      => [Color.new(255, 255, 255), Color.new(  0,  56, 144)],

  :resist        => [Color.new(232, 224, 216), Color.new( 56,  48,  40)],

  :hp_recovery   => [Color.new( 96, 255, 128), Color.new(  0,  64,  32)],

  :mp_damage     => [Color.new(248,  80, 172), Color.new( 48,   0,  32)],

  :mp_recovery   => [Color.new(160, 240, 255), Color.new( 32,  48, 144)],

  :tp_damage     => [Color.new(248, 240,  64), Color.new(  0,  80,  40)],

  :add_state     => [Color.new(255, 255, 255), Color.new(  0,  56, 144)],

  :rem_state     => [Color.new(224, 232, 240), Color.new( 32,  64, 128, 128)],

  :add_badstate  => [Color.new(255, 255, 255), Color.new(  0,   0,   0)],

  :rem_badstate  => [Color.new(224, 224, 224), Color.new( 32,  32,  32, 128)],

  :add_buff      => [Color.new(255, 255, 192), Color.new( 96,  64,   0)],

  :add_debuff    => [Color.new(200, 224, 232), Color.new( 40,  48,  56)],

  :rem_buff      => [Color.new(224, 224, 224), Color.new( 32,  32,  32, 128)],

  :counter       => [Color.new(255, 255, 224), Color.new(128,  96,   0)],

  :reflection    => [Color.new(224, 255, 255), Color.new(  0,  96, 128)],

  :substitute    => [Color.new(224, 255, 224), Color.new(  0, 128,  64)],

  :levelup       => [Color.new(255, 255, 255), Color.new(  0,   0,   0)],

  }

  POPUP_TYPE = {

  :miss          =>   0,:hp_damage     =>   0,:hp_slipdamage =>   1,

  :hp_recovery   =>   0,:hp_regenerate =>   1,:hp_drain      =>   0,

  :hp_drainrecv  =>   0,:mp_damage     =>   0,:mp_slipdamage =>   1,

  :mp_recovery   =>   0,:mp_regenerate =>   1,:mp_drain      =>   0,

  :mp_drainrecv  =>   0,:mp_paycost    =>  -1,:tp_damage     =>   1,

  :tp_charge     =>  -1,:tp_gain       =>   7,:tp_regenerate =>   1,

  :tp_paycost    =>  -1,:add_state     =>   2,:rem_state     =>   2,

  :add_badstate  =>   2,:rem_badstate  =>   2,:add_debuff    =>   3,

  :rem_buff      =>   3,:counter       =>   6,:reflection    =>   6,

  :substitute    =>   4,}

  LARGE_MOVEMENT = {

  :inirate    => 6.4,  :gravity      => 0.68,  :side_scatter => 1.2,

  :ref_height =>  32,  :ref_factor   => 0.60,  :ref_count    =>   2,

                       :duration     =>   40,  :fadeout      =>  20 }

  SMALL_MOVEMENT = {

  :inirate    => 4.4,  :gravity      => 0.60,  :side_scatter => 0.0,

  :ref_height =>  12,  :ref_factor   => 0.70,  :ref_count    =>   0,

                       :duration     =>   60,  :fadeout      =>  16 }

  RISE_MOVEMENT     = {:rising_speed => 0.75,  :line_spacing => 0.9,

                       :duration     =>   40,  :fadeout      =>   8 }

  SLIDE_MOVEMENT    = {:x_speed      =>    2,  :line_spacing => 0.9,

                       :duration     =>   50,  :fadeout      =>  32 }

  OVERLAY_MOVEMENT  = {:duration     =>   36,  :fadeout      =>  32 }

  FIX_TARGET_CHECKE     = true

  GUARD_TARGET_CHECKE   = true

  SMART_TARGET_SELECT   = true

  LAST_TARGET           = true

  LAST_PARTY_COMMAND    = true 

  LAST_ACTOR_COMMAND    = true

  TROOP_X_SORT          = true

  PARTY_COMMAND_SKIP    = true

  FITTING_LIST          = true

  ENHANCED_WHITEN       = true

  DISABLED_DAMAGE_SHAKE = true

  TROOP_X_SCREEN_FIX    = true

  TROOP_Y_OFFSET        = 0

  end

  # <<ver1.10>>

  if !$lnx_include[:lnx11aconf] || 

    $lnx_include[:lnx11aconf] && $lnx_include[:lnx11aconf] < 110

  LARGE_NUMBER_NAME = ""

  SMALL_NUMBER_NAME = ""

  LARGE_BUFFS_NAME  = ""

  SMALL_BUFFS_NAME  = ""

  end

end

 

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

# ■ [追加]:Popup_Data

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

#  戦闘中のポップアップをまとめて扱うクラス。ポップアップスプライトの

# initialize 時に自身を参照させて、ポップアップ内容を定義する際にも使います。

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

 

class Popup_Data

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

  # ● クラス変数

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

  @@make_methods = {} # ポップアップ作成メソッドのハッシュ

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

  # ● 定数(ポップアップのタイプID)

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

  SPRING_LARGE  = 0

  SPRING_SMALL  = 1

  RISING_LARGE  = 2

  RISING_SMALL  = 3

  SLIDING_LARGE = 4

  SLIDING_SMALL = 5

  OVERLAY_LARGE = 6

  OVERLAY_SMALL = 7

  LEVELUP       = :levelup

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

  # ● 公開インスタンス変数

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

  attr_accessor :type       # ポップアップのタイプ

  attr_accessor :popup      # 表示する内容

  attr_accessor :popup_size # ポップアップの大きさ

  attr_accessor :color      # 色

  attr_accessor :deco       # 修飾文字

  attr_accessor :battler    # ポップアップするバトラー

  attr_accessor :delay      # 表示開始までの時間

  attr_accessor :viewport   # ビューポート

  attr_accessor :popup_wait # ポップアップウェイト

  attr_accessor :buff_data  # 能力強化/弱体 <<ver1.10>>

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

  # ● オブジェクト初期化

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

  def initialize

    @sprites = []

    @viewport = Viewport.new

    @viewport.z = 120 # ポップアップの Z 座標

    spb = Sprite_PopupBase.new

    spb.create_number

    spb.dispose

    set_methods

    refresh

  end

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

  # ● ポップアップ生成メソッドの登録

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

  def set_methods

    @@make_methods[SPRING_LARGE]  = method(:makeup_spring_large)

    @@make_methods[SPRING_SMALL]  = method(:makeup_spring_small)

    @@make_methods[RISING_LARGE]  = method(:makeup_rising_large)

    @@make_methods[RISING_SMALL]  = method(:makeup_rising_small)

    @@make_methods[SLIDING_LARGE] = method(:makeup_sliding_large)

    @@make_methods[SLIDING_SMALL] = method(:makeup_sliding_small)

    @@make_methods[OVERLAY_LARGE] = method(:makeup_overlay_large)

    @@make_methods[OVERLAY_SMALL] = method(:makeup_overlay_small)

    @@make_methods[LEVELUP]       = method(:makeup_levelup)

  end

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

  # ● スプライト解放

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

  def dispose

    @sprites.each {|sprite| sprite.dispose}

    @viewport.dispose

  end

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

  # ● フレーム更新

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

  def update

    @sprites.each do |sprite|

      sprite.update

      @sprites.delete(sprite) if sprite.disposed?

    end

  end

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

  # ● リフレッシュ

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

  def refresh

    @type  = 0

    @popup = nil

    @popup_size = :large

    @color = :hp_damage

    @deco = ["", -1] # [テキスト, テキストの位置]

    @battler = nil

    @delay = 0

    @popup_wait = false

    # <<ver1.10>> 能力強化/弱体ポップアップを画像で表示する際に利用

    @buff_data = [-1, -1] # [能力, 強化or弱体or解除]

  end

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

  # ● ポップアップを生成

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

  def makeup

    if @@make_methods[@type]

      @@make_methods[@type].call

      @popup_wait = true

    end

  end

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

  # ● ポップアップウェイト

  #  バトルログタイプが [2:ヘルプ表示] の場合のみ実行されます。

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

  def add_wait

    return if LNX11::BATTLELOG_TYPE != 2 || !@popup_wait

    LNX11::POPUP_ADD_WAIT.times {BattleManager.log_window.abs_wait(1)}

    @popup_wait = false

  end

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

  # ● ポップアップ生成メソッド

  #  これらのメソッドを @@make_methods に登録して呼び出します。

  # これはポップアップタイプの拡張を容易にするための仕様です。

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

  def makeup_spring_large

    # @type   0 : 跳ねるポップアップ(大)

    @popup_size = :large

    @sprites.push(Sprite_PopupSpring.new(self))

  end

  def makeup_spring_small

    # @type   1 : 跳ねるポップアップ(小)

    @popup_size = :small

    @delay = @battler.popup_delay[1]

    @sprites.push(Sprite_PopupSpring.new(self))

  end

  def makeup_rising_large

    # @type   2 : ゆっくり上昇(大)

    @popup_size = :large

    @delay = @battler.popup_delay[2]

    @sprites.push(Sprite_PopupRising.new(self))

  end

  def makeup_rising_small

    # @type   3 : ゆっくり上昇(小)

    @popup_size = :small      

    @delay = @battler.popup_delay[2]

    @sprites.push(Sprite_PopupRising.new(self))

  end

  def makeup_sliding_large

    # @type   4 : スライド(大)

    @popup_size = :large

    @delay = @battler.popup_delay[3]

    @sprites.push(Sprite_PopupSliding.new(self))

  end

  def makeup_sliding_small

    # @type   5 : スライド(小)

    @popup_size = :small

    @delay = @battler.popup_delay[3]

    @sprites.push(Sprite_PopupSliding.new(self))      

  end

  def makeup_overlay_large

    # @type   6 : オーバーレイ(大)

    @popup_size = :large

    @sprites.push(Sprite_PopupOverlay.new(self))

  end

  def makeup_overlay_small

    # @type   7 : オーバーレイ(小)

    @popup_size = :small

    @sprites.push(Sprite_PopupOverlay.new(self))

  end

  def makeup_levelup

    # @type :levelup : レベルアップ

    @battler.popup_delay[3] = 0

    @popup_size = :large

    @sprites.push(Sprite_PopupLevelUp.new(self))

  end

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

  # ● TP のポップアップが有効か?

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

  def tp_popup_enabled?(target)

    return false if !$data_system.opt_display_tp

    return true  if LNX11::TP_POPUP_TYPE == 0 # すべてポップアップ

    return true  if LNX11::TP_POPUP_TYPE == 1 && target.actor? # アクターのみ

    false # ポップアップしない

  end

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

  # ● 任意のポップアップ

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

  def popup_custom(target, popup, type = 0, color = :hp_damage, deco = nil)

    refresh

    @battler = target

    @popup = popup

    type = LNX11::POPUP_TYPE[type] if type.is_a?(Symbol)

    @type = type

    @color = color

    @deco = LNX11::DECORATION_NUMBER[deco] if deco.is_a?(Symbol)

    # ポップアップ作成

    makeup

  end

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

  # ● レベルアップのポップアップ

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

  def popup_levelup(target)

    # 戦闘に参加している場合のみポップアップ

    return unless $game_party.battle_members.include?(target)

    refresh

    @type = :levelup

    @battler = target

    @popup = LNX11::POPUP_VOCAB[:levelup]

    @color = :levelup

    # ポップアップ作成

    makeup

  end

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

  # ● 単一テキストのポップアップ

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

  def popup_text(target, type)

    refresh

    @type = LNX11::POPUP_TYPE[type]

    @battler = target

    @popup = LNX11::POPUP_VOCAB[type]

    @color = type

    # ポップアップ作成

    makeup

  end

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

  # ● ミスのポップアップ

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

  def popup_miss(target, item)

    refresh

    @type = LNX11::POPUP_TYPE[:miss]

    @battler = target

    @popup = LNX11::POPUP_VOCAB[:miss]

    @color = :hp_damage

    # ポップアップ作成

    makeup

  end

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

  # ● HP ダメージポップアップ

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

  def popup_hp_damage(target, item)

    return if target.result.hp_damage == 0 && item && !item.damage.to_hp?

    refresh

    @popup = target.result.hp_damage

    @battler = target

    if target.result.hp_drain > 0

      # 被吸収

      @type = LNX11::POPUP_TYPE[:hp_drain]

      # 弱点/耐性

      if target.result.element_rate > 1

        @deco = LNX11::DECORATION_NUMBER[:weakness]

        @color = :weakness

      elsif target.result.element_rate < 1

        @deco = LNX11::DECORATION_NUMBER[:resist]

        @color = :resist

      else

        @color = :hp_damage

      end

    elsif target.result.hp_damage > 0

      # ダメージ

      @type = LNX11::POPUP_TYPE[:hp_damage]

      @color = :hp_damage

      if target.result.critical

        # クリティカル

        @deco = LNX11::DECORATION_NUMBER[:critical]

        @color = :critical

      end

      # 弱点/耐性

      if target.result.element_rate > 1

        @deco = LNX11::DECORATION_NUMBER[:weakness]

        @color = :weakness if @color != :critical

      elsif target.result.element_rate < 1

        @deco = LNX11::DECORATION_NUMBER[:resist]

        @color = :resist if @color != :critical

      end

    elsif target.result.hp_damage < 0

      # 回復

      @type = LNX11::POPUP_TYPE[:hp_recovery]

      @color = :hp_recovery

    else

      # 0 ダメージ

      @type = LNX11::POPUP_TYPE[:hp_damage]

      @color = :hp_damage

    end 

    # ポップアップ作成

    makeup

  end

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

  # ● MP ダメージポップアップ

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

  def popup_mp_damage(target, item)

    return if target.dead? || target.result.mp_damage == 0

    refresh

    @popup = target.result.mp_damage

    @battler = target

    @deco = LNX11::DECORATION_NUMBER[:mp_damage]

    if target.result.mp_drain > 0

      # 被吸収

      @type = LNX11::POPUP_TYPE[:mp_drain]

      @color = :mp_damage

    elsif target.result.mp_damage > 0

      # ダメージ

      @type = LNX11::POPUP_TYPE[:mp_damage]

      @color = :mp_damage

    elsif target.result.mp_damage < 0

      # 回復

      @type = LNX11::POPUP_TYPE[:mp_recovery]

      @color = :mp_recovery

    end

    # ポップアップ作成

    makeup

  end

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

  # ● TP ダメージポップアップ

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

  def popup_tp_damage(target, item)

    return unless tp_popup_enabled?(target)

    return if target.dead? || target.result.tp_damage == 0

    refresh

    @popup = target.result.tp_damage

    @battler = target

    deco = target.result.tp_damage > 0 ? :tp_minus : :tp_plus

    @deco = LNX11::DECORATION_NUMBER[deco]

    @type = LNX11::POPUP_TYPE[:tp_damage]

    @color = :tp_damage

    # ポップアップ作成

    makeup

  end

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

  # ● HP 吸収回復

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

  def popup_hp_drain(target, hp_drain)

    return if hp_drain == 0

    refresh

    @popup = hp_drain

    @battler = target

    @type = LNX11::POPUP_TYPE[:hp_drainrecv]

    @color = :hp_recovery

    # ポップアップ作成

    makeup

  end

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

  # ● MP 吸収回復

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

  def popup_mp_drain(target, mp_drain)

    return if mp_drain == 0

    refresh

    @popup = mp_drain

    @battler = target

    @deco = LNX11::DECORATION_NUMBER[:mp_damage]

    @type = LNX11::POPUP_TYPE[:mp_drainrecv]

    @color = :mp_recovery

    # ポップアップ作成

    makeup

  end

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

  # ● ステート付加のポップアップ

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

  def popup_added_states(target)

    refresh

    @battler = target

    target.result.added_state_objects.each do |state|

      next if state.id == target.death_state_id

      next if state.icon_index == 0 && LNX11::INDEXZERO_NO_POPUP

      next if state.add_no_display?      

      if state.add_no_decoration?

        @popup = state.add_display_name

      else

        @popup = sprintf(LNX11::DECORATION_TEXT[:add_state],

                         state.add_display_name)

      end

      type = state.advantage? ? :add_state : :add_badstate

      if state.add_popup_type

        @type = state.add_popup_type

      else

        @type = LNX11::POPUP_TYPE[type]

      end

      @color = type

      # ポップアップ作成

      makeup

    end

  end

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

  # ● ステート解除のポップアップ

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

  def popup_removed_states(target)

    refresh

    @type = LNX11::POPUP_TYPE[:rem_badstate]

    @battler = target

    target.result.removed_state_objects.each do |state|

      next if state.id == target.death_state_id

      next if state.icon_index == 0 && LNX11::INDEXZERO_NO_POPUP

      next if state.remove_no_display?

      if state.remove_no_decoration?

        @popup = state.remove_display_name

      else

        @popup = sprintf(LNX11::DECORATION_TEXT[:rem_state],

                         state.remove_display_name)

      end

      type = state.advantage? ? :rem_state : :rem_badstate

      if state.remove_popup_type

        @type = state.remove_popup_type

      else

        @type = LNX11::POPUP_TYPE[type]

      end

      @color = type

      # ポップアップ作成

      makeup

    end

  end

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

  # ● 能力強化/弱体のポップアップ

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

  def popup_buffs(target, buffs, fmt)

    return if buffs.empty?

    refresh

    @battler = target

    case fmt 

    when Vocab::BuffAdd 

      buffdeco = LNX11::DECORATION_TEXT[:add_buff]

      @type = LNX11::POPUP_TYPE[:add_buff]

      @color = :add_buff

      @buff_data[1] = 0

    when Vocab::DebuffAdd

      buffdeco = LNX11::DECORATION_TEXT[:add_debuff]

      @type = LNX11::POPUP_TYPE[:add_debuff]

      @color = :add_debuff

      @buff_data[1] = 1

    when Vocab::BuffRemove

      buffdeco = LNX11::DECORATION_TEXT[:rem_buff]

      @type = LNX11::POPUP_TYPE[:rem_buff]

      @color = :rem_buff

      @buff_data[1] = 2

    end

    buffs.each do |param_id|

      @popup = sprintf(buffdeco, LNX11::POPUP_VOCAB_PARAMS[param_id])

      @buff_data[0] = param_id

      # ポップアップ作成

      makeup

      @popup_wait = false

    end

  end

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

  # ● HP 再生

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

  def popup_regenerate_hp(target, hp_damage, paycost = false)

    return if hp_damage == 0

    refresh

    @popup = hp_damage

    @battler = target

    if hp_damage > 0

      # ダメージ

      @type = LNX11::POPUP_TYPE[:hp_slipdamage]

      @color = :hp_damage

    elsif hp_damage < 0

      # 回復

      @type = LNX11::POPUP_TYPE[:hp_regenerate]

      @color = :hp_recovery

    end 

    # ポップアップ作成

    makeup

  end

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

  # ● MP 再生

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

  def popup_regenerate_mp(target, mp_damage, paycost = false)

    return if mp_damage == 0

    refresh

    @popup = mp_damage

    @battler = target

    @deco = LNX11::DECORATION_NUMBER[mp_damage > 0 ? :mp_minus : :mp_plus]

    if mp_damage > 0

      # ダメージ

      @type = LNX11::POPUP_TYPE[paycost ? :mp_paycost : :mp_slipdamage]

      @color = :mp_damage

    elsif mp_damage < 0

      # 回復

      @type = LNX11::POPUP_TYPE[paycost ? :mp_paycost : :mp_regenerate]

      @color = :mp_recovery

    end

    # ポップアップ作成

    makeup

  end

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

  # ● TP 再生

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

  def popup_regenerate_tp(target, tp_damage, paycost = false)

    return unless tp_popup_enabled?(target)

    return if tp_damage == 0

    refresh

    @popup = tp_damage

    @battler = target

    @deco = LNX11::DECORATION_NUMBER[tp_damage > 0 ? :tp_minus : :tp_plus]

    @type = LNX11::POPUP_TYPE[paycost ? :tp_paycost : :tp_regenerate]

    @color = :tp_damage

    # ポップアップ作成

    makeup

  end

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

  # ● TP チャージ

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

  def popup_tp_charge(target, tp_damage)

    return unless tp_popup_enabled?(target)

    return if tp_damage == 0

    refresh

    @popup = tp_damage

    @battler = target

    @deco = LNX11::DECORATION_NUMBER[tp_damage > 0 ? :tp_minus : :tp_plus]

    @type = LNX11::POPUP_TYPE[:tp_charge]

    @color = :tp_damage

    # ポップアップ作成

    makeup

  end

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

  # ● TP 得

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

  def popup_tp_gain(target, tp_damage)

    return unless tp_popup_enabled?(target)

    return if tp_damage == 0

    refresh

    @popup = tp_damage

    @battler = target

    @deco = LNX11::DECORATION_NUMBER[tp_damage > 0 ? :tp_minus : :tp_plus]

    @type = LNX11::POPUP_TYPE[:tp_gain]

    @color = :tp_damage

    # ポップアップ作成

    makeup

  end

end

 

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

# ■ [追加]:Sprite_PopupBase

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

#  戦闘中のダメージ表示等をポップアップ表示するためのスプライトの

# スーパークラス。サブクラスで細かい動きを定義します。

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

 

class Sprite_PopupBase < Sprite

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

  # ● クラス変数

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

  @@cache_number = []

  @@cache_text   = {}

  @@w = []

  @@h = []

  @@priority = 0

  @@count    = 0

  @@buf_bitmap = nil

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

  # ● 定数

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

  NUMBER_COLOR_SIZE = 8

  NUMBERS    = [0,1,2,3,4,5,6,7,8,9]

  COLOR_KEYS = LNX11::POPUP_COLOR.keys 

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

  # ● オブジェクト初期化

  #     data : ポップアップデータ

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

  def initialize(data = nil)

    if data == nil || !data.battler.battle_member?

      # 非表示のポップアップ

      super(nil)

      @remove = true

      return

    end

    # ポップアップデータを適用

    super(data.viewport)

    @battler = data.battler # ポップアップを表示するバトラー

    @delay   = data.delay   # ディレイ(遅延) ※サブクラスによって扱いが違います

    @popup_size = data.popup_size # ポップアップの大きさ 大/小

    # 基本設定

    @duration = 60  # 消え始める時間

    @fadeout  = 16  # 消える速さ

    @rx = ry  = 0   # XY座標

    # Z座標

    @rz = base_z * 128 + priority

    popup_add

    self.visible = false

    # ポップアップデータからビットマップを作成

    if data.popup.is_a?(Numeric)

      # ダメージ値

      self.bitmap = number(data.popup, data.color, data.popup_size, data.deco)

    elsif data.popup.is_a?(String)

      # テキスト

      self.bitmap = text(data.popup, data.color, 

                         data.popup_size, data.buff_data)

    end

    # 位置設定

    self.ox = self.width  / 2

    self.oy = self.height / 2

    set_position

    start

  end

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

  # ● 解放

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

  def dispose

    popup_remove

    terminate

    self.bitmap.dispose if self.bitmap

    super

  end

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

  # ● フレーム更新

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

  def update

    return if removed? || delay?

    update_popup

    update_xy

    @duration -= 1

    self.opacity -= @fadeout if @duration <= 0

    dispose if self.opacity == 0

  end

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

  # ● 開始処理(サブクラスで定義)

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

  def start

  end

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

  # ● 終了処理(サブクラスで定義)

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

  def terminate

  end

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

  # ● フレーム更新(サブクラスで定義)

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

  def update_popup

  end

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

  # ● ポップアップ Z 座標

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

  def base_z

    0

  end

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

  # ● ポップアップのプライオリティを返す

  #  同一Z座標のポップアップで、後から生成されたものが手前に表示されるように

  # Z座標の修正値をクラス変数で管理しています。

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

  def priority

    @@priority * 2

  end

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

  # ● ポップアップ追加

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

  def popup_add

    @@priority += 1

    @@count += 1

  end

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

  # ● ポップアップ消去

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

  def popup_remove

    @remove = true

    @@count -= 1

    @@priority = 0 if @@count <= 0

  end

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

  # ● ディレイが残っている?

  #  サブクラスの update メソッドで使用します。

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

  def delay?

    @delay -= 1

    self.visible = (@delay <= 0)

    !self.visible

  end

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

  # ● ポップアップ消去済み?

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

  def removed?

    @remove

  end  

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

  # ● 座標更新

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

  def update_xy

    self.x = @rx

    self.y = @ry

    self.z = @rz

  end

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

  # ● ポップアップ位置の設定

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

  def set_position

    @rx = @battler.screen_x

    if @battler.actor?

      pos = LNX11::ACTOR_POPUP_POSITION

    else

      pos = [LNX11::ENEMY_POPUP_POSITION, 2].min

    end

    case pos

    when 0 ; @ry = @battler.screen_y        # 足元

    when 1 ; @ry = @battler.screen_y_center # 中心

    when 2 ; @ry = @battler.screen_y_top    # 頭上

    when 3 ; @ry = Graphics.height + LNX11::ACTOR_POPUP_Y # Y座標統一(アクター)

    end

  end

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

  # ● 描画するテキストの矩形を取得

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

  def text_size(str, name, size, bold = false)

    @@buf_bitmap = Bitmap.new(4, 4) if !@@buf_bitmap || @@buf_bitmap.disposed?

    @@buf_bitmap.font.name = name

    @@buf_bitmap.font.size = size

    @@buf_bitmap.font.bold = bold

    return @@buf_bitmap.text_size(str)

  end

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

  # ● 数字ビットマップの取得

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

  def bitmap_number(size = :large)

    return @@cache_number[size == :large ? 0 : 1]

  end

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

  # ● 数字ビットマップキャッシュの作成

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

  def create_number

    return if @@cache_number[0] && !@@cache_number[0].disposed?

    n_index = NUMBER_COLOR_SIZE

    @@cache_number.clear

    colors = LNX11::POPUP_COLOR.values # 色

    name = LNX11::NUMBER_FONT

    # 大・小の 2 パターンを作成する(ループ)

    [LNX11::LARGE_NUMBER, LNX11::SMALL_NUMBER].each_with_index do |n_size, i|

      next if get_number(i)

      size = n_size[:fontsize]

      # 数字の幅・高さ

      w = NUMBERS.collect{|n| text_size(n.to_s, name, size).width}.max + 4

      nh = NUMBERS.collect{|n| text_size(n.to_s, name, size).height}.max

      h = n_size[:line_height]

      @@w[i] = w

      @@h[i] = h

      # ビットマップ作成

      bitmap = Bitmap.new(w * NUMBERS.size, h * [colors.size, n_index].min)

      bitmap.font.name = LNX11::NUMBER_FONT

      bitmap.font.size = n_size[:fontsize]

      y = ((h - nh) / 2) - 1

      # 色ごとに分けて描画する(ループ)

      n_index.times do |col|

        # 色を変更

        bitmap.font.color.set(colors[col][0])

        bitmap.font.out_color.set(colors[col][1])

        # 文字ごとに分けて描画(ループ)

        NUMBERS.size.times do |num|

          bitmap.draw_text(num * w, (col * h) + y, w, nh, NUMBERS[num], 2)

        end

      end

      @@cache_number.push(bitmap)

    end

    p "LNX11a:数字ビットマップのキャッシュを作成しました。"

    # 数字ビットマップを表示する(テスト用)

    # s = Sprite.new

    # s.z = 1000000

    # s.bitmap = @@cache_number[1] # 0 or 1

    # loop do Graphics.update end

  end

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

  # ● 数字ビットマップの取得

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

  def get_number(i)

    case i

    when 0 # 大

      return false if LNX11::LARGE_NUMBER_NAME.empty?

      bitmap = Cache.system(LNX11::LARGE_NUMBER_NAME)

    when 1 # 小

      return false if LNX11::SMALL_NUMBER_NAME.empty?

      bitmap = Cache.system(LNX11::SMALL_NUMBER_NAME)

    end

    @@cache_number.push(bitmap)

    @@w[i] = bitmap.width / NUMBERS.size

    @@h[i] = bitmap.height / NUMBER_COLOR_SIZE

    true

  end

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

  # ● ダメージ数を描画したビットマップの取得

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

  def number(num, color, size = :large, deco = nil)

    # 数値を文字列の配列にする

    numbers = (num.abs.to_s).split(//)

    # 色番号を取得

    color_index = COLOR_KEYS.index(color)

    # ポップアップサイズを設定

    n_bitmap = bitmap_number(size)

    if size == :large

      n_size = LNX11::LARGE_NUMBER

      i = 0

    else

      n_size = LNX11::SMALL_NUMBER

      i = 1

    end

    spacing = n_size[:spacing]

    w = @@w[i]

    h = @@h[i]

    # ダメージ値のビットマップサイズ

    @bw = w * numbers.size + spacing * (numbers.size - 1)

    @bh = h

    # 修飾文字の描画

    @offset_x = @offset_y = 0

    text_bitmap = deco_text(deco,color,n_size[:fontsize]) if deco[1] >= 0

    # ビットマップを作成

    bitmap = Bitmap.new(@bw, @bh) 

    # 塗りつぶし(テスト用)

    # bitmap.fill_rect(bitmap.rect, Color.new(0,0,0,128))

    # ダメージ値を描画

    rect = Rect.new(0, h * color_index, w, h)

    numbers.size.times do |n|

      rect.x = numbers[n].to_i * w

      bitmap.blt(w * n + spacing * n + @offset_x, @offset_y, n_bitmap, rect) 

    end

    # 修飾文字の描画をコールバック

    @decoblt.call(bitmap) if @decoblt

    @decoblt = nil

    # ビットマップを返す

    bitmap

  end

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

  # ● 修飾文字の描画

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

  def deco_text(deco, color, sizerate)

    # 元の幅・高さ

    ow = @bw

    oh = @bh

    case deco[1]    

    when 2 # ダメージ値の下

      # テキストのビットマップを取得

      size = decosize(deco[0], sizerate, :top_bottom)

      text_bitmap = text(deco[0], color, size)

      # テキストの幅・高さ

      tw = text_bitmap.width

      th = text_bitmap.height * 0.8

      # 最終的なビットマップのサイズ

      @bw = [@bw, tw].max

      @bh += th

      # ダメージ値の描画位置の修正

      @offset_x = (@bw - ow) / 2

      @offset_y = 0

      # 修飾文字の描画位置を設定

      x = (@bw - tw) / 2

      y = oh * 0.8

    when 4 # ダメージ値の左

      # テキストのビットマップを取得

      size = decosize(deco[0], sizerate, :left_right)

      text_bitmap = text(deco[0], color, size)

      # テキストの幅・高さ

      tw = text_bitmap.width

      th = text_bitmap.height

      # 最終的なビットマップのサイズ

      @bw += tw

      @bh = [@bh, th].max

      # ダメージ値の描画位置の修正

      @offset_x = tw

      @offset_y = (@bh - oh) / 2

      # 修飾文字の描画位置を設定

      x = 2

      y = (@bh - th) / 2

    when 6 # ダメージ値の右

      # テキストのビットマップを取得

      size = decosize(deco[0], sizerate, :left_right)

      text_bitmap = text(deco[0], color, size)

      # テキストの幅・高さ

      tw = text_bitmap.width

      th = text_bitmap.height

      # 最終的なビットマップのサイズ

      @bw += tw

      @bh = [@bh, th].max

      # ダメージ値の描画位置の修正

      @offset_x = 0

      @offset_y = (@bh - oh) / 2

      # 修飾文字の描画位置を設定

      x = ow

      y = (@bh - th) / 2

    when 8 # ダメージ値の上

      # テキストのビットマップを取得

      size = decosize(deco[0], sizerate, :top_bottom)

      text_bitmap = text(deco[0], color, size)

      # テキストの幅・高さ

      tw = text_bitmap.width

      th = text_bitmap.height * 0.8

      # 最終的なビットマップのサイズ

      @bw = [@bw, tw].max

      @bh += th

      # ダメージ値の描画位置の修正

      @offset_x = (@bw - ow) / 2

      @offset_y = @bh - oh

      # 修飾文字の描画位置を設定

      x = (@bw - tw) / 2

      y = 0

    end

    # 修飾文字の描画(コールバック)

    @decoblt = Proc.new {|bitmap|

    bitmap.blt(x, y, text_bitmap, text_bitmap.rect)

    text_bitmap.dispose}

    return text_bitmap

  end

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

  # ● 修飾文字のサイズ

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

  def decosize(text, size, pos)

    if text.length != text.bytesize

      return size * LNX11::TEXT_SIZERATE[pos] * LNX11::TEXT_SIZERATE_MCS

    else

      return size * LNX11::TEXT_SIZERATE[pos]

    end

  end

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

  # ● テキストを描画したビットマップの取得

  #  ステートやダメージ値の修飾文字の描画に使用します。

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

  def text(text, color, size = :large, buff_data = [-1, -1])

    # キャッシュがあればそれを返す(無ければ作成)

    key = text + color.to_s + size.to_s

    if @@cache_text[key] && !@@cache_text[key].disposed?

      return @@cache_text[key].clone 

    end

    # 用語の置き換え

    text.gsub!("\hp") { Vocab::hp_a } if text.include?("\hp")

    text.gsub!("\mp") { Vocab::mp_a } if text.include?("\mp") 

    text.gsub!("\tp") { Vocab::tp_a } if text.include?("\tp")

    # <<ver1.10>> テキストの頭に _ があれば対応する画像ファイルを参照する

    if text[/^[\_]./]

      bitmap = get_text_bitmap(text, color, size)

      # キャッシュに保存

      @@cache_text[key] = bitmap

      # ビットマップを返す

      return bitmap.clone

    end

    # <<ver1.10>> 

    # 能力強化/弱体のポップアップで、ファイル名が指定されていればそれを返す

    if buff_data[0] >= 0 &&

      (size == :large && !LNX11::LARGE_BUFFS_NAME.empty?) ||

      (size == :small && !LNX11::SMALL_BUFFS_NAME.empty?)

      bitmap = get_buff_bitmap(buff_data, size)

      # キャッシュに保存

      @@cache_text[key] = bitmap

      # ビットマップを返す

      return bitmap.clone

    end

    # テキストにマルチバイト文字があれば日本語用フォントを使う

    if text.length != text.bytesize

      fontname = LNX11::TEXT_FONT_MCS

      sizerate = LNX11::TEXT_SIZERATE[:normal] * LNX11::TEXT_SIZERATE_MCS

    else

      fontname = LNX11::TEXT_FONT

      sizerate = LNX11::TEXT_SIZERATE[:normal]

    end

    # ポップアップサイズを設定

    case size

    when :large ; fontsize = LNX11::LARGE_NUMBER[:fontsize] * sizerate

    when :small ; fontsize = LNX11::SMALL_NUMBER[:fontsize] * sizerate

    else        ; fontsize = size

    end

    # テキストサイズ計算

    rect = text_size(text, fontname, fontsize)

    rect.width += 2

    # ビットマップを作成

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

    # 塗りつぶし(テスト用)

    # bitmap.fill_rect(bitmap.rect, Color.new(0,0,0,128)) 

    # フォント設定

    bitmap.font.name = fontname

    bitmap.font.size = fontsize

    bitmap.font.color.set(LNX11::POPUP_COLOR[color][0])

    bitmap.font.out_color.set(LNX11::POPUP_COLOR[color][1])

    # テキスト描画

    bitmap.draw_text(rect, text, 1)

    # キャッシュに保存

    @@cache_text[key] = bitmap

    # ビットマップを返す

    bitmap.clone

  end

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

  # ● 能力強化/弱体ビットマップの取得 <<ver1.10>>

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

  def get_buff_bitmap(buff_data, size)

    case size

    when :large ; src_bitmap = Cache.system(LNX11::LARGE_BUFFS_NAME)

    when :small ; src_bitmap = Cache.system(LNX11::SMALL_BUFFS_NAME)

    end

    src_rect = Rect.new

    src_rect.width  = src_bitmap.width  / 2

    src_rect.height = src_bitmap.height / 12

    src_rect.x = (buff_data[0] / 4) * src_rect.width

    src_rect.y = (buff_data[0] % 4) * src_rect.height * 3 +

                  buff_data[1] * src_rect.height

    bitmap = Bitmap.new(src_rect.width, src_rect.height)

    bitmap.blt(0, 0, src_bitmap, src_rect)

    bitmap

  end

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

  # ● テキストビットマップの取得 <<ver1.10>>

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

  def get_text_bitmap(text, color, size)

    # クリティカルカラーかつ、弱点/耐性なら参照するビットマップを変更

    if LNX11::POPUP_COLOR[color] == LNX11::POPUP_COLOR[:critical] &&

      (text == LNX11::DECORATION_NUMBER[:weakness][0] ||

       text == LNX11::DECORATION_NUMBER[:resist][0])

      # ファイル名に _critcolor を加える

      text += "_critcolor"

    end

    # MPダメージ/回復(符号なし)なら参照するビットマップを変更

    if text == LNX11::DECORATION_NUMBER[:mp_damage][0]

      # カラーに応じてファイル名を変更

      case LNX11::POPUP_COLOR[color]

      when LNX11::POPUP_COLOR[:mp_damage]   ; text += "_damage"

      when LNX11::POPUP_COLOR[:mp_recovery] ; text += "_recovery"

      end

    end

    # popup_xxxxxx_(large or small)

    Cache.system("popup" + text + (size == :large ? "_large" : "_small"))

  end

end

 

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

# ■ [追加]:Sprite_PopupSpring

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

#  通常の跳ねるポップアップ。

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

 

class Sprite_PopupSpring < Sprite_PopupBase

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

  # ● ポップアップ Z 座標

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

  def base_z

    14

  end

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

  # ● 開始処理

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

  def start

    # 動き設定

    set_movement

    # ディレイ設定 同じタイプのポップアップが重ならないようにする

    if @popup_size == :small

      self.oy -= @battler.popup_delay[1]

      @delay_clear = (@delay == 0)

      dy = self.bitmap.height * 0.8

      @battler.popup_delay[1] += dy

      @delay = 0

    end

  end

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

  # ● 終了処理

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

  def terminate

    # 一番上のポップアップなら、ディレイを初期化する

    @battler.popup_delay[1] = 0 if @delay_clear

  end

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

  # ● 投射運動の設定

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

  def set_movement

    if @popup_size == :large

      movement = LNX11::LARGE_MOVEMENT

    else

      movement = LNX11::SMALL_MOVEMENT

    end

    @fall       = -movement[:inirate]

    @gravity    =  movement[:gravity]

    @side       =  movement[:side_scatter] * rand(0) * (rand(2) == 0 ? -1 : 1)

    @ref_move   =  movement[:ref_height]

    @ref_factor =  movement[:ref_factor]

    @ref_count  =  movement[:ref_count]

    @duration   =  movement[:duration]

    @fadeout    =  movement[:fadeout]

  end

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

  # ● フレーム更新

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

  def update_popup

    update_freefall

  end

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

  # ● 投射運動の更新

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

  def update_freefall

    if @ref_count >= 0

      # X:左右移動

      @rx += @side

      # Y:自由落下

      @ry += @fall

      @ref_move -= @fall

      @fall += @gravity

      # 跳ね返り

      if @ref_move <= 0 && @fall >= 0

        @ref_count -= 1

        @fall = -@fall * @ref_factor

      end      

    end

  end

end

 

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

# ■ [追加]:Sprite_PopupRising

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

#  少しずつ上昇するポップアップ。

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

 

class Sprite_PopupRising < Sprite_PopupBase

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

  # ● ポップアップ Z 座標

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

  def base_z

    6

  end

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

  # ● 開始処理

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

  def start

    # 動き設定

    set_movement

    self.opacity = 0

    d = self.bitmap.height * LNX11::RISE_MOVEMENT[:line_spacing]

    @delay_count = d / @rising_speed 

    @battler.popup_delay[2] += @delay_count

  end

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

  # ● 動きの設定

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

  def set_movement

    @rising_speed = LNX11::RISE_MOVEMENT[:rising_speed]

    @duration = LNX11::RISE_MOVEMENT[:duration]

    @fadeout  = LNX11::RISE_MOVEMENT[:fadeout]

  end

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

  # ● フレーム更新

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

  def update_popup

    @delay_count -= 1

    @battler.popup_delay[2] -= 1 if @delay_count >= 0

    @ry -= @rising_speed # すこしずつ上昇

    self.opacity += 32 if @duration > 0

  end

end

 

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

# ■ [追加]:Sprite_PopupSliding

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

#  スライド表示するポップアップ。

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

 

class Sprite_PopupSliding < Sprite_PopupBase

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

  # ● ポップアップ Z 座標

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

  def base_z

    8

  end

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

  # ● 開始処理

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

  def start

    # 動き設定

    set_movement

    d = self.bitmap.height * LNX11::SLIDE_MOVEMENT[:line_spacing]

    self.oy += @delay + d / 2 if @delay > 0

    self.opacity = 0

    # ディレイ設定 同じタイプのポップアップが重ならないようにする

    @delay_clear = (@delay == 0)

    @battler.popup_delay[3] += (@delay <= 0 ? d / 2 : d)

    @delay = 0

  end

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

  # ● 終了処理

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

  def terminate

    # 一番下のポップアップなら、ディレイを初期化する

    @battler.popup_delay[3] = 0 if @delay_clear

  end

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

  # ● 動きの設定

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

  def set_movement

    @x_speed  = LNX11::SLIDE_MOVEMENT[:x_speed]

    @duration = LNX11::SLIDE_MOVEMENT[:duration]

    @fadeout  = LNX11::SLIDE_MOVEMENT[:fadeout]

    # フェードインのスライド分だけ X を移動

    @rx -= @x_speed * 255.0 / @fadeout

  end

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

  # ● フレーム更新

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

  def update_popup

    @rx += @x_speed if opacity != 255 # スライド

    self.opacity += @fadeout if @duration > 0

  end

end

 

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

# ■ [追加]:Sprite_PopupOverlay

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

#  オーバーレイポップアップ。自身の複製を加算合成で重ね合わせます。

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

 

class Sprite_PopupOverlay < Sprite_PopupBase

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

  # ● ポップアップ Z 座標

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

  def base_z

    10

  end

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

  # ● 開始処理

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

  def start

    @duration = LNX11::OVERLAY_MOVEMENT[:duration]

    @fadeout  = LNX11::OVERLAY_MOVEMENT[:fadeout]

    # オーバーレイの作成

    create_overlay

  end

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

  # ● 終了処理

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

  def terminate

    @overlay.dispose

    @overlay = nil

  end

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

  # ● オーバーレイ(複製)の作成

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

  def create_overlay

    @overlay = Sprite.new

    @overlay.bitmap   = self.bitmap

    @overlay.viewport = self.viewport

    @overlay.ox = self.ox

    @overlay.oy = self.oy

    @overlay.visible = false

    @overlay.blend_type = 1

  end

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

  # ● フレーム更新

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

  def update_popup

    self.opacity += @fadeout * 2 if @duration > 0

  end

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

  # ● フレーム更新

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

  def update

    super

    update_overlay

  end

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

  # ● オーバーレイの更新

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

  def update_overlay

    return if self.disposed? || @overlay.opacity == 0

    @overlay.x = self.x

    @overlay.y = self.y

    @overlay.z = self.z

    # 拡大・消去

    @overlay.zoom_x += 0.16

    @overlay.zoom_y += 0.12

    @overlay.opacity -= 20

    @overlay.visible = (@overlay.opacity != 0)

  end

end

 

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

# ■ [追加]:Sprite_PopupLevelUp

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

#  レベルアップのポップアップ。スライドポップアップを継承しています。

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

 

class Sprite_PopupLevelUp < Sprite_PopupSliding

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

  # ● ポップアップ Z 座標

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

  def base_z

    32

  end

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

  # ● ポップアップ位置の設定

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

  def set_position

    @rx = @battler.screen_x - LNX11::ACTOR_OFFSET[:x]

    case LNX11::LEVELUP_POPUP_POSITION

    when 0 ; @ry = @battler.screen_y        # 足元

    when 1 ; @ry = @battler.screen_y_center # 中心

    when 2 ; @ry = @battler.screen_y_top    # 頭上

    when 3 ; @ry = Graphics.height + LNX11::LEVELUP_POPUP_Y # Y座標統一

    end

  end

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

  # ● フレーム更新

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

  def update_popup

    super

    # リザルト中なら自動的に消去しない

    @duration += 1 if $game_troop.all_dead? || $game_message.busy?

  end

end

 

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

# ■ Bitmap

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

 

class Bitmap

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

  # ● [追加]:カーソル用三角形の描画

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

  def lnx_cursor_triangle(size, color, oy = 0, grad = 1)

    color = color.clone

    x = (self.width - size) / 2

    y = (self.height - size) / 2 + oy

    rect = Rect.new(x, y, size, 1)

    count = size / 2

    minus = 128 / count / 2

    count.times do

      clear_rect(rect)

      fill_rect(rect, color)

      color.red   = [color.red   - minus * grad, 0].max

      color.green = [color.green - minus * grad, 0].max

      color.blue  = [color.blue  - minus * grad, 0].max

      rect.y += rect.height

      clear_rect(rect)

      fill_rect(rect, color) 

      color.red   = [color.red   - minus * grad, 0].max

      color.green = [color.green - minus * grad, 0].max

      color.blue  = [color.blue  - minus * grad, 0].max

      rect.x += 1

      rect.y += rect.height

      rect.width -= 2

    end

  end

end

 

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

# ■ [追加]:Sprite_TargetCursor

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

#  対象選択されているバトラーや行動選択中のアクターを示すアローカーソルです。

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

class Sprite_TargetCursor < Sprite

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

  # ● クラス変数

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

  @@cursor_cache = nil

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

  # ● 公開インスタンス変数

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

  attr_accessor :battler     # バトラー

  attr_accessor :blink       # 点滅(対象の選択中)

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

  # ● オブジェクト初期化

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

  def initialize(viewport = nil)

    super(viewport)

    @wait = LNX11::CURSOR_ANI_SPEED

    @speed = [LNX11::CURSOR_SPEED, 1].max

    @battler = nil

    @sub_cursor = []

    @blink = false

    self.bitmap = cursor_bitmap

    partition = self.bitmap.width / self.height

    self.src_rect.set(0, 0, self.width / partition, self.height)

    self.ox = self.width / 2

    self.oy = self.height / 2

    self.x = @rx = @tx = 0

    self.y = @ry = @ty = 0

    self.z = 98

    self.visible = false

  end

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

  # ● 解放

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

  def dispose

    dispose_subcursor

    super

  end

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

  # ● サブカーソル作成

  #  メンバー全体にカーソルを表示するために複数のカーソルを作成します。

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

  def create_subcursor(members)

    return unless @sub_cursor.empty?

    members.each_with_index do |battler, i|

      @sub_cursor[i] = Sprite_TargetCursor.new(self.viewport)

      @sub_cursor[i].set(@rx, @ry)

      @sub_cursor[i].set(battler, true)

    end

  end

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

  # ● サブカーソル解放

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

  def dispose_subcursor

    @sub_cursor.each {|sprite| sprite.dispose }

    @sub_cursor = []

  end

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

  # ● サブカーソル更新

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

  def update_subcursor

    @sub_cursor.each {|sprite| sprite.update }

  end

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

  # ● ビットマップの設定

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

  def cursor_bitmap

    if !LNX11::CURSOR_NAME.empty?

      return Cache.system(LNX11::CURSOR_NAME)

    else

      # カーソルファイル名が指定されていなければRGSS側で生成

      return @@cursor_cache if @@cursor_cache && !@@cursor_cache.disposed?

      @@cursor_cache = Bitmap.new(32, 32)

      color = Color.new(0, 0, 0)

      @@cursor_cache.lnx_cursor_triangle(26, color, 2)

      2.times {@@cursor_cache.blur}

      color.set(255, 255, 255)

      @@cursor_cache.lnx_cursor_triangle(24, color, 1, 0.5)

      tone = LNX11::CURSOR_TONE ? LNX11::CURSOR_TONE : $game_system.window_tone

      r = 118 + tone.red

      g = 118 + tone.green

      b = 118 + tone.blue

      color.set(r, g, b, 232)

      @@cursor_cache.lnx_cursor_triangle(20, color,  0)

      @@cursor_cache.lnx_cursor_triangle(20, color,  1)

      p "LNX11a:カーソルビットマップを作成しました。"

      return @@cursor_cache

    end

  end

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

  # ● カーソルの表示

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

  def show

    self.x = @rx = @tx

    self.y = @ry = @ty

    self.visible = true

  end

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

  # ● カーソルの非表示

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

  def hide

    dispose_subcursor

    @battler = nil

    self.visible = false

  end

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

  # ● 移動平均

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

  def sma(a, b, p)

    # a = 目標位置 b = 現在地

    return a if a == b || (a - b).abs < 0.3 || p == 1

    result = ((a + b * (p.to_f - 1)) / p.to_f)

    return (a - result).abs <= 1.0 ? (b < a ? b + 0.3 : b - 0.3) : result

  end

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

  # ● フレーム更新

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

  def update

    update_subcursor

    self.opacity = @sub_cursor.empty? ? 255 : 0

    return if !visible || !@sub_cursor.empty?

    super

    # 点滅

    if LNX11::CURSOR_BLINK

      self.blend_type = @blink && Graphics.frame_count / 3 % 2 == 0 ? 1 : 0

    end

    # アニメーションを進める

    @wait -= 1

    if @wait <= 0

      @wait += LNX11::CURSOR_ANI_SPEED

      self.src_rect.x += self.width

      self.src_rect.x = 0 if self.src_rect.x >= self.bitmap.width

    end

    # カーソルの座標を更新

    set_xy if @battler && @sub_cursor.empty?

    self.x = @rx = sma(@tx, @rx, @speed)

    self.y = @ry = sma(@ty, @ry, @speed)

  end

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

  # ● カーソル位置の設定

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

  def set(*args)

    if args[0].is_a?(Numeric)

      # 引数一つ目が数値なら、XY指定

      @battler = nil

      set_xy(args[0], args[1])

      @blink = args[2] ? args[2] : false

    else

      # バトラーorシンボル指定

      if @battler != args[0]

        @battler = args[0]

        dispose_subcursor

        case args[0]

        when :party        ; create_subcursor($game_party.members)

        when :troop        ; create_subcursor($game_troop.alive_members)

        when :troop_random ; create_subcursor($game_troop.alive_members)

        else ; args[0] ? set_xy : hide

        end

      end

      @blink = args[1] ? args[1] : false

    end

    # スピードが1かカーソルが非表示なら表示に変える

    show if @sub_cursor.empty? && (@speed == 1 || !visible)

  end

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

  # ● カーソル位置をバトラーの位置に設定

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

  def set_xy(x = nil, y = nil)

    if x 

      # 直接指定

      x += LNX11::CURSOR_OFFSET[:x]

      y += LNX11::CURSOR_OFFSET[:y]

    else

      # バトラーの座標

      x = @battler.screen_x + LNX11::CURSOR_OFFSET[:x]

      y = @battler.screen_y_top + LNX11::CURSOR_OFFSET[:y]

    end

    @tx = x

    minmax = LNX11::CURSOR_MINMAX

    @ty = [[y, minmax[:min] + self.oy].max, minmax[:max]].min

  end

end

 

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

# ■ [追加]:Sprite_OneLine_BattleLog

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

#  バトルログを動的に表示するスプライトです。単体では1行しか表示できませんが、

# 複数同時に扱うことで複数行の表示を実装しています。

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

 

class Sprite_OneLine_BattleLog < Sprite

  @@grad_cache = nil

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

  # ● 公開インスタンス変数

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

  attr_accessor   :position # 表示位置(行)

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

  # ● オブジェクト初期化

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

  def initialize(width, height, max_line_number)

    super(nil)

    @rx = @ry = 0

    @line_height = height

    @max_line_number = max_line_number

    @position = -1

    @visible = true

    self.ox = -LNX11::STORAGE_OFFSET[:x]

    self.oy = -LNX11::STORAGE_OFFSET[:y]

    self.opacity = 0

    self.z = 96

    self.bitmap = Bitmap.new(width * 0.75, height)

  end

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

  # ● 解放

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

  def dispose

    self.bitmap.dispose

    super

  end

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

  # ● スプライトの表示

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

  def show

    @visible = true

  end

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

  # ● スプライトの非表示

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

  def hide

    @visible = false

    @position = -1

  end

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

  # ● 表示しているか?

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

  def visible?

    @visible

  end

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

  # ● フレーム更新

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

  def update

    return if self.opacity == 0

    self.opacity += @visible && @position >= 0 ? 24 : -24

    self.visible = self.opacity > 0

    return unless @visible # 不可視状態なら座標を更新しない

    @ry = (target_y + (@ry * 5)) / 6.0 if target_y < @ry

    @rx += 2 if @rx < 0

    self.x = @rx

    self.y = @ry

  end

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

  # ● テキストの描画

  #  自身が持つ Bitmap で描画するのではなく、Window の contents から

  # コピーします(Sprite からでは Window_Base#draw_text_ex が扱えないため)。

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

  def set_text(window, position)

    self.bitmap.clear

    # 横グラデーション

    if @@grad_cache && !@@grad_cache.disposed?

      self.bitmap.blt(0, 0, @@grad_cache, self.bitmap.rect)

    else

      color = LNX11::STORAGE_GRADIENT_COLOR

      fillrect = self.bitmap.rect

      fillrect.width /= 2

      self.bitmap.gradient_fill_rect(fillrect, color[0], color[1])

      @@grad_cache = self.bitmap.clone

    end

    # contents からコピー

    self.bitmap.blt(4, 0, window.contents, self.bitmap.rect)

    self.opacity = 1

    @rx = -8

    @position = position

    @ry = target_y

  end

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

  # ● 位置の繰り上げ

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

  def up_position

    @position -= 1

  end

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

  # ● メッセージが空か?(表示待ち)

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

  def mes_empty?

    @position < 0

  end

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

  # ● 移動するべき Y 座標

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

  def target_y

    @position * @line_height

  end

end

 

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

# ■ Window_BattleLog

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

#  戦闘の進行を実況表示するウィンドウです。

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

 

class Window_BattleLog < Window_Selectable

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

  # ● [エイリアス]:オブジェクト初期化

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

  alias :lnx11a_initialize :initialize

  def initialize

    lnx11a_initialize

    # バトルログタイプが 1 以上なら非表示にする

    @storage_number = 0

    hide if LNX11::BATTLELOG_TYPE >= 1

    BattleManager.log_window = self

  end

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

  # ● [追加]:文章の配列のクリア

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

  def lines_clear

    @lines.clear if LNX11::BATTLELOG_TYPE == 1

  end

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

  # ● [追加]:指定ウェイト

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

  def abs_wait(wait)

    @method_wait.call(wait) if @method_wait

  end

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

  # ● [再定義]:メッセージ速度の取得

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

  def message_speed

    return 20

  end

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

  # ● [再定義]:エフェクト実行が終わるまでウェイト

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

  def wait_for_effect

    return if LNX11::BATTLELOG_TYPE > 0

    @method_wait_for_effect.call if @method_wait_for_effect

  end

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

  # ● [追加]:アニメーションのウェイト用メソッドの設定

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

  def method_wait_for_animation=(method)

    @method_wait_for_animation = method

  end

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

  # ● [追加]:アニメーション再生が終わるまでウェイト

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

  def wait_for_animation

    @method_wait_for_animation.call if @method_wait_for_animation

  end

  

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

  # ● [エイリアス]:ウィンドウ高さの取得

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

  alias :lnx11a_window_height :window_height

  def window_height

    LNX11::BATTLELOG_TYPE == 1 ? fitting_height(1) : lnx11a_window_height

  end

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

  # ● [エイリアス]:最大行数の取得

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

  alias :lnx11a_max_line_number :max_line_number

  def max_line_number

    num = LNX11::STORAGE_LINE_NUMBER

    LNX11::BATTLELOG_TYPE == 1 ? num : lnx11a_max_line_number

  end

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

  # ● [オーバーライド]:行の高さを取得

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

  def line_height

    LNX11::BATTLELOG_TYPE == 1 ? LNX11::STORAGE_LINE_HEIGHT : super

  end

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

  # ● [オーバーライド]:フォント設定のリセット

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

  def reset_font_settings

    super

    return unless LNX11::BATTLELOG_TYPE == 1

    contents.font.size = LNX11::STORAGE_FONT[:size]

    contents.font.out_color.set(LNX11::STORAGE_FONT[:out_color])

  end

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

  # ● [エイリアス]:データ行数の取得

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

  alias :lnx11a_line_number :line_number

  def line_number

    return 0 if LNX11::BATTLELOG_TYPE == 2

    LNX11::BATTLELOG_TYPE == 1 ? @storage_number : lnx11a_line_number

  end

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

  # ● [再定義]:背景スプライトの作成

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

  alias :lnx11a_create_back_sprite :create_back_sprite 

  def create_back_sprite

    if LNX11::BATTLELOG_TYPE == 1

      # 蓄積型

      create_message_sprite

    else

      # 背景

      lnx11a_create_back_sprite

    end

  end

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

  # ● [再定義]:背景スプライトの解放

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

  alias :lnx11a_dispose_back_sprite :dispose_back_sprite

  def dispose_back_sprite

    if LNX11::BATTLELOG_TYPE == 1

      # 蓄積型

      dispose_message_sprite

    else

      # 背景

      lnx11a_dispose_back_sprite

    end

  end

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

  # ● [追加]:メッセージスプライトの作成

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

  def create_message_sprite

    # メッセージスプライト 行数分だけ作成する

    @mes_position = 0 # 次にメッセージを表示させる位置

    @mesup_count = LNX11::STORAGE_UP_MESSAGE_TIME # ログが進行するまでの時間

    @mes_sprites = Array.new(max_line_number + 1) {

    Sprite_OneLine_BattleLog.new(self.width, line_height, max_line_number)}

  end

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

  # ● [追加]:メッセージスプライトの解放

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

  def dispose_message_sprite

    @mes_sprites.each {|sprite| sprite.dispose }

  end

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

  # ● [追加]:メッセージスプライトを表示

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

  def show_message_sprite

    @mes_sprites.each {|sprite| sprite.show }

  end

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

  # ● [追加]:メッセージスプライトを非表示

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

  def hide_message_sprite

    @mes_sprites.each {|sprite| sprite.hide }

    @mes_position = 0

  end

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

  # ● [追加]:メッセージスプライトを一つ進める

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

  def up_message_sprite

    @mes_sprites.each {|sprite| sprite.up_position }

  end

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

  # ● [追加]:空のメッセージスプライトを返す

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

  def empty_message_sprite

    @mes_sprites.each {|sprite| return sprite if sprite.mes_empty? }

    @mes_sprites[0]

  end

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

  # ● [追加]:メッセージスプライトの更新

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

  def update_message_sprite

    # バトルログ消去フラグが有効

    if $game_temp.battlelog_clear

      $game_temp.battlelog_clear = false

      # スプライトが表示されていれば非表示にする

      if @mes_sprites[0].visible?

        hide_message_sprite

        lines_clear

      end

    end

    # ログの自動進行

    @mesup_count -= 1

    if @mesup_count <= 0 && @mes_position > 0

      up_message_sprite

      @mes_position -= 1

      @mesup_count = LNX11::STORAGE_UP_MESSAGE_TIME

    end

    @mes_sprites.each {|sprite| sprite.update }

  end

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

  # ● [追加]:メッセージスプライトのリフレッシュ

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

  def refresh_message_sprite

    # 文章が無ければ何もしない

    return if @lines.empty? 

    # スプライトを表示する

    show_message_sprite unless @mes_sprites[0].visible? 

    # 文章の描画

    contents.clear

    @lines[0] = last_text

    return if @lines[0].empty? 

    draw_line(0)

    @storage_number += 1

    # ウィンドウの内容をスプライトにコピー

    empty_message_sprite.set_text(self, @mes_position)

    # スプライト位置の変動    

    if @mes_position < max_line_number

      @mes_position += 1

    elsif @mesup_count > 0

      up_message_sprite

    end

    @mesup_count = (LNX11::STORAGE_UP_MESSAGE_TIME * 1.5).truncate

  end  

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

  # ● [オーバーライド]:フレーム更新

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

  def update

    super

    update_message_sprite if LNX11::BATTLELOG_TYPE == 1

  end

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

  # ● [エイリアス]:リフレッシュ

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

  alias :lnx11a_refresh :refresh

  def refresh

    return if LNX11::BATTLELOG_TYPE == 2

    LNX11::BATTLELOG_TYPE == 1 ? refresh_message_sprite : lnx11a_refresh

  end

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

  # ● [エイリアス]:クリア

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

  alias :lnx11a_clear :clear

  def clear

    return if LNX11::BATTLELOG_TYPE == 2

    LNX11::BATTLELOG_TYPE == 1 ? @storage_number = 0 : lnx11a_clear

  end

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

  # ● [エイリアス]:一行戻る

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

  alias :lnx11a_back_one :back_one

  def back_one

    if LNX11::BATTLELOG_TYPE == 1

      # 蓄積型

      @storage_number = [@storage_number - 1, 0].max

    else

      # 通常

      lnx11a_back_one

    end

  end

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

  # ● [エイリアス]:指定した行に戻る

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

  alias :lnx11a_back_to :back_to

  def back_to(line_number)

    if LNX11::BATTLELOG_TYPE == 1

      # 蓄積型

      @storage_number -= 1 while @storage_number > line_number

    else

      # 通常

      lnx11a_back_to(line_number)

    end

  end

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

  # ● [エイリアス]:ウェイト

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

  alias :lnx11a_wait :wait

  def wait

    return if LNX11::BATTLELOG_TYPE == 2

    # 元のメソッドを呼ぶ

    lnx11a_wait

  end

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

  # ● [エイリアス]:スキル/アイテム使用の表示

  #  使用時アニメーションの処理を追加します。

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

  alias :lnx11a_display_use_item :display_use_item

  def display_use_item(subject, item)

    if item.use_animation > 0

      # 使用時アニメーションが設定されていれば再生

      subject.animation_id = item.use_animation

      subject.animation_mirror = false

    end

    # 元のメソッドを呼ぶ

    lnx11a_display_use_item(subject, item)

    # アニメーションのウェイト

    wait_for_animation if item.use_animation > 0

  end

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

  # ● [追加]:ポップアップデータの取得

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

  def popup_data

    $game_temp.popup_data

  end

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

  # ● [エイリアス]:反撃の表示

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

  alias :lnx11a_display_counter :display_counter

  def display_counter(target, item)

    # ポップアップ

    popup_data.popup_text(target, :counter)

    # 元のメソッドを呼ぶ

    lnx11a_display_counter(target, item)

    # ポップアップウェイト

    popup_data.add_wait

  end

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

  # ● [エイリアス]:反射の表示

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

  alias :lnx11a_display_reflection :display_reflection

  def display_reflection(target, item)

    # ポップアップ

    popup_data.popup_text(target, :reflection)

    # 元のメソッドを呼ぶ

    lnx11a_display_reflection(target, item)

    # ポップアップウェイト

    popup_data.add_wait

  end

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

  # ● [エイリアス]:身代わりの表示

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

  alias :lnx11a_display_substitute :display_substitute

  def display_substitute(substitute, target)

    # ポップアップ

    popup_data.popup_text(substitute, :substitute)

    # 元のメソッドを呼ぶ

    lnx11a_display_substitute(substitute, target)

    # ポップアップウェイト

    popup_data.add_wait

  end

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

  # ● [エイリアス]:失敗の表示

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

  alias :lnx11a_display_failure :display_failure

  def display_failure(target, item)

    if target.result.hit? && !target.result.success

      # ポップアップ (ミスと同じ扱いにする)

      popup_data.popup_miss(target, item)

    end

    # 元のメソッドを呼ぶ

    lnx11a_display_failure(target, item)

    # ポップアップウェイト

    popup_data.add_wait

  end

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

  # ● [エイリアス]:ミスの表示

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

  alias :lnx11a_display_miss :display_miss

  def display_miss(target, item)

    # ポップアップ

    popup_data.popup_miss(target, item)

    # 元のメソッドを呼ぶ    

    lnx11a_display_miss(target, item)

    # ポップアップウェイト

    popup_data.add_wait

  end

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

  # ● [エイリアス]:回避の表示

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

  alias :lnx11a_display_evasion :display_evasion

  def display_evasion(target, item)

    # ポップアップ (ミスと同じ扱いにする)

    popup_data.popup_miss(target, item)

    # 元のメソッドを呼ぶ    

    lnx11a_display_evasion(target, item)

    # ポップアップウェイト

    popup_data.add_wait

  end

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

  # ● [エイリアス]:HP ダメージ表示

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

  alias :lnx11a_display_hp_damage :display_hp_damage

  def display_hp_damage(target, item)

    # ポップアップ

    popup_data.popup_hp_damage(target, item)

    # 元のメソッドを呼ぶ

    lnx11a_display_hp_damage(target, item)

    # ポップアップウェイト

    popup_data.add_wait

  end

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

  # ● [エイリアス]:MP ダメージ表示

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

  alias :lnx11a_display_mp_damage :display_mp_damage

  def display_mp_damage(target, item)

    # ポップアップ

    popup_data.popup_mp_damage(target, item)

    # 元のメソッドを呼ぶ

    lnx11a_display_mp_damage(target, item)

    # ポップアップウェイト

    popup_data.add_wait

  end

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

  # ● [エイリアス]:TP ダメージ表示

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

  alias :lnx11a_display_tp_damage :display_tp_damage

  def display_tp_damage(target, item)

    # ポップアップ

    popup_data.popup_tp_damage(target, item)

    # 元のメソッドを呼ぶ

    lnx11a_display_tp_damage(target, item)

    # ポップアップウェイト

    popup_data.add_wait

  end

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

  # ● [エイリアス]:ステート付加の表示

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

  alias :lnx11a_display_added_states :display_added_states

  def display_added_states(target)

    # ポップアップ

    popup_data.popup_added_states(target)

    # 元のメソッドを呼ぶ

    lnx11a_display_added_states(target)

  end

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

  # ● [エイリアス]:ステート解除の表示

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

  alias :lnx11a_display_removed_states :display_removed_states

  def display_removed_states(target)

    # ポップアップ

    popup_data.popup_removed_states(target)

    # 元のメソッドを呼ぶ

    lnx11a_display_removed_states(target)

  end

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

  # ● [エイリアス]:能力強化/弱体の表示(個別)

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

  alias :lnx11a_display_buffs :display_buffs

  def display_buffs(target, buffs, fmt)

    # ポップアップ

    popup_data.popup_buffs(target, buffs, fmt)

    # 元のメソッドを呼ぶ

    lnx11a_display_buffs(target, buffs, fmt)

  end

end

 

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

# ■ RPG::BaseItem

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

#  アクター、職業、スキル、アイテム、武器、防具、敵キャラ、およびステートの

# スーパークラス。

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

 

class RPG::BaseItem  

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

  # ● [追加]:バトラーグラフィックファイル名を取得

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

  def default_battler_graphic

    # キャッシュがある場合、それを返す

    return @default_battler_graphic if @default_battler_graphic

    # メモ取得

    re = LNX11::RE_BATTLER =~ note

    @default_battler_graphic = re ? $1 : ""

  end

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

  # ● [追加]:敵キャラの通常攻撃アニメの取得

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

  def atk_animation

    # キャッシュがある場合、それを返す

    return @atk_animation if @atk_animation

    # メモ取得

    re = LNX11::RE_ATK_ANIMATION =~ note

    @atk_animation = re ? $1.to_i : 1

  end

end

 

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

# ■ RPG::UsableItem

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

#  スキルとアイテムのスーパークラス。

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

class RPG::UsableItem < RPG::BaseItem

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

  # ● [エイリアス]:対象の選択操作が必要か否かを取得

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

  alias :lnx11a_need_selection? :need_selection?

  def need_selection?

    LNX11::FIX_TARGET_CHECKE && scope > 0 ? true : lnx11a_need_selection?

  end

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

  # ● [追加]:使用時アニメの取得

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

  def use_animation

    # キャッシュがある場合、それを返す

    return @use_animation if @use_animation

    # メモ取得

    re = LNX11::RE_USE_ANIMATION =~ note

    @use_animation = re ? $1.to_i : 0

  end

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

  # ● [追加]:簡易ヘルプ非表示の取得

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

  def no_display

    # キャッシュがある場合、それを返す

    return @no_display if @no_display

    # メモ取得

    re = LNX11::RE_USABLEITEM_NO_DISPLAY =~ note

    @no_display = re ? true : false

  end

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

  # ● [追加]:使用時追加ウェイトの取得

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

  def display_wait

    # キャッシュがある場合、それを返す

    return @display_wait if @display_wait

    # メモ取得

    re = LNX11::RE_DISPLAY_WAIT =~ note

    @display_wait = re ? $1.to_i : LNX11::HELPDISPLAT_WAIT

  end

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

  # ● [追加]:終了時追加ウェイトの取得

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

  def end_wait

    # キャッシュがある場合、それを返す

    return @end_wait if @end_wait

    # メモ取得

    re = LNX11::RE_END_WAIT =~ note

    @end_wait = re ? $1.to_i : LNX11::HELPDISPLAT_END_WAIT

  end

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

  # ● [追加]:簡易ヘルプ説明を取得

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

  def short_description

    # キャッシュがある場合、それを返す

    return @short_description if @short_description

    # メモ取得

    re = LNX11::RE_SHORT_DESCRIPTION =~ note

    @short_description = re ? $1 : ""

  end

end

 

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

# ■ RPG::State

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

#  ステートのデータクラス。

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

 

class RPG::State < RPG::BaseItem

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

  # ● [追加]:ステートアニメの取得

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

  def state_animation

    # キャッシュがある場合、それを返す

    return @state_animation if @state_animation

    # メモ取得

    re = LNX11::RE_STATE_ANIMATION =~ note

    @state_animation = re ? $1.to_i : 0

  end

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

  # ● [追加]:ポップアップ表示名の取得

  # <<ver1.10>>

  #  このメソッドは付加/解除ポップアップ表示名が設定されていない場合のみ

  # 呼び出されるようになりました。

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

  def display_name

    # キャッシュがある場合、それを返す

    return @display_name if @display_name

    # メモ取得

    re = LNX11::RE_STATE_DISPLAY =~ note

    @display_name = re ? $1 : name

  end

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

  # ● [追加]:付加ポップアップ表示名の取得 <<ver1.10>>

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

  def add_display_name

    # キャッシュがある場合、それを返す

    return @add_display_name if @add_display_name

    # メモ取得

    re = LNX11::RE_STATE_ADD_DISPLAY =~ note

    @add_display_name = re ? $1 : display_name

  end

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

  # ● [追加]:解除ポップアップ表示名の取得 <<ver1.10>>

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

  def remove_display_name

    # キャッシュがある場合、それを返す

    return @remove_display_name if @remove_display_name

    # メモ取得

    re = LNX11::RE_STATE_REM_DISPLAY =~ note

    @remove_display_name = re ? $1 : display_name

  end

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

  # ● [追加]:ポップアップ非表示の取得

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

  def no_display?

    # キャッシュがある場合、それを返す

    return @no_display if @no_display

    # 付加/解除のどちらかで設定されていれば無視する

    if LNX11::RE_STATE_ADD_NO_DISPLAY =~ note ||

       LNX11::RE_STATE_REM_NO_DISPLAY =~ note

      return @no_display = false

    end

    # メモ取得

    re = LNX11::RE_STATE_NO_DISPLAY =~ note

    @no_display = re ? true : false

  end

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

  # ● [追加]:付加ポップアップ非表示の取得

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

  def add_no_display?

    return true if no_display?

    # キャッシュがある場合、それを返す

    return @add_no_display if @add_no_display

    # メモ取得

    re = LNX11::RE_STATE_ADD_NO_DISPLAY =~ note

    @add_no_display = re ? true : false

  end

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

  # ● [追加]:解除ポップアップ非表示の取得

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

  def remove_no_display?

    return true if no_display?

    # キャッシュがある場合、それを返す

    return @remove_no_display if @remove_no_display

    # メモ取得

    re = LNX11::RE_STATE_REM_NO_DISPLAY =~ note

    @remove_no_display = re ? true : false

  end

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

  # ● [追加]:有利なステートの取得

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

  def advantage?

    # キャッシュがある場合、それを返す

    return @advantage if @advantage

    # メモ取得

    re = LNX11::RE_STATE_ADVANTAGE =~ note

    @advantage = re ? true : false

  end

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

  # ● [追加]:ポップアップタイプの取得

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

  def popup_type

    # キャッシュがある場合、それを返す

    return @popup_type if @popup_type != nil

    # 付加/解除のどちらかで設定されていれば無視する

    if LNX11::RE_STATE_ADD_TYPE =~ note ||

       LNX11::RE_STATE_REM_TYPE =~ note

      return @popup_type = false

    end

    # メモ取得

    re = LNX11::RE_STATE_TYPE =~ note

    @popup_type = re ? $1.to_i : false

  end

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

  # ● [追加]:付加ポップアップタイプの取得

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

  def add_popup_type

    return popup_type if popup_type

    # キャッシュがある場合、それを返す

    return @add_popup_type if @add_popup_type != nil

    # メモ取得

    re = LNX11::RE_STATE_ADD_TYPE =~ note

    @add_popup_type = re ? $1.to_i : false

  end

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

  # ● [追加]:解除ポップアップタイプの取得

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

  def remove_popup_type

    return popup_type if popup_type

    # キャッシュがある場合、それを返す

    return @remove_popup_type if @remove_popup_type != nil

    # メモ取得

    re = LNX11::RE_STATE_REM_TYPE =~ note

    @remove_popup_type = re ? $1.to_i : false

  end

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

  # ● [追加]:修飾文字非表示の取得

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

  def no_decoration?

    # キャッシュがある場合、それを返す

    return @no_decoration if @no_decoration

    # 付加/解除のどちらかで設定されていれば無視する

    if LNX11::RE_STATE_ADD_NO_DECORATION =~ note ||

       LNX11::RE_STATE_REM_NO_DECORATION =~ note

      return @no_decoration = false

    end

    # メモ取得

    re = LNX11::RE_STATE_NO_DECORATION =~ note

    @no_decoration = re ? true : false

  end

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

  # ● [追加]:付加修飾文字非表示の取得

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

  def add_no_decoration?

    return true if no_decoration?

    # キャッシュがある場合、それを返す

    return @add_no_decoration if @add_no_decoration

    # メモ取得

    re = LNX11::RE_STATE_ADD_NO_DECORATION =~ note

    @add_no_decoration = re ? true : false

  end

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

  # ● [追加]:解除修飾文字非表示の取得

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

  def remove_no_decoration?

    return true if no_decoration?

    # キャッシュがある場合、それを返す

    return @remove_no_decoration if @remove_no_decoration

    # メモ取得

    re = LNX11::RE_STATE_REM_NO_DECORATION =~ note

    @remove_no_decoration = re ? true : false

  end

end

 

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

# ■ BattleManager

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

#  戦闘の進行を管理するモジュールです。

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

 

class << BattleManager

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

  # ● [追加]:公開インスタンス変数

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

  attr_reader   :preemptive             # 先制攻撃フラグ

  attr_reader   :surprise               # 不意打ちフラグ

  attr_accessor :log_window             # バトルログウィンドウ

  attr_accessor :update_for_wait_method # ウェイト中のフレーム更新

  attr_accessor :helpdisplay_set_method        # 簡易ヘルプ表示

  attr_accessor :helpdisplay_clear_method      # 簡易ヘルプ消去

  attr_accessor :helpdisplay_wait_short_method # 簡易ヘルプ・短時間ウェイト

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

  # ● [追加]:簡易ヘルプ表示

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

  def helpdisplay_set(*args)

    @helpdisplay_set_method.call(*args) if @helpdisplay_set_method

  end

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

  # ● [追加]:簡易ヘルプ消去

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

  def helpdisplay_clear(*args)

    @helpdisplay_clear_method.call(*args) if @helpdisplay_clear_method

  end

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

  # ● [追加]:簡易ヘルプ・短時間ウェイト

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

  def helpdisplay_wait_short

    @helpdisplay_wait_short_method.call if @helpdisplay_wait_short_method

  end 

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

  # ● [追加]:キー入力待ち

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

  def helpdisplay_wait_input

    return if $game_message.helpdisplay_texts.empty?

    return if LNX11::MESSAGE_TYPE == 0

    return if !@helpdisplay_wait_input || !@update_for_wait_method

    update_for_wait_method.call while !Input.press?(:B) && !Input.press?(:C)

  end

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

  # ● [追加]:メッセージ進行の SE 再生

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

  def messagedisplay_se_play

    return if !@helpdisplay_se

    @helpdisplay_se.play  

    @helpdisplay_se = nil if @helpdisplay_se == LNX11::LEVELUP_SE

  end

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

  # ● [追加]:メッセージ進行

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

  def process_messagedisplay(wait)

    return if $game_message.helpdisplay_texts.empty?

    return if LNX11::MESSAGE_TYPE == 0

    $game_temp.battlelog_clear = true

    BattleManager.log_window.update

    if LNX11::BATTLELOG_TYPE == 2 || LNX11::MESSAGE_TYPE == 2

      # 簡易ヘルプ

      $game_message.helpdisplay_texts.each do |text|

        helpdisplay_wait_short

        messagedisplay_se_play

        helpdisplay_set(text, wait)

        helpdisplay_wait_input

      end

      helpdisplay_clear

    elsif LNX11::BATTLELOG_TYPE == 0

      # VXAceデフォルト

      BattleManager.log_window.clear

      $game_message.helpdisplay_texts.each do |text|

        messagedisplay_se_play

        BattleManager.log_window.add_text(text)

        BattleManager.log_window.abs_wait(wait)

        helpdisplay_wait_input

        max = BattleManager.log_window.max_line_number

        # 表示がいっぱいになったら消去

        if BattleManager.log_window.line_number >= max

          BattleManager.log_window.clear

        end

      end

      BattleManager.log_window.clear

    elsif LNX11::BATTLELOG_TYPE == 1

      # 蓄積型

      $game_message.helpdisplay_texts.each do |text|

        messagedisplay_se_play

        BattleManager.log_window.add_text(text)

        BattleManager.log_window.abs_wait(wait)

        helpdisplay_wait_input

      end

      $game_temp.battlelog_clear = true

      BattleManager.log_window.update

    end

    $game_message.helpdisplay_texts.clear

  end

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

  # ● [エイリアス]:メッセージ表示が終わるまでウェイト

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

  alias :lnx11a_wait_for_message :wait_for_message

  def wait_for_message

    # 簡易ヘルプ表示

    process_messagedisplay(@helpdisplay_wait ? @helpdisplay_wait : 60)

    return if $game_message.texts.empty?

    # 元のメソッドを呼ぶ

    lnx11a_wait_for_message

  end  

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

  # ● [エイリアス]:戦闘開始

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

  alias :lnx11a_battle_start :battle_start

  def battle_start    

    @helpdisplay_wait = LNX11::MESSAGE_WAIT[:battle_start][0]

    @helpdisplay_wait_input = LNX11::MESSAGE_WAIT[:battle_start][1]

    # メッセージウィンドウへのテキスト追加を禁止する

    $game_message.add_disabled

    # 元のメソッドを呼ぶ

    lnx11a_battle_start

    # メッセージウィンドウへのテキスト追加を許可する

    $game_message.add_enabled

    @helpdisplay_wait = nil

    @helpdisplay_wait_input = nil

  end

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

  # ● [エイリアス]:勝利の処理

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

  alias :lnx11a_process_victory :process_victory

  def process_victory

    @helpdisplay_wait = LNX11::MESSAGE_WAIT[:victory][0]

    @helpdisplay_wait_input = LNX11::MESSAGE_WAIT[:victory][1]

    # メッセージウィンドウへのテキスト追加を禁止する

    $game_message.add_disabled

    # 元のメソッドを呼ぶ

    success = lnx11a_process_victory

    # メッセージウィンドウへのテキスト追加を許可する

    $game_message.add_enabled

    @helpdisplay_wait = nil

    @helpdisplay_wait_input = nil

    return success

  end

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

  # ● [エイリアス]:逃走の処理

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

  alias :lnx11a_process_escape :process_escape

  def process_escape

    @helpdisplay_wait = LNX11::MESSAGE_WAIT[:escape][0]

    @helpdisplay_wait_input = LNX11::MESSAGE_WAIT[:escape][1]

    # メッセージウィンドウへのテキスト追加を禁止する

    $game_message.add_disabled

    # 元のメソッドを呼ぶ

    success = lnx11a_process_escape

    # メッセージウィンドウへのテキスト追加を許可する

    $game_message.add_enabled

    @helpdisplay_wait = nil

    @helpdisplay_wait_input = nil

    return success

  end

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

  # ● [エイリアス]:敗北の処理

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

  alias :lnx11a_process_defeat :process_defeat

  def process_defeat

    @helpdisplay_wait = LNX11::MESSAGE_WAIT[:defeat][0]

    @helpdisplay_wait_input = LNX11::MESSAGE_WAIT[:defeat][1]

    # メッセージウィンドウへのテキスト追加を禁止する

    $game_message.add_disabled

    # 元のメソッドを呼ぶ

    success = lnx11a_process_defeat

    # メッセージウィンドウへのテキスト追加を許可する

    $game_message.add_enabled

    @helpdisplay_wait = nil

    @helpdisplay_wait_input = nil

    return success

  end

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

  # ● [エイリアス]:ドロップアイテムの獲得と表示

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

  alias :lnx11a_gain_drop_items :gain_drop_items

  def gain_drop_items

    helpdisplay_clear

    @helpdisplay_wait = LNX11::MESSAGE_WAIT[:drop_item][0]

    @helpdisplay_wait_input = LNX11::MESSAGE_WAIT[:drop_item][1]

    @helpdisplay_se = LNX11::DROPITEM_SE

    # 元のメソッドを呼ぶ

    lnx11a_gain_drop_items

    @helpdisplay_wait = nil

    @helpdisplay_wait_input = nil

    @helpdisplay_se = nil

  end

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

  # ● [再定義]:経験値の獲得とレベルアップの表示

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

  def gain_exp

    @helpdisplay_wait = LNX11::MESSAGE_WAIT[:levelup][0]

    @helpdisplay_wait_input = LNX11::MESSAGE_WAIT[:levelup][1]

    $game_party.all_members.each do |actor|

      @helpdisplay_se = LNX11::LEVELUP_SE

      actor.gain_exp($game_troop.exp_total)

      # レベルアップ毎にメッセージ表示ウェイト

      wait_for_message

    end

    @helpdisplay_wait = nil

    @helpdisplay_wait_input = nil

    @helpdisplay_se = nil

  end

end

 

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

# ■ Game_Temp

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

#  セーブデータに含まれない、一時的なデータを扱うクラスです。このクラスのイン

# スタンスは $game_temp で参照されます。

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

 

class Game_Temp

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

  # ● [追加]:公開インスタンス変数

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

  attr_accessor :popup_data            # ポップアップスプライト

  attr_accessor :actor_battler_graphic # アクターのバトラーグラフィック

  attr_accessor :battlelog_clear       # バトルログ消去フラグ

  attr_accessor :target_cursor_sprite  # ターゲットカーソルスプライト

  attr_accessor :last_target_cursor    # 対象選択のカーソル記憶

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

  # ● [エイリアス]:オブジェクト初期化

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

  alias :lnx11a_initialize :initialize

  def initialize

    # 元のメソッドを呼ぶ

    lnx11a_initialize

    # 追加

    @popup_data = nil

    @actor_battler_graphic = []

    @battlelog_clear = false

    @battle_status_refresh = nil

    @target_cursor_sprite = nil

    clear_last_target_cursor

  end

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

  # ● [追加]:バトルステータス更新メソッドの設定

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

  def method_battle_status_refresh=(method)

    @battle_status_refresh = method

  end

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

  # ● [追加]:バトルステータス更新

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

  def battle_status_refresh

    return unless $game_party.in_battle

    @battle_status_refresh.call if @battle_status_refresh

  end

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

  # ● [追加]:対象選択のカーソル記憶をクリア

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

  def clear_last_target_cursor

    @last_target_cursor = {:actor => nil, :enemy => nil}

  end

end

 

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

# ■ Game_Action

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

#  戦闘行動を扱うクラスです。

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

 

class Game_Action

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

  # ● [エイリアス]:ターゲットの配列作成

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

  alias :lnx11a_make_targets :make_targets

  def make_targets    

    if LNX11::TROOP_X_SORT

      # 元のメソッドを呼んでソート

      return lnx11a_make_targets.sort {|a,b| a.screen_x <=> b.screen_x}

    else

      return lnx11a_make_targets

    end

  end

end

 

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

# ■ Game_ActionResult

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

#  戦闘行動の結果を扱うクラスです。属性に関する結果を追加します。

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

 

class Game_ActionResult

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

  # ● 公開インスタンス変数

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

  attr_accessor :element_rate               # 属性修正値

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

  # ● ダメージ値のクリア

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

  alias :lnx11a_clear_damage_values :clear_damage_values

  def clear_damage_values

    # 元のメソッドを呼ぶ

    lnx11a_clear_damage_values

    # 属性修正値をクリア

    @element_rate = 1.0

  end

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

  # ● [追加]:属性修正値の取得

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

  def element_rate

    return @element_rate if @element_rate

    @element_rate = 1.0

  end

end

 

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

# ■ Game_BattlerBase

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

#  バトラーを扱う基本のクラスです。

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

 

class Game_BattlerBase

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

  # ● [追加]:ポップアップデータの取得

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

  def popup_data

    $game_temp.popup_data

  end

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

  # ● [エイリアス]:スキル使用コストの支払い

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

  alias :lnx11a_pay_skill_cost :pay_skill_cost

  def pay_skill_cost(skill)

    rmp = self.mp

    rtp = self.tp

    # 元のメソッドを呼ぶ    

    lnx11a_pay_skill_cost(skill)

    return unless $game_party.in_battle

    # ポップアップ

    popup_data.popup_regenerate_mp(self, (rmp - self.mp).truncate, true)

    popup_data.popup_regenerate_tp(self, (rtp - self.tp).truncate, true)

  end

end

 

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

# ■ Game_Battler

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

#  スプライトに関するメソッドを追加したバトラーのクラスです。

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

 

class Game_Battler < Game_BattlerBase

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

  # ● 公開インスタンス変数

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

  attr_accessor :loop_animation_id     # ループアニメーション ID

  attr_accessor :loop_animation_mirror # ループアニメーション 左右反転フラグ

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

  # ● [エイリアス]:スプライトのエフェクトをクリア

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

  alias :lnx11a_clear_sprite_effects :clear_sprite_effects

  def clear_sprite_effects

    # 元のメソッドを呼ぶ

    lnx11a_clear_sprite_effects

    @loop_animation_id = 0

    @loop_animation_mirror = false

  end

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

  # ● [再定義]:アニメーション ID の設定

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

  def animation_id=(id)

    return unless battle_member?

    @animation_id = id

  end

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

  # ● [追加]:ステートのループアニメーションの設定

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

  def set_state_animation

    # 表示優先度が高いステートを優先

    sort_states

    anime = @states.collect {|id| $data_states[id].state_animation }

    anime.delete(0)

    @loop_animation_id = anime[0] ? anime[0] : 0

  end

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

  # ● [エイリアス]:ステート情報をクリア

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

  alias :lnx11a_clear_states :clear_states

  def clear_states

    # 元のメソッドを呼ぶ

    lnx11a_clear_states

    # ステートアニメ設定

    set_state_animation

  end

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

  # ● [エイリアス]:ステートの付加

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

  alias :lnx11a_add_state :add_state

  def add_state(state_id)

    # 元のメソッドを呼ぶ

    lnx11a_add_state(state_id)

    # ステートアニメ設定

    set_state_animation

  end

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

  # ● [エイリアス]:ステートの解除

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

  alias :lnx11a_remove_state :remove_state

  def remove_state(state_id)

    # 元のメソッドを呼ぶ

    lnx11a_remove_state(state_id)

    # ステートアニメ設定

    set_state_animation

  end

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

  # ● [追加]:ポップアップディレイの取得

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

  def popup_delay

    return @popup_delay if @popup_delay

    popup_delay_clear

  end

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

  # ● [追加]:ポップアップディレイの設定

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

  def popup_delay=(delay)

    @popup_delay = delay

  end

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

  # ● [追加]:ポップアップディレイの設定

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

  def popup_delay_clear

    @popup_delay = Array.new(16) { 0 }

  end

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

  # ● [エイリアス]:スキル/アイテムの属性修正値を取得

  #  弱点/耐性の判定を追加します。

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

  alias :lnx11a_item_element_rate :item_element_rate

  def item_element_rate(user, item)

    # 元のメソッドを呼ぶ

    rate = lnx11a_item_element_rate(user, item)

    return rate unless $game_party.in_battle

    # レートを結果に保存する

    @result.element_rate = rate

    rate

  end

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

  # ● [エイリアス]:ダメージの処理

  #  吸収による回復のポップアップを生成します。

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

  alias :lnx11a_execute_damage :execute_damage

  def execute_damage(user)

    # 元のメソッドを呼ぶ

    lnx11a_execute_damage(user)

    return unless $game_party.in_battle

    # ポップアップ

    popup_data.popup_hp_drain(user, @result.hp_drain)

    popup_data.popup_mp_drain(user, @result.mp_drain)

  end

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

  # ● [エイリアス]:HP の再生

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

  alias :lnx11a_regenerate_hp :regenerate_hp

  def regenerate_hp

    # 元のメソッドを呼ぶ

    lnx11a_regenerate_hp

    return unless $game_party.in_battle

    # ポップアップ

    popup_data.popup_regenerate_hp(self, @result.hp_damage)

  end

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

  # ● [エイリアス]:MP の再生

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

  alias :lnx11a_regenerate_mp :regenerate_mp

  def regenerate_mp

    # 元のメソッドを呼ぶ

    lnx11a_regenerate_mp

    return unless $game_party.in_battle

    # ポップアップ

    popup_data.popup_regenerate_mp(self, @result.mp_damage)

  end

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

  # ● [エイリアス]:TP の再生

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

  alias :lnx11a_regenerate_tp :regenerate_tp

  def regenerate_tp

    rtp = self.tp.to_i

    # 元のメソッドを呼ぶ

    lnx11a_regenerate_tp

    return unless $game_party.in_battle

    # ポップアップ

    popup_data.popup_regenerate_tp(self, rtp - self.tp.to_i)

  end

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

  # ● 被ダメージによる TP チャージ

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

  alias :lnx11a_charge_tp_by_damage :charge_tp_by_damage

  def charge_tp_by_damage(damage_rate)

    rtp = self.tp.to_i

    # 元のメソッドを呼ぶ

    lnx11a_charge_tp_by_damage(damage_rate)

    return unless $game_party.in_battle

    # ポップアップ

    popup_data.popup_tp_charge(self, rtp - self.tp.to_i)

  end

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

  # ● [エイリアス]:スキル/アイテムの使用者側への効果(TP 得)

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

  alias :lnx11a_item_user_effect :item_user_effect

  def item_user_effect(user, item)

    rtp = user.tp.to_i

    # 元のメソッドを呼ぶ

    lnx11a_item_user_effect(user, item)

    return unless $game_party.in_battle

    # ポップアップ

    popup_data.popup_tp_gain(user, rtp - user.tp.to_i)

  end

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

  # ● [追加]:高さの取得

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

  def bitmap_height

    return @bitmap_height if @bitmap_height

    @bitmap_height = 0

  end 

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

  # ● [追加]:高さの設定

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

  def bitmap_height=(y)

    @bitmap_height = y

  end

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

  # ● [追加]:バトル画面 Y 座標(頭上)の取得

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

  def screen_y_top

    screen_y - @bitmap_height

  end

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

  # ● [追加]:バトル画面 Y 座標(中心)の取得

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

  def screen_y_center

    screen_y - @bitmap_height / 2

  end

end

 

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

# ■ Game_Actor

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

#  アクターを扱うクラスです。このクラスは Game_Actors クラス($game_actors)

# の内部で使用され、Game_Party クラス($game_party)からも参照されます。

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

 

class Game_Actor < Game_Battler

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

  # ● [追加]:公開インスタンス変数

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

  attr_accessor :battler_graphic_name    # 後指定のバトラーグラフィック

  attr_accessor :refresh_battler_graphic # バトラーグラフィックの更新フラグ

  attr_accessor :screen_x                # バトル画面 X 座標

  attr_accessor :screen_y                # バトル画面 Y 座標

  attr_accessor :last_actor_command      # 最後に選択したコマンド

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

  # ● [再定義]:スプライトを使うか?

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

  def use_sprite?

    return true # 使う

  end

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

  # ● [追加]:バトル画面 Z 座標の取得

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

  def screen_z

    return $game_party.members_screen_z[0] if index == nil

    return $game_party.members_screen_z[index] # Game_EnemyのZ座標は100

  end

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

  # ● [エイリアス]:ダメージ効果の実行

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

  alias :lnx11a_perform_damage_effect :perform_damage_effect

  def perform_damage_effect

    # 元のメソッドを呼ぶ

    lnx11a_perform_damage_effect

    # シェイクを無効にしている場合、シェイクをクリア

    $game_troop.screen.clear_shake if LNX11::DISABLED_DAMAGE_SHAKE

  end

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

  # ● [再定義]:コラプス効果の実行

  #  アクターの[特徴>その他>消滅エフェクト]の設定を適用するようにします。

  #  処理内容は Game_Enemy のものとほぼ同一です。

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

  def perform_collapse_effect

    if $game_party.in_battle

      case collapse_type

      when 0

        @sprite_effect_type = :collapse

        Sound.play_actor_collapse

      when 1

        @sprite_effect_type = :boss_collapse

        Sound.play_boss_collapse1

      when 2

        @sprite_effect_type = :instant_collapse

      end

    end

  end

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

  # ● [追加]:グラフィック設定の配列を返す

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

  def graphic_name_index

    case LNX11::DEFAULT_BATTLER_GRAPHIC

    when 0 ; [@face_name, @face_index]

    when 1 ; [@character_name, @character_index]

    end

  end

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

  # ● [エイリアス]:グラフィックの変更

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

  alias :lnx11a_set_graphic :set_graphic

  def set_graphic(*args)

    face = graphic_name_index

    # 元のメソッドを呼ぶ

    lnx11a_set_graphic(*args)

    @refresh_battler_graphic = (face != graphic_name_index)

  end

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

  # ● [追加]:デフォルトバトラーグラフィックの取得

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

  def facebattler

    $game_temp.actor_battler_graphic[id]

  end

  def facebattler=(bitmap)

    facebattler.dispose if facebattler && !facebattler.disposed?

    $game_temp.actor_battler_graphic[id] = bitmap

  end

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

  # ● [追加]:後指定のバトラーグラフィックファイル名の取得

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

  def battler_graphic_name

    return @battler_graphic_name if @battler_graphic_name != nil

    @battler_graphic_name = ""

  end 

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

  # ● [追加]:後指定のバトラーグラフィックファイル名の指定

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

  def battler_graphic_name=(filename)

    @battler_graphic_name = filename

    @refresh_battler_graphic = true

  end

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

  # ● [追加]:顔グラフィックを描画して返す

  #  処理内容は Window_Base の draw_face に準じたものです。

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

  def draw_face(face_name, face_index, enabled = true)

    fw = 96

    fh = 96

    # ビットマップを作成して返す

    bitmap = Cache.face(face_name)

    rect = Rect.new(face_index % 4 * fw, face_index / 4 * fh, fw, fh)

    face = Bitmap.new(fw, fh)

    color = LNX11::DEFAULT_BG_COLOR

    face.gradient_fill_rect(face.rect, color[0], color[1], true) 

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

    bitmap.dispose

    face

  end

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

  # ● [追加]:歩行グラフィックを描画して返す

  #  処理内容は Window_Base の draw_character に準じたものです。

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

  def draw_character(character_name, character_index)

    return unless character_name

    bitmap = Cache.character(character_name)

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

    if sign && 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)

    character = Bitmap.new(cw, ch)

    color = LNX11::DEFAULT_BG_COLOR

    character.gradient_fill_rect(character.rect, color[0], color[1], true) 

    character.blt(0, 0, bitmap, src_rect)

    character

  end

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

  # ● [追加]:デフォルトバトラーグラフィック設定

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

  def default_battler_graphic

    case LNX11::DEFAULT_BATTLER_GRAPHIC

    when 0 # 顔グラフィック

      self.facebattler = draw_face(@face_name, @face_index)

    when 1 # 歩行グラフィック

      self.facebattler = draw_character(@character_name, @character_index)

    end

  end

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

  # ● [追加]:バトラーグラフィックの更新

  #  Sprite_Batter が利用するオブジェクトを更新します。

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

  def update_battler_graphic

    @battler_hue = 0

    if !battler_graphic_name.empty?

      # スクリプトで指定されている

      @battler_name = @battler_graphic_name

      dispose_facebattler

    elsif !actor.default_battler_graphic.empty?

      # メモで指定されている

      @battler_name = actor.default_battler_graphic

      dispose_facebattler

    else

      # 何も指定されていない

      @battler_name = ""

      default_battler_graphic

    end

    # 更新したので更新フラグを取り消す

    @refresh_battler_graphic = false

  end

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

  # ● [追加]:バトラー用顔グラフィックの解放

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

  def dispose_facebattler

    return if self.facebattler == nil

    self.facebattler.dispose

    self.facebattler = nil

  end

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

  # ● [エイリアス]:レベルアップメッセージの表示

  #   レベルアップのポップアップを追加します。

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

  alias :lnx11a_display_level_up :display_level_up

  def display_level_up(new_skills)

    popup_data.popup_levelup(self) if $game_party.in_battle

    lnx11a_display_level_up(new_skills)

  end

end

 

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

# ■ Game_Enemy

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

#  敵キャラを扱うクラスです。

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

 

class Game_Enemy < Game_Battler

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

  # ● [追加]:バトルメンバー判定

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

  def battle_member?

    true

  end

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

  # ● [追加]:通常攻撃 アニメーション ID の取得

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

  def atk_animation

    # メモを参照

    enemy.atk_animation

  end

end

 

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

# ■ Game_Party

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

#  パーティを扱うクラスです。所持金やアイテムなどの情報が含まれます。このクラ

# スのインスタンスは $game_party で参照されます。

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

 

class Game_Party < Game_Unit

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

  # ● [追加]:公開インスタンス変数

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

  attr_accessor :actor_invisible     # アクター非表示

  attr_accessor :status_invisible    # バトルステータス非表示

  attr_accessor :actor_bg_invisible  # アクター背景非表示

  attr_accessor :last_party_command  # 最後に選択したパーティコマンド

  attr_accessor :members_screen_x          # バトルメンバー分のX座標配列

  attr_accessor :members_screen_x_nooffset # X:オフセットなし

  attr_accessor :members_screen_y          # バトルメンバー分のY座標配列

  attr_accessor :members_screen_z          # バトルメンバー分のZ座標配列

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

  # ● [追加]:バトルメンバーの座標設定

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

  def set_members_xyz

    return if members.size == 0

    # 座標をまとめて設定

    set_screen_x

    set_screen_y

    set_screen_z

  end

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

  # ● [追加]:バトルメンバーの座標設定

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

  def set_members_battle_graphic

    $game_party.battle_members.each {|actor| actor.update_battler_graphic}

  end

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

  # ● [追加]:バトル画面 X 座標の設定

  #  ここで設定した座標は Game_Actor や ステータス表示等で利用されます。

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

  def set_screen_x

    @members_screen_x = []

    @members_screen_x_nooffset = []

    padding = LNX11::ACTOR_PADDING[:side]

    if LNX11::ACTOR_CENTERING

      # アクターのセンタリングが有効

      a_spacing = LNX11::ACTOR_SPACING_ADJUST

      padding += (max_battle_members - battle_members.size) * a_spacing

      width = (Graphics.width - padding * 2) / battle_members.size

    else

      # アクターのセンタリングが無効

      width = (Graphics.width - padding * 2) / max_battle_members

    end

    battle_members.each_with_index do |actor, i|

      offset = LNX11::ACTOR_OFFSET[:x]

      @members_screen_x_nooffset[i] = width * i + width / 2 + padding

      @members_screen_x[i] = @members_screen_x_nooffset[i] + offset

      actor.screen_x = @members_screen_x[i]

    end

  end

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

  # ● [追加]:バトル画面 Y 座標の設定

  #  ここで設定した座標は Game_Actor や ステータス表示等で利用されます。

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

  def set_screen_y

    offset = LNX11::ACTOR_OFFSET[:y]

    ay = Graphics.height - LNX11::ACTOR_PADDING[:bottom] + offset

    @members_screen_y = Array.new(max_battle_members) {ay}

    battle_members.each {|actor| actor.screen_y = ay}

  end

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

  # ● [追加]:バトル画面 Z 座標の設定

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

  def set_screen_z

    # 便宜上、XYと同じように配列を作成しておく

    az = LNX11::ACTOR_SCREEN_TONE ? 150 : -10

    @members_screen_z = Array.new(max_battle_members) {az}

  end

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

  # ● [オーバーライド]:戦闘開始処理

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

  def on_battle_start

    super

    # バトルステータスの更新

    $game_temp.battle_status_refresh

  end

end

 

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

# ■ Game_Troop

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

#  敵グループおよび戦闘に関するデータを扱うクラスです。

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

 

class Game_Troop < Game_Unit

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

  # ● [エイリアス]:セットアップ

  #  敵グループの座標修正処理を追加します。

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

  alias :lnx11a_setup :setup

  def setup(*args)

    # 元のメソッドを呼ぶ

    lnx11a_setup(*args)

    # 敵グループの座標修正

    @enemies.each do |enemy|

      # X:解像度がデフォルトでない場合に位置を補正する

      if LNX11::TROOP_X_SCREEN_FIX

        enemy.screen_x *= Graphics.width.to_f / 544

        enemy.screen_x.truncate

      end

      enemy.screen_y += LNX11::TROOP_Y_OFFSET

    end

  end

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

  # ● [エイリアス]:敵キャラ名の配列取得

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

  alias :lnx11a_enemy_names :enemy_names

  def enemy_names

    LNX11::MESSAGE_WINDOW_ENEMY_NAMES ? lnx11a_enemy_names : []

  end

end

 

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

# ■ Game_Message

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

#  文章や選択肢などを表示するメッセージウィンドウの状態を扱うクラスです。

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

 

class Game_Message

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

  # ● [追加]:公開インスタンス変数

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

  attr_reader   :helpdisplay_texts        # 簡易ヘルプ配列

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

  # ● [追加]:簡易ヘルプ配列の取得

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

  def helpdisplay_texts

    return @helpdisplay_texts if @helpdisplay_texts

    @helpdisplay_texts = []

  end

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

  # ● [エイリアス]:クリア

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

  alias :lnx11a_clear :clear

  def clear

    # 元のメソッドを呼ぶ

    lnx11a_clear

    @helpdisplay_texts = []

    @add_disabled = false

  end

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

  # ● [エイリアス]:テキストの追加

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

  alias :lnx11a_add :add

  def add(text)

    # テキストの追加が禁止されてる場合、簡易ヘルプ表示用の配列に追加する

    if @add_disabled

      @helpdisplay_texts = [] unless @helpdisplay_texts

      @helpdisplay_texts.push(text)

    else

      # 元のメソッドを呼ぶ

      lnx11a_add(text)

    end

  end

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

  # ● [追加]:テキスト追加の禁止

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

  def add_disabled

    return if LNX11::MESSAGE_TYPE == 0

    @add_disabled = true

  end

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

  # ● [追加]:テキスト追加の禁止

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

  def add_enabled

    return if LNX11::MESSAGE_TYPE == 0

    @add_disabled = false

  end

end

 

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

# ■ Sprite_Battler

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

#  バトラー表示用のスプライトです。

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

 

class Sprite_Battler < Sprite_Base

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

  # ● [追加]:ターゲットカーソルのバトラーの取得

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

  def cursor_battler

    $game_temp.target_cursor_sprite.battler

  end

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

  # ● [追加]:ターゲットカーソルの点滅状態に対応したシンボルを返す

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

  def cursor_effect

    $game_temp.target_cursor_sprite.blink ? :target_whiten : :command_whiten

  end

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

  # ● [追加]:対象選択フラッシュの設定

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

  def setup_cursor_effect 

    if cursor_battler == @battler ||

       (cursor_battler == :party && @battler.actor?) ||

       ([:troop, :troop_random].include?(cursor_battler) && !@battler.actor?)

      if @effect_type == nil || @effect_type != cursor_effect

        start_effect(cursor_effect)

      end

    else

      # フラッシュエフェクト終了

      end_cursor_effect

    end

  end

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

  # ● [追加]:対象選択フラッシュの終了

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

  def end_cursor_effect 

    if [:target_whiten, :command_whiten].include?(@effect_type)

      @effect_type = nil

      @effect_duration = 0

      revert_to_normal

    end

  end

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

  # ● [オーバーライド]:アニメーションスプライトの設定

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

  def animation_set_sprites(frame)

    o = self.opacity

    self.opacity = 255 if !@battler_visible || @effect_duration > 0

    # スーパークラスのメソッドを呼ぶ

    super(frame)

    self.opacity = o

  end

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

  # ● [オーバーライド]:アニメーションの原点設定

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

  def set_animation_origin

    # スーパークラスのメソッドを呼ぶ

    super

    # 画面アニメーションがアクターに再生されたら

    if @animation.position == 3 && @battler != nil && @battler.actor?

      # アニメーションのY座標を修正

      @ani_oy += LNX11::SCREEN_ANIMATION_OFFSET

    end

  end

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

  # ● [エイリアス]:転送元ビットマップの更新

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

  alias :lnx11a_update_bitmap :update_bitmap

  def update_bitmap

    if @battler.actor? && @battler.refresh_battler_graphic

      # バトラーグラフィックが変更されていれば更新する

      @battler.update_battler_graphic

    end

    if @battler.actor? && @battler.facebattler != nil

      # バトラー用顔グラフィックが作成されていれば、

      # それを Sprite の Bitmap とする

      new_bitmap = @battler.facebattler

      if bitmap != new_bitmap

        self.bitmap = new_bitmap

        init_visibility

      end

    else

      # 元のメソッドを呼ぶ

      lnx11a_update_bitmap

    end

  end

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

  # ● [エイリアス]:新しいアニメーションの設定

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

  alias :lnx11a_setup_new_animation :setup_new_animation

  def setup_new_animation

    lnx11a_setup_new_animation

    # ループアニメーションの設定

    if @battler.loop_animation_id > 0 && (@loop_animation == nil ||

       @battler.loop_animation_id != @loop_animation.id)

      animation = $data_animations[@battler.loop_animation_id]

      mirror = @battler.loop_animation_mirror

      start_loop_animation(animation, mirror)

    elsif @battler.loop_animation_id == 0 && @loop_animation

      end_loop_animation

    end

  end

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

  # ● [エイリアス]:新しいエフェクトの設定

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

  alias :lnx11a_setup_new_effect :setup_new_effect

  def setup_new_effect

    # 元のメソッドを呼ぶ

    lnx11a_setup_new_effect

    # フラッシュエフェクト設定

    if @battler_visible && cursor_battler

      setup_cursor_effect

    else

      # フラッシュエフェクト終了

      end_cursor_effect

    end

  end

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

  # ● [エイリアス]:エフェクトの開始

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

  alias :lnx11a_start_effect :start_effect

  def start_effect(effect_type)

    # エフェクト開始の追加

    @effect_type = effect_type

    case @effect_type

    when :target_whiten

      @effect_duration = 40

      @battler_visible = true

    when :command_whiten

      @effect_duration = 80

      @battler_visible = true

    end

    # 元のメソッドを呼ぶ

    lnx11a_start_effect(effect_type)

  end

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

  # ● [エイリアス]:エフェクトの更新

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

  alias :lnx11a_update_effect :update_effect

  def update_effect

    # エフェクト更新の追加

    if @effect_duration > 0

      @effect_duration -= 1

      case @effect_type

      when :target_whiten

        update_target_whiten

      when :command_whiten

        update_command_whiten

      end

      @effect_duration += 1

    end

    # 元のメソッドを呼ぶ

    lnx11a_update_effect

  end

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

  # ● [追加]:対象選択フラッシュエフェクトの更新

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

  def update_target_whiten

    alpha = @effect_duration < 20 ? @effect_duration : 40 - @effect_duration

    self.color.set(255, 255, 255, 0)

    self.color.alpha = (alpha + 1) * 2

  end

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

  # ● [追加]:コマンド選択フラッシュエフェクトの更新

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

  def update_command_whiten

    alpha = @effect_duration < 40 ? @effect_duration : 80 - @effect_duration

    self.color.set(255, 255, 255, 0)

    self.color.alpha = alpha * 2

  end

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

  # ● [追加]:高さの取得

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

  def bitmap_height

    self.bitmap.height

  end

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

  # ● [エイリアス]:位置の更新

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

  alias :lnx11a_update_position :update_position

  def update_position

    # 元のメソッドを呼ぶ

    lnx11a_update_position

    # 高さを更新

    @battler.bitmap_height = bitmap_height

    # 可視状態を更新

    self.visible = !$game_party.actor_invisible if @battler.actor?

  end

  if LNX11::ENHANCED_WHITEN

    # 白フラッシュを強めにする

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

    # ● [再定義]:白フラッシュエフェクトの更新

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

    def update_whiten

      self.color.set(255, 255, 255, 0)

      self.color.alpha = 192 - (16 - @effect_duration) * 12

    end

  end

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

  # ● ループアニメーションの追加

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

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

  # ● [追加]:クラス変数

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

  @@loop_ani_checker = []

  @@loop_ani_spr_checker = []

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

  # ● [エイリアス]:オブジェクト初期化

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

  alias :lnx11a_initialize :initialize

  def initialize(viewport, battler = nil)

    # 元のメソッドを呼ぶ

    lnx11a_initialize(viewport, battler)

    # ループアニメの残り時間

    @loop_ani_duration = 0

  end

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

  # ● [エイリアス]:解放

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

  alias :lnx11a_dispose :dispose

  def dispose

    # 元のメソッドを呼ぶ

    lnx11a_dispose

    # ループアニメを解放

    dispose_loop_animation

  end

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

  # ● [エイリアス]:フレーム更新

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

  alias :lnx11a_update :update

  def update

    # 元のメソッドを呼ぶ

    lnx11a_update

    update_loop_animation

    @@loop_ani_checker.clear

    @@loop_ani_spr_checker.clear

  end

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

  # ● [追加]:ループアニメーション表示中判定

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

  def loop_animation?

    @loop_animation != nil

  end

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

  # ● [追加]:ループアニメーションの開始

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

  def start_loop_animation(animation, mirror = false)

    dispose_loop_animation

    @loop_animation = animation

    if @loop_animation

      @loop_ani_mirror = mirror

      set_loop_animation_rate

      @loop_ani_duration = @loop_animation.frame_max * @loop_ani_rate + 1

      load_loop_animation_bitmap

      make_loop_animation_sprites

      set_loop_animation_origin

    end

  end

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

  # ● [追加]:ループアニメーションの速度を設定

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

  def set_loop_animation_rate

    if $lnx_include[:lnx09]

      # LNX09 を導入している

      default = LNX09::DEFAULT_BATTLE_SPEED_RATE

      if @loop_animation.speed_rate

        @loop_ani_rate = @loop_animation.speed_rate

      else

        @loop_ani_rate = default

      end

    else

      @loop_ani_rate = 4

    end

  end

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

  # ● [追加]:ループアニメーション グラフィックの読み込み

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

  def load_loop_animation_bitmap

    animation1_name = @loop_animation.animation1_name

    animation1_hue = @loop_animation.animation1_hue

    animation2_name = @loop_animation.animation2_name

    animation2_hue = @loop_animation.animation2_hue

    @loop_ani_bitmap1 = Cache.animation(animation1_name, animation1_hue)

    @loop_ani_bitmap2 = Cache.animation(animation2_name, animation2_hue)

    if @@_reference_count.include?(@loop_ani_bitmap1)

      @@_reference_count[@loop_ani_bitmap1] += 1

    else

      @@_reference_count[@loop_ani_bitmap1] = 1

    end

    if @@_reference_count.include?(@loop_ani_bitmap2)

      @@_reference_count[@loop_ani_bitmap2] += 1

    else

      @@_reference_count[@loop_ani_bitmap2] = 1

    end

    Graphics.frame_reset

  end

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

  # ● [追加]:ループアニメーションスプライトの作成

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

  def make_loop_animation_sprites

    @loop_ani_sprites = []

    if @use_sprite && !@@loop_ani_spr_checker.include?(@loop_animation)

      16.times do

        sprite = ::Sprite.new(viewport)

        sprite.visible = false

        @loop_ani_sprites.push(sprite)

      end

      if @loop_animation.position == 3

        @@loop_ani_spr_checker.push(@loop_animation)

      end

    end

    @loop_ani_duplicated = @@loop_ani_checker.include?(@loop_animation)

    if !@loop_ani_duplicated && @loop_animation.position == 3

      @@loop_ani_checker.push(@loop_animation)

    end

  end

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

  # ● [追加]:ループアニメーションの原点設定

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

  def set_loop_animation_origin

    if @loop_animation.position == 3

      if viewport == nil

        @loop_ani_ox = Graphics.width / 2

        @loop_ani_oy = Graphics.height / 2

      else

        @loop_ani_ox = viewport.rect.width / 2

        @loop_ani_oy = viewport.rect.height / 2

      end

    else

      @loop_ani_ox = x - ox + width / 2

      @loop_ani_oy = y - oy + height / 2

      if @loop_animation.position == 0

        @loop_ani_oy -= height / 2

      elsif @loop_animation.position == 2

        @loop_ani_oy += height / 2

      end

    end

  end

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

  # ● [追加]:ループアニメーションの解放

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

  def dispose_loop_animation

    if @loop_ani_bitmap1

      @@_reference_count[@loop_ani_bitmap1] -= 1

      if @@_reference_count[@loop_ani_bitmap1] == 0

        @loop_ani_bitmap1.dispose

      end

    end

    if @loop_ani_bitmap2

      @@_reference_count[@loop_ani_bitmap2] -= 1

      if @@_reference_count[@loop_ani_bitmap2] == 0

        @loop_ani_bitmap2.dispose

      end

    end

    if @loop_ani_sprites

      @loop_ani_sprites.each {|sprite| sprite.dispose }

      @loop_ani_sprites = nil

      @loop_animation = nil

    end

    @loop_ani_bitmap1 = nil

    @loop_ani_bitmap2 = nil

  end

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

  # ● [追加]:ループアニメーションの更新

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

  def update_loop_animation

    return unless loop_animation?

    @loop_ani_duration -= 1

    if @loop_ani_duration % @loop_ani_rate == 0

      if @loop_ani_duration > 0

        frame_index = @loop_animation.frame_max

        speed = (@loop_ani_duration + @loop_ani_rate - 1) / @loop_ani_rate

        frame_index -= speed

        loop_animation_set_sprites(@loop_animation.frames[frame_index])

        @loop_animation.timings.each do |timing|

          loop_animation_process_timing(timing) if timing.frame == frame_index

        end

      else

        # 残り時間を再設定してループ

        @loop_ani_duration = @loop_animation.frame_max * @loop_ani_rate + 1

      end

    end

  end

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

  # ● [追加]:ループアニメーションの終了

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

  def end_loop_animation

    dispose_loop_animation

  end

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

  # ● [追加]:ループアニメーションスプライトの設定

  #     frame : フレームデータ(RPG::Animation::Frame)

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

  def loop_animation_set_sprites(frame)

    cell_data = frame.cell_data

    @loop_ani_sprites.each_with_index do |sprite, i|

      next unless sprite

      pattern = cell_data[i, 0]

      if !pattern || pattern < 0

        sprite.visible = false

        next

      end

      sprite.bitmap = pattern < 100 ? @loop_ani_bitmap1 : @loop_ani_bitmap2

      sprite.visible = true

      sprite.src_rect.set(pattern % 5 * 192,

        pattern % 100 / 5 * 192, 192, 192)

      if @loop_ani_mirror

        sprite.x = @loop_ani_ox - cell_data[i, 1]

        sprite.y = @loop_ani_oy + cell_data[i, 2]

        sprite.angle = (360 - cell_data[i, 4])

        sprite.mirror = (cell_data[i, 5] == 0)

      else

        sprite.x = @loop_ani_ox + cell_data[i, 1]

        sprite.y = @loop_ani_oy + cell_data[i, 2]

        sprite.angle = cell_data[i, 4]

        sprite.mirror = (cell_data[i, 5] == 1)

      end

      sprite.z = self.z + 316 + i 

      sprite.ox = 96

      sprite.oy = 96

      sprite.zoom_x = cell_data[i, 3] / 100.0

      sprite.zoom_y = cell_data[i, 3] / 100.0

      sprite.opacity = cell_data[i, 6] * self.opacity / 255.0

      sprite.blend_type = cell_data[i, 7]

    end

  end

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

  # ● [追加]:SE とフラッシュのタイミング処理

  #     timing : タイミングデータ(RPG::Animation::Timing)

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

  def loop_animation_process_timing(timing)

    timing.se.play unless @loop_ani_duplicated

    case timing.flash_scope

    when 1

      self.flash(timing.flash_color, timing.flash_duration * @loop_ani_rate)

    when 2

      if viewport && !@loop_ani_duplicated

        duration = timing.flash_duration * @loop_ani_rate

        viewport.flash(timing.flash_color, duration)

      end

    when 3

      self.flash(nil, timing.flash_duration * @loop_ani_rate)

    end

  end

end

 

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

# ■ Spriteset_Battle

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

#  バトル画面のスプライトをまとめたクラスです。

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

 

class Spriteset_Battle

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

  # ● [エイリアス]:オブジェクト初期化

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

  alias :lnx11a_initialize :initialize

  def initialize

    # 元のメソッドを呼ぶ

    lnx11a_initialize

    # アクターエリアの背景の作成

    create_actor_background

  end

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

  # ● [エイリアス]:解放

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

  alias :lnx11a_dispose :dispose

  def dispose

    # 元のメソッドを呼ぶ

    lnx11a_dispose

    # アクターエリアの背景の解放

    dispose_actor_background

  end

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

  # ● [エイリアス]:フレーム更新

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

  alias :lnx11a_update :update

  def update

    # 元のメソッドを呼ぶ

    lnx11a_update

    # アクターエリアの背景の更新

    update_actor_background

  end

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

  # ● [追加]:アクターのビューポート

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

  def actor_viewport

    LNX11::ACTOR_SCREEN_TONE ? @viewport1 : @viewport2

  end

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

  # ● [追加]:アクターエリアの背景の作成

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

  def create_actor_background

    return if LNX11::ACTOR_BACKGROUND == 0

    viewport = actor_viewport

    height = LNX11::ACTOR_BACKGROUND_HEIGHT

    case LNX11::ACTOR_BACKGROUND

    when 1

      # グラデーション

      @actor_background = Sprite.new

      back = Bitmap.new(Graphics.width, height)

      color = LNX11::ACTOR_BG_GRADIENT_COLOR

      back.gradient_fill_rect(back.rect, color[0], color[1], true) 

      @actor_background.bitmap = back

    when 2

      # ウィンドウ

      @actor_background = Window_Base.new(0, 0, Graphics.width, height)

    else

      if LNX11::ACTOR_BACKGROUND.is_a?(String)

        # ファイル指定

        @actor_background = Sprite.new

        @actor_background.bitmap = Cache.system(LNX11::ACTOR_BACKGROUND)

        @actor_background.x = Graphics.width / 2

        @actor_background.ox = @actor_background.bitmap.width / 2

        height = @actor_background.bitmap.height

      end

    end

    @actor_background.viewport = viewport

    @actor_background.y = Graphics.height - height

    @actor_background.z = viewport == @viewport1 ? 120 : -20

    update_actor_background

  end

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

  # ● [追加]:アクターエリアの背景の解放

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

  def dispose_actor_background

    return unless @actor_background

    @actor_background.bitmap.dispose if @actor_background.is_a?(Sprite)

    @actor_background.dispose

  end

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

  # ● [追加]:アクターエリアの背景の更新

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

  def update_actor_background

    return unless @actor_background

    @actor_background.visible = !$game_party.actor_bg_invisible

  end

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

  # ● [再定義]:アクタースプライトの作成

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

  def create_actors

    # 座標とグラフィックの設定

    $game_party.set_members_xyz

    $game_party.set_members_battle_graphic

    # スプライトの作成

    viewport = actor_viewport

    @actor_sprites = $game_party.battle_members.collect do |actor|

      Sprite_Battler.new(viewport, actor)

    end

  end

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

  # ● [再定義]:アクタースプライトの更新

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

  def update_actors

    @actor_sprites.each {|sprite| sprite.update }

  end

end

 

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

# ■ Scene_Battle

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

#  バトル画面の処理を行うクラスです。

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

 

class Scene_Battle < Scene_Base

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

  # ● [追加]:簡易ヘルプのメソッド設定

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

  def set_helpdisplay_methods

    BattleManager.update_for_wait_method = method(:update_for_wait)

    BattleManager.helpdisplay_set_method = method(:helpdisplay_set)

    BattleManager.helpdisplay_clear_method = method(:helpdisplay_clear)

    BattleManager.helpdisplay_wait_short_method=method(:helpdisplay_wait_short)

  end

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

  # ● [追加]:簡易ヘルプ表示

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

  def helpdisplay_set(item, duration = nil)

    @wait_short_disabled = false

    @targethelp_window.show.set_item(item)

    @targethelp_window.update

    wait(duration ? duration : 20)

  end

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

  # ● [追加]:簡易ヘルプ消去

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

  def helpdisplay_clear(duration = nil)

    return if !@targethelp_window.visible

    @wait_short_disabled = false

    @targethelp_window.clear

    @targethelp_window.hide

    wait(duration ? duration : 10)

  end

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

  # ● [追加]:簡易ヘルプ・短時間ウェイト

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

  def helpdisplay_wait_short

    return if !@targethelp_window.visible || @wait_short_disabled

    @wait_short_disabled = true # 連続で短時間ウェイトが実行されないように

    @targethelp_window.clear

    abs_wait_short

  end

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

  # ● [追加]:バトラーのエフェクト実行中?

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

  def battler_effect?

    @spriteset.effect?

  end

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

  # ● [エイリアス]:コマンド[逃げる]

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

  alias :lnx11a_command_escape :command_escape

  def command_escape

    @party_command_window.close

    @party_command_window.openness = 0 if LNX11::MESSAGE_TYPE == 2

    @status_window.unselect

    # 元のメソッドを呼ぶ

    lnx11a_command_escape

  end

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

  # ● [エイリアス]:スキル/アイテムの使用

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

  alias :lnx11a_use_item :use_item

  def use_item

    # 簡易ヘルプ表示

    item = @subject.current_action.item

    if LNX11::BATTLELOG_TYPE == 2 && !item.no_display

      helpdisplay_set(item, item.display_wait)

    end

    # 元のメソッドを呼ぶ

    lnx11a_use_item

    # 簡易ヘルプ消去・エフェクトが終わるまで待つ

    if LNX11::BATTLELOG_TYPE == 2

      wait(item.end_wait) 

      helpdisplay_clear

    end

    wait_for_effect

  end

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

  # ● [エイリアス]:開始処理

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

  alias :lnx11a_start :start

  def start

    set_helpdisplay_methods

    @last_party_members = party_members

    $game_temp.method_battle_status_refresh = method(:refresh_status)

    $game_temp.clear_last_target_cursor

    $game_party.all_members.each {|actor| actor.last_actor_command = 0 }

    reset_sprite_effects

    standby_message_window_position

    create_targetcursor

    create_popup

    #元のメソッドを呼ぶ

    lnx11a_start

  end

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

  # ● [エイリアス]:終了処理

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

  alias :lnx11a_terminate :terminate

  def terminate

    $game_message.clear

    dispose_targetcursor

    dispose_popup

    # 元のメソッドを呼ぶ

    lnx11a_terminate

  end

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

  # ● [追加]:アクターのスプライト情報の初期化

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

  def reset_sprite_effects

    $game_party.battle_members.each do |actor|

      actor.popup_delay_clear

      actor.set_state_animation

    end

  end

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

  # ● [エイリアス]:全ウィンドウの作成

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

  alias :lnx11a_create_all_windows :create_all_windows

  def create_all_windows

    # 元のメソッドを呼ぶ

    lnx11a_create_all_windows

    create_targethelp_window

  end

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

  # ● [エイリアス]:ステータスウィンドウの作成

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

  alias :lnx11a_create_status_window :create_status_window

  def create_status_window

    # 元のメソッドを呼ぶ

    lnx11a_create_status_window

    @status_window.set_xy

  end

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

  # ● [エイリアス]:情報表示ビューポートの作成

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

  alias :lnx11a_create_info_viewport :create_info_viewport

  def create_info_viewport

    # 元のメソッドを呼ぶ

    lnx11a_create_info_viewport

    # ビューポートを修正

    @info_viewport.rect.y = Graphics.height - LNX11::ACTOR_BACKGROUND_HEIGHT

    @info_viewport.rect.height = LNX11::ACTOR_BACKGROUND_HEIGHT

    @status_window.viewport = nil

  end

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

  # ● [エイリアス]:パーティコマンドウィンドウの作成

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

  alias :lnx11a_create_party_command_window :create_party_command_window

  def create_party_command_window

    # 元のメソッドを呼ぶ

    lnx11a_create_party_command_window

    @party_command_window.viewport = nil

  end

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

  # ● [エイリアス]:アクターコマンドウィンドウの作成

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

  alias :lnx11a_create_actor_command_window :create_actor_command_window

  def create_actor_command_window

    # 元のメソッドを呼ぶ

    lnx11a_create_actor_command_window

    @actor_command_window.viewport = nil

  end

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

  # ● [エイリアス]:ログウィンドウの作成

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

  alias :lnx11a_create_log_window :create_log_window

  def create_log_window

    # 元のメソッドを呼ぶ

    lnx11a_create_log_window

    # ウェイトメソッド

    @log_window.method_wait_for_animation = method(:wait_for_animation)

  end  

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

  # ● [追加]:ターゲットカーソルの作成

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

  def create_targetcursor

    @targetcursor = Sprite_TargetCursor.new

    $game_temp.target_cursor_sprite = @targetcursor

  end

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

  # ● [追加]:ターゲットカーソルの解放

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

  def dispose_targetcursor

    @targetcursor.dispose

  end

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

  # ● [追加]:ターゲットヘルプウィンドウの作成

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

  def create_targethelp_window

    @targethelp_window = Window_TargetHelp.new

    @targethelp_window.visible = false

    # ターゲット選択ウィンドウに関連付ける

    @actor_window.help_window = @targethelp_window

    @enemy_window.help_window = @targethelp_window

  end

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

  # ● [追加]:ポップアップの作成

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

  def create_popup

    $game_temp.popup_data = Popup_Data.new

  end

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

  # ● [追加]:ポップアップの解放

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

  def dispose_popup

    $game_temp.popup_data.dispose

  end

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

  # ● [追加]:ポップアップデータの取得

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

  def popup_data

    $game_temp.popup_data

  end

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

  # ● [エイリアス]:フレーム更新(基本)

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

  alias :lnx11a_update_basic :update_basic

  def update_basic

    # 元のメソッドを呼ぶ

    lnx11a_update_basic

    # 追加したオブジェクトの更新

    update_targetcursor

    update_popup

    refresh_actors

  end

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

  # ● [追加]:パーティメンバーの ID 配列の取得

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

  def party_members

    $game_party.battle_members.collect {|actor| actor.id }

  end

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

  # ● [追加]:メンバーが入れ替わったらオブジェクトを再作成する

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

  def refresh_actors

    a_party_members = party_members

    return if @last_party_members == a_party_members

    @last_party_members = a_party_members

    $game_party.battle_members.each {|actor| actor.sprite_effect_type=:appear }

    reset_sprite_effects

    @spriteset.dispose_actors

    @spriteset.create_actors

    status_clear

    refresh_status

    Graphics.frame_reset

  end

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

  # ● [追加]:ステータスウィンドウの情報を更新(メンバー交代用)

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

  def status_clear

    @status_window.all_clear

  end

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

  # ● [追加]:メッセージウィンドウの位置の初期化

  #  毎フレーム呼び出すことで、イベントコマンド以外のメッセージの位置を

  # 固定します。

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

  def standby_message_window_position

    $game_message.background = LNX11::MESSAGE_WINDOW_BACKGROUND

    $game_message.position = LNX11::MESSAGE_WINDOW_POSITION

  end

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

  # ● [再定義]:メッセージウィンドウを開く処理の更新

  #    ステータスウィンドウなどが閉じ終わるまでオープン度を 0 にする。

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

  def update_message_open

    if $game_message.busy?

      @party_command_window.close

      @actor_command_window.close

      $game_temp.battlelog_clear = true

    else

      standby_message_window_position

    end

  end

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

  # ● [追加]:ターゲットカーソル更新

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

  def update_targetcursor

    # 選択中のバトラーの座標を設定する

    if @actor_window.active

      # アクター選択ウィンドウがアクティブ

      @targetcursor.set(@actor_window.targetcursor, true)

    elsif @enemy_window.active

      # 敵キャラ選択ウィンドウがアクティブ

      @targetcursor.set(@enemy_window.targetcursor, true)

    elsif @status_window.index >= 0

      # ステータスウィンドウがアクティブ

      @targetcursor.set(@status_window.actor)

    else

      # どれもアクティブでない場合は非表示

      @targetcursor.hide

    end

    @targetcursor.update

  end

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

  # ● [追加]:ポップアップ更新

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

  def update_popup

    # ポップアップスプライトの更新

    popup_data.update

  end  

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

  # ● [エイリアス]:パーティコマンド選択の開始

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

  alias :lnx11a_start_party_command_selection :start_party_command_selection

  def start_party_command_selection

    # 元のメソッドを呼ぶ

    lnx11a_start_party_command_selection

    # バトルログ削除

    @log_window.lines_clear

    $game_temp.battlelog_clear = LNX11::STORAGE_TURNEND_CLEAR

    @actor_command = false

    # 2ターン目以降のパーテイコマンドスキップ

    return unless @party_command_skip

    @party_command_skip = false

    command_fight if !scene_changing? && @party_command_window.active

  end

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

  # ● [エイリアス]:アクターコマンド選択の開始

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

  alias :lnx11a_start_actor_command_selection :start_actor_command_selection

  def start_actor_command_selection

    # 元のメソッドを呼ぶ

    lnx11a_start_actor_command_selection

    @actor_command = true

  end

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

  # ● [エイリアス]:ターン終了

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

  alias :lnx11a_turn_end :turn_end

  def turn_end

    @party_command_skip = (LNX11::PARTY_COMMAND_SKIP && @actor_command)

    @actor_command = false

    # 元のメソッドを呼ぶ

    lnx11a_turn_end

  end

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

  # ● [追加]:アクターの選択したアイテム・スキルを返す

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

  def actor_selection_item

    case @actor_command_window.current_symbol

    when :attack ; $data_skills[BattleManager.actor.attack_skill_id]

    when :skill  ; @skill

    when :item   ; @item

    when :guard  ; $data_skills[BattleManager.actor.guard_skill_id]

    else ; nil

    end

  end

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

  # ● [エイリアス]:コマンド[防御]

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

  alias :lnx11a_command_guard :command_guard

  def command_guard

    if LNX11::GUARD_TARGET_CHECKE

      BattleManager.actor.input.set_guard

      # アクター選択

      select_actor_selection

    else

      # 元のメソッドを呼ぶ

      lnx11a_command_guard

    end

  end

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

  # ● [エイリアス]:アクター選択の開始

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

  alias :lnx11a_select_actor_selection :select_actor_selection

  def select_actor_selection

    # ターゲットチェック

    @actor_window.set_target(actor_selection_item)

    # 元のメソッドを呼ぶ

    lnx11a_select_actor_selection

    # ターゲットチェック

    @actor_window.set_target_refresh(actor_selection_item, BattleManager.actor)

  end

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

  # ● [エイリアス]:敵キャラ選択の開始

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

  alias :lnx11a_select_enemy_selection :select_enemy_selection

  def select_enemy_selection

    # ターゲットチェック

    @enemy_window.set_target(actor_selection_item)

    # 元のメソッドを呼ぶ

    lnx11a_select_enemy_selection

    # ターゲットチェック

    @enemy_window.set_target_refresh(actor_selection_item, BattleManager.actor)

  end

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

  # ● [エイリアス]アクター[キャンセル]

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

  alias :lnx11a_on_actor_cancel :on_actor_cancel

  def on_actor_cancel

    # 元のメソッドを呼ぶ

    lnx11a_on_actor_cancel

    # 防御の場合

    case @actor_command_window.current_symbol

    when :guard

      @actor_command_window.activate

    end    

  end

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

  # ● [エイリアス]:攻撃アニメーションの表示

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

  alias :lnx11a_show_attack_animation :show_attack_animation

  def show_attack_animation(targets)

    if @subject.actor?

      lnx11a_show_attack_animation(targets)

    else

      # 敵の通常攻撃アニメーション

      show_normal_animation(targets, @subject.atk_animation, false)

    end

  end

end

 

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

# ■ LNX11_Window_ActiveVisible

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

#  バトル画面でターゲット選択中にウィンドウを非表示にするための

# ウィンドウ用モジュールです。

# ウィンドウの active と visible を連動させる役割があります。

# Window_ActorCommand,Window_BattleSkill, Window_BattleItem で

# インクルードされます。

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

 

module LNX11_Window_ActiveVisible

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

  # ● [オーバーライド]:ウィンドウのアクティブ化

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

  def activate

    self.show

    super

  end

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

  # ● [オーバーライド]:ウィンドウの非アクティブ化

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

  def deactivate

    @help_window != nil ? self.hide : self.visible = false

    super

  end

end

 

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

# ■ LNX11_Window_FittingList

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

#  バトル画面のスキルリスト・アイテムリストを項目数に合わせてリサイズする

# ウィンドウ用モジュールです。

# Window_BattleSkill, Window_BattleItem でインクルードされます。

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

 

module LNX11_Window_FittingList

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

  # ● [追加]:ウィンドウの高さ(最大)

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

  def max_height

    @info_viewport.rect.y - @help_window.height

  end

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

  # ● [オーバーライド]:リフレッシュ

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

  def refresh

    make_item_list

    self.height = [fitting_height(row_max), max_height].min

    super

    self.oy = 0

  end

end

  

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

# ■ LNX11_Window_TargetHelp

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

#  バトル画面で、ターゲット選択中にヘルプウィンドウを表示するための

# ウィンドウ用モジュールです。

# Window_BattleActor, Window_BattleEnemy でインクルードされます。

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

 

module LNX11_Window_TargetHelp

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

  # ● [追加]:ターゲットチェック

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

  def set_target(actor_selection_item)

    @cursor_fix = @cursor_all = @cursor_random = false

    item = actor_selection_item

    if actor_selection_item && !item.lnx11a_need_selection?

      # カーソルを固定

      @cursor_fix = true

      # 全体

      @cursor_all = item.for_all? 

      # ランダム

      if item.for_random?

        @cursor_all = true

        @cursor_random = true

        @random_number = item.number_of_targets

      end

    end

    # 戦闘不能の味方が対象か?

    @dead_friend = item.for_dead_friend?

  end

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

  # ● [追加]:ターゲットチェック(リフレッシュ後)

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

  def set_target_refresh(actor_selection_item, actor)

    item = actor_selection_item

    # 使用者が対象なら、使用者にカーソルを合わせる

    select($game_party.members.index(actor)) if @cursor_fix && item.for_user?

  end

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

  # ● [オーバーライド]:ウィンドウの表示

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

  def show

    @help_window.show

    super

  end

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

  # ● [オーバーライド]:ウィンドウの非表示

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

  def hide

    @help_window.hide

    super

  end

end

 

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

# ■ [追加]:Window_TargetHelp

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

#  ターゲットの名前情報やスキルやアイテムの名前を表示します。

#==============================================================================

 

class Window_TargetHelp < Window_Help

  #--------------------------------------------------------------------------

  # ● 公開インスタンス変数

  #--------------------------------------------------------------------------

  attr_accessor :random_number  # 効果範囲ランダムの数

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:オブジェクト初期化

  #--------------------------------------------------------------------------

  def initialize

    super(1) # 1行ヘルプ

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:ウィンドウの非表示

  #--------------------------------------------------------------------------

  def hide

    super

    clear

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:アイテム名設定

  #     item : スキル、アイテム、バトラー等

  #--------------------------------------------------------------------------

  def set_item(item)

    set_text(item ? item : "") # itemの説明ではなく、item自体を渡すようにする

  end

  #--------------------------------------------------------------------------

  # ● ゲージ幅

  #--------------------------------------------------------------------------

  def gauge_width

    LNX11::HELP_PARAM_WIDTH

  end

  #--------------------------------------------------------------------------

  # ● ゲージ幅(余白を含む)

  #--------------------------------------------------------------------------  

  def gauge_width_spacing

    LNX11::HELP_PARAM_WIDTH + 4

  end

  #--------------------------------------------------------------------------

  # ● パラメータエリアの幅

  #--------------------------------------------------------------------------  

  def param_width(size)

    gauge_width_spacing * size

  end

  #--------------------------------------------------------------------------

  # ● 効果範囲ランダムの数の取得

  #--------------------------------------------------------------------------

  def random_number

    # 全角にして返す

    @random_number.to_s.tr('0-9','0-9')

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:リフレッシュ

  #--------------------------------------------------------------------------

  def refresh

    contents.clear

    change_color(normal_color)

    if @text == :party

      draw_text(contents.rect, "All Allies", 1)

    elsif @text == :troop

      draw_text(contents.rect, "All Enemies", 1)

    elsif @text == :troop_random

      case LNX11::RANDOMSCOPE_DISPLAY

      when 0 ; draw_text(contents.rect, "All Enemies (Random)", 1)

      when 1 ; draw_text(contents.rect, "#{random_number} Random Enemies", 1)

      end

    elsif @text.is_a?(Game_Battler)

      # 選択対象の情報を描画

      draw_target_info

    elsif @text.is_a?(RPG::UsableItem)

      # アイテムかスキルならアイテム名を描画

      draw_item_name_help(@text)

    else

      # 通常のテキスト

      super

    end

  end

  #--------------------------------------------------------------------------

  # ● 選択対象の情報の描画

  #--------------------------------------------------------------------------

  def draw_target_info

    # バトラー情報の描画

    param = @text.actor? ? LNX11::HELP_ACTOR_PARAM : LNX11::HELP_ENEMY_PARAM

    # ゲージ付きステータス配列

    status = [param[:hp],param[:mp],param[:tp]&&$data_system.opt_display_tp]

    # 名前

    x = contents_width / 2 - contents.text_size(@text.name).width / 2

    name_width = contents.text_size(@text.name).width + 4

    if !status.include?(true)

      # ゲージ付きステータスを描画しない場合

      draw_targethelp_name(@text, x, name_width, param[:hp])

      x += name_width

      state_width = contents_width - x

    else

      # ゲージ付きステータスを描画する場合

      status.delete(false)

      x -= param_width(status.size) / 2

      draw_targethelp_name(@text, x, name_width, param[:hp])

      x += name_width

      state_width = contents_width - x - param_width(status.size)

    end

    # ステートアイコン

    if param[:state]

      draw_actor_icons(@text, x, 0, state_width) 

    end

    # パラメータの描画

    x = contents_width - param_width(status.size)

    # HP

    if param[:hp]

      draw_actor_hp(@text, x, 0, gauge_width)

      x += gauge_width_spacing

    end

    # MP

    if param[:mp]

      draw_actor_mp(@text, x, 0, gauge_width)

      x += gauge_width_spacing

    end

    # TP

    if param[:tp] && $data_system.opt_display_tp

      draw_actor_tp(@text, x, 0, gauge_width)

      x += gauge_width_spacing

    end

  end

  #--------------------------------------------------------------------------

  # ● ターゲットの名前描画

  #--------------------------------------------------------------------------

  def draw_targethelp_name(actor, x, name_width, hp)

    if hp

      # HPゲージを伴う場合(HPが少ない場合、名前の色が変化する)

      draw_actor_name(actor, x, 0, name_width)

    else

      text = actor.name

      draw_text(x, 0, text_size(text).width + 4, line_height, text)

    end

  end

  #--------------------------------------------------------------------------

  # ● アイテムの描画(中央揃え)

  #--------------------------------------------------------------------------

  def draw_item_name_help(item)

    case LNX11::HELPDISPLAY_TYPE

    when 0 # アイコン+名前

      w = contents.text_size(@text.name).width + 28

    when 1 # 名前のみ

      w = contents.text_size(@text.name).width + 4

    end

    # 簡易説明文の描画

    if !@text.short_description.empty?

      des = LNX11::HELPDISPLAY_DESCRIPTION

      contents.font.size = des[:size]

      text = des[:delimiter] + @text.short_description

      rect = contents.text_size(text)

      w += rect.width

      x = (contents_width - w) / 2

      y = (line_height - rect.height) / 2

      draw_text(x, y, w, line_height, text, 2)

      reset_font_settings

    end

    # 名前の描画

    x = (contents_width - w) / 2

    case LNX11::HELPDISPLAY_TYPE

    when 0 # アイコン+名前

      draw_item_name(@text, x, 0, true, w)

    when 1 # 名前のみ

      draw_text(x, 0, contents_width, line_height, @text.name)

    end

  end

end

 

#==============================================================================

# ■ Window_PartyCommand

#------------------------------------------------------------------------------

#  バトル画面で、戦うか逃げるかを選択するウィンドウです。

#==============================================================================

 

class Window_PartyCommand < Window_Command

  #--------------------------------------------------------------------------

  # ● [エイリアス]:オブジェクト初期化

  #--------------------------------------------------------------------------

  alias :lnx11a_initialize :initialize

  def initialize

    $game_party.last_party_command = nil

    # 元のメソッドを呼ぶ

    lnx11a_initialize

    # 座標を設定

    self.x = LNX11::PARTY_COMMAND_XY[:x]

    self.y = LNX11::PARTY_COMMAND_XY[:y]

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:ウィンドウ幅の取得

  #--------------------------------------------------------------------------

  def window_width

    return LNX11::PARTY_COMMAND_WIDTH

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:表示行数の取得

  #--------------------------------------------------------------------------

  def visible_line_number

    return LNX11::PARTY_COMMAND_HORIZON ? 1 : @list.size

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:桁数の取得

  #--------------------------------------------------------------------------

  def col_max

    return LNX11::PARTY_COMMAND_HORIZON ? @list.size : 1

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:アライメントの取得

  #--------------------------------------------------------------------------

  def alignment

    return LNX11::PARTY_COMMAND_ALIGNMENT

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:横に項目が並ぶときの空白の幅を取得

  #--------------------------------------------------------------------------

  def spacing

    return 8

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:ウィンドウを開く

  #--------------------------------------------------------------------------

  def open

    super

    # 最後に選択したコマンドを選択

    return self unless LNX11::LAST_PARTY_COMMAND

    last_command = $game_party.last_party_command

    if last_command && @list.include?(last_command)

      select(@list.index(last_command))

    end

    self

  end

  #--------------------------------------------------------------------------

  # ● [エイリアス]:ウィンドウを閉じる

  #--------------------------------------------------------------------------

  def close

    super

    # 選択したコマンドを記憶

    $game_party.last_party_command = @list[index] if index >= 0

    self

  end

end

 

#==============================================================================

# ■ Window_ActorCommand

#------------------------------------------------------------------------------

#  バトル画面で、アクターの行動を選択するウィンドウです。

#==============================================================================

 

class Window_ActorCommand < Window_Command

  include LNX11_Window_ActiveVisible

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:ウィンドウ幅の取得

  #--------------------------------------------------------------------------

  def window_width

    return LNX11::ACTOR_COMMAND_WIDTH

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:表示行数の取得

  #--------------------------------------------------------------------------

  def visible_line_number

    list_size = LNX11::ACTOR_COMMAND_NOSCROLL ? @list.size : 4

    return LNX11::ACTOR_COMMAND_HORIZON ? 1 : list_size

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:桁数の取得

  #--------------------------------------------------------------------------

  def col_max

    return LNX11::ACTOR_COMMAND_HORIZON ? [@list.size, 1].max :  1

  end 

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:アライメントの取得

  #--------------------------------------------------------------------------

  def alignment

    return LNX11::ACTOR_COMMAND_ALIGNMENT

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:横に項目が並ぶときの空白の幅を取得

  #--------------------------------------------------------------------------

  def spacing

    return 8

  end

  #--------------------------------------------------------------------------

  # ● [追加]:X 座標をアクターに合わせる

  #--------------------------------------------------------------------------

  def actor_x(actor)

    ax = $game_party.members_screen_x_nooffset[actor.index] - self.width / 2

    pad = LNX11::STATUS_SIDE_PADDING / 2

    # 画面内に収める

    self.x = [[ax, pad].max, Graphics.width - pad - self.width].min

    self.x += LNX11::ACTOR_COMMAND_OFFSET[:x]

  end

  #--------------------------------------------------------------------------

  # ● [追加]:Y 座標をアクターに合わせる

  #--------------------------------------------------------------------------

  def actor_y(actor)

    self.y = actor.screen_y_top - self.height

    self.y += LNX11::ACTOR_COMMAND_OFFSET[:y]

  end

  #--------------------------------------------------------------------------

  # ● [追加]:固定 Y 座標

  #--------------------------------------------------------------------------

  def screen_y

    if LNX11::ACTOR_COMMAND_Y_POSITION == 0

      self.y = Graphics.height - self.height + LNX11::ACTOR_COMMAND_OFFSET[:y]

    else

      self.y = LNX11::ACTOR_COMMAND_OFFSET[:y]

    end

  end

  #--------------------------------------------------------------------------

  # ● [エイリアス]:セットアップ

  #--------------------------------------------------------------------------

  alias :lnx11a_setup :setup

  def setup(actor)

    # 前のアクターのコマンドを記憶

    @actor.last_actor_command = @list[index] if @actor

    # 元のメソッドを呼ぶ

    lnx11a_setup(actor)

    self.arrows_visible = !LNX11::ACTOR_COMMAND_NOSCROLL

    self.height = window_height

    self.oy = 0

    # アクターコマンドの表示位置で分岐

    case LNX11::ACTOR_COMMAND_POSITION

    when 0

      # アクターの頭上

      actor_x(actor)

      actor_y(actor)

    when 1

      # Y 座標固定

      actor_x(actor)

      screen_y

    when 2

      # XY固定

      self.x = LNX11::ACTOR_COMMAND_OFFSET[:x]

      screen_y

    end

    # 最後に選択したコマンドを選択

    return unless LNX11::LAST_ACTOR_COMMAND

    last_command = @actor.last_actor_command

    if last_command && @list.include?(last_command)

      select(@list.index(last_command))

    end

  end

end

 

#==============================================================================

# ■ Window_BattleStatus

#------------------------------------------------------------------------------

#  バトル画面で、パーティメンバーのステータスを表示するウィンドウです。

#==============================================================================

 

class Window_BattleStatus < Window_Selectable

  #--------------------------------------------------------------------------

  # ● [追加]:公開インスタンス変数

  #--------------------------------------------------------------------------

  attr_reader :min_offset   # ステータス描画 X 座標の位置修正

  #--------------------------------------------------------------------------

  # ● [エイリアス]:オブジェクト初期化

  #--------------------------------------------------------------------------

  alias :lnx11a_initialize :initialize

  def initialize

    @actor_last_status = Array.new($game_party.max_battle_members) { nil }    

    # 元のメソッドを呼ぶ

    lnx11a_initialize

    # ウィンドウを最初から表示

    self.openness = 255

    self.opacity = 0

    update_invisible

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:行の高さを取得

  #--------------------------------------------------------------------------

  def line_height

    return LNX11::STATUS_LINE_HEIGHT

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:標準パディングサイズの取得

  #--------------------------------------------------------------------------

  def standard_padding

    return 0

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:表示行数の取得

  #--------------------------------------------------------------------------

  def visible_line_number

    return $data_system.opt_display_tp ? 4 : 3

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:桁数の取得

  #--------------------------------------------------------------------------

  def col_max

    return [item_max, 1].max

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:横に項目が並ぶときの空白の幅を取得

  #--------------------------------------------------------------------------

  def spacing

    return 0

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:項目の高さを取得

  #--------------------------------------------------------------------------

  def item_height

    self.height

  end  

  #--------------------------------------------------------------------------

  # ● [再定義]:ウィンドウ幅の取得

  #--------------------------------------------------------------------------

  def window_width

    Graphics.width

  end

  #--------------------------------------------------------------------------

  # ● [エイリアス]:ウィンドウ高さの取得

  #--------------------------------------------------------------------------

  alias :lnx11a_window_height :window_height

  def window_height

    # 一行目(名前・ステート)の高さを確保する

    lnx11a_window_height - line_height + [24, line_height].max

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:カーソルの更新

  #--------------------------------------------------------------------------

  def update_cursor

    # カーソルを表示しない

    cursor_rect.empty

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:システム色の取得

  #  ゲージ幅が短すぎる場合、HP,MP,TP の文字を非表示にします。

  #--------------------------------------------------------------------------

  def system_color

    gauge_area_width - @min_offset >= 52 ? super : Color.new

  end  

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:ゲージ背景色の取得

  #   ゲージの透明度を適用します。  

  #--------------------------------------------------------------------------

  def gauge_back_color

    color = super

    color.alpha *= LNX11::STATUS_GAUGE_OPACITY / 255.0

    color

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:ゲージの描画

  #   ゲージの透明度を適用します。

  #--------------------------------------------------------------------------

  def draw_gauge(x, y, width, rate, color1, color2)

    oparate = LNX11::STATUS_GAUGE_OPACITY / 255.0

    color1.alpha *= oparate

    color2.alpha *= oparate

    super

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:フレーム更新

  #--------------------------------------------------------------------------

  def update

    super

    update_invisible

  end

  #--------------------------------------------------------------------------

  # ● [追加]:表示状態更新

  #--------------------------------------------------------------------------

  def update_invisible

    self.contents_opacity = $game_party.status_invisible ? 0 : 255

  end  

  #--------------------------------------------------------------------------

  # ● [追加]:アクターオブジェクト取得

  #--------------------------------------------------------------------------

  def actor

    $game_party.members[@index]

  end

  #--------------------------------------------------------------------------

  # ● [追加]:座標の設定

  #--------------------------------------------------------------------------

  def set_xy

    # ステータス位置の調整:画面からはみ出ないようにする

    pw = $game_party.members_screen_x.last + LNX11::STATUS_OFFSET[:x]

    pw += gauge_area_width / 2

    right_end = Graphics.width - LNX11::STATUS_SIDE_PADDING

    min_offset = pw > right_end ? pw - right_end : 0

    # ステータスのオフセットを適用

    self.x = LNX11::STATUS_OFFSET[:x] - min_offset

    self.y = LNX11::STATUS_OFFSET[:y] + Graphics.height - self.height

    # ステータス幅の自動調整:位置を調整した分だけ幅を縮める

    @min_offset = LNX11::STATUS_AUTOADJUST ? min_offset : 0

  end

  #--------------------------------------------------------------------------

  # ● [再定義]:ゲージエリアの幅を取得

  #--------------------------------------------------------------------------

  def gauge_area_width

    return LNX11::STATUS_WIDTH

  end

  #--------------------------------------------------------------------------

  # ● [追加]:表示するステート数の取得

  #--------------------------------------------------------------------------

  def states(actor, width)

    icons = (actor.state_icons + actor.buff_icons)[0, width / 24]

    icons.size

  end

  #--------------------------------------------------------------------------

  # ● [追加]:名前とステートの描画(1行表示)

  #  width の範囲で名前を左揃え、ステートアイコンを右揃えで描画します。

  # ステートを優先して表示するため、アイコンが多すぎて名前の表示領域が

  # 極端に狭くなる場合は名前を描画しません。

  #--------------------------------------------------------------------------

  def draw_actor_name_with_icons(actor, x, y, width = 128, draw_name = true)

    # アイコンのY座標補正

    iy = ([line_height, 24].max - 24) / 2

    # 名前のY座標補正

    ny = ([line_height, 24].max - LNX11::STATUS_NAME_SIZE) / 2

    # 表示するステート数を取得

    icon = states(actor, width)

    if icon > 0

      # 表示するべきステートがある場合

      name_width = width - icon * 24

      ix = x + width - icon * 24

      if name_width >= contents.font.size * 2 && draw_name

        # 名前の表示領域(width) が フォントサイズ * 2 以上なら両方を描画

        draw_actor_name(actor, x, y + ny,  name_width)

        iw = width - name_width

        draw_actor_icons(actor, ix, y + iy, iw)

      else

        # ステートのみ描画

        draw_actor_icons(actor, ix, y + iy, width)

      end

    elsif draw_name

      # ない場合、名前のみ描画

      draw_actor_name(actor, x, y + ny, width)

    end

  end

  #--------------------------------------------------------------------------

  # ● [再定義]:リフレッシュ

  #--------------------------------------------------------------------------

  def refresh

    set_xy

    draw_all_items

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:項目を描画する矩形の取得

  #--------------------------------------------------------------------------

  def item_rect(index)

    rect = super

    rect.x = $game_party.members_screen_x[index] - gauge_area_width / 2

    rect.width = gauge_area_width

    rect

  end

  #--------------------------------------------------------------------------

  # ● [再定義]:基本エリアの矩形を取得

  #--------------------------------------------------------------------------

  def basic_area_rect(index)

    rect = item_rect(index)

    rect

  end

  #--------------------------------------------------------------------------

  # ● [再定義]:ゲージエリアの矩形を取得

  #--------------------------------------------------------------------------

  def gauge_area_rect(index)

    rect = basic_area_rect(index)

    rect.y += [24, line_height].max

    rect.x += @min_offset

    rect

  end

  #--------------------------------------------------------------------------

  # ● [再定義]:基本エリアの描画

  #--------------------------------------------------------------------------

  def draw_basic_area(rect, actor)

    # フォントサイズ変更

    contents.font.size = [LNX11::STATUS_NAME_SIZE, 8].max

    # 名前とステートを描画

    dn = LNX11::STATUS_NAME_SIZE > 0 # 名前を描画するか?

    width = gauge_area_width - @min_offset

    rest  = width % 24

    width += 24 - rest if rest > 0

    draw_actor_name_with_icons(actor, rect.x, rect.y, width, dn)

    # フォントサイズを元に戻す

    reset_font_settings

  end

  #--------------------------------------------------------------------------

  # ● [エイリアス]:ゲージエリアの描画

  #--------------------------------------------------------------------------

  alias :lnx11a_draw_gauge_area :draw_gauge_area

  def draw_gauge_area(*args)

    # フォントサイズ変更

    contents.font.size = LNX11::STATUS_PARAM_SIZE

    # 元のメソッドを呼ぶ

    lnx11a_draw_gauge_area(*args)

    # フォントサイズを元に戻す

    reset_font_settings

  end

  #--------------------------------------------------------------------------

  # ● [再定義]:ゲージエリアの描画(TP あり)

  #--------------------------------------------------------------------------

  def draw_gauge_area_with_tp(rect, actor)

    width = gauge_area_width - @min_offset

    draw_actor_hp(actor, rect.x, rect.y,                   width)

    draw_actor_mp(actor, rect.x, rect.y + line_height,     width)

    draw_actor_tp(actor, rect.x, rect.y + line_height * 2, width)

  end

  #--------------------------------------------------------------------------

  # ● [再定義]:ゲージエリアの描画(TP なし)

  #--------------------------------------------------------------------------

  def draw_gauge_area_without_tp(rect, actor)

    draw_actor_hp(actor, rect.x, rect.y,               gauge_area_width)

    draw_actor_mp(actor, rect.x, rect.y + line_height, gauge_area_width)

  end

  #--------------------------------------------------------------------------

  # ● [再定義]:項目の描画

  #--------------------------------------------------------------------------

  def draw_item(index)

    actor = $game_party.battle_members[index]

    a_status = status(actor)

    # ステータスが変化した場合のみ描画する

    return if @actor_last_status[index] == a_status

    @actor_last_status[index] = a_status

    contents.clear_rect(item_rect(index))

    draw_basic_area(basic_area_rect(index), actor)

    draw_gauge_area(gauge_area_rect(index), actor)

  end

  #--------------------------------------------------------------------------

  # ● [追加]:アクターのステータス配列を返す

  #--------------------------------------------------------------------------

  def status(actor)

    if $data_system.opt_display_tp

      return [actor.name, actor.state_icons + actor.buff_icons,

              actor.mhp, actor.hp, actor.mmp, actor.mp, actor.max_tp, actor.tp]

    else

      # TP を除くステータス配列

      return [actor.name, actor.state_icons + actor.buff_icons,

              actor.mhp, actor.hp, actor.mmp, actor.mp]

    end

  end

  #--------------------------------------------------------------------------

  # ● [追加]:内容の消去

  #--------------------------------------------------------------------------

  def all_clear

    contents.clear

    @actor_last_status = Array.new($game_party.max_battle_members) { nil }    

  end

end

 

#==============================================================================

# ■ Window_BattleActor

#------------------------------------------------------------------------------

#  バトル画面で、行動対象のアクターを選択するウィンドウです。

# 選択機能だけを持つ不可視のウィンドウとして扱います。

#==============================================================================

 

class Window_BattleActor < Window_BattleStatus

  include LNX11_Window_TargetHelp

  #--------------------------------------------------------------------------

  # ● [エイリアス]:オブジェクト初期化

  #--------------------------------------------------------------------------

  alias :lnx11a_wba_initialize :initialize

  def initialize(info_viewport)

    # 元のメソッドを呼ぶ

    lnx11a_wba_initialize(info_viewport)

    # ウィンドウを画面外に移動

    self.y = Graphics.height

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:ヘルプテキスト更新

  #--------------------------------------------------------------------------

  def update_help

    @help_window.set_item(targetcursor)

  end

  #--------------------------------------------------------------------------

  # ● [追加]:ターゲットカーソルに渡すオブジェクト

  #--------------------------------------------------------------------------

  def targetcursor

    @cursor_all ? :party : actor

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:ウィンドウ幅の取得

  #--------------------------------------------------------------------------

  def window_width

    64

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:全項目の描画

  #--------------------------------------------------------------------------

  def draw_all_items

    # 何もしない    

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:項目の描画

  #--------------------------------------------------------------------------

  def draw_item(index)

    # 何もしない

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:リフレッシュ

  #--------------------------------------------------------------------------

  def refresh

    # 何もしない

  end

  #--------------------------------------------------------------------------

  # ● [エイリアス]:ウィンドウの表示

  #--------------------------------------------------------------------------

  alias :lnx11a_show :show

  def show

    # 元のメソッドを呼ぶ

    lnx11a_show

    # 最後に選択したアクターを選択

    last_target = $game_temp.last_target_cursor[:actor]

    if last_target && $game_party.members.include?(last_target) &&

       LNX11::LAST_TARGET

      select($game_party.members.index(last_target))

    end

    # スマートターゲットセレクト

    if LNX11::SMART_TARGET_SELECT && !@cursor_fix

      if @dead_friend && (!last_target || last_target && last_target.alive?)

        dead_actor = $game_party.dead_members[0]

        select($game_party.members.index(dead_actor)) if dead_actor

      elsif !@dead_friend && (!last_target || last_target && last_target.dead?)

        alive_actor = $game_party.alive_members[0]

        select($game_party.members.index(alive_actor)) if alive_actor

      end

    end

    self

  end

  #--------------------------------------------------------------------------

  # ● [エイリアス]:ウィンドウの非表示

  #--------------------------------------------------------------------------

  alias :lnx11a_hide :hide

  def hide

    # 元のメソッドを呼ぶ

    lnx11a_hide

    # 選択したアクターを記憶

    $game_temp.last_target_cursor[:actor] = actor

    self

  end

end

 

#==============================================================================

# ■ Window_BattleEnemy

#------------------------------------------------------------------------------

#  バトル画面で、行動対象の敵キャラを選択するウィンドウです。

# 横並びの不可視のウィンドウとして扱います。

#==============================================================================

 

class Window_BattleEnemy < Window_Selectable

  include LNX11_Window_TargetHelp

  #--------------------------------------------------------------------------

  # ● [エイリアス]:オブジェクト初期化

  #--------------------------------------------------------------------------

  alias :lnx11a_initialize :initialize

  def initialize(info_viewport)

    # 敵キャラオブジェクトの設定

    set_enemy

    # 元のメソッドを呼ぶ

    lnx11a_initialize(info_viewport)

    # ウィンドウを画面外に移動

    self.y = Graphics.height

  end

  #--------------------------------------------------------------------------

  # ● [追加]:敵キャラオブジェクトの設定

  #--------------------------------------------------------------------------

  def set_enemy

    if LNX11::TROOP_X_SORT

      @troop = $game_troop.alive_members.sort {|a,b| a.screen_x <=> b.screen_x}

    else

      @troop = $game_troop.alive_members

    end

  end

  #--------------------------------------------------------------------------

  # ● [再定義]:敵キャラオブジェクト取得

  #--------------------------------------------------------------------------

  def enemy

    @troop[@index]

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:ウィンドウ幅の取得

  #--------------------------------------------------------------------------

  def window_width

    64

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:指定行数に適合するウィンドウの高さを計算

  #--------------------------------------------------------------------------

  def fitting_height(line_number)

    super(1)

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:桁数の取得

  #--------------------------------------------------------------------------

  def col_max

    return item_max

  end

  #--------------------------------------------------------------------------

  # ● [オーバーライド]:ヘルプテキスト更新

  #--------------------------------------------------------------------------

  def update_help

    @help_window.random_number = @random_number

    @help_window.set_item(targetcursor)

  end

  #--------------------------------------------------------------------------

  # ● [追加]:ターゲットカーソルに渡すオブジェクト

  #--------------------------------------------------------------------------

  def targetcursor

    @cursor_all ? (@cursor_random ? :troop_random : :troop) : enemy

  end

  #--------------------------------------------------------------------------

  # ● [エイリアス]:ウィンドウの表示

  #--------------------------------------------------------------------------

  alias :lnx11a_show :show

  def show

    # 元のメソッドを呼ぶ

    lnx11a_show

    # 敵キャラオブジェクトの設定

    set_enemy

    return self unless LNX11::LAST_TARGET

    # 最後に選択した敵キャラを選択

    last_target = $game_temp.last_target_cursor[:enemy]

    if last_target && @troop.include?(last_target)

      select(@troop.index(last_target))

    end

    self

  end

  #--------------------------------------------------------------------------

  # ● [エイリアス]:ウィンドウの非表示

  #--------------------------------------------------------------------------

  alias :lnx11a_hide :hide

  def hide

    # 元のメソッドを呼ぶ

    lnx11a_hide

    # 選択した敵キャラを記憶

    $game_temp.last_target_cursor[:enemy] = enemy

    self

  end

end

 

#==============================================================================

# ■ Window_BattleSkill

#------------------------------------------------------------------------------

#  いくつかのモジュールをインクルードします。

#==============================================================================

 

class Window_BattleSkill < Window_SkillList

  include LNX11_Window_ActiveVisible

  include LNX11_Window_FittingList if LNX11::FITTING_LIST

end

 

#==============================================================================

# ■ Window_BattleItem

#------------------------------------------------------------------------------

#  いくつかのモジュールをインクルードします。

#==============================================================================

 

class Window_BattleItem < Window_ItemList

  include LNX11_Window_ActiveVisible

  include LNX11_Window_FittingList if LNX11::FITTING_LIST

end

# l:5608

 

 

 

 

 

 

 

 

 

           두번째 스크립트

 

 

 

 

 

 

 

 

 

===============================두번째 스크립트(BattleManager에 덮어씌우세요.)====================================

#==============================================================================

# ** BattleManager

#------------------------------------------------------------------------------

#  This module manages battle progress.

#==============================================================================

 

module BattleManager

  #--------------------------------------------------------------------------

  # * Setup

  #--------------------------------------------------------------------------

  def self.setup(troop_id, can_escape = true, can_lose = false)

    init_members

    $game_troop.setup(troop_id)

    @can_escape = can_escape

    @can_lose = can_lose

    make_escape_ratio

  end

  #--------------------------------------------------------------------------

  # * Initialize Member Variables

  #--------------------------------------------------------------------------

  def self.init_members

    @phase = :init              # Battle Progress Phase

    @can_escape = false         # Can Escape Flag

    @can_lose = false           # Can Lose Flag

    @event_proc = nil           # Event Callback

    @preemptive = false         # Preemptive Attack Flag

    @surprise = false           # Surprise Flag

    @actor_index = -1           # Actor for Which Command Is Being Entered

    @action_forced = nil        # Force Action

    @map_bgm = nil              # For Memorizing Pre-Battle BGM

    @map_bgs = nil              # For Memorizing Pre-Battle BGS

    @action_battlers = []       # Action Order List

  end

  #--------------------------------------------------------------------------

  # * Processing at Encounter Time

  #--------------------------------------------------------------------------

  def self.on_encounter

    @preemptive = (rand < rate_preemptive)

    @surprise = (rand < rate_surprise && !@preemptive)

  end

  #--------------------------------------------------------------------------

  # * Get Probability of Preemptive Attack

  #--------------------------------------------------------------------------

  def self.rate_preemptive

    $game_party.rate_preemptive($game_troop.agi)

  end

  #--------------------------------------------------------------------------

  # * Get Probability of Surprise

  #--------------------------------------------------------------------------

  def self.rate_surprise

    $game_party.rate_surprise($game_troop.agi)

  end

  #--------------------------------------------------------------------------

  # * Save BGM and BGS

  #--------------------------------------------------------------------------

  def self.save_bgm_and_bgs

    @map_bgm = RPG::BGM.last

    @map_bgs = RPG::BGS.last

  end

  #--------------------------------------------------------------------------

  # * Play Battle BGM

  #--------------------------------------------------------------------------

  def self.play_battle_bgm

    $game_system.battle_bgm.play

    RPG::BGS.stop

  end

  #--------------------------------------------------------------------------

  # * Play Battle End ME

  #--------------------------------------------------------------------------

  def self.play_battle_end_me

    $game_system.battle_end_me.play

  end

  #--------------------------------------------------------------------------

  # * Resume BGM and BGS

  #--------------------------------------------------------------------------

  def self.replay_bgm_and_bgs

    @map_bgm.replay unless $BTEST

    @map_bgs.replay unless $BTEST

  end

  #--------------------------------------------------------------------------

  # * Create Escape Success Probability

  #--------------------------------------------------------------------------

  def self.make_escape_ratio

    @escape_ratio = 1.5 - 1.0 * $game_troop.agi / $game_party.agi

  end

  #--------------------------------------------------------------------------

  # * Determine if Turn Is Executing

  #--------------------------------------------------------------------------

  def self.in_turn?

    @phase == :turn

  end

  #--------------------------------------------------------------------------

  # * Determine if Turn Is Ending

  #--------------------------------------------------------------------------

  def self.turn_end?

    @phase == :turn_end

  end

  #--------------------------------------------------------------------------

  # * Determine if Battle Is Aborting

  #--------------------------------------------------------------------------

  def self.aborting?

    @phase == :aborting

  end

  #--------------------------------------------------------------------------

  # * Get Whether Escape Is Possible

  #--------------------------------------------------------------------------

  def self.can_escape?

    @can_escape

  end

  #--------------------------------------------------------------------------

  # * Get Actor for Which Command Is Being Entered

  #--------------------------------------------------------------------------

  def self.actor

    @actor_index >= 0 ? $game_party.members[@actor_index] : nil

  end

  #--------------------------------------------------------------------------

  # * Clear Actor for Which Command Is Being Entered

  #--------------------------------------------------------------------------

  def self.clear_actor

    @actor_index = -1

  end

  #--------------------------------------------------------------------------

  # * To Next Command Input

  #--------------------------------------------------------------------------

  def self.next_command

    begin

      if !actor || !actor.next_command

        @actor_index += 1

        return false if @actor_index >= $game_party.members.size

      end

    end until actor.inputable?

    return true

  end

  #--------------------------------------------------------------------------

  # * To Previous Command Input

  #--------------------------------------------------------------------------

  def self.prior_command

    begin

      if !actor || !actor.prior_command

        @actor_index -= 1

        return false if @actor_index < 0

      end

    end until actor.inputable?

    return true

  end

  #--------------------------------------------------------------------------

  # * Set Proc for Callback to Event

  #--------------------------------------------------------------------------

  def self.event_proc=(proc)

    @event_proc = proc

  end

  #--------------------------------------------------------------------------

  # * Set Wait Method

  #--------------------------------------------------------------------------

  def self.method_wait_for_message=(method)

    @method_wait_for_message = method

  end

  #--------------------------------------------------------------------------

  # * Wait Until Message Display has Finished

  #--------------------------------------------------------------------------

  def self.wait_for_message

    @method_wait_for_message.call if @method_wait_for_message

  end

  #--------------------------------------------------------------------------

  # * Battle Start

  #--------------------------------------------------------------------------

  def self.battle_start

    $game_system.battle_count += 1

    $game_party.on_battle_start

    $game_troop.on_battle_start

    $game_troop.enemy_names.each do |name|

      $game_message.add(sprintf(Vocab::Emerge, name))

    end

    if @preemptive

      $game_message.add(sprintf(Vocab::Preemptive, $game_party.name))

    elsif @surprise

      $game_message.add(sprintf(Vocab::Surprise, $game_party.name))

    end

    wait_for_message

  end

  #--------------------------------------------------------------------------

  # * Battle Abort

  #--------------------------------------------------------------------------

  def self.abort

    @phase = :aborting

  end

  #--------------------------------------------------------------------------

  # * Determine Win/Loss Results

  #--------------------------------------------------------------------------

  def self.judge_win_loss

    if @phase

      return process_abort   if $game_party.members.empty?

      return process_defeat  if $game_party.all_dead?

      return process_victory if $game_troop.all_dead?

      return process_abort   if aborting?

    end

    return false

  end

  #--------------------------------------------------------------------------

  # * Victory Processing

  #--------------------------------------------------------------------------

  def self.process_victory

    play_battle_end_me

    replay_bgm_and_bgs

    $game_message.add(sprintf(Vocab::Victory, $game_party.name))

    display_exp

    gain_gold

    gain_drop_items

    gain_exp

    SceneManager.return

    battle_end(0)

    return true

  end

  #--------------------------------------------------------------------------

  # * Escape Processing

  #--------------------------------------------------------------------------

  def self.process_escape

    $game_message.add(sprintf(Vocab::EscapeStart, $game_party.name))

    success = @preemptive ? true : (rand < @escape_ratio)

    Sound.play_escape

    if success

      process_abort

    else

      @escape_ratio += 0.1

      $game_message.add('\.' + Vocab::EscapeFailure)

      $game_party.clear_actions

    end

    wait_for_message

    return success

  end

  #--------------------------------------------------------------------------

  # * Abort Processing

  #--------------------------------------------------------------------------

  def self.process_abort

    replay_bgm_and_bgs

    SceneManager.return

    battle_end(1)

    return true

  end

  #--------------------------------------------------------------------------

  # * Defeat Processing

  #--------------------------------------------------------------------------

  def self.process_defeat

    if @can_lose

      revive_battle_members

      replay_bgm_and_bgs

      SceneManager.return

    else

      SceneManager.goto(Scene_Gameover)

    end

    battle_end(2)

    return true

  end

  #--------------------------------------------------------------------------

  # * Revive Battle Members (When Defeated)

  #--------------------------------------------------------------------------

  def self.revive_battle_members

    $game_party.battle_members.each do |actor|

      actor.hp = 1 if actor.dead?

    end

  end

  #--------------------------------------------------------------------------

  # * End Battle 

  #     result : Result (0: Win 1: Escape 2: Lose)

  #--------------------------------------------------------------------------

  def self.battle_end(result)

    @phase = nil

    @event_proc.call(result) if @event_proc

    $game_party.on_battle_end

    $game_troop.on_battle_end

    SceneManager.exit if $BTEST

  end

  #--------------------------------------------------------------------------

  # * Start Command Input

  #--------------------------------------------------------------------------

  def self.input_start

    if @phase != :input

      @phase = :input

      $game_party.make_actions

      $game_troop.make_actions

      clear_actor

    end

    return !@surprise && $game_party.inputable?

  end

  #--------------------------------------------------------------------------

  # * Start Turn

  #--------------------------------------------------------------------------

  def self.turn_start

    @phase = :turn

    clear_actor

    $game_troop.increase_turn

    make_action_orders

  end

  #--------------------------------------------------------------------------

  # * End Turn

  #--------------------------------------------------------------------------

  def self.turn_end

    @phase = :turn_end

    @preemptive = false

    @surprise = false

  end

  #--------------------------------------------------------------------------

  # * Display EXP Earned

  #--------------------------------------------------------------------------

  def self.display_exp

    if $game_troop.exp_total > 0

      text = sprintf(Vocab::ObtainExp, $game_troop.exp_total)

      $game_message.add('\.' + text)

    end

  end

  #--------------------------------------------------------------------------

  # * Gold Acquisition and Display

  #--------------------------------------------------------------------------

  def self.gain_gold

    if $game_troop.gold_total > 0

      text = sprintf(Vocab::ObtainGold, $game_troop.gold_total)

      $game_message.add('\.' + text)

      $game_party.gain_gold($game_troop.gold_total)

    end

    wait_for_message

  end

  #--------------------------------------------------------------------------

  # * Dropped Item Acquisition and Display

  #--------------------------------------------------------------------------

  def self.gain_drop_items

    $game_troop.make_drop_items.each do |item|

      $game_party.gain_item(item, 1)

      $game_message.add(sprintf(Vocab::ObtainItem, item.name))

    end

    wait_for_message

  end

  #--------------------------------------------------------------------------

  # * EXP Acquisition and Level Up Display

  #--------------------------------------------------------------------------

  def self.gain_exp

    $game_party.all_members.each do |actor|

      actor.gain_exp($game_troop.exp_total)

    end

    wait_for_message

  end

  #--------------------------------------------------------------------------

  # * Create Action Order

  #--------------------------------------------------------------------------

  def self.make_action_orders

    @action_battlers = []

    @action_battlers += $game_party.members unless @surprise

    @action_battlers += $game_troop.members unless @preemptive

    @action_battlers.each {|battler| battler.make_speed }

    @action_battlers.sort! {|a,b| b.speed - a.speed }

  end

  #--------------------------------------------------------------------------

  # * Force Action

  #--------------------------------------------------------------------------

  def self.force_action(battler)

    @action_forced = battler

    @action_battlers.delete(battler)

  end

  #--------------------------------------------------------------------------

  # * Get Forced State of Battle Action

  #--------------------------------------------------------------------------

  def self.action_forced?

    @action_forced != nil

  end

  #--------------------------------------------------------------------------

  # * Get Battler Subjected to Forced Action

  #--------------------------------------------------------------------------

  def self.action_forced_battler

    @action_forced

  end

  #--------------------------------------------------------------------------

  # * Clear Forcing of Battle Action

  #--------------------------------------------------------------------------

  def self.clear_action_force

    @action_forced = nil

  end

  #--------------------------------------------------------------------------

  # * Get Next Action Subject

  #    Get the battler from the beginning of the action order list.

  #    If an actor not currently in the party is obtained (occurs when index

  #    is nil, immediately after escaping in battle events etc.), skip them.

  #--------------------------------------------------------------------------

  def self.next_subject

    loop do

      battler = @action_battlers.shift

      return nil unless battler

      next unless battler.index && battler.alive?

      return battler

    end

  end

end

 


List of Articles
번호 분류 제목 글쓴이 날짜 조회 수
공지 스크립트 자료 게시물 작성시 주의사항 습작 2012.12.24 5109
공지 RPG VX ACE 유용한 링크 모음 16 아방스 2012.01.03 28921
217 HUD 화폐단위 표시 구분 5 file 허걱 2014.03.19 2938
216 이름입력 한글 이름입력창 23 file 에틴 2012.01.23 11679
215 메시지 한국어 조사처리 스크립트 7 Ilike게임 2012.10.09 3601
214 메시지 한국어 조사 처리 스크립트 (140130) 2 치리 2014.01.31 2647
213 메뉴 파티 개별 인벤토리 스크립트 안나카레리나 2018.06.25 738
212 메시지 텍스트 사운드 이펙트 ( Text Sound Effect ) 10 file 미루 2013.01.10 4281
211 타이틀/게임오버 타이틀 화면 없이 게임을 시작하게 만드는법. 6 마에르드 2012.02.11 4585
210 타이틀/게임오버 타이틀 스크린 커스터마이징 11 file 라실비아 2013.08.12 5153
209 키입력 키 입력 확장 - 전체키 + 마우스입력 40 file 허걱 2012.12.15 5779
208 기타 크리스탈 엔진 : 포켓몬 배틀 시스템 7 file 스리아씨 2013.09.24 3894
207 전투 콤보 카운팅 시스템 4 아르피쥐 2011.12.18 4589
206 타이틀/게임오버 코아 코스튬씨의 랜덤 타이틀 출력 스크립트를 VX Ace용으로 변환 (테스트용) 1 Alkaid 2011.12.29 3189
205 타이틀/게임오버 코아 코스튬씨의 랜덤 타이틀 스크립트를 VX Ace용으로 변환 (완성판) 2 Alkaid 2012.01.25 3980
204 그래픽 커스텀 아이콘 적용하기 2 file 간로 2015.09.28 2719
203 직업 직업 경험치+능력치 설정 확장 7 file zubako 2015.01.27 3988
202 이동 및 탈것 지상 탈것 스크립트 6 file 미루 2013.01.07 4579
201 전투 전투시 나오는 메세지 삭제 10 Nintendo 2012.03.03 4357
200 이름입력 전체키 + 조합한글 + 이름입력처리 변경 47 file 허걱 2012.07.04 8197
199 메뉴 저장금지시 메뉴에 저장 안 뜨게 하기 5 file Bunny_Boy 2013.08.24 2519
198 장비 장비 장착을 통한 스킬 습득 및 삭제 4 아이미르 2012.02.05 3597
Board Pagination Prev 1 2 3 4 5 6 7 8 9 10 11 Next
/ 11