breaking.py

import keyboard
import time
import threading
from ctypes import windll

# --- Configuration ---
BRAKE_KEY = 's'
MAX_BRAKE_TIME = 0.1      # Seconds to reach full pressure when held
BASE_PULSE_HZ = 1000000       # Base PWM frequency
COOLING_RATE = 0.008      # Brake temp cooling per second
EFFICIENCY_LOSS = 0.45    # Max brake efficiency loss
BRAKE_RELEASE_GRADIENT = 0.5  # Brake pressure decay per second when released

try:
   from ac_shared_memory import ACSharedMemory
   ac = ACSharedMemory()
   USE_REAL_TELEMETRY = True
except ImportError:
   print("AC telemetry not available - using simulated values")
   USE_REAL_TELEMETRY = False

def is_caps_lock_on():
   """Check if Caps Lock is enabled (Windows API method)."""
   return bool(windll.user32.GetKeyState(0x14) & 1)

class TelemetryHandler:
   def __init__(self):
      self.speed = 0.0
      self.steer = 0.0
      self.brake_temp = 0.0
      self.last_update = 0.0

   def update(self):
      if USE_REAL_TELEMETRY:
         self.speed = ac.physics.speedKmh / 3.6
         self.steer = ac.physics.steer
         self.brake_temp = (ac.physics.brakeTempFL + ac.physics.brakeTempFR) / 2
      else:
         self.speed = max(0, self.speed + (1 if time.time() % 2 < 1 else -1))
         self.steer = (time.time() % 3 - 1.5) / 1.5
         self.brake_temp = min(800, self.brake_temp + 2)

      self.brake_temp = max(0, self.brake_temp - COOLING_RATE)
      self.last_update = time.time()

class RealisticBrakeController:
   def __init__(self):
      self.telemetry = TelemetryHandler()
      self.brake_start = 0.0
      self.current_brake = 0.0
      self.running = True

      self.brake_bias = 0.55
      self.tire_grip = 1.2

      # Used to calculate time delta between brake updates.
      self.last_brake_update = time.time()

   def calculate_grip(self):
      optimal_temp = 80.0
      temp_diff = abs(self.telemetry.brake_temp - optimal_temp)
      return self.tire_grip * (1.0 - min(temp_diff / 200.0, 0.4))

   def safe_brake_pressure(self):
      max_pressure = (self.telemetry.speed**2 * self.calculate_grip()) / 100.0
      return clamp(max_pressure, 0.1, 1.0)

   def thermal_efficiency(self):
      efficiency = 1.0 - (self.telemetry.brake_temp / 800.0 * EFFICIENCY_LOSS)
      return clamp(efficiency, 0.65, 1.0)

   def update_brake(self):
      current_time = time.time()
      dt = current_time - self.last_brake_update
      self.last_brake_update = current_time

      if keyboard.is_pressed(BRAKE_KEY):
         # If brake is pressed, ramp up brake pressure.
         if self.brake_start == 0:
            self.brake_start = current_time

         hold_time = current_time - self.brake_start
         raw_pressure = clamp(hold_time / MAX_BRAKE_TIME, 0.0, 1.0)

         safe_max = self.safe_brake_pressure()
         efficiency = self.thermal_efficiency()
         final_pressure = raw_pressure * safe_max * efficiency

         self.current_brake = final_pressure

         # PWM simulation based on current pressure.
         pulse_duration = 1.0 / (BASE_PULSE_HZ * (1.0 + raw_pressure * 2))
         keyboard.press(BRAKE_KEY)
         time.sleep(pulse_duration * final_pressure)
         keyboard.release(BRAKE_KEY)
         time.sleep(pulse_duration * (1.0 - final_pressure))
      else:
         # When brake key is released, reset the start time
         self.brake_start = 0.0
         # Decay brake pressure gradually using the defined gradient.
         self.current_brake = max(0, self.current_brake - BRAKE_RELEASE_GRADIENT * dt)

         if self.current_brake > 0:
            pulse_duration = 1.0 / (BASE_PULSE_HZ * (1.0 + self.current_brake * 2))
            keyboard.press(BRAKE_KEY)
            time.sleep(pulse_duration * self.current_brake)
            keyboard.release(BRAKE_KEY)
            time.sleep(pulse_duration * (1.0 - self.current_brake))
         else:
            keyboard.release(BRAKE_KEY)

   def run(self):
      telemetry_thread = threading.Thread(target=self.telemetry.update)
      telemetry_thread.start()

      try:
         while self.running:
            self.update_brake()
            time.sleep(0.001)
      except KeyboardInterrupt:
         self.stop()

   def stop(self):
      self.running = False
      keyboard.release(BRAKE_KEY)

def clamp(value, min_val, max_val):
   return max(min_val, min(value, max_val))

if __name__ == "__main__":
   print("Realistic Brake Controller - ESC to exit")
   controller = RealisticBrakeController()
   controller.run()