def on_car_positions(self, data, tick): car = self.my_car() if not car.crashed: cur_index = self.my_car().track_piece_index macro_index = self.track.macro_piece_map[cur_index] next_macro_beginning = self.track.reverse_macro_map[(macro_index + 1) % len(self.track.reverse_macro_map)] lane = car.lane() next_macro_beginning_piece = car.track.track_pieces[next_macro_beginning] next_macro_radius = next_macro_beginning_piece.true_radius(lane) #next_macro_target_speed = physics.estimate_stable_speed_at_angle(next_macro_radius, physics.crash_angle_buffered()) next_macro_target_speed = physics.estimate_safe_speed_at_angle(next_macro_radius, physics.crash_angle_buffered()) if car.current_track_piece().is_straight: if physics.distance_to_break(car.velocity, next_macro_target_speed) >= \ car.track.distance_until_index(car.track_piece_index, car.in_piece_distance, next_macro_beginning, lane): self.throttle(physics.throttle_to_reach_velocity(car.velocity, next_macro_target_speed), tick) else: self.throttle(1.0, tick) else: # it's a bend! #FIXME: do the safe ending in a more intelligent way than adding one to the next piece index #FIXME: this is just copied from the other bot, we want velocities, not throttles the_until = (next_macro_beginning + 1) % car.track.track_piece_count deduced_throttle = my_bisect(0.0, 1.0, 6, lambda t: physics.is_safe_until_simple(car, t, the_until, 0.0)) self.throttle(deduced_throttle, tick) else: self.ping()
def on_car_positions(self, data, tick): car = self.my_car() cur_index = car.track_piece_index if not car.crashed: # turning on Turbo at the beginning of the longest straight: if cur_index == self.track.index_of_the_beginning_of_the_longest_straight_piece and self.turbo_available: self.turbo("Buckle up!", tick) return macro_index = self.track.macro_piece_map[cur_index] next_macro_beginning = self.track.reverse_macro_map[(macro_index + 1) % len(self.track.reverse_macro_map)] lane = car.lane() distance_until_next_macro = car.track.distance_until_index(car.track_piece_index, car.in_piece_distance, next_macro_beginning, lane) next_macro_beginning_piece = car.track.track_pieces[next_macro_beginning] next_macro_radius = next_macro_beginning_piece.true_radius(lane) next_macro_target_speed = physics.estimate_stable_speed_at_angle(next_macro_radius, physics.crash_angle_buffered()) ### SWITCH ### # should we consider switching? - is next piece a switch and is it legal now? if not car.is_switching() and not self.switch_initiated and self.track.next_piece(cur_index).switch and \ len(self.track.lanes) > 1 and car.velocity > physics.safe_speed: same_lane_and_close = self.other_cars_on_lane_within_distance(lane, 150) if len(same_lane_and_close): #there is somebody to go around dirs = car.possible_lane_switch_directions() switch_direction = random.choice(dirs) target_lane = lane + switch_direction print('checking if there is somebody blocking the other lane - {0}, after going in {1} direction'.format(target_lane, switch_direction)) opponents_on_target_lane = self.other_cars_on_lane_within_distance(target_lane, 250) if not opponents_on_target_lane: print("other lane is clear, let's see if physics says it is safe") car_other_lane = copy.copy(car) car_other_lane.start_lane_index += switch_direction car_other_lane.end_lane_index += switch_direction if physics.check_with_annealing(car_other_lane): print("going to switch lane to in the {0} direction".format(switch_direction)) self.switch_lane_int(switch_direction, tick) return else: print("staying here, switching is not safe!") else: print("somebody on the other lane, not switching now") if self.switch_initiated: print('reducing speed to be safe') self.throttle(0.0, tick) return ### end SWITCH ### if car.current_track_piece().is_straight: # straight! should_run_like_hell = self.is_race() and \ car.lap == self.lap_count() - 1 and \ macro_index == len(self.track.reverse_macro_map) - 1 and \ car.current_track_piece().is_straight if should_run_like_hell: print("gotta go fast!") if self.turbo_available: self.turbo("Strap yourselves in boys!", tick) else: self.throttle(1.0, tick) return next_macro_target_speed = physics.estimate_safe_speed_at_angle(next_macro_radius, physics.crash_angle_buffered()) # simulating the car braking to the safe speed car_at_next_macro = physics.simulate_straight_with_breaking_to_speed(car, distance_until_next_macro, next_macro_target_speed) # end of the simulation with annealing macro_plus_1 = (macro_index + 1) % len(self.track.reverse_macro_map) # getting the best speed for the bend deduced_speed = physics.estimate_optimal_speed_at_bend_with_annealing(car_at_next_macro, car.track.reverse_macro_map[macro_plus_1], True) # planning the breaking, now with better values # checking if we can afford it # velocity and travelled distance in one step of full throttle next_velocity, next_distance = physics.velocity_and_distance_step(car.velocity, 1.0) # distance needed to break breaking_distance = physics.distance_to_break(next_velocity, max(deduced_speed, next_macro_target_speed)) if breaking_distance + next_distance < distance_until_next_macro: self.throttle(1.0, tick) else: self.throttle(0.0, tick) else: # it's a bend! the_until = (next_macro_beginning + 1) % car.track.track_piece_count deduced_speed = physics.estimate_optimal_speed_at_bend_with_annealing(car, the_until) self.throttle(physics.throttle_to_reach_velocity(car.velocity, deduced_speed), tick) else: self.ping(tick)