def pilgrim(robot):
communications.self_communicate_loop(robot)
if robot.me.signal == 0:
for friendly_unit in vision.sort_visible_friendlies_by_distance(robot):
if friendly_unit.unit == 0 and friendly_unit.signal > -1:
robot.signal(friendly_unit.signal, 0)
break
unit_signal = robot.me.signal
carry_karb = robot.me.karbonite
carry_fuel = robot.me.fuel
pos_x = robot.me.x
pos_y = robot.me.y
if carry_fuel > 80 or carry_karb > 18 :
# robot.log("Nearing capacity")
return pilgrim_full(robot)
# robot.log('Position is ' + str(pos_x) + ' ' + str(pos_y))
ab = pilgrim_mine(robot)
if ab !=0:
return ab
else:
bc = pilgrim_move(robot, unit_signal)
if bc !=0:
return bc
def pilgrim(robot):
communications.self_communicate_loop(robot)
carry_karb = robot.me.karbonite
carry_fuel = robot.me.fuel
# The pilgrim is on a mine and wants to deposit resources
if carry_fuel > 80 or carry_karb > 18:
# robot.log("Nearing capacity")
return pilgrim_full(robot)
# The pilgrim checks if it has a mine on it's current position
pilgrim_is_mining = pilgrim_mine(robot)
if pilgrim_is_mining != 0:
return pilgrim_is_mining
# Recieve signal from castle on which mine to go to and start self broadcasting
if robot.me.signal == 0:
for friendly_unit in vision.sort_visible_friendlies_by_distance(robot):
if friendly_unit.unit == 0 and friendly_unit.signal > -1:
robot.signal(friendly_unit.signal, 0)
break
# Move Section
unit_signal = robot.me.signal
# If signal is for mine postion, then start self broadcasting that position, edge case is (0,0) mine
if unit_signal < 6464 and unit_signal > 0:
robot.signal(add_mine_position_to_signal(robot, unit_signal), 0)
robot.log("Pilgrim " + str(unit_signal))
# robot.log('Position is ' + str(pos_x) + ' ' + str(pos_y))
pilgrim_is_moving = pilgrim_move(robot, unit_signal)
if pilgrim_is_moving != 0:
return pilgrim_is_moving
def castle(robot):
# if robot.step % 10 == 0:
# robot.log("Script Helper Turn@" + str(robot.step))
castle_count = 0
church_count = 0
crusader_count = 0
pilgrim_count = 0
preacher_count = 0
prophet_count = 0
friendly_units = castle_all_friendly_units(robot)
total_karbonite = vision.all_karbonite(robot)
total_fuel = vision.all_fuel(robot)
# robot.log(mapping.analyze_map(robot.get_passable_map()))
for f_unit in friendly_units:
if f_unit.castle_talk == constants.unit_castle:
castle_count += 1
elif f_unit.castle_talk == constants.unit_church:
church_count += 1
elif f_unit.castle_talk == constants.unit_crusader:
crusader_count += 1
elif f_unit.castle_talk == constants.unit_pilgrim:
pilgrim_count += 1
elif f_unit.castle_talk == constants.unit_preacher:
preacher_count += 1
elif f_unit.castle_talk == constants.unit_prophet:
prophet_count += 1
# robot.log(str([unit.id for unit in vision.sort_visible_friendlies_by_distance(robot)]))
# robot.log("=> " + str(robot.me.signal))
# If nothing else, replicate your own last message
communications.self_communicate_loop(robot)
""" Building units -
Start with 2 pilgrims per castle (as long as karbonite after building remains above 50).
If sufficient resources(>100 karb, >200 fuel), build, in order -
1 crusader per 3 pilgrims
1 preacher per 2 crusaders (per 6 pilgrims)
1 prophet per 3 crusaders (per 9 pilgrims)
1 prophet per 2 resources on map
"""
if robot.step < 2 and robot.karbonite > 60:
robot.signal(robot.me.signal + 1, 2)
return castle_build(robot, constants.unit_pilgrim)
elif robot.karbonite > 100 and robot.fuel > 200:
if (crusader_count * 3) < pilgrim_count:
# robot.signal(robot.me.signal + 1, 2)
return castle_build(robot, constants.unit_crusader)
# elif (preacher_count * 2) < crusader_count:
# # robot.signal(robot.me.signal + 1, 2)
# return castle_build(robot, constants.unit_preacher)
# elif prophet_count * 3 < crusader_count:
# # robot.signal(robot.me.signal + 1, 2)
# return castle_build(robot, constants.unit_prophet)
elif pilgrim_count < (total_fuel + total_karbonite) * .55:
robot.signal(robot.me.signal + 1, 2)
return castle_build(robot, constants.unit_pilgrim)
def castle(robot):
unit_castle = SPECS['CASTLE']
unit_church = SPECS['CHURCH']
unit_crusader = SPECS['CRUSADER']
unit_pilgrim = SPECS['PILGRIM']
unit_preacher = SPECS['PREACHER']
unit_prophet = SPECS['PROPHET']
castle_count = 0
church_count = 0
crusader_count = 0
pilgrim_count = 0
preacher_count = 0
prophet_count = 0
friendly_units = castle_all_friendly_units(robot)
total_karbonite = vision.all_karbonite(robot)
total_fuel = vision.all_fuel(robot)
for f_unit in friendly_units:
if f_unit.unit == unit_castle:
castle_count+=1
elif f_unit.unit == unit_church:
church_count+=1
elif f_unit.unit == unit_crusader:
crusader_count+=1
elif f_unit.unit == unit_pilgrim:
pilgrim_count+=1
elif f_unit.unit == unit_preacher:
preacher_count+=1
elif f_unit.unit == unit_prophet:
prophet_count+=1
# robot.log(str([unit.id for unit in vision.sort_visible_friendlies_by_distance(robot)]))
# If nothing else, replicate your own last message
communications.self_communicate_loop(robot)
if robot.step < 2:
# self.log("Building a crusader at " + str(self.me['x']+1) + ", " + str(self.me['y']+1))
robot.signal(robot.me.signal + 1, 2)
return castle_build(robot, unit_pilgrim)
elif robot.step > 500 and robot.karbonite > 100 and robot.fuel > 200:
robot.signal(robot.me.signal + 1, 2)
return castle_build(robot, unit_pilgrim)
elif (total_fuel + total_karbonite) * .55 < pilgrim_count and robot.karbonite > 100 and robot.fuel > 200:
return castle_build(robot, unit_pilgrim)
else:
None
def castle(robot):
friendly_units = all_friendly_units(robot)
utility.get_economic_unit(robot, friendly_units)
# robot.log(str([unit.id for unit in vision.sort_visible_friendlies_by_distance(robot)]))
# If nothing else, replicate your own last message
communications.self_communicate_loop(robot)
if robot.step < 2:
# self.log("Building a crusader at " + str(self.me['x']+1) + ", " + str(self.me['y']+1))
robot.signal(robot.me.signal + 1, 0)
return castle_build(robot, SPECS['PILGRIM'])
elif robot.step > 500 and robot.karbonite > 100 and robot.fuel > 200:
return castle_build(robot, SPECS['PILGRIM'])
else:
None
# self.log("Castle health: " + self.me['health'])
robot.log(str(robot.me.signal))
def pilgrim(robot):
# TODO - Fix random difficult to find timeout errors happening for some pilgrims in large maps (-s 56)
# TODO - Add scout bots, who scout if no mine to mine
communications.self_communicate_loop(robot)
carry_karb = robot.me.karbonite
carry_fuel = robot.me.fuel
# The pilgrim is on a mine and wants to deposit resources
if carry_fuel > 80 or carry_karb > 18:
# robot.log("Nearing capacity")
return pilgrim_full(robot)
# The pilgrim checks if it has a mine on it's current position
pilgrim_is_mining = pilgrim_mine(robot)
if pilgrim_is_mining !=0:
return pilgrim_is_mining
# Recieve signal from castle on which mine to go to and start self broadcasting
if robot.me.signal == 0:
unused_store, friendly_units = vision.sort_visible_friendlies_by_distance(robot)
for friendly_unit in friendly_units:
if friendly_unit.unit == 0 and friendly_unit.signal > -1:
robot.signal(friendly_unit.signal, 0)
break
if utility.fuel_less_check(robot):
return None
# TODO - Add code to make pilgrim move to church or castle rather just building a new church
# Move Section
unit_signal = robot.me.signal
# If signal is for mine postion, then start self broadcasting that position, edge case is (0,0) mine
if unit_signal < 6464 and unit_signal > 0:
robot.signal(add_mine_position_to_signal(robot, unit_signal), 0)
# robot.log('Position is ' + str(pos_x) + ' ' + str(pos_y))
pilgrim_is_moving = pilgrim_move(robot, unit_signal)
if pilgrim_is_moving !=0:
return pilgrim_is_moving
def castle(robot):
# if robot.step % 10 == 0:
# robot.log("Script Helper Turn@" + str(robot.step))
unit_castle = SPECS['CASTLE']
unit_church = SPECS['CHURCH']
unit_crusader = SPECS['CRUSADER']
unit_pilgrim = SPECS['PILGRIM']
unit_preacher = SPECS['PREACHER']
unit_prophet = SPECS['PROPHET']
castle_count = 0
church_count = 0
crusader_count = 0
pilgrim_count = 0
preacher_count = 0
prophet_count = 0
friendly_units = castle_all_friendly_units(robot)
total_karbonite = vision.all_karbonite(robot)
total_fuel = vision.all_fuel(robot)
robot.log(
mapping.get_nearby_map(robot.me.x, robot.me.y,
robot.get_passable_map()))
for f_unit in friendly_units:
if f_unit.unit == unit_castle:
castle_count += 1
elif f_unit.unit == unit_church:
church_count += 1
elif f_unit.unit == unit_crusader:
crusader_count += 1
elif f_unit.unit == unit_pilgrim:
pilgrim_count += 1
elif f_unit.unit == unit_preacher:
preacher_count += 1
elif f_unit.unit == unit_prophet:
prophet_count += 1
# robot.log(str([unit.id for unit in vision.sort_visible_friendlies_by_distance(robot)]))
# robot.log("=> " + str(robot.me.signal))
# If nothing else, replicate your own last message
communications.self_communicate_loop(robot)
""" Building units -
Start with 2 pilgrims.
If sufficient resources(>100 karb, >200 fuel), build, in order -
1 crusader per 3 pilgrims
1 preacher per 2 crusaders (per 6 pilgrims)
1 prophet per 3 crusaders (per 9 pilgrims)
1 prophet per 2 resources on map
"""
if robot.step < 2:
robot.signal(robot.me.signal + 1, 2)
return castle_build(robot, unit_pilgrim)
elif robot.karbonite > 100 and robot.fuel > 200:
if crusader_count * 3 < pilgrim_count:
# robot.signal(robot.me.signal + 1, 2)
return castle_build(robot, unit_crusader)
elif preacher_count * 2 < crusader_count:
# robot.signal(robot.me.signal + 1, 2)
return castle_build(robot, unit_preacher)
elif prophet_count * 3 < crusader_count:
# robot.signal(robot.me.signal + 1, 2)
return castle_build(robot, unit_prophet)
elif (total_fuel + total_karbonite) * .55 < pilgrim_count:
robot.signal(robot.me.signal + 1, 2)
return castle_build(robot, unit_pilgrim)
