请问有没有战斗时一次出两招的方法

invirgin · 发表于 2015-12-18 21:49:32

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

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

×

在战斗时每次只能出一招有没有什么方法可以做到主要MP 够想出几招都行呢？
呵呵···

15968715431 · 发表于 2015-12-19 10:16:00

[pre lang="ruby"]#==============================================================================
#
# ▼ Yanfly Engine Ace - Active Chain Skills v1.01
# -- Last Updated: 2011.12.22
# -- Level: Hard
# -- Requires: n/a
#
#==============================================================================

$imported = {} if $imported.nil?
$imported["YEA-ActiveChainSkills"] = true

#==============================================================================
# ▼ Updates
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# 2011.12.22 - Better updating speed for window.
# 2011.12.18 - Started Script and Finished.
#
#==============================================================================
# ▼ Introduction
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# 這腳本實現了主動連技的可能性，當帶有連技屬性的技能發動時，畫面左下方會出現
# 可以連甚麼技的訊息列表，透過簡單QTE，能立刻發動下一招連技。理論上，只要有足夠
# 的資源(MP, TP) 和連技屬性的設定，是可以無限連技的。
#==============================================================================
# ▼ Instructions
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# To install this script, open up your script editor and copy/paste this script
# to an open slot below ▼ Materials/素材 but above ▼ Main. Remember to save.
#
# -----------------------------------------------------------------------------
# 以下是要放進[技能][註]的東東
# -----------------------------------------------------------------------------
# <chain skill L: x>
# <chain skill R: x>
# <chain skill X: x>
# <chain skill Y: x>
# <chain skill Z: x>
# 這個是給予可連技屬性的東東，X 是技能的編號， 013,102 之類的。放了進去就是代表
# 此技能能連去編號XXX 的技能。當沒有設定時，如只設定了Skill X,Y,Z ，L和R 是不
# 會在連技訊息列表中出現。而不夠資源如MP,TP 時，連技訊息列表中該技能就會黑掉。
# <chain only>
# 這個東東是令該技能在正常技能表中不能選擇，只能透過連技去發動。
#==============================================================================
# ▼ Compatibility
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# This script is made strictly for RPG Maker VX Ace. It is highly unlikely that
# it will run with RPG Maker VX without adjusting.
#
# While this script doesn't interfere with Input Combo Skills, it will most
# likely be unable to used in conjunction with Input Combo Skills. I will not
# provide support for any errors that may occur from this, nor will I be
# responsible for any damage doing this may cause your game.
#
#==============================================================================

module YEA
  module ACTIVE_CHAIN

#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - Chain Skill Settings -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# Adjust general settings here. These settings adjust the sound effect
# played when an active skill is selected and what the minimum time window
# is for an active chain skill.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# 下面是連技成功時的音效，可改。
ACTIVE_SKILL_SOUND = RPG::SE.new("Skill2", 80, 100)

# 下面是設定連技訊息列表出現的時間長度，也就是QTE 的限時。
MINIMUM_TIME = 120

#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - Chain Skill Text -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# 這裡是設定連技訊息列表內容的地方，除了Title 外，都可用text codes.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
CHAIN_TITLE  = "Active Chain Skills"
TITLE_SIZE = 20
L_SKILL_ON = "\eC[17]Q\eC[0]Chain: "
L_SKILL_OFF  = "\eC[7]QChain: "
L_SKILL_ACT  = "\eC[17]QChain: "
R_SKILL_ON = "\eC[17]W\eC[0]Chain: "
R_SKILL_OFF  = "\eC[7]WChain: "
R_SKILL_ACT  = "\eC[17]WChain: "
X_SKILL_ON = "\eC[17]A\eC[0]ttack: "
X_SKILL_OFF  = "\eC[7]Attack: "
X_SKILL_ACT  = "\eC[17]Attack: "
Y_SKILL_ON = "\eC[17]S\eC[0]trike: "
Y_SKILL_OFF  = "\eC[7]Strike: "
Y_SKILL_ACT  = "\eC[17]Strike: "
Z_SKILL_ON = "\eC[17]D\eC[0]efend: "
Z_SKILL_OFF  = "\eC[7]Defend: "
Z_SKILL_ACT  = "\eC[17]Defend: "

  end # ACTIVE_CHAIN
end # YEA

#==============================================================================
# ▼ Editting anything past this point may potentially result in causing
# computer damage, incontinence, explosion of user's head, coma, death, and/or
# halitosis so edit at your own risk.
#==============================================================================

module YEA
  module REGEXP
  module SKILL

CHAIN_ONLY  = /<(?:CHAIN_ONLY|chain only)>/i
CHAIN_SKILL = /<(?:CHAIN_SKILL|chain skill)[ ]([LRXYZ]):[ ](\d+)>/i

  end # SKILL
  end # REGEXP
end # YEA

#==============================================================================
# ■ DataManager
#==============================================================================

module DataManager

  #--------------------------------------------------------------------------
  # alias method: load_database
  #--------------------------------------------------------------------------
  class <<self; alias load_database_acs load_database; end
  def self.load_database
load_database_acs
load_notetags_acs
  end

  #--------------------------------------------------------------------------
  # new method: load_notetags_acs
  #--------------------------------------------------------------------------
  def self.load_notetags_acs
for skill in $data_skills
   next if skill.nil?
   skill.load_notetags_acs
end
  end

end # DataManager

#==============================================================================
# ■ RPG::Skill
#==============================================================================

class RPG::Skill < RPG::UsableItem

  #--------------------------------------------------------------------------
  # public instance variables
  #--------------------------------------------------------------------------
  attr_accessor :chain_only
  attr_accessor :chain_skill

  #--------------------------------------------------------------------------
  # common cache: load_notetags_acs
  #--------------------------------------------------------------------------
  def load_notetags_acs
@chain_only = false
@chain_skill = {}
#---
self.note.split(/[\r\n]+/).each { |line|
   case line
   #---
   when YEA::REGEXP::SKILL::CHAIN_ONLY
      @chain_only = true
   when YEA::REGEXP::SKILL::CHAIN_SKILL
      case $1.upcase
      when "L"; @chain_skill[:L] = $2.to_i
      when "R"; @chain_skill[:R] = $2.to_i
      when "X"; @chain_skill[:X] = $2.to_i
      when "Y"; @chain_skill[:Y] = $2.to_i
      when "Z"; @chain_skill[:Z] = $2.to_i
      else; next
      end
   #---
   end
} # self.note.split
#---
  end

end # RPG::UsableItem

#==============================================================================
# ■ Game_Action
#==============================================================================

class Game_Action

  #--------------------------------------------------------------------------
  # new method: set_active_chain_skill
  #--------------------------------------------------------------------------
  def set_active_chain_skill(skill_id)
set_skill(skill_id)
@target_index = subject.current_action.target_index
@active_chain_skill = true
  end

  #--------------------------------------------------------------------------
  # alias method: valid?
  #--------------------------------------------------------------------------
  alias game_action_valid_acs valid?
  def valid?
subject.enable_active_chain(true) if @active_chain_skill
result = game_action_valid_acs
subject.enable_active_chain(false) if @active_chain_skill
return result
  end

end # Game_Action

#==============================================================================
# ■ Game_BattlerBase
#==============================================================================

class Game_BattlerBase

  #--------------------------------------------------------------------------
  # alias method: skill_conditions_met?
  #--------------------------------------------------------------------------
  alias game_battlerbase_skill_conditions_met_acs skill_conditions_met?
  def skill_conditions_met?(skill)
return false if chain_skill_restriction?(skill)
return game_battlerbase_skill_conditions_met_acs(skill)
  end

  #--------------------------------------------------------------------------
  # new method: chain_skill_restriction?
  #--------------------------------------------------------------------------
  def chain_skill_restriction?(skill)
return false unless actor?
return false unless $game_party.in_battle
return false unless skill.chain_only
return !@active_chain_enabled
  end

  #--------------------------------------------------------------------------
  # alias method: hp=
  #--------------------------------------------------------------------------
  alias game_battlerbase_hpequals_acs hp=
  def hp=(value)
game_battlerbase_hpequals_acs(value)
return unless SceneManager.scene_is?(Scene_Battle)
return unless actor?
return if value == 0
SceneManager.scene.refresh_active_chain_skill_window(self)
  end

  #--------------------------------------------------------------------------
  # alias method: mp=
  #--------------------------------------------------------------------------
  alias game_battlerbase_mpequals_acs mp=
  def mp=(value)
game_battlerbase_mpequals_acs(value)
return unless SceneManager.scene_is?(Scene_Battle)
return unless actor?
return if value == 0
SceneManager.scene.refresh_active_chain_skill_window(self)
  end

  #--------------------------------------------------------------------------
  # alias method: tp=
  #--------------------------------------------------------------------------
  alias game_battlerbase_tpequals_acs tp=
  def tp=(value)
game_battlerbase_tpequals_acs(value)
return unless SceneManager.scene_is?(Scene_Battle)
return unless actor?
return if value == 0
SceneManager.scene.refresh_active_chain_skill_window(self)
  end

end # Game_BattlerBase

#==============================================================================
# ■ Game_Battler
#==============================================================================

class Game_Battler < Game_BattlerBase

  #--------------------------------------------------------------------------
  # alias method: on_battle_start
  #--------------------------------------------------------------------------
  alias game_battler_on_battle_start_acs on_battle_start
  def on_battle_start
game_battler_on_battle_start_acs
@active_chain_enabled = false
  end

  #--------------------------------------------------------------------------
  # alias method: on_battle_end
  #--------------------------------------------------------------------------
  alias game_battler_on_battle_end_acs on_battle_end
  def on_battle_end
game_battler_on_battle_end_acs
@active_chain_enabled = false
  end

  #--------------------------------------------------------------------------
  # new method: enable_active_chain
  #--------------------------------------------------------------------------
  def enable_active_chain(active)
return unless actor?
@active_chain_enabled = active
  end

  #--------------------------------------------------------------------------
  # new method: add_active_skill_chain
  #--------------------------------------------------------------------------
  def add_active_skill_chain(skill_id)
chain_skill = Game_Action.new(self)
chain_skill.set_active_chain_skill(skill_id)
@actions.insert(1, chain_skill)
  end

end # Game_Battler

#==============================================================================
# ■ Window_ChainSkillList
#==============================================================================

class Window_ChainSkillList < Window_Base

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize
dw = [Graphics.width/2, 320].max
super(-standard_padding, 0, dw, fitting_height(6))
self.z = 200
self.opacity = 0
hide
  end

  #--------------------------------------------------------------------------
  # reveal
  #--------------------------------------------------------------------------
  def reveal(battler, skill)
@battler = battler
@skill = skill
@chain_skills = []
for key in skill.chain_skill
   next if key[1].nil?
   next if $data_skills[key[1]].nil?
   next unless @battler.skills.include?($data_skills[key[1]])
   @chain_skills.push($data_skills[key[1]])
end
return if @chain_skills == []
self.y = Graphics.height - fitting_height(4)
self.y -= fitting_height(@chain_skills.size + 1)
show
activate
@enabled = true
refresh
  end

  #--------------------------------------------------------------------------
  # button=
  #--------------------------------------------------------------------------
  def button=(button)
@button = button
@enabled = false
refresh unless @button.nil?
  end

  #--------------------------------------------------------------------------
  # refresh_check
  #--------------------------------------------------------------------------
  def refresh_check(battler)
return if @battler != battler
refresh
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh
@button = nil if @enabled
contents.clear
draw_background_colour
draw_horz_line(0)
draw_combo_title
draw_chain_skills
  end

  #--------------------------------------------------------------------------
  # draw_background_colour
  #--------------------------------------------------------------------------
  def draw_background_colour
dh = line_height * (@chain_skills.size + 1)
rect = Rect.new(0, 0, contents.width, dh)
back_colour1 = Color.new(0, 0, 0, 192)
back_colour2 = Color.new(0, 0, 0, 0)
contents.gradient_fill_rect(rect, back_colour1, back_colour2)
  end

  #--------------------------------------------------------------------------
  # draw_horz_line
  #--------------------------------------------------------------------------
  def draw_horz_line(dy)
line_y = dy + line_height - 2
line_colour = normal_color
line_colour.alpha = 48
contents.fill_rect(0, line_y, contents.width, 2, line_colour)
  end

  #--------------------------------------------------------------------------
  # draw_combo_title
  #--------------------------------------------------------------------------
  def draw_combo_title
reset_font_settings
text = YEA::ACTIVE_CHAIN::CHAIN_TITLE
contents.font.size = YEA::ACTIVE_CHAIN::TITLE_SIZE
contents.font.bold = true
contents.font.italic = true
draw_text(12, 0, contents.width - 12, line_height, text)
reset_font_settings
  end

  #--------------------------------------------------------------------------
  # draw_chain_skills
  #--------------------------------------------------------------------------
  def draw_chain_skills
button_array = [:L, :R, :X, :Y, :Z]
dx = 24
dy = line_height
for button in button_array
   next if @skill.chain_skill[button].nil?
   chain_skill = $data_skills[@skill.chain_skill[button]]
   next unless @battler.skills.include?(chain_skill)
   text = text_setting(button, chain_skill)
   text += sprintf("\eI[%d]", chain_skill.icon_index)
   text += chain_skill.name
   draw_text_ex(dx, dy, text)
   dy += line_height
end
  end

  #--------------------------------------------------------------------------
  # text_setting
  #--------------------------------------------------------------------------
  def text_setting(button, skill)
active = button == @button
text = ""
case button
when :L
   if @enabled && @battler.usable?(skill)
      text = YEA::ACTIVE_CHAIN::L_SKILL_ON
   elsif !@enabled && active
      text = YEA::ACTIVE_CHAIN::L_SKILL_ACT
   else
      text = YEA::ACTIVE_CHAIN::L_SKILL_OFF
   end
when :R
   if @enabled && @battler.usable?(skill)
      text = YEA::ACTIVE_CHAIN::R_SKILL_ON
   elsif !@enabled && active
      text = YEA::ACTIVE_CHAIN::R_SKILL_ACT
   else
      text = YEA::ACTIVE_CHAIN::R_SKILL_OFF
   end
when :X
   if @enabled && @battler.usable?(skill)
      text = YEA::ACTIVE_CHAIN::X_SKILL_ON
   elsif !@enabled && active
      text = YEA::ACTIVE_CHAIN::X_SKILL_ACT
   else
      text = YEA::ACTIVE_CHAIN::X_SKILL_OFF
   end
when :Y
   if @enabled && @battler.usable?(skill)
      text = YEA::ACTIVE_CHAIN::Y_SKILL_ON
   elsif !@enabled && active
      text = YEA::ACTIVE_CHAIN::Y_SKILL_ACT
   else
      text = YEA::ACTIVE_CHAIN::Y_SKILL_OFF
   end
when :Z
   if @enabled && @battler.usable?(skill)
      text = YEA::ACTIVE_CHAIN::Z_SKILL_ON
   elsif !@enabled && active
      text = YEA::ACTIVE_CHAIN::Z_SKILL_ACT
   else
      text = YEA::ACTIVE_CHAIN::Z_SKILL_OFF
   end
end
return text
  end

end # Window_ChainSkillList

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

class Scene_Battle < Scene_Base

  #--------------------------------------------------------------------------
  # alias method: create_all_windows
  #--------------------------------------------------------------------------
  alias scene_battle_create_all_windows_acs create_all_windows
  def create_all_windows
scene_battle_create_all_windows_acs
create_chain_skill_window
  end

  #--------------------------------------------------------------------------
  # new method: create_chain_skill_window
  #--------------------------------------------------------------------------
  def create_chain_skill_window
@active_chain_skill_window = Window_ChainSkillList.new
@active_chain_skill_counter = 0
  end

  #--------------------------------------------------------------------------
  # alias method: use_item
  #--------------------------------------------------------------------------
  alias scene_battle_use_item_acs use_item
  def use_item
@subject.enable_active_chain(true)
item = @subject.current_action.item
chain_skill_list_appear(true, item)
start_active_skill_counter(item)
scene_battle_use_item_acs
wait_active_skill_counter
chain_skill_list_appear(false, item)
@subject.enable_active_chain(false)
  end

  #--------------------------------------------------------------------------
  # new method: chain_skill_list_appear
  #--------------------------------------------------------------------------
  def chain_skill_list_appear(visible, skill)
return if @subject.nil?
return unless @subject.actor?
return unless skill.is_a?(RPG::Skill)
@active_chain_skill = 0
@current_chain_skill = skill
@active_chain_skill_window.reveal(@subject, skill) if visible
@active_chain_skill_window.hide unless visible
  end

  #--------------------------------------------------------------------------
  # new method: refresh_active_chain_skill_window
  #--------------------------------------------------------------------------
  def refresh_active_chain_skill_window(battler)
return unless @active_chain_skill_window.visible
@active_chain_skill_window.refresh_check(battler)
  end

  #--------------------------------------------------------------------------
  # new method: start_active_skill_counter
  #--------------------------------------------------------------------------
  def start_active_skill_counter(skill)
return unless @active_chain_skill_window.visible
@active_chain_skill_counter = YEA::ACTIVE_CHAIN::MINIMUM_TIME
  end

  #--------------------------------------------------------------------------
  # new method: wait_active_skill_counter
  #--------------------------------------------------------------------------
  def wait_active_skill_counter
return unless @active_chain_skill_window.visible
wait(@active_chain_skill_counter)
  end

  #--------------------------------------------------------------------------
  # new method: update_active_chain_skill_counter
  #--------------------------------------------------------------------------
  def update_active_chain_skill_counter
return if @active_chain_skill_counter == 0
@active_chain_skill_counter -= 1
  end

  #--------------------------------------------------------------------------
  # alias method: update_basic
  #--------------------------------------------------------------------------
  alias scene_battle_update_basic_acs update_basic
  def update_basic
scene_battle_update_basic_acs
update_active_chain_skill_counter
update_active_chain_skill_select
  end

  #--------------------------------------------------------------------------
  # new method: update_active_chain_skill_select
  #--------------------------------------------------------------------------
  def update_active_chain_skill_select
return unless @active_chain_skill_window.visible
return if @active_chain_skill > 0
if Input.press?(:L)
   check_active_chain_skill(:L)
elsif Input.press?(:R)
   check_active_chain_skill(:R)
elsif Input.press?(:X)
   check_active_chain_skill(:X)
elsif Input.press?(:Y)
   check_active_chain_skill(:Y)
elsif Input.press?(:Z)
   check_active_chain_skill(:Z)
end
  end

  #--------------------------------------------------------------------------
  # new method: check_active_chain_skill
  #--------------------------------------------------------------------------
  def check_active_chain_skill(button)
skill_id = @current_chain_skill.chain_skill[button]
return if skill_id.nil?
return if $data_skills[skill_id].nil?
chain_skill = $data_skills[skill_id]
return unless @subject.usable?(chain_skill)
return unless @subject.skills.include?(chain_skill)
@active_chain_skill_counter = 12
@active_chain_skill = skill_id
@active_chain_skill_window.button = button
YEA::ACTIVE_CHAIN::ACTIVE_SKILL_SOUND.play
@subject.add_active_skill_chain(skill_id)
  end

end # Scene_Battle

#==============================================================================
#
# ▼ End of File
#
#==============================================================================
[/pre]

invirgin · 发表于 2015-12-19 15:27:20

本帖最后由 invirgin 于 2015-12-19 15:28 编辑

15968715431 发表于 2015-12-19 10:16
#==============================================================================
#
# ▼ Yanfly Engin ...

感谢你热心提供的连击脚本但是这个脚本是“连击”用的发招有顺序的一招连着一招的我想要实现的是只要MP够，一次可以选上好几招(没有顺序，选那个都行)，按确定后，就一起释放了。请问还有其他办法么？谢谢了

jianyulei · 发表于 2015-12-31 09:15:25

每个技能导入事件，让技能再发动行吗？

jianyulei · 发表于 2015-12-31 19:30:31

本帖最后由 jianyulei 于 2015-12-31 19:33 编辑

在技能的右边空栏内双击

然后弹出的窗口选最后一页导入公共事件

再在公共事件里面写好命令，因为引擎自带的强制发动技能没有消耗，所以这里我用了T神的额外战斗行动脚本

http://taroxd.github.io/rgss/
这是T神的脚本库，里面找找吧，还需要吧一个基础脚本放在额外行动脚本上方才能运行。

以上是MP够就能不断发动某个技能直到MP耗尽的做法，如果你想要的效果是只要MP够就能不断行动，可以自行选择技能使用直到MP不足为止的话……也是可以做到的，而且也不难。

jianyulei · 发表于 2016-1-2 12:33:28

你是想把MP作为行动力看，当自己行动时可以任意消耗MP，当MP不足时主动结束回合让下个人物开始行动吧？
需要下面2个脚本
‘’[pre lang="ruby"]# coding: utf-8
#===============================================================================
# ■ [hzm]メモ欄拡張共通部分さん＋ for RGSS3
#-------------------------------------------------------------------------------
#　2014/09/27　Ru/むっくRu
#-------------------------------------------------------------------------------
#  データベースのメモ欄の情報を読み取るための共通処理．
#  メモ欄の各行に特定もフレーズがついたものだけを取得します．
#
#  鳥小屋.txtのメモ欄を使うスクリプト群を使う場合に必須になります．
#  （※スクリプト名の頭に[hzm]が付いているスクリプト）
#-------------------------------------------------------------------------------
# 【注意】
#  「[hzm]メモ欄拡張共通部分 for RGSS3」の機能を内包しています．
#  このスクリプトを導入する場合は，
#  [hzm]メモ欄拡張共通部分 for RGSS3は導入しないでください．
#-------------------------------------------------------------------------------
# 【旧バージョン（[hzm]メモ欄拡張共通部分 for RGSS3）からの仕様変更点】
#  ・メモ欄のヘッダ文字（[hzm]）の他にも複数指定することを可能に
# 指定のメソッドを呼び出すことで，
# [hzm]以外のヘッダ文字をつけたものを認識させることを可能に．
# （僕が）派生スクリプトを作りやすくするのが目的．
#
#  ・同一項目の複数記述に正式対応
# [hzm]属性耐性:炎,50
# [hzm]属性耐性:水,100
# みたいに同じ項目を複数書いても使えるようになります．
# ※注意：別にこのスクリプトに属性耐性の機能があるわけではないです
#
#-------------------------------------------------------------------------------
# 【更新履歴】
# 2014/09/27 キャッシュが存在しない場合に再生成するように変更
# 2012/06/04 バージョンチェック用メソッド名修正
# 2012/06/04 [hzm]メモ欄拡張共通部分 for RGSS3から派生
#-------------------------------------------------------------------------------

#===============================================================================
# ↓ 以下、スクリプト部 ↓
#===============================================================================

# 旧スクリプト導入時にエラー処理を行う
raise "「[hzm]メモ欄拡張共通部分 for RGSS3」が導入されています．\n「[hzm]メモ欄拡張共通部分 for RGSS3」は既に不要なので，\n削除してください．" if defined?(HZM_VXA::Note)

module HZM_VXA
  module Note2
# ● デフォルトのマークフレーズ
# （※変更しないでください）
DEFAULT_MARK = '[hzm]'
# ● 「[hzm]メモ欄拡張共通部分 for RGSS3」との互換性を保持するか？
USE_OLD_STYLE = true
  end
end

module HZM_VXA
  module Note2
#---------------------------------------------------------------------------
# ● メモスクリプトのバージョン
# .区切りの3つの数字で表現
# 1桁目：メジャーバージョン（仕様変更＝互換性破たん時に変更）
# 2桁目：マイナーバージョン（機能追加時に変更）
# 3桁目：パッチバージョン（不具合修正時に変更）
#---------------------------------------------------------------------------
VERSION = '3.0.0'
#---------------------------------------------------------------------------
# ● バージョン比較処理
#---------------------------------------------------------------------------
def self.check_version?(version_str)
   version    = version2array(VERSION)
   req_version = version2array(version_str)
   # メジャーバージョンが要求と一致するか？
   return false unless version[0] == req_version[0]
   # マイナーバージョンが要求より低くないか？
   return false unless version[1] >= req_version[1]
   true
end
#---------------------------------------------------------------------------
# ● バージョン文字列の分解
#---------------------------------------------------------------------------
def self.version2array(version_str)
   version_str.split('.').map{|n| n.to_i}
end
#---------------------------------------------------------------------------
# ● ヘッダマーク配列
#---------------------------------------------------------------------------
@header_mark = []
#---------------------------------------------------------------------------
# ● ヘッダマークの取得
#---------------------------------------------------------------------------
def self.header_mark
   @header_mark
end
#---------------------------------------------------------------------------
# ● ヘッダマークの追加
#---------------------------------------------------------------------------
def self.add_header_mark(mark_str)
   @header_mark.push(mark_str) unless @header_mark.include?(mark_str)
end
#---------------------------------------------------------------------------
# ● メモ欄の内容を解析
#---------------------------------------------------------------------------
def self.setup
   add_header_mark(DEFAULT_MARK)
   list = [
      $data_actors,
      $data_classes,
      $data_skills,
      $data_items,
      $data_weapons,
      $data_armors,
      $data_enemies,
      $data_states,
      $data_tilesets,
   ]
   list.each do |data|
      data.each do |d|
      d.hzm_vxa_note2_init if d
      end
   end
end
#---------------------------------------------------------------------------
# ■ メモ欄を持つクラスに追加するメソッド類
#---------------------------------------------------------------------------
module Utils
   #-------------------------------------------------------------------------
   # ● メモ欄のチェック
   #-------------------------------------------------------------------------
   def hzm_vxa_note2_init
      hzm_vxa_note2_clear
      self.note.split(/\r?\n/).each do |line|
      HZM_VXA::Note2.header_mark.each do |mark|
         next unless line.index(mark) == 0
         l = line.sub!(mark, '')
         if l =~ /^([^\:]+)\:(.+)$/
            hzm_vxa_note2_add(mark, $1, $2)
         else
            hzm_vxa_note2_add(mark, l, '')
         end
      end
      end
   end
   #-------------------------------------------------------------------------
   # ● メモ欄情報の追加
   #-------------------------------------------------------------------------
   def hzm_vxa_note2_add(mark, key, str)
      # 文字列として保存
      @hzm_vxa_note2_str[mark][key] ||= []
      @hzm_vxa_note2_str[mark][key].push(str.to_s)
      # カンマ区切りのデータとして保存
      @hzm_vxa_note2_data[mark][key] ||= []
      data = str.split(/\s*\,\s*/).map do |d|
      if d =~ /^\-?\d+$/
         d.to_i
      elsif d =~ /^\-?\d+\.\d+$/
         d.to_f
      else
         d.to_s
      end
      end
      @hzm_vxa_note2_data[mark][key].push(data)
   end
   #-------------------------------------------------------------------------
   # ● メモ欄情報の削除
   #-------------------------------------------------------------------------
   def hzm_vxa_note2_clear
      @hzm_vxa_note2_str = {}
      @hzm_vxa_note2_data = {}
      HZM_VXA::Note2.header_mark.each do |mark|
      @hzm_vxa_note2_str[mark] = {}
      @hzm_vxa_note2_data[mark] = {}
      end
   end
   #-------------------------------------------------------------------------
   # ● メモ内容取得
   #-------------------------------------------------------------------------
   def hzm_vxa_note2_match(mark, keys)
      hzm_vxa_note2_matches(mark, keys).last
   end
   def hzm_vxa_note2_match_str(mark, keys)
      hzm_vxa_note2_matches_str(mark, keys).last
   end
   def hzm_vxa_note2_matches(mark, keys)
      mark ||= HZM_VXA::Note2::DEFAULT_MARK
      ret = []
      keys.each do |key|
      ret += self.hzm_vxa_note2_data[mark][key] if self.hzm_vxa_note2_data[mark].include?(key)
      end
      ret
   rescue => e
      puts "#{$!} - #{$@}"
   end
   def hzm_vxa_note2_matches_str(mark, keys)
      mark ||= HZM_VXA::Note2::DEFAULT_MARK
      ret = []
      keys.each do |key|
      ret += self.hzm_vxa_note2_str[mark][key] if self.hzm_vxa_note2_str[mark].include?(key)
      end
      ret
   end
   def hzm_vxa_note2_data
      hzm_vxa_note2_init unless @hzm_vxa_note2_data
      @hzm_vxa_note2_data
   end
   def hzm_vxa_note2_str
      hzm_vxa_note2_init unless @hzm_vxa_note2_str
      @hzm_vxa_note2_str
   end
end
  end
end

# メモ欄を持つクラスに機能追加
class RPG::BaseItem
  include HZM_VXA::Note2::Utils
end
class RPG::Tileset
  include HZM_VXA::Note2::Utils
end

# メモ解析
if true
  class << DataManager
alias hzm_vxa_note2_init init
def init
   hzm_vxa_note2_init
   HZM_VXA::Note2.setup
end
  end
end

# 旧スクリプトとの互換性保持
if HZM_VXA::Note2::USE_OLD_STYLE
  module HZM_VXA
module Note
   #-------------------------------------------------------------------------
   # ● メモスクリプトのバージョン
   #-------------------------------------------------------------------------
   VERSION = 2.20
   #-------------------------------------------------------------------------
   # ● バージョンチェック機構
   #-------------------------------------------------------------------------
   def self.check_version(n)
      (n >= 2 and n < 3)
   end
end
  end
  module HZM_VXA
module Note2
   module Utils
      #-----------------------------------------------------------------------
      # ● メモ内容取得
      #-----------------------------------------------------------------------
      def hzm_vxa_note_match(keys)
      hzm_vxa_note2_match(HZM_VXA::Note2::DEFAULT_MARK, keys)
      end
      def hzm_vxa_note(key)
      hzm_vxa_note2_match(HZM_VXA::Note2::DEFAULT_MARK, [key])
      end
      #-----------------------------------------------------------------------
      # ● メモ内容（単一文字列）取得
      #-----------------------------------------------------------------------
      def hzm_vxa_note_str_match(keys)
      hzm_vxa_note2_match_str(HZM_VXA::Note2::DEFAULT_MARK, keys)
      end
      def hzm_vxa_note_str(key)
      hzm_vxa_note2_match_str(HZM_VXA::Note2::DEFAULT_MARK, [key])
      end
   end
end
  end
end
[/pre]

# coding: utf-8
#===============================================================================
# ■ [hzm]ターン消費無しスキルさん＋ for RGSS3
# ※ このスクリプトには「[hzm]メモ欄拡張共通部分さん＋ for RGSS3」が必要です
# 「[hzm]メモ欄拡張共通部分 for RGSS3」では動作しません
#-------------------------------------------------------------------------------
#　2014/06/22　Ru/むっくRu
#-------------------------------------------------------------------------------
# 【機能1：ターン消費無しスキル/アイテム】
#  ターンを消費せずに，選択した瞬間に発動するスキルを設定します．
#  「データベース」の「スキル」の「メモ」欄に以下のように記述してください．
#
#  [hzm]ターン消費無し:n
#  または
#  [hzm]即発動:n
#
#  n の部分は1以上の数値に置き換えてください（例：[hzm]ターン消費無し:1）
#  この数字の部分の回数だけ，1ターン中にこのスキルを使用することができます．
#  （:nの部分を省略した場合、:1と記述した場合と同じになります）
#
#  同様にアイテムにも設定を行うことができます．
#  「データベース」の「アイテム」の「メモ」欄に同様に記述してください．
#-------------------------------------------------------------------------------
# 【機能2：行動順序をスキルごとに反映】
#  デフォルトのシステムだと，例えば2回行動のキャラクターが
#  「通常攻撃（速度補正：0）」，「防御（速度補正：2000）」の
#  2つを選択した場合に，速度補正が低い側（通常攻撃）のほうに統一されてしまい，
#  防御がターンの最初に発動しません．
#
#  このスクリプトでは，ターンの順番をキャラクターごとではなく，
#  そのキャラクターの行動ごとに順番を設定することによって，
#  各行動ごとの速度補正を適用できるようにします．
#
#  例）
#  エリック
# 素早さ： 30　行動：通常攻撃（速度補正：0），防御（速度補正：2000）
#  スライム
# 素早さ：100　行動：通常攻撃（速度補正：0）
#
#  ・デフォルトのシステムの場合
#  スライム通常攻撃→エリック通常攻撃→エリック防御
#
#  ・このスクリプト導入後
#  エリック防御→スライム通常攻撃→エリック通常攻撃
#-------------------------------------------------------------------------------
# 【更新履歴】
# 2014/06/22 通常攻撃にも適用できるように
# 2014/06/07 次回行動アクター取得処理が正常に動いていないのを修正v2
# 2013/07/18 行動終了時に解除される行動制約ステートが解除されないのを修正
# 2013/03/17 エネミーの行動ターン数指定がおかしくなるのを修正。おまけ機能追加。
# 2013/02/16 ターン開始時に行動不能が解除された際にエラー落ちするのを修正
# 2013/01/11 コモンイベント呼び出しでアクターを離脱させるとエラー落ちしていたのを修正
# 2012/10/14 行動回数再計算ON時，エネミーが「逃げる」とエラー落ちしていたのを修正
# 2012/10/09 マップ上でアイテムを使用した際にエラー落ちしていたのを修正
# 2012/10/06 戦闘中にパーティ入れ替えを行った場合にエラー落ちしていたのを修正
#          ステータスウィンドウの更新が正常に行われていなかったのを修正
# 2012/10/05 大幅修正を行いました．
#          新メモスクリプト（[hzm]メモ欄拡張共通部分さん＋ for RGSS3）用に変更
#          行動回数の再計算機能（アクター/エネミー）を追加
#          1ターン内で使用できる回数の設定を追加
#          「各行動ごとに行動順を設定さん for RGSS3」の機能を内包
# 2012/10/03 行動回数の再計算（暫定）を追加
# 2012/06/01 エネミー用設定を追加
# 2012/04/21 複数回行動するアクターが正常に動作しない不具合を修正
# 2012/04/01 味方の行動不能状態を回復した際に強制終了する不具合を修正
# 2012/03/28 アイテムにも対応
# 2012/01/28 コモンイベント内で「戦闘行動の強制」を使用した際に強制終了するのを修正
# 2012/01/28 コモンイベントの呼び出しが正常に動作しないのを少し修正
# 2012/01/03 ぶっぱ
#-------------------------------------------------------------------------------

#===============================================================================
# ● 設定項目
#===============================================================================
module HZM_VXA
  module QuickSkill
# ● ターン消費無し行動後に行動回数を再計算する（上級設定）
# [効果]
# ・エネミーも（疑似的に）ターン消費無しスキルを使用可能に
# ・行動回数を変化させるステートを即時反映
# [副作用]
# ・50%の確率で行動回数増加などの設定が使用不可に
#    true  : する
#    false : しない
CHECK_ACTION_TIMES = false

# ● オマケ機能：敵の行動パターンのターン数の仕様をVX化
# 1ターン目（最初のターン）に指定の行動をさせたい場合、
# VX Aceでは行動パターンを0ターン目に設定する必要があります。
# この設定方法をVX同様の仕様に変更し、
# 1ターン目の場合は1ターン目に設定できるようにします。
# （上級設定に関係なく使用できます）
# true  : VX仕様にする
# false : 変更しない
ENEMY_TURN_NORMALIZE = false
  end
end

#===============================================================================
# ↑ 　ここまで設定　 ↑
# ↓ 以下、スクリプト部 ↓
#===============================================================================

raise "「[hzm]メモ欄拡張共通部分さん＋ for RGSS3」を導入してください" unless defined?(HZM_VXA::Note2)
raise "「[hzm]メモ欄拡張共通部分さん＋ for RGSS3」のバージョンが一致しません" unless HZM_VXA::Note2.check_version?('3.0.0')

module HZM_VXA
  module QuickSkill
# メモ欄から読み込む要素名の候補を設定
QUICK_KEYS = ['ターン消費無し', '即発動',  'QuickSkill']
#---------------------------------------------------------------------------
# ● QuickSkill中か？
#---------------------------------------------------------------------------
def self.quickSkill?
   @quickSkill
end
#---------------------------------------------------------------------------
# ● 即時行動開始
#---------------------------------------------------------------------------
def self.start
   @quickSkill = true
end
#---------------------------------------------------------------------------
# ● 即時行動終了
#---------------------------------------------------------------------------
def self.finish
   @quickSkill = false
   # 全てのbattlerのアクションを戻す
   $game_party.hzm_vxa_quickSkill_force_action_reverse
   $game_troop.hzm_vxa_quickSkill_force_action_reverse
end
#---------------------------------------------------------------------------
# ● スキル使用回数のリセット
#---------------------------------------------------------------------------
def self.reset_use_count
   $game_party.hzm_vxa_quickSkill_reset_use_count
   $game_troop.hzm_vxa_quickSkill_reset_use_count
end
# ターン消費無しアイテム管理対象
ITEM_COUNT_PARTY = true
  end
end

module BattleManager
  #-----------------------------------------------------------------------------
  # ● 行動順序の作成（再定義）
  #-----------------------------------------------------------------------------
  def self.make_action_orders
@action_battlers = []
all_actions = []
all_members = []
all_members += $game_party.members unless @surprise
all_members += $game_troop.members unless @preemptive
all_members.each do |member|
   next unless member.movable?
   member.make_speed
   member.actions.each {|action| all_actions.push action }
end
all_actions.sort!{|a,b| b.speed - a.speed }
all_actions.each {|action| @action_battlers.push action.subject}
  end
  #-----------------------------------------------------------------------------
  # ● 行動が未選択のアクターを先頭から探す（独自）
  #-----------------------------------------------------------------------------
  def self.hzm_vxa_quickSkill_can_action_actor_before(daemon)
return false unless $game_party.members.index(daemon)
for @actor_index in 0..$game_party.members.index(daemon)
   actor = $game_party.members[@actor_index]
   return true if actor.next_command
end
false
  end
end

class Game_Unit
  attr_accessor :hzm_vxa_quickSkill_can_use_item
  #-----------------------------------------------------------------------------
  # ● 戦闘開始処理（エイリアス）
  #-----------------------------------------------------------------------------
  alias hzm_vxa_quickSkill_on_battle_start on_battle_start
  def on_battle_start
hzm_vxa_quickSkill_on_battle_start
hzm_vxa_quickSkill_reset_use_count
  end
  #-----------------------------------------------------------------------------
  # ● 戦闘行動の復元（独自）
  #-----------------------------------------------------------------------------
  def hzm_vxa_quickSkill_force_action_reverse
members.each {|member| member.hzm_vxa_quickSkill_force_action_reverse }
  end
  #-----------------------------------------------------------------------------
  # ● スキル使用回数のリセット（独自）
  #-----------------------------------------------------------------------------
  def hzm_vxa_quickSkill_reset_use_count
members.each {|member| member.hzm_vxa_quickSkill_reset_use_count }
if HZM_VXA::QuickSkill::ITEM_COUNT_PARTY
   @hzm_vxa_quickSkill_can_use_item ||= []
   @hzm_vxa_quickSkill_can_use_item.clear
end
  end
end

class Game_Battler < Game_BattlerBase
  #-----------------------------------------------------------------------------
  # ● 行動速度の決定（エイリアス）
  #-----------------------------------------------------------------------------
  alias hzm_vxa_quickSkill_make_speed make_speed
  def make_speed
# 空行動は削除する
@actions.reject! {|a| a == nil}
# 元の処理
hzm_vxa_quickSkill_make_speed
# アクションを速度順にソート
@actions.sort! {|a,b| b.speed - a.speed }
  end
  #-----------------------------------------------------------------------------
  # ● スキルの使用可能条件チェック（エイリアス）
  #-----------------------------------------------------------------------------
  alias hzm_vxa_quickSkill_skill_conditions_met? skill_conditions_met?
  def skill_conditions_met?(skill)
# 元の処理
return false unless hzm_vxa_quickSkill_skill_conditions_met?(skill)
# 戦闘中でなければOK
return true unless $game_party.in_battle
# 指定回数チェック
if data = skill.hzm_vxa_note_match(HZM_VXA::QuickSkill::QUICK_KEYS)
   cnt = data.first.to_i
   cnt = 1  unless cnt > 0
   hzm_vxa_quickSkill_reset_use_count unless @hzm_vxa_quickSkill_can_use_skill
   return false if cnt > 0 and @hzm_vxa_quickSkill_can_use_skill.count(skill.id) >= cnt
end
true
  end
  #-----------------------------------------------------------------------------
  # ● アイテムの使用可能条件チェック（エイリアス）
  #-----------------------------------------------------------------------------
  alias hzm_vxa_quickSkill_item_conditions_met? item_conditions_met?
  def item_conditions_met?(item)
# 元の処理
return false unless hzm_vxa_quickSkill_item_conditions_met?(item)
# 戦闘中でなければOK
return true unless $game_party.in_battle
# 指定回数チェック
if data = item.hzm_vxa_note_match(HZM_VXA::QuickSkill::QUICK_KEYS)
   cnt = data.first.to_i
   cnt = 1  unless cnt > 0
   if HZM_VXA::QuickSkill::ITEM_COUNT_PARTY
      return false if cnt > 0 and $game_party.hzm_vxa_quickSkill_can_use_item.count(item.id) >= cnt
   else
      return false if cnt > 0 and @hzm_vxa_quickSkill_can_use_item.count(item.id) >= cnt
   end
end
true
  end
  #-----------------------------------------------------------------------------
  # ● スキル使用回数リセット（独自）
  #-----------------------------------------------------------------------------
  def hzm_vxa_quickSkill_reset_use_count
   @hzm_vxa_quickSkill_can_use_skill ||= []
   @hzm_vxa_quickSkill_can_use_skill.clear
   unless HZM_VXA::QuickSkill::ITEM_COUNT_PARTY
      @hzm_vxa_quickSkill_can_use_item ||= []
      @hzm_vxa_quickSkill_can_use_item.clear
   end
  end
  #-----------------------------------------------------------------------------
  # ● 戦闘行動の強制（エイリアス）
  #-----------------------------------------------------------------------------
  alias hzm_vxa_quickSkill_force_action force_action
  def force_action(skill_id, target_index)
@hzm_vxa_quickSkill_actions = HZM_VXA::QuickSkill.quickSkill? ? @actions.clone : nil
hzm_vxa_quickSkill_force_action(skill_id, target_index)
  end
  #-----------------------------------------------------------------------------
  # ● 戦闘行動の復元（独自）
  #-----------------------------------------------------------------------------
  def hzm_vxa_quickSkill_force_action_reverse
return unless @hzm_vxa_quickSkill_actions
@actions = @hzm_vxa_quickSkill_actions
@hzm_vxa_quickSkill_actions = nil
  end
  #-----------------------------------------------------------------------------
  # ● スキル／アイテムの使用（エイリアス）
  #-----------------------------------------------------------------------------
  alias hzm_vxa_quickSkill_use_item use_item
  def use_item(item)
# 戦闘中かどうか？
if $game_party.in_battle
   # カウント可能か確認
   hzm_vxa_quickSkill_reset_use_count unless @hzm_vxa_quickSkill_can_use_skill
   # スキル/アイテム使用回数カウント
   @hzm_vxa_quickSkill_can_use_skill.push(item.id) if item.is_a?(RPG::Skill)
   if HZM_VXA::QuickSkill::ITEM_COUNT_PARTY
      $game_party.hzm_vxa_quickSkill_can_use_item.push(item.id)  if item.is_a?(RPG::Item)
   else
      @hzm_vxa_quickSkill_can_use_item.push(item.id)  if item.is_a?(RPG::Item)
   end
end
# 元の処理
hzm_vxa_quickSkill_use_item(item)
  end
end

class Game_Actor < Game_Battler
  #-----------------------------------------------------------------------------
  # ● アクションを先頭に入れ替え（独自）
  #-----------------------------------------------------------------------------
  def hzm_vxa_quickSkill_swapAction
tmp = @actions[0]
@actions[0] = @actions[@action_input_index]
@actions[@action_input_index] = tmp
  end
end

class Game_Action
  #-----------------------------------------------------------------------------
  # ● 行動速度の計算（エイリアス）
  #-----------------------------------------------------------------------------
  alias hzm_vxa_quickSkillEnemy_speed speed
  def speed
# ターン消費無し行動の行動速度を最速化
item.speed = 999999 if item and item.hzm_vxa_note_match(HZM_VXA::QuickSkill::QUICK_KEYS)
# 元の処理
hzm_vxa_quickSkillEnemy_speed
  end
end

class Scene_Battle < Scene_Base
  #-----------------------------------------------------------------------------
  # ● 情報表示ビューポートの更新（エイリアス）
  #-----------------------------------------------------------------------------
  alias hzm_vxa_quickSkill_update_info_viewport update_info_viewport
  def update_info_viewport
# 元の処理
hzm_vxa_quickSkill_update_info_viewport
# ターン消費無し行動中は非表示に
move_info_viewport(64) if @hzm_vxa_quickSkill_active
  end
  #-----------------------------------------------------------------------------
  # ● 次のコマンド入力へ（エイリアス）
  #-----------------------------------------------------------------------------
  alias hzm_vxa_quickSkill_next_command next_command
  def next_command
# ターン消費無し行動が選択されているか確認・実行
if @hzm_vxa_quickSkill_skill and
   @hzm_vxa_quickSkill_skill.hzm_vxa_note_match(HZM_VXA::QuickSkill::QUICK_KEYS)
   # ターン消費無し行動の実行
   hzm_vxa_quickSkill_run
   # 行動を再選択
   if BattleManager.hzm_vxa_quickSkill_can_action_actor_before(@subject) or
      @subject.inputable?
      @subject.prior_command
      return start_actor_command_selection
   end
end
# 元の処理
hzm_vxa_quickSkill_next_command
  end
  #-----------------------------------------------------------------------------
  # ● コマンド［攻撃］（エイリアス）
  #-----------------------------------------------------------------------------
  alias hzm_vxa_quickSkill_command_attack command_attack
  def command_attack
@hzm_vxa_quickSkill_skill = $data_skills[BattleManager.actor.attack_skill_id]
hzm_vxa_quickSkill_command_attack
  end
  #-----------------------------------------------------------------------------
  # ● スキル［決定］（エイリアス）
  #-----------------------------------------------------------------------------
  alias hzm_vxa_quickSkill_on_skill_ok on_skill_ok
  def on_skill_ok
@hzm_vxa_quickSkill_skill = @skill_window.item
hzm_vxa_quickSkill_on_skill_ok
  end
  #-----------------------------------------------------------------------------
  # ● スキル［キャンセル］（エイリアス）
  #-----------------------------------------------------------------------------
  alias hzm_vxa_quickSkill_on_skill_cancel on_skill_cancel
  def on_skill_cancel
@hzm_vxa_quickSkill_skill = nil
hzm_vxa_quickSkill_on_skill_cancel
  end
  #-----------------------------------------------------------------------------
  # ● アイテム［決定］（エイリアス）
  #-----------------------------------------------------------------------------
  alias hzm_vxa_quickSkill_on_item_ok on_item_ok
  def on_item_ok
@hzm_vxa_quickSkill_skill = @item_window.item
hzm_vxa_quickSkill_on_item_ok
  end
  #-----------------------------------------------------------------------------
  # ● アイテム［キャンセル］（エイリアス）
  #-----------------------------------------------------------------------------
  alias hzm_vxa_quickSkill_on_item_cancel on_item_cancel
  def on_item_cancel
@hzm_vxa_quickSkill_skill = nil
hzm_vxa_quickSkill_on_item_cancel
  end
  #-----------------------------------------------------------------------------
  # ● アクターコマンド選択の開始（エイリアス）
  #-----------------------------------------------------------------------------
  alias hzm_vxa_quickSkill_start_actor_command_selection start_actor_command_selection
  def start_actor_command_selection
hzm_vxa_quickSkill_start_actor_command_selection
BattleManager.actor.make_actions unless BattleManager.actor.input
  end
  #--------------------------------------------------------------------------
  # ● 強制された戦闘行動の処理（エイリアス）
  #--------------------------------------------------------------------------
  alias hzm_vxa_quickSkill_process_forced_action process_forced_action
  def process_forced_action
@hzm_vxa_quickSkill_force_action = BattleManager.action_forced?

# 元の処理
hzm_vxa_quickSkill_process_forced_action

@hzm_vxa_quickSkill_force_action = nil
  end
  #-----------------------------------------------------------------------------
  # ● 戦闘行動の処理（再定義）
  #-----------------------------------------------------------------------------
#~ def process_action
#~    return if scene_changing?

#~    # 強制行動の場合は次回アクターを計算しない
#~    unless @hzm_vxa_quickSkill_force_action
#~    if HZM_VXA::QuickSkill::CHECK_ACTION_TIMES
#~       HZM_VXA::QuickSkill.re_action_times if @hzm_vxa_quickSkill_re_action_times_flag
#~       @hzm_vxa_quickSkill_re_action_times_flag = false
#~    end

#~    BattleManager.make_action_orders
#~    @subject = BattleManager.next_subject
#~    end

#~    return turn_end unless @subject
#~    if @subject.current_action
#~    @subject.current_action.prepare
#~    if @subject.current_action.valid?
#~       @status_window.open
#~       execute_action
#~    end
#~    @subject.remove_current_action
#~    end
#~    process_action_end unless @subject.current_action
#~ end
  #-----------------------------------------------------------------------------
  # ● ターン終了（エイリアス）
  #-----------------------------------------------------------------------------
  alias hzm_vxa_quickSkill_turn_end turn_end
  def turn_end
# 行動不能キャラの行動終了処理を実行
# （※行動順序厳密化によりステート「行動終了時」が実行されないため）
all_battle_members.each do |battler|
   next if battler.movable?
   @subject = battler
   process_action_end
end
@subject = nil
# 元の処理
hzm_vxa_quickSkill_turn_end
# ターン中使用回数リセット
HZM_VXA::QuickSkill.reset_use_count
  end
  #-----------------------------------------------------------------------------
  # ● ターン消費無し行動の実行（独自）
  #-----------------------------------------------------------------------------
  def hzm_vxa_quickSkill_run
return unless @hzm_vxa_quickSkill_skill
@hzm_vxa_quickSkill_skill = nil
# 行動の開始
HZM_VXA::QuickSkill::start
@actor_command_window.close if @actor_command_window
@hzm_vxa_quickSkill_active = true
# 行動アクター，行動内容の設定
@subject = BattleManager.actor
@subject.hzm_vxa_quickSkill_swapAction # 選んだ行動を先頭に引きずり出す
# 行動
execute_action
# イベント処理
process_event
# おわり
@subject.hzm_vxa_quickSkill_swapAction # 元の位置に戻す
HZM_VXA::QuickSkill::finish
# ウィンドウを戻す
refresh_status
@hzm_vxa_quickSkill_active = false
@actor_command_window.open if @actor_command_window
@status_window.open if @status_window
# 行動回数の再計算
HZM_VXA::QuickSkill.re_action_times if HZM_VXA::QuickSkill::CHECK_ACTION_TIMES
  end
end

# 行動回数の再計算用 & エネミー行動ターン数正常化共通処理
if HZM_VXA::QuickSkill::CHECK_ACTION_TIMES or HZM_VXA::QuickSkill::ENEMY_TURN_NORMALIZE
  class << BattleManager
#---------------------------------------------------------------------------
# ● ターン終了（エイリアス）
#---------------------------------------------------------------------------
alias hzm_vxa_quickSkill_turn_end turn_end
def turn_end
   hzm_vxa_quickSkill_turn_end
   $game_troop.hzm_vxa_quickSkill_increase_turn2
end
  end

  class Game_Troop < Game_Unit
attr_reader :hzm_vxa_quickSkill_turn_count
#---------------------------------------------------------------------------
# ● クリア（エイリアス）
#---------------------------------------------------------------------------
alias hzm_vxa_quickSkill_clear clear
def clear
   hzm_vxa_quickSkill_clear
   @hzm_vxa_quickSkill_turn_count = HZM_VXA::QuickSkill::ENEMY_TURN_NORMALIZE ? 1 : 0
end
#---------------------------------------------------------------------------
# ● クリア（独自）
#---------------------------------------------------------------------------
def hzm_vxa_quickSkill_increase_turn2
   @hzm_vxa_quickSkill_turn_count += 1
end
  end

  class Game_Enemy < Game_Battler
#--------------------------------------------------------------------------
# ● 行動条件合致判定［ターン数］（再定義）
#--------------------------------------------------------------------------
def conditions_met_turns?(param1, param2)
   n = $game_troop.hzm_vxa_quickSkill_turn_count
   if param2 == 0
      n == param1
   else
      n > 0 && n >= param1 && n % param2 == param1 % param2
   end
end
  end
end

# 行動回数の再計算用
if HZM_VXA::QuickSkill::CHECK_ACTION_TIMES
  module HZM_VXA
module QuickSkill
   #-------------------------------------------------------------------------
   # ● 行動回数の再計算
   #-------------------------------------------------------------------------
   if CHECK_ACTION_TIMES
      def self.re_action_times
      $game_party.hzm_vxa_quickSkill_re_action_times
      $game_troop.hzm_vxa_quickSkill_re_action_times
      end
   end
end
  end

  class Game_Unit
#---------------------------------------------------------------------------
# ● 行動回数の再計算（独自）
#---------------------------------------------------------------------------
def hzm_vxa_quickSkill_re_action_times
   members.each {|member| member.hzm_vxa_quickSkill_re_action_times }
end
  end

  class Game_Actor < Game_Battler
#---------------------------------------------------------------------------
# ● 行動回数の再計算
#---------------------------------------------------------------------------
if HZM_VXA::QuickSkill::CHECK_ACTION_TIMES
   def hzm_vxa_quickSkill_re_action_times
      action_cnt = make_action_times
      @actions.push Game_Action.new(self) while @actions.size < action_cnt
      @actions.pop while @actions.size > action_cnt
   end
end
  end

  class Game_Enemy < Game_Battler
#---------------------------------------------------------------------------
# ● 行動回数の再計算（独自）
#---------------------------------------------------------------------------
def hzm_vxa_quickSkill_re_action_times
   action_cnt = make_action_times
   make_actions if @actions.size < action_cnt
   @actions.pop while @actions.size > action_cnt
end
  end

  class Scene_Battle < Scene_Base
#---------------------------------------------------------------------------
# ● スキル／アイテムの使用（エイリアス）
#---------------------------------------------------------------------------
alias hzm_vxa_quickSkill_use_item use_item
def use_item
   # 元の処理
   hzm_vxa_quickSkill_use_item
   # 行動回数の再計算フラグ（エネミーの場合）
   item = (@subject.enemy? and @subject.current_action) ?
      @subject.current_action.item : nil
   @hzm_vxa_quickSkill_re_action_times_flag =
      (item and item.hzm_vxa_note_match(HZM_VXA::QuickSkill::QUICK_KEYS))
end
  end
end

第一个是前置脚本，第二个脚本可以让技能不消耗回合发动，附带了个技能排序功能，不过这个功能你可以忽视。
在技能备注 [hzm]即発動:99 就能让技能不消耗回合发动出来，你再做个技能，名叫跳过回合对自己使用，附加一个没有任何意义的状态，当没有MP的时候用这个技能就到下一个人行动了。
如果你是想某技能的连击只有部分技能可以适用，那么你先建立一个单独的技能类型，把这些技能全放到这个技能类型里，可以造成连击的技能为自己附加1回合的状态，效果是获得技能类型，并失去其他技能类型，如果你不想让攻击和防御指令也能使用的话也可以添加进去。如果是道具不能使用那么需要用某个插件。

soulsaga · 发表于 2016-1-2 12:41:16

LZ其实是想一次行动中选多个技能..MP不夠就不能选才对啊..
然后按确定一次过发动所有技能这样..

invirgin · 发表于 2016-1-2 13:47:14

soulsaga 发表于 2016-1-2 12:41
LZ其实是想一次行动中选多个技能..MP不夠就不能选才对啊..
然后按确定一次过发动所有技能这样.. ...

是的是的就是这个意思有什么办法吗？

[已经过期] 请问有没有战斗时一次出两招的方法

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

点评

点评

点评

开拓者

[已经过期] 请问有没有 战斗时 一次出两招的 方法

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

点评

点评

点评

开拓者

[已经过期] 请问有没有战斗时一次出两招的方法