def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') surrender_plan = Sequence(name='Surrender Condition') decorator_inverter = Inverter() if_lost_check = Check(if_lost_the_game) decorator_inverter.child_node = if_lost_check surrender_action = Action(surrender) surrender_plan.child_nodes = [decorator_inverter, surrender_action] offensive_plan = Sequence(name='Offensive Strategy') can_dominate_check = Check(can_dominate_enemy_planet) decorator_always_false = AlwaysFalse() attack_action = Action(attack_most_valuable_enemy_planet) decorator_always_false.child_node = attack_action offensive_plan.child_nodes = [can_dominate_check, decorator_always_false] defensive_plan = Sequence(name='Defensive Strategy') is_attacked_check = Check(enemy_has_fleet_attacking) decorator_always_false = AlwaysFalse() defense_action = Action(send_defensive_fleet) decorator_always_false.child_node = defense_action defensive_plan.child_nodes = [is_attacked_check, decorator_always_false] spread_plan = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_to_most_valuable_neutral_planet) spread_plan.child_nodes = [neutral_planet_check, spread_action] root.child_nodes = [surrender_plan,offensive_plan, defensive_plan, spread_plan] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') offensive_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_largest_fleet) attack_action = Action(attack) offensive_plan.child_nodes = [largest_fleet_check, attack_action] spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread) spread_sequence.child_nodes = [neutral_planet_check, spread_action] defense_plan = Sequence(name='Defense Strategy') defense_check = Check(have_weak_planets) defense_action = Action(defend) defense_plan.child_nodes = [defense_check, defense_action] desperado_plan = Sequence(name='Desperado Strategy') under_attack_check = Check(planet_under_attack) attack_desperado_action = Action(desperado_attack) desperado_plan.child_nodes = [under_attack_check, attack_desperado_action] root.child_nodes = [ offensive_plan, defense_plan, spread_sequence, attack_action.copy() ] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') defensive_plan = Sequence(name='Defensive Strategy') planet_number_check = Check(have_more_planets) defend_action = Action(defend) defensive_plan.child_nodes = [planet_number_check, defend_action] offensive_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_largest_fleet) attack = Action(attack_weakest_enemy_planet) offensive_plan.child_nodes = [largest_fleet_check, attack] spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread) spread_sequence.child_nodes = [neutral_planet_check, spread_action] increase_planet_growth = Sequence(name='Must construct additional pylons') growth_check = Check(need_growth) grow = Action(grow_planet) growth_plan.child_nodes = [growth_check, grow] root.child_nodes = [ defensive_plan, offensive_plan, spread_sequence, attack.copy() ] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') offensive_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_largest_fleet) attack_choice = Selector(name='Attack Method') attack_growth = Action(attack_highest_growth) attack_closest = Action(attack_nearest_enemy_planet) attack_weakest = Action(attack_weakest_enemy_planet) attack_choice.child_nodes = [attack_growth, attack_closest, attack_weakest] offensive_plan.child_nodes = [largest_fleet_check, attack_choice] spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_to_nearest_neutral_planet) spread_sequence.child_nodes = [neutral_planet_check, spread_action] defense_sequence = Sequence(name='Defense Strategy') multiple_planet_check = Check(if_have_multiple_planets) redistribute_action = Action(strongest_to_weakest) defense_sequence.child_nodes = [multiple_planet_check, redistribute_action] root.child_nodes = [ offensive_plan, spread_sequence, defense_sequence, attack_closest.copy() ] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') offensive_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(starting_position_close) attack = Action(attack_start) offensive_plan.child_nodes = [largest_fleet_check, attack] """ this shouldn't have to be ever used. at all. spread_sequence = Sequence(name='Defense Strategy') spread_action = Action(defend) defend_check = Check(have_five_planets) spread_sequence.child_nodes = [defend_check, spread_action] """ spread_close = Sequence(name='Spreading Strategy') spread_close_action = Action(spread_to_weakest_and_closest_planet) spread_close.child_nodes = [spread_close_action] attack = Sequence(name='Attack Strategy') attack_action = Action(attack_them) attack_check = Check(have_five_planets) attack.child_nodes = [attack_check, attack_action] root.child_nodes = [offensive_plan, spread_close, attack] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') defensive_plan = Sequence(name='Defensive Strategy') attacked_check = Check(is_being_attacked) defend = Action(defend_planet) defensive_plan.child_nodes = [attacked_check, defend] spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_time) spread_sequence.child_nodes = [neutral_planet_check, spread_action] neut_sequence = Sequence(name='Neutral Strategy') neut_attacked_check = Check(neut_attacked) neut_action = Action(neut_overtake) neut_sequence.child_nodes = [neut_attacked_check, neut_action] offensive_plan = Sequence(name="Offensive Strategy") attack = Action(attack_fun) offensive_plan.child_nodes = [attack] super_offensive_plan = Sequence(name="Super Offensive Strategy") super_offensive_check = Check(killing_blow) super_attack = Action(killing_blow_action) super_offensive_plan.child_nodes = [super_offensive_check, super_attack] root.child_nodes = [ super_offensive_plan, offensive_plan, neut_sequence, defensive_plan, spread_sequence ] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') defensive_plan = Sequence(name='Defensive Strategy') attacked_check = Check(is_being_attacked) defend = Action(defend_planet_attack) defensive_plan.child_nodes = [attacked_check, defend] spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_to_closest_neutral_planet) spread_sequence.child_nodes = [neutral_planet_check, spread_action] offensive_plan = Sequence(name="Offensive Strategy") largest_fleet_check = Check(have_largest_fleet) attack = Action(attack_weakest_enemy_planet) offensive_plan.child_nodes = [largest_fleet_check, attack] root.child_nodes = [ offensive_plan, defensive_plan, spread_sequence, attack.copy() ] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') # Define available actions to take. colonize = Action(take_defenseless_territory) invade = Action(attack_with_no_mercy) reinforce = Action(reinforce_with_vengeance) retaliate = Action(retaliate_with_fury) # *** Begin preliminary suprise invasion over the galaxy. *** imperial_ambition = Sequence(name='Expansion Strategy: Manifest Destiny') imperial_ambition.child_nodes = [colonize, invade] # *** Consolidate and retaliate if under attack by hostiles. *** imperial_shield = Sequence(name='Security Strategy: Cereberus') danger_check = Check(if_under_attack) imperial_shield.child_nodes = [danger_check, reinforce, retaliate] # *** If the advantage is ours, attack with full force. *** imperial_aggression = Sequence(name='Aggressive Strategy: Crush All Remaining Resistance') largest_fleet_check = Check(have_largest_fleet) imperial_aggression.child_nodes = [largest_fleet_check, invade] # Begin selecting strategies. root.child_nodes = [imperial_ambition, imperial_aggression, imperial_shield, invade.copy()] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') oppression = Sequence(name="Oppression") alpha_check = Check(apex) plan_alpha = Action(order_alpha) oppression.child_nodes = [alpha_check, plan_alpha] offensive_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_largest_fleet) attack = Action(attack_plan) offensive_plan.child_nodes = [largest_fleet_check, attack] deny_sequence = Sequence(name='Deny Strategy') neutral_planet_check = Check(if_neutral_planet_available) deny_plan = Action(deny_enemy_fleet) s_plan = Action(spread_plan) deny_sequence.child_nodes = [neutral_planet_check, deny_plan] root.child_nodes = [offensive_plan, deny_sequence, oppression, attack.copy()] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): #Punish the Opponent Strategy: #if our effective attack power (distance, fleet power in distance, planet growth) #is greater than #our opponents effective defense power (distance, fleet power in distance, planet growth) #then capture the planet #if it isn't greater start to move resources towards the frontier # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') acquire_freebies = Sequence(name='Free Planets Strategy') free_planet_check = Check(if_free_planet) attack = Action(free_planet_plan) acquire_freebies.child_nodes = [free_planet_check, attack] defensive_plan = Sequence(name='Defensive Strategy') enemy_fleet_check = Check(if_enemy_fleet) defend = Action(intercept_plan) defensive_plan.child_nodes = [enemy_fleet_check, defend] spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_until_advantaged) spread_sequence.child_nodes = [neutral_planet_check, spread_action] root.child_nodes = [acquire_freebies, defensive_plan, spread_sequence] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') offensive_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_largest_fleet) attack = Action(attack_weakest_enemy_planet) offensive_plan.child_nodes = [largest_fleet_check, attack] spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_to_weakest_neutral_planet) spread_sequence.child_nodes = [neutral_planet_check, spread_action] # Otherwise, attack everywhere attack_all = Action(attack_everyone) # spread to all neutral planets # spread_all = Action(spread_all_neutral) # root.child_nodes = [offensive_plan, spread_sequence, attack.copy()] root.child_nodes = [offensive_plan, spread_sequence, attack_all] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') logging.info('building tree') snipe_plan = Sequence(name='Snipe Strategy') snipe_available_check = Check(snipe_available) snipe_attack = Action(snipe_boi) snipe_plan.child_nodes = [snipe_available_check, snipe_attack] offensive_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_largest_fleet) attack = Action(attack_weakest_enemy_planet) offensive_plan.child_nodes = [largest_fleet_check, attack] spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_to_best_neutral) spread_sequence.child_nodes = [neutral_planet_check, spread_action] defense_plan = Sequence(name='Defensive Strategy') defend_boi_check = Check(defend_boi_available) defend_action = Action(defend_boi) defense_plan.child_nodes = [defend_boi_check, defend_action] ''' snipe_plan, ''' root.child_nodes = [ defense_plan, snipe_plan, offensive_plan, spread_sequence, attack.copy() ] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') ''' offensive_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_largest_fleet) attack = Action(attack_weakest_enemy_planet) offensive_plan.child_nodes = [largest_fleet_check, attack] spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_to_weakest_neutral_planet) spread_sequence.child_nodes = [neutral_planet_check, spread_action] root.child_nodes = [offensive_plan, spread_sequence, attack.copy()] ''' test_plan = Sequence(name='Attack Best Planet') attack = Action(take_best_planet) test_plan.child_nodes = [attack] root.child_nodes = [test_plan] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') """offensive_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_largest_fleet) attack = Action(attack_weakest_enemy_planet) offensive_plan.child_nodes = [largest_fleet_check, attack] spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread) spread_sequence.child_nodes = [neutral_planet_check, spread_action] defensive_plan = Sequence(name= 'Defensive Plan') have_largest_fleet = Check(have_largest_fleet) match_fleets = Action(defend_planets2) defensive_plan.child_nodes = [enemy_attacking_check, match_fleets]""" have_largest = Check(have_largest_fleet) defend = Action(defend_planets2) spread_sequence = Action(spread) equal_action = Action(equalize) defensive_plan = Sequence(name='Defensive Plan') defensive_plan.child_nodes = [equal_action, defend, spread_sequence] offensive_plan = Sequence(name='Offensive Strategy') offensive_plan.child_nodes = [have_largest, spread_sequence, defend] root.child_nodes = [offensive_plan, defensive_plan] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') steal_plan = Sequence(name='Steal Strategy') enemy_just_conquered_check = Check(enemy_just_conquered) steal = Action(attack_recent_lost_neutral_planet) steal_plan.child_nodes = [enemy_just_conquered_check, steal] offensive_plan = Sequence(name='Offensive Strategy') #largest_fleet_check = Check(have_largest_fleet) stable_check = Check(is_stable_enough_to_attack) attack_close = Action(attack_closet_enemy_outpost) attack_weak = Action(attack_weakest_enemy_planet) offensive_plan.child_nodes = [stable_check, attack_close, attack_weak] spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_to_weakest_neutral_planet) spread_sequence.child_nodes = [neutral_planet_check, spread_action] repair_sequence = Sequence(name='Repair Strategy') weak_planet_check = Check(is_my_weakest_planet_at_risk) repair_action = Action(spread_my_fleet) repair_sequence.child_nodes = [weak_planet_check, repair_action] root.child_nodes = [steal_plan, offensive_plan, spread_sequence, repair_sequence, attack_close.copy()] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') spread_out_plan = Sequence(name='Spread Out Strategy') spread_out_attack = Action(wide_spread) spread_out_plan.child_nodes = [spread_out_attack] defense = Action(defend) close_enemy_planet_attack = Action(attack_close_enemy_planet) close_neutral_planet_attack = Action(attack_close_neutral_planet) offensive_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_largest_fleet) attack = Action(attack_weakest_enemy_planet) offensive_plan.child_nodes = [largest_fleet_check, attack] spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_to_weakest_neutral_planet) spread_sequence.child_nodes = [neutral_planet_check, spread_action] root.child_nodes = [ defense, spread_out_plan, close_enemy_planet_attack, close_neutral_planet_attack, offensive_plan, spread_sequence, attack.copy() ] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') # Checks largest_fleet_check = Check(have_largest_fleet) enemy_planet_check = Check(if_enemy_planet_available) neutral_planet_check = Check(if_neutral_planet_available) # Spread to weakest neutral spread_orig = Sequence(name='Spread Original') # spread_orig = Selector(name='Spread Original') spread_orig_action = Action(spread_to_weakest_neutral_planet) spread_orig.child_nodes = [spread_orig_action] # Spread vanilla spread_vanilla_plan = Sequence(name='Spread Vanilla') # spread_vanilla_plan = Selector(name='Spread Vanilla') spread_vanilla_action = Action(spread_vanilla) spread_vanilla_plan.child_nodes = [spread_vanilla_action] # Spread to high growth rate spread_hgr_plan = Sequence(name='Spread High Growth Rate') # spread_hgr_plan = Selector(name='Spread High Growth Rate') spread_hgr_action = Action(spread_to_highest_growth_rate) spread_hgr_plan.child_nodes = [spread_hgr_action] # Spread default spread_def_plan = Sequence(name='Spread Default') # spread_def_plan = Selector(name='Spread Default') spread_def_action = Action(spread_default) spread_def_plan.child_nodes = [spread_def_action] # Attack Vanilla attack_plan = Sequence(name='Attack Vanilla') # attack_plan = Selector(name='Attack Vanilla') attack_action = Action(attack_vanilla) attack_plan.child_nodes = [attack_action] # Attack high growth rate attack_hgr_plan = Sequence(name='Attack High Growth Rate') # attack_hgr_plan = Selector(name='Attack High Growth Rate') attack_hgr_action = Action(attack_high_growth) attack_hgr_plan.child_nodes = [attack_hgr_action] # Attack-full attack_full = Sequence(name='Attack Full Sequence') attack_full.child_nodes = [largest_fleet_check, enemy_planet_check, attack_plan, attack_hgr_plan] # Spread-full spread_full = Sequence(name='Spread Full Sequence') spread_full.child_nodes = [neutral_planet_check, spread_def_plan, spread_hgr_plan, spread_vanilla_plan, spread_orig] root.child_nodes = [attack_full, spread_full, attack_action.copy(), attack_hgr_action.copy(), spread_vanilla_action.copy(), spread_orig_action.copy(), spread_def_action.copy(), spread_hgr_action.copy()] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') offensive_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_largest_fleet) attack = Action(attack_weakest_enemy_planet) offensive_plan.child_nodes = [largest_fleet_check, attack] spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_to_weakest_neutral_planet) spread_sequence.child_nodes = [neutral_planet_check, spread_action] reinforcements = Sequence(name='Send Reinforcements') invaded_check = Check(invaded_maybe) send_backup = Action(send_aid_to_invaded_planet) reinforcements.child_nodes = [invaded_check, send_backup] multi_plan = Sequence(name='Multi Attack') have_planets = Check(min_planets) multi_action = Action(multi_attack) multi_plan.child_nodes = [largest_fleet_check, have_planets, multi_action] mul_spread = Sequence(name='Multi Spread') have_planets = Check(min_planets) is_neutral = Check(if_neutral_planet_available) multi_spread_action = Action(multi_spread) mul_spread.child_nodes = [have_planets, is_neutral, multi_spread_action] strong_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_largest_fleet) strongest_attack = Action(strong_attack) strong_plan.child_nodes = [largest_fleet_check, strongest_attack] finish_plan = Sequence(name='Finish Plan') largest_fleet_check = Check(have_largest_fleet) have_planets = Check(min_planets) finish_action = Action(barrage) finish_plan.child_nodes = [largest_fleet_check, have_planets, finish_action] pinpoint_plan = Sequence(name='Pinpoint') largest_fleet_check = Check(have_largest_fleet) have_planets = Check(min_planets) pinpoint_action = Action(pinpoint) pinpoint_plan.child_nodes = [largest_fleet_check, have_planets, pinpoint_action] root.child_nodes = [offensive_plan, spread_sequence, reinforcements, mul_spread, multi_plan, finish_plan, attack.copy()] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') """ offensive_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_largest_fleet) attack = Action(attack_weakest_enemy_planet) offensive_plan.child_nodes = [largest_fleet_check, attack] spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_to_weakest_neutral_planet) spread_sequence.child_nodes = [neutral_planet_check, spread_action] counter_action = Action(counter_fleet) regrow_sequence = Sequence(name='Regrow Strategy') lone_ally_check = Check(lone_ally) take_high_growth_action = Action(take_high_growth) regrow_sequence.child_nodes = [lone_ally_check, take_high_growth_action] checkmate_sequence = Sequence(name='Checkmate Strategy') lone_enemy_check = Check(lone_enemy) rush_first_target_action = Action(rush_first_target) checkmate_sequence.child_nodes = [lone_enemy_check, rush_first_target_action] """ early_game_strategy = Sequence(name='Early Game Strategy') lone_ally_check = Check(lone_ally) grow_from_one_action = Action(grow_from_one) early_game_strategy.child_nodes = [lone_ally_check, grow_from_one_action] production_action = Action(production) aggressive_strategy = Selector(name='Aggressive Strategy') attack_sequence = Sequence(name='Attack Sequence') largest_fleet_check = Check(have_largest_fleet) attack_action = Action(attack) attack_sequence.child_nodes = [largest_fleet_check, attack_action] spread_action = Action(spread) aggressive_strategy.child_nodes = [attack_sequence, spread_action] defend_action = Action(defend) root.child_nodes = [ early_game_strategy, aggressive_strategy, defend_action ] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') defensive_plan = Sequence(name="Defensive Plan") defend_being_attacked = Check(enemy_attacking) defend_planets = Action(defend_planet) defend_losing = Check(losing_enemy) defend_abandon = Action(abandon_planet) defensive_plan.child_nodes = [defend_being_attacked,defend_planets,defend_losing,defend_abandon] '''offensive_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_largest_fleet) attack = Action(attack_weakest_enemy_planet) offensive_plan.child_nodes = [largest_fleet_check, attack]''' greedy_a_behavior = Sequence(name='Greedy Attack') greedy_a_check = Check(outnumebering_enemy) greedy_a_attack = Action(attack_enemy) greedy_a_behavior.child_nodes = [greedy_a_check,greedy_a_attack] inter_a_behavior = Sequence(name="Intermediate Attack") inter_a_check = Check(winning_few_enemy) inter_a_attack = Action(attack_enemy) inter_a_behavior.child_nodes = [inter_a_check,inter_a_attack] caut_a_behavior = Sequence(name="Cautious Attack") caut_a_check = Check(losing_enemy) caut_a_attack = Action(attack_enemy) caut_a_behavior.child_nodes = [caut_a_check, caut_a_attack] offensive_plan = Selector(name='Offensive Strategy') offensive_plan.child_nodes = [greedy_a_behavior,inter_a_behavior,caut_a_behavior] spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_to_planets) spread_sequence.child_nodes = [neutral_planet_check, spread_action] '''spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_to_weakest_neutral_planet) spread_sequence.child_nodes = [neutral_planet_check, spread_action]''' root.child_nodes = [defensive_plan,offensive_plan,spread_sequence] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): logging.info('Setting Up Behavior Tree') # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') logging.info('Root Defined') play_offensively = Sequence(name='Offensive Tactics') winning_check = Check(have_most_planets) play_defensively = Sequence(name='Defensive Tactics') losing_check = Check(have_least_planets) logging.info('Offensive - Defensive Check Defined') early_occupy = Sequence(name='Early Occupation of Neutrals') owned_planets_check = Check(low_planets_check) occupy = Action(occupy_nearest_neutral_planet) early_occupy.child_nodes = [owned_planets_check, occupy] logging.info('Occupation Strategy Defined') offensive_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_largest_fleet) attack = Action(attack_weakest_enemy_planet) offensive_plan.child_nodes = [largest_fleet_check, attack] logging.info('Offensive Strategy Defined') spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_to_weakest_neutral_planet) spread_sequence.child_nodes = [neutral_planet_check, spread_action] logging.info('Spread Sequence Defined') defensive_plan = Sequence(name='Defensive Strategy') smallest_fleet_check = Check(have_smallest_fleet) reinforce = Action(reinforce_weakest_planet) defensive_plan.child_nodes = [smallest_fleet_check, reinforce] logging.info('Defensive Strategy Defined') play_offensively.child_nodes = [ winning_check, early_occupy, offensive_plan, spread_sequence ] play_defensively.child_nodes = [ losing_check, early_occupy, defensive_plan, spread_sequence ] root.child_nodes = [play_offensively, play_defensively, occupy.copy()] logging.info('Children Assigned') logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') # This sequence is only executed at the beginning of the game, # it spreads to the 4 weakest/nearest planets to establish a foothold initialize_sequence = Sequence(name='Initialize Sequence') start = Check(is_start) fleet_check = Check(fleets) spread_action = Action(spread_to_closest_weak_planets) initialize_sequence.child_nodes = [start, fleet_check, spread_action] # This is the plan of attack that is used throughout the bots strategy # The bot checks to see if it has an arbitrarily set strong enough store of ships on its planet # and attacks enemy or neutral planets with those numbers. attack_plan = Sequence(name='Attacking Plan') strong_fleet = Check(strong_fleet_check) attack = Action(strong_attack) attack_plan.child_nodes = [strong_fleet, attack] # This strategy is executed when the bot is losing, it will begin to attack the enemy more agressively, # taking the enemies weakest planets to regain ground less_planet_strategy = Sequence(name='Losing Plan') less_planets = Check(planet_control_check) take_weakest_planet = Action(take_weakest_planets) attack_spread = Action(spread) less_planet_strategy.child_nodes = [ less_planets, take_weakest_planet, attack_spread ] # This strategy executes when the bot is winning. # It will shift into a defensive mode, reinforcing currently owned planets while still seeking to spread more_planet_strategy = Sequence(name='Winning Plan') more_planets = Check(planet_control_check_winning) defend_planets = Action(defend) defense_spread = Action(spread) more_planet_strategy.child_nodes = [ more_planets, take_weakest_planet, defend_planets, defense_spread ] root.child_nodes = [ initialize_sequence, less_planet_strategy, more_planet_strategy, attack_plan ] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): """ # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') offensive_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_largest_fleet) attack = Action(attack_weakest_enemy_planet) offensive_plan.child_nodes = [largest_fleet_check, attack] spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_to_weakest_neutral_planet) spread_sequence.child_nodes = [neutral_planet_check, spread_action] root.child_nodes = [offensive_plan, spread_sequence, attack.copy()] """ root = Selector(name="Strategy Sequence") spread_sequence = Sequence(name="Spread Strategy") neutral_available_check = Check(if_neutral_planet_available) succeed_spread = AlwaysSucceed(name="Spread Succeeder") spread = Action(spread_to_best_neutral) succeed_spread.child_node = spread succeed_defend = AlwaysSucceed(name="Defend Succeeder") defend = Action(defend_planets) succeed_defend.child_node = defend spread_sequence.child_nodes = [ neutral_available_check, succeed_spread, succeed_defend ] attack_sequence = Sequence(name="Attack Strategy") alive_check = Check(opponent_alive) succeed_attack = AlwaysSucceed(name="Succeed Attack") attack = Action(attack_opponent_planets) succeed_attack.child_node = attack attack_sequence.child_nodes = [ alive_check, succeed_attack, succeed_defend.copy() ] root.child_nodes = [spread_sequence, attack_sequence] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) neutral_planet_check2 = Check(if_desirable_planet) spread_action = Action(spread_to_desirable_planet) spread_sequence.child_nodes = [ neutral_planet_check, neutral_planet_check2, spread_action ] defend_planet = Sequence(name='Defense Strategy') enemy_attack_check = Check(enemy_attack) defend_action = Action(defend_friendly_planet) defend_planet.child_nodes = [enemy_attack_check, defend_action] optimal_offense = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_largest_fleet) desirable_planet_check = Check(if_desirable_attack) best_attack = Action(attack_desirable_planet) optimal_offense.child_nodes = [ largest_fleet_check, desirable_planet_check, best_attack ] offense = Sequence(name='Offensive Strategy 2') largest_fleet_check2 = Check(have_largest_fleet) attack = Action(attack_weakest_enemy_planet) offense.child_nodes = [largest_fleet_check2, attack] reinforce = Sequence(name='Reinforce') reinforce_check = Check(low_count) reinforce_action = Action(reinforce_friendly_planet) reinforce.child_nodes = [reinforce_check, reinforce_action] spread2 = Sequence(name='Spread 2') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_to_weakest_neutral_planet) spread2.child_nodes = [neutral_planet_check, spread_action] root.child_nodes = [spread_sequence, offense, optimal_offense] #spread_sequence,defend_planet, reinforce, optimal_offense, spread2, offense logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): """ # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') offensive_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_largest_fleet) attack = Action(attack_weakest_enemy_planet) offensive_plan.child_nodes = [largest_fleet_check, attack] spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_to_weakest_neutral_planet) spread_sequence.child_nodes = [neutral_planet_check, spread_action] root.child_nodes = [offensive_plan, spread_sequence, attack.copy()] logging.info('\n' + root.tree_to_string()) return root """ # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') Gambit = Sequence(name="Gambit") besieged = Check(is_attacking) counter = Action(attack_or_defend) Gambit.child_nodes = [besieged, counter] spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_to_weakest_neutral_planet) spread_sequence.child_nodes = [neutral_planet_check, spread_action] offensive_plan = Sequence(name='War') largest_fleet_check = Check(have_largest_fleet) attack = Action(attack_weakest_enemy_planet) offensive_plan.child_nodes = [largest_fleet_check, attack] root.child_nodes = [Gambit, spread_sequence, offensive_plan] logging.info('\n' + root.tree_to_string()) return root
def parse_tree(tree_string): root = Selector(name="Root") #Current node has the current selector or sequence that we are processing current_node = root for char in tree_string: if char == "-": #Selector new_node = Selector(name="Selector") new_node.parent_node = current_node new_node.child_nodes = [] current_node.child_nodes.append(new_node) elif char == "_": #Sequence new_node = Sequence(name="Sequence") new_node.parent_node = current_node new_node.child_nodes = [] current_node.child_nodes.append(new_node) elif char == "[": #Start children current_node = current_node.child_nodes[-1] elif char == "]": #End children current_node = current_node.parent_node elif char.isupper(): #Check new_node = Check(node_dict[char]) new_node.parent_node = current_node current_node.child_nodes.append(new_node) elif char.islower(): #Action new_node = Action(node_dict[char]) new_node.parent_node = current_node current_node.child_nodes.append(new_node) logging.info('\n Decoded tree as: ' + root.tree_to_string()) return root
def new_tree(): root = Selector() #plan for the first few turns of the game, expand to easy neutral planets then switch to aggressive expansion startingMoves = Sequence() gameStart = Check(homeBase) fleetEngage = Check(readyShips) createEmpire = Action(expandToNeutrals) startingMoves.child_nodes = [gameStart, fleetEngage, createEmpire] #once we have a stable base, we can start spreading out and attacking enemy planets expandEmpire = Sequence() muster = Check(checkForces) crusade = Action(assult) expandEmpire.child_nodes = [muster, crusade] root.child_nodes = [startingMoves, expandEmpire] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') grab_what_enemy_wants = Sequence(name='Getting what enemy wants') neutral_planet_check = Check(if_neutral_planet_available) is_grabbing = Check(if_a_good_neutral_available) take_good_neutral = Action(if_a_good_neutral_available_now) grab_what_enemy_wants.child_nodes = [ neutral_planet_check, is_grabbing, take_good_neutral ] offensive_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_largest_fleet) #largest_growth_rate_check = Check(have_largest_growth_rate) attack = Action(attack_weakest_enemy_planet) offensive_plan.child_nodes = [attack] """ send_three_to_neutral = Sequence(name='send 3 neutral') above_30 = Check(above_30_not_sending) send_one = Action(send_to_closest_neutral_if_backup) send_backup = Action(send_affensive_help) send_three_to_neutral.child_nodes = [above_30, send_one, send_backup, send_backup] """ spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_selector = Selector(name='Spread Selector') enough = Check(if_dont_have_enough_neutral) not_close_enough = Check(if_enemy_too_far) spread_selector.child_nodes = [enough, not_close_enough] worth = Check(worth_attacking_neutral) spread_action = Action(spread_to_best_neutral) spread_sequence.child_nodes = [ neutral_planet_check, spread_selector, worth, spread_action ] root.child_nodes = [grab_what_enemy_wants, spread_sequence, offensive_plan] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') exploit_plan = Sequence(name='Exploit Weakest Strategy') production_check = Check(if_better_production) weak_planet_check = Check(if_weak_enemy_planet) exploit = Action(attack_good_enemy_planet) exploit_plan.child_nodes = [production_check, weak_planet_check, exploit] explore_plan = Sequence(name='Explore Strategy') explore_check = Check(if_unexplored) explore = Action(spread_unexplored_planet) explore_plan.child_nodes = [explore_check, explore] default_attack = Action(attack_weakest_enemy_planet) root.child_nodes = [exploit_plan, explore_plan, default_attack] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') other_attack = Action(attack_same_planet_as_enemy) b_spread = Action(best_spread) offensive_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_largest_fleet) attack = Action(attack_weakest_enemy_planet) offensive_plan.child_nodes = [largest_fleet_check, attack] spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_to_weakest_closest_neutral_planet) spread_sequence.child_nodes = [neutral_planet_check, spread_action] root.child_nodes = [b_spread, other_attack, offensive_plan] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') #attack_beneficial beneficial_plan = Sequence(name='beneficial Strategy') #check_neutrals = Check(benefit_check) benefit = Action(attack_beneficial) beneficial_plan.child_nodes = [benefit] #[check_neutrals, benefit] speedy_spread_spree_plan = Sequence(name='speedy quick Strategy') check_neutrals = Check(quicky_check) quick = Action(attack_quickest) speedy_spread_spree_plan.child_nodes = [check_neutrals, quick] fat_spread_plan = Sequence(name='Fat Spread Strategy') largest_fleet_check = Check(have_largest_fleet) #checky_check = Check(checky_check) spread = Action(spread_to_fattest_neutral_planet) #_weakest_enemy_planet fat_spread_plan.child_nodes = [largest_fleet_check, spread] offensive_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_largest_fleet) attack = Action(aggressive_attack) #_weakest_enemy_planet offensive_plan.child_nodes = [largest_fleet_check, attack] #spread_sequence = Sequence(name='Spread Strategy') #neutral_planet_check = Check(if_neutral_planet_available) #spread_action = Action(spread_to_weakest_neutral_planet) #spread_sequence.child_nodes = [neutral_planet_check, spread_action] root.child_nodes = [ speedy_spread_spree_plan, offensive_plan, beneficial_plan, attack.copy() ] #root.child_nodes = [offensive_plan, spread_sequence, attack.copy()] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') grab_what_enemy_wants = Sequence(name='Getting what enemy wants') neutral_planet_check = Check(if_neutral_planet_available) is_grabbing = Check(if_a_good_neutral_available) take_good_neutral = Action(if_a_good_neutral_available_now) grab_what_enemy_wants.child_nodes = [neutral_planet_check, is_grabbing, take_good_neutral] offensive_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_largest_fleet) #largest_growth_rate_check = Check(have_largest_growth_rate) attack = Action(attack_weakest_enemy_planet) offensive_plan.child_nodes = [attack] """ send_three_to_neutral = Sequence(name='send 3 neutral') above_30 = Check(above_30_not_sending) send_one = Action(send_to_closest_neutral_if_backup) send_backup = Action(send_affensive_help) send_three_to_neutral.child_nodes = [above_30, send_one, send_backup, send_backup] """ spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_selector = Selector(name='Spread Selector') enough = Check(if_dont_have_enough_neutral) not_close_enough = Check(if_enemy_too_far) spread_selector.child_nodes = [enough, not_close_enough] worth = Check(worth_attacking_neutral) spread_action = Action(spread_to_best_neutral) spread_sequence.child_nodes = [neutral_planet_check, spread_selector, worth, spread_action] root.child_nodes = [grab_what_enemy_wants, spread_sequence, offensive_plan] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') #attack plan invert_att = Inverter() succeed_att = Succeeder() offensive_plan = Sequence(name='Offensive Strategy') enough_planets_check = Check(has_enough_planets) attack = Action(attack_weakest_enemy_planet) invert_att.child_node = succeed_att succeed_att.child_node = offensive_plan offensive_plan.child_nodes = [enough_planets_check, attack] #defense plan invert_def = Inverter() succeed_def = Succeeder() defense = Action(defend_weakest_ally) succeed_def.child_node = defense invert_def.child_node = succeed_def #reinforce plan #invert_reinforce = Inverter() #succeed_reinforce = Succeeder() #reinforce = Action(reinforce_new_planet) #succeed_reinforce.child_node = reinforce #invert_reinforce.child_node = succeed_reinforce #spread plan spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_to_weakest_neutral_planet) spread_sequence.child_nodes = [neutral_planet_check, spread_action] root.child_nodes = [invert_att, invert_def, spread_sequence, attack.copy()] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') # sequence = Sequence(name) # check(s) = Check(name_of_check) - takes boolean # action = Action(name_of_behavior) - do something # sequence.child_nodes = [check(s), action(s)] #spread_sequence = Sequence(name='Spread Strategy') #neutral_planet_check = Check(if_neutral_planet_available) #spread_action = Action(spread_to_weakest_neutral_planet) #spread_sequence.child_nodes = [neutral_planet_check, spread_action] spread_production_sequence = Sequence(name='Spread Production Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_production_sequence_action = Action(spread_production) spread_production_sequence.child_nodes = [neutral_planet_check, spread_production_sequence_action] defend_sequence = Sequence(name='Defend Strategy') enemy_attacks_check = Check(enemy_attacks) defend_action = Action(defend2) defend_sequence.child_nodes = [enemy_attacks_check, defend_action] offensive_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_largest_fleet) attack = Action(attack_weakest_enemy_planet) offensive_plan.child_nodes = [largest_fleet_check, attack] # root.child_nodes = [spread_production_sequence, offensive_plan, attack.copy()] #root.child_nodes = [spread_sequence, spread_production_sequence, offensive_plan, attack.copy()] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') spread_sequence = Sequence(name='Spread Strategy') neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_to_weakest_neutral_planet) spread_sequence.child_nodes = [neutral_planet_check, spread_action] spread_enemy = Sequence(name='Spread Attack') enemy_check = Check(spread_check) spread_go = Action(start_spread) spread_enemy.child_nodes = [enemy_check, spread_go] defense = Sequence(name='defense') defensive_check = Check(defense_check) defense_go = Action(defense_action) defense.child_nodes = [defensive_check, defense_go] root.child_nodes = [spread_sequence, spread_enemy, defense] logging.info('\n' + root.tree_to_string()) return root
def setup_behavior_tree(): # Top-down construction of behavior tree root = Selector(name='High Level Ordering of Strategies') # defense_planet = Sequence(name='Save My Planet') # check_attack = Check(if_planet_got_attack) # protect = Action(protect_planet) # defense_planet.child_nodes = [check_attack, protect] # silent = Sequence(name="do nothing") # check_ships = Check(check_ship_left) # wait = Action(do_no_op) # silent.child_nodes = [check_ships, wait] defensive_plan = Sequence(name='Deffensive Strategy') check_owned_ship = Check(have_more_conquest) protect_action = Action(defendPlanet) defensive_plan.child_nodes = [check_owned_ship, protect_action] # defense = Selector(name='defense') # defense.child_nodes = [denfensive_plan] populate_plan = Sequence(name='no-op') conserve_check = Check(save_fleet) nothing = Action(do_no_op) populate_plan.child_nodes = [conserve_check, nothing] growth_plan = Sequence(name='Eco Strategy') eco_check = Check(need_econ) grow = Action(spread_ally) growth_plan.child_nodes = [eco_check, grow] offensive_plan = Sequence(name='Offensive Strategy') largest_fleet_check = Check(have_less_conquest) attack = Action(attack_weakest_enemy_planet) offensive_plan.child_nodes = [largest_fleet_check, attack] spread_sequence = Sequence(name='Spread Strategy') conquest_check = Check(have_less_conquest) neutral_planet_check = Check(if_neutral_planet_available) spread_action = Action(spread_to_weakest_neutral_planet) spread_sequence.child_nodes = [ conquest_check, neutral_planet_check, spread_action ] steal_plan = Sequence(name='Thief') steal_check = Check(steal_fleet) big_check = Check(have_largest_fleet) steal = Action(steal_planet) steal_plan.child_nodes = [big_check, steal_check, steal] ''' defensive_plan = Sequence(name='Defend Strategy') enemy_planet_attack_check = Check(if_enemy_planet_attack) largest_fleet_check = Check(have_largest_fleet) visiting_check = Check(is_busy_reinforce) # Returns true if already did this. ''' #steal and growth plan could cause a lost #root.child_nodes = [spread_sequence, offensive_plan, defensive_plan, steal_plan] root.child_nodes = [ defensive_plan, offensive_plan, spread_sequence, steal_plan ] logging.info('\n' + root.tree_to_string()) return root