Python Map.point_to_index方法代码示例

# 需要导入模块: from Map import Map [as 别名]
# 或者: from Map.Map import point_to_index [as 别名]
    def __init__(self, terrain_map):
        height = terrain_map.height
        width = terrain_map.width
        time0 = time()
        score_array = self.create_score_array(terrain_map, height, width)
        if PRINT_TIMING:
            print("\nScoreMap init", time() - time0)
        to_score = set()  # stores the next tiles to update score in a set
        curr_score = INITIAL_SCORE
        if PRINT_TIMING:
            time0 = time()
        # Set bottom row of scores to (1, [SOUTH]) or (NON_TRAVERSIBLE_SCORE, [])
        for i in range(width):
            p = Point(i, height - 1)
            ndx = Map.point_to_index(p, width, height)
            if self.needs_scoring(score_array, ndx):
                score_array[ndx] = ScoreTile(INITIAL_SCORE, [Directions.SOUTH])
                neighbors = Map.get_neighbors_static(p, width, height)
                for neighbor_key in neighbors:
                    neighbor_point = neighbors[neighbor_key]
                    if neighbor_point is not None:
                        neighbor_ndx = Map.point_to_index(neighbor_point, width, height)
                        if self.needs_scoring(score_array, neighbor_ndx):
                            to_score.add(neighbor_point)

        if PRINT_TIMING:
            print("ScoreMap add to bottom", time() - time0)
        #TODO check that this works
        # Start scoring all other tiles

        if PRINT_TIMING:
            time0 = time()
        while len(to_score) > 0:
            curr_score += 1
            currently_scoring = to_score
            to_score = set()
            for point in currently_scoring:
                ndx = Map.point_to_index(point, width, height)
                if self.needs_scoring(score_array, ndx):
                    score = self.score_point(score_array, point, curr_score, height, width)
                    score_array[ndx] = score
                    neighbors = Map.get_neighbors_static(point, width, height)
                    for neighbor_key in neighbors:
                        neighbor_point = neighbors[neighbor_key]
                        if neighbor_point is not None:
                            neighbor_ndx = Map.point_to_index(neighbor_point, width, height)
                            if self.needs_scoring(score_array, neighbor_ndx):
                                to_score.add(neighbor_point)

        if PRINT_TIMING:
            print("ScoreMap score rest", time() - time0)

        super(ScoreMap, self).__init__(score_array, width, height)

# 需要导入模块: from Map import Map [as 别名]
# 或者: from Map.Map import point_to_index [as 别名]
 def create_score_array(self, terrain_map, height, width):
     score_array = [None] * (height * width)
     # Set scores of non traversable tiles to NON_TRAVERSABLE_SCORE
     for x in range(width):
         for y in range(height):
             p = Point(x, y)
             ndx = Map.point_to_index(p, width, height)
             t_tile = terrain_map.map[ndx]
             if not t_tile.is_traversable():
                 score_array[ndx] = ScoreTile(NON_TRAVERSABLE_SCORE, [])
     return score_array

# 需要导入模块: from Map import Map [as 别名]
# 或者: from Map.Map import point_to_index [as 别名]
 def get_all_traversable_states(self):
     states = []
     for x in range(self.width):
         for y in range(self.height):
             pnt = Point(x, y)
             ndx = Map.point_to_index(pnt, self.width, self.height)
             terrain = self.map[ndx]
             if terrain.is_traversable():
                 for dir in Directions:
                     state = State(pnt, dir)
                     states.append(state)
     return states

# 需要导入模块: from Map import Map [as 别名]
# 或者: from Map.Map import point_to_index [as 别名]
 def score_point(self, score_array, point, score, height, width):
     result_score = ScoreTile(score, [])
     ndx = Map.point_to_index(point, width, height)
     neighbors = Map.get_neighbors_static(point, width, height)
     # TODO Test THIS directions and score from surrounding tiles
     # for neighbor_point in neighbors:
     #     neighbor_ndx = map.point_to_index(neighbor_point, width, height)
     #     neighbor_tile = score_array[neighbor_ndx]
     #     if neighbor_tile
     # for neighbor in neighbors:
     # print(neighbor)
     # print(neighbors[neighbor])
     for direction in Directions:
         neighbor_point = neighbors[direction]
         if neighbor_point is not None:
             neighbor_ndx = Map.point_to_index(neighbor_point, width, height)
             neighbor_tile = score_array[neighbor_ndx]
             if neighbor_tile is not None:
                 if neighbor_tile.score < score and neighbor_tile.score != -1:
                     result_score.directions.append(direction)
     return result_score

# 需要导入模块: from Map import Map [as 别名]
# 或者: from Map.Map import point_to_index [as 别名]
    def score_rest(self, to_score, next_to_score, start_index, processor_count):

        for index in range(start_index, len(to_score), processor_count):
            Map.point_to_index(to_score[index], width, height)