# =========================================================================== # ◆ A1 Scripts ◆ # A1共通処理(RGSS2/RGSS3共用) # # バージョン : 4.50 (2012/01/26) # 作者 : A1 # URL : [url]http://a1tktk.web.fc2.com/[/url] # --------------------------------------------------------------------------- # 更新履歴 :2011/11/11 Ver1.00 新規作成 # :2011/12/22 Ver2.00 RGSS3用と同様の処理に変更 # :2011/12/30 Ver2.10 RGSS3用メソッドを追加 # :2011/12/30 Ver3.00 RGSS3用共通処理と統合 # :2011/12/31 Ver3.10 マップチップサーチの仕様を変更 # :2011/12/31 Ver3.10 拡張通行判定を追加 # :2012/01/01 Ver3.11 クラス名の取得処理を追加 # :2012/01/02 Ver3.20 配列を考慮したsplit処理を追加 # :2012/01/02 Ver3.20 配列の全ての要素を整数にする処理を追加 # :2012/01/02 Ver3.30 注釈の処理の仕様を変更 # :2012/01/02 Ver3.40 「前のイベントコマンドの取得」を追加 # :2012/01/03 Ver3.50 「フレーム更新」を追加 # :2012/01/04 Ver3.60 「指定のウィンドウが開いている間ウェイト」追加 # :2012/01/04 Ver3.70 RGSS2用処理見直し # :2012/01/05 Ver3.80 注釈文字列にエスケープコマンド対応 # :2012/01/05 Ver3.80 多次元配列を考慮したsplit処理を追加 # :2012/01/05 Ver3.80 注釈にスクリプト処理機能を追加 # :2012/01/10 Ver3.90 文字縁取り描画を追加 # :2012/01/11 Ver4.00 テキストビットマップのキャッシュを追加 # :2012/01/13 Ver4.01 「タイルセットの変更」ができなくなる不具合を修正 # :2012/01/14 Ver4.10 split処理を強化 # :2012/01/14 Ver4.20 空白を含む注釈コマンドに対応 # :2012/01/14 Ver4.21 split処理の不具合を修正 # :2012/01/21 Ver4.30 メモの内容を取得する関数を追加 # :2012/01/24 Ver4.40 メモの内容を取得する関数を追加 # :2012/01/24 Ver4.50 メモの内容を取得する関数を追加 # --------------------------------------------------------------------------- # 設置場所 # なるべく上の方 # # 必要スクリプト # なし #============================================================================== $imported = {} if $imported == nil $imported["A1_Common_Script"] = 4.50 #============================================================================== # ■ Kernel #============================================================================== module Kernel #-------------------------------------------------------------------------- # ○ RGSSのバージョン取得 #-------------------------------------------------------------------------- def rgss_version return 3 if defined? Graphics.play_movie return 2 if defined? Graphics.resize_screen return 1 end #-------------------------------------------------------------------------- # ○ コモンスクリプトのバージョン取得 #-------------------------------------------------------------------------- def common_version $imported["A1_Common_Script"] end #-------------------------------------------------------------------------- # ○ コモンスクリプトのバージョンが古い #-------------------------------------------------------------------------- def old_common_script(script_name, version) msgbox("#{script_name}にはA1共通スクリプトVer#{version}以上が必要です") end end #============================================================================== # ■ A1_System #============================================================================== module A1_System end #============================================================================== # ■ A1_System::CommonModule #============================================================================== class A1_System::CommonModule #-------------------------------------------------------------------------- # ○ 定数 #-------------------------------------------------------------------------- TWOBYTE_LIST = { " " => " ", "=" => "=", ":" => ":" } #-------------------------------------------------------------------------- # ○ オブジェクト初期化 #-------------------------------------------------------------------------- def initialize define_command end #-------------------------------------------------------------------------- # ○ 変換対象の全角文字を半角に置換 #-------------------------------------------------------------------------- def replace_twobyte(str) for key in TWOBYTE_LIST.keys str.gsub!(key) {TWOBYTE_LIST[key]} end return str end #-------------------------------------------------------------------------- # ○ マイナスが含まれている文字列を数値にする #-------------------------------------------------------------------------- def minus_to_i(s) if s[0,0] == "-" s.gsub!("-","") return s.to_i * -1 else return s.to_i end end #-------------------------------------------------------------------------- # ○ ミリ秒単位の現在時間 #-------------------------------------------------------------------------- def now_usec now = Time.now hour = now.hour * 60 * 60 min = now.min * 60 sec = now.sec msec = (now.usec / 1000.0).round return (hour + min + sec) * 1000 + msec end #-------------------------------------------------------------------------- # ○ イベントリストの作成 #-------------------------------------------------------------------------- def create_event_list(code, indent, parameters) list = RPG::EventCommand.new list.code = code list.indent = indent list.parameters = parameters return list end #-------------------------------------------------------------------------- # ○ メソッド呼び出し #-------------------------------------------------------------------------- def send_method(method_name) return send(method_name) if respond_to?(method_name) end #-------------------------------------------------------------------------- # ○ オブジェクトの型を判断してStringならエンコード #-------------------------------------------------------------------------- def encoding_string(obj) obj.force_encoding("UTF-8") if obj.is_a?(String) return obj end #-------------------------------------------------------------------------- # ○ メモの内容から必要な情報を取得 #-------------------------------------------------------------------------- def note_data(note, key) result = [] note.each_line {|line| next unless line =~ /<#{key}[ ]?(.*)>/ return true if $1.empty? data = $a1_common.replace_twobyte($1).split(" ") for st in data result.push(st) end } return false if result.empty? return result end #-------------------------------------------------------------------------- # ○ メモの内容からハッシュを作成 #-------------------------------------------------------------------------- def note_data_hash(note, key, data_default = nil, default = {}, ret = {}) list = note_data_split(note, key) return default if list.empty? list.each {|data| ret[data[0]] = data[1] ? data[1] : data_default } return ret end #-------------------------------------------------------------------------- # ○ メモの内容からカンマ区切りの多元配列を取得 #-------------------------------------------------------------------------- def note_data_split(note, key, default = [], ret = []) data = note_data(note, key) return default unless data.is_a?(Array) data.each {|str| ret.push(convert_integer_from_array(split_array(str)))} return ret end #-------------------------------------------------------------------------- # ○ 配列の内容から数値があれば変換 #-------------------------------------------------------------------------- def convert_integer_from_array(data, ret = []) data.each {|str| ret.push(convert_integer(str))} return ret end #-------------------------------------------------------------------------- # ○ 数値があれば変換 #-------------------------------------------------------------------------- def convert_integer(str) return $1.to_i if str =~ /(^[-]?[0-9]+$)/ str.is_a?(Array) ? convert_integer_from_array(str) : str end #-------------------------------------------------------------------------- # ○ メモの内容から単項目の数値を取得 #-------------------------------------------------------------------------- def note_data_one_value(note, key, default) data = note_data(note, key) return data[0].to_i if data.is_a?(Array) return default end #-------------------------------------------------------------------------- # ○ メモの内容から単項目を取得 #-------------------------------------------------------------------------- def note_data_one(note, key, default) data = note_data(note, key) return data[0] if data.is_a?(Array) return default end #-------------------------------------------------------------------------- # ○ メモの内容からカンマ区切りの文字列を取得 #-------------------------------------------------------------------------- def note_data_array_str(note, key, default) data = note_data(note, key) return data[0].split(",") if data.is_a?(Array) return default end #-------------------------------------------------------------------------- # ○ メモの内容からカンマ区切りの数値を取得 #-------------------------------------------------------------------------- def note_data_array_value(note, key, default) data = note_data(note, key) return default unless data.is_a?(Array) return convert_integer_from_array(split_array(data[0])) end #-------------------------------------------------------------------------- # ○ カンマ区切りの文字列メモを変換 #-------------------------------------------------------------------------- def note_data_array(note, key, type, default = nil, through = true) ret = [] default.each {|dat| ret.push(dat)} if default != nil data = note_data(note, key) return ret unless data.is_a?(Array) data = data[0].split(",") for d in data next if ret.include?(d) if through ret.push(d.to_i) if type.is_a?(Integer) ret.push(d) if type.is_a?(String) end return ret end #-------------------------------------------------------------------------- # ○ ディレクトリの作成 #-------------------------------------------------------------------------- def make_directory(dir_name) Dir::mkdir(dir_name) unless FileTest.exist?(dir_name) end #-------------------------------------------------------------------------- # ○ コマンドリスト #-------------------------------------------------------------------------- def make_command(command, src = "", dect = "") src.gsub!("/","\\") dect.gsub!("/","\\") cmd = "#{command} \"#{src}\" \"#{dect}\"" return cmd end #-------------------------------------------------------------------------- # ○ 素材の拡張子を取得 #-------------------------------------------------------------------------- def material_ext(directory, file, direct = false) exts = [] exts = [".png",".bmp",".jpg"] if directory =~ /(.*)Graphics\/(.*)/ exts = [".mid",".ogg",".wav",".mp3",".wma"] if directory =~ /(.*)Audio(.*)/ find_file = sprintf("%s%s", directory, file) unless direct find_file = file if direct for ext in exts return ext if File.exist?(sprintf("%s%s", find_file, ext)) end return nil end #-------------------------------------------------------------------------- # ○ 素材が存在するかチェック #-------------------------------------------------------------------------- def material_exist?(directory, file, direct = false) return false if material_ext(directory, file, direct) == nil return true end #-------------------------------------------------------------------------- # ○ ファイルコピー #-------------------------------------------------------------------------- def copy_file(src, dest) srcFile = File.open( src, "rb" ) dstFile = File.open( dest, "wb" ) dstFile.write( srcFile.read ) srcFile.close dstFile.close end #-------------------------------------------------------------------------- # ○ ファイルの存在を確認してファイルコピー #-------------------------------------------------------------------------- def material_copy(src, dest, directory) ext = material_ext(directory, src, true) copy_file( src + ext, dest + ext ) if ext != nil end #-------------------------------------------------------------------------- # ○ 配列からAudioを作成 #-------------------------------------------------------------------------- def set_audio(sound, kind) case kind when "BGM"; audio = RPG::BGM.new when "BGS"; audio = RPG::BGS.new when "ME"; audio = RPG::ME.new when "SE"; audio = RPG::SE.new end audio.name = sound[0] audio.volume = sound[1] audio.pitch = sound[2] return audio end #-------------------------------------------------------------------------- # ○ 既に準拠識別子を持っているかチェック #-------------------------------------------------------------------------- def chk_rtp(file_name, default) return "" if file_name =~ /^VX_.*/ return "" if file_name =~ /^XP_.*/ return "" if file_name =~ /^2000_.*/ return "" if file_name =~ /^2003_.*/ return default end #-------------------------------------------------------------------------- # ○ 先頭の $ を切り出す #-------------------------------------------------------------------------- def one_character(file_name) return file_name unless file_name[0] == "$" tmp = file_name.clone tmp[0] = "" return tmp end #-------------------------------------------------------------------------- # ○ 配列を入れ替える #-------------------------------------------------------------------------- def change_array(array, index1, index2) tmp = array[index1] array[index1] = array[index2] array[index2] = tmp return array end #-------------------------------------------------------------------------- # ○ 移動ルートの作成 #-------------------------------------------------------------------------- def create_move_route(repeat, skippable, wait, list) move_route = RPG::MoveRoute.new move_route.repeat = repeat move_route.skippable = skippable move_route.wait = wait move_route.list = list return move_route end #-------------------------------------------------------------------------- # ○ 移動ルートコマンドの作成 #-------------------------------------------------------------------------- def create_move_command(code, parameters) list = RPG::MoveCommand.new list.code = code list.parameters = parameters return list end #-------------------------------------------------------------------------- # ○ インタプリタ起動用リストの作成 #-------------------------------------------------------------------------- def create_list(code, indent, parameters) list = RPG::EventCommand.new list.code = code list.indent = indent list.parameters = parameters return list end #-------------------------------------------------------------------------- # ○ クラス名の取得 #-------------------------------------------------------------------------- def class_name(class_instance) return class_instance.to_s.split(":")[0].gsub("#<","") end #-------------------------------------------------------------------------- # ○ 配列を考慮したsplit #-------------------------------------------------------------------------- def split_array(str) str = convert_escape_characters(str) ret = [] tmp_array = str.split(",") return strip_array_str(tmp_array) unless str.include?("[") tmp_str = "" tmp_array.each {|s| if char_in_str(s, "[", "]") && tmp_str.empty? ret.push(s) unless s =~ /^\[/ ret.push([s[1...s.size-1]]) if s =~ /^\[/ else tmp_str = "#{tmp_str}#{s}," if char_in_str(tmp_str, "[", "]") unless tmp_str =~ /^\[/ ret.push(tmp_str[0...tmp_str.size-1]) tmp_str = "" else tmp_str = tmp_str[1...tmp_str.size-2] tmp_str = split_array(tmp_str) if tmp_str.include?("[") tmp_str = tmp_str.split(",") if tmp_str.include?(",") ret.push(tmp_str) if tmp_str.is_a?(Array) ret.push([tmp_str]) if !tmp_str.is_a?(Array) tmp_str = "" end end end } return strip_array_str(ret) end #-------------------------------------------------------------------------- # ○ 配列の中の文字列の先頭と末尾の空白を除去 #-------------------------------------------------------------------------- def strip_array_str(array, ret = []) array.each {|str| ret.push(strip_array_str(str)) if str.is_a?(Array); next if str.is_a?(Array); ret.push(str.strip) } return ret end #-------------------------------------------------------------------------- # ○ 文字列の中に文字が何文字含まれているか調べて同数ならtrueを返す #-------------------------------------------------------------------------- def char_in_str(str, c1, c2) num1 = 0 num2 = 0 (0...str.size).each {|i| num1 += 1 if str[i] == c1; num2 += 1 if str[i] == c2 } return num1 == num2 end #-------------------------------------------------------------------------- # ○ 制御文字の変換 #-------------------------------------------------------------------------- def convert_escape_characters(text) result = text.to_s.clone result.gsub!(/\\/) { "\e" } result.gsub!(/\e\e/) { "\\" } result.gsub!(/\eV\[(\d+)\]/i) { $game_variables[$1.to_i] } result.gsub!(/\eV\[(\d+)\]/i) { $game_variables[$1.to_i] } result.gsub!(/\eN\[(\d+)\]/i) { actor_name($1.to_i) } result.gsub!(/\eP\[(\d+)\]/i) { party_member_name($1.to_i) } result.gsub!(/\eG/i) { Vocab::currency_unit } loop { result = result.sub(/<s>(.+?)<\/s>/i) { eval($1) }; break unless $1 } result end #-------------------------------------------------------------------------- # ○ アクター n 番の名前を取得 #-------------------------------------------------------------------------- def actor_name(n) actor = n >= 1 ? $game_actors[n] : nil actor ? actor.name : "" end #-------------------------------------------------------------------------- # ○ パーティメンバー n 番の名前を取得 #-------------------------------------------------------------------------- def party_member_name(n) actor = n >= 1 ? $game_party.members[n - 1] : nil actor ? actor.name : "" end #-------------------------------------------------------------------------- # ○ 配列を全て整数にする #-------------------------------------------------------------------------- def params_to_i(params) ret = [] params.each {|param| ret.push(param.to_i)} return ret end #-------------------------------------------------------------------------- # ○ 注釈コマンド定義 #-------------------------------------------------------------------------- def define_command @cmd_108 = {} end #-------------------------------------------------------------------------- # ○ 注釈コマンド定義取得 #-------------------------------------------------------------------------- def cmd_108 @cmd_108 end #-------------------------------------------------------------------------- # ○ フレーム更新 #-------------------------------------------------------------------------- def update end #-------------------------------------------------------------------------- # ○ 文字の幅と高さを取得 #-------------------------------------------------------------------------- def text_size(font, size, text) bitmap = Cache.system("") bitmap.font.name = font bitmap.font.size = size tw = bitmap.text_size(text).width th = bitmap.text_size(text).height bitmap.dispose return [tw, th] end #-------------------------------------------------------------------------- # ○ 文字の幅を取得 #-------------------------------------------------------------------------- def text_width(font, text) texts = text.split("\n") @max_width = 0 texts.each {|text| width = text_size(font.name, font.size, text)[0] @max_width = @max_width < width ? width : @max_width } return @max_width end end #============================================================================== # ◆ RGSS3用処理 #============================================================================== if rgss_version == 3 #============================================================================== # ■ RPG::Tileset #============================================================================== class RPG::Tileset #-------------------------------------------------------------------------- # ○ 拡張通行判定 #-------------------------------------------------------------------------- def ex_flags @ex_flags ||= Table.new(8192) return @ex_flags end #-------------------------------------------------------------------------- # ○ 拡張通行判定初期化 #-------------------------------------------------------------------------- def init_ex_flags @ex_flags = Table.new(8192) end end #============================================================================== # ■ Game_Interpreter #------------------------------------------------------------------------------ # イベントコマンドを実行するインタプリタです。このクラスは Game_Map クラス、 # Game_Troop クラス、Game_Event クラスの内部で使用されます。 #============================================================================== class Game_Interpreter #-------------------------------------------------------------------------- # ☆ オブジェクト初期化 # depth : ネストの深さ #-------------------------------------------------------------------------- alias a1_common_gi_rgss3_initialize initialize def initialize(depth = 0, sub_interpreter = false) @sub_interpreter = sub_interpreter a1_common_gi_rgss3_initialize(depth) end #-------------------------------------------------------------------------- # ☆ メッセージ表示がビジー状態の間ウェイト #-------------------------------------------------------------------------- alias a1_common_gi_wait_for_message wait_for_message def wait_for_message return if @sub_interpreter a1_common_gi_wait_for_message end end #============================================================================== # ■ Window_Message #------------------------------------------------------------------------------ # 文章表示に使うメッセージウィンドウです。 #============================================================================== class Window_Message < Window_Base #-------------------------------------------------------------------------- # ☆ 通常文字の処理 #-------------------------------------------------------------------------- alias a1_common_wm_process_normal_character process_normal_character def process_normal_character(c, pos) wait_for_one_character_before a1_common_wm_process_normal_character(c, pos) end #-------------------------------------------------------------------------- # ○ 一文字出力前のウェイト #-------------------------------------------------------------------------- def wait_for_one_character_before end end #============================================================================== # ■ RPG::Map #============================================================================== class RPG::Map #-------------------------------------------------------------------------- # ○ マップチップを調べるか判定する #-------------------------------------------------------------------------- def search_map_chip? return true if $a1_common.note_data(self.note, "マップチップサーチ") return false end end #============================================================================== # ■ Game_Map #------------------------------------------------------------------------------ # マップを扱うクラスです。スクロールや通行可能判定などの機能を持っています。 # このクラスのインスタンスは $game_map で参照されます。 #============================================================================== class Game_Map #-------------------------------------------------------------------------- # ☆ セットアップ #-------------------------------------------------------------------------- alias a1_common_gm_setup setup def setup(map_id) a1_common_gm_setup(map_id) setup_tileset map_chip_search if search_map_chip? end #-------------------------------------------------------------------------- # ★ タイルセットの取得 #-------------------------------------------------------------------------- def tileset setup_tileset unless @tileset && @now_tileset_id == @tileset_id return @tileset end #-------------------------------------------------------------------------- # ○ タイルセットのセットアップ #-------------------------------------------------------------------------- def setup_tileset @tileset = $data_tilesets[@tileset_id].clone @tileset.flags = $data_tilesets[@tileset_id].flags.clone @now_tileset_id = @tileset_id end #-------------------------------------------------------------------------- # ○ マップチップを調べるか判定する #-------------------------------------------------------------------------- def search_map_chip? return @map.search_map_chip? end #-------------------------------------------------------------------------- # ○ 指定座標の全レイヤーのフラグ判定(イベント含む) #-------------------------------------------------------------------------- def all_tiles_flag?(x, y, bit) all_tiles(x, y).any? {|tile_id| tileset.flags[tile_id] & bit != 0 } end #-------------------------------------------------------------------------- # ○ 指定座標の全レイヤーの拡張フラグ判定(イベント含む) #-------------------------------------------------------------------------- def all_tiles_flag_ex?(x, y, bit) all_tiles(x, y).any? {|tile_id| tileset.ex_flags[tile_id] & bit != 0 } end #-------------------------------------------------------------------------- # ○ 指定座標の全レイヤーの拡張フラグ判定 #-------------------------------------------------------------------------- def layered_tiles_flag_ex?(x, y, bit) layered_tiles(x, y).any? {|tile_id| tileset.ex_flags[tile_id] & bit != 0 } end #-------------------------------------------------------------------------- # ○ 地形タグの取得(イベント含む) #-------------------------------------------------------------------------- def terrain_tag_all_tailes(x, y) return 0 unless valid?(x, y) all_tiles(x, y).each do |tile_id| tag = tileset.flags[tile_id] >> 12 return tag if tag > 0 end return 0 end end #============================================================================== # ■ DataManager #------------------------------------------------------------------------------ # データベースとゲームオブジェクトを管理するモジュールです。ゲームで使用する # ほぼ全てのグローバル変数はこのモジュールで初期化されます。 #============================================================================== module DataManager #-------------------------------------------------------------------------- # ○ エイリアス用特異メソッド #-------------------------------------------------------------------------- class << self alias :a1_common_create_game_objects :create_game_objects end #-------------------------------------------------------------------------- # ☆ 各種ゲームオブジェクトの作成 #-------------------------------------------------------------------------- def self.create_game_objects $a1_common ||= A1_System::CommonModule.new a1_common_create_game_objects end end #============================================================================== # ■ Scene_Base #------------------------------------------------------------------------------ # ゲーム中の全てのシーンのスーパークラスです。 #============================================================================== class Scene_Base #-------------------------------------------------------------------------- # ☆ フレーム更新(基本) #-------------------------------------------------------------------------- alias a1_common_sb_update_basic update_basic def update_basic a1_common_sb_update_basic $a1_common.update end #-------------------------------------------------------------------------- # ○ 指定のウィンドウが開いている間ウェイト #-------------------------------------------------------------------------- def wait_for_window_open(window) update_basic until window.openness == 0 end end #============================================================================== # ■ Window_Base #------------------------------------------------------------------------------ # ゲーム中の全てのウィンドウのスーパークラスです。 #============================================================================== class Window_Base < Window #-------------------------------------------------------------------------- # ★ 制御文字の事前変換 # 実際の描画を始める前に、原則として文字列に変わるものだけを置き換える。 # 文字「\」はエスケープ文字(\e)に変換。 #-------------------------------------------------------------------------- def convert_escape_characters(text) return $a1_common.convert_escape_characters(text) end end #============================================================================== # ◆ RGSS2用処理 #============================================================================== elsif rgss_version == 2 #============================================================================== # ■ Window #============================================================================== class Window #-------------------------------------------------------------------------- # ○ ウィンドウが開いている? #-------------------------------------------------------------------------- def open? return self.openness == 255 end #-------------------------------------------------------------------------- # ○ ウィンドウが閉じている? #-------------------------------------------------------------------------- def close? return self.openness == 0 end end #============================================================================== # ■ Cache #------------------------------------------------------------------------------ # 各種グラフィックを読み込み、Bitmap オブジェクトを作成、保持するモジュール # です。読み込みの高速化とメモリ節約のため、作成した Bitmap オブジェクトを内部 # のハッシュに保存し、同じビットマップが再度要求されたときに既存のオブジェクト # を返すようになっています。 #============================================================================== module Cache #-------------------------------------------------------------------------- # ○ キャッシュ存在チェック #-------------------------------------------------------------------------- def self.include?(key) @cache[key] && !@cache[key].disposed? end end #============================================================================== # ■ Game_Interpreter #------------------------------------------------------------------------------ # イベントコマンドを実行するインタプリタです。このクラスは Game_Map クラス、 # Game_Troop クラス、Game_Event クラスの内部で使用されます。 #============================================================================== class Game_Interpreter #-------------------------------------------------------------------------- # ○ 注釈 #-------------------------------------------------------------------------- def command_108 @comments = [@params[0]] while next_event_code == 408 @index += 1 @comments.push(@list[@index].parameters[0]) end end #-------------------------------------------------------------------------- # ★ イベントコマンドの実行 #-------------------------------------------------------------------------- def execute_command return rgss3_execute_command unless @index >= @list.size-1 command_end return true end #-------------------------------------------------------------------------- # ○ RGSS3風「イベントコマンドの実行」 #-------------------------------------------------------------------------- def rgss3_execute_command command = @list[@index] @params = command.parameters @indent = command.indent method_name = "command_#{command.code}" send(method_name) if respond_to?(method_name) end #-------------------------------------------------------------------------- # ○ 次のイベントコマンドのコードを取得 #-------------------------------------------------------------------------- def next_event_code @list[@index + 1].code end end #============================================================================== # ■ Game_Map #------------------------------------------------------------------------------ # マップを扱うクラスです。スクロールや通行可能判定などの機能を持っています。 # このクラスのインスタンスは $game_map で参照されます。 #============================================================================== class Game_Map #-------------------------------------------------------------------------- # ○ マップチップを調べるか判定する #-------------------------------------------------------------------------- def search_map_chip? return $data_map_infos[@map_id].name =~ /\[サーチ\]/ end #-------------------------------------------------------------------------- # ○ 指定座標に存在するタイル扱いイベント(すり抜け以外)の配列取得 #-------------------------------------------------------------------------- def tile_events_xy(x, y) @tile_events.select {|event| event.pos_nt?(x, y) } end #-------------------------------------------------------------------------- # ○ タイル扱いイベントの配列をリフレッシュ #-------------------------------------------------------------------------- def refresh_tile_events @tile_events = @events.values.select {|event| event.tile? } end end #============================================================================== # ■ Game_Character #------------------------------------------------------------------------------ # キャラクターを扱うクラスです。このクラスは Game_Player クラスと Game_Event # クラスのスーパークラスとして使用されます。 #============================================================================== class Game_Character #-------------------------------------------------------------------------- # ○ タイル判定 #-------------------------------------------------------------------------- def tile? @tile_id > 0 && @priority_type == 0 end end #============================================================================== # ■ Scene_Title #------------------------------------------------------------------------------ # タイトル画面の処理を行うクラスです。 #============================================================================== class Scene_Title < Scene_Base #-------------------------------------------------------------------------- # ☆ データベースのロード #-------------------------------------------------------------------------- alias a1_common_st_load_database load_database def load_database a1_common_st_load_database $data_map_infos = load_data("Data/MapInfos.rvdata") end #-------------------------------------------------------------------------- # ☆ 各種ゲームオブジェクトの作成 #-------------------------------------------------------------------------- alias a1_common_st_create_game_objects create_game_objects def create_game_objects $a1_common ||= A1_System::CommonModule.new a1_common_st_create_game_objects end end #============================================================================== # ◆ RGSS用処理 #============================================================================== elsif rgss_version == 1 end #============================================================================== # ■ Cache #------------------------------------------------------------------------------ # 各種グラフィックを読み込み、Bitmap オブジェクトを作成、保持するモジュール # です。読み込みの高速化とメモリ節約のため、作成した Bitmap オブジェクトを内部 # のハッシュに保存し、同じビットマップが再度要求されたときに既存のオブジェクト # を返すようになっています。 #============================================================================== module Cache #-------------------------------------------------------------------------- # ○ 拡大縮小したビットマップのロード #-------------------------------------------------------------------------- def self.load_resize_bitmap(load_path, key, resize = nil) @cache ||= {} key = load_path if key == nil return @cache[key] if include?(key) @cache[key] = Bitmap.new(load_path) return @cache[key] if resize == nil return @cache[key] if @cache[key].width == resize[0] and @cache[key].height == resize[1] info = calc_size(resize, key) return resize_bitmap(@cache[key], info[0], info[1], key) end #-------------------------------------------------------------------------- # ○ 拡大縮小した色相変化済みビットマップを作成/取得 #-------------------------------------------------------------------------- def self.load_resize_hue_changed_bitmap(load_path, path, hue, resize) key = [path, hue] return @cache[key] if include?(key) @cache[key] = load_resize_bitmap(load_path, path, resize).clone @cache[key].hue_change(hue) return @cache[key] end #-------------------------------------------------------------------------- # ○ リサイズするサイズを取得 #-------------------------------------------------------------------------- def self.calc_size(resize, key) width = resize[0] width = @cache[key].width * width.abs if width < 0 height = resize[1] height = @cache[key].height * height.abs if height < 0 height = Integer(@cache[key].height * (width.to_f / @cache[key].width.to_f)) if height == 0 return [width, height] end #-------------------------------------------------------------------------- # ○ ビットマップの拡大縮小 #-------------------------------------------------------------------------- def self.resize_bitmap(bitmap, width, height, key) resize = Bitmap.new(width, height) resize.stretch_blt(resize.rect, bitmap, bitmap.rect) @cache[key] = resize return resize end #-------------------------------------------------------------------------- # ○ テキストビットマップの取得 #-------------------------------------------------------------------------- def self.text_picture(text, font) load_text_bitmap(text, font) end #-------------------------------------------------------------------------- # ○ フォントのキーを作成 #-------------------------------------------------------------------------- def self.make_font_key(text, font) [text, font.name, font.size, font.bold, font.italic, font.outline, font.shadow, font.color.to_s, font.out_color.to_s] end #-------------------------------------------------------------------------- # ○ テキストビットマップの作成 #-------------------------------------------------------------------------- def self.load_text_bitmap(text, font) @cache ||= {} key = make_font_key(text, font) return @cache[key] if include?(key) # 計算用ダミービットマップ bitmap = Cache.system("") bitmap.font = font tw = bitmap.text_size(text).width + 8 # ビットマップ作成 bitmap = Bitmap.new(tw, bitmap.font.size + 4) bitmap.font = font bitmap.draw_text(0, 0, bitmap.width, bitmap.height, text, 1) @cache[key] = bitmap return @cache[key] end end #============================================================================== # ■ Game_Interpreter #------------------------------------------------------------------------------ # イベントコマンドを実行するインタプリタです。このクラスは Game_Map クラス、 # Game_Troop クラス、Game_Event クラスの内部で使用されます。 #============================================================================== class Game_Interpreter #-------------------------------------------------------------------------- # ○ 注釈 #-------------------------------------------------------------------------- alias a1_common_command_108 command_108 def command_108 a1_common_command_108 proc_comment(@comments) end #-------------------------------------------------------------------------- # ○ 注釈の処理 #-------------------------------------------------------------------------- def proc_comment(comments) param = "" comments.each {|comment| param += comment } params = param.sub(/^(\S+)/, "") command = $1 comment_parameters = $a1_common.split_array(params) if params proc_comment_command(command, comment_parameters) end #-------------------------------------------------------------------------- # ○ 注釈の実行 #-------------------------------------------------------------------------- def proc_comment_command(command, params) cmd_108 = $a1_common.cmd_108[command] method(cmd_108).call(params) if cmd_108 != nil end #-------------------------------------------------------------------------- # ○ 前のイベントコマンドを取得 #-------------------------------------------------------------------------- def prev_event @list[@index - 1] end end #============================================================================== # ■ Game_Map #------------------------------------------------------------------------------ # マップを扱うクラスです。スクロールや通行可能判定などの機能を持っています。 # このクラスのインスタンスは $game_map で参照されます。 #============================================================================== class Game_Map #-------------------------------------------------------------------------- # ○ 全マップチップを調べる #-------------------------------------------------------------------------- def map_chip_search tileset.init_ex_flags ([email]0...@map.data.xsize[/email]).each {|x| map_chip_search_y(x) } end #-------------------------------------------------------------------------- # ○ x座標にあるy座標のマップチップを調べる #-------------------------------------------------------------------------- def map_chip_search_y(x) ([email]0...@map.data.ysize[/email]).each {|y| map_pos_proc(x, y); map_chip_search_z(x, y) } end #-------------------------------------------------------------------------- # ○ x,y座標にあるz座標のマップチップを調べる #-------------------------------------------------------------------------- def map_chip_search_z(x, y) ([email]0...@map.data.zsize[/email]).each {|z| map_chip_proc(x, y, z) } tile_events_xy(x, y).collect {|ev| tile_event_proc(ev.tile_id) } end #-------------------------------------------------------------------------- # ○ 座標に対して処理を行う #-------------------------------------------------------------------------- def map_pos_proc(x, y) end #-------------------------------------------------------------------------- # ○ マップチップに対して処理を行う #-------------------------------------------------------------------------- def map_chip_proc(x, y, z) end #-------------------------------------------------------------------------- # ○ タイルのイベントに対して処理を行う #-------------------------------------------------------------------------- def tile_event_proc(tile_id) end end #============================================================================== # ■ Window_Base #------------------------------------------------------------------------------ # ゲーム中の全てのウィンドウのスーパークラスです。 #============================================================================== class Window_Base < Window #-------------------------------------------------------------------------- # ○ 入力を受け付けるか? #-------------------------------------------------------------------------- def can_input? @can_input end #-------------------------------------------------------------------------- # ○ 入力受け付け設定 #-------------------------------------------------------------------------- def can_input=(flag) @can_input = flag end end #============================================================================== # ■ Bitmap #============================================================================== class Bitmap #-------------------------------------------------------------------------- # ○ 文字縁取り描画 #-------------------------------------------------------------------------- def draw_text_f(x, y, width, height, str, align = 0, color = Color.new(64,32,128)) shadow = self.font.shadow b_color = self.font.color.dup font.shadow = false font.color = color draw_text(x + 1, y, width, height, str, align) draw_text(x - 1, y, width, height, str, align) draw_text(x, y + 1, width, height, str, align) draw_text(x, y - 1, width, height, str, align) font.color = b_color draw_text(x, y, width, height, str, align) font.shadow = shadow end #-------------------------------------------------------------------------- # ○ 文字縁取り描画の矩形を取得 #-------------------------------------------------------------------------- def draw_text_f_rect(r, str, align = 0, color = Color.new(64,32,128)) draw_text_f(r.x, r.y, r.width, r.height, str, align = 0, color) end end
# =========================================================================== # ◆ A1 Scripts ◆ # A1バトル共通スクリプト(RGSS3) # # バージョン : 1.23 (2012/01/27) # 作者 : A1 # URL : [url]http://a1tktk.web.fc2.com/[/url] # --------------------------------------------------------------------------- # 更新履歴 :2012/01/18 Ver1.00 リリース # 2012/01/21 Ver1.10 装備拡張対応 # 2012/01/21 Ver1.10 メンバー加入時の不具合を修正 # 2012/01/21 Ver1.10 メンバー加入時に既にパーティに居るさい何もしないように修正 # 2012/01/24 Ver1.20 スキル拡張対応 # 2012/01/24 Ver1.21 Window_BattleActorの不具合を修正 # 2012/01/26 Ver1.22 Window_BattleSkillの不具合を修正 # 2012/01/27 Ver1.23 戦闘行動がない際の不具合を修正 # --------------------------------------------------------------------------- # 設置場所 # A1共通スクリプトより下 # 一部再定義メソッドがあるため、なるべく上の方 # # 必要スクリプト # A1共通スクリプトVer4.30以上 #============================================================================== $imported = {} if $imported == nil if $imported["A1_Common_Script"] $imported["A1_BattleCommonScript"] = true old_common_script("A1バトル共通スクリプト", "4.30") if common_version < 4.30 #============================================================================== # ■ Window_Base #------------------------------------------------------------------------------ # ゲーム中の全てのウィンドウのスーパークラスです。 #============================================================================== class Window_Base < Window #-------------------------------------------------------------------------- # ○ メソッドの定義 #-------------------------------------------------------------------------- def define_method(method, symbol) @method ||= {} @method[symbol] = method end #-------------------------------------------------------------------------- # ○ メソッドのコール #-------------------------------------------------------------------------- def call_method(symbol, *args) @method ||= {} @method[symbol].call(*args) if @method[symbol] end #-------------------------------------------------------------------------- # ○ 顔グラフィックの描画(解放なし) #-------------------------------------------------------------------------- def draw_face_no_dispose(face_name, face_index, x, y, enabled = true) bitmap = Cache.face(face_name) rect = Rect.new(face_index % 4 * 96, face_index / 4 * 96, 96, 96) contents.blt(x, y, bitmap, rect, enabled ? 255 : translucent_alpha) end #-------------------------------------------------------------------------- # ○ 背景の描画 #-------------------------------------------------------------------------- def draw_background(rect) temp_rect = rect.clone temp_rect.width /= 2 contents.gradient_fill_rect(temp_rect, back_color2, back_color1) temp_rect.x = temp_rect.width contents.gradient_fill_rect(temp_rect, back_color1, back_color2) end #-------------------------------------------------------------------------- # ○ 背景色 1 の取得 #-------------------------------------------------------------------------- def back_color1 Color.new(0, 0, 0, 192) end #-------------------------------------------------------------------------- # ○ 背景色 2 の取得 #-------------------------------------------------------------------------- def back_color2 Color.new(0, 0, 0, 0) end end #============================================================================== # ■ Window_Help #------------------------------------------------------------------------------ # スキルやアイテムの説明、アクターのステータスなどを表示するウィンドウです。 #============================================================================== class Window_Help < Window_Base #-------------------------------------------------------------------------- # ○ センターにテキストを描画 #-------------------------------------------------------------------------- def draw_center_text(text) contents.clear draw_text(0, 0, contents.width, line_height, text, 1) end end #============================================================================== # ■ Window_BattleActor #------------------------------------------------------------------------------ # バトル画面で、行動対象のアクターを選択するウィンドウです。 #============================================================================== class Window_BattleActor < Window_BattleStatus #-------------------------------------------------------------------------- # ★ ウィンドウの表示 #-------------------------------------------------------------------------- def show setup_remain if @info_viewport self.visible = true refresh open self end #-------------------------------------------------------------------------- # ★ ウィンドウの非表示 #-------------------------------------------------------------------------- def hide close @info_viewport.rect.width = Graphics.width if @info_viewport call_method(:select_actor_end) end #-------------------------------------------------------------------------- # ○ フレーム更新 #-------------------------------------------------------------------------- def update return update_basic unless self.visible super self.visible = false if self.openness == 0 end #-------------------------------------------------------------------------- # ○ フレーム更新(基本) #-------------------------------------------------------------------------- def update_basic process_cursor_move process_handling end #-------------------------------------------------------------------------- # ○ 項目の選択 #-------------------------------------------------------------------------- def select(index) super call_method(:select_actor, index) end #-------------------------------------------------------------------------- # ○ ウィンドウの調整 #-------------------------------------------------------------------------- def setup_remain width_remain = Graphics.width - width self.x = width_remain @info_viewport.rect.width = width_remain select(0) end end #============================================================================== # ■ Window_BattleEnemy #------------------------------------------------------------------------------ # バトル画面で、行動対象の敵キャラを選択するウィンドウです。 #============================================================================== class Window_BattleEnemy < Window_Selectable #-------------------------------------------------------------------------- # ★ ウィンドウの表示 #-------------------------------------------------------------------------- def show setup_remain if @info_viewport self.visible = true open self end #-------------------------------------------------------------------------- # ★ ウィンドウの非表示 #-------------------------------------------------------------------------- def hide close @info_viewport.rect.width = Graphics.width if @info_viewport call_method(:select_enemy_end) end #-------------------------------------------------------------------------- # ○ フレーム更新 #-------------------------------------------------------------------------- def update return update_basic unless self.visible super self.visible = false if self.openness == 0 end #-------------------------------------------------------------------------- # ○ フレーム更新(基本) #-------------------------------------------------------------------------- def update_basic process_cursor_move process_handling end #-------------------------------------------------------------------------- # ○ 項目の選択 #-------------------------------------------------------------------------- def select(index) super call_method(:select_enemy, index) end #-------------------------------------------------------------------------- # ○ ウィンドウの調整 #-------------------------------------------------------------------------- def setup_remain width_remain = Graphics.width - width self.x = width_remain @info_viewport.rect.width = width_remain select(0) end end #============================================================================== # ■ Window_BattleSkill #------------------------------------------------------------------------------ # バトル画面で、使用するスキルを選択するウィンドウです。 #============================================================================== class Window_BattleSkill < Window_SkillList #-------------------------------------------------------------------------- # ☆ オブジェクト初期化 # info_viewport : 情報表示用ビューポート #-------------------------------------------------------------------------- alias a1_psw_wbs_initialize initialize def initialize(help_window, info_viewport) a1_psw_wbs_initialize(help_window, info_viewport) self.openness = 0 self.visible = true @help_window.openness = 0 @help_window.visible = true end #-------------------------------------------------------------------------- # ○ 高さを変える #-------------------------------------------------------------------------- def resize_height(base_y) self.height = base_y - self.y create_contents end #-------------------------------------------------------------------------- # ★ ウィンドウの表示 #-------------------------------------------------------------------------- def show self.visible = true @help_window.visible = true select_last open @help_window.open self end #-------------------------------------------------------------------------- # ★ ウィンドウの非表示 #-------------------------------------------------------------------------- def hide close @help_window.close @info_viewport.rect.width = Graphics.width if @info_viewport call_method(:skill_item_window_hide) end #-------------------------------------------------------------------------- # ○ オープン #-------------------------------------------------------------------------- def open self.visible = true call_method(:skill_item_window_show) super end #-------------------------------------------------------------------------- # ○ アクティブ化 #-------------------------------------------------------------------------- def activate open @help_window.open super end end #============================================================================== # ■ Window_BattleItem #------------------------------------------------------------------------------ # バトル画面で、使用するアイテムを選択するウィンドウです。 #============================================================================== class Window_BattleItem < Window_ItemList #-------------------------------------------------------------------------- # ☆ オブジェクト初期化 # info_viewport : 情報表示用ビューポート #-------------------------------------------------------------------------- alias a1_battle_common_wbi_initialize initialize def initialize(help_window, info_viewport) a1_battle_common_wbi_initialize(help_window, info_viewport) self.openness = 0 self.visible = true @help_window.openness = 0 @help_window.visible = true end #-------------------------------------------------------------------------- # ○ 高さを変える #-------------------------------------------------------------------------- def resize_height(base_y) self.height = base_y - self.y create_contents end #-------------------------------------------------------------------------- # ★ ウィンドウの表示 #-------------------------------------------------------------------------- def show self.visible = true @help_window.visible = true select_last open @help_window.open self end #-------------------------------------------------------------------------- # ★ ウィンドウの非表示 #-------------------------------------------------------------------------- def hide close @help_window.close call_method(:skill_item_window_hide) end #-------------------------------------------------------------------------- # ○ オープン #-------------------------------------------------------------------------- def open self.visible = true call_method(:skill_item_window_show) super end #-------------------------------------------------------------------------- # ○ アクティブ化 #-------------------------------------------------------------------------- def activate open @help_window.open super end #-------------------------------------------------------------------------- # ○ フレーム更新 #-------------------------------------------------------------------------- def update return unless self.visible super self.visible = false if self.openness == 0 end end #============================================================================== # ■ Window_ActorCommand #------------------------------------------------------------------------------ # バトル画面で、アクターの行動を選択するウィンドウです。 #============================================================================== class Window_ActorCommand < Window_Command #-------------------------------------------------------------------------- # ☆ セットアップ #-------------------------------------------------------------------------- alias a1_battle_common_wac_setup setup def setup(actor) call_method(:actor_command_setup, actor) a1_battle_common_wac_setup(actor) end #-------------------------------------------------------------------------- # ○ ウィンドウのアクティブ化 #-------------------------------------------------------------------------- def activate open super end #-------------------------------------------------------------------------- # ○ オープン #-------------------------------------------------------------------------- def open call_method(:actor_command_open) super end #-------------------------------------------------------------------------- # ○ クローズ #-------------------------------------------------------------------------- def close call_method(:actor_command_close) super end end #============================================================================== # ■ Window_BattleStatus #------------------------------------------------------------------------------ # バトル画面で、パーティメンバーのステータスを表示するウィンドウです。 #============================================================================== class Window_BattleStatus < Window_Selectable #-------------------------------------------------------------------------- # ☆ リフレッシュ #-------------------------------------------------------------------------- alias a1_battle_common_wbs_refresh refresh def refresh call_method(:refresh_statsu_window) return unless self.visible a1_battle_common_wbs_refresh end #-------------------------------------------------------------------------- # ○ ウィンドウを開く #-------------------------------------------------------------------------- def open super call_method(:open_status_window) end #-------------------------------------------------------------------------- # ○ ウィンドウを閉じる #-------------------------------------------------------------------------- def close super call_method(:close_status_window) end #-------------------------------------------------------------------------- # ○ 項目の選択 #-------------------------------------------------------------------------- def select(index) super call_method(:select_status_window, index) end #-------------------------------------------------------------------------- # ○ フレーム更新 #-------------------------------------------------------------------------- def update call_method(:update_status_window) return unless self.visible super end #-------------------------------------------------------------------------- # ○ 解放 #-------------------------------------------------------------------------- def dispose super call_method(:dispose_status_window) end end #============================================================================== # ■ Window_PersonalStatus #============================================================================== class Window_PersonalStatus < Window_Base #-------------------------------------------------------------------------- # ○ オブジェクト初期化 #-------------------------------------------------------------------------- def initialize(x, y, opacity = 0) super(x, y, Graphics.width / 2, 120) self.opacity = opacity self.openness = 0 [url=home.php?mod=space&uid=95897]@actor[/url] = nil end #-------------------------------------------------------------------------- # ○ アクターの設定 #-------------------------------------------------------------------------- def actor=(actor) @actor = actor refresh end #-------------------------------------------------------------------------- # ○ リフレッシュ #-------------------------------------------------------------------------- def refresh contents.clear draw_face(@actor.face_name, @actor.face_index, 0, 0) draw_text(116, line_height * 0, contents.width, line_height, @actor.name) draw_actor_level(@actor, 116, 0 + line_height * 1) draw_actor_icons(@actor, 180, 0 + line_height * 1) draw_actor_hp(@actor, 116, 0 + line_height * 2, 128) draw_actor_mp(@actor, 116, 0 + line_height * 3, 60) draw_actor_tp(@actor, 184, 0 + line_height * 3, 60) if $data_system.opt_display_tp end #-------------------------------------------------------------------------- # ○ フレーム更新 #-------------------------------------------------------------------------- def update return unless self.visible super self.visible = false if self.openness == 0 end #-------------------------------------------------------------------------- # ○ オープン #-------------------------------------------------------------------------- def open self.visible = true super end #-------------------------------------------------------------------------- # ○ 顔グラフィックの描画 #-------------------------------------------------------------------------- def draw_face(face_name, face_index, x, y, enabled = true) draw_face_no_dispose(face_name, face_index, x, y, enabled) end end #============================================================================== # ■ RPG::Enemy #============================================================================== class RPG::Enemy < RPG::BaseItem #-------------------------------------------------------------------------- # ○ 初期装備 #-------------------------------------------------------------------------- def equips @equips ||= [0,0,0,0,0] @equips[0] ||= $a1_common.note_data_one(self.note, "エネミー武器", 0) return @equips end end #============================================================================== # ■ Game_Enemy #------------------------------------------------------------------------------ # 敵キャラを扱うクラスです。このクラスは Game_Troop クラス($game_troop)の # 内部で使用されます。 #============================================================================== class Game_Enemy < Game_Battler #-------------------------------------------------------------------------- # ☆ オブジェクト初期化 #-------------------------------------------------------------------------- alias a1_battle_common_ge_initialize initialize def initialize(index, enemy_id) @equips = [] a1_battle_common_ge_initialize(index, enemy_id) init_equips(enemy.equips) end end #============================================================================== # ■ Game_Actor #------------------------------------------------------------------------------ # アクターを扱うクラスです。このクラスは Game_Actors クラス($game_actors) # の内部で使用され、Game_Party クラス($game_party)からも参照されます。 #============================================================================== class Game_Actor < Game_Battler #-------------------------------------------------------------------------- # ★ 装備品の初期化 # equips : 初期装備の配列 #-------------------------------------------------------------------------- def init_equips(equips) super end #-------------------------------------------------------------------------- # ★ 装備タイプからスロット ID に変換(空きを優先) #-------------------------------------------------------------------------- def empty_slot(etype_id) super end #-------------------------------------------------------------------------- # ★ 装備タイプからスロット ID のリストに変換 #-------------------------------------------------------------------------- def slot_list(etype_id) super end #-------------------------------------------------------------------------- # ★ エディタで設定されたインデックスを装備タイプ ID に変換 #-------------------------------------------------------------------------- def index_to_etype_id(index) super end #-------------------------------------------------------------------------- # ★ 装備スロットの配列を取得 #-------------------------------------------------------------------------- def equip_slots super end #-------------------------------------------------------------------------- # ★ 装備品オブジェクトの配列取得 #-------------------------------------------------------------------------- def equips super end #-------------------------------------------------------------------------- # ★ 武器オブジェクトの配列取得 #-------------------------------------------------------------------------- def weapons super end #-------------------------------------------------------------------------- # ★ 通常能力値の加算値取得 #-------------------------------------------------------------------------- def param_plus(param_id) super end #-------------------------------------------------------------------------- # ☆ 通常攻撃 アニメーション ID の取得 #-------------------------------------------------------------------------- alias a1_battle_common_ga_atk_animation_id1 atk_animation_id1 def atk_animation_id1 return a1_battle_common_ga_atk_animation_id1 if !@current_weapon || @current_weapon.is_a?(Array) @current_weapon.animation_id end #-------------------------------------------------------------------------- # ☆ 通常攻撃 アニメーション ID の取得(二刀流:武器2) #-------------------------------------------------------------------------- alias a1_battle_common_ga_atk_animation_id2 atk_animation_id2 def atk_animation_id2 return a1_battle_common_ga_atk_animation_id2 if !@current_weapon || @current_weapon.is_a?(Array) @current_weapon.animation_id end #-------------------------------------------------------------------------- # ○ 装備タイプ名を取得 #-------------------------------------------------------------------------- def e_type_name(item) return $data_system.weapon_types[item.wtype_id] if item.is_a?(RPG::Weapon) return $data_system.armor_types[item.atype_id] if item.is_a?(RPG::Armor) end end #============================================================================== # ■ Game_BattlerBase #------------------------------------------------------------------------------ # バトラーを扱う基本のクラスです。主に能力値計算のメソッドを含んでいます。こ # のクラスは Game_Battler クラスのスーパークラスとして使用されます。 #============================================================================== class Game_BattlerBase #-------------------------------------------------------------------------- # ○ 二刀流? #-------------------------------------------------------------------------- def two_sword_style? weapons[0] && weapons[1] end #-------------------------------------------------------------------------- # ○ バトラーオブジェクト取得 #-------------------------------------------------------------------------- def battler return actor if self.actor? return enemy end end #============================================================================== # ■ Game_Battler #------------------------------------------------------------------------------ # スプライトや行動に関するメソッドを追加したバトラーのクラスです。このクラス # は Game_Actor クラスと Game_Enemy クラスのスーパークラスとして使用されます。 #============================================================================== class Game_Battler < Game_BattlerBase #-------------------------------------------------------------------------- # ○ 公開インスタンス変数 #-------------------------------------------------------------------------- attr_accessor :current_weapon attr_accessor :current_main #-------------------------------------------------------------------------- # ○ 装備品の初期化 # equips : 初期装備の配列 #-------------------------------------------------------------------------- def init_equips(equips) @equips = Array.new(equip_slots.size) { Game_BaseItem.new } equips.each_with_index do |item_id, i| etype_id = index_to_etype_id(i) slot_id = empty_slot(etype_id) @equips[slot_id].set_equip(etype_id == 0, item_id) if slot_id end refresh end #-------------------------------------------------------------------------- # ○ 装備タイプからスロット ID に変換(空きを優先) #-------------------------------------------------------------------------- def empty_slot(etype_id) list = slot_list(etype_id) list.find {|i| @equips[i].is_nil? } || list[0] end #-------------------------------------------------------------------------- # ○ 装備タイプからスロット ID のリストに変換 #-------------------------------------------------------------------------- def slot_list(etype_id) result = [] equip_slots.each_with_index {|e, i| result.push(i) if e == etype_id } result end #-------------------------------------------------------------------------- # ○ エディタで設定されたインデックスを装備タイプ ID に変換 #-------------------------------------------------------------------------- def index_to_etype_id(index) index == 1 && dual_wield? ? 0 : index end #-------------------------------------------------------------------------- # ○ 装備スロットの配列を取得 #-------------------------------------------------------------------------- def equip_slots return [0,0,2,3,4] if dual_wield? # 二刀流 return [0,1,2,3,4] # 通常 end #-------------------------------------------------------------------------- # ○ 装備品オブジェクトの配列取得 #-------------------------------------------------------------------------- def equips @equips.collect {|item| item.object } end #-------------------------------------------------------------------------- # ○ 武器オブジェクトの配列取得 #-------------------------------------------------------------------------- def weapons @equips.select {|item| item.is_weapon? }.collect {|item| item.object } end #-------------------------------------------------------------------------- # ○ 通常能力値の加算値取得 #-------------------------------------------------------------------------- def param_plus(param_id) equips.compact.inject(super) {|r, item| r += item.params[param_id] + ex_item_params(item, param_id) } end #-------------------------------------------------------------------------- # ○ アイテムにかける追加要素 #-------------------------------------------------------------------------- def ex_item_params(item, param_id) return 0 end #-------------------------------------------------------------------------- # ○ スキルを取得 #-------------------------------------------------------------------------- def skill(skill_id) $data_skills[skill_id] end end #============================================================================== # ■ Game_Party #------------------------------------------------------------------------------ # パーティを扱うクラスです。所持金やアイテムなどの情報が含まれます。このクラ # スのインスタンスは $game_party で参照されます。 #============================================================================== class Game_Party < Game_Unit #-------------------------------------------------------------------------- # ☆ アクターを加える #-------------------------------------------------------------------------- alias a1_battle_common_gp_add_actor add_actor def add_actor(actor_id) return a1_battle_common_gp_add_actor(actor_id) unless in_battle return if @actors.include?(actor_id) prev_add_actor(battle_members) insert_actor(actor_id) post_add_actor($game_actors[actor_id]) end #-------------------------------------------------------------------------- # ○ アクターを加える #-------------------------------------------------------------------------- def insert_actor(actor_id) @new_index = @remove_member_index ? @remove_member_index[0] : @actors.size @actors.insert(@new_index, actor_id) unless @actors.include?(actor_id) $game_player.refresh $game_map.need_refresh = true return unless @remove_member_index @remove_member_index.delete_at(0) @remove_member_index = nil if @remove_member_index.empty? end #-------------------------------------------------------------------------- # ○ アクターを加えたIndexを取得 #-------------------------------------------------------------------------- def new_index @new_index end #-------------------------------------------------------------------------- # ○ アクターを加える前処理 #-------------------------------------------------------------------------- def prev_add_actor(members) BattleManager.call_method(:prev_add_battler, members) end #-------------------------------------------------------------------------- # ○ アクターを加えた後処理 #-------------------------------------------------------------------------- def post_add_actor(member) BattleManager.call_method(:post_add_battler, member) end #-------------------------------------------------------------------------- # ☆ アクターを外す #-------------------------------------------------------------------------- alias a1_battle_common_gp_remove_actor remove_actor def remove_actor(actor_id) prev_remove_actor($game_actors[actor_id]) if in_battle a1_battle_common_gp_remove_actor(actor_id) post_remove_actor if in_battle end #-------------------------------------------------------------------------- # ○ アクターを外す前処理 #-------------------------------------------------------------------------- def prev_remove_actor(member) @remove_member_index ||= [] @remove_member_index.push(member.index) BattleManager.call_method(:prev_remove_battler, member) end #-------------------------------------------------------------------------- # ○ アクターを外した後処理 #-------------------------------------------------------------------------- def post_remove_actor BattleManager.call_method(:post_remove_battler) end end #============================================================================== # ■ BattleManager #------------------------------------------------------------------------------ # 戦闘の進行を管理するモジュールです。 #============================================================================== module BattleManager #-------------------------------------------------------------------------- # ○ エイリアス用特異メソッド #-------------------------------------------------------------------------- class << self alias :a1_battle_common_bm_turn_end :turn_end alias :a1_battle_common_bm_turn_start :turn_start alias :a1_battle_common_bm_battle_end :battle_end end #-------------------------------------------------------------------------- # ☆ ターン開始 #-------------------------------------------------------------------------- def self.turn_start @turn_end_wait = 0 a1_battle_common_bm_turn_start end #-------------------------------------------------------------------------- # ☆ ターン終了 #-------------------------------------------------------------------------- def self.turn_end call_method(:wait, @turn_end_wait) if @turn_end_wait > 0 @turn_end_wait = 0 a1_battle_common_bm_turn_end end #-------------------------------------------------------------------------- # ○ メソッドの設定 #-------------------------------------------------------------------------- def self.define_method(method, symbol) @method ||= {} @method[symbol] = method end #-------------------------------------------------------------------------- # ○ メソッドのコール #-------------------------------------------------------------------------- def self.call_method(symbol, *args) @method[symbol].call(*args) if @method[symbol] end #-------------------------------------------------------------------------- # ○ ターン終了後ウェイト設定 #-------------------------------------------------------------------------- def self.turn_end_wait=(flame) @turn_end_wait = flame if @turn_end_wait < flame || flame == 0 end #-------------------------------------------------------------------------- # ☆ 戦闘終了 # result : 結果(0:勝利 1:逃走 2:敗北) #-------------------------------------------------------------------------- def self.battle_end(result) call_method(:battle_end, result) a1_battle_common_bm_battle_end(result) end end #============================================================================== # ■ Game_Action #------------------------------------------------------------------------------ # 戦闘行動を扱うクラスです。このクラスは Game_Battler クラスの内部で使用され # ます。 #============================================================================== class Game_Action #-------------------------------------------------------------------------- # ☆ ターゲットの配列作成 #-------------------------------------------------------------------------- alias a1_battle_common_gac_make_targets make_targets def make_targets @targets ||= pre_make_targets return @targets end #-------------------------------------------------------------------------- # ○ ターゲットの配列先行作成 #-------------------------------------------------------------------------- def pre_make_targets @targets = a1_battle_common_gac_make_targets end #-------------------------------------------------------------------------- # ○ ターゲットの配列を取得 #-------------------------------------------------------------------------- def targets @targets.compact end #-------------------------------------------------------------------------- # ○ ターゲットの配列をクリア #-------------------------------------------------------------------------- def clear_targets @targets = nil end end #============================================================================== # ■ Scene_Battle #------------------------------------------------------------------------------ # バトル画面の処理を行うクラスです。 #============================================================================== class Scene_Battle < Scene_Base #-------------------------------------------------------------------------- # ☆ 開始処理 #-------------------------------------------------------------------------- alias a1_battle_common_sb_start start def start a1_battle_common_sb_start define_battle_manager_method end #-------------------------------------------------------------------------- # ○ バトルマネージャメソッドの定義 #-------------------------------------------------------------------------- def define_battle_manager_method BattleManager.define_method(method(:wait), :wait) BattleManager.define_method(method(:post_add_battler), :post_add_battler) BattleManager.define_method(method(:post_remove_battler), :post_remove_battler) BattleManager.define_method(method(:prev_remove_battler), :prev_remove_battler) BattleManager.define_method(method(:prev_add_battler), :prev_add_battler) BattleManager.define_method(method(:process_victory), :process_victory) BattleManager.define_method(method(:battle_end), :battle_end) end #-------------------------------------------------------------------------- # ☆ ステータスウィンドウの作成 #-------------------------------------------------------------------------- alias a1_battle_common_sb_create_status_window create_status_window def create_status_window a1_battle_common_sb_create_status_window post_create_status_window define_status_window_method end #-------------------------------------------------------------------------- # ○ ステータスウィンドウ作成の後処理 #-------------------------------------------------------------------------- def post_create_status_window end #-------------------------------------------------------------------------- # ○ ステータスウィンドウメソッドの定義 #-------------------------------------------------------------------------- def define_status_window_method @status_window.define_method(method(:refresh_statsu_window), :refresh_statsu_window) @status_window.define_method(method(:close_status_window), :close_status_window) @status_window.define_method(method(:open_status_window), :open_status_window) @status_window.define_method(method(:select_status_window), :select_status_window) @status_window.define_method(method(:update_status_window), :update_status_window) @status_window.define_method(method(:dispose_status_window), :dispose_status_window) end #-------------------------------------------------------------------------- # ○ ステータスウィンドウがリフレッシュされた時の処理 #-------------------------------------------------------------------------- def refresh_statsu_window end #-------------------------------------------------------------------------- # ○ ステータスウィンドウがクローズされた時の処理 #-------------------------------------------------------------------------- def close_status_window end #-------------------------------------------------------------------------- # ○ ステータスウィンドウがオープンされた時の処理 #-------------------------------------------------------------------------- def open_status_window end #-------------------------------------------------------------------------- # ○ ステータスウィンドウがセレクトされた時の処理 #-------------------------------------------------------------------------- def select_status_window(index) end #-------------------------------------------------------------------------- # ○ ステータスウィンドウが更新された時の処理 #-------------------------------------------------------------------------- def update_status_window end #-------------------------------------------------------------------------- # ○ ステータスウィンドウが解放された時の処理 #-------------------------------------------------------------------------- def dispose_status_window end #-------------------------------------------------------------------------- # ☆ 情報表示ビューポートの作成 #-------------------------------------------------------------------------- alias a1_battle_common_sb_create_info_viewport create_info_viewport def create_info_viewport a1_battle_common_sb_create_info_viewport post_create_info_viewport end #-------------------------------------------------------------------------- # ○ 情報表示ビューポート作成の後処理 #-------------------------------------------------------------------------- def post_create_info_viewport end #-------------------------------------------------------------------------- # ☆ スキルウィンドウの作成 #-------------------------------------------------------------------------- alias a1_battle_common_sb_create_skill_window create_skill_window def create_skill_window a1_battle_common_sb_create_skill_window post_create_skill_window define_skill_window_method end #-------------------------------------------------------------------------- # ○ スキルウィンドウ作成の後処理 #-------------------------------------------------------------------------- def post_create_skill_window end #-------------------------------------------------------------------------- # ○ スキルウィンドウメソッドの定義 #-------------------------------------------------------------------------- def define_skill_window_method @skill_window.define_method(method(:skill_item_window_show), :skill_item_window_show) @skill_window.define_method(method(:skill_item_window_hide), :skill_item_window_hide) end #-------------------------------------------------------------------------- # ☆ アイテムウィンドウの作成 #-------------------------------------------------------------------------- alias a1_battle_common_sb_create_item_window create_item_window def create_item_window a1_battle_common_sb_create_item_window post_create_item_window define_item_window_method end #-------------------------------------------------------------------------- # ○ アイテムウィンドウ作成の後処理 #-------------------------------------------------------------------------- def post_create_item_window end #-------------------------------------------------------------------------- # ○ アイテムウィンドウメソッドの定義 #-------------------------------------------------------------------------- def define_item_window_method @item_window.define_method(method(:skill_item_window_show), :skill_item_window_show) @item_window.define_method(method(:skill_item_window_hide), :skill_item_window_hide) end #-------------------------------------------------------------------------- # ○ スキル/アイテムウィンドウが表示された時の処理 #-------------------------------------------------------------------------- def skill_item_window_show end #-------------------------------------------------------------------------- # ○ スキル/アイテムウィンドウが非表示になった時の処理 #-------------------------------------------------------------------------- def skill_item_window_hide end #-------------------------------------------------------------------------- # ☆ パーティコマンドウィンドウの作成 #-------------------------------------------------------------------------- alias a1_battle_common_sb_create_party_command_window create_party_command_window def create_party_command_window a1_battle_common_sb_create_party_command_window post_create_party_command_window define_party_command_window_method define_party_command_window_handle end #-------------------------------------------------------------------------- # ○ パーティコマンドウィンドウ作成の後処理 #-------------------------------------------------------------------------- def post_create_party_command_window end #-------------------------------------------------------------------------- # ○ パーティコマンドウィンドウメソッドの定義 #-------------------------------------------------------------------------- def define_party_command_window_method end #-------------------------------------------------------------------------- # ○ パーティコマンドウィンドウハンドルの定義 #-------------------------------------------------------------------------- def define_party_command_window_handle end #-------------------------------------------------------------------------- # ☆ アクターウィンドウの作成 #-------------------------------------------------------------------------- alias a1_battle_common_sb_create_actor_window create_actor_window def create_actor_window a1_battle_common_sb_create_actor_window post_create_actor_window define_actor_window_method end #-------------------------------------------------------------------------- # ○ アクターウィンドウ作成の後処理 #-------------------------------------------------------------------------- def post_create_actor_window end #-------------------------------------------------------------------------- # ○ アクターウィンドウメソッドの定義 #-------------------------------------------------------------------------- def define_actor_window_method @actor_window.define_method(method(:select_actor), :select_actor) @actor_window.define_method(method(:select_actor_end), :select_actor_end) end #-------------------------------------------------------------------------- # ○ アクターウィンドウをセレクトした時の処理 #-------------------------------------------------------------------------- def select_actor(index) end #-------------------------------------------------------------------------- # ○ アクターウィンドウをセレクト終了した時の処理 #-------------------------------------------------------------------------- def select_actor_end end #-------------------------------------------------------------------------- # ☆ 敵キャラウィンドウの作成 #-------------------------------------------------------------------------- alias a1_battle_common_sb_create_enemy_window create_enemy_window def create_enemy_window a1_battle_common_sb_create_enemy_window post_create_enemy_window define_enemy_window_method end #-------------------------------------------------------------------------- # ○ 敵キャラウィンドウ作成の後処理 #-------------------------------------------------------------------------- def post_create_enemy_window end #-------------------------------------------------------------------------- # ○ 敵キャラウィンドウメソッドの定義 #-------------------------------------------------------------------------- def define_enemy_window_method @enemy_window.define_method(method(:select_enemy), :select_enemy) @enemy_window.define_method(method(:select_enemy_end) ,:select_enemy_end) end #-------------------------------------------------------------------------- # ○ 敵キャラウィンドウをセレクトした時の処理 #-------------------------------------------------------------------------- def select_enemy(index) end #-------------------------------------------------------------------------- # ○ 敵キャラウィンドウをセレクト終了した時の処理 #-------------------------------------------------------------------------- def select_enemy_end end #-------------------------------------------------------------------------- # ☆ アクターコマンドウィンドウの作成 #-------------------------------------------------------------------------- alias a1_battle_common_sb_start_create_actor_command_window create_actor_command_window def create_actor_command_window a1_battle_common_sb_start_create_actor_command_window post_create_actor_command_window define_actor_command_handle define_actor_command_window end #-------------------------------------------------------------------------- # ○ アクターコマンドウィンドウ作成の後処理 #-------------------------------------------------------------------------- def post_create_actor_command_window end #-------------------------------------------------------------------------- # ○ アクターコマンドウィンドウメソッドの定義 #-------------------------------------------------------------------------- def define_actor_command_window @actor_command_window.define_method(method(:actor_command_open), :actor_command_open) @actor_command_window.define_method(method(:actor_command_close), :actor_command_close) @actor_command_window.define_method(method(:actor_command_setup), :actor_command_setup) end #-------------------------------------------------------------------------- # ○ アクターコマンドウィンドウハンドルの定義 #-------------------------------------------------------------------------- def define_actor_command_handle end #-------------------------------------------------------------------------- # ○ アクターコマンドウィンドウがオープンした時の処理 #-------------------------------------------------------------------------- def actor_command_open end #-------------------------------------------------------------------------- # ○ アクターコマンドウィンドウがクローズした時の処理 #-------------------------------------------------------------------------- def actor_command_close end #-------------------------------------------------------------------------- # ○ アクターコマンドウィンドウのセットアップ時の処理 #-------------------------------------------------------------------------- def actor_command_setup(actor) end #-------------------------------------------------------------------------- # ☆ パーティコマンド選択の開始 #-------------------------------------------------------------------------- alias a1_battle_common_sb_start_party_command_selection start_party_command_selection def start_party_command_selection prev_start_party_command_selection a1_battle_common_sb_start_party_command_selection post_start_party_command_selection end #-------------------------------------------------------------------------- # ○ パーティコマンド選択の開始の前処理 #-------------------------------------------------------------------------- def prev_start_party_command_selection end #-------------------------------------------------------------------------- # ○ パーティコマンド選択の開始の後処理 #-------------------------------------------------------------------------- def post_start_party_command_selection end #-------------------------------------------------------------------------- # ☆ 次のコマンド入力へ #-------------------------------------------------------------------------- alias a1_battle_common_sb_next_command next_command def next_command prev_next_command a1_battle_common_sb_next_command post_next_command end #-------------------------------------------------------------------------- # ○ 次のコマンド入力への前処理 #-------------------------------------------------------------------------- def prev_next_command end #-------------------------------------------------------------------------- # ○ 次のコマンド入力への後処理 #-------------------------------------------------------------------------- def post_next_command end #-------------------------------------------------------------------------- # ☆ 前のコマンド入力へ #-------------------------------------------------------------------------- alias a1_battle_common_sb_prior_command prior_command def prior_command prev_prior_command a1_battle_common_sb_prior_command post_prior_command end #-------------------------------------------------------------------------- # ○ 前のコマンド入力への前処理 #-------------------------------------------------------------------------- def prev_prior_command end #-------------------------------------------------------------------------- # ○ 前のコマンド入力への後処理 #-------------------------------------------------------------------------- def post_prior_command end #-------------------------------------------------------------------------- # ☆ ターン開始 #-------------------------------------------------------------------------- alias a1_battle_common_sb_turn_start turn_start def turn_start prev_turn_start a1_battle_common_sb_turn_start post_turn_start end #-------------------------------------------------------------------------- # ○ ターン開始の前処理 #-------------------------------------------------------------------------- def prev_turn_start end #-------------------------------------------------------------------------- # ○ ターン開始の後処理 #-------------------------------------------------------------------------- def post_turn_start end #-------------------------------------------------------------------------- # ☆ ターン終了 #-------------------------------------------------------------------------- alias a1_battle_common_sb_turn_end turn_end def turn_end prev_turn_end a1_battle_common_sb_turn_end post_turn_end end #-------------------------------------------------------------------------- # ○ ターン終了の前処理 #-------------------------------------------------------------------------- def prev_turn_end end #-------------------------------------------------------------------------- # ○ ターン終了の後処理 #-------------------------------------------------------------------------- def post_turn_end end #-------------------------------------------------------------------------- # ○ ウィンドウが閉じるまでウェイト #-------------------------------------------------------------------------- def wait_fot_window_close(window) update_basic while window.close? end #-------------------------------------------------------------------------- # ○ アクターのバトルメンバー取得 #-------------------------------------------------------------------------- def battle_members @party_battle_members ||= $game_party.battle_members return @party_battle_members end #-------------------------------------------------------------------------- # ○ バトルメンバーの追加の前処理 #-------------------------------------------------------------------------- def prev_add_battler(members) end #-------------------------------------------------------------------------- # ○ バトルメンバーの追加後の処理 #-------------------------------------------------------------------------- def post_add_battler(member) @party_battle_members = $game_party.battle_members end #-------------------------------------------------------------------------- # ○ バトルメンバー削除の前処理 #-------------------------------------------------------------------------- def prev_remove_battler(member) end #-------------------------------------------------------------------------- # ○ バトルメンバーの削除後の処理 #-------------------------------------------------------------------------- def post_remove_battler @party_battle_members = $game_party.battle_members end #-------------------------------------------------------------------------- # ☆ 戦闘行動の実行 #-------------------------------------------------------------------------- alias a1_battle_common_sb_execute_action execute_action def execute_action prev_execute_action a1_battle_common_sb_execute_action post_execute_action end #-------------------------------------------------------------------------- # ○ 戦闘行動の実行の前処理 #-------------------------------------------------------------------------- def prev_execute_action @subject.current_action.pre_make_targets end #-------------------------------------------------------------------------- # ○ 戦闘行動の実行の後処理 #-------------------------------------------------------------------------- def post_execute_action @subject.current_action.clear_targets if @subject.current_action end #-------------------------------------------------------------------------- # ☆ スキル/アイテムの使用 #-------------------------------------------------------------------------- alias a1_battle_common_sb_use_item use_item def use_item prev_use_item a1_battle_common_sb_use_item post_use_item end #-------------------------------------------------------------------------- # ○ スキル/アイテムの使用の前処理 #-------------------------------------------------------------------------- def prev_use_item end #-------------------------------------------------------------------------- # ○ スキル/アイテムの使用の後処理 #-------------------------------------------------------------------------- def post_use_item end #-------------------------------------------------------------------------- # ○ 勝利の処理 #-------------------------------------------------------------------------- def process_victory end #-------------------------------------------------------------------------- # ○ 戦闘終了 #-------------------------------------------------------------------------- def battle_end(result) $game_party.all_members.each {|member| init_member_battle_end(member) } end #-------------------------------------------------------------------------- # ○ 戦闘終了時のメンバー初期化 #-------------------------------------------------------------------------- def init_member_battle_end(member) member.current_weapon = nil member.current_main = nil end end end
#=========================================================================== # ◆ A1 Scripts ◆ # 戦闘中入れ替え(RGSS3) # # バージョン : 1.00 (2012/01/18) # 作者 : A1 # URL : [url]http://a1tktk.web.fc2.com/[/url] #--------------------------------------------------------------------------- # 機能: # ・戦闘中にメンバーを入れ替えます #--------------------------------------------------------------------------- # 更新履歴 :2012/01/18 Ver1.00 リリース #--------------------------------------------------------------------------- # 設置場所 # A1バトル共通スクリプト以下 # # 必要スクリプト # A1バトル共通スクリプト #--------------------------------------------------------------------------- # 使い方 # 導入することで適用されます #============================================================================== $imported ||= {} if $imported["A1_BattleCommonScript"] $imported["A1_ChangeMember"] = true old_common_script("戦闘中入れ替え", "3.90") if common_version < 3.90 #============================================================================== # ■ Window_PartyCommand #============================================================================== class Window_MemberChange < Window_Selectable #-------------------------------------------------------------------------- # ○ オブジェクト初期化 #-------------------------------------------------------------------------- def initialize @form_actor_window = Window_PersonalStatus.new(0, Graphics.height - 120, 255) @to_actor_window = Window_PersonalStatus.new(Graphics.width / 2, Graphics.height - 120, 255) setup_members width = @battle_members.size * 48 + standard_padding * 2 height = (@all_members.size / @battle_members.size.to_f).ceil * 48 + standard_padding * 2 + 36 super((Graphics.width - width) / 2, (Graphics.height - height) / 2, width, height) self.y = Graphics.height - @form_actor_window.height - height if self.y + height > Graphics.height - @form_actor_window.height self.index = 0 @from_actor = -1 self.openness = 0 end #-------------------------------------------------------------------------- # ○ アクティブ化 #-------------------------------------------------------------------------- def activate super refresh @form_actor_window.actor = @all_members[self.index] end #-------------------------------------------------------------------------- # ○ メンバーのセットアップ #-------------------------------------------------------------------------- def setup_members @all_members = $game_party.all_members @battle_members = $game_party.battle_members end #-------------------------------------------------------------------------- # ○ 項目の選択 #-------------------------------------------------------------------------- def select(index) super @form_actor_window.actor = @all_members[self.index] if @from_actor == -1 @to_actor_window.actor = @all_members[self.index] if @from_actor >= 0 end #-------------------------------------------------------------------------- # ○ 項目数の取得 #-------------------------------------------------------------------------- def item_max @all_members.size end #-------------------------------------------------------------------------- # ○ 桁数の取得 #-------------------------------------------------------------------------- def col_max @battle_members.size end #-------------------------------------------------------------------------- # ○ リフレッシュ #-------------------------------------------------------------------------- def refresh super draw_horz_line(52) end #-------------------------------------------------------------------------- # ○ 水平線の描画 #-------------------------------------------------------------------------- def draw_horz_line(y) line_y = y + line_height / 2 - 1 contents.fill_rect(0, line_y, contents_width, 2, line_color) end #-------------------------------------------------------------------------- # ○ 水平線の色を取得 #-------------------------------------------------------------------------- def line_color color = normal_color color.alpha = 128 color end #-------------------------------------------------------------------------- # ○ 項目の描画 #-------------------------------------------------------------------------- def draw_item(index) c_name = member(index).character_name c_index = member(index).character_index rect = item_rect(index) draw_character(c_name, c_index, rect.x + 24, rect.y + 40) end #-------------------------------------------------------------------------- # ○ 項目を描画する矩形の取得 #-------------------------------------------------------------------------- def item_rect(index) rect = Rect.new rect.width = item_width rect.height = item_height rect.x = index % col_max * item_width rect.y = index / col_max * item_height rect.y += 24 if index > @battle_members.size - 1 rect end #-------------------------------------------------------------------------- # ○ 項目の幅を取得 #-------------------------------------------------------------------------- def item_width return 48 end #-------------------------------------------------------------------------- # ○ 項目の高さを取得 #-------------------------------------------------------------------------- def item_height return 48 end #-------------------------------------------------------------------------- # ○ ウィンドウ内容の高さを計算 #-------------------------------------------------------------------------- def contents_height row_max * item_height + 24 end #-------------------------------------------------------------------------- # ○ 下端パディングの更新 #-------------------------------------------------------------------------- def update_padding_bottom surplus = (height - standard_padding * 2) % item_height - 24 self.padding_bottom = padding + surplus end #-------------------------------------------------------------------------- # ○ メンバーの取得 #-------------------------------------------------------------------------- def member(index) @all_members[index] end #-------------------------------------------------------------------------- # ○ 決定処理の有効状態を取得 #-------------------------------------------------------------------------- def ok_enabled? return true end #-------------------------------------------------------------------------- # ○ 決定ボタンが押されたときの処理 #-------------------------------------------------------------------------- def process_ok Sound.play_ok Input.update return select_start_to_actor if @from_actor == -1 return call_cancel_handler if @from_actor == self.index change_member if @from_actor >= 0 post_change_member end #-------------------------------------------------------------------------- # ○ メンバー入れ替え #-------------------------------------------------------------------------- def change_member $game_party.swap_order(@from_actor, self.index) end #-------------------------------------------------------------------------- # ○ メンバー入れ替え後の処理 #-------------------------------------------------------------------------- def post_change_member setup_members self.index = @from_actor @form_actor_window.actor = @all_members[self.index] @from_actor = -1 @to_actor_window.close refresh end #-------------------------------------------------------------------------- # ○ 入れ替え先のアクター選択開始 #-------------------------------------------------------------------------- def select_start_to_actor @from_actor = self.index @to_actor_window.open self.index = self.index < @battle_members.size ? @battle_members.size : 0 @to_actor_window.actor = @all_members[self.index] end #-------------------------------------------------------------------------- # ○ 入れ替え元のアクター #-------------------------------------------------------------------------- def from_actor @from_actor end #-------------------------------------------------------------------------- # ○ オープン #-------------------------------------------------------------------------- def open super @form_actor_window.open end #-------------------------------------------------------------------------- # ○ キャンセルハンドラの呼び出し #-------------------------------------------------------------------------- def call_cancel_handler super if @from_actor == -1 @from_actor = -1 @to_actor_window.close @form_actor_window.actor = @all_members[self.index] activate end #-------------------------------------------------------------------------- # ○ クローズ #-------------------------------------------------------------------------- def close super @form_actor_window.close @to_actor_window.close end #-------------------------------------------------------------------------- # ○ フレーム更新 #-------------------------------------------------------------------------- def update super @form_actor_window.update @to_actor_window.update end #-------------------------------------------------------------------------- # ○ 解放 #-------------------------------------------------------------------------- def dispose super @form_actor_window.dispose @to_actor_window.dispose end end #============================================================================== # ■ Window_PartyCommand #------------------------------------------------------------------------------ # バトル画面で、戦うか逃げるかを選択するウィンドウです。 #============================================================================== class Window_PartyCommand < Window_Command #-------------------------------------------------------------------------- # ☆ コマンドリストの作成 #-------------------------------------------------------------------------- alias a1_cbm_wpc_make_command_list make_command_list def make_command_list a1_cbm_wpc_make_command_list add_command("入れ替え", :member_change, $game_party.all_members.size > $game_party.max_battle_members) end end #============================================================================== # ■ Scene_Battle #------------------------------------------------------------------------------ # バトル画面の処理を行うクラスです。 #============================================================================== class Scene_Battle < Scene_Base #-------------------------------------------------------------------------- # ☆ 全ウィンドウの作成 #-------------------------------------------------------------------------- alias a1_cbm_wpc_create_all_windows create_all_windows def create_all_windows a1_cbm_wpc_create_all_windows create_member_change_window end #-------------------------------------------------------------------------- # ○ 入れ替えウィンドウの作成 #-------------------------------------------------------------------------- def create_member_change_window @window_member_change = Window_MemberChange.new @window_member_change.set_handler(:cancel, method(:on_member_change_cancel)) end #-------------------------------------------------------------------------- # ☆ パーティコマンドウィンドウハンドルの定義 #-------------------------------------------------------------------------- alias a1_cbm_sb_define_party_command_window_handle define_party_command_window_handle def define_party_command_window_handle a1_cbm_sb_define_party_command_window_handle @party_command_window.set_handler(:member_change, method(:command_member_change)) end #-------------------------------------------------------------------------- # ○ 入れ替え #-------------------------------------------------------------------------- def command_member_change @prev_battle_members = $game_party.battle_members @status_window.close @party_command_window.close @window_member_change.open @window_member_change.activate end #-------------------------------------------------------------------------- # ○ 変更したメンバーを取得 #-------------------------------------------------------------------------- def change_diss_members(ret = []) $game_party.battle_members.each_with_index {|member, i| ret.push(member) if member != @prev_battle_members[i] } return ret end #-------------------------------------------------------------------------- # ○ メンバーチェンジ[キャンセル] #-------------------------------------------------------------------------- def on_member_change_cancel @party_command_window.activate @status_window.refresh @status_window.open @party_command_window.open @window_member_change.close change_diss_members.each {|member| member.make_actions } @party_battle_members = $game_party.battle_members end end end
欢迎光临 Project1 (https://rpg.blue/) | Powered by Discuz! X3.1 |