コード例 #1
0
    def attack_with_puck(self, env):
        def f(point):
            nfc = shortcuts.net_front_center(env, shortcuts.opponent_player(env))
            angles = [
                min(geometry.degree_to_rad(110), geometry.ray_ray_angle(oh, env.me, point))
                for oh in shortcuts.opponent_field_hockeyists(env)
                if geometry.distance(oh, nfc) > 300
            ]
            ticks_to_reach_point = assessments.ticks_to_reach_point(env, env.me, point)
            if not angles:
                return -ticks_to_reach_point
            return geometry.rad_to_degree(min(angles)) - ticks_to_reach_point / 100

        strike_point = algorithm.best_point_for_polynoms(self.target_polygons, f=f)

        if any(geometry.point_in_convex_polygon(env.me, p) for p in self.attack_polygons):
            goal_point = experiments.get_goal_point(env)
            basic_actions.turn_to_unit(env, goal_point)

            if basic_actions.turned_to_unit(env, goal_point, eps=geometry.degree_to_rad(1.0)):
                env.move.speed_up = 1.0

            if self.swing_condition(env):
                env.move.action = ActionType.SWING

            if self.strike_condition(env):
                env.move.action = ActionType.STRIKE
            return

        if self.pass_condition(env, strike_point):
            self.do_pass(env)
            return

        experiments.fast_move_to_point_forward(env, strike_point)
コード例 #2
0
    def attack_with_puck(self, env):
        if any(geometry.point_in_convex_polygon(env.me, p) for p in self.attack_polygons):
            strike_point = env.me

        else:
            strike_point = algorithm.best_point_for_polynoms(
                self.attack_polygons,
                f=lambda p: -assessments.ticks_to_reach_point(env, env.me, p))
        # strike_point = geometry.convex_polygons_nearest_point(
        #     self.attack_polygons, env.me)

        if env.me.get_distance_to_unit(strike_point) >= 60:
            # print strike_point
            experiments.fast_move_to_point(env, strike_point)
            return

        goal_point = experiments.get_goal_point(env)
        basic_actions.turn_to_unit(env, goal_point)

        if basic_actions.turned_to_unit(env, goal_point, eps=geometry.degree_to_rad(1.0)):
            # if self.opponent_protect_goal(env, goal_point):
            #     env.move.action = ActionType.SWING
            # else:
            #     env.move.action = ActionType.STRIKE
            env.move.action = ActionType.SWING
コード例 #3
0
 def test_point_in_convex_polygon(self):
     polygon = geometry.Polygon([
         geometry.Point(0, 0),
         geometry.Point(1, 0),
         geometry.Point(1, 1),
         geometry.Point(0, 1),
     ])
     self.assertTrue(geometry.point_in_convex_polygon(
         geometry.Point(0.5, 0.5),
         polygon
     ))
     self.assertFalse(geometry.point_in_convex_polygon(
         geometry.Point(1.5, 0.5),
         polygon
     ))
     self.assertFalse(geometry.point_in_convex_polygon(
         geometry.Point(1.00001, 0.00001),
         polygon
     ))
     self.assertTrue(geometry.point_in_convex_polygon(
         geometry.Point(0.99999, 0.00001),
         polygon
     ))
コード例 #4
0
    def pass_condition(self, env, strike_point):
        if env.world.tick - self.history.game_start_tick <= 75:
            return True

        pass_taker = self.count_pass_taker(env)
        if geometry.distance(self.hwp, pass_taker) > 200:
            for oh in shortcuts.opponent_field_hockeyists(env):
                if geometry.interval_point_distance(self.hwp, strike_point, oh) < 60:
                    return True

        if any(geometry.point_in_convex_polygon(self.hwp, p) for p in self.precount.dead_polygons):
            return True

        return False
コード例 #5
0
    def attack_with_puck(self, env, gstrategy):
        strike_point = gstrategy.strike_point

        if any(geometry.point_in_convex_polygon(env.me, p) for p in self.precount.attack_polygons):
            goal_point = experiments.get_goal_point(env)
            basic_actions.turn_to_unit(env, goal_point)

            if basic_actions.turned_to_unit(env, goal_point, eps=geometry.degree_to_rad(1.0)):
                env.move.speed_up = 1.

            if self.swing_condition(env):
                env.move.action = ActionType.SWING

            if self.strike_condition(env):
                env.move.action = ActionType.STRIKE
            return

        experiments.fast_move_to_point_forward(env, strike_point)
コード例 #6
0
    def pass_condition(self, env, strike_point):
        if env.world.tick - self.game_start_tick <= 75:
            return True

        collega = filter(lambda h: h.id != env.me.id, shortcuts.my_field_hockeyists(env))[0]
        net_center = shortcuts.net_front_center(env, shortcuts.opponent_player(env))
        if geometry.distance(collega, env.me) > 200:
            for oh in shortcuts.opponent_field_hockeyists(env):
                # my_angle = geometry.ray_ray_angle(env.me, strike_point, net_center)
                # o_angle = geometry.ray_ray_angle(oh, strike_point, net_center)
                # my_distance = geometry.distance(env.me, strike_point)
                # o_distance = geometry.distance(oh, strike_point)

                # if my_angle > o_angle and my_distance > o_distance:
                #     return True

                if geometry.interval_point_distance(env.me, strike_point, oh) < 60:
                    return True

        if any(geometry.point_in_convex_polygon(env.me, p) for p in self.dead_polygons):
            return True

        return False
コード例 #7
0
 def its_dangerous(self, env):
     return (
         any(geometry.point_in_convex_polygon(env.world.puck, p) for p in self.weak_polygons)
         or geometry.distance(env.world.puck, self.defence_point) < 120
     )