Beispiel #1
0
    def init(self):
        all_walls = []
        id_map = []

        for x, y in Map.dimensions:
            p = Position((x, y))

            id_map.append(p)

            if Map.isCellPosValid(p + Direction.RIGHT):
                all_walls.append((p, Direction.RIGHT))

            if Map.isCellPosValid(p + Direction.DOWN):
                all_walls.append((p, Direction.DOWN))

        random.shuffle(all_walls)
        self.all_walls = Stack(*all_walls)

        self.id_map = UnionFind(*id_map)

        self.old_p_wall = None
Beispiel #2
0
    def getRandomDirection(p: Position) -> (Direction, None):
        """
        Fonction permettant d'obtenir une direction aléatoire valide.

        INPUT :
            p : Position, une position
            visited_pos : list liste tuple, la liste des cases déjà visitées

        OUTPUT :
            res : Direction ou None si aucune direction n'est valide
        """

        list_dir = Direction.getRandomDirectionList()
        # On récupère les directions triées aléatoirement

        res = None

        for dir in list_dir:
            new_p = p + dir

            if Map.isCellPosValid(new_p):
                # Si la nouvelle case est bien dans le plateau
                """
                if visited_pos[new_p.x][new_p.y] is None:
                    # Si cette nouvelle case n'a jamais été visitée

                    if Map.getWall(p + dir/2) == Map.WALL:
                        # S'il y a bien un mur à briser

                        res = dir
                """

                if Map.getWall(p + dir / 2) == Map.WALL:
                    # S'il y a bien un mur à briser

                    res = dir

        return res
    def applyAlgorith(self):
        left_dir = Direction.all_directions[(self.dir_id +
                                             self.increment_direction_id) % 4]
        front_dir = Direction.all_directions[self.dir_id % 4]

        self.move_forward = True

        if Map.isWallPosValid(self.new_p + left_dir / 2) and Map.getWall(
                self.new_p + left_dir / 2) == Map.EMPTY:
            # Si le mur de droite est valide et est vide...

            self.dir_id += self.increment_direction_id
            # On tourne dans la direction choisie
        elif not Map.isCellPosValid(self.new_p + front_dir) or Map.getWall(
                self.new_p + front_dir / 2) == Map.WALL:
            # Sinon si la case devant est hors du plateau ou il y a un mur en face...

            self.dir_id += (self.increment_direction_id + 2) % 4
            # On tourne dans la direction opposée

            self.move_forward = False

        left_dir = Direction.all_directions[(self.dir_id +
                                             self.increment_direction_id) % 4]
        front_dir = Direction.all_directions[self.dir_id % 4]
        # On recalcule les directions

        if self.move_forward:
            # S'il faut avancer on avance
            self.old_p = Position(self.new_p)
            self.new_p = self.new_p + front_dir
            self.go_forward_frame += 1

        self.nb_iter += 1

        if self.nb_iter == 4 * Map.width * Map.height:
            raise GenericResolution.NoSolutionError()