def move(self, d: Direction) -> MoveVerdict:
"""
Executes a step of this player. If the player is already inactive, this
won't cause any state changes in map.
:param d: Direction the player should take
:return: A verdict, which reflects the changes the move caused
"""
if self._inactive:
return MoveVerdict(verdict=MoveVerdictEnum.INACTIVE)
verdict = super(Player, self).move(d)
if verdict.verdict == MoveVerdictEnum.NO_MOVE or verdict.verdict == MoveVerdictEnum.CAPTURED:
self._inactive = True
elif verdict.verdict == MoveVerdictEnum.NO_VERDICT:
raise RuntimeError("Inconclusive verdict when trying to move")
elif verdict.verdict == MoveVerdictEnum.MOVE:
self._momentum += 1
self.set_facing(d)
# If player is capable to move only one step,
# it should finish moving no matter what.
# Except if player is delayed.
if self.__move_only_once and verdict.verdict != MoveVerdictEnum.DELAYED:
self._inactive = True
return verdict
def before_step(self, intruder: AbstractBlock, i: MoveInfo) -> MoveVerdict:
"""
:return: Whether intruder can step on block
"""
if not self._data:
return MoveVerdict(MoveVerdictEnum.MOVE)
top_verdict = self.top().before_step(intruder, i)
return top_verdict
def before_step(self, intruder: AbstractBlock) -> MoveVerdict:
verdict = MoveVerdict(verdict=MoveVerdictEnum.NO_MOVE)
try:
intruder: Player
intruder.set_dead()
verdict.reports.append(
PlayerMoveReport(position=intruder.position, died=True))
except AttributeError:
pass # Intruder is not player
return verdict
def before_step(self, intruder: AbstractBlock, i: MoveInfo) -> MoveVerdict:
walls_verdict = self._walls.before_step(intruder, i)
if walls_verdict.verdict != MoveVerdictEnum.NO_VERDICT:
return walls_verdict
if self.free_space > 0 or self._capacity == -1:
if isinstance(intruder, Player):
# Accept block
self._blocks_in_pool.append(intruder)
return MoveVerdict(verdict=MoveVerdictEnum.CAPTURED)
# If full, behaves like a rock
return super(DuckPoolBlock, self).before_step(intruder, i)
def before_step(self, intruder: AbstractBlock,
_i: MoveInfo) -> MoveVerdict:
verdict = MoveVerdict(verdict=MoveVerdictEnum.NO_MOVE)
# Try to kill it
try:
intruder: 'Player'
intruder.set_dead()
verdict.reports.append(
PlayerMoveReport(position=intruder.position, died=True))
except AttributeError:
pass
return verdict
def move(self, d: Direction) -> MoveVerdict:
"""
:param d: Direction the movable object takes
:return: True, if state changed, false otherwise
"""
if self._game_map is None:
raise ValueError("Movable object is not initialized")
elif self._position is None:
# might be captured
logging.warning("Movable tried to move without position set")
return MoveVerdict(verdict=MoveVerdictEnum.INACTIVE)
t = self._game_map.block(self._position).top()
if type(t) != type(self):
# I cannot find myself in game map
raise ValueError(
f"Cannot find movable object of type {type(self)} in position {self._position} Unexpected type: {type(t)}"
)
new_pos = dir_func_map.get(d)(self._position)
move_info = MoveInfo(direction=d, target=new_pos)
cell_to_interact = self._game_map.block(new_pos)
result: MoveVerdict = cell_to_interact.before_step(self, move_info)
cell_to_interact.after_step(self, move_info)
if result.verdict == MoveVerdictEnum.MOVE:
# Original position needs to be saved, because game map overrides it
# when it moves player object
original_position = self._position
self._game_map.move(self._position, new_pos, self)
result.reports.append(
MovableMoveReport(position=original_position, target=new_pos))
elif result.verdict == MoveVerdictEnum.CAPTURED:
# Movable is captured by something, remove from map
self._game_map.block(self._position).pop()
result.reports.append(
MovableMoveReport(position=self._position,
target=None,
captured=True))
self._position = None
return result
def before_step(self, intruder: AbstractBlock, i: MoveInfo) -> MoveVerdict:
if self._life <= 0:
return MoveVerdict(verdict=MoveVerdictEnum.MOVE)
rock_block_verdict = super(MeltingIceBlock,
self).before_step(intruder, i)
# Ice only melts if intruder comes from a distance. If they don't have
# a momentum property, assume that it cannot break
try:
if intruder.momentum > 0:
self._life -= 1
rock_block_verdict.reports.append(
MeltingIceReport(life_was=self._life + 1,
life_now=self._life,
position=i.target))
except AttributeError:
# only melt for 'player like' objects
pass
return rock_block_verdict
def before_step(self, intruder: AbstractBlock, _i: MoveInfo) -> MoveVerdict:
"""
:return: Whether intruder can step on block
"""
return MoveVerdict(verdict=MoveVerdictEnum.MOVE)
def before_step(self, intruder: 'AbstractBlock', i : MoveInfo) -> MoveVerdict:
wall_side = Direction.opposite(i.direction)
wall = self._walls.get(wall_side)
if wall is None:
return MoveVerdict(verdict=MoveVerdictEnum.NO_VERDICT)
return self._walls[wall_side].before_step(intruder)
def before_step(self, intruder: 'AbstractBlock') -> MoveVerdict:
return MoveVerdict(MoveVerdictEnum.NO_VERDICT)
def before_step(self, intruder: 'AbstractBlock',
move_info: MoveInfo) -> MoveVerdict:
return MoveVerdict(verdict=MoveVerdictEnum.NO_MOVE)
def before_step(self, intruder: 'AbstractBlock',
move_info: MoveInfo) -> MoveVerdict:
"""
:return: Whether intruder can step on block
"""
return MoveVerdict(verdict=MoveVerdictEnum.NO_VERDICT)
def before_step(self, intruder: 'AbstractBlock',
i: MoveInfo) -> MoveVerdict:
# When colliding with another player, that player should not stop,
# because it might happen, that they move "simultaneously"
return MoveVerdict(verdict=MoveVerdictEnum.DELAYED)