DoubleX RMVXA Unison Skills/Items - Printable Version+- Save-Point (https://www.save-point.org)
+-- Forum: Material Development (https://www.save-point.org/forum-8.html)
+--- Forum: Scripts Database (https://www.save-point.org/forum-39.html)
+---- Forum: RPGMaker VX/VXAce (RGSS2/3) Engines (https://www.save-point.org/forum-117.html)
+---- Thread:
DoubleX RMVXA Unison Skills/Items (/thread-4958.html)DoubleX RMVXA Unison Skills/Items - DoubleX - 01-24-2014
DoubleX RMVXA Unison Skills/Items
Version: v1.01d
IntroductionVersion: v1.01d
Allows users to create unison skills or items for actors
Features
* Use of notetags(needs knowledge of notetag usage) to set specific skills or items needing specific actors and using specific parameter rules in their damage formulae in notetags in these skills or items' notebox
Video
Script
"script"
Code:
#==============================================================================|
# ** DoubleX RMVXA Unison Skills/Items v1.01d |
#------------------------------------------------------------------------------|
# * Changelog |
# v1.01d(GMT 0300 21-7-2015): |
# - Increased this script's effectiveness, efficiency and flexibility |
# v1.01c(GMT 0900 1-6-2014): |
# - Fixed unison item not invoking common event bug |
# v1.01b(GMT 0030 13-2-2014): |
# - Fixed nil @input_actor and @unison_actor bug |
# v1.01a(GMT 0700 7-2-2014): |
# - Added <unison param: x> notetag |
# v1.00e(GMT 0300 26-1-2014): |
# - Fixed nil, non-skill and non-item item bug |
# v1.00d(GMT 0500 24-1-2014): |
# - Fixed Action Times+ Bug |
# v1.00c(GMT 0900 16-1-2014): |
# - Unison skills and items can only be selected by their unison actors |
# v1.00b(GMT 1300 15-1-2014): |
# - Fixed $game_actors[actor_id] with actor_id equals nil bug |
# v1.00a(GMT 0600 15-1-2014): |
# - 1st version of this script finished |
#------------------------------------------------------------------------------|
# * Author |
# DoubleX |
#------------------------------------------------------------------------------|
# * Terms of use |
# None other than not claiming this script as created by anyone except |
# DoubleX or his alias |
#------------------------------------------------------------------------------|
# * Prerequisites |
# Scripts: |
# - none |
# Knowledge: |
# - Use of notetags |
#------------------------------------------------------------------------------|
# * Functions |
# - Allows users to create unison skills or items for actors |
#------------------------------------------------------------------------------|
# * Manual |
# To use this script, open the script editor and put this script into an |
# open slot between ▼ Materials and ▼ Main. Save to take effect. |
#------------------------------------------------------------------------------|
# * Compatibility |
# Scripts rewriting or aliasing: |
# - load_database under DataManager |
# - param, inputable? or usable? under Game_BattlerBase |
# - make_damage_value or use_item under Game_Battler |
# - clear_actions or next_command under Game_Actor |
# - enable? under Window_ItemList |
# - display_use_item under Window_BattleLog |
# - start, next_command, prior_command or turn_start under Scene_Battle |
# may have compatibility issues with this script |
# Place this script above those aliasing any of these methods if possible |
#==============================================================================|
($imported ||= {})["DoubleX RMVXA Unison Item"] = true
#------------------------------------------------------------------------------|
# * Notetag <unison item: x> for skills and items: |
# x is the list of id of actors needed for the skill or item. For instance: |
# - <unison item: 1> means actor with id 1 is required to use it |
# - <unison item: 4, 2> means actors with id 4 and 2 are needed to use it |
# All actors in list x needs to be in the battle, inputable, able to use it |
# and pay its cost. They'll all pay the cost after using it. Only actors in |
# list x can select it. |
#------------------------------------------------------------------------------|
# * Notetag <unison rule: x> for skills and items: |
# x is the rule of setting parameters used in the damage formula of the |
# skill or item. Notetag setting overrides the universal UNISON_PARAM_RULE. |
# This notetag doesn't work if <unison item: x> is absent or x is nil. |
#------------------------------------------------------------------------------|
# * Notetag <unison param: x> for skills and items: |
# x is the list of id of actors needed for the skill or item and stat is |
# parameters used in its damage formula. For instance: |
# - <unison atk: 1> means atk in its damage formula uses atk of actor with |
# id 1 |
# - <unison mat: 4, 2> means mat in its damage formula uses mat of actors |
# with id 4 and 2 under unison rule specified in <unison rule: x> notetag |
# param can be hp, mp, tp, level, mhp, mmp, atk, def, mat, mdf, agi or luk. |
#------------------------------------------------------------------------------|
#==============================================================================|
# ** You only need to edit this part as it's about what this script does |
#------------------------------------------------------------------------------|
module DoubleX_RMVXA
module Unison_Item
#------------------------------------------------------------------------------|
# * SHOW_UNISON_ACTOR, default = true |
# The battlelog will show all actors involved in the unison skills or items |
# instead of only the one invoking them if SHOW_UNISON_ACTOR is true. |
#------------------------------------------------------------------------------|
SHOW_UNISON_ACTOR = true
#------------------------------------------------------------------------------|
# * UNISON_PARAM_RULE, default = 2 |
# Each parameter in the damage formula of the unison skills or items used |
# will be altered by one of the rules below if there's no working notetag: |
# 0 - No changes will take place |
# 1 - Its minimum among all actors involved in the unison skills or items |
# used will be used in their damage formulae |
# 2 - Its average among all actors involved in the unison skills or items |
# used will be used in their damage formulae |
# 3 - Its maximum among all actors involved in the unison skills or items |
# used will be used in their damage formulae |
#------------------------------------------------------------------------------|
UNISON_PARAM_RULE = 2
#==============================================================================|
#==============================================================================|
# ** You need not edit this part as it's about how this script works |
#------------------------------------------------------------------------------|
UNISON_PARAM_0 = /<(?:UNISON_PARAM_0|unison mhp):[ ](\d+(?:\s*,\s*\d+)*)>/i
UNISON_PARAM_1 = /<(?:UNISON_PARAM_1|unison mmp):[ ](\d+(?:\s*,\s*\d+)*)>/i
UNISON_PARAM_2 = /<(?:UNISON_PARAM_2|unison atk):[ ](\d+(?:\s*,\s*\d+)*)>/i
UNISON_PARAM_3 = /<(?:UNISON_PARAM_3|unison def):[ ](\d+(?:\s*,\s*\d+)*)>/i
UNISON_PARAM_4 = /<(?:UNISON_PARAM_4|unison mat):[ ](\d+(?:\s*,\s*\d+)*)>/i
UNISON_PARAM_5 = /<(?:UNISON_PARAM_5|unison mdf):[ ](\d+(?:\s*,\s*\d+)*)>/i
UNISON_PARAM_6 = /<(?:UNISON_PARAM_6|unison agi):[ ](\d+(?:\s*,\s*\d+)*)>/i
UNISON_PARAM_7 = /<(?:UNISON_PARAM_7|unison luk):[ ](\d+(?:\s*,\s*\d+)*)>/i
UNISON_PARAM_hp = /<(?:UNISON_PARAM_hp|unison hp):[ ](\d+(?:\s*,\s*\d+)*)>/i
UNISON_PARAM_mp = /<(?:UNISON_PARAM_mp|unison mp):[ ](\d+(?:\s*,\s*\d+)*)>/i
UNISON_PARAM_tp = /<(?:UNISON_PARAM_tp|unison tp):[ ](\d+(?:\s*,\s*\d+)*)>/i
UNISON_PARAM_level = /<(?:UNISON_PARAM_level|unison level):[ ](\d+(?:\s*,\s*\d+)*)>/i
end # Unison_Item
end # DoubleX_RMVXA
#------------------------------------------------------------------------------|
# * Edit module: DataManager |
#------------------------------------------------------------------------------|
class << DataManager
#----------------------------------------------------------------------------|
# Alias method: load_database |
#----------------------------------------------------------------------------|
alias load_database_unison_item load_database
def load_database
load_database_unison_item
# Added to load unison notetags
load_notetags_unison_item
#
end # load_database
#----------------------------------------------------------------------------|
# New method: load_notetags_unison_item |
#----------------------------------------------------------------------------|
def load_notetags_unison_item
[$data_skills, $data_items].each { |data|
data.each { |obj| obj.load_notetags_unison_item if obj }
}
end # load_notetags_unison_item
end # DataManager
#------------------------------------------------------------------------------|
# * Edit class: RPG::UsableItem |
#------------------------------------------------------------------------------|
class RPG::UsableItem < RPG::BaseItem
#----------------------------------------------------------------------------|
# New public instance variables |
#----------------------------------------------------------------------------|
attr_accessor :unison_item
attr_accessor :unison_actor_id
attr_accessor :unison_rule
[0, 1, 2, 3, 4, 5, 6, 7, "hp", "mp", "tp", "level"].each { |param|
eval("attr_accessor :unison_param_#{param = param.to_s}")
eval("attr_accessor :unison_param_#{param}_id")
}
#----------------------------------------------------------------------------|
# New method: load_notetags_unison_item |
#----------------------------------------------------------------------------|
def load_notetags_unison_item
@unison_item = false
@unison_actor_id = []
@unison_rule = (ui = DoubleX_RMVXA::Unison_Item)::UNISON_PARAM_RULE
[0, 1, 2, 3, 4, 5, 6, 7, "hp", "mp", "tp", "level"].each { |param|
eval("@unison_param_#{param = param.to_s} = false")
eval("@unison_param_#{param}_id = []")
}
@note.split(/[\r\n]+/).each { |line|
case line
when /<(?:UNISON_ITEM|unison item):[ ](\d+(?:\s*,\s*\d+)*)>/i
$1.scan(/\d+/).each { |n| @unison_actor_id << n.to_i if n.to_i > 0 }
@unison_item ||= @unison_actor_id.size > 0
when /<(?:UNISON_RULE|unison rule):[ ]*(\d+)>/i
@unison_rule = $1.to_i if @unison_item
else
[0, 1, 2, 3, 4, 5, 6, 7, "hp", "mp", "tp", "level"].each { |param|
case line
when eval("ui::UNISON_PARAM_#{param = param.to_s}")
$1.scan(/\d+/).each { |num|
eval("@unison_param_#{param}_id.push(num.to_i)") if num.to_i > 0
}
eval("@unison_param_#{param} = true") if
eval("@unison_param_#{param}_id.size > 0")
end
}
end
}
end # load_notetags_unison_item
end # RPG::UsableItem
#------------------------------------------------------------------------------|
# * Edit class: Game_BattlerBase |
#------------------------------------------------------------------------------|
class Game_BattlerBase
#----------------------------------------------------------------------------|
# Alias method: param |
#----------------------------------------------------------------------------|
alias param_unison_item param
def param(param_id)
# Rewritten to return unison param when it's set
@unison_param_set ? @unison_param[param_id] : param_unison_item(param_id)
#
end # param
#----------------------------------------------------------------------------|
# Alias method: inputable? |
#----------------------------------------------------------------------------|
alias inputable_unison_item? inputable?
def inputable?
# Rewritten to check if at least 1 action slot isn't reserved
return false unless inputable_unison_item?
return true unless SceneManager.scene_is?(Scene_Battle) && actor?
@unison_inputs < @actions.size
#
end # inputable?
#----------------------------------------------------------------------------|
# Alias method: usable? |
#----------------------------------------------------------------------------|
alias usable_unison_item? usable?
def usable?(item)
# Rewritten to check if all unison actors can use the unison skill/item
unless actor? && item && item.is_a?(RPG::UsableItem) && item.unison_item
return usable_unison_item?(item)
end
return false unless item.unison_actor_id.include?(id)
return false unless usable_unison_item?(item)
return unison_skill_usable?(item) if item.is_a?(RPG::Skill)
return unison_item_usable?(item) if item.is_a?(RPG::Item)
false
#
end # usable?
#----------------------------------------------------------------------------|
# New method: unison_skill_usable? |
#----------------------------------------------------------------------------|
def unison_skill_usable?(item)
battle = SceneManager.scene_is?(Scene_Battle)
(item.unison_actor_id - [id]).each { |actor_id|
actor = $game_actors[actor_id]
return false unless actor.battle_member? && actor.inputable?
return false if battle && actor.actions.select { |a| a.item }.size >=
actor.actions.size - actor.unison_inputs
return false unless actor.skill_conditions_met?(item)
return false unless actor.skills.any? { |s| s == $data_skills[item.id] }
}
true
end # unison_skill_usable?
#----------------------------------------------------------------------------|
# New method: unison_item_usable? |
#----------------------------------------------------------------------------|
def unison_item_usable?(item)
return false unless item_conditions_met?(item)
(item.unison_actor_id - [id]).each { |actor_id|
actor = $game_actors[actor_id]
return false unless actor.battle_member? && actor.inputable?
}
true
end # unison_item_usable?
#----------------------------------------------------------------------------|
# New method: unison_param_set |
#----------------------------------------------------------------------------|
def unison_param_set(item)
@unison_param = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 1, 2, 3, 4, 5, 6, 7, "hp", "mp", "tp", "level"].each_with_index { |param_id, i|
if item.send("unison_param_#{param_id.to_s}".to_sym)
unison_param_actor = item.send("unison_param_#{param_id.to_s}_id".to_sym)
else
unison_param_actor = item.unison_actor_id
end
unison_param_rule(item, param_id, i, unison_param_actor)
}
@unison_level = @unison_param[11]
@unison_param_set = true
end # unison_param_set
#----------------------------------------------------------------------------|
# New method: unison_param_rule |
#----------------------------------------------------------------------------|
def unison_param_rule(item, param_id, i, unison_param_actor)
case item.unison_rule
when 1
if param_id.is_a?(Numeric)
@unison_param[i] = param_max(param_id)
elsif param_id == "hp"
@unison_param[8] = param_max(0)
elsif param_id == "mp"
@unison_param[9] = param_max(1)
elsif param_id == "tp"
@unison_param[10] = max_tp
else
@unison_param[11] = max_level
end
unison_param_min_max(param_id, i, unison_param_actor, :min)
when 2
unison_param_actor.each { |actor_id|
if param_id.is_a?(Numeric)
@unison_param[i] += $game_actors[actor_id].param(i)
else
@unison_param[i] += $game_actors[actor_id].send(param_id.to_s.to_sym)
end
}
@unison_param[i] /= unison_param_actor.size
when 3
unison_param_min_max(param_id, i, unison_param_actor, :max)
else
return unison_param_clear
end
end # unison_param_rule
#----------------------------------------------------------------------------|
# New method: unison_param_min_max |
#----------------------------------------------------------------------------|
def unison_param_min_max(param_id, i, unison_param_actor, sym)
unison_param_actor.each { |actor_id|
if param_id.is_a?(Numeric)
@unison_param[i] = [@unison_param[i], $game_actors[actor_id].param(i)].send(sym)
else
@unison_param[i] = [@unison_param[i],
$game_actors[actor_id].send(param_id.to_s.to_sym)].send(sym)
end
}
end # unison_param_min_max
#----------------------------------------------------------------------------|
# New method: unison_param_clear |
#----------------------------------------------------------------------------|
def unison_param_clear
@unison_level = nil
@unison_param_set = false
end # unison_param_clear
#----------------------------------------------------------------------------|
# (v1.01a+)New method: hp |
#----------------------------------------------------------------------------|
def hp
@unison_param_set ? @unison_param[8] : @hp
end # hp
#----------------------------------------------------------------------------|
# (v1.01a+)New method: mp |
#----------------------------------------------------------------------------|
def mp
@unison_param_set ? @unison_param[9] : @mp
end # mp
#----------------------------------------------------------------------------|
# (v1.01a+)New method: tp |
#----------------------------------------------------------------------------|
def tp
@unison_param_set ? @unison_param[10] : @tp
end # tp
end # Game_BattlerBase
#------------------------------------------------------------------------------|
# * Edit class: Game_Battler |
#------------------------------------------------------------------------------|
class Game_Battler < Game_BattlerBase
#----------------------------------------------------------------------------|
# Alias method: make_damage_value |
#----------------------------------------------------------------------------|
alias make_damage_value_unison_item make_damage_value
def make_damage_value(user, item)
# Added to set the params of the user as the unison version
unison = user.actor? && item.unison_item && item.unison_rule > 0
user.unison_param_set(item) if unison
#
make_damage_value_unison_item(user, item)
# Added to reset the params of the user to the default
user.unison_param_clear if unison
#
end # make_damage_value
#----------------------------------------------------------------------------|
# Alias method: use_item |
#----------------------------------------------------------------------------|
alias use_item_unison_item use_item
def use_item(item)
# Rewritten to pay unison skill cost
unless item.is_a?(RPG::Skill) && item.unison_item
return use_item_unison_item(item)
end
item.unison_actor_id.each { |a_id| $game_actors[a_id].pay_skill_cost(item) }
item.effects.each { |effect| item_global_effect_apply(effect) }
#
end # use_item
end # Game_Battler
#------------------------------------------------------------------------------|
# * Edit class: Game_Actor |
#------------------------------------------------------------------------------|
class Game_Actor < Game_Battler
#----------------------------------------------------------------------------|
# New public instance variables |
#----------------------------------------------------------------------------|
attr_accessor :unison_inputs
attr_writer :unison_level
#----------------------------------------------------------------------------|
# (v1.01d+)Alias method: setup |
#----------------------------------------------------------------------------|
alias setup_unison_item setup
def setup(actor_id)
setup_unison_item(actor_id)
# Added to initialize the number of reserved action slots
@unison_inputs = 0
#
end # setup
#----------------------------------------------------------------------------|
# (v1.00d+)Alias method: clear_actions |
#----------------------------------------------------------------------------|
alias clear_actions_unison_item clear_actions
def clear_actions
clear_actions_unison_item
# Added to reset the number of reserved action slots
@unison_inputs = 0
#
end # clear_actions
#----------------------------------------------------------------------------|
# (v1.01d+)Alias method: next_command |
#----------------------------------------------------------------------------|
alias next_command_unison_item next_command
def next_command
# Added to return false if the next slot is reserved for unison skill/items
return false if @action_input_index >= @actions.size - 1 - @unison_inputs
#
next_command_unison_item
end # next_command
#----------------------------------------------------------------------------|
# (v1.01a+)New method: level |
#----------------------------------------------------------------------------|
def level
@unison_level || @level
end # level
end # Game_Actor
#------------------------------------------------------------------------------|
# * Edit class: Window_ItemList |
#------------------------------------------------------------------------------|
class Window_ItemList < Window_Selectable
#----------------------------------------------------------------------------|
# (v1.00c+)Alias method: enable? |
#----------------------------------------------------------------------------|
alias enable_unison_item? enable?
def enable?(item)
# Rewritten to set disable unison items when unison conditions aren't met
return enable_unison_item?(item) unless item.is_a?(RPG::Item) &&
item.unison_item && SceneManager.scene_is?(Scene_Battle)
BattleManager.actor.usable?(item)
#
end # enable?
end # Window_ItemList
#------------------------------------------------------------------------------|
# * Edit class: Window_BattleLog |
#------------------------------------------------------------------------------|
class Window_BattleLog < Window_Selectable
#----------------------------------------------------------------------------|
# Alias method: display_use_item |
#----------------------------------------------------------------------------|
alias display_use_item_unison_item display_use_item
def display_use_item(subject, item)
# Rewritten to display unison actors while using unison skills or items
unless DoubleX_RMVXA::Unison_Item::SHOW_UNISON_ACTOR && item.unison_item
return display_use_item_unison_item(subject, item)
end
display_unison_item(item)
#
end # display_use_item
#----------------------------------------------------------------------------|
# New method: display_unison_item |
#----------------------------------------------------------------------------|
def display_unison_item(item)
unless item.is_a?(RPG::Skill)
return add_text(sprintf(Vocab::UseItem, unison_actor_names(item), item.name))
end
add_text(unison_actor_names(item) + item.message1)
return if item.message2.empty?
wait
add_text(item.message2)
end # display_unison_item
#----------------------------------------------------------------------------|
# New method: unison_actor_names |
#----------------------------------------------------------------------------|
def unison_actor_names(item)
names = ""
size = item.unison_actor_id.size
item.unison_actor_id.each_with_index { |actor_id, index|
if index > 0 && index < size - 1
names += ", "
elsif size > 1 && index == size - 1
names += " and "
end
names += $game_actors[actor_id].name
}
names
end # unison_actor_names
end # Window_BattleLog
#------------------------------------------------------------------------------|
# * Edit class: Scene_Battle |
#------------------------------------------------------------------------------|
class Scene_Battle < Scene_Base
#----------------------------------------------------------------------------|
# (v1.01d+)Alias method: start |
#----------------------------------------------------------------------------|
alias start_unison_item start
def start
start_unison_item
# Added to initialize the unison action linkage hash
@unison_actor_ids = {}
#
end # start
#----------------------------------------------------------------------------|
# Alias method: next_command |
#----------------------------------------------------------------------------|
alias next_command_unison_item next_command
def next_command
# Added to set the link of the unison action slot to the unison invokees
add_unison_actor_ids if (actor = BattleManager.actor) && actor.input &&
actor.input.item && actor.input.item.unison_item
#
next_command_unison_item
end # next_command
#----------------------------------------------------------------------------|
# Alias method: prior_command |
#----------------------------------------------------------------------------|
alias prior_command_unison_item prior_command
def prior_command
# Added to clear the currently selected action before selecting the prior
BattleManager.actor.input.clear if BattleManager.actor.input
#
prior_command_unison_item
# Added to clear the unison action linkage and unconfirm the action
clear_unison_actor_ids if BattleManager.actor
#
end # prior_command
#----------------------------------------------------------------------------|
# Alias method: turn_start |
#----------------------------------------------------------------------------|
alias turn_start_unison_item turn_start
def turn_start
# Added to reset the links of the unison action slots to the unison invokees
@unison_actor_ids = {}
$game_party.alive_members.each { |mem| mem.unison_inputs = -1 }
#
turn_start_unison_item
end # turn_start
#----------------------------------------------------------------------------|
# New method: add_unison_actor_ids |
#----------------------------------------------------------------------------|
def add_unison_actor_ids
ids = (actor = BattleManager.actor).input.item.unison_actor_id - [actor.id]
@unison_actor_ids[[actor.index, actor.action_input_index]] = ids
ids.each { |id| $game_actors[id].unison_inputs += 1 }
end # add_unison_actor_ids
#----------------------------------------------------------------------------|
# New method: clear_unison_actor_ids |
#----------------------------------------------------------------------------|
def clear_unison_actor_ids
a = BattleManager.actor
return unless ids = @unison_actor_ids[[a.index, a.action_input_index]]
@unison_actor_ids.delete([a.index, a.action_input_index])
ids.each { |id| $game_actors[id].unison_inputs -= 1 }
end # clear_unison_actor_ids
end # Scene_Battle
#==============================================================================|Instructions
Open the script editor and put this script into an open slot between Materials and Main. Save to take effect.
FAQ
None
Compatibility
Scripts rewriting or aliasing method:
- load_database under DataManager
- param, inputable? or usable? under Game_BattlerBase
- make_damage_value or use_item under Game_Battler
- clear_actions or next_command under Game_Actor
- enable? under Window_ItemList
- display_use_item under Window_BattleLog
- start, next_command, prior_command or turn_start under Scene_Battle
may have compatibility issues with this script
Place this script above those aliasing any of these methods if possible
Credits and Thanks
None
Author's Notes
None
Terms and Conditions
None other than not claiming this script as created by anyone except DoubleX or his alias
RE: DoubleX RMVXA Unison Skills/Items - DoubleX - 07-23-2015
Updates
v1.01d(GMT 0300 21-7-2015):
- Increased this script's effectiveness, efficiency and flexibility