ホーム
>
RPGツクール
>
テクニック集
>
XP一覧
>
テクニック

連繋スキル

CooperationSkill

概要

Summary

複数のキャラクターが協力してスキルを発動します。

↑目次

更新履歴

History

2007/11/30

連繋スキルを発動すると、無条件でオーバードライブゲージを消費するバグを修正。

2007/11/22

ACB未導入時、同一ターゲットのみ連繋を許可する機能が正常に働かないバグを修正。

2007/11/02

ターゲットが同じ場合のみ連繋を許可する機能を追加。

2007/10/05

オーバードライブゲージを消費する連繋スキルに対応。

2007/09/03

複数のアクターが発動条件を満たすと、連繋が発動しないことがあるバグを修正。

2007/08/27

連繋に加担しないキャラのスキルが発動しないバグを修正。

ACB導入時、コマンドを開いたまま連繋が発動すると落ちるバグを修正。

連繋スキル発動時に落ちるバグを修正？

2007/05/28

アクターが連繋スキルを発動すると落ちるバグを修正。

2007/01/28

連繋スキル発動時に落ちることがあるバグを修正？

2006/03/14

連繋元スキルの発動可否を設定する機能を追加。

処理を効率化。

2005/09/28

コモンイベント機能を有効化。

2005/05/05

敵の連繋発動時に落ちるバグを修正。

「攻撃力F」が0の連繋スキルが命中しないバグを修正。

2005/04/24

他サイトとの併用性向上。

連繋発動時、無関係なキャラも発動者に含まれるバグを修正。

2005/03/10

≪スキル使用メッセージ≫に対応。

発動条件の記述ミスを修正。

2005/03/09

コマンド入力中に連繋スキルを発動すると点滅したままになるバグを修正。

2005/03/08

バグの原因と思われる箇所を色々と修正。

2005/03/07

全滅確定時に連繋スキルが発動すると落ちるバグを修正。

2005/03/04

新規作成。

↑目次

スクリプト

Script

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#_/    ◆ 連繋スキル - KGC_CooperationSkill ◆
#_/    ◇ Last update : 2007/11/30 ◇
#_/----------------------------------------------------------------------------
#_/  複数のスキルを組み合わせ、別のスキルを発動させる機能です。
#_/  It is a function to combine some skills, and to execute another skill.
#_/============================================================================
#_/  ≪個別戦闘コマンド[SeparationCommand]≫より下
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/

#==============================================================================
# ★ カスタマイズ項目 - Customize ★
#==============================================================================

module KGC
  # ◆連繋スキル配列
  #  ≪[発動スキルID, [必要スキルID1, 必要スキルID2, ...]]≫
  #  配列なので、忘れずに , で区切ってください。
  CS_SKILLS = [
    # スパイラルフレア
    [101, [7, 60]],
    [101, [8, 60]],
    [101, [9, 60]],
  ]  # -- Don't delete this line! --

# ◆敵連繋スキル許可
  #  true にすると、敵も連繋スキル判定を行う。
  CS_PERMIT_ENEMY = true

# ◆連繋元スキル発動許可
  #  true にすると、連繋元となるスキルもすべて発動する。
  #  false にすると、連繋スキルのみ発動する。
  #  (≪Active Count Battle≫では、最後の連繋元スキルにのみ影響)
  CS_EXECUTE_ORIGIN_SKILL = false

# ◆ターゲットが同じ場合のみ連繋を許可
  #  元のスキルがすべて同じターゲット(または全体)の場合のみ発動許可。
  #   ※ ランダムターゲットとは相性が良くありません。
  CS_ONLY_SAME_TARGET = true
end

#### CS_SKILLS
### Array of "Cooperation Skill".
#  << ["Cooperation Skill" ID, [Necessary skill ID 1, ID 2, ...]] >>

#### CS_PERMIT_ENEMY
### Enables enemy to execute "Cooperation Skill".

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

$imported = {} if $imported == nil
$imported["CooperationSkill"] = true

#==============================================================================
# ■ Game_Battler (分割定義 3)
#==============================================================================

class Game_Battler
  #--------------------------------------------------------------------------
  # ● 連繋スキルの効果適用
  #     user_list : スキルの使用者リスト (バトラー)
  #     skill     : スキル
  #     is_actor  : 使用者がアクター
  #--------------------------------------------------------------------------
  def cooperation_skill_effect(user_list, skill, is_actor)
    # クリティカルフラグをクリア
    self.critical = false
    # スキルの効果範囲が HP 1 以上の味方で、自分の HP が 0、
    # またはスキルの効果範囲が HP 0 の味方で、自分の HP が 1 以上の場合
    if ((skill.scope == 3 or skill.scope == 4) and self.hp == 0) or
       ((skill.scope == 5 or skill.scope == 6) and self.hp >= 1)
      # メソッド終了
      return false
    end
    # 有効フラグをクリア
    effective = false
    # コモンイベント ID が有効の場合は有効フラグをセット
    effective |= skill.common_event_id > 0
    # 第一命中判定
    hit2 = 100 * user_list.size
    if skill.atk_f > 0
      user_list.each { |user|
        hit2 += user.hit * skill.atk_f / 100
      }
    end
    hit2 /= user_list.size * 0.75
    hit = Integer(skill.hit * hit2 / 100)
    hit_result = (rand(100) < hit)
    # 不確実なスキルの場合は有効フラグをセット
    effective |= hit < 100
    # 命中の場合
    if hit_result
      # 威力を計算
      power = 0
      user_list.each { |user|
        power += user.atk * skill.atk_f / 100
      }
      power /= user_list.size * 0.75
      power = Integer(power + skill.power)
      if power > 0
        power -= self.pdef * skill.pdef_f / 200
        power -= self.mdef * skill.mdef_f / 200
        power = [power, 0].max
      end
      # 倍率を計算
      rate = 0
      user_list.each { |user|
        rate += (user.str * skill.str_f / 100)
        rate += (user.dex * skill.dex_f / 100)
        rate += (user.agi * skill.agi_f / 100)
        rate += (user.int * skill.int_f / 100)
      }
      rate /= user_list.size * 0.75
      rate = Integer(rate + 20)
      # 基本ダメージを計算
      self.damage = power * rate / 20
      # 属性修正
      self.damage *= elements_correct(skill.element_set)
      self.damage /= 100
      # ダメージの符号が正の場合
      if self.damage > 0
        # 防御修正
        if self.guarding?
          self.damage /= 2
        end
      end
      # 分散
      if skill.variance > 0 and self.damage.abs > 0
        amp = [self.damage.abs * skill.variance / 100, 1].max
        self.damage += rand(amp+1) + rand(amp+1) - amp
      end
      # 第二命中判定
      eva = 0
      user_dex = 0
      user_list.each { |user|
        user_dex += user.dex
      }
      user_dex /= user_list.size
      eva += 8 * self.agi / user_dex
      eva += self.eva
      hit = self.damage < 0 ? 100 : 100 - eva * skill.eva_f / 100
      hit = self.cant_evade? ? 100 : hit
      hit_result = (rand(100) < hit)
      # 不確実なスキルの場合は有効フラグをセット
      effective |= hit < 100
    end
    # 命中の場合
    if hit_result
      # 威力 0 以外の物理攻撃の場合
      if skill.power != 0 and skill.atk_f > 0
        # ステート衝撃解除
        remove_states_shock
        # 有効フラグをセット
        effective = true
      end
      # HP からダメージを減算
      last_hp = self.hp
      self.hp -= self.damage
      effective |= self.hp != last_hp
      # ステート変化
      @state_changed = false
      effective |= states_plus(skill.plus_state_set)
      effective |= states_minus(skill.minus_state_set)
      # 威力が 0 の場合
      if skill.power == 0
        # ダメージに空文字列を設定
        self.damage = ""
        # ステートに変化がない場合
        unless @state_changed
          # ダメージに "Miss" を設定
          self.damage = "Miss"
        end
      end
    # ミスの場合
    else
      # ダメージに "Miss" を設定
      self.damage = "Miss"
    end
    # 戦闘中でない場合
    unless $game_temp.in_battle
      # ダメージに nil を設定
      self.damage = nil
    end
    # メソッド終了
    return effective
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

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

class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # ● スキルの使用可能判定
  #     skill_id : スキル ID
  #--------------------------------------------------------------------------
  def skill_can_use?(skill_id)
    return super(skill_id)
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Game_CooperationSkillUser
#==============================================================================

class Game_CooperationSkillUser
  attr_reader   :index, :skill_id, :target_battlers
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(index, skill_id, target_battlers = [])
    @index = index
    @skill_id = skill_id
    @target_battlers = []
    target_battlers.each { |t|
      @target_battlers << t.index
    }
  end
  #--------------------------------------------------------------------------
  # ● 同値判定
  #--------------------------------------------------------------------------
  def equal?(obj)
    return (obj.is_a?(Game_CooperationSkillUser) &&
      @index == obj.index && @skill_id == obj.skill_id &&
      @target_battlers == obj.target_battlers)
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Scene_Battle (分割定義 1)
#==============================================================================

class Scene_Battle
  #--------------------------------------------------------------------------
  # ● メイン処理
  #--------------------------------------------------------------------------
  alias main_KGC_CooperationSkill main
  def main
    # 連繋スキル発動フラグを解除
    @cooperation_skill_exec = false
    @cooperation_skill_id = 0
    # 連繋判定用配列を初期化
    @cooperate_actors = []
    @cooperate_enemies = []

main_KGC_CooperationSkill
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Scene_Battle (分割定義 2)
#==============================================================================

class Scene_Battle
  #--------------------------------------------------------------------------
  # ● パーティコマンドフェーズ開始
  #--------------------------------------------------------------------------
  alias start_phase2_KGC_CooperationSkill start_phase2
  def start_phase2
    # 連繋スキル発動フラグを解除
    @cooperation_skill_exec = false
    @cooperation_skill_id = 0
    # 連繋判定用配列を初期化
    @cooperate_actors = []
    @cooperate_enemies = []

start_phase2_KGC_CooperationSkill
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Scene_Battle (分割定義 4)
#==============================================================================

class Scene_Battle
  unless KGC::CS_EXECUTE_ORIGIN_SKILL || $imported["ActiveCountBattle"]
  #--------------------------------------------------------------------------
  # ● メインフェーズ開始
  #--------------------------------------------------------------------------
  alias start_phase4_KGC_CooperationSkill start_phase4
  def start_phase4
    start_phase4_KGC_CooperationSkill

# 判定用データ作成
    @cooperate_actors = []
    @cooperate_enemies = []
    init_cooperate_battler_list(0)
    init_cooperate_battler_list(1)
  end
  #--------------------------------------------------------------------------
  # ● 判定用データ初期化
  #--------------------------------------------------------------------------
  def init_cooperate_battler_list(type)
    case type
    when 0  # Actor
      cooperate_battlers = @cooperate_actors
      battler_list = $game_party.actors
    when 1  # Enemy
      cooperate_battlers = @cooperate_actors
      battler_list = $game_troop.enemies
    end
    # 対象側バトラーを設定
    battler_list.each { |battler|
      if battler.current_action.kind == 1
        @active_battler = battler
        skill = $data_skills[battler.current_action.skill_id]
        @target_battlers = []
        set_target_battlers(skill.scope)
        user = Game_CooperationSkillUser.new(battler.index,
          battler.current_action.skill_id,
          @target_battlers.clone)
        cooperate_battlers << user
      end
    }
    @active_battler = nil
  end
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新 (メインフェーズ ステップ 2 : アクション開始)
  #--------------------------------------------------------------------------
  alias update_phase4_step2_KGC_CooperationSkill update_phase4_step2
  def update_phase4_step2
    @judged = false
    unless KGC::CS_EXECUTE_ORIGIN_SKILL
      # 行動がスキルの場合
      if @active_battler.current_action.kind == 1
        # 対象側バトラーを設定
        skill = $data_skills[@active_battler.current_action.skill_id]
        @target_battlers = []
        set_target_battlers(skill.scope)
      end
      # 発動判定
      judge_cooperation_skill(@active_battler)
      if @cooperation_skill_exec
        @phase4_step = 6
        return
      end
    end

update_phase4_step2_KGC_CooperationSkill
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新 (メインフェーズ ステップ 6 : リフレッシュ)
  #--------------------------------------------------------------------------
  alias update_phase4_step6_KGC_CooperationSkill update_phase4_step6
  def update_phase4_step6
    if @cooperation_skill_exec && !@judged
      # 連繋スキル終了
      @cooperation_skill_exec = false
      @cooperation_skill_id = 0
      @exec_battlers = []
    # 発動判定
    elsif KGC::CS_EXECUTE_ORIGIN_SKILL
      judge_cooperation_skill(@active_battler)
    end
    if @cooperation_skill_exec
      execute_cooperation_skill
      @judged = false
      return
    end

update_phase4_step6_KGC_CooperationSkill
  end
  #--------------------------------------------------------------------------
  # ● 連繋スキル第一発動判定
  #     battler : 判定対象
  #--------------------------------------------------------------------------
  def judge_cooperation_skill(battler)
    if @judged
      return false
    end
    @judged = true

# 行動がスキルの場合
    if battler.current_action.kind == 1
      # 敵全滅判定
      target_all_dead = true
      target_list = battler.is_a?(Game_Actor) ?
        $game_troop.enemies : $game_party.actors
      target_list.each { |t|
        if t.exist?
          target_all_dead = false
          break
        end
      }
      # 対象が残っていれば第二発動判定
      unless target_all_dead
        return judge_cooperation_skill_second(battler)
      end
    else
      # 判定用配列から削除
      if battler.is_a?(Game_Actor)
        remove_cooperate_battler(0, battler)
      elsif battler.is_a?(Game_Enemy)
        remove_cooperate_battler(1, battler)
      end
    end
    return false
  end
  #--------------------------------------------------------------------------
  # ● 連繋スキル第二発動判定
  #--------------------------------------------------------------------------
  def judge_cooperation_skill_second(battler)
    # 判定用データ作成
    user = Game_CooperationSkillUser.new(battler.index,
      battler.current_action.skill_id,
      @target_battlers.clone)
    @current_cooperate_battler = user
    if battler.is_a?(Game_Actor)
      remove_cooperate_battler(0, battler)
      @cooperate_actors << user
    elsif battler.is_a?(Game_Enemy) && KGC::CS_PERMIT_ENEMY
      remove_cooperate_battler(1, battler)
      @cooperate_enemies << user
    end
    # 連繋スキル発動判定
    KGC::CS_SKILLS.each { |cs|
      # アクター判定
      if battler.is_a?(Game_Actor)
        check_cooperation_exec_battlers(0, cs)
      # エネミー判定
      elsif battler.is_a?(Game_Enemy) && KGC::CS_PERMIT_ENEMY
        check_cooperation_exec_battlers(1, cs)
      end
      if @cooperation_skill_exec
        break
      end
    }
    return @cooperation_skill_exec
  end
  #--------------------------------------------------------------------------
  # ● 連繋スキル発動バトラー判定
  #     type        : 0..Actor  1..Enemy
  #     cs_data : Cooperation skill data
  #--------------------------------------------------------------------------
  def check_cooperation_exec_battlers(type, cs_data)
    @cooperation_skill_exec = false
    case type
    when 0  # Actor
      cooperate_battlers = @cooperate_actors
      battler_list = $game_party.actors
    when 1  # Enemy
      cooperate_battlers = @cooperate_enemies
      battler_list = $game_troop.enemies
    end

# 行動者が発動者に含まれるか判定
    @exec_battlers = []
    need_skills = cs_data[1].clone
    cs_data[1].each_with_index { |skill_id, i|
      if @current_cooperate_battler.skill_id == skill_id
        @exec_battlers << @current_cooperate_battler
        need_skills.delete_at(i)
        break
      end
    }
    # 行動者が加担していなければ戻る
    if @exec_battlers.size == 0
      return
    end

# 発動者リストを作成
    need_skills.each { |skill_id|
      user = cooperate_battlers.find { |cb|
        skill_id == cb.skill_id && !@exec_battlers.include?(cb)
      }
      if user == nil
        return
      end
      @exec_battlers << user
    }

# 発動者全員が発動条件を満たすか判定
    duplicate_battlers = (0..99).to_a
    @exec_battlers.each { |eb|
      if !battler_list[eb.index].exist? ||
          !battler_list[eb.index].skill_can_use?(cs_data[0])
        return
      end
      duplicate_battlers &= eb.target_battlers
    }
    # 同じターゲットを指定しているか判定
    if KGC::CS_ONLY_SAME_TARGET && duplicate_battlers.size == 0
      return
    end

# 発動フラグを立てる
    @cooperation_skill_exec = true
    @cooperation_skill_id = cs_data[0]
    @cooperation_skill_user = type
    # 発動者を削除
    cooperate_battlers.each_with_index { |cb, i|
      if @exec_battlers.include?(cb)
        @action_battlers.delete(battler_list[cb.index])
        cooperate_battlers[i] = nil
      end
    }
    cooperate_battlers.compact!
  end
  #--------------------------------------------------------------------------
  # ● 連繋加担者削除
  #     type    : 0..アクター  1..エネミー
  #     battler : 削除対象
  #--------------------------------------------------------------------------
  def remove_cooperate_battler(type, battler)
    case type
    when 0  # アクター
      if @cooperate_actors.size > 1
        @cooperate_actors.each_index { |i|
          if @cooperate_actors[i].index == battler.index
            @cooperate_actors[i] = nil
          end
        }
        @cooperate_actors.compact!
      end
    when 1  # エネミー
      if KGC::CS_PERMIT_ENEMY && @cooperate_enemies.size > 1
        @cooperate_enemies.each_index { |i|
          if @cooperate_enemies[i].index == battler.index
            @cooperate_enemies[i] = nil
          end
        }
        @cooperate_enemies.compact!
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● 連繋スキル発動
  #--------------------------------------------------------------------------
  def execute_cooperation_skill
    # スキル取得
    skill = $data_skills[@cooperation_skill_id]
    # ヘルプウィンドウにスキル名を表示
    @help_window.set_text(skill.name, 1)
    if $imported["SkillMessage"]
      # スキル使用メッセージ表示
      show_skill_message(@active_battler, skill)
    end
    # アニメーション ID を設定
    @animation1_id = skill.animation1_id
    @animation2_id = skill.animation2_id
    # コモンイベント ID を設定
    @common_event_id = skill.common_event_id
    # 攻撃対象取得
    @target_battlers = []
    set_target_battlers(skill.scope)

user_list = []
    case @cooperation_skill_user
    when 0  # アクター
      @exec_battlers.each { |eb|
        user_list << $game_party.actors[eb.index]
      }
      if $imported["ActiveCountBattle"] && @input_battler != nil
        user_list.each { |user|
          if user == @input_battler
            # コマンド入力を解除
            cancel_command_input
          end
        }
      end
      @status_window.refresh
    when 1  # エネミー
      @exec_battlers.each { |eb|
        user_list << $game_troop.enemies[eb.index]
      }
    end
    user_list.each { |user|
      # SP消費
      user.sp -= skill.sp_cost
      # 発動アニメを表示
      user.animation_id = @animation1_id
      user.animation_hit = true
      # OverDrive ゲージ消費
      if $imported["OverDrive2"] && skill.overdrive?
        user.overdrive -= skill.od_cost
      elsif $imported["OverDrive"] &&
          skill.element_set.include?($game_special_elements["overdrive"])
        user.overdrive = 0
      end
    }
    # スキル適用
    @target_battlers.each { |target|
      target.cooperation_skill_effect(user_list, skill,
        @cooperation_skill_user == 0)
    }
    # ステップ 4 に移行
    @phase4_step = 4
  end
  #--------------------------------------------------------------------------
  # ● 連繋スキル加担判定
  #     battler : 判定するバトラー
  #--------------------------------------------------------------------------
  def cooperation_exec?(battler)
    if @cooperation_skill_exec
      if !battler.is_a?(Game_Enemy) || KGC::CS_PERMIT_ENEMY
        # 発動者に含まれているか判定
        @exec_battlers.each_index { |i|
          if @exec_battlers[i].index == battler.index
            return true
          end
        }
      end
    end
    return false
  end
end

↑目次

使用法

Usage

まずは、カスタマイズ項目の

CS_SKILLS = [
  ...
]

を書き換えます。
ここは解説通り[発動スキルID, [必要スキルID1, 必要スキルID2, ...]]という書式で入力します。
例えば、ID120のスキルをID40,61,78の組み合わせで発動させる場合、

[120, [40, 61, 78]]

と指定します。(右側の配列内は、どのような順番でもOK)

# ◆敵連繋スキル許可
CS_ENEMY_PERMIT = true

はエネミーの連繋スキル発動許可設定です。
true を指定すると、敵も連繋スキルを使用するようになります。
うまく行動パターンを組めば、意図的に連繋を狙う敵も作成可能です。

# ◆ターゲットが同じ場合のみ連繋を許可
CS_ONLY_SAME_TARGET = false

同じ敵をターゲットにした場合のみ連繋スキルを発動させる場合は、ここをtrueにします。
全体攻撃の場合は、すべての敵をターゲットにしたと見なします。
（攻撃後に蘇生した場合など、実際に攻撃対象になっていない場合は無効）
≪ランダムターゲット≫とは相性がよくないので、併用は控えてください。

戦闘中、「各キャラクターが最後に使用したスキルが連繋スキル発動条件を満たす」場合に発動します。
発動前に別のスキルを使用したり、スキル以外の行動を行った場合は↑の条件を満たさないため、発動しません。
（敵や、発動に関与しないキャラクターは、何をしても影響しません）
例えば、サンプルの「スパイラルフレア」の場合は
　アルシェス：スパイラルブレード
　ヒルダ：ファイア
を使用した後、追加で「スパイラルフレア」が発動…という具合です。
ちなみに、カスタマイズ項目の

# ◆連繋元スキル発動許可
CS_EXECUTE_ORIGIN_SKILL = false

をfalseにすると、連繋スキルの条件となるスキル（先の例では、「スパイラルブレード」と「ファイア」）を発動しなくなります。
（≪Active Count Battle≫では、最後の条件スキルのみ発動しません）

発動時のアニメは、連繋スキルの「使用側アニメーション」になります。
SPは、連繋スキル発動に関与したキャラクター全員が消費します。

↑目次

注意事項

Notes

≪Active Count Battle≫では、連繋スキル発動時に発動キャラのACBゲージが0になります。

↑目次

連繋スキル

CooperationSkill

目次

Outline

概要

Summary

更新履歴

History

スクリプト

Script

使用法

Usage

注意事項

Notes