def slash(action, state):
"""The Slash action is triggered if a character able to slash steps past an enemy"""
# Check to make sure the actor is Moving and that they can slash
if not isinstance(
action,
actions.Move) or "Slash" not in action['element']['abilities']:
return []
actor = action['element']
src = state.find(actor)
dest = action['target']
# Can only target cells that were next to the actor at the start and end of his movement.
# By doing it this way, we can handle leaping with the same test.
targets = grid.neighbors(src) & grid.neighbors(dest)
results = []
for target in targets:
# for every cell in targets, check if an enemy is present
if target in state and actor['team'] != state[target][
'team'] and "Health" in state[target]['abilities']:
# If so, add a Slash Action as a reaction.
reaction = CreateAction({
"type": "Slash",
"element": actor,
"target": target
})
logger.debug("%s triggered %s", action, reaction)
results.append(reaction)
return results
def get_action(cls, actor, state):
actor['bomb cooldown'] -= 1
if actor['bomb cooldown'] >= 0:
return
for cell in grid.burst(state.find(actor), 3):
if cell in state.keys():
continue
# Check who we're targeting
neighbors = [state[c] for c in grid.neighbors(cell) if c in state]
teams = set(n['team'] for n in neighbors if 'team' in n)
if actor['team'] in teams: # Can't hit allies.
continue
elif len(teams
) == 0: # Don't target cells where you won't hit anyone.
continue
else:
return [
CreateAction({
'type': "ThrowBomb",
'element': actor,
'target': cell
})
]
def _redelmeier_routine(p, parent, untried, forbidden):
# todo use lifo linked list / stack implementation for untried
if p == 0:
yield Polyomino(normalize(parent))
else:
while untried:
nbr = untried.pop()
child = parent | {nbr}
new_neighbours = list(
filter(
lambda x: x not in parent and x not in forbidden and (
(x[1] >= 0 and x[0] >= 0) or x[1] >= 1),
neighbors(nbr).difference(untried)))
forbidden = forbidden.union([nbr])
yield from _redelmeier_routine(p - 1, child,
untried + new_neighbours, forbidden)
def validate(self, state):
"""Validate that the action doesn't violate any rules."""
source = state.find(self.element)
if self.target not in grid.neighbors(source):
return False
if "team" not in state.get(
self.target,
{}) or self.element['team'] == state[self.target]['team']:
return False
return True
def __expand_space(grid, fringe, visited, g, h, parent, curr):
for n in neighbors(grid, curr):
if n not in visited:
if n not in fringe:
g[n] = float('inf')
parent[n] = None
if g[curr] + cost(grid, curr, n) < g[n]:
g[n] = g[curr] + cost(grid, curr, n)
parent[n] = curr
fringe[n] = g[n] + h(n)
def validate(self, state):
if "Move" not in self.element["abilities"]:
logger.debug("%s does not have the ability to Move")
return False
if self.target not in grid.neighbors(state.find(self.element)):
return False
if self.target not in grid.VALID_CELLS:
return False
if self.target in state:
logger.debug("%s tried to move to %s, which is occupied by %s",
self.element, self.target, state[self.target])
return False
return True
def get_action(cls, actor, state):
results = []
results.append(
CreateAction({
'type': "Explode",
'element': actor,
'target': state.find(actor)
}))
for cell in grid.neighbors(state.find(actor)):
results.append(
CreateAction({
'type': "BlastWave",
'element': actor,
'target': cell
}))
return results
def h_favor_highways_smart(grid, s, goal, *args, **kwargs):
# Only useful for searching for highways beyond manhattan distance bc we only need to compare manhattan distance
# d_x = s.coords[0] - goal.coords[0]
# d_y = s.coords[1] - goal.coords[1]
m_d = manhattan_distance(s, goal)
c = h(grid, s, goal, *args, **kwargs)
for n in neighbors(grid, s):
if is_horizontal(s, n) or is_vertical(s, n):
if s.is_highway() and n.is_highway():
m_d_n = manhattan_distance(n, goal)
if m_d < m_d_n:
c = cost(grid, s, n) * m_d
# In order to take into account searching for highways beyond the manhattan distance,
# we would need to know the parent of s
# if s.parent is n:
# continue
return c
def __expand_space_integrated(grid, o, c_a, c_i, g, anchor, inad, bp, w1, w2, curr):
for k in o:
if curr in o[k]:
o[k].remove(curr)
for n in neighbors(grid, curr):
if n not in g:
g[n] = float('inf')
bp[n] = None
g_new = g[curr] + cost(grid, curr, n)
if g[n] > g[curr] + cost(grid, curr, n):
g[n] = g_new
bp[n] = curr
if n not in c_a:
o[anchor][n] = key(g, anchor, n, w1)
if n not in c_i:
for i in inad:
if key(g, i, n, w1) <= w2*o[anchor][n]:
o[i][n] = key(g, i, n, w1)
while not frontier.empty():
current = frontier.get()
for next in grid.negihbors(current):
if next not in visited:
frontier.put(next)
visited[next] = True
#modification to keep track of movment
frontier = Queue()
frontier.put(start)
came_from = []
came_from[start] = True
while not frontier.empty():
current = frontier.get()
for next in grid.neighbors(current):
if next not in came_from:
frontier.put(next)
came_from[next] = current
#reconstruction of path
current = goal #here we have goal
path = [current]
while current != start:
current = came_from[current]
path.append(current)
path.reverse()
#'eary exit' means to stop expanding the frontier as soon as the goal is found
frontier = Queue()
frontier.put(start)
while not frontier.empty(): current = frontier.get() for next in grid.negihbors(current): if next not in visited: frontier.put(next) visited[next] = True #modification to keep track of movment frontier = Queue() frontier.put(start) came_from =[] came_from[start] = True while not frontier.empty(): current = frontier.get() for next in grid.neighbors(current): if next not in came_from: frontier.put(next) came_from[next] = current #reconstruction of path current = goal #here we have goal path = [current] while current != start: current = came_from[current] path.append(current) path.reverse() #'eary exit' means to stop expanding the frontier as soon as the goal is found frontier = Queue() frontier.put(start)
def threatened_cells(cls, actor, state):
return grid.neighbors(state.find(actor))
def targets(cls, actor, state):
results = set()
for target, element in state.items():
if 'team' not in element or element['team'] != actor['team']:
results |= grid.neighbors(target)
return results
def test_neighbors(self):
n = [s for (i, s) in np.ndenumerate(self.grid) if i is not (1, 1)]
computed_n = neighbors(self.grid, self.grid[1, 1])
for s in n:
assert s in computed_n
