def __init__(self):
# Initialize any objects or variables you need here.
self.i = 0
self.up = None
self.right = None
self.down = None
self.left = None
self.height = None
self.width = None
self.turret_counter = None
self.vertical = None
self.maniac = Maniac()
class PlayerAI:
def __init__(self):
# Initialize any objects or variables you need here.
self.i = 0
self.up = None
self.right = None
self.down = None
self.left = None
self.height = None
self.width = None
self.turret_counter = None
self.vertical = None
self.maniac = Maniac()
def relative_offset_to_absolute(self,facing, x, y):
if facing == Direction.UP:
return x,y
elif facing == Direction.DOWN:
return -x,-y
elif facing == Direction.LEFT:
return y,-x
elif facing == Direction.RIGHT:
return -y,x
def public_direction_to_private(self, direction):
if direction == Direction.UP:
return 0
elif direction == Direction.Right:
return 1
elif direction == Direction.Down:
return 2
elif direction == Direction.Left:
return 3
def translate_directions(self, player, gameboard):
if player.direction == Direction.UP:
self.up = Direction.UP
self.right = Direction.RIGHT
self.down = Direction.DOWN
self.left = Direction.LEFT
self.height = gameboard.height
self.width = gameboard.width
self.vertical = True
elif player.direction == Direction. RIGHT:
self.up = Direction.RIGHT
self.right = Direction.DOWN
self.down = Direction.LEFT
self.left = Direction.UP
self.height = gameboard.width
self.width = gameboard.height
self.vertical = False
elif player.direction == Direction. DOWN:
self.up = Direction.DOWN
self.right = Direction.LEFT
self.down = Direction.UP
self.left = Direction.RIGHT
self.height = gameboard.height
self.width = gameboard.width
self.vertical = True
elif player.direction == Direction. LEFT:
self.up = Direction.LEFT
self.right = Direction.UP
self.down = Direction.RIGHT
self.left = Direction.DOWN
self.height = gameboard.width
self.width = gameboard.height
self.vertical = False
else:
pass
def is_bullet_chasing(self, player, gameboard):
player_position = player.x, player.y
behind_slot = tuple(map(operator.add, player_position, self.relative_offset_to_absolute(player.direction, 0,1)))
if behind_slot[0] < 0 or behind_slot[0] == gameboard.width or behind_slot[1] < 0 or behind_slot[1] == gameboard.height:
behind_slot = tuple(map(operator.add, player_position, self.relative_offset_to_absolute(player.direction, 0,-self.height + 1)))
if gameboard.are_bullets_at_tile(behind_slot[0], behind_slot[1]):
bullets = gameboard.bullets_at_tile[behind_slot[0]][behind_slot[1]]
for bullet in bullets:
if bullet.direction == player.direction:
return True
return False
def distance(self, pos1, pos2):
return math.sqrt((pos1[0] - pos2[0])**2 + (pos1[1] - pos2[1])**2)
def in_turret_range(self, turret, player_x, player_y):
if self.distance((turret.x, turret.y), (player_x, player_y)) < 5:
return True
def get_left_coords(self, player, player_position, gameboard):
left_bullet_slot = tuple(map(operator.add, player_position, self.relative_offset_to_absolute(player.direction, -1,0)))
if left_bullet_slot[0] < 0 or left_bullet_slot[0] == gameboard.width or left_bullet_slot[1] < 0 or left_bullet_slot[1] == gameboard.height:
left_bullet_slot = tuple(map(operator.add, player_position, self.relative_offset_to_absolute(player.direction, self.width - 1, 0,)))
return left_bullet_slot
def get_right_coords(self, player, player_position, gameboard):
right_bullet_slot = tuple(map(operator.add, player_position, self.relative_offset_to_absolute(player.direction, +1,0)))
if right_bullet_slot[0] < 0 or right_bullet_slot[0] == gameboard.width or right_bullet_slot[1] < 0 or right_bullet_slot[1] == gameboard.height:
right_bullet_slot = tuple(map(operator.add, player_position, self.relative_offset_to_absolute(player.direction, -self.width + 1, 0)))
return right_bullet_slot
def get_front_coords(self, player, player_position, gameboard):
front_bullet_slot = tuple(map(operator.add, player_position, self.relative_offset_to_absolute(player.direction, 0,-1)))
if front_bullet_slot[0] < 0 or front_bullet_slot[0] == gameboard.width or front_bullet_slot[1] < 0 or front_bullet_slot[1] == gameboard.height:
front_bullet_slot = tuple(map(operator.add, player_position, self.relative_offset_to_absolute(player.direction, 0, self.height - 1)))
return front_bullet_slot
def get_back_coords(self, player, player_position, gameboard):
front_bullet_slot = tuple(map(operator.add, player_position, self.relative_offset_to_absolute(player.direction, 0,+1)))
if front_bullet_slot[0] < 0 or front_bullet_slot[0] == gameboard.width or front_bullet_slot[1] < 0 or front_bullet_slot[1] == gameboard.height:
front_bullet_slot = tuple(map(operator.add, player_position, self.relative_offset_to_absolute(player.direction, 0, -self.height + 1)))
return front_bullet_slot
def turret_dangerous(self, turret):
print("turret_counter")
print(self.turret_counter[turret.x][turret.y])
print("cool down + fire time")
print(turret.cooldown_time + turret.fire_time)
if turret.is_dead or self.turret_counter[turret.x][turret.y] > turret.fire_time:
return False
else:
return True
def immediate_danger(self, gameboard, player):
player_position = player.x, player.y
for i in range(self.width):
if self.vertical:
turret_pos = (i, player.y)
else:
turret_pos = (player.x, i)
if gameboard.is_turret_at_tile(turret_pos[0], turret_pos[1]):
turret = gameboard.turret_at_tile[turret_pos[0]][turret_pos[1]]
if not turret.is_dead and turret.is_firing_next_turn and self.in_turret_range(turret, player.x, player.y):
return True
for i in range(gameboard.height):
if gameboard.is_turret_at_tile(player.x, i):
turret = gameboard.turret_at_tile[player.x][i]
if turret.is_firing_next_turn and self.in_turret_range(turret, player.x, player.y):
return True
left_bullet_slot = self.get_left_coords(player, player_position, gameboard)
right_bullet_slot = self.get_right_coords(player, player_position, gameboard)
left_bullets = gameboard.bullets_at_tile[left_bullet_slot[0]][left_bullet_slot[1]]
right_bullets = gameboard.bullets_at_tile[right_bullet_slot[0]][right_bullet_slot[1]]
for bullet in left_bullets:
if bullet.direction == self.right:
return True
for bullet in right_bullets:
if bullet.direction == self.left:
return True
return False
def frontal_danger(self, player, gameboard, opponent):
player_position = player.x, player.y
front_slot = self.get_front_coords(player ,player_position, gameboard)
front_left_slot = self.get_left_coords(player, front_slot, gameboard)
front_right_slot = self.get_right_coords(player, front_slot, gameboard)
front_front_slot = self.get_front_coords(player, front_slot, gameboard)
print("player_position")
print(player_position)
print("front_slot")
print(front_slot)
print("front_left")
print(front_left_slot)
print("front_right")
print(front_right_slot)
print("front front")
print(front_front_slot)
if gameboard.is_wall_at_tile(front_slot[0], front_slot[1]) or front_slot == (opponent.x, opponent.y):
return True
for i in range(self.width):
if self.vertical:
turret_pos = (i, front_slot[1])
else:
turret_pos = (front_slot[0], i)
if gameboard.is_turret_at_tile(turret_pos[0], turret_pos[1]):
turret = gameboard.turret_at_tile[turret_pos[0]][turret_pos[1]]
if self.turret_dangerous(turret) and self.in_turret_range(turret, front_slot[0],front_slot[1]):
return True
if gameboard.are_bullets_at_tile(front_left_slot[0], front_left_slot[1]):
for bullet in gameboard.bullets_at_tile[front_left_slot[0]][front_left_slot[1]]:
if bullet.direction == self.right:
return True
if gameboard.are_bullets_at_tile(front_right_slot[0], front_right_slot[1]):
for bullet in gameboard.bullets_at_tile[front_right_slot[0]][front_right_slot[1]]:
if bullet.direction == self.left:
return True
if gameboard.are_bullets_at_tile(front_front_slot[0], front_front_slot[1]):
for bullet in gameboard.bullets_at_tile[front_front_slot[0]][front_front_slot[1]]:
if bullet.direction == self.down:
return True
return False
def absolute_direction_move_from_relative(self, direction ):
if direction == Direction.UP:
return Move.FACE_UP
if direction == Direction.RIGHT:
return Move.FACE_RIGHT
if direction == Direction.DOWN:
return Move.FACE_DOWN
if direction == Direction.LEFT:
return Move.FACE_LEFT
def get_valid_moves(self, gameboard, player, opponent):
valid_moves = []
if self.is_bullet_chasing(player, gameboard):
valid_moves.append(Move.FORWARD)
return valid_moves
if self.immediate_danger(gameboard, player):
valid_moves.append(Move.FORWARD)
return valid_moves
valid_moves.append(Move.SHOOT)
valid_moves.append(Move.NONE)
if (player.laser_count > 0):
valid_moves.append(Move.LASER)
if (player.shield_count > 0 and (not player.shield_active)):
valid_moves.append(Move.SHIELD)
if not self.frontal_danger(player, gameboard, opponent):
valid_moves.append(Move.FORWARD)
left_slot = self.get_left_coords(player, (player.x, player.y), gameboard)
right_slot = self.get_right_coords(player, (player.x, player.y), gameboard)
back_slot = self.get_back_coords(player, (player.x, player.y), gameboard)
if not gameboard.is_wall_at_tile(left_slot[0], left_slot[1]) and not left_slot == (opponent.x, opponent.y):
valid_moves.append(self.absolute_direction_move_from_relative(self.left))
if not gameboard.is_wall_at_tile(right_slot[0], right_slot[1]) and not right_slot == (opponent.x, opponent.y):
valid_moves.append(self.absolute_direction_move_from_relative(self.right))
if not gameboard.is_wall_at_tile(back_slot[0], back_slot[1]) and not back_slot == (opponent.x, opponent.y):
valid_moves.append(self.absolute_direction_move_from_relative(self.down))
return valid_moves
# if there is a bullet right behind you, you can only move forward
def update_turret_counters(self, gameboard):
if self.turret_counter == None:
self.turret_counter = [[None for x in range(gameboard.height)] for x in range(gameboard.width)]
for turret in gameboard.turrets:
self.turret_counter[turret.x][turret.y] = 0
return
else:
for turret in gameboard.turrets:
if self.turret_counter[turret.x][turret.y] == turret.fire_time + turret.cooldown_time - 1:
self.turret_counter[turret.x][turret.y] = 0
return
self.turret_counter[turret.x][turret.y] += 1
def get_move(self, gameboard, player, opponent):
# Write your AI here.
self.update_turret_counters(gameboard)
self.translate_directions(player, gameboard)
move_choice = Move.NONE
valid_moves = self.get_valid_moves(gameboard, player, opponent)
print (valid_moves)
temp_move = self.maniac.checkforassasin(gameboard,player,opponent)
if (temp_move in valid_moves) and (temp_move !=Move.NONE):
move_choice = temp_move
else:
for move in valid_moves:
move_choice = move
return move_choice
