def step(self, packet: GameTickPacket, drone: Drone, index: int): # Get centre of small circle. direction_angle = (math.pi / 4) + ((math.pi / 2) * (index // 16)) centre = vec3(dot(rotation(direction_angle), vec2( 1, 0))) * self.big_radius centre[2] = self.height # Angle for the small circle. # Wraps nicely around the small circle. t = self.time_since_start + 2.5 if t > 2 * math.pi: t = 2 * math.pi angle = (t / 16) * (index % 16 - 8) angle += (2 * math.pi / 4) * (index // 16) + (math.pi / 4) target = vec3(dot(rotation(angle), vec2(self.small_radius, 0))) target += centre # Hover controls. drone.hover.up = normalize(drone.position - centre) drone.hover.target = target drone.hover.step(self.dt) drone.controls = drone.hover.controls # If any bot got lost, now they have a chance to recover. if drone.on_ground: drone.controls.jump = True else: drone.controls.jump = False
def step(self, packet: GameTickPacket, drone: Drone, index: int): self.finished = (100 + self.big_radius - self.time_since_start * self.speed) <= 0 # Get centre of small circle. direction_angle = (math.pi / 4) + ((math.pi / 2) * (index // 16)) centre = vec3(dot(rotation(direction_angle), vec2(1, 0))) # Crossing action. centre *= (self.big_radius - self.time_since_start * self.speed) centre[2] = self.height # Angle for the small circle. angle = (2 * math.pi / 16) * (index % 16) angle += (2 * math.pi / 4) * (index // 16 - 1) angle += self.time_since_start * self.spin target = vec3(dot(rotation(angle), vec2(self.small_radius, 0))) target += centre # Different heights. target[2] += (index // 16 - 2) * self.height_diff # Hover controls. drone.hover.up = normalize(drone.position - centre) drone.hover.target = target drone.hover.step(self.dt) drone.controls = drone.hover.controls
def predict_car_drive(self, index, time_limit=2.0, dt=1 / 60) -> List[vec3]: """Simple prediction of a driving car assuming no acceleration.""" car = self.cars[index] time_steps = int(time_limit / dt) speed = norm(car.velocity) ang_vel_z = car.angular_velocity[2] # predict circular path if ang_vel_z != 0 and car.on_ground: radius = speed / ang_vel_z centre = car.position - cross(normalize(xy(car.velocity)), vec3(0, 0, 1)) * radius centre_to_car = vec2(car.position - centre) return [ vec3(dot(rotation(ang_vel_z * dt * i), centre_to_car)) + centre for i in range(time_steps) ] # predict straight path return [ car.position + car.velocity * dt * i for i in range(time_steps) ]
def step(self, packet: GameTickPacket, drone: Drone, index: int): if drone.position[2] < 25: drone.since_jumped = 0.0 # Go forward drone.controls.throttle = 1.0 if abs( drone.velocity[1]) < 500 else 0.01 # If near half-line if abs(drone.position[1]) < 200: drone.controls.jump = True else: drone.since_jumped += self.dt height = 50 + drone.since_jumped * 150 angle = 1.0 + drone.since_jumped * 1.2 if index % 2 == 0: angle += math.pi rot = rotation(angle) v = vec3(dot(rot, vec2(1, 0))) drone.hover.target = v * self.radius drone.hover.target[2] = height drone.hover.up = normalize(drone.position) drone.hover.step(self.dt) drone.controls = drone.hover.controls
def set_drone_states(self, drones: List[Drone]): for i, drone in enumerate(drones): angle = i * math.pi * 2 / len(drones) rot = rotation(angle) v = vec3(dot(rot, vec2(1, 0))) drone.position = v * self.radius + self.center drone.orientation = look_at(v * -1, vec3(0, 0, 1)) drone.velocity = vec3(0, 0, 0) drone.angular_velocity = vec3(0, 0, 0)
def set_drone_states(self, drones: List[Drone]): for i, drone in enumerate(drones): angle = (2 * math.pi / 64) * i drone.position = vec3(dot(rotation(angle), vec2(self.radius, 0))) drone.position[2] = self.height drone.velocity = vec3(0, 0, 0) drone.orientation = euler_to_rotation( vec3(math.pi / 2, angle, math.pi)) drone.angular_velocity = vec3(0, 0, 0)
def step(self, packet: GameTickPacket, drone: Drone, index: int): # Calculate shift direction. direction_angle = (math.pi / 4) + ((math.pi / 2) * (index // 16)) direction = vec3(dot(rotation(direction_angle), vec2(1, 0))) # Shift in one direction. angle = (2 * math.pi / 64) * index target = vec3(dot(rotation(angle), vec2(self.start_radius, 0))) target += direction * (self.end_radius - self.start_radius) * ( self.time_since_start / self.duration) target[2] = self.height target = (target + drone.position) / 2 # Hover controls. drone.hover.up = normalize(drone.position) drone.hover.target = target drone.hover.step(self.dt) drone.controls = drone.hover.controls
def step(self, packet: GameTickPacket, drone: Drone, index: int): radius = 1050 + 150 * self.time_since_start angle = math.pi + self.time_since_start * (math.pi / 5) angle += (2 * math.pi / 64) * index target = vec3(dot(rotation(angle), vec2(radius, 0))) target[2] = self.height drone.hover.up = normalize(-1 * xy(drone.position)) drone.hover.target = target drone.hover.step(self.dt) drone.controls = drone.hover.controls
def step(self, packet: GameTickPacket, drone: Drone, index: int): if drone.start_pos is None: drone.start_pos = drone.position # spin = (index % 16 - 8) * 0.01 # Unwind helix. # rotation = axis_to_rotation(vec3(0, 0, spin)) # position_on_circle = normalize(xy(drone.position)) * self.start_radius # drone.hover.target = dot(rotation, position_on_circle) # drone.hover.target[2] = drone.start_pos[2] # drone.hover.step(self.dt) # drone.controls = drone.hover.controls current_radius = norm(vec2(drone.position)) desired_angle = (2 * math.pi / 64) * index current_angle = math.atan2(drone.position[1], drone.position[0]) if current_angle < 0.0: current_angle += 2 * math.pi # only positive angles # Expand radius. if current_radius < self.radius - 150: direction_angle = (math.pi / 4) + ((math.pi / 2) * (index // 16)) direction = vec3(dot(rotation(direction_angle), vec2(1, 0))) target = drone.position + direction * 200 target[2] = drone.start_pos[2] # Get to correct angle. elif abs(desired_angle - current_angle) > 0.05: target = vec3(dot(rotation(desired_angle), vec2(self.radius, 0))) target[2] = drone.start_pos[2] # Get to correct height. else: target = vec3(dot(rotation(desired_angle), vec2(self.radius, 0))) target[2] = self.height drone.hover.up = normalize(drone.position) drone.hover.target = target drone.hover.step(self.dt) drone.controls = drone.hover.controls
def step(self, packet: GameTickPacket, drones: List[Drone]): s = int(math.sqrt(len(drones))) # Side length for i, drone in enumerate(drones): # Get grid pos. x = (i // s) - (s - 1) / 2 y = (i % s) - (s - 1) / 2 # Get height from func. z = 800 + self.func(x, y) # 800 is base height drone.hover.target = vec3(x * self.spacing, y * self.spacing, z) rot = rotation(self.rotation_speed * self.time_since_start * 2) drone.hover.up = vec3(dot(rot, vec2(1, 0))) drone.hover.step(self.dt) drone.controls = drone.hover.controls
def set_drone_states(self, drones: List[Drone]): for i, drone in enumerate(drones): angle = math.pi / 2 rot = rotation(angle) v = vec3(dot(rot, vec2(1, 0))) v[2] = 0.25 if i % 2 == 0: drone.position = self.center + vec3( math.floor(i / 2) * 250, math.floor(i / 2) * -250, 1750) else: drone.position = self.center + vec3( (1 + math.floor(i / 2)) * -250, (1 + math.floor(i / 2)) * -250, 1750) print(i, drone.position)
def step(self, packet: GameTickPacket, drone: Drone, index: int): angle = (2 * math.pi / 64) * index target = vec3(dot(rotation(angle), vec2(self.radius, 0))) target[2] = self.height # Hover controls drone.hover.target = target drone.hover.up = normalize(drone.position) drone.hover.step(self.dt) drone.controls = drone.hover.controls # If any bot got lost, now they have a chance to recover. if drone.on_ground: drone.controls.jump = True else: drone.controls.jump = False
def shooting_target(agent): """"Method that gives the target for the shooting strategy""" ball = agent.info.ball car = agent.info.my_car car_to_ball = ball.location - car.location backline_intersect = line_backline_intersect(agent.their_goal.center[1], vec2(car.location), vec2(car_to_ball)) if abs(backline_intersect) < 700: goal_to_ball = normalize(car.location - ball.location) error = 0 else: # Right of the ball if -500 > backline_intersect: target = agent.their_goal.corners[3] + vec3(400, 0, 0) # Left of the ball elif backline_intersect > 500: target = agent.their_goal.corners[2] - vec3(400, 0, 0) goal_to_ball = normalize(ball.location - target) # Subtract the goal to car vector difference = goal_to_ball - normalize(car.location - target) error = cap(abs(difference[0]) + abs(difference[1]), 0, 5) goal_to_ball_2d = vec2(goal_to_ball[0], goal_to_ball[1]) test_vector_2d = dot(rotation(0.5 * math.pi), goal_to_ball_2d) test_vector = vec3(test_vector_2d[0], test_vector_2d[1], 0) distance = cap( (40 + distance_2d(ball.location, car.location) * (error**2)) / 1.8, 0, 4000) location = ball.location + vec3( (goal_to_ball[0] * distance), goal_to_ball[1] * distance, 0) # this adjusts the target based on the ball velocity perpendicular # to the direction we're trying to hit it multiplier = cap(distance_2d(car.location, location) / 1500, 0, 2) distance_modifier = cap( dot(test_vector, ball.velocity) * multiplier, -1000, 1000) location += vec3(test_vector[0] * distance_modifier, test_vector[1] * distance_modifier, 0) # another target adjustment that applies if the ball is close to the wall extra = 3850 - abs(location[0]) if extra < 0: location[0] = cap(location[0], -3850, 3850) location[1] = location[1] + (-sign(agent.team) * cap(extra, -800, 800)) return location
def step(self, packet: GameTickPacket, drones: List[Drone]): for drone in drones: drone.hover.up = normalize(drone.position) for i, layer in enumerate(self.layers): if drone.id in layer: # Calculate radius if self.time_since_start < self.radius_shrink_start: radius = 2000 elif self.time_since_start < self.radius_shrink_start + self.radius_shrink_duration: diff = 2000 - self.radii[i] radius = 2000 - diff * ( (self.time_since_start - self.radius_shrink_start) / self.radius_shrink_duration) else: radius = self.radii[i] # Calculate xy position if self.time_since_start > self.recirculation_start: a = layer.index(drone.id) angle = a * math.pi * 2 / len(layer) rot = rotation(angle) pos_xy = vec3(dot(rot, vec2(1, 0))) else: pos_xy = xy(drone.position) # Combine xy and radius drone.hover.target = normalize(pos_xy) * radius # Get height if self.time_since_start < self.separation_duration: diff = 1000 - self.heights[i] height = 1000 - diff * (self.time_since_start / self.separation_duration) else: height = self.heights[i] drone.hover.target[2] = height break drone.hover.step(self.dt) drone.controls = drone.hover.controls
def step(self, packet: GameTickPacket, drone: Drone, index: int): if drone.start_pos is None: drone.start_pos = drone.position drone.sort_phase = 1 # Finish if all have been sorted. if index == 0: # Initially set finished to True. self.finished = True if drone.sort_phase != 3: # Will be set to False if any is not in phase 3. self.finished = False # It's my time! if self.time_since_start > 0.5 + index * self.delay: desired_angle = (2 * math.pi / 64) * index # current_radius = norm(vec2(drone.position)) current_angle = math.atan2(drone.position[1], drone.position[0]) if current_angle < 0.0: current_angle += 2 * math.pi # only positive angles # Rotate to correct angle. if drone.sort_phase == 1: # if index in range(64)[::8]: print(index, current_angle, desired_angle) if abs(current_angle - desired_angle) < 0.1: drone.sort_phase = 2 target = dot(rotation(current_angle + 0.4), vec2(self.radius - 400, 0)) target = vec3(target) target[2] = self.height + (180 * index // 16) # Height and final corrections. elif drone.sort_phase == 2: target = vec3( dot(rotation(desired_angle), vec2(self.radius, 0))) target[2] = self.height if norm(drone.position - target) < 200: drone.sort_phase = 3 target[2] = (4 * drone.position[2] + self.height) / 5 elif drone.sort_phase == 3: target = vec3( dot(rotation(desired_angle), vec2(self.radius, 0))) target[2] = self.height else: # Stay in place. target = drone.start_pos # Hover controls drone.hover.target = target drone.hover.up = normalize(drone.position) drone.hover.step(self.dt) drone.controls = drone.hover.controls # If any bot got lost, now they have a chance to recover. if drone.on_ground: drone.controls.jump = True else: drone.controls.jump = False
def step(self, packet: GameTickPacket, drone: Drone, index: int): if drone.since_jumped is None: # Control throttle start and jump. if self.time_since_start > self.delay * (index % 16): # Speed controller. drone.controls.throttle = 1.0 if max(abs( drone.velocity[0]), abs(drone.velocity[1])) < 500 else 0.03 # If near half-line if norm(vec3(0, 0, 0) - drone.position) < 700: drone.since_jumped = 0.0 drone.controls.jump = True # Create helix after jump. else: # Increment timer. drone.since_jumped += self.dt # HEIGHT if drone.since_jumped < 11: height = 150 + drone.since_jumped * 150 # speed of rise elif drone.since_jumped < 20: height = 1800 - (drone.since_jumped - 11) * 150 else: height = 450 + (drone.since_jumped - 16) * 30 height = min(height, 600) # RADIUS if drone.since_jumped < 11: radius = 500 elif drone.since_jumped < 15: radius = 500 - (drone.since_jumped - 10) * 50 elif drone.since_jumped < 17: radius = 300 elif drone.since_jumped < 20: radius = 300 + (drone.since_jumped - 17) * 100 else: radius = 400 + drone.since_jumped**3 / 10 radius = min(radius, 2000) # ANGLE if drone.since_jumped < 11: angle = drone.since_jumped * 0.4 # rotation speed elif drone.since_jumped < 20: angle = (11 * 0.4) + (drone.since_jumped - 11) * 0.6 else: angle = (11 * 0.4) + (9 * 0.6) + (drone.since_jumped - 20) * 0.3 # Offset angle. angle += (index // 16) * (math.pi / 2) # Set hover target and controller. rot = rotation(angle) v = vec3(dot(rot, vec2(1, 0))) drone.hover.target = v * radius drone.hover.target[2] = height drone.hover.up = normalize(drone.position) drone.hover.step(self.dt) drone.controls = drone.hover.controls if drone.since_jumped < 0.05: drone.controls.jump = True drone.controls.boost = False