1032 lines
No EOL
58 KiB
Ruby
1032 lines
No EOL
58 KiB
Ruby
#==============================================================================
|
||
# ■ イベント起動判定拡張 (VX Ace用)
|
||
#------------------------------------------------------------------------------
|
||
# 製作者 : CanariAlternate
|
||
# サイト名 : カルトの鳥篭
|
||
# サイトURL : http://canarialt.blog.fc2.com
|
||
#------------------------------------------------------------------------------
|
||
# ■ 概要 : イベントが接触したイベントを起動する。トリガーを拡張する。
|
||
#
|
||
# ■ 必須 : 「注釈取得スクリプト」
|
||
# 「共有変数スクリプト」
|
||
#
|
||
# ■ 位置 : 「注釈取得スクリプト」より下
|
||
# 「フィールド並行戦闘」より下
|
||
#------------------------------------------------------------------------------
|
||
# ■ 機能 : イベントが接触したイベントを起動する。
|
||
# トリガーを拡張する。
|
||
# プレイヤーを擬似イベント化する。
|
||
#
|
||
# ■ スクリプト(イベントコマンド) :
|
||
# get_invoker #=> イベントを起動した実行者(イベント又はプレイヤー)のIDを取得
|
||
# ※プレイヤーのIDは -1 です。
|
||
#
|
||
# start_player? #=> イベントを起動した実行者はプレイヤーか判定
|
||
#
|
||
# multiple_starts? #=> イベントが多重起動されているか判定
|
||
# ※多重起動されてない場合は false
|
||
# ※多重起動されている場合は 起動人数を返す。
|
||
#
|
||
# event_running? #=> イベントが他のイベントを実行中か判定
|
||
#
|
||
# ■ スクリプト(移動ルートの設定)
|
||
# check_action_event #=> 決定ボタンを押した時と同様の起動判定を実行
|
||
#------------------------------------------------------------------------------
|
||
# ■ 仕様 : イベントが起動したイベントは並列処理で実行されます。
|
||
# イベント実行中は実行した方もされた方も自律移動を停止します。
|
||
# イベントページが変わってもイベントは中断されません。
|
||
# ※マップを移動した場合は中断される。
|
||
#
|
||
# １つのイベントは他のイベントを１つ起動できます。
|
||
# A,B,C,Dの４つのイベントそれぞれがEのイベントを起動すると
|
||
# Eのイベントは同時に４つ並列処理されることになります。
|
||
# ※なので重複実行と途中中断を前提としたイベントの実行内容を推奨
|
||
#
|
||
# イベント同士ではトリガーの設定は無視します。
|
||
# プレイヤーがイベントを起動する際はトリガーで判定します。
|
||
#
|
||
# すり抜けがonで且つプライオリティが「通常キャラと同じ」のイベントを
|
||
# 決定キーや接触によって起動することは出来なくなります。
|
||
# ※自動実行や並列処理は通常通り起動します。
|
||
# ※既に起動しているイベントがこの仕様によって実行を中断されたりすることはありません。
|
||
#------------------------------------------------------------------------------
|
||
# 更新履歴 : 2012/09/09 Ver1.00 初期型が完成
|
||
# 2012/09/11 Ver1.01 機能の拡張とモジュールで設定できるように変更
|
||
# 2012/09/13 Ver1.02 主人公にコモンイベントを割り当て機能を実装
|
||
# 2012/09/14 Ver1.03 機能・仕様・設定などの説明をとりあえず記述完了
|
||
# 2012/09/15 Ver1.04 Interpreterで実行者を記憶する変数を識別するハッシュをシンボルに変更
|
||
# 多重起動の取得で起動予定が含まれていたのを含まないように修正
|
||
# 説明に具体例を加えて解り易くなった？
|
||
# 2012/09/22 Ver1.05 他のスクリプトと注釈取得処理を統一した。
|
||
# それにより注釈での設定方法が仕様変更された。
|
||
# 2012/09/26 Ver1.06 注釈の取得処理を改良した。
|
||
# 2012/10/07 Ver1.07 コードを整理した。
|
||
# 2012/10/08 Ver1.08 説明を思い切って大幅カット。コードの整理。
|
||
# 2012/11/04 Ver1.09 起動判定の追加用のメソッドを追加
|
||
# 2012/12/30 Ver1.10 Ver1.09での改悪を修正した。
|
||
# 2013/02/19 Ver1.11 共通処理スクリプトの廃止による変更を施した。
|
||
# 2013/04/08 Ver1.12 カウンター越しにイベントを起動できないバグを修正した。
|
||
# 2013/07/21 Ver1.13 説明文を修正した。
|
||
#==============================================================================
|
||
|
||
$imported ||= {}
|
||
$imported[:CanariAlternate_EventEveryone] = true
|
||
|
||
#==============================================================================
|
||
# ■ Calt
|
||
#------------------------------------------------------------------------------
|
||
# CanariAlternateが製作したスクリプト用のモジュールです。
|
||
#==============================================================================
|
||
module Calt
|
||
#-----------------------------------------------------------------------------
|
||
# ◆イベントが接触したイベントを起動
|
||
# ①自分から接触した時に相手のイベントを起動
|
||
EVENT_START_FROM_ME_NOTE = /\[相手を起動\]/ # 記述した頁に適用
|
||
EVENT_START_FROM_ME_ALL_NOTE = /\<相手を起動\>/ # 全ての頁に適用(1頁目に記述)
|
||
EVENT_START_FROM_ME_REVERSE = false # 全てのイベントの初期状態を反転
|
||
#
|
||
# ①によって起動されることを許可
|
||
EVENT_TO_OTHERS_NOTE = /\[起動対象\]/ # 記述した頁に適用
|
||
EVENT_TO_OTHERS_ALL_NOTE = /\<起動対象\>/ # 全ての頁に適用(1頁目に記述)
|
||
EVENT_TO_OTHERS_REVERSE = false # 全てのイベントの初期状態を反転
|
||
#
|
||
# ②自分から接触した時に自分のイベントを起動させる(仕様上は相手に起動されたという扱い)
|
||
EVENT_START_TO_ME_NOTE = /\[自分を起動\]/ # 記述した頁に適用
|
||
EVENT_START_TO_ME_ALL_NOTE = /\<自分を起動\>/ # 全ての頁に適用(1頁目に記述)
|
||
EVENT_START_TO_ME_REVERSE = false # 全てのイベントの初期状態を反転
|
||
#
|
||
# ②によって起動させられることを許可
|
||
EVENT_FROM_OTHERS_NOTE = /\[起動触媒\]/ # 記述した頁に適用
|
||
EVENT_FROM_OTHERS_ALL_NOTE = /\<起動触媒\>/ # 全ての頁に適用(1頁目に記述)
|
||
EVENT_FROM_OTHERS_REVERSE = false # 全てのイベントの初期状態を反転
|
||
#
|
||
#
|
||
# ◆起動時の向き変更禁止
|
||
# イベントを起動した実行者(プレイヤーまたはイベント)の方を向くのを禁止
|
||
EVENT_LOCK_DIRECTION = /\[起動時の向き変更禁止\]/ # 記述した頁に適用
|
||
EVENT_LOCK_DIRECTION_ALL = /\<起動時の向き変更禁止\>/ # 全ての頁に適用(1頁目に記述)
|
||
EVENT_LOCK_DIRECTION_REVERSE = false # 全てのイベントの初期状態を反転
|
||
#
|
||
#
|
||
# ◆トリガーの拡張
|
||
# ■ 基本のトリガー
|
||
# 0: 決定ボタン
|
||
# 1: プレイヤーから接触(＆ 決定ボタン)
|
||
# 2: イベントから接触(＆ プレイヤーから接触 ＆ 決定ボタン)
|
||
# 3: 自動実行
|
||
# 4: 並列処理
|
||
# ■ 拡張したトリガー
|
||
# 5: イベントから接触 ＆ 決定ボタン
|
||
# 6: イベントから接触 ＆ プレイヤーから接触
|
||
# 7: イベントから接触
|
||
# 8: プレイヤーから接触
|
||
#
|
||
EVENT_TRIGGER_C_BUTTON_NOTE = /\[決定ボタン\]/ # 決定ボタン
|
||
EVENT_TRIGGER_PLAYER_NOTE = /\[プレイヤーから接触\]/ # プレイヤーから接触
|
||
EVENT_TRIGGER_EVENT_NOTE = /\[イベントから接触\]/ # イベントから接触
|
||
# 以上の３つのキーワードを注釈に組み合わせて記述して指定します。
|
||
#
|
||
# 例 : 実行内容
|
||
# ◆注釈：[決定ボタン]
|
||
# ： ：[イベントから接触]
|
||
# ◆
|
||
# トリガーは イベントから接触 ＆ 決定ボタン になります。
|
||
# ※３つのキーワードの１つも記述しなかったら本来の設定が優先されます。
|
||
#
|
||
#-----------------------------------------------------------------------------
|
||
# ◆プレイヤーを擬似イベント化などの設定
|
||
# ※使用する予定がない場合は全部 0 にしておけば問題ない。
|
||
#
|
||
# 擬似イベントにする為に使うコモンイベントを指定するゲーム変数
|
||
# 設定が 0 : プレイヤーを擬似イベントにしません。
|
||
# 設定したゲーム変数の値を 0 : プレイヤーを擬似イベントにしません。
|
||
# 設定したゲーム変数の値を 7 : 7番のコモンイベントを割り当て
|
||
# 設定したゲーム変数の値を 63 : 63番のコモンイベントを割り当て
|
||
EVENT_ACTOR_EVENT_MIMIC = 0
|
||
#
|
||
# 決定ボタンでイベントを起動するのを禁止するか設定するスイッチ番号
|
||
# 設定が 0 : 無効(禁止しない)
|
||
# 設定したスイッチON : 有効
|
||
# 設定したスイッチOFF : 無効
|
||
EVENT_ACTOR_LOCK_C_BUTTON = 0
|
||
#
|
||
# プレイヤーからイベントに接触した時にイベントを起動するか設定するスイッチ番号
|
||
# 設定が 0 : 有効
|
||
# 設定したスイッチON : 有効
|
||
# 設定したスイッチOFF : 無効
|
||
EVENT_ACTOR_START_FROM_ME = 0
|
||
#
|
||
# プレイヤー(擬似イベント)をイベントによって起動されることを許可するか設定するスイッチ番号
|
||
# 設定が 0 : 無効
|
||
# 設定したスイッチON : 有効
|
||
# 設定したスイッチOFF : 無効
|
||
EVENT_ACTOR_TO_OTHERS = 0
|
||
#
|
||
# プレイヤーから接触した時にプレイヤー(擬似イベント)を起動させるか設定するスイッチ番号
|
||
# 設定が 0 : 無効
|
||
# 設定したスイッチON : 有効
|
||
# 設定したスイッチOFF : 無効
|
||
EVENT_ACTOR_START_TO_ME = 0
|
||
#
|
||
# イベントからプレイヤーに接触した時にイベントを起動するか設定するスイッチ番号
|
||
# 設定が 0 : 有効
|
||
# 設定したスイッチON : 有効
|
||
# 設定したスイッチOFF : 無効
|
||
EVENT_ACTOR_FROM_OTHERS = 0
|
||
#
|
||
# プレイヤー(擬似イベント)を起動時に向き変更を禁止するか設定するスイッチの番号
|
||
# 設定が 0 : 無効
|
||
# 設定したスイッチON : 有効
|
||
# 設定したスイッチOFF : 無効
|
||
EVENT_ACTOR_LOCK_DIRECTION = 0
|
||
#
|
||
# プレイヤーにトリガーを設定(現在は使用していません)
|
||
EVENT_ACTOR_TRIGGER = 0 # ※不要になったので現在は使用していない。
|
||
#-----------------------------------------------------------------------------
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Game_Character
|
||
#------------------------------------------------------------------------------
|
||
# 主に移動ルートなどの処理を追加したキャラクターのクラスです。Game_Player、
|
||
# Game_Follower、GameVehicle、Game_Event のスーパークラスとして使用されます。
|
||
#==============================================================================
|
||
class Game_Character < Game_CharacterBase
|
||
#--------------------------------------------------------------------------
|
||
# ● 定数
|
||
#--------------------------------------------------------------------------
|
||
TRIGGERS = [0,1,2,5,6,7,8] # 自動実行と並列処理を除く全てのトリガー
|
||
TRIGGERS_P = [ 1,2, 6, 8] # 自分から接触で相手を起動する #=> 相手のトリガーがプレイヤーから接触
|
||
TRIGGERS_E = [ 2,5,6,7 ] # 自分から接触で自分を起動させる #=> 自分のトリガーがイベントから接触
|
||
TRIGGERS_C = [0,1,2,5 ] # 決定ボタンで正面に居る相手を起動する #=> 相手のトリガーが決定ボタン(接触)
|
||
TRIGGERS_D = [0 ] # 決定ボタンで足元に居る相手を起動する #=> 相手のトリガーが決定ボタン(足元)
|
||
#--------------------------------------------------------------------------
|
||
# ● 公開インスタンス変数
|
||
#--------------------------------------------------------------------------
|
||
attr_accessor :start_from_me # ①自分から接触した時に相手を起動する
|
||
attr_accessor :to_others # ①によって起動されることを許可
|
||
attr_accessor :start_to_me # ②自分から接触した時に自分を起動させる(相手に起動されたという扱い)
|
||
attr_accessor :from_others # ②によって起動させられることを許可
|
||
attr_accessor :lock_direction # 起動された時に実行者の方を向くことを禁止
|
||
attr_accessor :invoker_event # このイベントを起動・実行中のイベントを一時記憶
|
||
attr_reader :invoker_events # このイベントを実行中のイベントを記憶する配列
|
||
attr_reader :license # イベントのページが変更されて無い事を証明する為の値
|
||
#--------------------------------------------------------------------------
|
||
# ● 公開メンバ変数の初期化 [追加]
|
||
#--------------------------------------------------------------------------
|
||
alias init_public_members_EventEveryone_Character init_public_members
|
||
def init_public_members
|
||
init_public_members_EventEveryone_Character
|
||
@start_from_me = false
|
||
@to_others = false
|
||
@start_to_me = false
|
||
@from_others = false
|
||
@lock_direction = false
|
||
@invoker_event = nil
|
||
@invoker_events = []
|
||
@license = 0
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ①自分から接触した時に相手を起動するか判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def start_from_me? ; return @start_from_me ; end
|
||
#--------------------------------------------------------------------------
|
||
# ● ①によって起動されることを許可するか判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def to_others? ; return @to_others ; end
|
||
#--------------------------------------------------------------------------
|
||
# ● ②自分から接触した時に自分を起動させるか判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def start_to_me? ; return @start_to_me ; end
|
||
#--------------------------------------------------------------------------
|
||
# ● ②によって起動させられることを許可するか判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def from_others? ; return @from_others ; end
|
||
#--------------------------------------------------------------------------
|
||
# ● 起動された時に実行者の方を向くことを禁止か判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def lock_direction? ; return @lock_direction ; end
|
||
#--------------------------------------------------------------------------
|
||
# ● このイベントを実行中の人数を取得 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def invoker_events_size
|
||
size = @invoker_events.size
|
||
@invoker_events.each do |data|
|
||
# イベント実行者ロックキーか予約キーなら人数に含めない
|
||
size -= 1 if lock_key?(data) || reserve_key?(data)
|
||
end
|
||
return size
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● このイベントがイベントを実行中か判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def running_interpreter? ; return false ; end
|
||
#--------------------------------------------------------------------------
|
||
# ● イベントリストの取得 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def get_list ; return nil ; end
|
||
#--------------------------------------------------------------------------
|
||
# ● 起動中フラグのセット [新規]
|
||
#--------------------------------------------------------------------------
|
||
def set_starting ; return false ; end
|
||
#--------------------------------------------------------------------------
|
||
# ● 指定されたトリガーのいずれかか否かを判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def trigger_in?(triggers) ; return true ; end
|
||
#--------------------------------------------------------------------------
|
||
# ● 通常キャラですり抜け状態かを判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def normal_priority_through? ; return normal_priority? && @through ; end
|
||
#--------------------------------------------------------------------------
|
||
# ● イベント実行者ロックキーを生成 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def lock_key(invoker, event=self)
|
||
return [invoker, event] # [実行者, イベント]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● イベント実行者ロックキーか判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def lock_key?(key)
|
||
return false unless key.instance_of?(Array) # 配列でない
|
||
return key[1] != :reserve # 予約キーのシンボルではないかどうか
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 予約キーを生成 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def reserve_key(invoker)
|
||
return [invoker, :reserve] # [実行者, 予約キーのシンボル]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 予約キーか判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def reserve_key?(key)
|
||
return false unless key.instance_of?(Array) # 配列でない
|
||
return key[1] == :reserve # 予約キーのシンボルかどうか
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ロック解除の特殊処理キーを生成 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def unlock_key ; return :unlock_key ; end
|
||
#--------------------------------------------------------------------------
|
||
# ● ロック解除の特殊処理キーか判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def unlock_key?(key) ; return :unlock_key == key ; end
|
||
#--------------------------------------------------------------------------
|
||
# ● マップイベントの起動 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def start_map_event(x, y, triggers, normal)
|
||
return if running_interpreter? # このイベントはイベントを実行中
|
||
events = $game_map.events_xy(x, y)
|
||
events.unshift($game_player) if $game_player.pos?(x, y) # 先頭にプレイヤーを追加
|
||
events.each do |event|
|
||
next unless event.to_others? # ①によって起動されることを許可しない
|
||
next unless event.normal_priority? == normal
|
||
next if event.normal_priority_through? # すり抜け状態の通常キャラ
|
||
##next unless event.trigger_in?(triggers) # トリガーが一致しない
|
||
next if event == self # 起動するイベントと実行者(自分)が同一
|
||
event.invoker_event = self # 起動するイベントに実行者(自分)を一時記憶
|
||
event.start
|
||
if running_interpreter? # イベントの起動に成功
|
||
@move_succeed = true # 移動が成功したことにする(移動防止)
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 自分を起動 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def start_me(x, y, triggers, normal)
|
||
##return unless trigger_in?(triggers) # このイベントのトリガーが一致しない
|
||
$game_map.events_xy(x, y).each do |event|
|
||
next unless event.from_others? # ②によって起動させられることを許可しない
|
||
next unless event.normal_priority? == normal
|
||
next if event.normal_priority_through? # すり抜け状態の通常キャラ
|
||
next if event.running_interpreter? # 既にイベントを実行中
|
||
next if event == self # 自分と実行者が同一
|
||
@invoker_event = event # 自分に実行者を一時記憶
|
||
start # 自分を起動
|
||
if event.running_interpreter? # イベントの起動に成功
|
||
@move_succeed = true # 移動が成功したことにする(移動防止)
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● イベント起動 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def start
|
||
@invoker_event ||= $game_player # 明示されてない場合はプレイヤー
|
||
if @invoker_event == $game_player
|
||
# 実行者がプレイヤー
|
||
event_list = get_list # 実行内容を取得
|
||
unless !event_list || event_list.size <= 1 # 実行内容が有効
|
||
set_starting
|
||
lock if trigger_in?(TRIGGERS)
|
||
end
|
||
else
|
||
# 実行者がプレイヤーでない
|
||
event_list = get_list # 実行内容を取得
|
||
unless !event_list || event_list.size <= 1 # 実行内容が有効
|
||
# 実行内容が空ではない
|
||
@invoker_event.invoker_event = lock_key(@invoker_event) # 実行者にロックキーを一時記憶
|
||
@invoker_event.lock # 実行者をロック
|
||
unless @invoker_event.running_interpreter
|
||
# 実行者がイベントを実行中ではない
|
||
@invoker_event.running_set(event_list, @id, @invoker_event.id) # 実行者のインタプリタにイベントをセット
|
||
@invoker_event.run_eve_set(self, "xxx") # 実行者に起動したイベント(自分)を記憶
|
||
else
|
||
# 実行者がイベントを実行中である
|
||
@invoker_event.run_eve_set(self, "xxx") # 同時に条件を満たしたイベントは起動を予約する
|
||
@invoker_event = reserve_key(@invoker_event) # 予約キーをセット
|
||
end
|
||
lock if trigger_in?(TRIGGERS)
|
||
end
|
||
end
|
||
@invoker_event = nil if @invoker_event # 処理終了時に初期化
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 同位置のイベント起動判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def check_event_trigger_here(triggers)
|
||
start_map_event(@x, @y, triggers, false)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 接触イベントの起動判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def check_event_trigger_touch(x, y)
|
||
if start_to_me? # ②自分から接触した時に自分を起動
|
||
if !jumping? && normal_priority? && !@through
|
||
start_me(x, y, TRIGGERS_E, true)
|
||
end
|
||
end
|
||
if start_from_me? # ①自分から接触した時に相手を起動
|
||
if !jumping? && normal_priority? && !@through
|
||
start_map_event(x, y, TRIGGERS_P, true)
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 接触（重なり）によるイベント起動判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def check_touch_event
|
||
check_event_trigger_here(TRIGGERS_E) if start_to_me? # ②自分から接触した時に自分を起動
|
||
check_event_trigger_here(TRIGGERS_P) if start_from_me? # ①自分から接触した時に相手を起動
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 決定ボタンによるイベント起動判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def check_action_event
|
||
check_event_trigger_here(TRIGGERS_D)
|
||
check_event_trigger_there(TRIGGERS_C)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 正面のイベント起動判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def check_event_trigger_there(triggers)
|
||
x2 = $game_map.round_x_with_direction(@x, @direction)
|
||
y2 = $game_map.round_y_with_direction(@y, @direction)
|
||
start_map_event(x2, y2, triggers, true)
|
||
return if running_interpreter?
|
||
return unless $game_map.counter?(x2, y2)
|
||
x3 = $game_map.round_x_with_direction(x2, @direction)
|
||
y3 = $game_map.round_y_with_direction(y2, @direction)
|
||
start_map_event(x3, y3, triggers, true)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 移動中でない場合の処理 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def update_nonmoving(last_moving)
|
||
return if check_touch_event if last_moving
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ロックキーからキャラクター情報を取得 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def get_char_key(key)
|
||
if lock_key?(key)
|
||
# イベント実行者ロックキーである
|
||
char = key[1] # 被実行者を取得
|
||
elsif reserve_key?(key)
|
||
# 実行者が予約キーである
|
||
char = key[0] # 予約者を取得
|
||
else
|
||
# 実行者が予約キーでない
|
||
char = key # 実行者を取得
|
||
end
|
||
return char
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ロック（実行中のイベントが立ち止まる処理）[新規]
|
||
#--------------------------------------------------------------------------
|
||
def lock
|
||
@invoker_event ||= $game_player # 実行者が明示されていない
|
||
unless @locked # ロックされていない
|
||
unless lock_direction?
|
||
# 起動時の向き変更を許可
|
||
char = get_char_key(@invoker_event)
|
||
@prelock_direction = @direction
|
||
turn_toward_character(char) # 実行者の方を向く
|
||
else
|
||
# 起動時の向き変更を禁止
|
||
@prelock_direction = 0
|
||
end
|
||
@invoker_events = []
|
||
@locked = true
|
||
end
|
||
unless @invoker_events.include?(@invoker_event)
|
||
# 実行者と一致する要素が配列にない
|
||
@invoker_events.push(@invoker_event) # 実行者を末尾に追加
|
||
end
|
||
@invoker_event = nil # 処理終了時に初期化
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ロック解除 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def unlock
|
||
if @locked # ロックされている
|
||
@invoker_event ||= $game_player # 実行者が明示されていない
|
||
if unlock_key?(@invoker_event)
|
||
# ロック解除の判定のみを行う特殊処理キーである
|
||
@locked = false if @invoker_events.empty? # 配列が空ならロック解除
|
||
elsif @invoker_events.size > 1
|
||
# 配列に複数の実行者が格納されている
|
||
index = @invoker_events.index(@invoker_event) # 消去する実行者の位置を取得
|
||
@invoker_events.delete_at(index) if index # 取得した位置の要素を消去
|
||
if index == 0 && lock_direction? && @prelock_direction != 0
|
||
# 取得した位置が先頭で起動時の向き変更を許可で元の向きが初期化されていない
|
||
char = get_char_key(@invoker_events[0]) # キャラ情報を取得
|
||
turn_toward_character(char) # 次に優先する実行者の方を向く
|
||
end
|
||
elsif @invoker_events.include?(@invoker_event)
|
||
# 配列の要素が複数でなく実行者と配列の要素が一致
|
||
@invoker_events = []
|
||
@locked = false
|
||
set_direction(@prelock_direction)
|
||
elsif @invoker_events.empty?
|
||
# 配列が既に空であるがロックされている
|
||
p "ロック解除処理で不整合が発生"
|
||
@locked = false
|
||
end
|
||
end
|
||
@invoker_event = nil # 処理終了時に初期化
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Game_Event
|
||
#------------------------------------------------------------------------------
|
||
# イベントを扱うクラスです。条件判定によるイベントページ切り替えや、並列処理
|
||
# イベント実行などの機能を持っており、Game_Map クラスの内部で使用されます。
|
||
#==============================================================================
|
||
class Game_Event < Game_Character
|
||
#--------------------------------------------------------------------------
|
||
# ● 公開インスタンス変数
|
||
#--------------------------------------------------------------------------
|
||
attr_accessor :running_events # このイベントが実行中・起動予定のイベントを記憶する配列
|
||
attr_accessor :running_interpreter # このイベントが実行中のイベント内容を並列処理する為のインタプリタ
|
||
#--------------------------------------------------------------------------
|
||
# ● 公開メンバ変数の初期化 [追加]
|
||
#--------------------------------------------------------------------------
|
||
alias init_public_members_EventEveryone_Event init_public_members
|
||
def init_public_members
|
||
init_public_members_EventEveryone_Event
|
||
@running_events = nil
|
||
@running_interpreter = nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● このイベントがイベントを実行中か判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def running_interpreter? ; return @running_events ? true : false ; end
|
||
#--------------------------------------------------------------------------
|
||
# ● ①自分から接触した時に相手を起動するを注釈から取得 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def get_start_from_me_note
|
||
event_result = event_note_include?(Calt::EVENT_START_FROM_ME_NOTE)
|
||
whole_result = whole_note_include?(Calt::EVENT_START_FROM_ME_ALL_NOTE)
|
||
return event_result ^ whole_result ^ Calt::EVENT_START_FROM_ME_REVERSE
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ①によって起動されることを許可を注釈から取得 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def get_to_others_note
|
||
event_result = event_note_include?(Calt::EVENT_TO_OTHERS_NOTE)
|
||
whole_result = whole_note_include?(Calt::EVENT_TO_OTHERS_ALL_NOTE)
|
||
return event_result ^ whole_result ^ Calt::EVENT_TO_OTHERS_REVERSE
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ②自分から接触した時に自分を起動させるを注釈から取得 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def get_start_to_me_note
|
||
event_result = event_note_include?(Calt::EVENT_START_TO_ME_NOTE)
|
||
whole_result = whole_note_include?(Calt::EVENT_START_TO_ME_ALL_NOTE)
|
||
return event_result ^ whole_result ^ Calt::EVENT_START_TO_ME_REVERSE
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ②によって起動させられることを許可を注釈から取得 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def get_from_others_note
|
||
event_result = event_note_include?(Calt::EVENT_FROM_OTHERS_NOTE)
|
||
whole_result = whole_note_include?(Calt::EVENT_FROM_OTHERS_ALL_NOTE)
|
||
return event_result ^ whole_result ^ Calt::EVENT_FROM_OTHERS_REVERSE
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 起動された時に実行者の方を向くことを禁止を注釈から取得 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def get_lock_direction_note
|
||
event_result = event_note_include?(Calt::EVENT_LOCK_DIRECTION)
|
||
whole_result = whole_note_include?(Calt::EVENT_LOCK_DIRECTION_ALL)
|
||
return event_result ^ whole_result ^ Calt::EVENT_LOCK_DIRECTION_REVERSE
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● トリガーの設定を注釈から取得 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def get_trigger_note
|
||
return @trigger if @trigger == 3 || @trigger == 4 # 自動実行・並列処理でない
|
||
c_btn = event_note_include?(Calt::EVENT_TRIGGER_C_BUTTON_NOTE) # 決定ボタン
|
||
player = event_note_include?(Calt::EVENT_TRIGGER_PLAYER_NOTE) # プレイヤーから接触
|
||
event = event_note_include?(Calt::EVENT_TRIGGER_EVENT_NOTE) # イベントから接触
|
||
return @trigger unless c_btn || player || event # 注釈でトリガーを指定されていない
|
||
result = TRIGGERS # 自動実行・並列処理を除くトリガーの配列
|
||
result = c_btn ? (result & TRIGGERS_C) : (result - TRIGGERS_C)
|
||
result = player ? (result & TRIGGERS_P) : (result - TRIGGERS_P)
|
||
result = event ? (result & TRIGGERS_E) : (result - TRIGGERS_E)
|
||
unless result[0] # 例外が発生(定数の定義ミス)
|
||
p "注釈からトリガーの取得でエラー発生"
|
||
return @trigger
|
||
end
|
||
return result[0]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● イベントリストの取得 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def get_list ; return @list ; end
|
||
#--------------------------------------------------------------------------
|
||
# ● 起動中フラグのセット [新規]
|
||
#--------------------------------------------------------------------------
|
||
def set_starting ; @starting = true ; end
|
||
#--------------------------------------------------------------------------
|
||
# ● イベント起動 [◆再定義]
|
||
#--------------------------------------------------------------------------
|
||
def start ; super ; end
|
||
#--------------------------------------------------------------------------
|
||
# ● ロック（実行中のイベントが立ち止まる処理）[◆再定義]
|
||
#--------------------------------------------------------------------------
|
||
def lock ; super ; end
|
||
#--------------------------------------------------------------------------
|
||
# ● ロック解除 [◆再定義]
|
||
#--------------------------------------------------------------------------
|
||
def unlock ; super ; end
|
||
#--------------------------------------------------------------------------
|
||
# ● 接触イベントの起動判定 [◆再定義]
|
||
#--------------------------------------------------------------------------
|
||
def check_event_trigger_touch(x, y)
|
||
# プレイヤーとの接触判定
|
||
unless $game_map.interpreter.running? # 既にイベントを実行中ではない
|
||
if $game_player.from_others? # ②によって起動させられることを許可している
|
||
if !jumping? && normal_priority? && !@through
|
||
if $game_player.pos_nt?(x, y)
|
||
if trigger_in?(TRIGGERS_E) # このイベントのトリガーが一致
|
||
start # 自分を起動
|
||
if $game_player.running_interpreter? # イベントの起動に成功
|
||
@move_succeed = true # 移動が成功したことにする(移動防止)
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
super # 後はスーパークラスと同一処理
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● イベントページのセットアップ [追加]
|
||
#--------------------------------------------------------------------------
|
||
alias setup_page_EventEveryone setup_page
|
||
def setup_page(new_page)
|
||
@license += 1 # ページが変更されていない事を証明する為の値を更新
|
||
if @invoker_events.reject! { |key| reserve_key?(key) } # 予約キーを消去
|
||
# 予約キーが消去された場合
|
||
@invoker_event = unlock_key # 特殊処理キーを一時記憶
|
||
unlock # ロック解除判定のみを行わせる
|
||
end
|
||
setup_page_EventEveryone(new_page)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● イベントページ更新時に注釈から設定を取得 [追加]
|
||
#--------------------------------------------------------------------------
|
||
alias setup_note_settings_EventEveryone setup_note_settings
|
||
def setup_note_settings
|
||
setup_note_settings_EventEveryone
|
||
@start_from_me = get_start_from_me_note
|
||
@to_others = get_to_others_note
|
||
@start_to_me = get_start_to_me_note
|
||
@from_others = get_from_others_note
|
||
@lock_direction = get_lock_direction_note
|
||
@trigger = get_trigger_note
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● フレーム更新 [◆再定義]
|
||
#--------------------------------------------------------------------------
|
||
def update
|
||
last_moving = moving? # 最後に移動中だったか
|
||
super
|
||
check_event_trigger_auto
|
||
update_nonmoving(last_moving) unless moving? # 停止時の接触判定を追加
|
||
|
||
if @interpreter
|
||
@interpreter.setup(@list, @event.id) unless @interpreter.running?
|
||
@interpreter.update
|
||
end
|
||
|
||
# 自分が起動したイベントの実行内容を並列処理
|
||
if running_interpreter? # イベントを実行中
|
||
@running_interpreter.update # インタプリタを更新
|
||
unless @running_interpreter.running? # 実行内容が終了している
|
||
@running_interpreter = nil # セットされていたインタプリタを初期化
|
||
running_unlock_me # 自分のロック解除
|
||
running_unlock_event # 自分が実行していたイベントのロック解除
|
||
@running_events.shift # 自分が実行していたイベントの記憶を消去
|
||
running_reserve_check # 起動予約がないか確認する処理
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 自分用インタプリタに実行内容をセット [新規]
|
||
#--------------------------------------------------------------------------
|
||
def running_set(event_list, event_id, invoker_id)
|
||
@running_interpreter = Game_Interpreter.new # インタプリタを生成
|
||
@running_interpreter.setup(event_list, event_id) # 実行内容をセット
|
||
@running_interpreter.set_invoker(invoker_id) # 実行者のIDをセット
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 自分の実行中イベントリストにキーを追加 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def run_eve_set(event, pattern)
|
||
unless @running_events
|
||
# 実行内容が空
|
||
@running_events = [ [event, pattern, :first] ] # 通常
|
||
else
|
||
# 既に実行内容がある
|
||
@running_events.push([event, pattern, event.license]) # 予約
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 自分のロック解除処理 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def running_unlock_me
|
||
@invoker_event = lock_key(self, @running_events[0][0]) # 自分にロックキーを一時記憶
|
||
unlock # 自分のロック解除
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 相手のロック解除処理 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def running_unlock_event
|
||
if @running_events[0][2] == :first
|
||
key = self # 通常に起動されている場合
|
||
else
|
||
key = reserve_key(self) # 予約から起動されている場合
|
||
end
|
||
@running_events[0][0].invoker_event = key # 起動していた相手にキーを一時記憶
|
||
@running_events[0][0].unlock
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 起動予約の確認処理 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def running_reserve_check
|
||
until @running_events.empty? # 配列が空で無い限りループ処理
|
||
if @running_events[0][0].license == @running_events[0][2]
|
||
# ページの変更が無い事を確認
|
||
event_list = @running_events[0][0].get_list
|
||
event_id = @running_events[0][0].id
|
||
invoker_id = @id
|
||
running_set(event_list, event_id, invoker_id) # 自分のインタプリタに実行内容をセット
|
||
break # ループを脱出
|
||
else
|
||
# ページが変更されている
|
||
running_unlock_me # 自分のロック解除
|
||
# 相手は勝手に解除しているので相手の解除は不要
|
||
@running_events.shift # 自分が予約していたイベントの記憶を消去
|
||
end
|
||
end
|
||
@running_events = nil if @running_events.empty? # 配列が空なら初期化
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Game_Player
|
||
#------------------------------------------------------------------------------
|
||
# プレイヤーを扱うクラスです。イベントの起動判定や、マップのスクロールなどの
|
||
# 機能を持っています。このクラスのインスタンスは $game_player で参照されます。
|
||
#==============================================================================
|
||
class Game_Player < Game_Character
|
||
#--------------------------------------------------------------------------
|
||
# ● オブジェクト初期化 [追加]
|
||
#--------------------------------------------------------------------------
|
||
alias initialize_EventEveryone initialize
|
||
def initialize
|
||
initialize_EventEveryone
|
||
@id = -1 # プレイヤーのIDは-1にする
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● イベントリストの取得 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def get_list
|
||
val_id = Calt::EVENT_ACTOR_EVENT_MIMIC
|
||
return false if val_id == 0 # ゲーム変数が指定されていない
|
||
com_id = $game_variables[val_id] # コモンイベントの番号を取得
|
||
return false if com_id == 0 # コモンイベントの番号が設定されていない
|
||
return $data_common_events[com_id].list # コモンイベントの実行内容を取得
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 指定されたトリガーのいずれかか否かを判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def trigger_in?(triggers)
|
||
return true # プレイヤー用のトリガーは使用しなくなったので常に真を返す
|
||
val_id = Calt::EVENT_ACTOR_TRIGGER
|
||
return triggers.include?(2) if val_id == 0 # ゲーム変数の指定が無い場合は2
|
||
return triggers.include?($game_variables[val_id])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 決定ボタンによるイベントの起動を禁止か判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def lock_c_button?
|
||
switch_id = Calt::EVENT_ACTOR_LOCK_C_BUTTON
|
||
return false if switch_id == 0 # 指定が無い場合はOFF
|
||
return $game_switches[switch_id]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ①自分から接触した時に相手を起動するか判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def start_from_me?
|
||
switch_id = Calt::EVENT_ACTOR_START_FROM_ME
|
||
return true if switch_id == 0 # 指定が無い場合はON
|
||
return $game_switches[switch_id]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ①によって起動されることを許可するか判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def to_others?
|
||
switch_id = Calt::EVENT_ACTOR_TO_OTHERS
|
||
return false if switch_id == 0 # 指定が無い場合はOFF
|
||
return $game_switches[switch_id]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ②自分から接触した時に自分を起動させるか判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def start_to_me?
|
||
switch_id = Calt::EVENT_ACTOR_START_TO_ME
|
||
return false if switch_id == 0 # 指定が無い場合はOFF
|
||
return $game_switches[switch_id]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ②によって起動させられることを許可するか判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def from_others?
|
||
switch_id = Calt::EVENT_ACTOR_FROM_OTHERS
|
||
return true if switch_id == 0 # 指定が無い場合はON
|
||
return $game_switches[switch_id]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 起動された時に実行者の方を向くことを禁止か判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def lock_direction?
|
||
switch_id = Calt::EVENT_ACTOR_LOCK_DIRECTION
|
||
return false if switch_id == 0 # 指定が無い場合はOFF
|
||
return $game_switches[switch_id]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● このイベントがイベントを実行中か判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def running_interpreter?
|
||
return $game_map.any_event_starting? || $game_map.interpreter.running?
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 場所移動の実行 [追加]
|
||
#--------------------------------------------------------------------------
|
||
alias perform_transfer_EventEveryone perform_transfer
|
||
def perform_transfer
|
||
if @new_map_id != $game_map.map_id && transfer?
|
||
@invoker_events = [] # 場所移動の時に初期化
|
||
@locked = false if @locked # 場所移動の時に初期化
|
||
end
|
||
perform_transfer_EventEveryone
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● マップイベントの起動 [◆再定義]
|
||
#--------------------------------------------------------------------------
|
||
def start_map_event(x, y, triggers, normal)
|
||
# 開始時の実行中判定の処理を微妙に変更。他はスーパークラスと同一処理(ただし不要な処理はコメントアウト)
|
||
return if $game_map.interpreter.running? # プレイヤーはイベントを実行中
|
||
events = $game_map.events_xy(x, y)
|
||
##events.unshift($game_player) if $game_player.pos?(x, y) # 先頭にプレイヤーを追加
|
||
events.each do |event|
|
||
##next unless event.to_others? # ①によって起動されることを許可しない
|
||
next unless event.normal_priority? == normal
|
||
next if event.normal_priority_through? # すり抜け状態の通常キャラ
|
||
next unless event.trigger_in?(triggers) # トリガーが一致しない
|
||
##next if event == self # 起動するイベントと実行者(自分)が同一
|
||
event.invoker_event = self # 起動するイベントに実行者(自分)を一時記憶
|
||
event.start
|
||
if running_interpreter? # イベントの起動に成功
|
||
@move_succeed = true # 移動が成功したことにする(移動防止)
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 自分を起動 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def start_me(x, y, triggers, normal)
|
||
##return unless trigger_in?(triggers) # このイベントのトリガーが一致しない
|
||
$game_map.events_xy(x, y).each do |event|
|
||
next unless event.from_others? # ②によって起動させられることを許可しない
|
||
next unless event.normal_priority? == normal
|
||
next if event.normal_priority_through? # すり抜け状態の通常キャラ
|
||
next if event.running_interpreter? # 既にイベントを実行中
|
||
##next if event == self # 自分と実行者が同一
|
||
@invoker_event = event # 自分に実行者を一時記憶
|
||
start # 自分を起動
|
||
if event.running_interpreter? # イベントの起動に成功
|
||
@move_succeed = true # 移動が成功したことにする(移動防止)
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 同位置のイベント起動判定 [◆再定義]
|
||
#--------------------------------------------------------------------------
|
||
def check_event_trigger_here(triggers)
|
||
super
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 接触イベントの起動判定 [◆再定義]
|
||
#--------------------------------------------------------------------------
|
||
def check_event_trigger_touch(x, y)
|
||
super
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 接触（重なり）によるイベント起動判定 [◆再定義]
|
||
#--------------------------------------------------------------------------
|
||
def check_touch_event
|
||
return false if in_airship?
|
||
check_event_trigger_here(TRIGGERS_E) if start_to_me? # ②自分から接触した時に自分を起動
|
||
check_event_trigger_here(TRIGGERS_P) if start_from_me? # ①自分から接触した時に相手を起動
|
||
$game_map.setup_starting_event
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 決定ボタンによるイベント起動判定 [◆再定義]
|
||
#--------------------------------------------------------------------------
|
||
def check_action_event
|
||
return false if in_airship?
|
||
check_event_trigger_here(TRIGGERS_D)
|
||
return true if $game_map.setup_starting_event
|
||
check_event_trigger_there(TRIGGERS_C)
|
||
$game_map.setup_starting_event
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 正面のイベント起動判定 [◆再定義]
|
||
#--------------------------------------------------------------------------
|
||
def check_event_trigger_there(triggers)
|
||
x2 = $game_map.round_x_with_direction(@x, @direction)
|
||
y2 = $game_map.round_y_with_direction(@y, @direction)
|
||
start_map_event(x2, y2, triggers, true)
|
||
return if $game_map.any_event_starting?
|
||
return unless $game_map.counter?(x2, y2)
|
||
x3 = $game_map.round_x_with_direction(x2, @direction)
|
||
y3 = $game_map.round_y_with_direction(y2, @direction)
|
||
start_map_event(x3, y3, triggers, true)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 移動中でない場合の処理 [◆再定義]
|
||
#--------------------------------------------------------------------------
|
||
def update_nonmoving(last_moving)
|
||
return if $game_map.interpreter.running?
|
||
if last_moving
|
||
$game_party.on_player_walk
|
||
return if check_touch_event
|
||
end
|
||
if movable? && Input.trigger?(:C) && !@locked # ロック時
|
||
return if get_on_off_vehicle
|
||
return if check_action_event unless lock_c_button? # 決定ボタンによる起動が禁止されていない
|
||
end
|
||
update_encounter if last_moving && !@locked # ロック時
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● フレーム更新 [◆再定義]
|
||
#--------------------------------------------------------------------------
|
||
def update
|
||
last_real_x = @real_x
|
||
last_real_y = @real_y
|
||
last_moving = moving?
|
||
move_by_input unless @locked # ロック時
|
||
super
|
||
update_scroll(last_real_x, last_real_y)
|
||
update_vehicle
|
||
update_nonmoving(last_moving) unless moving?
|
||
@followers.update
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Game_Interpreter
|
||
#------------------------------------------------------------------------------
|
||
# イベントコマンドを実行するインタプリタです。このクラスは Game_Map クラス、
|
||
# Game_Troop クラス、Game_Event クラスの内部で使用されます。
|
||
#==============================================================================
|
||
class Game_Interpreter
|
||
#--------------------------------------------------------------------------
|
||
# ● キャラクターの取得 [追加]
|
||
#--------------------------------------------------------------------------
|
||
alias get_character_EventEveryone get_character
|
||
def get_character(param)
|
||
# 引数がこのイベントを指定していてIDがプレイヤーと同値の場合は引数を変更
|
||
param = -1 if param == 0 && @event_id == $game_player.id
|
||
get_character_EventEveryone(param)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● セルフスイッチの操作 [追加]
|
||
#--------------------------------------------------------------------------
|
||
alias command_123_EventEveryone command_123
|
||
def command_123
|
||
return command_123_EventEveryone unless @event_id == $game_player.id # 主人公以外なら通常処理
|
||
key = [:extra, @event_id, @params[0]]
|
||
$game_self_switches[key] = (@params[1] == 0)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 条件分岐 [追加]
|
||
#--------------------------------------------------------------------------
|
||
alias command_111_EventEveryone command_111
|
||
def command_111
|
||
return command_111_EventEveryone unless @event_id == $game_player.id && @params[0] == 2
|
||
key = [:extra, @event_id, @params[1]]
|
||
@branch[@indent] = ($game_self_switches[key] == (@params[2] == 0))
|
||
command_skip if !@branch[@indent]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● このイベントを起動したイベントのIDをセット [新規]
|
||
#--------------------------------------------------------------------------
|
||
def set_invoker(id)
|
||
@memory[:invoker] = id
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● このイベントを起動したイベントのIDを取得 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def get_invoker
|
||
return @memory[:invoker] ||= $game_player.id
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● このイベントを起動したのはプレイヤーか判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def start_player?
|
||
return get_invoker == $game_player.id
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 多重起動されているか判定(多重起動なら起動人数を返す) [新規]
|
||
#--------------------------------------------------------------------------
|
||
def multiple_starts?
|
||
char = get_character(0) # このイベントを取得
|
||
size = char.invoker_events_size # このイベントを実行中の人数を取得
|
||
return size > 1 ? size : false
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● このイベントがイベントを実行中か判定 [新規]
|
||
#--------------------------------------------------------------------------
|
||
def event_running?
|
||
char = get_character(0) # このイベントを取得
|
||
return char.running_interpreter?
|
||
end
|
||
end |