Example #1
0
class DodgeStrike(Strike):

    allow_backwards = True

    def intercept_predicate(self, car, ball):
        return ball.pos[2] < 280

    def __init__(self, car, info, target=None):
        self.dodge = AimDodge(car, 0.1, info.ball.pos)
        self.dodging = False

        super().__init__(car, info, target)

    def configure(self, intercept: Intercept):
        super().configure(intercept)

        if self.target is None:
            self.arrive.target = intercept.ground_pos + ground_direction(intercept, self.car) * 100
        else:
            self.arrive.target = intercept.ground_pos - ground_direction(intercept.ground_pos, self.target) * 110

        self.dodge.jump.duration =  0.05 + clamp((intercept.ball.pos[2]-92) / 600, 0, 1.5)
        self.dodge.target = intercept.ball.pos


    def step(self, dt):
        if self.dodging:
            self.dodge.step(dt)
            self.controls = self.dodge.controls
        else:
            super().step(dt)
            if self.arrive.time - self.car.time < self.dodge.jump.duration + 0.2:
                self.dodging = True
        self.finished = self.finished or self.dodge.finished
Example #2
0
class DodgeStrike(Strike):
    """
    Strike the ball by dodging into it.
    """

    allow_backwards = False
    jump_time_multiplier = 1.0

    def intercept_predicate(self, car: Car, ball: Ball):
        return ball.position[2] < 300

    def __init__(self, car, info, target=None):
        self.dodge = AimDodge(car, 0.1, info.ball.position)
        self.dodging = False

        super().__init__(car, info, target)

    def configure(self, intercept: Intercept):
        super().configure(intercept)

        ball = intercept.ball
        target_direction = ground_direction(ball, self.target)
        hit_dir = ground_direction(ball.velocity, target_direction * 4000)

        self.arrive.target = intercept.ground_pos - hit_dir * 100
        self.arrive.target_direction = hit_dir

        additional_jump = clamp(
            (ball.position[2] - 92) / 500, 0, 1.5) * self.jump_time_multiplier
        self.dodge.jump.duration = 0.05 + additional_jump
        self.dodge.target = intercept.ball.position
        self.arrive.additional_shift = additional_jump * 500

    def interruptible(self) -> bool:
        return not self.dodging and super().interruptible()

    def step(self, dt):
        if self.dodging:
            self.dodge.step(dt)
            self.controls = self.dodge.controls
        else:
            super().step(dt)
            if (self.arrive.arrival_time - self.car.time <
                    self.dodge.jump.duration + 0.13
                    and abs(self.arrive.drive.target_speed -
                            norm(self.car.velocity)) < 1000):
                self.dodging = True

        if self.dodge.finished:
            self.finished = True
Example #3
0
class DodgeStrike(Strike):

    allow_backwards = True

    def intercept_predicate(self, car, ball):
        return ball.position[2] < 280

    def __init__(self, car, info, target=None):
        self.dodge = AimDodge(car, 0.1, info.ball.position)
        self.dodging = False

        super().__init__(car, info, target)

    def configure(self, intercept: Intercept):
        super().configure(intercept)

        if self.target is None:
            self.arrive.target = intercept.ground_pos + ground_direction(
                intercept, self.car) * 100
        else:
            self.arrive.target = intercept.ground_pos - ground_direction(
                intercept.ground_pos, self.target) * 110

        additional_jump = clamp((intercept.ball.position[2] - 92) / 600, 0,
                                1.5)
        self.dodge.jump.duration = 0.05 + additional_jump
        self.dodge.target = intercept.ball.position
        self.arrive.additional_shift = additional_jump * 500

    def step(self, dt):
        if self.dodging:
            self.dodge.step(dt)
            self.controls = self.dodge.controls
        else:
            super().step(dt)
            if (self.arrive.time - self.car.time <
                    self.dodge.jump.duration + 0.2
                    and abs(self.arrive.drive.target_speed -
                            norm(self.car.velocity)) < 500):
                self.dodging = True
        self.finished = self.finished or self.dodge.finished
Example #4
0
class DodgeStrike(Strike):
    """
    Strike the ball by dodging into it.
    """

    allow_backwards = False
    jump_time_multiplier = 1.0

    def intercept_predicate(self, car: Car, ball: Ball):
        if (ball.time - car.time) < self.get_jump_duration(ball.position[2]):
            return False
        return ball.position[2] < 300

    def __init__(self, car, info, target=None):
        self.dodge = AimDodge(car, 0.1, info.ball.position)
        self.dodging = False

        super().__init__(car, info, target)

    def get_jump_duration(self, ball_height: float) -> float:
        return 0.05 + clamp(
            (ball_height - 92) / 500, 0, 1.5) * self.jump_time_multiplier

    def configure(self, intercept: Intercept):
        super().configure(intercept)

        ball = intercept.ball
        target_direction = ground_direction(ball, self.target)
        hit_dir = ground_direction(
            ball.velocity, target_direction * (norm(ball.velocity) * 3 + 500))

        self.arrive.target = intercept.ground_pos - hit_dir * 165
        self.arrive.target_direction = hit_dir

        self.dodge.jump.duration = self.get_jump_duration(ball.position[2])
        self.dodge.target = intercept.ball.position
        self.arrive.additional_shift = self.get_jump_duration(
            ball.position[2]) * 1000

    def interruptible(self) -> bool:
        if self.info.ball.position[2] > 150 and self.dodging:
            return True
        return not self.dodging and super().interruptible()

    def step(self, dt):
        if self.dodging:
            self.dodge.step(dt)
            self.controls = self.dodge.controls
        else:
            super().step(dt)
            if (self.arrive.arrival_time - self.car.time <
                    self.dodge.jump.duration + 0.13
                    and abs(self.arrive.drive.target_speed -
                            norm(self.car.velocity)) < 1000 and
                (dot(normalize(self.car.velocity),
                     ground_direction(self.car, self.arrive.target)) > 0.95
                 or norm(self.car.velocity) < 500)):
                self.dodging = True

        if self.dodge.finished:
            self.finished = True
Example #5
0
    def __init__(self, car, info, target=None):
        self.dodge = AimDodge(car, 0.1, info.ball.position)
        self.dodging = False

        super().__init__(car, info, target)