ACBS - Atoa Custom Battle System 3.2

[Charlie Fleed]

Cool. I want a shoryuken now. :)

[Ace]

wow really nice^^

[serano65]

never mind got it to work love the system by the way

[Blazblue Fan]

I'm having trouble setting the fusion skills I typed it in like the one that was already there but the skills don't fuse together. Can you also help me with the fusion skills? Sorry about asking questions that probably have simple answers.

Also, is there a way to fuse overdrive attacks?

[Ace]

Hi I'm new here so i just wanted to ask if there is a thread on how to use Overdrive Add-on?

thank you!

Reading the instructions on the script would also help a lot. the only thing not explained there was posted recently on this thread...

I forget to add some instructions on the Overdrive script.

The overdrive must be "unlocked", with an script call add the code:
$game_actors[Actor ID].overdrive_unlock = true

Not 100% sure if the code is this one, i will check it later

Here it is^^

[Victor Sant]

@Blazblue Fan
Well man, if you don't show how you did, how do excpect me to show you what you did wrong?
Post your settings so i can point you the right way.

About the overdrive + fusion, it's possible, but probably all actors on the fusion would need to have the overdrive full, but probably only the active battler will have his bar reseted. i didn't test it so i can't say for sure.

Also, remember that the overdrive must be "unlocked"

[Blazblue Fan]

Sorry about that here are my settings

Content Hidden

#==============================================================================
# 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

[Victor Sant]

@Blazblue Fan
You didn't need to post the whole script... just post the settings you've made...
For me it's look the default script, with no chage.

[Blazblue Fan]

Okay here's the part that I edited

Content Hidden

# 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]}
}

I added another combination skill but they don't fuse together in battle

[Victor Sant]

Fusion Type skill occurs when the two basic components of it are used on the same turn.

Did you use the skill 7 and 57 or two 7 in the same turn and nothing happened?