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)