Save-Point

#==============================================================================
# Skill Combinação
# By Atoa
#==============================================================================
# This script allows you to create 'Combination' skills
#
# These skill needs the participation of more than one actor.
#
# The skill power is based on the average of the participants stats.
# So, set valuers higher than the normal for combination skill.
#
# Add this scripts bellow the script 'ACBS | Battle Main Code'
# He must stay bellow *ALL* other battle related scripts
#
#¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
# ***IMPORTANT WARNING*** #
#¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
#
# These settings are *VERY* complex and need an good RGSS knowledge
# If you're an noob on RPG Maker, DON'T MESS WITH THIS PART!
# I won't give any support for novice to use the Skill Combination
# So learn basic RGSS before trying to change here.
# Don't complain that it's don't work if you don't know what you doing.
#
#==============================================================================

module Atoa
# Do not remove or change this line
Combination_Skill ={}
# Do not remove or change this line

Skill_Settings[117] = ["MOVEPOSTION/0,-40,80,80,200"]
Skill_Settings[118] = ["MOVEPOSTION/0,40,80,-80,200"]
Skill_Settings[119] = ["MOVETYPE/NOMOVE","ANIME/Magic_Pose"]

Skill_Settings[121] = ["MOVETYPE/STEPFOWARD"]

Skill_Settings[123] = ["MOVETYPE/NOMOVE","ANIME/Magic_Pose"]

#¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
# COMBINATION SETTINGS
#¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
# The combinations are divided in 4 types 'Union', 'Fusion', 'Combination'
# and 'Sequence'.
# Each type has it own features.
# They can enter in conflit if the combinations uses the same skills.
# So, avoid using the same skills in various combinations types.
#

# UNION:
# Union are skills where you combine battlers to use an skill.
# You can only use them if all the battlers needed for the combination
# are in condition to act.
# Like the 'Unite' of Suikoden series
#
# IMPORTANTE:
# - if used with the Atoa ATB, the union skill will be avaliable only
# when all needed actors have their bar full.
# - if used with the Atoa CTB, the union skill will be avaliable only
# when all needed actors are near to act
#
# Combination_Skill['Union'] = {
# Skill_ID => {Battler_Type, {Battler_ID =>[Effect_ID]},
# }
#
# Skill_ID = ID of the skill used and the result skill of the combiantion
# Battler_Type = type of the battlers that participate of the combination
# 'Actor' = the users are actors
# 'Enemy' = the users are enemies
# Effect_ID = ID of the skills that are used during the combination.
# each actor execute one action depending on the array index
#
Combination_Skill['Union'] = {
100 => {1 =>[117, nil], 2 =>[118, nil], 4 =>[nil, 119]},
101 => {5 =>[121], 6 =>[117]}
}

# FUSION:
# Fusion are skill wich you combine two or more skills to make a new one.
# If the skills that is part of the combination are used separately,
# nothing happens, the skills are used normally.
# Bur if all skills are used in the same turn, an new skill is used instead.
# E.g.: You have an Fusion of Cross Cut and Fire.
# If you use them alone, they're used normally, but if you use them in the
# same turn, the skill 'Cross Fire' will be used instead.
#
# IMPORTANT:
# Doesn't work with the Atoa ATB or Atoa CTB
#
# Combination_Skill['Fusion'] = {
# Result_Skill_ID => {Fusion_Skill_ID =>[Effect_ID]},
# }
#
#
# Result_Skill_ID = ID of the skill resulted of the Fusion
# Fusion_Skill_ID = IDs of the skills that makes the fusion
# You can set different moves based on the 'Fusion_Skill_ID'
# The battler thar is using that skill will do the corresponding move
# Effect_ID = ID of the skills that are used during the combination.
# each actor execute one action depending on the array index
#
Combination_Skill['Fusion'] = {
102 => {7 =>[123], 57 =>[122]},
8 => {7 =>[125], 7 => [126]}
}

# COOPERATION:
# Cooperation are skills thats needs more than one character to execute them.
# Different from the 'Union', they're not based on the battler ID.
# You need an number of battlers to use the skill, then, when this number is
# reached, the skill is executed
#
# Combination_Skill['Cooperation'] = {
# Skill_ID => {Battler_Index =>[Effect_ID]},
# }
#
# Skill_ID = ID of the skill result of the Cooperation
# Battler_Index = Index fo the Battler, it's the number of 'indexes' that
# define, how many battlers will be needed to execute the skill.
# Must be always on order from 0 to the number of participating battler - 1
# The move is based on the index and the battler ID, the battler with
# the lower ID will execute the move with the lower index
# Effect_ID = ID das skills que são executadas na combinação.
# cada personagem executa sua respectiva ação de acordo com o index da array.
#
Combination_Skill['Cooperation'] = {
103 => {0 =>[117], 1 =>[118], 2 =>[119]}
}

# SEQUENCE:
# Squence are skills differents from the others, in the ones before, all the
# battlers participates on the skill execution, but not on this.
# In the sequence types combo, the skills are used normally, but when an
# sequence is done, the last skill used becomes an new skill.
# You can create sequences based on Skill ID or Elements ID
# Similar to the combo system of Breath of Fire 4
#
# E.g 1.: when use the skills 'Fire', 'Fire' and 'Fira' in this order, the skill
# 'Fira' won't be used, instead, the skill 'Blazing Hell' will be used
# E.g 2.: when use an fire element skill and an wind element skill in this order
# the wind element skill will became the skill 'Explosion'.
#
# Note: In the case of elemental combination, if an skill have more than one element
# only the first will be considered
#
# There's also some extra settings for this combination type.
#
# Combination_Skill['Sequence'] = { Result_Skill_ID => [Action_Type, [Sequence_ID]]},
# Result_Skill_ID = ID of the skill result of the Sequence
# Action_Type = sequence type
# 'Skill' = the combination is based on skill ID
# 'Element' = the combination is based on skill Element
# Sequence_ID = IDs of the skill/elements useds in the sequence.
# The order you add the IDs here is what define the order that the
# skills must be used
#
Combination_Skill['Sequence'] = {
104 => ['Skill', [7,7,8]],
105 => ['Element', [1,6]],
}

# Set if the sequence will be canceled if the action isn't an valid action
Sequence_Break = true
# true = the sequence is canceled if an enemy acts or an ally don't use an skill
# false = the sequence isn't canceled if an enemy acts or an ally don't use an skill

# IDs of the skills thats negates sequence of elemental skills
# Must be used in the case you don't want an skill to enter an elemental sequence
# E.g.: The sword skill 'Hurricane' is wind elemental, but you don't want it
# to make part of the 'Explosion' (fire » wind) sequence
No_Sequence_Skills = [59]

end

#==============================================================================
# ? Atoa Module
#==============================================================================
$atoa_script = {} if $atoa_script.nil?
$atoa_script['Atoa Combination'] = true

#==============================================================================
# ? Game_Temp
#==============================================================================
class Game_Temp
#--------------------------------------------------------------------------
attr_accessor(:combination_skill_used, :combination_battlers, :cp_actors, :cp_enemies)
#--------------------------------------------------------------------------
alias atoa_initialize_combination initialize
def initialize
atoa_initialize_combination
@combination_battlers, @union = [], []
@combination_skill_used = {'Actor' => [], 'Enemy' => []}
@cp_actors, @cp_enemies = {}, {}
end
end
#==============================================================================
# ? Game_Battler
#==============================================================================
class Game_Battler
#--------------------------------------------------------------------------
attr_accessor(:in_combination, :old_fusion, :new_fusion, :cp_skill, :cooperation_index)
end

#==============================================================================
# ? Game_Actor
#==============================================================================
class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
alias atoa_inputable_combination inputable?
def inputable?
inputable = atoa_inputable_combination
unless $atoa_script['Atoa ATB'] or $atoa_script['Atoa CTB']
for id in $game_temp.combination_skill_used['Actor']
if Combination_Skill['Union'] != nil and Combination_Skill['Union'].include?(id)
inputable = false if Combination_Skill['Union'][id].include?(@actor_id)
end
end
end
return inputable
end
#--------------------------------------------------------------------------
alias atoa_skill_can_use_combination_gameactor skill_can_use?
def skill_can_use?(skill_id)
if Combination_Skill['Union'] != nil and Combination_Skill['Union'].include?(skill_id)
for actor_id in Combination_Skill['Union'][skill_id]
actor = $game_actors[actor_id[0]]
return false if not $game_party.actors.include?(actor) or
($game_party.actors.include?(actor) and (actor.restriction > 1 or actor.dead?)) or
($atoa_script['Atoa ATB'] and not actor.atb_full?) or
($atoa_script['Atoa CTB'] and not actor.ctb_next?)
end
elsif Combination_Skill['Fusion'] != nil and Combination_Skill['Fusion'].include?(skill_id)
for battler in $game_temp.combination_battlers
return false if battler.restriction > 1 or battler.dead?
end
elsif Combination_Skill['Cooperation'] != nil && Combination_Skill['Cooperation'].include?(skill_id)
for battler in $game_temp.combination_battlers
return false if battler.restriction > 1 or battler.dead?
end
end
atoa_skill_can_use_combination_gameactor(skill_id)
end
end

#==============================================================================
# ? Game_Enemy
#==============================================================================
class Game_Enemy < Game_Battler
#--------------------------------------------------------------------------
def skill_can_use?(skill_id)
if Combination_Skill['Union'] != nil and Combination_Skill['Union'].include?(skill_id)
for enemy_id in Combination_Skill['Union'][skill_id]
for enemy in $game_troop.enemies
next unless enemy.id == enemy_id
return false if enemy.restriction > 1 or enemy.dead? or $atoa_script['Atoa ATB']
end
end
elsif Combination_Skill['Fusion'] != nil and Combination_Skill['Fusion'].include?(skill_id)
for battler in $game_temp.combination_battlers
return false if battler.restriction > 1 or battler.dead?
end
elsif Combination_Skill['Cooperation'] != nil and Combination_Skill['Cooperation'].include?(skill_id)
for battler in $game_temp.combination_battlers
return false if battler.restriction > 1 or battler.dead?
end
end
super
end
end

#==============================================================================
# ? Scene_Battle
#==============================================================================
class Scene_Battle
#--------------------------------------------------------------------------
alias atoa_main_combination main
def main
@combination_master_id = []
@actors_skill_sequence = []
@enemies_skill_sequence = []
@actors_element_sequence = []
@enemies_element_sequence = []
@combination_target = {}
reset_combination
reset_cooperaion
atoa_main_combination
end
#--------------------------------------------------------------------------
def phase3_prior_actor
begin
@active_battler.blink = false if @active_battler != nil
return start_phase2 if @actor_index == 0
@actor_index -= 1
@active_battler = $game_party.actors[@actor_index]
@active_battler.blink = true
if @combination_master_id[@active_battler.current_action.skill_id] == @active_battler.id
$game_temp.combination_skill_used['Actor'].delete(@active_battler.current_action.skill_id)
@combination_master_id[@active_battler.current_action.skill_id] = nil
end
end until @active_battler.inputable?
phase3_setup_command_window
end
#--------------------------------------------------------------------------
alias atoa_turn_ending_combination turn_ending
def turn_ending
reset_cooperaion
atoa_turn_ending_combination
end
#--------------------------------------------------------------------------
alias atoa_update_phase4_step3_combination update_phase4_step3
def update_phase4_step3
add_skill_to_sequence
if @active_battler.in_combination == 'Union'
union_update_phase4_step3
elsif @active_battler.in_combination == 'Fusion'
fusion_update_phase4_step3
elsif @active_battler.in_combination == 'Sequence'
sequence_update_phase4_step3
elsif @active_battler.in_combination == 'Cooperation'
cooperation_update_phase4_step3
else
atoa_update_phase4_step3_combination
end
end
#--------------------------------------------------------------------------
alias atoa_update_phase3_skill_select_combination update_phase3_skill_select
def update_phase3_skill_select
@skill = @skill_window.skill
delete_skill
if Input.trigger?(Input::C)
unless @skill.nil? or not @active_battler.skill_can_use?(@skill.id)
if Combination_Skill['Union'] != nil and Combination_Skill['Union'].include?(@skill.id)
unless $game_temp.combination_skill_used['Actor'].include?(@skill.id)
$game_temp.combination_skill_used['Actor'] << @skill.id
end
@combination_master_id[@skill.id] = @active_battler.id
end
end
end
atoa_update_phase3_skill_select_combination
end
#--------------------------------------------------------------------------
alias atoa_make_skill_action_result_combination make_skill_action_result
def make_skill_action_result
if @active_battler.current_action.kind == 1
if @active_battler.in_combination == 'Union' or
@active_battler.in_combination == 'Fusion' or
@active_battler.in_combination == 'Cooperation'
return make_skill_combination_action_result
elsif @active_battler.in_combination == 'Sequence'
return make_skill_sequence_action_result
end
end
atoa_make_skill_action_result_combination
end
#--------------------------------------------------------------------------
alias atoa_update_phase4_step2_combination update_phase4_step2
def update_phase4_step2
set_combination_action
atoa_update_phase4_step2_combination
end
#--------------------------------------------------------------------------
alias atoa_update_phase4_step4_combination update_phase4_step4
def update_phase4_step4
if @active_battler.in_combination == 'Union' or
@active_battler.in_combination == 'Fusion' or
@active_battler.in_combination == 'Cooperation'
combination_update_phase4_step4
else
atoa_update_phase4_step4_combination
end
end
#--------------------------------------------------------------------------
alias atoa_update_phase4_step5_combination update_phase4_step5
def update_phase4_step5
if @active_battler.in_combination == 'Union' or
@active_battler.in_combination == 'Fusion' or
@active_battler.in_combination == 'Cooperation'
combination_update_phase4_step5
else
atoa_update_phase4_step5_combination
end
end
#--------------------------------------------------------------------------
alias atoa_update_phase4_step6_combination update_phase4_step6
def update_phase4_step6
if @active_battler.in_combination == 'Union' or
@active_battler.in_combination == 'Fusion' or
@active_battler.in_combination == 'Cooperation'
combination_update_phase4_step6
else
atoa_update_phase4_step6_combination
end
reset_combination
end
#--------------------------------------------------------------------------
alias atoa_now_action_combination now_action
def now_action(battler)
if @union != []
if @union[battler.id][@current_move].nil?
battler.now_action = nil
else
battler.now_action = $data_skills[@union[battler.id][@current_move]]
end
return
elsif @fusion != [] and battler.old_fusion != 0
if @fusion[battler.old_fusion][@current_move].nil?
battler.now_action = nil
else
battler.now_action = $data_skills[@fusion[battler.old_fusion][@current_move]]
end
return
elsif @cooperation != {}
if @cooperation[battler.cooperation_index][@current_move].nil?
battler.now_action = nil
else
battler.now_action = $data_skills[@cooperation[battler.cooperation_index][@current_move]]
end
return
end
atoa_now_action_combination(battler)
end
#--------------------------------------------------------------------------
alias atoa_set_action_combination set_action
def set_action
if @active_battler.in_combination == 'Union' or
@active_battler.in_combination == 'Fusion' or
@active_battler.in_combination == 'Cooperation'
combination_set_action
else
atoa_set_action_combination
end
end
#--------------------------------------------------------------------------
def combination_set_action
for battler in $game_temp.combination_battlers
now_action(battler)
set_hit_number(battler)
end
set_old_info
combination_action_loop_part1
unimmortaling_all
end
#--------------------------------------------------------------------------
def combination_action_loop_part1
loop do
update_basic
combination_action_loop_part2
unimmortaling
@current_move += 1
@move_size -= 1
for battler in $game_temp.combination_battlers
now_action(battler)
set_action_movement(battler)
end
have_no_sequence = true
for battler in $game_temp.combination_battlers
next if battler.now_action.nil?
have_no_sequence = false if battler.current_action.action_sequence.size > 0
end
break if @move_size <= 0 and have_no_sequence
end
end
#--------------------------------------------------------------------------
def combination_action_loop_part2
loop do
for battler in $game_temp.combination_battlers
next if battler.now_action.nil?
battler.current_action.move_times -= 1
end
@hit_animation = true
combination_action_loop_part3
unimmortaling
if @target_battlers.empty?
for battler in $game_temp.combination_battlers
next if battler.now_action.nil?
battler.current_action.move_times = 0
end
break
end
for battler in $game_temp.combination_battlers
next if battler.now_action.nil?
battler.current_action.hit_times = action_hits(battler)
end
have_no_moves = true
for battler in $game_temp.combination_battlers
next if battler.now_action.nil?
have_no_moves = false if battler.current_action.move_times > 0
end
break if have_no_moves
end
end
#--------------------------------------------------------------------------
def combination_action_loop_part3
loop do
for battler in $game_temp.combination_battlers
now_action(battler)
end
for battler in $game_temp.combination_battlers
next if battler.now_action.nil?
battler.current_action.hit_times -= 1
end
if @hit_animation
for battler in $game_temp.combination_battlers
next if battler.now_action.nil?
update_move_postion(battler)
end
update_move_anim
for battler in $game_temp.combination_battlers
next if battler.now_action.nil?
set_move_end(battler)
end
end
if @target_battlers.empty?
for battler in $game_temp.combination_battlers
next if battler.now_action.nil?
battler.current_action.hit_times = 0
end
break
end
for battler in $game_temp.combination_battlers
next if battler.now_action.nil?
action_anime(battler) if @hit_animation
end
wait(@wait_time.to_i / 2) if @wait_time != nil
make_results
combination_update_phase4_step4
combination_update_phase4_step5
have_no_hits = true
for battler in $game_temp.combination_battlers
next if battler.now_action.nil?
have_no_hits = false if battler.current_action.hit_times > 0
end
break if have_no_hits
end
end
#--------------------------------------------------------------------------
def union_update_phase4_step3
return @phase4_step = 6 if cant_use_action(@active_battler)
@union = Combination_Skill['Union'][@combination_id].dup
$game_temp.combination_battlers.clear
@current_move = 0
for id in @union
battlers = @active_battler.actor? ? $game_party.actors : $game_troop.enemies
for battler in battlers
if id[0] == battler.id
$game_temp.combination_battlers << battler
now_action(battler)
size = @union[battler.id].size
@move_size = size if @move_size.nil? or size > @move_size
end
end
end
sort_combination_battlers
for battler in $game_temp.combination_battlers
now_action(battler)
next if battler.now_action.nil?
return @phase4_step = 6 if cant_use_union(battler)
set_action_movement(battler)
end
for battler in $game_temp.combination_battlers
action_start_anime_combination(battler, @combination_id)
end
wait(@wait_time)
@wait_time = 0
set_action
@phase4_step = 6 unless @phase4_step == 1
end
#--------------------------------------------------------------------------
def fusion_update_phase4_step3
return @phase4_step = 6 if cant_use_action(@active_battler)
now_action(@active_battler)
@fusion = Combination_Skill['Fusion'][@combination_id].dup
$game_temp.combination_battlers.clear
@current_move = 0
battlers = @active_battler.actor? ? $game_party.actors : $game_troop.enemies
for battler in battlers
if battler.new_fusion == @active_battler.new_fusion
$game_temp.combination_battlers << battler
now_action(battler)
size = @fusion[battler.old_fusion].size
@move_size = size if @move_size.nil? or size > @move_size
end
end
sort_combination_battlers
for battler in $game_temp.combination_battlers
next if battler.now_action.nil?
return @phase4_step = 6 if cant_use_fusion(battler)
set_action_movement(battler)
end
for battler in $game_temp.combination_battlers
action_start_anime_combination(battler, @combination_id)
end
wait(@wait_time)
@wait_time = 0
set_action
@phase4_step = 6 unless @phase4_step == 1
end
#--------------------------------------------------------------------------
def cooperation_update_phase4_step3
unless chek_cooperation_full
@active_battler.in_combination = ''
@phase4_step = 6
return
end
if @active_battler.actor?
$game_temp.combination_battlers = $game_temp.cp_actors[@active_battler.cp_skill].dup
$game_temp.cp_actors[@active_battler.cp_skill].clear
else
$game_temp.combination_battlers = $game_temp.cp_enemies[@active_battler.cp_skill].dup
$game_temp.cp_enemies[@active_battler.cp_skill].clear
end
@combination_id = @active_battler.cp_skill
@cooperation = Combination_Skill['Cooperation'][@combination_id].dup
$game_temp.combination_battlers.sort! {|a,b| a.id <=> b.id}
@current_move = 0
index = 0
for battler in $game_temp.combination_battlers
battler.cooperation_index = index
index += 1
now_action(battler)
next if battler.now_action.nil?
return break_cooperation(battler) if cant_use_cooperation(battler)
set_action_movement(battler)
end
for battler in $game_temp.combination_battlers
action_start_anime_combination(battler, @combination_id)
end
wait(@wait_time)
@wait_time = 0
set_action
@phase4_step = 6 unless @phase4_step == 1
end
#--------------------------------------------------------------------------
def break_cooperation(battler)
if battler.actor?
$game_temp.cp_actors[battler.cp_skill].delete(battler)
else
$game_temp.cp_enemies[battler.cp_skill].delete(battler)
end
battler.cp_skill = 0
@phase4_step = 6
end
#--------------------------------------------------------------------------
def action_start_anime_combination(battler, combination_id)
@animation1_id = 0
now_action(battler)
skill = $data_skills[combination_id]
battler_sprite = set_battler_sprite(battler)
if skill.magic?
pose = set_pose_id(battler, 'Magic_Cast')
else
pose = set_pose_id(battler, 'Physical_Cast')
end
ext = check_extension(skill, 'CAST')
unless ext.nil?
ext.slice!('CAST/')
pose = eval(ext)
end
if pose != nil
@active_battler.pose_id = pose
battler_sprite.pose(battler.pose_id)
end
@animation1_id = skill.animation1_id
@help_window.set_text(skill.name, 1)
battle_cry_advanced(battler, 'SKILLCAST', battler.now_action.id)
set_mirage(battler, 'CAST')
unless @animation1_id == 0
battler.animation_id = @animation1_id
battler.animation_hit = true
@wait_time = $data_animations[@animation1_id].frame_max * 2
end
if battler.now_action != nil && check_include(battler.now_action, 'HIDEBATTLER')
battler.invisible = true
end
battler.mirage = false
end
#--------------------------------------------------------------------------
def combination_update_phase4_step4
for battler in $game_temp.combination_battlers
now_action(battler)
next if battler.now_action.nil?
throw_object(battler, battler.now_action)
end
throw_loop
set_target_animation
for battler in $game_temp.combination_battlers
next if battler.now_action.nil?
boomerang_return(battler, battler.now_action)
end
throw_loop
wait_base = @animation2_id == 0 ? 1 : [$data_animations[@animation2_id].frame_max, 1].max
wait_time2 = 1
for battler in $game_temp.combination_battlers
next if battler.now_action.nil?
wait_time1 = check_wait_time(wait_base, battler, 'TIMEAFTERANIM')
wait_time2 = wait_time1 if wait_time1 > wait_time2
end
wait_time2 = [[wait_time2 * (battle_speed + 1) / 2.0, 2].max , 1].max
wait(wait_time2.to_i)
@hit_animation = false
@phase4_step = 5
end
#--------------------------------------------------------------------------
def combination_update_phase4_step5
update_basic
@status_window.refresh
update_basic
dmg_wait = false
for target in @target_battlers
if target.damage != nil
damage_mirror(target)
if @active_battler.now_action.is_a?(RPG::Skill) and((target.damage == Miss_Message and
check_include(@active_battler.now_action, 'STEAL')) or
check_include(@active_battler.now_action, 'NODAMAGE'))
target.damage = ''
end
target.damage_pop = true
dmg_wait = true unless target.dead?
end
end
wait_time = [(battle_speed / 2) + 1 , 2].max
wait(wait_time.to_i) if dmg_wait
for target in @target_battlers
reset_idle_anim(target)
end
update_basic
steal_action_result(@active_battler) unless @steal_action
for battler in $game_temp.combination_battlers
next if battler.now_action.nil?
battler.reset_speed = true
battler.mirage = false
end
@phase4_step = 6
reset_critical
end
#--------------------------------------------------------------------------
def combination_update_phase4_step6
reset_critical
wait_time = [(battle_speed / 4) * 5, 2].max
wait(wait_time.to_i) if @action_done
@active_battler.action_scope = 0
$game_temp.forcing_battler = nil
if @common_event_id > 0
common_event = $data_common_events[@common_event_id]
$game_system.battle_interpreter.setup(common_event.list, 0)
end
@phase4_step = 1
@help_window.visible = false
slip_damage_pop([@active_battler]) if Slip_Damage_Pop_Time == 1
for battler in $game_party.actors + $game_troop.enemies
battler.invisible = false
end
slip_damage_pop([@active_battler]) if Slip_Damage_Pop_Time == 1
for battler in $game_temp.combination_battlers
update_move_return_init(battler)
end
update_move_anim('Return')
for battler in $game_temp.combination_battlers
update_move_return_end(battler)
end
for battler in $game_troop.enemies + $game_party.actors
reset_position_by_id(battler.actor?, battler.id) if battler.exist?
reset_idle_anim(battler)
reset_battler_direction(battler)
end
if $atoa_script['Atoa ATB']
@action_phase = false
@atb_turn_count += 1 unless Custom_Turn_Count == 2
@active_battler.passed = false
for battler in $game_temp.combination_battlers
battler.atb = 0
end
@input_battlers.delete(@active_battler)
@action_battlers.delete(@active_battler)
@action_battler = nil
update_meters
judge
elsif $atoa_script['Atoa CTB']
@ctb_turn_count += 1
for battler in $game_temp.combination_battlers
battler.ctb_update(@action_cost)
end
@input_battlers.delete(@active_battler)
@action_battlers.delete(@active_battler)
@action_battler = nil
judge
end
end
#--------------------------------------------------------------------------
def delete_skill
unless @skill.nil?
if Combination_Skill['Union'] != nil and
Combination_Skill['Union'].include?(@skill.id)
if $game_temp.combination_skill_used['Actor'].include?(@skill.id)
$game_temp.combination_skill_used['Actor'].delete(@skill.id)
end
@combination_master_id[@skill.id] = nil
end
end
end
#--------------------------------------------------------------------------
def cant_use_union(battler)
if battler.now_action.is_a?(RPG::Skill) and not battler.skill_can_use?(@combination_id)
unless battler.current_action.forcing
$game_temp.forcing_battler = nil
@phase4_step = 1
return true
end
end
return false
end
#--------------------------------------------------------------------------
def cant_use_fusion(battler)
if battler.now_action.is_a?(RPG::Skill) and not battler.skill_can_use?(battler.old_fusion)
unless battler.current_action.forcing
$game_temp.forcing_battler = nil
@phase4_step = 1
return true
end
end
return false
end
#--------------------------------------------------------------------------
def cant_use_cooperation(battler)
unless battler.skill_can_use?(battler.cp_skill)
unless battler.current_action.forcing
$game_temp.forcing_battler = nil
@phase4_step = 1
return true
end
end
return false
end
#--------------------------------------------------------------------------
def set_combination_action
make_enemy_union
set_union_action
set_fusion_action
set_cooperation_action
end
#--------------------------------------------------------------------------
def make_enemy_union
for battler in $game_troop.enemies
action = battler.current_action
if action.kind == 1 && Combination_Skill['Union'] != nil and
Combination_Skill['Union'].include?(action.skill_id)
unless $game_temp.combination_skill_used['Enemy'].include?(action.skill_id)
$game_temp.combination_skill_used['Enemy'] << action.skill_id
end
end
end
end
#--------------------------------------------------------------------------
def set_union_action
actor = @active_battler.actor? ? 'Actor' : 'Enemy'
for skill_id in $game_temp.combination_skill_used[actor]
if Combination_Skill['Union'] != nil && Combination_Skill['Union'].include?(skill_id)
battlers = @active_battler.actor? ? $game_party.actors : $game_troop.enemies
for battler in battlers
next unless (@action_battlers.include?(battler) or battler == @active_battler)
if Combination_Skill['Union'][skill_id].include?(battler.id) and
@active_battler.current_action.skill_id == skill_id
if battler == @active_battler
battler.in_combination = 'Union'
battler.current_action.kind = 1
battler.current_action.skill_id = skill_id
battler.current_action.target_index = $game_actors[@combination_master_id[skill_id]].current_action.target_index
@combination_id = skill_id
elsif @action_battlers.include?(battler)
@action_battlers.delete(battler)
end
end
end
end
end
end
#--------------------------------------------------------------------------
def set_fusion_action
battlers = @active_battler.actor? ? $game_party.actors.dup : $game_troop.enemies.dup
if Combination_Skill['Fusion'] != nil
for skill in Combination_Skill['Fusion']
skill_fusion = []
skill_fusion2 = []
skills_fusion = []
battler_in_fusion = []
fusion_set = false
for battler in battlers
if battler.in_combination != 'Fusion' and battler.current_action.kind == 1 and
(@action_battlers.include?(battler) or battler == @active_battler) and
skill[1].include?(battler.current_action.skill_id) and not
skill_fusion.include?(battler.current_action.skill_id)
battler_in_fusion << battler
skill_fusion << battler.current_action.skill_id
end
end
for action in skill[1]
skill_fusion2 << action[0]
end
skill_fusion.sort!
skill_fusion2.sort!
for i in 0...skill_fusion.size
fusion = skill_fusion[i...skill_fusion.size]
skills_fusion << fusion if fusion.size > 1
end
for i in 0...skill_fusion.size
fusion = skill_fusion[0...(skill_fusion.size - i)]
skills_fusion << fusion if fusion.size > 1
end
for fusion in skills_fusion
break fusion_set = true if skill_fusion2 == fusion
end
if fusion_set and battler_in_fusion.include?(@active_battler)
for battler in battler_in_fusion
if battler == @active_battler
battler.old_fusion = battler.current_action.skill_id
battler.new_fusion = skill[0]
battler.in_combination = 'Fusion'
@combination_id = battler.new_fusion
elsif @action_battlers.include?(battler)
battler.old_fusion = battler.current_action.skill_id
battler.new_fusion = skill[0]
@action_battlers.delete(battler)
end
end
end
end
end
end
#--------------------------------------------------------------------------
def set_cooperation_action
@active_battler.cp_skill = 0
if Combination_Skill['Cooperation'] != nil
for skill in Combination_Skill['Cooperation']
if $game_temp.cp_actors[skill[0]] != nil and @active_battler.actor? and
$game_temp.cp_actors[skill[0]].include?(@active_battler)
$game_temp.cp_actors[skill[0]].delete(@active_battler)
elsif $game_temp.cp_enemies[skill[0]] != nil and not @active_battler.actor? and
$game_temp.cp_enemies[skill[0]].include?(@active_battler)
$game_temp.cp_enemies[skill[0]].delete(@active_battler)
end
if @active_battler.current_action.kind == 1 and
skill[0] == @active_battler.current_action.skill_id
@active_battler.cp_skill = skill[0]
@active_battler.in_combination = 'Cooperation'
$game_temp.cp_actors[skill[0]] << @active_battler if @active_battler.actor?
$game_temp.cp_enemies[skill[0]] << @active_battler unless @active_battler.actor?
end
end
end
end
#--------------------------------------------------------------------------
def chek_cooperation_full
if @active_battler.current_action.kind == 1 and
Combination_Skill['Cooperation'] != nil and
Combination_Skill['Cooperation'].include?(@active_battler.current_action.skill_id)
for skill in Combination_Skill['Cooperation']
battlers = @active_battler.actor? ? $game_temp.cp_actors[skill[0]] :
$game_temp.cp_enemies[skill[0]]
if skill[0] == @active_battler.cp_skill && skill[1].size == battlers.size
return true
end
end
end
return false
end
#--------------------------------------------------------------------------
def sequence_update_phase4_step3
return @phase4_step = 6 if cant_use_sequence
action_start_anime(@active_battler)
wait(@wait_time)
@wait_time = 0
set_action
@phase4_step = 6 unless @phase4_step == 1
end
#--------------------------------------------------------------------------
def cant_use_sequence
unless @active_battler.skill_can_use?(@old_skill_used_id)
unless @active_battler.current_action.forcing
$game_temp.forcing_battler = nil
return true
end
end
return false
end
#--------------------------------------------------------------------------
def make_skill_combination_action_result
for battler in $game_temp.combination_battlers
next if battler.now_action.nil?
@skill = @old_skill = battler.now_action
end
if @active_battler.in_combination == 'Union'
return if check_union
elsif @active_battler.in_combination == 'Fusion'
return if check_fusion
elsif @active_battler.in_combination == 'Cooperation'
return if check_combination
end
@multi_action_running = true
@status_window.refresh
@animation1_id = @skill.animation1_id
@animation2_id = @skill.animation2_id
@common_event_id = @skill.common_event_id
for target in @target_battlers
taget_damage = 0
for battler in $game_temp.combination_battlers
next if battler.now_action.nil?
target.skill_effect(battler, battler.now_action)
taget_damage += target.damage if target.damage.is_a?(Numeric)
end
target.damage = taget_damage
end
end
#--------------------------------------------------------------------------
def check_union
old_skill = $data_skills[@combination_id]
for battler in $game_temp.combination_battlers
return true if cant_use_union(battler) and not @multi_action_running
end
for battler in $game_temp.combination_battlers
battler.sp -= old_skill.sp_cost unless @multi_action_running
end
return false
end
#--------------------------------------------------------------------------
def check_fusion
for battler in $game_temp.combination_battlers
return true if cant_use_fusion(battler) and not @multi_action_running
end
for battler in $game_temp.combination_battlers
old_skill = $data_skills[battler.old_fusion]
battler.sp -= old_skill.sp_cost unless @multi_action_running
end
return false
end
#--------------------------------------------------------------------------
def check_combination
for battler in $game_temp.combination_battlers
return true if cant_use_cooperation(battler) and not @multi_action_running
end
for battler in $game_temp.combination_battlers
battler.sp -= @skill.sp_cost unless @multi_action_running
end
return false
end
#--------------------------------------------------------------------------
def make_skill_sequence_action_result
old_skill = $data_skills[@old_skill_used_id]
@skill = @active_battler.now_action
unless @active_battler.current_action.forcing or @multi_action_running
unless @active_battler.skill_can_use?(old_skill.id)
$game_temp.forcing_battler = nil
@phase4_step = 1
return
end
end
@active_battler.sp -= old_skill.sp_cost unless @multi_action_running
@multi_action_running = true
@status_window.refresh
@animation1_id = @skill.animation1_id
@animation2_id = @skill.animation2_id
@common_event_id = @skill.common_event_id
for target in @target_battlers
target.skill_effect(@active_battler, @skill)
end
end
#--------------------------------------------------------------------------
def reset_combination
if @active_battler != nil
type = @active_battler.actor? ? 'Actor' : 'Enemy'
$game_temp.combination_skill_used[type].delete(@combination_id)
end
@union, @fusion, @cooperation = [], [], {}
@old_skill_used_id = @combination_id = @move_size = @current_move = 0
for battler in $game_party.actors + $game_troop.enemies
battler.in_combination = ''
battler.old_fusion = 0
battler.new_fusion = []
end
end
#--------------------------------------------------------------------------
def reset_cooperaion
if Combination_Skill['Cooperation'] != nil
for skill in Combination_Skill['Cooperation']
$game_temp.cp_actors[skill[0]] = []
$game_temp.cp_enemies[skill[0]] = []
end
end
end
#--------------------------------------------------------------------------
def sort_combination_battlers
$game_temp.combination_battlers.delete(@active_battler)
$game_temp.combination_battlers.unshift(@active_battler)
$game_temp.combination_battlers.uniq!
end
#--------------------------------------------------------------------------
def add_skill_to_sequence
if @active_battler.actor?
if @active_battler.current_action.kind == 1
squence_skill = $data_skills[@active_battler.current_action.skill_id]
return if squence_skill.nil?
@enemies_skill_sequence.clear if Sequence_Break
@actors_skill_sequence << squence_skill.id
unless No_Sequence_Skills.include?(squence_skill.id)
@actors_element_sequence << squence_skill.element_set.first
else
@actors_element_sequence << nil
end
elsif @active_battler.current_action.kind != 1 and Sequence_Break
@actors_skill_sequence.clear
@actors_element_sequence.clear
end
else
if @active_battler.current_action.kind == 1
squence_skill = $data_skills[@active_battler.current_action.skill_id]
return if squence_skill.nil?
@actors_skill_sequence.clear if Sequence_Break
@enemies_skill_sequence << squence_skill.id
unless No_Sequence_Skills.include?(squence_skill.id)
@enemies_element_sequence << squence_skill.element_set.first
else
@enemies_element_sequence << nil
end
elsif @active_battler.current_action.kind != 1 and Sequence_Break
@enemies_skill_sequence.clear
@enemies_element_sequence.clear
end
end
skill_sequence_check = @active_battler.actor? ? @actors_skill_sequence.dup : @enemies_skill_sequence.dup
element_sequence_check = @active_battler.actor? ? @actors_element_sequence.dup : @enemies_element_sequence.dup
unless Combination_Skill['Sequence'].nil?
for sequence in Combination_Skill['Sequence']
combination_set = false
if sequence[1][0] == 'Skill'
for i in 0...skill_sequence_check.size
break combination_set = true if [sequence[1][1]] == skill_sequence_check.indexes(i...skill_sequence_check.size)
end
if combination_set
@old_skill_used_id = @active_battler.current_action.skill_id
@active_battler.current_action.skill_id = sequence[0]
@active_battler.in_combination = 'Sequence'
now_action(@active_battler)
if @active_battler.actor?
@actors_skill_sequence.pop
@actors_skill_sequence << @active_battler.current_action.skill_id
else
@enemies_skill_sequence.pop
@enemies_skill_sequence << @active_battler.current_action.skill_id
end
set_action_movement(@active_battler)
break
end
end
if sequence[1][0] == 'Element'
for i in 0...element_sequence_check.size
break combination_set = true if [sequence[1][1]] == element_sequence_check.indexes(i...element_sequence_check.size)
end
if combination_set
@old_skill_used_id = @active_battler.current_action.skill_id
@active_battler.current_action.skill_id = sequence[0]
@active_battler.in_combination = 'Sequence'
now_action(@active_battler)
squence_skill = $data_skills[@active_battler.current_action.skill_id]
if @active_battler.actor?
@actors_element_sequence.pop
@actors_element_sequence << squence_skill.element_set.first
else
@enemies_element_sequence.pop
@enemies_element_sequence << squence_skill.element_set.first
end
set_action_movement(@active_battler)
break
end
end
end
end
end
end

# Result_Skill_ID = ID of the skill resulted of the Fusion
# Fusion_Skill_ID = IDs of the skills that makes the fusion
# You can set different moves based on the 'Fusion_Skill_ID'
# The battler thar is using that skill will do the corresponding move
# Effect_ID = ID of the skills that are used during the combination.
# each actor execute one action depending on the array index
#
Combination_Skill['Fusion'] = {
102 => {7 =>[123], 57 =>[122]},
8 => {7 =>[125], 7 => [126]}
}