def diagonal(game_info, opponent_distance, x_sign): controller_input = SimpleControllerState() current_state = game_info.me ball_angle = atan2((game_info.ball.pos - current_state.pos).y, (game_info.ball.pos - current_state.pos).x) offset = Vec3(0, 0, 0) if current_state.pos.y < -2250: #Boost towards the first small boost controller_input = GroundTurn(current_state, current_state.copy_state(pos=game_info.ball.pos+offset)).input() controller_input.boost = 1 elif current_state.pos.y < - 1500: controller_input = FrontDodge(current_state).input() elif current_state.pos.y > -700: controller_input = FrontDodge(current_state).input() else: #If we're on the ground between stages, boost and turn towards the ball controller_input = GroundTurn(current_state, current_state.copy_state(pos=game_info.ball.pos)).input() if current_state.wheel_contact: controller_input.boost = 1 return controller_input
def controller(self, agent, angle): controller_state = SimpleControllerState() steer_value = steer(angle) controller_state.steer = steer_value controller_state.throttle = 1 controller_state.handbrake = True if self.level == PowerSlideLevel.NORMAL: balance_threshold = 0.25 * abs( agent.me.angular_velocity.data[2])**2 + 0.05 if balance_threshold * -1 <= angle <= balance_threshold: controller_state.handbrake = False controller_state.boost = True if abs(agent.me.angular_velocity.data[2]) >= 0.15: controller_state.steer = sign( agent.me.angular_velocity.data[2]) * -1 else: controller_state.steer = 0 elif self.level == PowerSlideLevel.U_TURN: if abs(angle) < 1.15: controller_state.steer = steer_value * -1 controller_state.throttle = -1 controller_state.handbrake = False controller_state.boost = False if abs(angle) < 0.15: controller_state.steer = 0 return controller_state
def far_back(game_info, opponent_distance): controller_input = SimpleControllerState() current_state = game_info.me ball_angle = atan2((game_info.ball.pos - current_state.pos).y, (game_info.ball.pos - current_state.pos).x) if abs(current_state.pos.y) > 3800: #If we're far away, boost to speed up controller_input.boost = 1 elif abs(current_state.pos.y) > 1500: #Front flip for speed controller_input = FrontDodge(current_state).input() elif current_state.pos.y > -700: controller_input = FrontDodge(current_state).input() elif current_state.wheel_contact: #Otherwise if we're on the ground, boost and turn towards the ball controller_input = GroundTurn(current_state, current_state.copy_state(pos=game_info.ball.pos)).input() controller_input.boost = 1 else: #Otherwise turn towards the ball (this might not actually do anything) controller_input = GroundTurn(current_state, current_state.copy_state(pos=game_info.ball.pos)).input() return controller_input
def follow_ball_on_ground(gi: GameInfo) -> Sequence: ball_loc = Vec3(gi.packet.game_ball.physics.location) ball_loc_flat = ball_loc.flat() ball_vel_flat = Vec3(gi.packet.game_ball.physics.velocity).flat() ball_ground_speed = ball_vel_flat.length() ideal_position = ball_loc_flat controls = SimpleControllerState( steer=gi.car.steer_toward_target(ideal_position) ) car_ground_speed = gi.car.velocity.flat().length() car_to_ball_dist = gi.car.location.flat().dist(ball_loc_flat) if car_to_ball_dist > 800: controls.throttle = 1.0 controls.boost = abs(controls.steer) < 0.2 and car_ground_speed < 2300 else: if car_ground_speed - ball_ground_speed > 525 and car_to_ball_dist < 500: controls.throttle = min(max((ball_ground_speed - car_ground_speed) / 3600, -1.0), 0) controls.boost = False else: controls.throttle = min(max((ball_ground_speed - car_ground_speed) / 525, 0), 1.0) controls.boost = ball_ground_speed - car_ground_speed > 992 if gi.car.location.flat().dist(ball_loc_flat) > 92.75 and ball_loc.z < 200: controls.throttle = min(1.0, controls.throttle + 0.1) return Sequence([SingleStep(controls)])
def deltaC( info: Info, target: Vector3, jt ): # this controller takes a vector containing the required acceleration to reach a target, and then gets the car there c = SimpleControllerState() target_local = info.car_matrix.dot(target) if info.car.has_wheel_contact: # if on the ground if jt + 1.5 > info.game_time: # if we haven't jumped in the last 1.5 seconds c.jump = True else: c.jump = False jt = info.game_time else: c.steer, c.yaw, c.pitch, c.roll, error = default_pd(info, target_local, True) if target.length > 25: # stops boosting when "close enough" c.boost = True if error > 0.9: # don't boost if we're not facing the right way c.boost = False tsj = info.game_time - jt # time since jump if tsj < 0.215: c.jump = True elif tsj < 0.25: c.jump = False elif ( tsj >= 0.25 and tsj < 0.27 and target.z > 560 ): # considers a double-jump if we still need to go up a lot c.jump = True c.boost = False c.yaw = c.pitch = c.roll = 0 else: c.jump = False c.throttle = 1 return c, jt
def exampleController(agent, target_object): #target_object es un objeto tipo obj location = target_object.local_location controller_state = SimpleControllerState() angle_to_target = math.atan2(location.data[1], location.data[0]) angle_velocity = math.atan2(agent.me.velocity.data[1], agent.me.velocity.data[1]) #draw_debug(agent.renderer,location.data) draw_debug(agent, agent.renderer, target_object.location.data) current_speed = velocity2D(agent.me) #steering if abs(angle_to_target) < math.pi / 4: if agent.me.has_wheel_contact == True: controller_state.boost = True controller_state.handbrake = False else: controller_state.boost = False controller_state.handbrake = True controller_state.steer = sign(angle_to_target) * min( 1, abs(2 * angle_to_target)) controller_state.throttle = 1 #dodging if abs(angle_to_target) < math.pi / 2 and abs( angle_velocity) < math.pi / 3: dodging(agent, target_object, controller_state, angle_to_target) return controller_state
def arrive_on_time(position: Vector3, velocity: Vector3, target: Vector3, time_taken: float) -> SimpleControllerState: to_target = target - position distance = to_target.magnitude() average_speed = distance / (time_taken + 0.0000001) current_speed = velocity.magnitude() target_speed = (1 - SPEED_MATCH) * current_speed + SPEED_MATCH * average_speed controller = SimpleControllerState() if current_speed < target_speed: controller.throttle = 1 controller.boost = target_speed > 1410 else: controller.boost = False if current_speed - target_speed > 75: controller.throttle = -1 else: controller.throttle = 0 if current_speed < 100: controller.throttle = 0.2 return controller
def flyController(self, agent): controller_state = SimpleControllerState() location = toLocal(agent.ball, agent.me) angle_to_target = np.arctan2(location[1], location[0]) location_of_target = toLocal(agent.ball, agent.me) '''steering''' if angle_to_target > .1: controller_state.steer = 1 #controller_state.yaw = 1 controller_state.throttle = 1 if distance2D(agent.ball, agent.me) < 1000: controller_state.boost = True elif angle_to_target < -.1: controller_state.steer = -1 #controller_state.yaw = -1 controller_state.throttle = 1 if distance2D(agent.ball, agent.me) < 1000: controller_state.boost = True else: controller_state.steer = controller_state.yaw = 0 controller_state.throttle = .5 if angle_to_target < .1 and angle_to_target > -.1: controller_state.boost = True else: controller_state.boost = False #jump time_difference = time.time() - agent.start if time_difference > 2.2: agent.start = time.time() elif time_difference < .1 and distance2D( agent.ball, agent.me) < 1000 and agent.ball.location[2] > 100: controller_state.jump = True print("jump") else: controller_state.jump = False if agent.ball.location[2] > agent.me.location[ 2] and agent.me.rotation[0] < verticalangle2D( agent.ball.local_location, agent.me) and agent.me.rotation[1] < angle_to_radians( 0): #change angle, this is wrong controller_state.pitch = 1 # nose up elif agent.ball.location[2] < agent.me.location[ 2] and agent.me.rotation[0] > verticalangle2D( agent.ball.local_location, agent.me) and agent.me.rotation[1] > angle_to_radians(0): controller_state.pitch = -1 # nose down #updated code broke this # if(agent.ball.location[2] > agent.me.location[2]): # print("ball above car", verticalangle2D(agent.ball.local_location, agent.me)*180/np.pi) # if(agent.ball.location[2] < agent.me.location[2]): # print("ball below car", verticalangle2D(agent.ball.local_location, agent.me)*180/np.pi) return (controller_state)
def ground_controller(game_info, target_location): """Gives a set of commands to move the car along the ground toward a target location Attributes: target_location (Vec3): The local location the car wants to aim for Returns: SimpleControllerState: the set of commands to achieve the goal """ controller_state = SimpleControllerState() ball_direction = target_location distance = target_location.flat().length() angle = -math.atan2(ball_direction.y, ball_direction.x) if angle > math.pi: angle -= 2*math.pi elif angle < -math.pi: angle += 2*math.pi speed = 0.0 turn_rate = 0.0 r1 = 250 r2 = 1000 # adjust angle if angle > 0.02: turn_rate = -1.0 elif angle < -0.02: turn_rate = 1.0 else: turn_rate = 0 if distance <= r1: # if toward ball move forward if abs(angle) < math.pi / 4: speed = 1.0 else: # if not toward ball reverse, flips turn rate to adjust turn_rate = turn_rate * -1.0 speed = -1.0 # if far away, move at full speed forward elif distance >= r2: speed = 1.0 if game_info.me.velocity.length() < 2250: controller_state.boost = True # if mid range, adjust forward else: # adjust speed if game_info.me.velocity.length() < 2250: controller_state.boost = True if abs(angle) < math.pi / 2: speed = 1.0 else: speed = 0.5 controller_state.throttle = speed controller_state.steer = turn_rate controller_state.jump = False return controller_state
def offcenter(game_info=None, x_sign=None, persistent=None): controller_input = SimpleControllerState() current_state = game_info.me ball = game_info.ball team_sign = game_info.team_sign ball = game_info.ball #Set which boost we want based on team and side. if team_sign == 1: first_boost = 7 else: first_boost = 26 if abs(current_state.pos.x) > 150 and abs(current_state.pos.y) > 1100: #If we're not near the center-line of the field, boost towards the first small boost controller_input = GroundTurn( current_state, current_state.copy_state(pos=Vec3(0, -3000, 0))).input() controller_input.boost = 1 elif abs(current_state.pos.y) > 1500 and current_state.pos.z < 30: controller_input.jump = 1 controller_input.boost = 1 elif abs(current_state.pos.y) > 1000 and not current_state.double_jumped: #If we're far away, fast dodge to speed up. controller_input = CancelledFastDodge(current_state, Vec3(1, x_sign, 0)).input() elif abs(current_state.pos.y) > 355 and current_state.double_jumped: if persistent.aerial_turn.action == None: persistent.aerial_turn.initialize = True vector_to_ball = game_info.ball.pos - current_state.pos yaw_to_ball = atan2(vector_to_ball.y, vector_to_ball.x) target_rot = Orientation(pitch=pi / 3, yaw=yaw_to_ball, roll=0) persistent.aerial_turn.target_orientation = target_rot else: controller_input, persistent = aerial_rotation( game_info.dt, persistent) controller_input.boost = 1 elif abs(current_state.pos.y) > 355: controller_input = GroundTurn( current_state, current_state.copy_state(pos=Vec3(0, -team_sign * 100, 0))).input() else: controller_input = FrontDodge(current_state).input() return controller_input, persistent
def update(self): stateController = SimpleControllerState() if not self.firstJump: self.firstJump = True stateController.jump = True self.jumpTimer = time.time() elif self.firstJump and not self.secondJump: if time.time() - self.jumpTimer < self.firstJumpHold: stateController.jump = True elif time.time() - self.jumpTimer > self.firstJumpHold and time.time() - self.jumpTimer < self.firstJumpHold +.05: stateController.boost = True stateController.jump = False else: self.secondJump = True stateController.boost = True self.jumpTimer = time.time() else: if time.time() - self.jumpTimer < self.secondJumpHold: stateController.jump = True stateController.boost = True else: self.active = False self.jump = False #self.agent.activeState = flightSystems(self.agent) if time.time() - self.jumpTimer > 0.15: pitchAngle = math.degrees(self.agent.me.rotation[1]) y_vel = self.agent.me.avelocity[1] pitch = 0 if pitchAngle > 50: if y_vel > -.4: pitch = clamp(1,-1,-1 + abs(y_vel)) elif pitchAngle < 50: if y_vel < .4: pitch = clamp(1,-1,1 - abs(y_vel)) #print(pitchAngle) if y_vel > 1: pitch = -1 elif y_vel < -1: pitch = 1 stateController.pitch = pitch #print(math.degrees(self.agent.me.rotation[1])) return stateController
def diagonal(game_info=None, x_sign=None, persistent=None): current_state = game_info.me controls = SimpleControllerState() #Set which boost we want based on team and side. if x_sign == -1: first_boost = 11 else: first_boost = 10 if game_info.boosts[first_boost].is_active: #If we haven't taken the small boost yet, drive towards it controls = GroundTurn( current_state, current_state.copy_state(pos=Vec3(0, -1000, 0))).input() controls.boost = 1 elif abs(current_state.pos.y) > 1100 and current_state.wheel_contact: controls.jump = 1 controls.boost = 1 elif abs(current_state.pos.y) > 1100 and current_state.pos.z < 40: controls.jump = 1 controls.boost = 1 elif abs(current_state.pos.y) > 500 and not current_state.double_jumped: controls = CancelledFastDodge(current_state, Vec3(1, x_sign, 0)).input() elif abs(current_state.pos.y) > 250 and not current_state.wheel_contact: if persistent.aerial_turn.action == None: persistent.aerial_turn.initialize = True target_rot = Orientation(pitch=pi / 3, yaw=current_state.rot.yaw, roll=0) persistent.aerial_turn.target_orientation = target_rot else: controls, persistent = aerial_rotation(game_info.dt, persistent) controls.boost = 1 controls.steer = x_sign #Turn into the ball elif abs(current_state.pos.y) > 235: controls.throttle = 1 controls.boost = 1 controls.steer = x_sign else: controls = FrontDodge(current_state).input() return controls, persistent
def go_to_and_stop(data: Data, point, boost=True, slide=True): controller_state = SimpleControllerState() car_to_point = point - data.car.location point_rel = data.car.relative_location(point) dist = car_to_point.length() steer_correction_radians = point_rel.ang() set_normal_steering_and_slide(controller_state, steer_correction_radians, dist, slide) vel_f = data.car.velocity.proj_onto_size(data.car.orientation.front) ex_brake_dist = (vel_f**2) / 2800 if dist > ex_brake_dist * 1.05: controller_state.throttle = 1 if dist > ex_brake_dist * 1.5 and boost: if not data.car.is_on_wall and not controller_state.handbrake and data.car.velocity.length( ) < 2000: if is_heading_towards2(steer_correction_radians, car_to_point.length()): if data.car.orientation.up.ang_to(UP) < math.pi * 0.3: controller_state.boost = True elif dist < ex_brake_dist: controller_state.throttle = -1 return controller_state
def controller(self, agent): controller_state = SimpleControllerState() controller_state.pitch = 1 controller_state.throttle = -1 self.time_difference = agent.game_info.seconds_elapsed - self.start if self.time_difference <= 0.1: controller_state.jump = True elif 0.1 <= self.time_difference <= 0.15: controller_state.jump = False elif 0.15 <= self.time_difference <= 0.35: controller_state.jump = True elif 0.4 <= self.time_difference <= 1.75: controller_state.pitch = -1 if 1.2 <= self.time_difference: controller_state.throttle = 1 if 0.575 <= self.time_difference <= 1.2: controller_state.boost = True controller_state.roll = 1 if 0.7 <= self.time_difference <= 1.5: controller_state.yaw = .5 return controller_state
def go_nuts(gi: GameInfo) -> Sequence: ball_location = Vec3(gi.packet.game_ball.physics.location) if gi.car.location.flat().dist(ball_location.flat()) > 2000: # We're far away from the ball, let's try to lead it a little bit ball_prediction = gi.bot.get_ball_prediction_struct() # This can predict bounces, etc ball_in_future_location = Vec3(find_slice_at_time(ball_prediction, gi.packet.game_info.seconds_elapsed + 2).physics.location) target_location = ball_in_future_location.flat() + (ball_in_future_location.flat() - Vec3(gi.field.opponent_goal.location)).rescale(2200).flat() with Renderer(gi.bot.renderer) as r: r.draw_line_3d(ball_location, target_location, r.cyan()) else: target_location = ball_location + (ball_location - Vec3(gi.field.opponent_goal.location)).rescale(100) # Draw some things to help understand what the bot is thinking with Renderer(gi.bot.renderer) as r: r.draw_line_3d(gi.car.location, target_location, r.white()) r.draw_string_3d(gi.car.location, 1, 1, f'Speed: {gi.car.velocity.length():.1f}', r.white()) r.draw_rect_3d(target_location, 8, 8, True, r.cyan(), centered=True) controls = SimpleControllerState() controls.steer = gi.car.steer_toward_target(target_location) controls.throttle = 1.0 controls.boost = abs(controls.steer) < 0.2 and gi.car.velocity.length() < 2000 # controls.handbrake = abs(controls.steer) > 0.99 and gi.car.location.dist(ball_location) > 1000 return Sequence([SingleStep(controls)])
def get_output(self, game_tick_packet: GameTickPacket) -> SimpleControllerState: # Get the direction to the ball car = game_tick_packet.game_cars[self.index] ball_pos = game_tick_packet.game_ball.physics.location to_ball_x = ball_pos.x - car.physics.location.x to_ball_y = ball_pos.y - car.physics.location.y dist_to_ball = math.sqrt(to_ball_x**2 + to_ball_y**2) if dist_to_ball == 0: return SimpleControllerState() to_ball_x /= dist_to_ball to_ball_y /= dist_to_ball # How is the car aligned with the direction to the ball? yaw = float(car.physics.rotation.yaw) car_left_x = -math.sin(yaw) car_left_y = math.cos(yaw) dot_product = to_ball_x * car_left_x + to_ball_y * car_left_y # Act on the information above. controller_state = SimpleControllerState() controller_state.throttle = 1.0 controller_state.steer = min( 1, max(-1, self.steering_coefficient * dot_product)) controller_state.boost = abs(dot_product) < .1 controller_state.handbrake = abs(dot_product) > .9 return controller_state
def get_output(self, game_tick_packet: GameTickPacket) -> SimpleControllerState: controller_state = SimpleControllerState() controller_state.throttle = 1 controller_state.boost = True controller_state.steer = -1 if int(game_tick_packet.game_info.seconds_elapsed) % 2 == 0 else 1 self.renderer.draw_line_3d((0, 0, 50), (0, 0, 2000), self.renderer.orange()) return controller_state
def go_towards_point_with_timing(data: Data, point: Vec3, eta: float, slide=False, alpha=1.25): controller_state = SimpleControllerState() car_to_point = point - data.car.location point_rel = data.car.relative_location(point) steer_correction_radians = point_rel.ang() dist = car_to_point.length() set_normal_steering_and_slide(controller_state, steer_correction_radians, dist, slide) vel_f = data.car.velocity.proj_onto(car_to_point).length() avg_vel_f = dist / eta target_vel_f = rlmath.lerp(vel_f, avg_vel_f, alpha) if vel_f < target_vel_f: controller_state.throttle = 1.0 # boost? if target_vel_f > 1410: if not data.car.is_on_wall and not controller_state.handbrake and data.car.velocity.length( ) < 2000: if is_heading_towards2(steer_correction_radians, dist): if data.car.orientation.up.ang_to(UP) < math.pi * 0.3: controller_state.boost = True elif (vel_f - target_vel_f) > 80: controller_state.throttle = -0.6 elif (vel_f - target_vel_f) > 100: controller_state.throttle = -1.0 return controller_state
def exampleController(agent, target_object, target_speed): location = toLocal(target_object, agent.me) controller_state = SimpleControllerState() angle_to_ball = math.atan2(location.data[1], location.data[0]) current_speed = velocity2D(agent.me) #steering controller_state.steer = steer(angle_to_ball) #throttle if target_speed > current_speed: controller_state.throttle = 1.0 if target_speed > 1400 and agent.start > 2.2 and current_speed < 2250: controller_state.boost = True elif target_speed < current_speed: controller_state.throttle = 0 #dodging time_difference = time.time() - agent.start if time_difference > 2.2 and distance2D(target_object, agent.me) > ( velocity2D(agent.me) * 2.5) and abs(angle_to_ball) < 1.3: agent.start = time.time() elif time_difference <= 0.1: controller_state.jump = True controller_state.pitch = -1 elif time_difference >= 0.1 and time_difference <= 0.15: controller_state.jump = False controller_state.pitch = -1 elif time_difference > 0.15 and time_difference < 1: controller_state.jump = True controller_state.yaw = controller_state.steer controller_state.pitch = -1 return controller_state
def run(self, my_car, packet, agent): car_location = Vec3(my_car.physics.location) vertical_vel = my_car.physics.velocity.z controls = SimpleControllerState() controls.yaw = steer_toward_target( my_car, self.target, -my_car.physics.angular_velocity.z / 6) controls.boost = not (vertical_vel < 0 and car_location.z > 40 and self.tick < 20) controls.use_item = car_location.dist( Vec3(packet.game_ball.physics.location )) < 200 and relative_location( car_location, Orientation(my_car.physics.rotation), Vec3(packet.game_ball.physics.location)).z < 75 if self.tick == 0: controls.jump = True self.tick = 1 else: if self.tick <= 10: self.tick += 1 elif my_car.has_wheel_contact: agent.stack.pop() if vertical_vel < 0 and car_location.z > 40 and self.tick < 20: self.tick += 1 controls.pitch = 1 if vertical_vel < 0 and car_location.z < 40: controls.jump = True controls.pitch = -1 controls.yaw = 0 return controls
def exampleController(agent, target_object,target_speed): distance = distance2D(agent.me.location,target_object.location) if distance > 400: #print("switching to efficient") agent.state = efficientMover return efficientMover(agent,target_object,target_speed) controller_state = SimpleControllerState() controller_state.handbrake = False car_direction = get_car_facing_vector(agent.me) car_to_ball = agent.me.location - target_object.location steer_correction_radians = steer(car_direction.correction_to(car_to_ball)) current_speed = getVelocity(agent.me.velocity) #steering controller_state.steer = steer(steer_correction_radians) #throttle if target_speed > current_speed: controller_state.throttle = 1.0 if target_speed > 1400 and current_speed < 2250: controller_state.boost = True elif target_speed < current_speed: controller_state.throttle = 0 return controller_state
def reach_point_with_timing_and_vel(data: Data, point: Vec3, eta: float, vel_d: float, slide=False): controller_state = SimpleControllerState() car_to_point = point.flat() - data.car.location point_rel = data.car.relative_location(point) steer_correction_radians = point_rel.ang() dist = car_to_point.length() set_normal_steering_and_slide(controller_state, steer_correction_radians, dist, slide) vel_f = data.car.velocity.proj_onto(car_to_point).length() acc_f = -2 * (2 * vel_f * eta + eta * vel_d - 3 * dist) / (eta * eta) if abs(steer_correction_radians) > 1: acc_f = acc_f * steer_correction_radians * steer_correction_radians force = acc_f / (1410 - vel_f) controller_state.throttle = min(max(-1, force), 1) # boost? if force > 1: if not data.car.is_on_wall and not controller_state.handbrake and data.car.velocity.length( ) < 2000: if is_heading_towards2(steer_correction_radians, dist): if data.car.orientation.up.ang_to(UP) < math.pi * 0.3: controller_state.boost = True return controller_state
def action_goto(self, my_car, car_location, target_location): controller = SimpleControllerState() if target_location is None: return controller car_to_target = target_location - car_location # Find the direction of our car using the Orientation class car_orientation = Orientation(my_car.physics.rotation) car_direction = car_orientation.forward steer_correction_radians = find_correction(car_direction, car_to_target) if steer_correction_radians > 0: # Positive radians in the unit circle is a turn to the left. turn = -1.0 # Negative value for a turn to the left. self.action_display = "turn left" else: turn = 1.0 self.action_display = "turn right" controller.throttle = 1.0 controller.steer = turn controller.boost = True return controller
def exec(self, bot) -> SimpleControllerState: ct = time.time() - self._start_time controls = SimpleControllerState() controls.throttle = 1 car = bot.data.my_car # Target is allowed to be a function that takes bot as a parameter. Check what it is if callable(self.target): target = self.target(bot) else: target = self.target # To boost or not to boost, that is the question car_to_target = target - car.pos vel_p = proj_onto_size(car.vel, car_to_target) angle = angle_between(car_to_target, car.forward()) controls.boost = self.boost and angle < self._boost_ang_req and vel_p < self._max_speed # States of dodge (note reversed order) # Land on ground if ct >= self._t_finishing: self._almost_finished = True if car.on_ground: self.done = True else: bot.maneuver = RecoveryManeuver(bot) self.done = True return controls elif ct >= self._t_second_unjump: # Stop pressing jump and rotate and wait for flip is done pass elif ct >= self._t_aim: if ct >= self._t_second_jump: controls.jump = 1 # Direction, yaw, pitch, roll if self.target is None: controls.roll = 0 controls.pitch = -1 controls.yaw = 0 else: target_local = dot(car_to_target, car.rot) target_local.z = 0 direction = normalize(target_local) controls.roll = 0 controls.pitch = -direction.x controls.yaw = sign(car.rot.get(2, 2)) * direction.y # Stop pressing jump elif ct >= self._t_first_unjump: pass # First jump else: controls.jump = 1 return controls
def move_towards_point(self, my_car, point, boost: bool) -> SimpleControllerState: # Set the final controls based off of above decision making controls = SimpleControllerState() controls.steer = steer_toward_target(my_car, point) controls.throttle = 1.0 if boost: controls.boost = True return controls
def input(self): controller_input = SimpleControllerState() controller_input.throttle = 1 if self.boost == 1: controller_input.boost = 1 controller_input.handbrake = 1 controller_input.steer = self.direction return controller_input
def hermite_update(fieldstate): spline_pos, spline_d = h_spline.get( fieldstate.elapsed_time() - spline_start, spline_scale) goal_position = spline_pos error_vector = goal_position - fieldstate.car_location() correction_angle = fieldstate.car_facing_vector().correction_to( error_vector) goal_velocity = spline_d goal_angle = fieldstate.car_facing_vector().correction_to(spline_d) output = SimpleControllerState() #velocity PID vel_pid_out = vel_pid.update(goal_velocity.length(), fieldstate.car_velocity().length(), fieldstate.delta_time()) position_pid_out = position_pid.update(error_vector.length(), 0, fieldstate.delta_time()) output.throttle = clamp(vel_pid_out + position_pid_out, 1.0, -1.0) #heading PID heading_pid_out = heading_pid.update(-goal_angle * sign(output.throttle), 0, fieldstate.delta_time()) heading_abs_pid_out = heading_abs_pid.update( -correction_angle * sign(output.throttle), 0, fieldstate.delta_time()) output.steer = clamp(heading_pid_out + heading_abs_pid_out, 1.0, -1.0) # fi.write("{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{}\n".format( # fieldstate.elapsed_time(), # error_vector.length() * sign(Vector3.dot(error_vector, fieldstate.car_facing_vector().normalize())), # goal_position.x, # goal_position.y, # fieldstate.car_location().x, # fieldstate.car_location().y, # goal_velocity.length(), # fieldstate.car_velocity().length(), # math.atan2(spline_d.y, spline_d.x), # math.atan2(fieldstate.car_facing_vector().y, fieldstate.car_facing_vector().x), # vel_pid_out, # position_pid_out, # heading_pid_out, # heading_abs_pid_out, # output.throttle, # output.steer # )) if goal_velocity.length() > 1400: output.boost = True return output
def get_controller_state_from_actions( action: np.ndarray) -> SimpleControllerState: controls = action.clip(-1, 1) controller_state = SimpleControllerState() controller_state.pitch = controls[0] controller_state.yaw = controls[1] controller_state.roll = controls[2] controller_state.boost = bool(controls[3] >= 0) return controller_state
def get_controls(game_info, sub_state_machine): controls = SimpleControllerState() controls.throttle = 1 controls.boost = 1 controls.steer = -1 persistent = game_info.persistent return controls, persistent
def goto(target_location, target_speed, my_car, agent, packet): car_speed = Vec3(my_car.physics.velocity).length() distance = Vec3(my_car.physics.location).flat().dist( target_location.flat()) angle = Orientation( my_car.physics.rotation).forward.ang_to(target_location - Vec3(my_car.physics.location)) controls = SimpleControllerState() controls.steer = steer_toward_target(my_car, target_location, 0) controls.yaw = steer_toward_target(my_car, target_location, -my_car.physics.angular_velocity.z / 6) controls.throttle = cap(target_speed - car_speed, -1, 1) controls.boost = (target_speed > 1410 and abs(target_speed - car_speed) > 20 and angle < 0.3) controls.handbrake = angle > 2.3 controls.jump = (1 if my_car.physics.location.y >= 0 else -1) == ( 1 if agent.team == 1 else -1 ) and abs( my_car.physics.location.y) > 5000 and my_car.physics.location.z > 200 controls.use_item = Vec3(my_car.physics.location).dist( Vec3(packet.game_ball.physics.location)) < 200 and relative_location( Vec3(my_car.physics.location), Orientation( my_car.physics.rotation), Vec3(packet.game_ball.physics.location)).z < 75 if (abs(target_speed - car_speed) > 20 and angle < 0.3 and distance > 600) and ((target_speed > 1410 and my_car.boost == 0) or 700 < car_speed < 800): agent.stack.append(wavedash(target_location)) return controls