def halfrotate(i, a, f):
if i == 1:
return deque()
elif i == 0:
rcenter = Unit(None, f.right + 1,
a.bottom + 1) # minus unit radius
elif i == 2:
rcenter = Unit(None, f.left - 1, a.top - 1) # minus unit radius
return deque([select_vehicles(a), rotate(pi, rcenter)])
def test_group_renew():
group = Group()
u1 = Unit(1, 1)
group.addUnit(u1)
assert group.unitList == [u1]
u2 = Unit(2, 2)
group.renew([u2])
assert group.unitList == [u2]
def setStrategyAttackGate(self):
# if the position is good or i am swinging >> let's strike!
if ((self.me.get_distance_to_unit(
self.attackCircle) < self.attackCircle.radius
and abs(self.me.get_angle_to_unit(self.attackCircle)) <
self.attackAngle) or self.me.state == HockeyistState.SWINGING):
strikeX = self.opponentPlayer.net_front
if self.me.y < self.rink_center_y:
strikeY1 = self.opponentPlayer.net_bottom - self.world.puck.radius
strikeY2 = self.opponentPlayer.net_bottom - 2.0 * self.world.puck.radius
else:
strikeY1 = self.opponentPlayer.net_top + self.world.puck.radius
strikeY2 = self.opponentPlayer.net_top + 2.0 * self.world.puck.radius
unit1 = Unit(9910, 0.0, 0.0, strikeX, strikeY1, 0.0, 0.0, 0.0, 0.0)
unit2 = Unit(9911, 0.0, 0.0, strikeX, strikeY2, 0.0, 0.0, 0.0, 0.0)
dist1 = min([
dist2segment(self.me, unit1, opponent)
for opponent in self.opponentUnits
])
dist2 = min([
dist2segment(self.me, unit2, opponent)
for opponent in self.opponentUnits
])
if dist1 < dist2:
#print "trystrike2 " + str(dist1) + " " + str(dist2)
self.tryStrike(strikeX, strikeY2)
else:
#print "trystrike1 " + str(dist1) + " " + str(dist2)
self.tryStrike(strikeX, strikeY1)
return True
if abs(self.me.x -
self.opponentPlayer.net_front) > self.game.world_width / 2.0:
if self.me.y < self.rink_center_y:
self.trySkate(self.attackCircle.x,
0.2 * self.game.world_height)
else:
self.trySkate(self.attackCircle.x,
0.8 * self.game.world_height)
else:
if self.me.y < self.rink_center_y:
self.trySkate(
self.attackCircle.x,
self.opponentPlayer.net_bottom - self.world.puck.radius)
else:
self.trySkate(
self.attackCircle.x,
self.opponentPlayer.net_top + self.world.puck.radius)
return True
def do_shuffle(s: MyStrategy, w: World, g: Game, m: Move):
vs = s.worldstate.vehicles
classes = [
reduce(lambda x, y: y | x, list(map(lambda x: vs.by_type[x], i)))
for i in types
]
pv = vs.by_player[vs.me]
allunits = vs.resolve(pv)
fullarea = get_square(allunits)
pointofscale = Unit(None, fullarea.left, fullarea.top)
result = deque()
for clas in range(len(classes)):
units = vs.resolve(classes[clas] & pv)
area = get_square(units)
pointofscale = Unit(None, area.left, area.top)
spreadflag = "spread:" + str(clas)
shiftflag = "shifted:" + str(clas)
mergeflag = "merged:" + str(clas)
spread_groups = select_types(types[clas], s.full_area)
spread_groups += do_and_check(
scale(pointofscale, len(types[clas])), spreadflag,
classes[clas])
shift_groups = deque()
merge_groups = deque()
slowpockarea = get_square(vs.resolve(vs.by_type[types[clas][0]]))
for i in range(1, len(types[clas])):
shift = 4 * i / len(types[clas]) # 4 - vehicle diameter
thetype = types[clas][i]
destination = Unit(None, 0, shift)
group_of_interest = vs.by_type[thetype] & pv
goi_area = get_square(vs.resolve(group_of_interest))
shift_groups += deque(
[select_vehicles(s.full_area, vtype=thetype)])
shift_groups += do_and_check(move(destination), shiftflag,
group_of_interest)
aligned_destination = Unit(None,
slowpockarea.left - goi_area.left,
0)
merge_groups += deque(
[select_vehicles(s.full_area, vtype=thetype)])
merge_groups += do_and_check(move(aligned_destination),
mergeflag, group_of_interest)
tight_groups = select_types(types[clas], s.full_area)
tight_groups += do_and_check(scale(pointofscale, 0.1), tightflag,
classes[clas])
result += shift_groups
result += deque([at_flag(spreadflag, 1, merge_groups)])
result += deque([at_flag(shiftflag, 1, spread_groups)])
result += deque([at_flag(mergeflag, 1, tight_groups)])
result += deque(
[at_flag(tightflag, 2, deque([fill_flag("shuffled")]))])
s.current_action = result + s.current_action
def test_group_add_units():
group = Group()
u1 = Unit(1, 1)
u2 = Unit(2, 2)
u3 = Unit(3, 3)
group.addUnit(u1)
group.addUnit(u2)
group.addUnit(u3)
assert group.unitList == [u1, u2, u3]
assert group.getX() == 2 # mass X
assert group.getY() == 2 # mass Y
def do_hunt(s: MyStrategy, w: World, g: Game, m: Move):
vs = s.worldstate.vehicles
myv = list(vs.resolve(vs.by_group[gr]))
mya = get_square(myv)
density = len(myv) / mya.area()
#print("Density is: " + str(density))
#print("Area is: " + str(mya))
#print("Amount is: " + str(len(myv)))
if density < criticaldensity:
if len(vs.by_group[gr] & vs.by_group[gr + 1]) == 0:
destination = get_center(myv)
aerials = vs.by_group[gr + 1]
pos = get_center(list(vs.resolve(aerials)))
targetv = Unit(None, destination.x - pos.x,
destination.y - pos.y)
s.current_action.append(
select_vehicles(s.full_area, group=gr + 1))
s.current_action.append(move(targetv))
s.current_action.append(
at_move_end(
aerials,
deque([
select_vehicles(s.full_area, group=gr + 1),
group(gr),
])))
s.current_action += deque([hurricane(gr), hunt(gr, game)])
else:
huntchain = deque([
select_vehicles(s.full_area, group=gr),
move_to_enemies(
gr, game.tank_speed * game.swamp_terrain_speed_factor),
wait(60),
hunt(gr, game)
])
s.current_action += huntchain
def get_center(vehicles: list):
length = len(vehicles)
assert (length > 0)
center = length // 2
xsort = sorted(vehicles, key=lambda x: x.x)
ysort = sorted(vehicles, key=lambda x: x.y)
return Unit(None, xsort[center].x, ysort[center].y)
def get_unit(self, name):
con = lite.connect(os.path.join(self.database_path, 'easybeer.db'))
c = con.cursor()
c.execute("""select * from units where name=:name""", {'name': name})
u = c.fetchone()
c.close()
con.close()
if u: return Unit(u[0], u[1])
else: return None
def apply_default_values(self):
self.model.update_unit(Unit('temperature', 'Celsius'))
self.model.update_unit(Unit('delta_temperature', 'Celsius'))
self.model.update_unit(Unit('water_volume', 'Liter'))
self.model.update_unit(Unit('malt_mass', 'Kilogram'))
self.model.update_unit(Unit('yeast_mass', 'Gram'))
self.model.update_unit(Unit('yeast_rate', 'Billion/°P/Liter'))
self.model.update_unit(Unit('hop_rate', 'Gram per liter'))
self.model.update_unit(Unit('hop_mass', 'Gram'))
self.close()
def test_unit_creation():
_x = 1
_y = 1
_hp = 5
_typeId = Terran.SCV
unit = Unit(x=_x, y=_y, hp=_hp, typeId=_typeId, idn=0)
assert unit.getX() == _x
assert unit.getY() == _y
assert unit.getHp() == _hp
assert unit.getTypeId() == _typeId
def tryStrike(self, strikeX, strikeY):
PASS_ACCURACY = pi / 3.0
STRIKE_ACCURACY = 1.0 * pi / 180.0
angle = self.me.get_angle_to(strikeX, strikeY)
self.move_turn = angle
self.move_speed_up = 1.0
danger = False
for opponentUnit in self.opponentUnits:
if (opponentUnit.get_distance_to_unit(
self.me) < 1.1 * self.game.stick_length
and abs(opponentUnit.get_angle_to_unit(
self.me)) < 0.6 * self.game.stick_sector
and opponentUnit.state != HockeyistState.KNOCKED_DOWN):
danger = True
if (opponentUnit.get_distance_to_unit(
self.world.puck) < 1.1 * self.game.stick_length
and abs(opponentUnit.get_angle_to_unit(
self.world.puck)) < 0.7 * self.game.stick_sector
and opponentUnit.state != HockeyistState.KNOCKED_DOWN):
danger = True
if abs(angle) < STRIKE_ACCURACY and self.me.get_distance_to_unit(
self.attackCircle) > self.attackPassDistance:
if self.me.swing_ticks < self.game.max_effective_swing_ticks and not danger:
#print "swing: " + str(self.me.swing_ticks)
self.move_action = ActionType.SWING
return True
if (self.me.state == HockeyistState.SWINGING
or abs(angle) < STRIKE_ACCURACY):
#print "strike puck: " + str(self.me.swing_ticks)
self.move_action = ActionType.STRIKE
return True
if (abs(angle) < PASS_ACCURACY
#and danger
and self.me.state != HockeyistState.SWINGING and
self.me.get_distance_to_unit(
self.attackCircle) < self.attackPassDistance):
print "strike pass"
unit = Unit(9912, 0.0, 0.0, strikeX, strikeY, 0.0, 0.0, 0.0, 0.0)
self.tryPass('Strike', unit)
return True
return False
def create(self, *, round: int) -> Unit:
attrs = {}
uniforms = []
for name, v in self.params.items():
if isinstance(v, Param):
x, attrs[name] = v.sample(round=round)
uniforms.append(x)
else:
attrs[name] = v
price = int((1 + mean(uniforms)) * 100 * round)
return Unit(**attrs, price=price)
def each(i, a, f):
step = a.bottom - a.top
center = f.get_center().y
distributed_size = parts * (3 * step + 4)
top_from_bottom = ss.full_area.bottom - distributed_size
top_from_center = center - distributed_size / 2
top = (top_from_center < 0 and f.top + 10
or top_from_bottom < top_from_center and top_from_bottom
or top_from_center)
target = Unit(None, 0, i * (2 * step + 4) - top)
return deque([
select_vehicles(a),
move(target),
])
def do_kill(s: MyStrategy, w: World, g: Game, m: Move):
enemy = w.get_opponent_player()
vs = s.worldstate.vehicles
epicenter = Unit(None, enemy.next_nuclear_strike_x,
enemy.next_nuclear_strike_y)
radius = g.tactical_nuclear_strike_radius + 10
enemies = vs.resolve(vs.by_player[vs.opponent])
clusters = clusterize(enemies)
navigator = enemy.next_nuclear_strike_vehicle_id
in_cluster_of_len = 0
for c in clusters:
cluset = set()
for i in c:
cluset.add(enemies[i].id)
if navigator in cluset:
in_cluster_of_len = len(c)
break
expl_area = Area(epicenter.x - radius, epicenter.x + radius,
epicenter.y - radius, epicenter.y + radius)
my_avias = vs.by_player[vs.me] & (vs.by_type[VehicleType.HELICOPTER]
| vs.by_type[VehicleType.FIGHTER])
my_avias_len = len(my_avias)
if my_avias_len >= in_cluster_of_len:
target = vs[navigator]
shift = Unit(None, target.x - epicenter.x, target.y - epicenter.y)
result = [
select_vehicles(expl_area, vtype=VehicleType.HELICOPTER),
move(shift),
select_vehicles(expl_area, vtype=VehicleType.FIGHTER),
move(shift),
]
else:
result = [select_vehicles(expl_area), scale(epicenter, 10)]
result.append(wait(enemy.next_nuclear_strike_tick_index -
w.tick_index))
s.current_action = deque(result) + s.current_action
def read_inputs(self):
u = []
temperature = self.temperature_combo.currentText()
u.append(Unit('temperature', temperature))
u.append(Unit('delta_temperature', temperature))
water_volume = self.water_volume_combo.currentText()
u.append(Unit('water_volume', water_volume))
malt_mass = self.malt_mass_combo.currentText()
u.append(Unit('malt_mass', malt_mass))
yeast_mass = self.yeast_mass_combo.currentText()
u.append(Unit('yeast_mass', yeast_mass))
hop_rate = self.hop_rate_combo.currentText()
u.append(Unit('hop_rate', hop_rate))
hop_mass = self.hop_mass_combo.currentText()
u.append(Unit('hop_mass', hop_mass))
'this is a special one'
u.append(Unit('yeast_rate', 'Billion/°P/' + water_volume))
return u
def patrol(me, world, game, move):
global gotox
global gotoy
global need_request
deltax = 6
deltay = 4
if gotox < 0 or gotoy < 0 or me.get_distance_to(gotox, gotoy) < 3:
#print "patrol: where to go?"
commander = [
trooper for trooper in world.troopers
if trooper.teammate and trooper.type == TrooperType.COMMANDER
]
if commander:
need_request = True
gotox, gotoy = -1, -1
print "patrol: made request"
#move.action = ActionType.END_TURN
#return False
#else:
print "patrol: cycle move"
if me.x <= world.width / 2 and me.y <= world.height / 2:
gotox, gotoy = world.width - deltax, deltay
#print "patrol: new direction east"
elif me.x >= world.width / 2 and me.y <= world.height / 2:
gotox, gotoy = world.width - deltax, world.height - deltay
#print "patrol: new direction south"
elif me.x >= world.width / 2 and me.y >= world.height / 2:
gotox, gotoy = deltax, world.height - deltay
#print "patrol: new direction west"
elif me.x <= world.width / 2 and me.y >= world.height / 2:
gotox, gotoy = deltax, deltay
#print "patrol: new direction north"
print "patrol: me", me.x, me.y
print "patrol: direction", gotox, gotoy
if me.action_points >= get_move_cost(me, world, game, move):
unit = Unit(-1000, gotox, gotoy)
target = find_free_cell(me, world, game, move, unit)
if move_to_unit(me, world, game, move, target):
return True
move.action = ActionType.END_TURN
#print "patrol: cannot move"
return False
def adjust(clas):
## Perform a vertical move
secondturn = deque()
name = namefull + ":" + str(clas)
counted = 0
for i in [0, 2]: # lines except central
line = lines[i]
target = Unit(None, 0, lines[1].top - line.top)
for tt in types[clas]:
squadtomove = vs.in_area(line) & vs.by_type[tt]
if len(squadtomove) > 0:
secondturn += do_and_check(
[select_vehicles(s.full_area, vtype=tt),
move(target)], name, squadtomove)
counted += 1
return (deque([at_flag(name, counted, deque([fill_flag(namefull)]))]) +
secondturn)
def find_free_cell(me, world, game, move, unit):
for i in range(min(world.width, world.height)):
for j in [
z for z in range(unit.x - i, unit.x + i)
if 0 <= z <= world.width
]:
for k in [
z for z in range(unit.y - i, unit.y + i)
if 0 <= z <= world.height
]:
if world.cells[j][k] == CellType.FREE:
target = Unit(-1000, j, k)
#print "find_free_cell: original ", unit.x, ", ", unit.y
#print "find_free_cell: target found ", j, ", ", k
return target
#print "find_free_cell: cannot find free cell ", unit.x, ", ", unit.y
return unit
def commander_request(me, world, game, move):
global gotox
global gotoy
global need_request
if me.type == TrooperType.COMMANDER:
players = [
player for player in world.players
if player.name != 'zoldatoff' and player.name != 'MyStrategy'
and player.approximate_x >= 0 and player.approximate_y >= 0
]
if players:
min_player = players[0]
min_distance = 10000
for player in players:
unit = Unit(-player.id, player.approximate_x,
player.approximate_y)
distance = get_distance(me, world, game, move, unit)
if distance < min_distance:
min_distance = distance
min_player = player
if gotox >= 0 and gotoy >= 0:
gotox, gotoy = min_player.approximate_x, min_player.approximate_y
need_request = False
print "commander_request: new destination", gotox, gotoy
return False
if (me.type == TrooperType.COMMANDER and
me.action_points >= game.commander_request_enemy_disposition_cost
and need_request):
move.action = ActionType.REQUEST_ENEMY_DISPOSITION
need_request = False
print "commander_request: request sent"
return True
move.action = ActionType.END_TURN
#print "commander_request: no action"
return False
def use_bonus_grenade(me, world, game, move):
if (me.holding_grenade and me.action_points >= game.grenade_throw_cost):
my_troopers = [
trooper for trooper in world.troopers if trooper.teammate
]
enemy_troopers = [
trooper for trooper in world.troopers if not trooper.teammate
]
max_damage = 0
for x in [
z for z in range(me.x - int(game.grenade_throw_range), me.x +
int(game.grenade_throw_range))
if 0 <= z <= world.width
]:
for y in [
z
for z in range(me.y - int(game.grenade_throw_range), me.y +
int(game.grenade_throw_range))
if 0 <= z <= world.height
]:
damage_to_me = False
unit = Unit(-1000, x, y)
if me.get_distance_to_unit(unit) > game.grenade_throw_range:
continue
for my_trooper in my_troopers:
if my_trooper.get_distance_to_unit(unit) < 1.05:
damage_to_me = True
break
if damage_to_me:
continue
damage = 0
for enemy_trooper in enemy_troopers:
if 0.95 < enemy_trooper.get_distance_to_unit(unit) < 1.05:
damage = damage + game.grenade_collateral_damage
elif enemy_trooper.get_distance_to_unit(unit) < 0.95:
damage = damage + game.grenade_direct_damage
if damage > max_damage:
max_damage = damage
max_unit = unit
if ((me.stance == TrooperStance.STANDING
and 1.0 * max_damage / game.grenade_throw_cost * me.shoot_cost /
me.standing_damage > 1.0)
or (me.stance == TrooperStance.KNEELING
and 1.0 * max_damage / game.grenade_throw_cost *
me.shoot_cost / me.kneeling_damage > 1.0) or
(me.stance == TrooperStance.PRONE and 1.0 * max_damage /
game.grenade_throw_cost * me.shoot_cost / me.prone_damage > 1.0)):
print "use_bonus_grenade: damage = ", max_damage
print "use_bonus_grenade: me ", me.x, me.y
print "use_bonus_grenade: target", max_unit.x, max_unit.y
print "use_bonus_grenade: distance", me.get_distance_to_unit(
max_unit)
move.action = ActionType.THROW_GRENADE
move.x = max_unit.x
move.y = max_unit.y
return True
#print "use_bonus_grenade: cannot use grenade"
move.action = ActionType.END_TURN
return False
def test_unit_change_invis():
unit = Unit(x=0, y=0)
assert unit.invis == False
unit.changeInvis()
assert unit.invis == True
def do_shuffle(ss, w: World, g: Game, m: Move):
vss = ss.worldstate.vehicles
pv = vss.by_player[vss.me]
myv = vss.resolve(pv)
mya = get_square(myv)
#print("Area after alighment")
#print(mya)
parts = 10
step = (mya.bottom - mya.top) / parts
central = Area.copy(ss.full_area)
fragment_area = get_square(vss.resolve(pv & vss.by_type[VehicleType.IFV]))
fragment = fragment_area.right - fragment_area.left
central.left = (mya.left + mya.right - fragment) / 2
central.right = central.left + fragment
righter = Area.copy(ss.full_area)
righter.right = mya.right
righter.left = mya.right - fragment
lefter = Area.copy(ss.full_area)
lefter.left = mya.left
lefter.right = mya.left + fragment
#fourth_turn = deque([
#select_vehicles(ss.full_area),
#rotate(-pi/2, Unit(None, central.right + fragment/2, mya.top + fragment*2))
def halfrotate(i, a, f):
if i == 1:
return deque()
elif i == 0:
rcenter = Unit(None, f.right + 1,
a.bottom + 1) # minus unit radius
elif i == 2:
rcenter = Unit(None, f.left - 1, a.top - 1) # minus unit radius
return deque([select_vehicles(a), rotate(pi, rcenter)])
fifth_turn = deque([
at_flag("rerotated", 1, deque([fill_flag("formation_done")])),
devide(vss.by_group[1], halfrotate, 3, "rerotated")
])
fourth_turn = (do_and_check(tight(pv), "tighted", pv) +
deque([at_flag("tighted", 1, fifth_turn)]))
third_turn = deque([
select_vehicles(lefter),
move(Unit(None, central.left - lefter.left, 0)),
select_vehicles(righter),
move(Unit(None, central.left - righter.left, 0)),
wait(10),
at_move_end(pv, fourth_turn)
])
second_turn = deque([
select_vehicles(ss.full_area, vtype=VehicleType.FIGHTER),
move(Unit(None, 0, step + 1)),
select_vehicles(ss.full_area, vtype=VehicleType.ARRV),
move(Unit(None, 0, step + 1)),
select_vehicles(ss.full_area, vtype=VehicleType.IFV),
move(Unit(None, 0, 2 * step + 3)),
wait(10),
at_move_end(pv, third_turn)
])
def each(i, a, f):
step = a.bottom - a.top
center = f.get_center().y
distributed_size = parts * (3 * step + 4)
top_from_bottom = ss.full_area.bottom - distributed_size
top_from_center = center - distributed_size / 2
top = (top_from_center < 0 and f.top + 10
or top_from_bottom < top_from_center and top_from_bottom
or top_from_center)
target = Unit(None, 0, i * (2 * step + 4) - top)
return deque([
select_vehicles(a),
move(target),
])
ss.current_action.appendleft(devide(pv, each, parts, "loosed"))
ss.current_action.appendleft(at_flag("loosed", 1, second_turn))
def get_center(self):
return Unit(None, (self.left + self.right) / 2,
(self.top + self.bottom) / 2)
def decode_objects(d):
if d.get("__type__") == "Tank":
return Tank(0, "", 0, d["x"], d["y"], 0, 0, d["angle"], 0, d["turret_relative_angle"], 0, 0, 0, 0, 0, 0, TankType.MEDIUM)
elif d.get("__type__") == "Unit":
return Unit(0, d["width"], d["height"], d["x"], d["y"], 0, 0, d["angle"], 0)
return d
def fictive_unit(prototype, x, y, angle=None):
if angle is None:
angle = prototype.angle
return Unit(0, prototype.width, prototype.height, x, y, 0, 0, angle, 0)
def trySkate(self, skateX, skateY, zeroSpeed=False):
if self.world.puck.owner_hockeyist_id == self.me.id:
#print "trySkate: calcAcceleration1"
self.calcAcceleration(skateX, skateY)
#if self.speed < 0.1:
test = Unit(
9913, 0.0, 0.0, self.me.x +
6.0 * self.me.radius * cos(self.me.angle + self.move_turn),
self.me.y +
6.0 * self.me.radius * sin(self.me.angle + self.move_turn),
0.0, 0.0, 0.0, 0.0)
dangerUnits = [
unit for unit in self.opponentUnits
if unit.get_angle_to_unit(self.me) < pi / 3.0
]
if dangerUnits:
dangerUnits.sort(key=lambda x: dist2segment(self.me, test, x))
dist = dist2segment(self.me, test, dangerUnits[0])
if dist < 10.0 and self.me.get_angle_to_unit(
dangerUnits[0]) < 0.0:
self.move_turn = self.game.hockeyist_turn_angle_factor
#print "me+puck: angle +"
elif dist < 10.0:
self.move_turn = -self.game.hockeyist_turn_angle_factor
#print "me+puck: angle -"
return True
elif self.tryStrikeOpponent():
#print "trySkate: tryStrikeOpponent"
return True
elif zeroSpeed:
# i don't have a puck
# i don't have a puck
angle = self.me.get_angle_to(skateX, skateY)
dist = self.me.get_distance_to(skateX, skateY)
#if dist < 10.0*self.me.radius and abs(angle) > pi/2:
if abs(angle) > pi / 2.0 and dist < self.game.world_width / 2.0:
# going back
if angle > 0.0:
self.move_turn = angle - pi
else:
self.move_turn = angle + pi
if self.speed >= 0.0:
self.move_speed_up = -1.0
elif dist / self.speed > self.speed / self.game.hockeyist_speed_up_factor:
self.move_speed_up = self.speed / self.game.hockeyist_speed_up_factor
else:
self.move_speed_up = -1.0
else:
# going front
self.move_turn = angle
if self.speed <= 0.0:
self.move_speed_up = 1.0
elif dist / self.speed < self.speed / self.game.hockeyist_speed_down_factor:
self.move_speed_up = -self.speed / self.game.hockeyist_speed_down_factor
else:
self.move_speed_up = 1.0
#print "zeroSpeed: " + str(self.move_turn) + " " + str(self.move_speed_up)
return True
else:
#print "trySkate: calcAcceleration2"
self.calcAcceleration(skateX, skateY)
if self.speed < 0.1:
test = Unit(
9914, 0.0, 0.0, self.me.x +
2.0 * self.me.radius * cos(self.me.angle + self.move_turn),
self.me.y +
2.0 * self.me.radius * sin(self.me.angle + self.move_turn),
0.0, 0.0, 0.0, 0.0)
dist = min([
unit.get_distance_to_unit(test)
for unit in self.opponentUnits
])
if test.x < self.game.rink_left or test.x > self.game.rink_right or test.y < self.game.rink_top or test.y > self.game.rink_bottom:
dist = 0.0
if dist < 2.0 and self.me.get_angle_to_unit(
self.attackCircle) > 0.0:
self.move_turn += self.game.hockeyist_turn_angle_factor
#print "me-puck: angle +"
elif dist < 2.0:
self.move_turn -= self.game.hockeyist_turn_angle_factor
#print "me-puck: angle -"
return True
def initial_compact(s):
## Compactifies the initial spawn into one line
## At the end of process will set the "compacted" flag
## Returns deque with actions. s - MyStrategy
result = deque()
vs = s.worldstate.vehicles
pv = vs.by_player[vs.me]
# hardcoded, no way to obtain dynamicaly
spawnarea = Area(18, 220, 18, 220)
squadarea = get_square(vs.resolve(vs.by_type[VehicleType.IFV] & pv))
spawnarea_width = (spawnarea.right - spawnarea.left)
colwidth = squadarea.right - squadarea.left
centralleft = spawnarea.left + (spawnarea_width - colwidth) / 2
centralright = centralleft + colwidth
linewidth = squadarea.bottom - squadarea.top
lines = [
Area(spawnarea.left, spawnarea.right, spawnarea.top,
spawnarea.top + linewidth),
Area(spawnarea.left, spawnarea.right, centralleft, centralright),
Area(spawnarea.left, spawnarea.right, spawnarea.bottom - linewidth,
spawnarea.bottom),
]
columns = [
Area(spawnarea.left, spawnarea.left + colwidth, spawnarea.top,
spawnarea.bottom),
Area(centralleft, centralright, spawnarea.top, spawnarea.bottom),
Area(spawnarea.right - colwidth, spawnarea.right, spawnarea.top,
spawnarea.bottom),
]
sets = [
reduce(lambda x, y: y | x, list(map(lambda x: vs.by_type[x], i)))
for i in types
]
namefull = "secondturn"
def adjust(clas):
## Perform a vertical move
secondturn = deque()
name = namefull + ":" + str(clas)
counted = 0
for i in [0, 2]: # lines except central
line = lines[i]
target = Unit(None, 0, lines[1].top - line.top)
for tt in types[clas]:
squadtomove = vs.in_area(line) & vs.by_type[tt]
if len(squadtomove) > 0:
secondturn += do_and_check(
[select_vehicles(s.full_area, vtype=tt),
move(target)], name, squadtomove)
counted += 1
return (deque([at_flag(name, counted, deque([fill_flag(namefull)]))]) +
secondturn)
for t in [GROUNDERS, FLYERS]:
empties = set(range(3))
registredflags = 0
unitsfromset = [None] * len(columns)
squadsfromset = [None] * len(columns)
for i, col in enumerate(columns):
colunits = vs.in_area(col)
unitsfromset[i] = colunits & sets[t]
squadsfromset[i] = len(unitsfromset[i]) // 100
if squadsfromset[i] > 0:
empties.discard(i)
#print("Type " + str(t) + " has " + str(squadsfromset) + " squads by columns")
#print(empties)
for i, col in enumerate(columns):
if squadsfromset[i] > 0:
name = "firstturn:" + str(t)
for tomovetype in movables:
if squadsfromset[i] <= 1:
break
movecandidateset = (unitsfromset[i]
& vs.by_type[tomovetype])
if len(movecandidateset) == 0:
continue
if t == GROUNDERS and i != 1:
sample = vs[movecandidateset.pop()]
obstacle = set()
#print("Checking for obstacles...")
for lno, line in enumerate(lines):
if line.is_inside(sample):
#print("... at line " + str(lno))
obstacle = (vs.in_area(line)
& vs.in_area(columns[1]) & sets[t])
break
if len(obstacle) > 0:
#print("Obstacle detected")
obstacletype = vs[obstacle.pop()].type
if obstacletype == VehicleType.TANK:
#print("It is tank, lets find something else to move")
continue
else:
tcol = empties.pop()
empties.add(1)
target = Unit(
None, columns[tcol].left - columns[1].left,
0)
#print("Move obstacle from 1 to " + str(tcol))
result += do_and_check([
select_vehicles(s.full_area,
vtype=obstacletype),
move(target)
], name, unitsfromset[i])
registredflags += 1
tcol = empties.pop()
target = Unit(None, columns[tcol].left - columns[i].left,
0)
#print("Move from " + str(i) + " to " + str(tcol))
result += do_and_check([
select_vehicles(s.full_area, vtype=tomovetype),
move(target)
], name, unitsfromset[i])
registredflags += 1
squadsfromset[i] -= 1
result = deque([
at_flag("firstturn:" + str(t), registredflags, adjust(t))
]) + result
return deque([at_flag(namefull, 2, deque([fill_flag("compacted")]))
]) + result
def do_move(s: MyStrategy,
w: World,
g: Game,
m: Move,
max_speed=max_speed):
vs = s.worldstate.vehicles
aviaspeedfactor = 1
myg = vs.by_group[gr]
my = list(vs.resolve(myg))
marea = get_square(my)
mycenter = get_center(my)
aviasupport = vs.by_group[gr + 1]
if len(aviasupport) > 0:
aviacenter = get_center(list(vs.resolve(aviasupport)))
enemies = list(vs.resolve(vs.by_player[vs.opponent]))
if len(enemies) == 0:
return # some patroling action might be inserted later
clusters = clusterize(enemies, thresh=20)
aviaingroup = len(myg & aviasupport)
#allmine = len(myg | aviasupport)
groundmine = len(my)
least = get_center(enemies)
value = 500
mindistance = 2000
for c in clusters:
#print("Cluster:" + str(len(c)))
cluster = list(map(lambda x: enemies[x], c))
clustercenter = get_center(cluster)
distance = mycenter.get_distance_to_unit(clustercenter)
#new_value = map(lambda i: 1-int(i.type==0)-int(i.type==1)/2, cluster)
#new_value = reduce(lambda x, y: x+y, new_value)
new_value = len(cluster)
criticaldistance = (
new_value + groundmine) / 2 # should be obtained empirically
#print(str(value) + " == " + str(new_value))
if distance < criticaldistance:
# combat mode! fight or flee!
cluset = set(map(lambda x: x.id, cluster))
fulladvantage = calculate(s.effectiveness, vs,
(myg | aviasupport) - vs.damaged,
cluset)
#if len((myg | aviasupport)-vs.damaged) / len(myg | aviasupport) > 0.7:
print("Advantage: " + str(fulladvantage))
print("Cluster length: " + str(len(cluster)))
nuke_cd = w.get_my_player(
).remaining_nuclear_strike_cooldown_ticks
if (nuke_cd == 0 and len(cluster) > 20):
print("NUKE IT!")
navigator = -1
dst = 2000
for i in aviasupport:
ndst = vs[i].get_distance_to_unit(clustercenter)
if ndst < dst:
dst = ndst
navigator = i
if navigator > 0:
narea = get_square([vs[navigator]])
aviaspeedfactor = 10
if dst <= 2 * g.fighter_vision_range / 3:
s.flags["nuking"] = w.tick_index + 60
s.current_action.append(
nuke_it(clustercenter, navigator))
else:
s.flags["nuking"] = 20000
target = Unit(None, clustercenter.x - aviacenter.x,
clustercenter.y - aviacenter.y)
if target.x == 0:
target = Unit(
None, target.x,
target.y - g.fighter_vision_range)
elif target.y == 0:
target = Unit(
None, target.x - g.fighter_vision_range,
target.y)
else:
slope = target.y / target.x
dx = sqrt((g.fighter_vision_range**2) /
(slope**2 + 1))
dy = dx * slope
target = Unit(None, target.x - dx,
target.y - dy)
s.current_action.append(
select_vehicles(narea,
vtype=VehicleType.FIGHTER))
s.current_action.append(move(target))
# slowly go to the enemy
else:
print("Navigator not found")
# NUKE IS COMMING!
elif "nuking" in s.flags and s.flags["nuking"] < w.tick_index:
s.flags.pop("nuking")
#fight!
least = Unit(None,
mycenter.x + (clustercenter.x - mycenter.x) / 2,
mycenter.y + (clustercenter.y - mycenter.y) / 2)
mindistance = distance
value = new_value
max_speed = max_speed * 0.8
if aviaspeedfactor == 1:
aviaadvantage = calculate(s.effectiveness, vs,
aviasupport - vs.damaged, cluset)
#print("Aviaadvantage: " + str(aviaadvantage))
if aviaadvantage > 0:
aviaspeedfactor = 10
elif aviaingroup > 0 and aviaadvantage < -10:
aviaspeedfactor = 0.5
if value * valdst + mindistance > new_value * valdst + distance:
#print(str(value) + " > " + str(new_value))
least = clustercenter
value = new_value
mindistance = distance
dx = (least.x - mycenter.x)
dy = (least.y - mycenter.y)
destination = Unit(None, dx, dy)
if aviaspeedfactor != 1 or "nuking" in s.flags:
aviadestination = Unit(None, least.x - aviacenter.x,
least.y - aviacenter.y)
s.current_action.appendleft(
move(aviadestination, max_speed=aviaspeedfactor * max_speed))
s.current_action.appendleft(group(gr, action=ActionType.DISMISS))
s.current_action.appendleft(select_vehicles(marea, group=gr + 1))
elif aviaingroup == 0 and not "nuking" in s.flags:
ddx = copysign(100 * max_speed, dx)
ddy = copysign(100 * max_speed, dy)
overmain = Unit(None, mycenter.x - aviacenter.x + ddx,
mycenter.y - aviacenter.y + ddy)
s.current_action.appendleft(move(overmain,
max_speed=2 * max_speed))
s.current_action.appendleft(group(gr, action=ActionType.ASSIGN))
s.current_action.appendleft(select_vehicles(marea, group=gr + 1))
s.current_action.appendleft(move(destination, max_speed=max_speed))
def __init__(self, me, world, game):
#print "================ " + str(world.tick)
self.me = me
self.world = world
self.game = game
self.move_turn = None
self.move_speed_up = None
self.move_action = None
self.move_pass_angle = None
self.move_pass_power = None
self.angle = self.me.angle
speed = sqrt(self.me.speed_x * self.me.speed_x +
self.me.speed_y * self.me.speed_y)
if self.me.speed_y > 0.0 and self.angle > 0.0:
self.speed = speed
elif self.me.speed_y > 0.0 and self.angle < 0.0:
self.speed = -speed
elif self.me.speed_y < 0.0 and self.angle > 0.0:
self.speed = -speed
elif self.me.speed_y < 0.0 and self.angle < 0.0:
self.speed = speed
elif self.me.speed_x > 0.0 and -pi / 2.0 < self.angle < pi / 2.0:
self.speed = speed
else:
self.speed = -speed
self.player = self.world.get_my_player()
self.opponentPlayer = self.world.get_opponent_player()
self.myUnits = [
hockeyist for hockeyist in self.world.hockeyists
if hockeyist.teammate and hockeyist.id != self.me.id
and hockeyist.type != HockeyistType.GOALIE
and hockeyist.state != HockeyistState.RESTING
]
self.myUnits.sort(key=lambda x: self.me.get_distance_to_unit(x))
self.team_count = len(self.myUnits) + 1
goalies = [
hockeyist for hockeyist in self.world.hockeyists
if hockeyist.teammate and hockeyist.type == HockeyistType.GOALIE
]
if goalies:
self.goalie = goalies[0]
else:
self.goalie = None
forwards = [
hockeyist for hockeyist in self.world.hockeyists
if hockeyist.teammate and hockeyist.type == HockeyistType.FORWARD
]
if forwards:
self.forward = forwards[0]
else:
self.forward = None
versatiles = [
hockeyist for hockeyist in self.world.hockeyists
if hockeyist.teammate and hockeyist.type == HockeyistType.VERSATILE
]
if versatiles:
self.versatile = versatiles[0]
else:
self.versatile = None
defenders = [
hockeyist for hockeyist in self.world.hockeyists if
hockeyist.teammate and hockeyist.type == HockeyistType.DEFENCEMAN
]
if defenders:
self.defender = defenders[0]
else:
self.defender = None
self.opponentUnits = [
hockeyist for hockeyist in self.world.hockeyists
if not hockeyist.teammate and hockeyist.type !=
HockeyistType.GOALIE and hockeyist.state != HockeyistState.RESTING
]
self.opponentUnits.sort(key=lambda x: self.me.get_distance_to_unit(x))
self.rink_center_x = 0.5 * (self.game.rink_left + self.game.rink_right)
self.rink_center_y = 0.5 * (self.game.rink_top + self.game.rink_bottom)
if self.player.net_front < self.rink_center_x:
self.position = "left"
forward_x = self.opponentPlayer.net_front - 0.4 * self.game.world_width
defence_x = self.player.net_front + 3.1 * self.me.radius
# defence2_x = self.player.net_front + 4.1*self.me.radius
else:
self.position = "right"
forward_x = self.opponentPlayer.net_front + 0.4 * self.game.world_width
defence_x = self.player.net_front - 3.1 * self.me.radius
# defence2_x = self.player.net_front - 4.1*self.me.radius
if self.me.y < self.rink_center_y:
forward_y = self.game.rink_top + 0.2 * self.game.world_height
else:
forward_y = self.game.rink_bottom - 0.2 * self.game.world_height
self.forwardPlace = Unit(9906, 0.0, 0.0, forward_x, forward_y, 0.0,
0.0, 0.0, 0.0)
self.defendCircle = Unit(9907, 0.0, 1.0 * self.game.stick_length,
defence_x, self.rink_center_y, 0.0, 0.0, 0.0,
0.0)
#self.defendCircle2 = Unit(9901, 0.0, 1.0*self.game.stick_length,
# defence2_x, self.rink_center_y+self.me.radius,
# 0.0, 0.0, 0.0, 0.0)
self.attackAngle = pi / 2.0 - pi / 6.0
if self.goalie:
self.attackCircle = Unit(9908, 1.0, 0.4 * self.game.world_height,
self.opponentPlayer.net_front,
self.rink_center_y, 0.0, 0.0, 0.0, 0.0)
self.attackPassDistance = 3.0 * self.me.radius
else:
self.attackCircle = Unit(9909, 1.0, self.game.world_width,
self.opponentPlayer.net_front,
self.rink_center_y, 0.0, 0.0, 0.0, 0.0)
self.attackPassDistance = self.game.world_width
def calcAcceleration(self, skateX, skateY):
Tmin = 10000
a_min = 1.0
if self.me.get_distance_to(skateX,
skateY) > self.game.world_width / 5.0:
self.move_turn = self.me.get_angle_to(skateX, skateY)
self.move_speed_up = 1.0
return True
if abs(self.me.get_angle_to(skateX, skateY)) <= pi / 2.0:
direction = 'forward'
else:
direction = 'back'
for i in range(10):
(x, y) = (self.me.x, self.me.y)
v = self.speed
alpha = self.angle
a0 = 1.0 - i / 10.0
T = Tmin
if direction == 'forward' and a0 < 0.0:
break
# if direction == 'back' and self.me.get_distance_to(skateX, skateY) > 100.0 and a < 0.0:
# break
for j in range(100):
aj = a0 - j * 0.001
unit = Unit(999 + i * 100 + j, 0.0, 0.0, x, y, 0.0, 0.0, alpha,
0.0)
if (x < self.game.rink_left or x > self.game.rink_right
or y < self.game.rink_top
or y > self.game.rink_bottom):
break
if unit.get_distance_to(skateX, skateY) < 1.0:
T = j
break
if aj > 0.0:
v += aj * self.game.hockeyist_speed_up_factor
else:
v += aj * self.game.hockeyist_speed_down_factor
v = 0.95 * v # friction
dalpha = unit.get_angle_to(skateX, skateY)
if v < 0.0 and dalpha < 0.0:
dalpha = dalpha + pi
elif v < 0.0 and dalpha > 0.0:
dalpha = dalpha - pi
dalpha = copysign(
min(abs(dalpha), self.game.hockeyist_turn_angle_factor),
dalpha)
alpha = normAngle(alpha + dalpha)
(x, y) = (x + v * cos(alpha), y + v * sin(alpha))
if T < Tmin:
Tmin = T
a_min = a0
alpha = self.me.get_angle_to(skateX, skateY)
if T == 10000:
#print self.me.x, self.me.y, skateX, skateY, self.angle, direction, self.speed
self.move_turn = alpha
self.move_speed_up = 1.0
elif direction == 'back' and a_min < 0.0 and alpha < 0.0:
self.move_turn = alpha + pi
self.move_speed_up = a_min
elif direction == 'back' and a_min < 0.0 and alpha > 0.0:
self.move_turn = alpha - pi
self.move_speed_up = a_min
else:
self.move_turn = alpha
self.move_speed_up = a_min
return True
