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 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 setHalfFlip(self): #_time = self.time #if _time - self.flipTimer >= 1.9: controls = [] timers = [] control_1 = SimpleControllerState() control_1.throttle = -1 control_1.jump = True controls.append(control_1) timers.append(0.125) controls.append(SimpleControllerState()) timers.append(self.fakeDeltaTime * 4) control_3 = SimpleControllerState() control_3.throttle = -1 control_3.pitch = 1 control_3.jump = True controls.append(control_3) timers.append(self.fakeDeltaTime * 4) control_4 = SimpleControllerState() control_4.throttle = -1 control_4.pitch = -1 control_4.roll = -.1 #control_4.jump = True controls.append(control_4) timers.append(0.5) self.activeState = Divine_Mandate(self, controls, timers) self.flipTimer = self.time
def waitController(agent, target, speed): controller_state = SimpleControllerState() loc = toLocal(target, agent.me) angle_to_target = math.atan2(loc.data[1], loc.data[0]) controller_state.steer = steer(angle_to_target) current_speed = velocity2D(agent.me) if current_speed < speed: controller_state.throttle = 1.0 elif current_speed - 50 > speed: controller_state.throttle = -1.0 else: controller_state.throttle = 0 time_diff = time.time() - agent.start if time_diff > 2.2 and distance2D(target,agent.me) > (velocity2D(agent.me)*2.3) and abs(angle_to_target) < 1 and current_speed < speed: agent.start = time.time() elif time_diff <= 0.1: controller_state.jump = True controller_state.pitch = -1 elif time_diff >= 0.1 and time_diff <= 0.15: controller_state.jump = False controller_state.pitch = -1 elif time_diff > 0.15 and time_diff < 1: controller_state.jump = True controller_state.yaw = controller_state.steer controller_state.pitch = -1 return controller_state
def frugalController(agent, target, speed): controller_state = SimpleControllerState() location = toLocal(target, agent.me) angle_to_target = math.atan2(location.data[1], location.data[0]) controller_state.steer = steer(angle_to_target) speed -= ((angle_to_target**2) * 300) current_speed = velocity1D(agent.me).data[1] if current_speed < speed: controller_state.throttle = 1.0 elif current_speed - 50 > speed: controller_state.throttle = -1.0 else: controller_state.throttle = 0 time_difference = time.time() - agent.start if time_difference > 2.2 and distance2D( target, agent.me) > (velocity2D(agent.me) * 2.3) and abs( angle_to_target ) < 0.9 and current_speed < speed and current_speed > 220: 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 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 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 exampleController(self, target_object, target_speed): location = target_object.local_location controller_state = SimpleControllerState() angle_to_ball = math.atan2(location.data[1], location.data[0]) current_speed = velocity2D(self.me) #team team = sign(self.team) # if team<=0: #blue #try to get the ball to orange goal #else: #orange #try to get the ball to blue goal #steering if angle_to_ball > 0.1: controller_state.steer = controller_state.yaw = 1 elif angle_to_ball < -0.1: controller_state.steer = controller_state.yaw = -1 else: controller_state.steer = controller_state.yaw = 0 #powersliding if angle_to_ball > 0.8: controller_state.handbrake = True elif angle_to_ball < -0.8: controller_state.handbrake = True else: controller_state.handbrake = False #throttle if target_speed > current_speed: controller_state.throttle = 1.0 if target_speed > 1400 and self.start > 2.2 and current_speed < 2250: controller_state.boost = True elif target_speed < current_speed: controller_state.throttle = 0 #dodging front only time_difference = time.time() - self.start if time_difference > 2.2 and distance2D( target_object.location, self.me.location) > 1000 and abs(angle_to_ball) < 1.3: self.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 shotController(self, agent): controller_state = SimpleControllerState() goal_location = toLocal( [0, -sign(agent.team) * FIELD_LENGTH / 2, 0], agent.me) #100 is arbitrary since math is in 2D still goal_angle = np.arctan2(goal_location[1], goal_location[0]) #print(goal_angle * 180 / np.pi) location = toLocal(agent.ball, agent.me) angle_to_target = np.arctan2(location[1], location[0]) target_speed = velocity2D( agent.ball) + (distance2D(agent.ball, agent.me) / 1.5) current_speed = velocity2D(agent.me) #steering if angle_to_target > .1: controller_state.steer = controller_state.yaw = 1 elif angle_to_target < -.1: controller_state.steer = controller_state.yaw = -1 else: controller_state.steer = controller_state.yaw = 0 #throttle if angle_to_target >= 1.4: target_speed -= 1400 else: if (target_speed > 1400 and target_speed > current_speed and agent.start > 2.2 and current_speed < 2250): controller_state.boost = True if target_speed > current_speed: controller_state.throttle = 1.0 elif target_speed < current_speed: controller_state.throttle = 1 #dodging time_difference = time.time() - agent.start if time_difference > 2.2 and distance2D(agent.ball, agent.me) <= 270: agent.start = time.time() elif time_difference <= .1: controller_state.jump = True controller_state.pitch = -1 elif time_difference >= .1 and time_difference <= .15: controller_state.jump = False controller_state.pitch = -1 elif time_difference > .15 and time_difference < 1: controller_state.jump = True controller_state.yaw = math.sin(goal_angle) controller_state.pitch = -abs(math.cos(goal_angle)) return controller_state
def calcController(agent, target_object, target_speed): goal_local = toLocal([0, -sign(agent.team)*FIELD_LENGTH/2, 100], agent.me) goal_angle = math.atan2(goal_local.data[1], goal_local.data[0]) loc = toLocal(target_object, agent.me) controller_state = SimpleControllerState() angle_to_targ = math.atan2(loc.data[1],loc.data[0]) current_speed = velocity2D(agent.me) distance = distance2D(target_object, agent.me) #steering controller_state.steer = steer(angle_to_targ) r = radius(current_speed) slowdown = (Vector3([0,sign(target_object.data[0])*(r+40),0])-loc.flatten()).magnitude() / cap(r*1.5,1,1200) target_speed = cap(current_speed*slowdown,0,current_speed) # throttle if agent.ball.location.data[0] == 0 and agent.ball.location.data[1] == 0: controller_state.throttle, controller_state.boost = 1, True else: controller_state.throttle, controller_state.boost = throttle(target_speed,current_speed) #dodging time_diff = time.time() - agent.start if (time_diff > 2.2 and distance <= 150) or (time_diff > 4 and distance >= 1000) and not kickoff(agent): agent.start = time.time() elif time_diff <= 0.1: controller_state.jump = True controller_state.pitch = -1 elif time_diff >= 0.1 and time_diff <= 0.15: controller_state.jump = False controller_state.pitch = -1 elif time_diff > 0.15 and time_diff < 1: controller_state.jump = True controller_state.yaw = math.sin(goal_angle) controller_state.pitch = -abs(math.cos(goal_angle)) if not dodging(agent) and not agent.me.grounded: target = agent.me.velocity.normalize() targ_local = to_local(target.scale(500), agent.me) return recoveryController(agent, targ_local) return controller_state
def follow_controller(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) pitch = agent.me.location.data[0] % math.pi roll = agent.me.location.data[2] % math.pi # Turn dem wheels controller_state.steer = cap(angle_to_ball * 5, -1, 1) print(velocity2D(agent.me)) if abs(angle_to_ball) > (math.pi / 3.): controller_state.handbrake = True else: controller_state.handbrake = False # throttle if target_speed > current_speed: controller_state.throttle = 1.0 if target_speed > 1400 and agent.start > 2.2 and current_speed < 2250 and abs( angle_to_ball) < (math.pi / 3.): controller_state.boost = True elif target_speed < current_speed: controller_state.throttle = 0 # doging time_difference = time.time() - agent.start if time_difference > 2.2 and distance2D( target_object, agent.me) > 1000 and abs(angle_to_ball) < 1.3 and velocity2D( agent.me) > 1200: 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 # print("target: " + str(target_speed) + ", current: " + str(current_speed)) return controller_state
def fix_orientation(data: Data, point=None): controller = SimpleControllerState() strength = 0.22 ori = data.car.orientation if point is None and data.car.velocity.flat().length2() != 0: point = data.car.location + data.car.velocity.flat().rescale(500) pitch_error = -ori.pitch * strength controller.pitch = data.agent.pid_pitch.calc(pitch_error) roll_error = -ori.roll * strength controller.roll = data.agent.pid_roll.calc(roll_error) if point is not None: # yaw rotation can f up the other's so we scale it down until we are more confident about landing on the wheels car_to_point = point - data.car.location yaw_error = ori.front.ang_to_flat(car_to_point) * strength * 1.5 land_on_wheels01 = 1 - ori.up.ang_to(UP) / (math.pi * 2) controller.yaw = data.agent.pid_yaw.calc(yaw_error) * (land_on_wheels01 **6) # ! controller.throttle = 1 return controller
def get_output(self, packet: GameTickPacket) -> Optional[SimpleControllerState]: controller = SimpleControllerState() bot = PhysicsObject(packet.game_cars[self.agent.index].physics) if packet.game_info.seconds_elapsed > self.next_dodge_time: controller.jump = True # Calculate pitch and roll based on target and bot position # Correct yaw from (0 to pi to -pi to 0), to (0 to 2pi). # Then rotate circle by pi/2 degrees. Then flip circle vertically. yaw = bot.rotation.z if yaw < 0: yaw += 2 * math.pi yaw -= math.pi / 2 if yaw < 0: yaw += 2 * math.pi yaw = 2 * math.pi - yaw direction_to_target = (self.target - bot.location).normalised() angle_to_target = math.atan2(direction_to_target.y, direction_to_target.x) angle = angle_to_target - yaw controller.pitch = -math.cos(angle) controller.roll = math.sin(angle) if self.on_second_jump: return None else: self.on_second_jump = True self.next_dodge_time = packet.game_info.seconds_elapsed + self.dodge_time else: controller.jump = False return controller
def shotController(agent, target_object, target_speed): goal_local = toLocal([0, -sign(agent.team) * FIELD_LENGTH / 2, 100], agent.me) goal_angle = math.atan2(goal_local.data[1], goal_local.data[0]) location = toLocal(target_object, agent.me) controller_state = SimpleControllerState() angle_to_target = math.atan2(location.data[1], location.data[0]) current_speed = velocity2D(agent.me) #steering if angle_to_target > 0.1: controller_state.steer = controller_state.yaw = 1 elif angle_to_target < -0.1: controller_state.steer = controller_state.yaw = -1 else: controller_state.steer = controller_state.yaw = 0 #throttle if angle_to_target >= 1.4: target_speed -= 1400 else: if target_speed > 1400 and target_speed > current_speed and agent.start > 2.2 and current_speed < 2250: controller_state.boost = True if target_speed > current_speed: controller_state.throttle = 1.0 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) <= 270: 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 = math.sin(goal_angle) controller_state.pitch = -abs(math.cos(goal_angle)) return controller_state
def simple_front_flip_chain(): first_controller = SimpleControllerState() second_controller = SimpleControllerState() third_controller = SimpleControllerState() first_controller.jump = True first_duration = 0.1 second_controller.jump = False second_controller.pitch = -1 second_duration = 0.1 third_controller.jump = True third_controller.pitch = -1 third_duration = 0.1 return Action_chain([first_controller,second_controller,third_controller],[first_duration,second_duration, third_duration])
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 shotController(agent, target_object, target_speed): goal_local = toLocal([0, -sign(agent.team)*FIELD_LENGTH/2, 100], agent.me) goal_angle = math.atan2(goal_local.data[1], goal_local.data[0]) loc = toLocal(target_object, agent.me) controller_state = SimpleControllerState() angle_to_targ = math.atan2(loc.data[1],loc.data[0]) current_speed = velocity2D(agent.me) distance = distance2D(target_object, agent.me) #steering controller_state.steer = steer(angle_to_targ) # throttle if agent.ball.location.data[0] == 0 and agent.ball.location.data[1] == 0: controller_state.throttle, controller_state.boost = 1, True else: controller_state.throttle, controller_state.boost = throttle(target_speed,current_speed) time_diff = time.time() - agent.start #dodging time_diff = time.time() - agent.start if (time_diff > 2.2 and distance <= 270) or (time_diff > 4 and distance >= 1000): agent.start = time.time() elif time_diff <= 0.1: controller_state.jump = True controller_state.pitch = -1 elif time_diff >= 0.1 and time_diff <= 0.15: controller_state.jump = False controller_state.pitch = -1 elif time_diff > 0.15 and time_diff < 1: controller_state.jump = True controller_state.yaw = math.sin(goal_angle) controller_state.pitch = -abs(math.cos(goal_angle)) if not dodging(agent) and not agent.me.grounded: target = agent.me.velocity.normalize() targ_local = to_local(target.scale(500), agent.me) return recoveryController(agent, targ_local) return controller_state
def update(self): controller_state = SimpleControllerState() if not self.firstJump: controller_state.throttle = -1 controller_state.jump = True controller_state.pitch = 1 self.firstJump = True self.jumpStart = time.time() return controller_state elif self.firstJump and not self.secondJump: jumpTimer = time.time() - self.jumpStart controller_state.throttle = -1 controller_state.pitch = 1 controller_state.jump = False if jumpTimer < 0.12: controller_state.jump = True if jumpTimer > 0.15: controller_state.jump = True self.jumpStart = time.time() self.secondJump = True return controller_state elif self.firstJump and self.secondJump: timer = time.time() - self.jumpStart if timer < 0.15: controller_state.throttle = -1 controller_state.pitch = 1 else: controller_state.pitch = -1 controller_state.throttle = 1 controller_state.roll = 1 if timer > .8: controller_state.roll = 0 if timer > 1.15: self.active = False return controller_state else: print( "halfFlip else conditional called in update. This should not be happening" )
def chase_controller(agent, target_object, target_speed): #note target location is an obj location = toLocal(target_object, agent.car) controller_state = SimpleControllerState() angle_to_ball = math.atan2(location.data[1], location.data[0]) current_speed = velocity2D(agent.car) ball_path = agent.get_ball_prediction_struct( ) #next 6 seconds of ball's path print(bal_path[1]) #to steer if angle_to_ball > 0.1: controller_state.steer = controller_state.yaw = 1 elif angle_to_ball < -0.1: controller_state.steer = controller_state.yaw = -1 else: controller_state.steer = controller_state.yaw = 0 #adjust speed 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 #techniquing time_diff = time.time() - agent.start #time since last technique if time_diff > 2.2 and distance2D( target_object.location, agent.car.location) > 1000 and abs(angle_to_ball) < 1.3: agent.start = time.time() elif time_diff <= 0.1: controller_state.jump = True controller_state.pitch = -1 elif time_diff >= 0.1 and time_diff <= 0.15: controller_state.jump = False elif time_diff > 0.15 and time_diff < 1: controller_state.jump = True controller_state.yaw = controller_state.steer controller_state.pitch = -1 return controller_state
def shot_controller(agent, target_object, target_speed): #note target location is an obj local_goal_location = toLocal([0, FIELD_LENGTH / 2, 100], agent.car) goal_angle = math.atan2(local_goal_location.data[1], local_goal_location.data[0]) location = toLocal(target_object, agent.car) controller_state = SimpleControllerState() angle_to_target = math.atan2(location.data[1], location.data[0]) current_speed = velocity2D(agent.car) #to steer if angle_to_target > 0.1: controller_state.steer = controller_state.yaw = 1 elif angle_to_target < -0.1: controller_state.steer = controller_state.yaw = -1 else: controller_state.steer = controller_state.yaw = 0 #adjust speed 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 #techniquing time_diff = time.time() - agent.start #time since last technique if time_diff > 2.2 and distance2D(target_object, agent.car) > 270: agent.start = time.time() elif time_diff <= 0.1: controller_state.jump = True controller_state.pitch = -1 elif time_diff >= 0.1 and time_diff <= 0.15: controller_state.jump = False controller_state.pitch = -1 elif time_diff > 0.15 and time_diff < 1: controller_state.jump = True controller_state.yaw = math.sin(goal_angle) controller_state.pitch = -abs(math.cos(goal_angle)) return controller_state
def shotController(agent, target_object, target_speed, goal=None): if goal == None: goal = [0, -sign(agent.team) * FIELD_LENGTH / 2, 100] goal_local = toLocal(goal, agent.me) goal_angle = math.atan2(goal_local.data[1], goal_local.data[0]) location = toLocal(target_object, agent.me) controller_state = SimpleControllerState() angle_to_target = math.atan2(location.data[1], location.data[0]) current_speed = velocity1D(agent.me).data[1] #velocity2D(agent.me) #steering controller_state.steer = steer(angle_to_target) #throttle if target_speed > 1400 and target_speed > current_speed and agent.start > 2.5 and current_speed < 2250 and agent.me.grounded == True: controller_state.boost = True if target_speed > current_speed: controller_state.throttle = 1.0 elif target_speed < current_speed: controller_state.throttle = -1.0 #dodging closing = distance2D(target_object, agent.me) / cap( -dpp(target_object, agent.ball.velocity, agent.me.location, agent.me.velocity), 1, 2300) time_difference = time.time() - agent.start if ballReady( agent) and time_difference > 2.2 and closing <= 0.8 and distance2D( agent.me, target_object) < 200: 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 = math.sin(goal_angle) controller_state.pitch = -abs(math.cos(goal_angle)) return controller_state
def take_shot_controller(agent, target_object, target_speed): goal_local = toLocation([0, -sign(agent.team) * FIELD_LENGTH / 2, 100]) goal_angle = math.atan2(goal_local.data[1], goal_local.data[0]) pitch = agent.me.location.data[0] % math.pi roll = agent.me.location.data[2] % math.pi location = toLocation(target_object) controller_state = SimpleControllerState() angle_to_target = math.atan2(location.data[1], location.data[0]) current_speed = velocity2D(agent.me) controller_state.steer = cap(angle_to_target * 5, -1, 1) # 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 # doging time_difference = time.time() - agent.start if time_difference > 2.2 and abs(angle_to_target) < 1.3 and velocity2D( agent.me) > 1200 and distance2D(target_object, agent.me) < 1000: 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 = cap(math.sin(goal_angle) / math.pi, -1, 1) controller_state.pitch = -1 # print("target: " + str(target_speed) + ", current: " + str(current_speed)) return controller_state
def to_simple_controller_state(self): controls = SimpleControllerState() controls.throttle = self.throttle controls.steer = self.steer controls.yaw = self.yaw controls.pitch = self.pitch controls.roll = self.roll controls.boost = self.boost controls.jump = self.jump controls.handbrake = self.handbrake return controls
def recoveryController(agent, local): #accepts agent, the agent's controller, and a target (in local coordinates) controller_state = SimpleControllerState() turn = math.atan2(local.data[1],local.data[0]) up = toLocal(agent.me.location + Vector3([0,0,100]), agent.me) target = [math.atan2(up.data[1],up.data[2]), math.atan2(local.data[2],local.data[0]), turn] #determining angles each axis must turn controller_state.steer = steerPD(turn, 0) controller_state.yaw = steerPD(target[2],-agent.me.rvelocity.data[2]/5) controller_state.pitch = steerPD(target[1],agent.me.rvelocity.data[1]/5) controller_state.roll = steerPD(target[0],agent.me.rvelocity.data[0]/5) return controller_state
def speedDodgeController(agent, target_object, goal_angle): controller_state = SimpleControllerState() #dodging time_diff = time.time() - agent.start if time_diff > 2.2: agent.start = time.time() elif time_diff <= 0.1: controller_state.jump = True controller_state.pitch = -1 elif time_diff >= 0.1 and time_diff <= 0.15: controller_state.jump = False controller_state.pitch = -1 elif time_diff > 0.15 and time_diff < 1: controller_state.jump = True controller_state.yaw = math.sin(goal_angle) controller_state.pitch = -abs(math.cos(goal_angle)) return controller_state
def getSensible_thingToCONTROL(magicWariable): ThisISTHE_controller = SimpleControllerState() ThisISTHE_controller.throttle = magicWariable[magicWariable[0][0]] ThisISTHE_controller.steer = magicWariable[magicWariable[0][1]] ThisISTHE_controller.pitch = magicWariable[magicWariable[0][2]] ThisISTHE_controller.yaw = magicWariable[magicWariable[0][3]] ThisISTHE_controller.roll = magicWariable[magicWariable[0][4]] ThisISTHE_controller.jump = magicWariable[magicWariable[0][5]] ThisISTHE_controller.boost = magicWariable[magicWariable[0][6]] ThisISTHE_controller.handbrake = magicWariable[magicWariable[0][7]] return ThisISTHE_controller
def update(self): controller_state = SimpleControllerState() jump = flipHandler(self.agent, self.flip_obj) if jump: if self.targetCode == 1: controller_state.pitch = -1 controller_state.steer = 0 controller_state.throttle = 1 elif self.targetCode == 0: ball_local = toLocal(self.agent.ball.location, self.agent.me) ball_angle = math.atan2(ball_local.data[1], ball_local.data[0]) controller_state.jump = True controller_state.yaw = math.sin(ball_angle) pitch = -math.cos(ball_angle) controller_state.pitch = pitch if pitch > 0: controller_state.throttle = -1 else: controller_state.throttle = 1 elif self.targetCode == 2: controller_state.pitch = 0 controller_state.steer = 0 controller_state.yaw = 0 elif self.targetCode == 3: controller_state.pitch = 1 controller_state.steer = 0 controller_state.throttle = -1 elif self.targetCode == -1: controller_state.pitch = 0 controller_state.steer = 0 controller_state.throttle = 0 controller_state.jump = jump controller_state.boost = False if self.flip_obj.flipDone: self.active = False return controller_state
def exec(self, bot) -> SimpleControllerState: man_ct = bot.info.time - self.maneuver_start_time controls = SimpleControllerState() car = bot.info.my_car vel_f = proj_onto_size(car.vel, car.forward) # Reverse a bit if vel_f > -50 and man_ct < 0.3: controls.throttle = -1 self.halfflip_start_time = bot.info.time return controls ct = bot.info.time - self.halfflip_start_time # States of jump if ct >= self._t_finishing: self._almost_finished = True controls.throttle = 1 controls.boost = self.boost if car.on_ground: self.done = True else: bot.maneuver = RecoveryManeuver() self.done = True elif ct >= self._t_roll_begin: controls.pitch = -1 controls.roll = 1 elif ct >= self._t_second_jump_end: controls.pitch = -1 elif ct >= self._t_second_jump_begin: controls.jump = 1 controls.pitch = 1 elif ct >= self._t_first_jump_end: controls.pitch = 1 else: controls.jump = 1 controls.throttle = -1 controls.pitch = 1 return controls
def deltaC(agent, target): c = SimpleControllerState() target = target # - agent.me.velocity target_local = toLocal(agent.me.location + target, agent.me) angle_to_target = math.atan2(target_local.data[1], target_local.data[0]) pitch_to_target = math.atan2(target_local.data[2], target_local.data[0]) if agent.me.grounded: if agent.jt + 1.5 > time.time(): c.jump = True else: c.jump = False agent.jt = time.time() else: c.yaw = steerPD(angle_to_target, -agent.me.rvelocity.data[1] / 4) c.pitch = steerPD(pitch_to_target, agent.me.rvelocity.data[0] / 4) if target.magnitude() > 10: c.boost = True if abs(pitch_to_target) + abs(angle_to_target) > 0.9: c.boost = False else: top = toLocal([ agent.me.location.data[0], agent.me.location.data[1], agent.me.location.data[2] + 1000 ], agent.me) roll_to_target = math.atan2(top.data[1], top.data[2]) c.roll = steerPD(roll_to_target, agent.me.rvelocity.data[2] * 0.5) tsj = time.time() - agent.jt if tsj < 0.215: c.jump = True elif tsj < 0.25: c.jump = False elif tsj >= 0.25 and tsj < 0.27 and target.data[2] > 560: c.jump = True c.boost = False c.yaw = 0 c.pitch = 0 c.roll = 0 else: c.jump = False return c