아방스 - LNX11 전투 RPGXP 전투처럼 만들기

이 스크립트를 사용하면 전투화면을 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

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

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

# ● バトルログプッシュ

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

# 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

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

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

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

# ■ [追加]: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

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

# ● リフレッシュ

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

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

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

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

# 　バトルログタイプが [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

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

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

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

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

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

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

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

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

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

# ● 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

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

# ■ [追加]: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

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

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

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

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

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

@@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

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

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

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

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

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

# popup_xxxxxx_(large or small)

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

end

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

# ■ [追加]:Sprite_PopupSpring

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

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

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

class Sprite_PopupSpring < Sprite_PopupBase

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

# ● ポップアップ Z 座標

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

def base_z

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

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

# ● 終了処理

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

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

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

# ■ [追加]:Sprite_PopupRising

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

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

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

class Sprite_PopupRising < Sprite_PopupBase

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

# ● ポップアップ Z 座標

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

def base_z

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

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

# ■ [追加]:Sprite_PopupSliding

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

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

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

class Sprite_PopupSliding < Sprite_PopupBase

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

# ● ポップアップ Z 座標

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

def base_z

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

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

# ■ [追加]:Sprite_PopupOverlay

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

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

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

class Sprite_PopupOverlay < Sprite_PopupBase

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

# ● ポップアップ Z 座標

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

def base_z

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

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

# ■ [追加]:Sprite_PopupLevelUp

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

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

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

class Sprite_PopupLevelUp < Sprite_PopupSliding

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

# ● ポップアップ Z 座標

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

def base_z

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

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

# ● フレーム更新

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

def update_popup

super

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

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

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

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

# ■ [追加]: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

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

# ● サブカーソル解放

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

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

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

# ● カーソルの表示

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

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

@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

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

# ■ [追加]: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

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

# ■ 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

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

# ● [再定義]:背景スプライトの解放

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

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

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

# ● [追加]:メッセージスプライトの作成

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

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

# ログの自動進行

@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

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

# ● [エイリアス]:指定した行に戻る

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

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

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

# ● [エイリアス]:ウェイト

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

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

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

# ■ 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

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

# ■ 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

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

# ■ 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

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

# ■ 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

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

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

# ■ 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

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

# ■ 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

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

# ■ 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

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

# ■ 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

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

# ■ 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

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

# ■ 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

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

# ● [追加]:グラフィック設定の配列を返す

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

def graphic_name_index

case LNX11::DEFAULT_BATTLER_GRAPHIC

when 0 ; [@face_name, @face_index]

when 1 ; [@character_name, @character_index]

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

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

# ● [追加]:バトラーグラフィックの更新

# 　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

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

# ■ Game_Enemy

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

# 　敵キャラを扱うクラスです。

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

class Game_Enemy < Game_Battler

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

# ● [追加]:バトルメンバー判定

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

def battle_member?

true

end

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

# ● [追加]:通常攻撃アニメーション ID の取得

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

def atk_animation

# メモを参照

enemy.atk_animation

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

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

# ● [追加]:バトル画面 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

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

# ■ 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

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

# ● [エイリアス]:敵キャラ名の配列取得

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

alias :lnx11a_enemy_names :enemy_names

def enemy_names

LNX11::MESSAGE_WINDOW_ENEMY_NAMES ? lnx11a_enemy_names : []

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

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

# ● [追加]:テキスト追加の禁止

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

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

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

# ■ 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

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

# ● [追加]:対象選択フラッシュの終了

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

def end_cursor_effect

if [:target_whiten, :command_whiten].include?(@effect_type)

@effect_type = nil

@effect_duration = 0

revert_to_normal

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

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

# ● [エイリアス]:転送元ビットマップの更新

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

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

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

# ● [エイリアス]:新しいアニメーションの設定

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

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

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

# ● [エイリアス]:新しいエフェクトの設定

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

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

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

# ● [エイリアス]:エフェクトの開始

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

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

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

# ● ループアニメーションの追加

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

# ● [追加]:クラス変数

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

@@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

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

# ● [追加]:ループアニメーションの速度を設定

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

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

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

# ● [追加]:ループアニメーショングラフィックの読み込み

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

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

@loop_ani_duplicated = @@loop_ani_checker.include?(@loop_animation)

if !@loop_ani_duplicated && @loop_animation.position == 3

@@loop_ani_checker.push(@loop_animation)

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

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

# ● [追加]:ループアニメーションの解放

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

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

if @loop_ani_bitmap2

@@_reference_count[@loop_ani_bitmap2] -= 1

if @@_reference_count[@loop_ani_bitmap2] == 0

@loop_ani_bitmap2.dispose

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

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

# ● [追加]:ループアニメーションの終了

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

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

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

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

# ● [追加]: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

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

# ■ 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

@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

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

# ● [再定義]:アクタースプライトの更新

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

def update_actors

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

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

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

# ● [エイリアス]:全ウィンドウの作成

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

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

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

# ● [追加]:ターゲットカーソル更新

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

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

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

# ● [エイリアス]:コマンド［防御］

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

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

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

# ● [エイリアス]:アクター選択の開始

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

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

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

# ● [エイリアス]:攻撃アニメーションの表示

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

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

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

# ■ 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

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

# ■ 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

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

# ■ 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

# 戦闘不能の味方が対象か？

@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

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

# ■ [追加]: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','０-９')

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

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

# ● 選択対象の情報の描画

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

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

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

# ● ターゲットの名前描画

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

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

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

# ● アイテムの描画(中央揃え)

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

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

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

# ■ 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

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

# ■ 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

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

# ● [エイリアス]:セットアップ

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

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

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

# ■ 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

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

# ● [再定義]:リフレッシュ

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

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

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

# ● [追加]:内容の消去

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

def all_clear

contents.clear

@actor_last_status = Array.new($game_party.max_battle_members) { nil }

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

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

self

end

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

# ● [エイリアス]:ウィンドウの非表示

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

alias :lnx11a_hide :hide

def hide

# 元のメソッドを呼ぶ

lnx11a_hide

# 選択したアクターを記憶

$game_temp.last_target_cursor[:actor] = actor

self

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

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

# ● [再定義]:敵キャラオブジェクト取得

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

def enemy

@troop[@index]

end

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

# ● [オーバーライド]:ウィンドウ幅の取得

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

def window_width

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

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

# ■ 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 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

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

# * 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

번호	분류	제목	글쓴이	날짜	조회 수
공지		스크립트 자료 게시물 작성시 주의사항	습작	2012.12.24	5109
공지		RPG VX ACE 유용한 링크 모음 16	아방스	2012.01.03	28923
217	그래픽	셰이크 강화 스크립트	시낵스	2023.12.13	92
216	오디오	볼륨변경 스크립트	레기우스州	2020.08.09	504
»	전투	LNX11 전투 RPGXP 전투처럼 만들기	큔.	2018.11.23	1443
214	온라인	브라우저 열기 스크립트 1	큔.	2018.09.09	671
213	타이틀/게임오버	GG침 스크립트	큔.	2018.07.18	835
212	메뉴	파티 개별 인벤토리 스크립트	안나카레리나	2018.06.25	738
211	전투	기본전투의 커스텀 명중률 제작	안나카레리나	2018.06.10	543
210	기타	LUD Script Package	LuD	2017.08.15	1079
209	맵/타일	레이어 맵 <layer> 기능 2	LuD	2017.08.03	1469
208	HUD	아이템 레어리티 스크립트 (번역기 돌림) 2	부초	2017.07.21	1424
207	기타	(링크)RPG VX ACE 블랙잭 스크립트	게임애호가	2017.06.18	1002
206	전투	SPRG 컨버터 NEXT 1	게임애호가	2016.06.09	1905
205	전투	Tomoaky's RGSS3_SRPG ver.0.15a 한국어번역 3	초코빙수	2016.06.05	2071
204	맵/타일	Map Zoom Ace by MGC	습작	2016.02.28	1015
203	메시지	Item Choice Help Window for Ace 2	습작	2016.02.15	1379
202	기타	'결정 키로 이벤트 시작' 조건분기 추가	Bunny_Boy	2016.01.16	1165
201	그래픽	커스텀 아이콘 적용하기 2	간로	2015.09.28	2721
200	버그픽스	RGSS3 Unofficial Bug Fix Snippets	Alkaid	2015.09.09	662
199	이동 및 탈것	Khas Pathfinder(길찾기 스크립트) 15	찬잎	2015.07.10	1961
198	메시지	아이템 정보 메세지가 뜨는 아이템 획득 1	폴라	2015.05.21	2202