帮忙翻译下

气味123 · 发表于 2011-1-1 15:54:19

加入我们，或者，欢迎回来。

您需要登录才可以下载或查看，没有帐号？注册会员

x

本帖最后由气味123 于 2011-1-3 11:13 编辑

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#_/ ◆ 連係スキル - KGC_CooperationSkill ◆ VX ◆
#_/ ◇ Last update : 2009/01/25 ◇
#_/----------------------------------------------------------------------------
#_/ 複数のスキルを組み合わせ、別のスキルを発動させる機能です。
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#==============================================================================
# ★ カスタマイズ項目 - Customize BEGIN ★
#==============================================================================
module KGC
module CooperationSkill
# ◆ 連係発動時の名前の区切り文字
NAME_SEPARATOR = "、"
# ◆ 連係元スキル発動
# true : 連係元となるスキルもすべて発動する。
# false : 連係スキルのみ発動する。
# ※ 併用するスクリプトによっては効果がない場合があります。
EXECUTE_ORIGIN_SKILL = false
# ◆ ターゲットが同じ場合のみ連係を発動
# true : 元のスキルがすべて同じターゲット(または全体)の場合のみ発動。
# ※ ターゲットがランダムのスキルとは相性が良くありません。
# false : ターゲットが誰でもスキル条件さえ満たせば発動。
# 連係スキルのターゲットは、発動時の行動者のターゲット。
SAME_TARGET_ONLY = true
# ◆ 敵連係スキル許可
# true : 敵も連係スキル判定を行う。
# false : 敵は連係スキルを使用不可。
PERMIT_ENEMY = true
end
end
#==============================================================================
# ☆ カスタマイズ項目終了 - Customize END ☆
#==============================================================================
$imported = {} if $imported == nil
$imported["CooperationSkill"] = true
module KGC
module CooperationSkill
# 連係スキル用条件パラメータ
PARAMS = {
:level_avg => "LEVEL_AVG|平均レベル",
:level_min => "LEVEL_MIN|最[小低]レベル",
:level_max => "LEVEL_MAX|最[大高]レベル",
}
# 連係スキル用属性・ステートリスト
ARRAYS = {
:attack_element => "ATTACK_ELEMENT|攻撃属性",
:state => "STATE|ステート",
}
module Regexp
module Skill
# 連係スキル開始
BEGIN_COOPERATE = /<(?:COOPERATION_SKILL|連[係繋]スキル)>/i
# 連係スキル終了
END_COOPERATE = /<\/(?:COOPERATION_SKILL|連[係繋]スキル)>/i
# 必要スキルリスト
NEED_SKILLS = /^\s*(?:NEED_SKILLS?|必要スキル)\s*(\d+(?:\s*,\s*\d+)*)\s*/i
REG_NAME = '[^:\+\-\d\s]+'
REG_OU = 'OVER|UNDER|以上|以下'
# 条件パラメータ
# レベル 10 以上など
COOPERATE_PARAMS = /^\s*(#{REG_NAME})\s*(\d+)\s*(#{REG_OU})?\s*$/i
# 属性・ステートリスト
# ステート 1,-2,3 など
COOPERATE_ARRAYS = /^\s*(#{REG_NAME})\s*(\d+(?:\s*,\s*\-?\d+)*)\s*$/i
end
end
end
end
#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
#==============================================================================
# ■ RPG::Skill
#==============================================================================
class RPG::Skill < RPG::UsableItem
#--------------------------------------------------------------------------
# ○ 連係スキルであるか
#--------------------------------------------------------------------------
def is_cooperation?
self.note.each_line { |line|
# 開始タグを探す
if line =~ KGC::CooperationSkill::Regexp::Skill::BEGIN_COOPERATE
return true
end
}
return false
end
end
#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
#==============================================================================
# ■ Game_Temp
#==============================================================================
class Game_Temp
#--------------------------------------------------------------------------
# ● 公開インスタンス変数
#--------------------------------------------------------------------------
attr_accessor :judging_cooperation_skill # 連係スキル判定中フラグ
#--------------------------------------------------------------------------
# ● オブジェクト初期化
#--------------------------------------------------------------------------
alias initialize_KGC_CooperationSkill initialize
def initialize
initialize_KGC_CooperationSkill
@judging_cooperation_skill = false
end
end
#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
#==============================================================================
# □ Game_CooperationSkill
#------------------------------------------------------------------------------
# 連係スキルの情報を扱うクラスです。
#==============================================================================
class Game_CooperationSkill
#--------------------------------------------------------------------------
# ○ 公開インスタンス変数
#--------------------------------------------------------------------------
attr_reader :id # 発動スキル ID
attr_reader :need_skills # 必要スキル ID リスト
attr_reader :params # 条件パラメータ
attr_reader :params_over # 条件パラメータ: ～以上
attr_reader :need_arrays # 必要属性・ステートリスト
attr_reader :disuse_arrays # 不要属性・ステートリスト
#--------------------------------------------------------------------------
# ○ オブジェクト初期化
# skill_id : スキル ID
# note : メモ
#--------------------------------------------------------------------------
def initialize(skill_id, note)
@id = skill_id
@need_skills = []
@params = {}
@params_over = {}
@need_arrays = {}
@disuse_arrays = {}
parse_note(note)
end
#--------------------------------------------------------------------------
# ○ スキルを取得
#--------------------------------------------------------------------------
def skill
return $data_skills[@id]
end
#--------------------------------------------------------------------------
# ○ メモ欄を解析
# note : メモ
#--------------------------------------------------------------------------
def parse_note(note)
coop_flag = false
note.each_line { |line|
case line
when KGC::CooperationSkill::Regexp::Skill::BEGIN_COOPERATE
# 連係スキル定義開始
coop_flag = true
when KGC::CooperationSkill::Regexp::Skill::END_COOPERATE
# 連係スキル定義終了
coop_flag = false
end
next unless coop_flag
case line
when KGC::CooperationSkill::Regexp::Skill::NEED_SKILLS
# 必要スキル
parse_need_skills($1.scan(/\-?\d+/))
when KGC::CooperationSkill::Regexp::Skill::COOPERATE_PARAMS
# パラメータ
parse_params($1, $2.to_i, $3)
when KGC::CooperationSkill::Regexp::Skill::COOPERATE_ARRAYS
# 属性・ステート
parse_arrays($1, $2.scan(/\-?\d+/))
end
}
end
#--------------------------------------------------------------------------
# ○ 必要スキルを解析
# list : スキル ID 一覧
#--------------------------------------------------------------------------
def parse_need_skills(list)
skills = []
list.each { |num|
skills |= [num.to_i]
}
@need_skills << skills
end
#--------------------------------------------------------------------------
# ○ 連係スキルの能力値修正を適用
# param : 対象パラメータ
# value : 修正値
# cond : 以上 or 以下
#--------------------------------------------------------------------------
def parse_params(param, value, cond)
KGC::CooperationSkill::PARAMS.each { |k, v|
next if param !~ /(?:#{v})/i
@params[k] = value
@params_over[k] = (cond !~ /UNDER|以下/i)
break
}
end
#--------------------------------------------------------------------------
# ○ 連係スキルの追加属性・ステートを適用
# param : 対象パラメータ
# list : 属性・ステート一覧
#--------------------------------------------------------------------------
def parse_arrays(param, list)
KGC::CooperationSkill::ARRAYS.each { |k, v|
next if param !~ /(?:#{v})/i
if @need_arrays[k] == nil
@need_arrays[k] = []
@disuse_arrays[k] = []
end
list.each { |num|
n = num.to_i
if n > 0
@need_arrays[k] |= [n]
else
@disuse_arrays[k] |= [n.abs]
end
}
break
}
end
end
#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
$data_skills = load_data("Data/Skills.rvdata") if $data_skill == nil
module KGC::CooperationSkill
# 連係スキルリストを変換
list = []
$data_skills.each { |skill|
next if skill == nil
next unless skill.is_cooperation?
list << Game_CooperationSkill.new(skill.id, skill.note)
}
SKILLS = list
end
#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
#==============================================================================
# ■ Game_Actor
#==============================================================================
class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# ● スキルの使用可能判定
# skill : スキル
#--------------------------------------------------------------------------
def skill_can_use?(skill)
return super
end
end
#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
#==============================================================================
# □ Game_CooperationSkillUser
#------------------------------------------------------------------------------
# 連係スキル発動者の情報を扱うクラスです。
#==============================================================================
class Game_CooperationSkillUser
#--------------------------------------------------------------------------
# ○ 公開インスタンス変数
#--------------------------------------------------------------------------
attr_reader :index # 発動者のインデックス
attr_reader :skill_id # 発動者が使用したスキル ID
attr_reader :target_battlers # 攻撃対象
#--------------------------------------------------------------------------
# ○ オブジェクト初期化
#--------------------------------------------------------------------------
def initialize(battler)
if $imported["Counter"]
battler.action.made_targets = nil
end
@index = battler.index
@skill_id = battler.action.skill_id
@target_battlers = []
battler.action.make_targets.each { |t|
@target_battlers << t.index
}
end
#--------------------------------------------------------------------------
# ○ 同値判定
#--------------------------------------------------------------------------
def equal?(obj)
return false unless obj.is_a?(Game_CooperationSkillUser)
return false if @index != obj.index
return false if skill_id != obj.skill_id
return false if @target_battlers != obj.target_battlers
return true
end
#--------------------------------------------------------------------------
# ○ 等値演算子
#--------------------------------------------------------------------------
def ==(obj)
return self.equal?(obj)
end
end
#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
#==============================================================================
# □ Game_CooperationBattler
#------------------------------------------------------------------------------
# 連係スキル発動時のダミーバトラークラスです。
#==============================================================================
class Game_CooperationBattler < Game_Battler
#--------------------------------------------------------------------------
# ● 公開インスタンス変数
#--------------------------------------------------------------------------
attr_accessor :battler_type # :actor or :enemy
attr_accessor :exec_battlers # 発動者リスト
attr_accessor :coop_skill # 連係スキル情報
#--------------------------------------------------------------------------
# ● オブジェクト初期化
#--------------------------------------------------------------------------
def initialize
@battler_type = :actor
@exec_battlers = []
@coop_skill = nil
super
end
#--------------------------------------------------------------------------
# ● アクターか否かの判定
#--------------------------------------------------------------------------
def actor?
return (@battler_type == :actor)
end
#--------------------------------------------------------------------------
# ● インデックス取得
#--------------------------------------------------------------------------
def index
return 0
end
#--------------------------------------------------------------------------
# ● 表示名の取得
#--------------------------------------------------------------------------
def name
str = ""
members = (actor? ? $game_party : $game_troop).members
exec_battlers.each_with_index { |b, i|
str += members[b.index].name
if i < exec_battlers.size - 1
str += KGC::CooperationSkill::NAME_SEPARATOR
end
}
return str
end
#--------------------------------------------------------------------------
# ● レベルの取得
#--------------------------------------------------------------------------
def level
values = []
exec_battlers.each { |b| values << b.level }
return values.max
end
#--------------------------------------------------------------------------
# ○ 最大レベルの取得
#--------------------------------------------------------------------------
def level_max
return level
end
#--------------------------------------------------------------------------
# ○ 平均レベルの取得
#--------------------------------------------------------------------------
def level_avg
n = 0
exec_battlers.each { |b| n += b.level }
return (n / exec_battlers.size)
end
#--------------------------------------------------------------------------
# ● MaxHP の取得
#--------------------------------------------------------------------------
def maxhp
values = []
exec_battlers.each { |b| values << b.maxhp }
return values.max
end
#--------------------------------------------------------------------------
# ● MaxMP の取得
#--------------------------------------------------------------------------
def maxmp
values = []
exec_battlers.each { |b| values << b.maxmp }
return values.max
end
#--------------------------------------------------------------------------
# ● HP の取得
#--------------------------------------------------------------------------
def hp
values = []
exec_battlers.each { |b| values << b.hp }
return values.min
end
#--------------------------------------------------------------------------
# ● MP の取得
#--------------------------------------------------------------------------
def mp
values = []
exec_battlers.each { |b| values << b.mp }
return values.min
end
#--------------------------------------------------------------------------
# ○ ドライブゲージ量取得
#--------------------------------------------------------------------------
def overdrive
values = []
exec_battlers.each { |b| values << b.overdrive }
return values.min
end
#--------------------------------------------------------------------------
# ● 攻撃力の取得
#--------------------------------------------------------------------------
def atk
values = []
exec_battlers.each { |b| values << b.atk }
return values.max
end
#--------------------------------------------------------------------------
# ● 防御力の取得
#--------------------------------------------------------------------------
def def
values = []
exec_battlers.each { |b| values << b.def }
return values.max
end
#--------------------------------------------------------------------------
# ● 精神力の取得
#--------------------------------------------------------------------------
def spi
values = []
exec_battlers.each { |b| values << b.spi }
return values.max
end
#--------------------------------------------------------------------------
# ● 敏捷性の取得
#--------------------------------------------------------------------------
def agi
values = []
exec_battlers.each { |b| values << b.agi }
return values.max
end
#--------------------------------------------------------------------------
# ● 命中率の取得
#--------------------------------------------------------------------------
def hit
values = []
exec_battlers.each { |b| values << b.hit }
return [values.max, 100].max
end
#--------------------------------------------------------------------------
# ● 回避率の取得
#--------------------------------------------------------------------------
def eva
return 0
end
#--------------------------------------------------------------------------
# ● クリティカル率の取得
#--------------------------------------------------------------------------
def cri
values = []
exec_battlers.each { |b| values << b.cri }
return values.max
end
#--------------------------------------------------------------------------
# ● MP の変更
# mp : 新しい MP
#--------------------------------------------------------------------------
def mp=(mp)
# 加担者全員の MP を減らす
diff = self.mp - mp
exec_battlers.each { |b| b.mp -= diff }
end
#--------------------------------------------------------------------------
# ○ ドライブゲージの操作
#--------------------------------------------------------------------------
def overdrive=(value)
# 加担者全員のドライブゲージを減らす
diff = self.overdrive - overdrive
exec_battlers.each { |b| b.overdrive -= diff }
end
#--------------------------------------------------------------------------
# ● 全回復
#--------------------------------------------------------------------------
def recover_all
# 何もしない
end
#--------------------------------------------------------------------------
# ● 戦闘不能判定
#--------------------------------------------------------------------------
def dead?
exec_battlers.each { |b|
return true if b.dead?
}
return false
end
#--------------------------------------------------------------------------
# ● 存在判定
#--------------------------------------------------------------------------
def exist?
exec_battlers.each { |b|
return false unless b.exist?
}
return true
end
#--------------------------------------------------------------------------
# ● コマンド入力可能判定
#--------------------------------------------------------------------------
def inputable?
exec_battlers.each { |b|
return false unless b.inputtable?
}
return true
end
#--------------------------------------------------------------------------
# ● 行動可能判定
#--------------------------------------------------------------------------
def movable?
exec_battlers.each { |b|
return false unless b.movable?
}
return true
end
#--------------------------------------------------------------------------
# ● 沈黙状態判定
#--------------------------------------------------------------------------
def silent?
exec_battlers.each { |b|
return true if b.silent?
}
return false
end
#--------------------------------------------------------------------------
# ● 暴走状態判定
#--------------------------------------------------------------------------
def berserker?
return false
end
#--------------------------------------------------------------------------
# ● 混乱状態判定
#--------------------------------------------------------------------------
def confusion?
return false
end
#--------------------------------------------------------------------------
# ● 防御中判定
#--------------------------------------------------------------------------
def guarding?
return false
end
#--------------------------------------------------------------------------
# ● 通常攻撃の属性取得
#--------------------------------------------------------------------------
def element_set
result = []
exec_battlers.each { |b| result |= b.element_set }
return result
end
#--------------------------------------------------------------------------
# ● 通常攻撃のステート変化 (+) 取得
#--------------------------------------------------------------------------
def plus_state_set
result = []
exec_battlers.each { |b| result |= b.plus_state_set }
return result
end
#--------------------------------------------------------------------------
# ● 通常攻撃のステート変化 (-) 取得
#--------------------------------------------------------------------------
def minus_state_set
result = []
exec_battlers.each { |b| result |= b.minus_state_set }
return result
end
#--------------------------------------------------------------------------
# ● ステート [スリップダメージ] 判定
#--------------------------------------------------------------------------
def slip_damage?
return false
end
#--------------------------------------------------------------------------
# ● ステート [命中率減少] 判定
#--------------------------------------------------------------------------
def reduce_hit_ratio?
return false
end
end
#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
#==============================================================================
# ■ Scene_Battle
#==============================================================================
class Scene_Battle < Scene_Base
#--------------------------------------------------------------------------
# ● 開始処理
#--------------------------------------------------------------------------
alias start_KGC_CooperationSkill start
def start
start_KGC_CooperationSkill
init_cooperation_skill
end
#--------------------------------------------------------------------------
# ○ 連係スキル用変数初期化
#--------------------------------------------------------------------------
def init_cooperation_skill
@cooperation_skill_judged = false
@cooperation_skill_exec = false
@cooperation_skill_data = nil
@cooperate_actors = []
@cooperate_enemies = []
end
#--------------------------------------------------------------------------
# ● パーティコマンド選択の開始
#--------------------------------------------------------------------------
alias start_party_command_selection_KGC_CooperationSkill
start_party_command_selection
def start_party_command_selection
if $game_temp.in_battle
init_cooperation_skill
end
start_party_command_selection_KGC_CooperationSkill
end
#--------------------------------------------------------------------------
# ● 戦闘処理の実行開始
#--------------------------------------------------------------------------
alias start_main_KGC_CooperationSkill start_main
def start_main
start_main_KGC_CooperationSkill
init_cooperate_battler_list
end
#--------------------------------------------------------------------------
# ○ 判定用データ初期化
#--------------------------------------------------------------------------
def init_cooperate_battler_list
[:actor, :enemy].each { |i|
case i
when :actor
cooperate_battlers = @cooperate_actors
members = $game_party.members
when :enemy
cooperate_battlers = @cooperate_enemies
members = $game_troop.members
end
# 対象側バトラーを設定
cooperate_battlers.clear
unless KGC::CooperationSkill::EXECUTE_ORIGIN_SKILL
members.each { |battler|
next unless battler.action.skill?
cooperate_battlers << Game_CooperationSkillUser.new(battler)
}
end
}
end
#--------------------------------------------------------------------------
# ● 戦闘行動の実行
#--------------------------------------------------------------------------
alias execute_action_KGC_CooperationSkill execute_action
def execute_action
@cooperation_skill_judged = false
if KGC::CooperationSkill::EXECUTE_ORIGIN_SKILL
execute_action_KGC_CooperationSkill
judge_cooperation_skill(@active_battler)
else
judge_cooperation_skill(@active_battler)
unless @cooperation_skill_judged && @cooperation_skill_exec
execute_action_KGC_CooperationSkill
end
end
if @cooperation_skill_exec
if @cooperation_skill_judged
execute_cooperation_skill
else
finish_cooperation_skill
end
end
end
#--------------------------------------------------------------------------
# ○ 連係スキル第一発動判定
# battler : 行動者
#--------------------------------------------------------------------------
def judge_cooperation_skill(battler)
return false if @cooperation_skill_judged
return false if @cooperation_skill_exec
@cooperation_skill_judged = true
unit = (battler.is_a?(Game_Actor) ? $game_troop : $game_party)
if battler.action.kind == 1
# 対象が残っていれば第二発動判定
unless unit.all_dead?
return judge_cooperation_skill_second(battler)
end
else
# 行動がスキル以外なら判定用配列から削除
if unit.is_a?(Game_Party)
remove_cooperate_battler(:actor, battler)
elsif unit.is_a?(Game_Troop)
remove_cooperate_battler(:enemy, battler)
end
end
return false
end
#--------------------------------------------------------------------------
# ○ 連係加担者削除
# type : :actor or :enemy
# battler : 削除対象
#--------------------------------------------------------------------------
def remove_cooperate_battler(type, battler)
battlers = (type == :actor ? @cooperate_actors : @cooperate_enemies)
battlers.each_index { |i|
if battlers[i].index == battler.index
battlers[i] = nil
end
}
battlers.compact!
end
#--------------------------------------------------------------------------
# ○ 連係スキル第二発動判定
# battler : 行動者
#--------------------------------------------------------------------------
def judge_cooperation_skill_second(battler)
# 判定用データ作成
@current_cooperate_user = Game_CooperationSkillUser.new(battler)
if battler.is_a?(Game_Actor)
remove_cooperate_battler(:actor, battler)
@cooperate_actors |= [@current_cooperate_user]
elsif battler.is_a?(Game_Enemy)
remove_cooperate_battler(:enemy, battler)
@cooperate_enemies |= [@current_cooperate_user]
end
# 連係スキル発動判定
KGC::CooperationSkill::SKILLS.each { |cs|
# アクター判定
if battler.is_a?(Game_Actor)
judge_cooperation_skill_third(:actor, cs)
# エネミー判定
elsif battler.is_a?(Game_Enemy)
judge_cooperation_skill_third(:enemy, cs)
end
break if @cooperation_skill_exec
}
return @cooperation_skill_exec
end
#--------------------------------------------------------------------------
# ○ 連係スキル第三発動判定
# type : :actor or :enemy
# cs_data : Cooperation skill data
#--------------------------------------------------------------------------
def judge_cooperation_skill_third(type, cs_data)
if type == :enemy
# エネミーに発動させない場合は戻る
return unless KGC::CooperationSkill::PERMIT_ENEMY
end
@cooperation_skill_exec = false
case type
when :actor
cooperate_battlers = @cooperate_actors
members = $game_party.members
when :enemy
cooperate_battlers = @cooperate_enemies
members = $game_troop.members
end
@exec_battlers = create_cooperation_exec_battlers(cs_data,
cooperate_battlers, members)
# 行動者が加担していなければ戻る
return if @exec_battlers.empty?
# 同一ターゲットを指定していなければ戻る
return unless same_target_include?(cs_data, cooperate_battlers, members)
$game_temp.judging_cooperation_skill = true
prepare_cooperation_exec(type, cs_data, cooperate_battlers, members)
$game_temp.judging_cooperation_skill = false
end
#--------------------------------------------------------------------------
# ○ 連係スキル発動者リスト作成
# cs_data : Cooperation skill data
# cooperate_battlers : 連係加担者リスト
# members : 連係加担側のメンバー全体
#--------------------------------------------------------------------------
def create_cooperation_exec_battlers(cs_data, cooperate_battlers, members)
battlers = []
cs_data.need_skills.each { |ns|
battlers.clear
# 行動者加担判定
next unless ns.include?(@current_cooperate_user.skill_id)
# 全必要スキル充足判定
skills = ns.clone
ns.each { |skill_id|
user = cooperate_battlers.find { |cb|
skill_id == cb.skill_id && !battlers.include?(cb)
}
# 使用者がいなければ失敗判定
if user == nil
battlers.clear
skills = [0]
break
end
battlers << user
skills.delete(skill_id)
}
break if skills.empty? # 判定用配列が空 ==> 必要スキル充足
}
unless cooperation_conditions_satisfy?(cs_data, battlers, members)
battlers = []
end
return battlers
end
#--------------------------------------------------------------------------
# ○ 使用条件充足判定
# cs_data : Cooperation skill data
# candidate_battlers : 判定対象の連係加担者リスト
# members : 連係加担側のメンバー全体
#--------------------------------------------------------------------------
def cooperation_conditions_satisfy?(cs_data, candidate_battlers, members)
return if candidate_battlers.empty?
# パラメータ算出
level_avg = 0
levels = []
candidate_battlers.each { |cb|
battler = members[cb.index]
level_avg += battler.level
levels << battler.level
}
level_avg /= members.size
comp = Proc.new { |a, b, over| over ? a >= b : a <= b } # 判定用 Proc
cs_data.params.each { |k, v|
param = 0
case k
when :level_avg # 平均レベル
param = level_avg
when :level_min # 最低レベル
param = levels.min
when :level_max # 最高レベル
param = levels.max
end
return false unless comp.call(param, v, cs_data.params_over[k])
}
return true
end
#--------------------------------------------------------------------------
# ○ 連係ターゲット一致判定
# cs_data : Cooperation skill data
# cooperate_battlers : 連係加担者リスト
# members : 連係加担側のメンバー全体
#--------------------------------------------------------------------------
def same_target_include?(cs_data, cooperate_battlers, members)
return true unless KGC::CooperationSkill::SAME_TARGET_ONLY
# 同じターゲットを指定しているか判定
duplicate_battlers = (0..99).to_a
@exec_battlers.each { |eb|
duplicate_battlers &= eb.target_battlers
}
return (duplicate_battlers.size > 0)
end
#--------------------------------------------------------------------------
# ○ 連係発動準備
# type : :actor or :enemy
# cs_data : Cooperation skill data
# cooperate_battlers : 連係加担者リスト
# members : 連係加担側のメンバー全体
#--------------------------------------------------------------------------
def prepare_cooperation_exec(type, cs_data, cooperate_battlers, members)
# 発動可否判定
@exec_battlers.each { |eb|
battler = members[eb.index]
unless battler.exist? && battler.skill_can_use?(cs_data.skill)
return
end
}
@cooperation_skill_exec = true
@cooperation_skill_data = cs_data
@cooperation_skill_user = type
# 発動者を行動順リストから削除
cooperate_battlers.each_with_index { |cb, i|
if @exec_battlers.include?(cb)
@action_battlers.delete(members[cb.index])
cooperate_battlers[i] = nil
end
}
cooperate_battlers.compact!
end
#--------------------------------------------------------------------------
# ○ 連係スキル発動
#--------------------------------------------------------------------------
def execute_cooperation_skill
# ダミーを登録
@action_battlers.unshift(create_cooperation_skill_battler)
end
#--------------------------------------------------------------------------
# ○ 連係発動者 (ダミーバトラー) 作成
#--------------------------------------------------------------------------
def create_cooperation_skill_battler
battler = Game_CooperationBattler.new
battler.battler_type = @cooperation_skill_user
battler.coop_skill = @cooperation_skill_data
battler.action.set_skill(@cooperation_skill_data.id)
# ターゲット取得
members = (@cooperation_skill_user == :actor ?
$game_party : $game_troop).members
target = (0..99).to_a
@exec_battlers.each { |eb|
battler.exec_battlers << members[eb.index]
target &= eb.target_battlers
}
if target.empty?
# ターゲット不明なら最後の行動者のターゲットを採用
target = @current_cooperate_user.target_battlers
end
battler.action.target_index = target[rand(target.size)]
return battler
end
#--------------------------------------------------------------------------
# ○ 連係スキル終了
#--------------------------------------------------------------------------
def finish_cooperation_skill
@cooperation_skill_exec = false
@cooperation_skill_data = nil
@exec_battlers = []
end
#--------------------------------------------------------------------------
# ○ 連係スキル加担判定
# battler : 判定するバトラー
#--------------------------------------------------------------------------
def cooperation_exec?(battler)
return false unless @cooperation_skill_exec
if battler.is_a?(Game_Actor) || KGC::CooperationSkill::PERMIT_ENEMY
# 発動者に含まれているか判定
@exec_battlers.each_index { |i|
return true if @exec_battlers[i].index == battler.index
}
end
return false
end
end

复制代码

一箭烂YiJL · 发表于 2011-1-1 16:00:38

这个脚本是不是合体技？

315038639 · 发表于 2011-1-1 16:14:20

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_ /_/_/_/_/_/_/_/_/_/_/_/_/_/_/
＃_ /联络技巧◆ - KGC_CooperationSkill◆◆VX的
＃_ /◇最后更新：2009/01/25◇
#_/----------------------------------------------- -----------------------------
＃_ /组合多种技能，有能力调用另一个技能。
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_ /_/_/_/_/_/_/_/_/_/_/_/_/_/_/

#================================================= =============================
货号＃自定义★ - ★自定义的BEGIN
#================================================= =============================

KGC的模块
模块CooperationSkill
  ＃分隔符时启动◆作品名称
  NAME_SEPARATOR =“，”

  ◆消防联络技巧＃元
  ＃真：所有的技能从中消防工程。
  ＃错误：只有技能，消防工程。
  ＃※没有脚本的综合效果。
  EXECUTE_ORIGIN_SKILL =假

  ＃只有当您激活相同的目标◆
  ＃正确的：原来的目标是所有（或所有）只有激活时同样的技能。
  ＃技能，而不是一个随机的目标是很好的※。
  ＃错误：解雇任何人，即使符合技能要求的目标。
  联络技巧＃目标，激活时的行动目标。
  SAME_TARGET_ONLY =真

  ＃◆工程技术允许敌人
  ＃真：判断敌人的技能一起工作。
  ＃错误：没有敌人的联络能力。
  PERMIT_ENEMY =真
结束
结束

#================================================= =============================
＃☆结束定制内容 - 自定义完☆
#================================================= =============================

进口= $ $ {}如果进口零==
进口$ [“CooperationSkill”] =真

KGC的模块
模块CooperationSkill
  对技能要求＃中的参数结合
  参数= {
：Level_avg“=>”LEVEL_AVG |平均水平，“
：Level_min“=>”LEVEL_MIN |的最小型低]的水平，“
：Level_max“=>”LEVEL_MAX |顶部[Oodaka]的水平，“
  }

  ＃属性列表的技能，为国家的联系
  阵列= {
：Attack_element“=>”ATTACK_ELEMENT |攻击属性“
：国家“=>”态|国“
  }

  模块的regexp
技能模块
   ＃启动联络技巧
   BEGIN_COOPERATE = /<(?: COOPERATION_SKILL |连续[脚腕关系]技能）“/我
   ＃结束联络技巧
   END_COOPERATE = / <\ /（：？COOPERATION_SKILL |连续[脚腕关系]技能）“/我
   ＃所需技能列表
   NEED_SKILLS = / ^ \秒*（：？NEED_SKILLS |技能要求？）\秒*（\ d +可（：\ S的*，\的*是\ D +）*？）\的* /我

   REG_NAME ='[^：\ + \ - \ ð \秒] +'
   REG_OU =结束了|下|更多|少'

   条件参数＃
   ＃10或更高的水平
   COOPERATE_PARAMS = / ^ \秒*（＃{REG_NAME}）\秒*（\ d +可）\秒*（＃{REG_OU}）？\ S的* $ /我
   ＃属性的国家名单
   国家＃1，2，3，
   COOPERATE_ARRAYS = / ^ \秒*（＃{REG_NAME}）\秒*（\ d +可（：\ S的*，\秒* \ - \的D +）*？）\的* $ /我
结束
  结束
结束
结束

＃★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#================================================= =============================
＃■角色扮演：：技能
#================================================= =============================

角色扮演类：：技能<角色扮演：：UsableItem
  #------------------------------------------------- -------------------------
  ○什么是联络技巧＃
  #------------------------------------------------- -------------------------
  高清is_cooperation？
self.note.each_line {|行|
   ＃查找开始标记
   如果行=〜KGC的：：CooperationSkill：：正则表达式：：技能：：BEGIN_COOPERATE
      返回true
   结束
}
返回false
  结束
结束

＃★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#================================================= =============================
＃■Game_Temp
#================================================= =============================

类Game_Temp
  #------------------------------------------------- -------------------------
  ●拓基米＃实例变量
  #------------------------------------------------- -------------------------
  attr_accessor：judging_cooperation_skill＃旗决定联络技巧
  #------------------------------------------------- -------------------------
  ●＃对象初始化
  #------------------------------------------------- -------------------------
  别名initialize_KGC_CooperationSkill初始化
  高清初始化
initialize_KGC_CooperationSkill

@ Judging_cooperation_skill =假
  结束
结束

＃★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#================================================= =============================
＃□Game_CooperationSkill
#------------------------------------------------- -----------------------------
＃类联络技巧来处理信息。
#================================================= =============================

类Game_CooperationSkill
  #------------------------------------------------- -------------------------
  ＃实例变量拓博○
  #------------------------------------------------- -------------------------
  attr_reader：身份证编号＃技能触发
  attr_reader：need_skills＃先决条件ID列表
  attr_reader：条件参数参数＃
  attr_reader：params_over＃状态参数： - 更多
  attr_reader：need_arrays＃列出所需状态的属性
  attr_reader：disuse_arrays＃列出所需状态的属性
  #------------------------------------------------- -------------------------
  ＃初始化对象○
  ＃Skill_id：技能的ID
  ＃注：请注意
  #------------------------------------------------- -------------------------
  高清初始化（skill_id，注）
@标识= skill_id
@ Need_skills = []
@参数= {}
@ Params_over = {}
@ Need_arrays = {}
@ Disuse_arrays = {}
parse_note（注）
  结束
  #------------------------------------------------- -------------------------
  ＃获取技能○
  #------------------------------------------------- -------------------------
  高清技术
返回$ data_skills [@ id]的
  结束
  #------------------------------------------------- -------------------------
  ○现场分析注释＃
  ＃注：请注意
  #------------------------------------------------- -------------------------
  高清parse_note（注）
coop_flag =假
note.each_line {|行|
   案件线
   当KGC前：：CooperationSkill：：正则表达式：：技能：：BEGIN_COOPERATE
      ＃启动耀西沙达联络技巧
      coop_flag =真
   当KGC前：：CooperationSkill：：正则表达式：：技能：：END_COOPERATE
      ＃完耀西沙达联络技巧
      coop_flag =假
   结束
   未来除非coop_flag

   案件线
   当KGC前：：CooperationSkill：：正则表达式：：技能：：NEED_SKILLS
      ＃技能要求
      parse_need_skills（$ 1.scan（/ \ - ？\的D + /））
   当KGC前：：CooperationSkill：：正则表达式：：技能：：COOPERATE_PARAMS
      ＃中的参数
      parse_params（$ 1，$ 2.to_i，$ 3）
   当KGC前：：CooperationSkill：：正则表达式：：技能：：COOPERATE_ARRAYS
      国家＃属性
      parse_arrays（$ 1，$ 2.scan（/ \ - ？\的D + /））
   结束
}
  结束
  #------------------------------------------------- -------------------------
  ＃○必要的技能解析
  ＃列出：技能ID列表
  #------------------------------------------------- -------------------------
  高清parse_need_skills（名单）
技能= []
list.each {|编号|
   技能| = [num.to_i]
}
@ Need_skills <<技能
  结束
  #------------------------------------------------- -------------------------
  ＃修复的能力，同时适用于○技能
  ＃参数：目标参数
  ＃值：修饰符
  ＃电导率：或多或少
  #------------------------------------------------- -------------------------
  高清parse_params（参数，价值，待续）
KGC前：：CooperationSkill：：PARAMS.each {| K表，五|
   下一步，如果参数！〜/(?:#{ v}的）/我

   @参数[k]的值=
   @ Params_over [k]的=（cond!〜/下|少/我）
   打破
}
  结束
  #------------------------------------------------- -------------------------
  ＃附加属性向国家联络技巧○
  ＃参数：目标参数
  ＃列出：国家属性列表
  #------------------------------------------------- -------------------------
  高清parse_arrays（参数，列表）
KGC前：：CooperationSkill：：ARRAYS.each {| K表，五|
   下一步，如果参数！〜/(?:#{ v}的）/我

   如果@ need_arrays [k]的零==
      @ Need_arrays [k]的= []
      @ Disuse_arrays [k]的= []
   结束
   list.each {|编号|
      每组num.to_i
      如果n> 0
      @ Need_arrays [k]的| = [n]的
      其他
      @ Disuse_arrays [k]的| = [n.abs]
      结束
   }
   打破
}
  结束
结束

＃★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

$ Data_skills = load_data（“数据/ Skills.rvdata”），如果$ data_skill ==无

KGC的模块：：CooperationSkill
  ＃转换技能的联络名单
  名单= []
  $ Data_skills.each {|技术|
下一步，如果无技能==
未来除非skill.is_cooperation？

清单<<Game_CooperationSkill.new（skill.id，skill.note）
  }
  技巧=列表
结束

＃★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#================================================= =============================
＃■Game_Actor
#================================================= =============================

类Game_Actor <Game_Battler
  #------------------------------------------------- -------------------------
  ＃●测定可用技能
  ＃技能：技能
  #------------------------------------------------- -------------------------
  高清skill_can_use？（技能）
超级回报
  结束
结束

＃★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#================================================= =============================
＃□Game_CooperationSkillUser
#------------------------------------------------- -----------------------------
＃一流的技能，处理消防工程的信息。
#================================================= =============================

类Game_CooperationSkillUser
  #------------------------------------------------- -------------------------
  ＃实例变量拓博○
  #------------------------------------------------- -------------------------
  attr_reader：＃指数运动指数
  attr_reader：skill_id＃身份证火的技能
  attr_reader：target_battlers＃攻击
  #------------------------------------------------- -------------------------
  ＃初始化对象○
  #------------------------------------------------- -------------------------
  高清初始化（战斗者）
如果$进口[“反”]
   battler.action.made_targets =无
结束
@指数= battler.index
@ Skill_id = battler.action.skill_id
@ Target_battlers = []
battler.action.make_targets.each {|吨|
   @ Target_battlers <<t.index
}
  结束
  #------------------------------------------------- -------------------------
  ○＃当量的测定
  #------------------------------------------------- -------------------------
  高清平等的吗？（OBJ文件）
返回false，除非obj.is_a？（Game_CooperationSkillUser）
如果@指数返回false！= obj.index
返回false skill_id！= obj.skill_id
返回false如果@ target_battlers！= obj.target_battlers

返回true
  结束
  #------------------------------------------------- -------------------------
  ○＃相等运算符
  #------------------------------------------------- -------------------------
  高清==（obj的）
返回self.equal？（OBJ文件）
  结束
结束

＃★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#================================================= =============================
＃□Game_CooperationBattler
#------------------------------------------------- -----------------------------
＃这是联络时调用Damibatorakurasu技能。
#================================================= =============================

类Game_CooperationBattler <Game_Battler
  #------------------------------------------------- -------------------------
  ●拓基米＃实例变量
  #------------------------------------------------- -------------------------
  attr_accessor：battler_type＃：演员或：敌人
  attr_accessor：exec_battlers＃列出火
  attr_accessor：coop_skill＃联络技能的信息
  #------------------------------------------------- -------------------------
  ●＃对象初始化
  #------------------------------------------------- -------------------------
  高清初始化
@ Battler_type =：演员
@ Exec_battlers = []
@ Coop_skill =无
超
  结束
  #------------------------------------------------- -------------------------
  ＃确定演员●
  #------------------------------------------------- -------------------------
  高清演员？
返回（@ battler_type ==：演员）
  结束
  #------------------------------------------------- -------------------------
  ＃获取指数●
  #------------------------------------------------- -------------------------
  高清指数
返回0
  结束
  #------------------------------------------------- -------------------------
  ＃获取显示名称●
  #------------------------------------------------- -------------------------
  高清名称
海峡=“”
成员=（$ game_party演员：？$ game_troop）的成员。
exec_battlers.each_with_index {| B，我|
   海峡+ =成员[b.index]。名称
   如果我<exec_battlers.size - 1
      KGC的海峡+ =：：CooperationSkill：：NAME_SEPARATOR
   结束
}
返回海峡
  结束
  #------------------------------------------------- -------------------------
  ＃取得的水平●
  #------------------------------------------------- -------------------------
  高清水平
值= []
exec_battlers.each {| b |值<<b.level}
返回values.max
  结束
  #------------------------------------------------- -------------------------
  ＃得到最大○
  #------------------------------------------------- -------------------------
  高清level_max
回报水平
  结束
  #------------------------------------------------- -------------------------
  ＃取得平均水平○
  #------------------------------------------------- -------------------------
  高清level_avg
n = 0时
exec_battlers.each {| b |名词+ = b.level}
返回（牛顿/ exec_battlers.size）
  结束
  #------------------------------------------------- -------------------------
  ●MaxHP获取＃
  #------------------------------------------------- -------------------------
  高清maxhp
值= []
exec_battlers.each {| b |值<<b.maxhp}
返回values.max
  结束
  #------------------------------------------------- -------------------------
  ●MaxMP获取＃
  #------------------------------------------------- -------------------------
  高清maxmp
值= []
exec_battlers.each {| b |值<<b.maxmp}
返回values.max
  结束
  #------------------------------------------------- -------------------------
  ＃●惠普收购
  #------------------------------------------------- -------------------------
  高清马力
值= []
exec_battlers.each {| b |值<<b.hp}
返回values.min
  结束
  #------------------------------------------------- -------------------------
  ●MP的获取＃
  #------------------------------------------------- -------------------------
  高清MP的
值= []
exec_battlers.each {| b |值<<b.mp}
返回values.min
  结束
  #------------------------------------------------- -------------------------
  ＃取得的驱动器数量计○
  #------------------------------------------------- -------------------------
  高清超速
值= []
exec_battlers.each {| b |值<<b.overdrive}
返回values.min
  结束
  #------------------------------------------------- -------------------------
  ＃攻击●取得
  #------------------------------------------------- -------------------------
  高清攻击力
值= []
exec_battlers.each {| b |值<<b.atk}
返回values.max
  结束
  #------------------------------------------------- -------------------------
  ＃取得防御●
  #------------------------------------------------- -------------------------
  高清画质
值= []
exec_battlers.each {| b |值<<b.def}
返回values.max
  结束
  #------------------------------------------------- -------------------------
  ＃获取精神力量●
  #------------------------------------------------- -------------------------
  高清的SPI
值= []
exec_battlers.each {| b |值<<b.spi}
返回values.max
  结束
  #------------------------------------------------- -------------------------
  ＃取得敏捷●
  #------------------------------------------------- -------------------------
  高清阿吉
值= []
exec_battlers.each {| b |值<<b.agi}
返回values.max
  结束
  #------------------------------------------------- -------------------------
  ＃取得●精度
  #------------------------------------------------- -------------------------
  高清打
值= []
exec_battlers.each {| b |值<<b.hit}
返回[values.max，100]。最大
  结束
  #------------------------------------------------- -------------------------
  ＃取得逃税●
  #------------------------------------------------- -------------------------
  高清伊娃
返回0
  结束
  #------------------------------------------------- -------------------------
  ＃取得暴击●
  #------------------------------------------------- -------------------------
  高清国际广播电台
值= []
exec_battlers.each {| b |值<<b.cri}
返回values.max
  结束
  #------------------------------------------------- -------------------------
  ●MP的变化＃
  ＃手机：新国会议员
  #------------------------------------------------- -------------------------
  高清熔点=（议员）
减少每个人的国会议员＃共谋
差异= self.mp - MP的
exec_battlers.each {| b | b.mp -=差异}
  结束
  #------------------------------------------------- -------------------------
  ○车道＃操作规范
  #------------------------------------------------- -------------------------
  高清超速=（值）
车道＃减轻所有共犯计
差异= self.overdrive - 超速
exec_battlers.each {| b | b.overdrive -=差异}
  结束
  #------------------------------------------------- -------------------------
  ＃●全部收回
  #------------------------------------------------- -------------------------
  高清recover_all
＃什么都不做
  结束
  #------------------------------------------------- -------------------------
  ●无行为能力的决心＃
  #------------------------------------------------- -------------------------
  高清死了吗？
exec_battlers.each {| b |
   返回true，如果b.dead？
}
返回false
  结束
  #------------------------------------------------- -------------------------
  ＃判断有无●
  #------------------------------------------------- -------------------------
  高清存在？
exec_battlers.each {| b |
   返回除非b.exist假？
}
返回true
  结束
  #------------------------------------------------- -------------------------
  ＃命令可以输入●确定
  #------------------------------------------------- -------------------------
  高清可输入的？
exec_battlers.each {| b |
   返回false，除非b.inputtable？
}
返回true
  结束
  #------------------------------------------------- -------------------------
  ●＃可操作的决定
  #------------------------------------------------- -------------------------
  高清移动？
exec_battlers.each {| b |
   返回false，除非b.movable？
}
返回true
  结束
  #------------------------------------------------- -------------------------
  ●＃沉默状态确定
  #------------------------------------------------- -------------------------
  高清沉默？
exec_battlers.each {| b |
   返回true，如果b.silent？
}
返回false
  结束
  #------------------------------------------------- -------------------------
  ●＃失控状态确定
  #------------------------------------------------- -------------------------
  高清狂战士？
返回false
  结束
  #------------------------------------------------- -------------------------
  ●确定混乱＃
  #------------------------------------------------- -------------------------
  高清混乱呢？
返回false
  结束
  #------------------------------------------------- -------------------------
  ＃测定保护●
  #------------------------------------------------- -------------------------
  高清护卫？
返回false
  结束
  #------------------------------------------------- -------------------------
  ＃得到一个正常的属性攻击●
  #------------------------------------------------- -------------------------
  高清element_set
结果= []
exec_battlers.each {| b |结果| = b.element_set}
返回结果
  结束
  #------------------------------------------------- -------------------------
  ＃改变一个普通攻击●（+）的收购状态
  #------------------------------------------------- -------------------------
  高清plus_state_set
结果= []
exec_battlers.each {| b |结果| = b.plus_state_set}
返回结果
  结束
  #------------------------------------------------- -------------------------
  ＃改变一个普通攻击●国家（ - ）获得
  #------------------------------------------------- -------------------------
  高清minus_state_set
结果= []
exec_battlers.each {| b |结果| = b.minus_state_set}
返回结果
  结束
  #------------------------------------------------- -------------------------
  国家＃●[损伤滑]测试
  #------------------------------------------------- -------------------------
  高清slip_damage？
返回false
  结束
  #------------------------------------------------- -------------------------
  国家＃●[精度下降]测试
  #------------------------------------------------- -------------------------
  高清reduce_hit_ratio？
返回false
  结束
结束

＃★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#================================================= =============================
＃■Scene_Battle
#================================================= =============================

类Scene_Battle <Scene_Base
  #------------------------------------------------- -------------------------
  ＃开始处理●
  #------------------------------------------------- -------------------------
  别名start_KGC_CooperationSkill启动
  高清开始
start_KGC_CooperationSkill

init_cooperation_skill
  结束
  #------------------------------------------------- -------------------------
  ＃初始化变量进行联络的能力○
  #------------------------------------------------- -------------------------
  高清init_cooperation_skill
@ Cooperation_skill_judged =假
@ Cooperation_skill_exec =假
@ Cooperation_skill_data =无
@ Cooperate_actors = []
@ Cooperate_enemies = []
  结束
  #------------------------------------------------- -------------------------
  ●党＃启动命令的选择
  #------------------------------------------------- -------------------------
  别名start_party_command_selection_KGC_CooperationSkill
start_party_command_selection
  高清start_party_command_selection
如果$ game_temp.in_battle
   init_cooperation_skill
结束

start_party_command_selection_KGC_CooperationSkill
  结束
  #------------------------------------------------- -------------------------
  ＃开始执行作战●
  #------------------------------------------------- -------------------------
  别名start_main_KGC_CooperationSkill start_main
  高清start_main
start_main_KGC_CooperationSkill

init_cooperate_battler_list
  结束
  #------------------------------------------------- -------------------------
  ＃初始化数据为决策○
  #------------------------------------------------- -------------------------
  高清init_cooperate_battler_list
[：演员：敌人]每个{|我|。
   万一我
   当：演员
      cooperate_battlers = @ cooperate_actors
      成员= $ game_party.members
   当：敌人
      cooperate_battlers = @ cooperate_enemies
      成员= $ game_troop.members
   结束
   巴特勒＃设定目标
   cooperate_battlers.clear
   除非KGC前：：CooperationSkill：：EXECUTE_ORIGIN_SKILL
      members.each {|战斗者|
      未来除非battler.action.skill？
      cooperate_battlers <<Game_CooperationSkillUser.new（战斗者）
      }
   结束
}
  结束
  #------------------------------------------------- -------------------------
  ＃担负战备●
  #------------------------------------------------- -------------------------
  别名execute_action_KGC_CooperationSkill execute_action
  高清execute_action
@ Cooperation_skill_judged =假

如果KGC前：：CooperationSkill：：EXECUTE_ORIGIN_SKILL
   execute_action_KGC_CooperationSkill
   judge_cooperation_skill（@ active_battler）
其他
   judge_cooperation_skill（@ active_battler）
   除非@ cooperation_skill_judged＆＆@ cooperation_skill_exec
      execute_action_KGC_CooperationSkill
   结束
结束

如果@ cooperation_skill_exec
   如果@ cooperation_skill_judged
      execute_cooperation_skill
   其他
      finish_cooperation_skill
   结束
结束
  结束
  #------------------------------------------------- -------------------------
  ○决定引发了第一次联络技巧＃
  ＃战斗者：参与
  #------------------------------------------------- -------------------------
  高清judge_cooperation_skill（战斗者）
返回false如果@ cooperation_skill_judged
返回false如果@ cooperation_skill_exec
@ Cooperation_skill_judged =真

单位=（battler.is_a（Game_Actor）$ game_troop：？？$ game_party）
如果battler.action.kind == 1
   ＃决定如果火灾左边第二个目标
   除非unit.all_dead？
      返回judge_cooperation_skill_second（战斗者）
   结束
其他
   ＃如果不删除从行动的技能确定阵列
   如果unit.is_a？（Game_Party）
      remove_cooperate_battler（：演员，战斗者）
   elsif unit.is_a？（Game_Troop）
      remove_cooperate_battler（：敌人，战斗者）
   结束
结束
返回false
  结束
  #------------------------------------------------- -------------------------
  ＃删除Works帮凶○
  ＃类型：：演员或：敌人
  ＃战斗者：删除
  #------------------------------------------------- -------------------------
  高清remove_cooperate_battler（类型，战斗者）
battlers =（类型==：演员@ cooperate_actors：@ cooperate_enemies）
battlers.each_index {|我|
   如果battlers [我]。指数== battler.index
      battlers [我] =无
   结束
}
battlers.compact！
  结束
  #------------------------------------------------- -------------------------
  ＃激活第二联○决心技能
  ＃战斗者：参与
  #------------------------------------------------- -------------------------
  高清judge_cooperation_skill_second（战斗者）
＃创建决策数据
@ Current_cooperate_user = Game_CooperationSkillUser.new（战斗者）
如果battler.is_a？（Game_Actor）
   remove_cooperate_battler（：演员，战斗者）
   @ Cooperate_actors | = [@ current_cooperate_user]
elsif battler.is_a？（Game_Enemy）
   remove_cooperate_battler（：敌人，战斗者）
   @ Cooperate_enemies | = [@ current_cooperate_user]
结束
＃决定触发联络技巧
KGC前：：CooperationSkill：：SKILLS.each {|客服|
   ＃测定演员
   如果battler.is_a？（Game_Actor）
      judge_cooperation_skill_third（：演员，CS）的
   ＃决定敌人
   elsif battler.is_a？（Game_Enemy）
      judge_cooperation_skill_third（：敌人，CS）的
   结束

   如果@ cooperation_skill_exec突破
}
返回@ cooperation_skill_exec
  结束
  #------------------------------------------------- -------------------------
  ○联络技巧＃第三行使决策
  ＃类型：：演员或：敌人
  ＃Cs_data：合作技术统计
  #------------------------------------------------- -------------------------
  高清judge_cooperation_skill_third（类型，cs_data）
如果type ==：敌人
   ＃如果你不回敌人的炮火
   KGC的回报，除非：：CooperationSkill：：PERMIT_ENEMY
结束

@ Cooperation_skill_exec =假
案件类型
当：演员
   cooperate_battlers = @ cooperate_actors
   成员= $ game_party.members
当：敌人
   cooperate_battlers = @ cooperate_enemies
   成员= $ game_troop.members
结束

@ Exec_battlers = create_cooperation_exec_battlers（cs_data，
   cooperate_battlers，委员）
＃返回，如果没有在他们的行动的同谋
返回if@exec_battlers.empty？

＃返回，除非您指定相同的目标
除非same_target_include回报？（cs_data，cooperate_battlers，委员）

$ Game_temp.judging_cooperation_skill =真
prepare_cooperation_exec（类型，cs_data，cooperate_battlers，委员）
$ Game_temp.judging_cooperation_skill =假
  结束
  #------------------------------------------------- -------------------------
  ＃创建列表的工作技能锻炼○
  ＃Cs_data：合作技术统计
  ＃Cooperate_battlers：列出帮凶工程
  ＃成员：一个全员工程的共谋
  #------------------------------------------------- -------------------------
  高清create_cooperation_exec_battlers（cs_data，cooperate_battlers，委员）
battlers = []
cs_data.need_skills.each {|南北|
   battlers.clear
   ＃部分确定其行为
   未来除非ns.include？（@ current_cooperate_user.skill_id）

   ＃技能要求满足所有的决定
   技能= ns.clone
   ns.each {| skill_id |
      用户= cooperate_battlers.find {|会CB |
      skill_id == cb.skill_id＆＆！battlers.include？（CB）的
      }
      ＃如果用户没有确定
      如果用户==无
      battlers.clear
      技能= [0]
      打破
      结束
      battlers <<用户
      skills.delete（skill_id）
   }
   BREAK如果skills.empty？确定为空阵列＃==>技能要求的满意度
}

除非cooperation_conditions_satisfy？（cs_data，battlers，委员）
   battlers = []
结束

返回battlers
  结束
  #------------------------------------------------- -------------------------
  ＃决定○条件的满足
  ＃Cs_data：合作技术统计
  ＃Candidate_battlers：工程计划表进行测试同谋
  ＃成员：一个全员工程的共谋
  #------------------------------------------------- -------------------------
  高清cooperation_conditions_satisfy？（cs_data，candidate_battlers，委员）
返回，如果candidate_battlers.empty？

＃参数的计算
level_avg = 0
各级= []
candidate_battlers.each {|会CB |
   战斗者=成员[cb.index]
   level_avg + = battler.level
   水平“<battler.level
}
level_avg / = members.size

比赛= Proc.new {|甲，乙过来，|在一个> = B的：一个<= B的}＃触发的决心

cs_data.params.each {| K表，五|
   参数= 0
   方案K
   当：level_avg＃平均水平
      参数= level_avg
   当：level_min＃最低水平
      参数= levels.min
   当：level_max＃最高水平
      参数= levels.max
   结束
   返回false，除非comp.call（参数，五，cs_data.params_over [k]的）
}

返回true
  结束
  #------------------------------------------------- -------------------------
  ＃匹配目标决策联系○
  ＃Cs_data：合作技术统计
  ＃Cooperate_battlers：列出帮凶工程
  ＃成员：一个全员工程的共谋
  #------------------------------------------------- -------------------------
  高清same_target_include？（cs_data，cooperate_battlers，委员）
返回true，除非KGC的：：CooperationSkill：：SAME_TARGET_ONLY

＃如果目标确定为
duplicate_battlers =（0 .. 99）。to_a
@ Exec_battlers.each {|光大|
   duplicate_battlers＆= eb.target_battlers
}
返回（duplicate_battlers.size> 0）
  结束
  #------------------------------------------------- -------------------------
  ○准备消防工程＃
  ＃类型：：演员或：敌人
  ＃Cs_data：合作技术统计
  ＃Cooperate_battlers：列出帮凶工程
  ＃成员：一个全员工程的共谋
  #------------------------------------------------- -------------------------
  高清prepare_cooperation_exec（类型，cs_data，cooperate_battlers，委员）
＃决定是否行使
@ Exec_battlers.each {|光大|
   战斗者=成员[eb.index]
   除非battler.exist？＆＆battler.skill_can_use？（cs_data.skill）
      返回
   结束
}

@ Cooperation_skill_exec =真
@ Cooperation_skill_data = cs_data
@ Cooperation_skill_user =类型

＃从列表中删除那些谁行使行为
cooperate_battlers.each_with_index {|淙斌，我|
   if@exec_battlers.include？（CB）的
      @ Action_battlers.delete（成员[cb.index]）
      cooperate_battlers [我] =无
   结束
}
cooperate_battlers.compact！
  结束
  #------------------------------------------------- -------------------------
  ○消防联络技巧＃
  #------------------------------------------------- -------------------------
  高清execute_cooperation_skill
＃注册一个虚拟
@ Action_battlers.unshift（create_cooperation_skill_battler）
  结束
  #------------------------------------------------- -------------------------
  ＃触发连锁○（巴特勒假人）创建
  #------------------------------------------------- -------------------------
  高清create_cooperation_skill_battler
战斗者= Game_CooperationBattler.new
battler.battler_type = @ cooperation_skill_user
battler.coop_skill = @ cooperation_skill_data
battler.action.set_skill（@ cooperation_skill_data.id）

＃获取目标
成员=（@ cooperation_skill_user ==：演员？
   $ Game_party：$ game_troop）成员。
目标=（0 .. 99）。to_a
@ Exec_battlers.each {|光大|
   battler.exec_battlers <<成员[eb.index]
   目标＆= eb.target_battlers
}
如果target.empty？
   ＃目标采取的行动最后为人所知的，如果目标
   目标= @ current_cooperate_user.target_battlers
结束
battler.action.target_index =目标[兰特（target.size）]

返回战斗者
  结束
  #------------------------------------------------- -------------------------
  ○联络技能＃退出
  #------------------------------------------------- -------------------------
  高清finish_cooperation_skill
@ Cooperation_skill_exec =假
@ Cooperation_skill_data =无
@ Exec_battlers = []
  结束
  #------------------------------------------------- -------------------------
  ＃技能的一部分，确定联动○
  ＃战斗者：巴特勒法官
  #------------------------------------------------- -------------------------
  高清cooperation_exec？（战斗者）
返回false，除非@ cooperation_skill_exec

如果battler.is_a（Game_Actor）| | KGC的：？：CooperationSkill：：PERMIT_ENEMY
   ＃确定是否大火已被所载
   @ Exec_battlers.each_index {|我|
      返回true如果@ exec_battlers [我]。指数== battler.index
   }
结束
返回false
  结束
结束

帐号		自动登录	找回密码
密码			注册会员

[已经解决] 帮忙翻译下

加入我们，或者，欢迎回来。

点评

点评