Example #1
0
 def has_intersection_with_tiles(distance):
     course = tire_speed.normalized() * distance
     line = Line(begin=get_current_tile(context.position, tile_size),
                 end=get_current_tile(context.position + course, tile_size))
     return make_has_intersection_with_lane(
         position=context.position,
         course=course,
         barriers=list(chain(generate_barriers(line))),
         width=context.game.tire_radius,
     )(0)
Example #2
0
def path_has_tiles(path, tiles, tile_size, tile_type):
    for p in path:
        if is_in_world(p, tiles, tile_size):
            tile = get_current_tile(p, tile_size)
            if tiles[tile.x][tile.y] == tile_type:
                return True
    return False
Example #3
0
def first_point_index(path, tiles, tile_size, tile_type):
    for i, p in enumerate(path):
        if is_in_world(p, tiles, tile_size):
            tile = get_current_tile(p, tile_size)
            if tiles[tile.x][tile.y] == tile_type:
                return i
    return len(path)
 def generate():
     for i, p in islice(enumerate(path), len(path) - 1):
         middle = (p + path[i + 1]) / 2
         yield get_current_tile(middle, 1)
def make_tiles_points(points, tile_size, world_height):
    return dict((get_point_index(get_current_tile(v, tile_size), world_height),
                 OrderedPoint(index=i, position=v))
                for i, v in enumerate(points))
def make_tiles_bonuses(bonuses, tile_size, world_height):
    result = defaultdict(list)
    for v in bonuses:
        index = get_point_index(get_current_tile(v, tile_size), world_height)
        result[index].append(v)
    return result
Example #7
0
def is_in_empty_tile(position, tiles, tile_size):
    tile = get_current_tile(position, tile_size)
    return tiles[tile.x][tile.y] == TileType.EMPTY
Example #8
0
 def tile(self):
     return get_current_tile(self.position, self.game.track_tile_size)
Example #9
0
    def get(self, context: Context, path):
        if (self.__tiles is None or self.__tile_barriers is None or
                self.__tiles != context.world.tiles_x_y):
            self.__tiles = copy(context.world.tiles_x_y)
            self.__tile_barriers = make_tiles_barriers(
                tiles=context.world.tiles_x_y,
                margin=context.game.track_tile_margin,
                size=context.game.track_tile_size,
            )
        tile_size = context.game.track_tile_size
        sub_path = [context.position] + path
        if reduce(mul, generate_cos(path), 1) < 0:
            target_position = Curve(sub_path).at(tile_size)
        else:
            target_position = Polyline(sub_path).at(tile_size)
        course = target_position - context.position
        current_tile = context.tile
        target_tile = get_current_tile(target_position, tile_size)
        target_tile.x = max(0, min(context.world.width - 1, target_tile.x))
        target_tile.y = max(0, min(context.world.height - 1, target_tile.y))
        range_x = list(range(current_tile.x, target_tile.x + 1)
                       if current_tile.x <= target_tile.x
                       else range(target_tile.x, current_tile.x + 1))
        range_y = list(range(current_tile.y, target_tile.y + 1)
                       if current_tile.y <= target_tile.y
                       else range(target_tile.y, current_tile.y + 1))

        def generate_tiles():
            for x in range_x:
                for y in range_y:
                    yield Point(x, y)

        row_size = context.world.height

        def generate_tiles_barriers():
            def impl():
                for tile in generate_tiles():
                    yield self.__tile_barriers[get_point_index(tile, row_size)]
            return (v for v in chain.from_iterable(impl()))

        all_units = list(
            Unit(Point(v.x, v.y), Point(v.speed_x, v.speed_y)) for v in chain(
                (v for v in context.world.cars
                 if v.id != context.me.id and (v.speed_x > 0 or v.speed_y > 0)),
                (x for x in context.world.projectiles),
            )
        )
        tiles_barriers = generate_tiles_barriers()
        projectiles_barriers = generate_projectiles_barriers(context)
        cars_barriers = generate_cars_barriers(context)
        oil_slicks_barriers = generate_oil_slicks_barriers(context)
        all_barriers = list(chain(
            tiles_barriers,
            (BarrierLimit(v, 0.9) for v in projectiles_barriers),
            (BarrierLimit(v, 0.8) for v in cars_barriers),
            (BarrierLimit(v, 0.7) for v in oil_slicks_barriers),
        ))
        width = max(context.me.width, context.me.height)
        angle = course.rotation(context.direction)

        static = make_has_intersection_with_lane(
            position=context.position,
            course=course * (0.75 + context.speed.norm() / MAX_SPEED),
            barriers=all_barriers,
            width=width,
        )

        world_tiles = context.world.tiles_x_y

        def dynamic(current_angle):
            if abs(current_angle) > 0.6:
                return False
            my_speed = course.rotate(current_angle) * context.speed.norm()
            my_line = Line(context.position, context.position + my_speed)
            for unit in all_units:
                if unit.speed.norm() == 0:
                    continue
                unit_line = Line(unit.position, unit.position + unit.speed)
                intersection = my_line.intersection(unit_line)
                if intersection is None:
                    continue
                if not is_in_world(intersection, world_tiles, tile_size):
                    continue
                if is_in_empty_tile(intersection, world_tiles, tile_size):
                    continue
                unit_dir = intersection - unit.position
                if unit_dir.norm() == 0 or unit_dir.cos(unit.speed) < 0:
                    continue
                if unit_dir.norm() > my_speed.norm() * 100:
                    continue
                my_dir = intersection - context.position
                if my_dir.norm() == 0 or my_dir.cos(my_speed) < 0:
                    continue
                unit_time = unit_dir.norm() / unit.speed.norm()
                my_time = my_dir.norm() / my_speed.norm()
                if abs(my_time - unit_time) <= MY_INTERVAL:
                    return True
            return False

        def adjust(has_intersection, begin, end):
            return adjust_course(has_intersection, angle, begin, end)

        if context.speed.norm() > 0:
            rotation = adjust(lambda x: dynamic(x) or static(x), -1, 1)
        else:
            rotation = adjust(static, -1, 1)
        if rotation is not None:
            return course.rotate(rotation)
        return course
Example #10
0
 def test_at_100_100_with_tile_size_100_returns_1_1(self):
     result = get_current_tile(point=Point(x=100, y=100), tile_size=100)
     assert_that(result, equal_to(Point(1, 1)))
Example #11
0
 def generate():
     for i, p in islice(enumerate(path), len(path) - 1):
         middle = (p + path[i + 1]) / 2
         yield get_current_tile(middle, 1)
Example #12
0
def make_tiles_points(points, tile_size, world_height):
    return dict((get_point_index(get_current_tile(v, tile_size), world_height),
                 OrderedPoint(index=i, position=v))
                for i, v in enumerate(points))
Example #13
0
def make_tiles_bonuses(bonuses, tile_size, world_height):
    result = defaultdict(list)
    for v in bonuses:
        index = get_point_index(get_current_tile(v, tile_size), world_height)
        result[index].append(v)
    return result