Random Events

frogpilot/assets/theme_manager.py

@@ -10,7 +10,7 @@ from urllib.parse import quote_plus
 
 from openpilot.frogpilot.common.frogpilot_download_utilities import GITLAB_URL, download_file, get_repository_url, handle_error, verify_download
 from openpilot.frogpilot.common.frogpilot_utilities import delete_file, extract_zip, load_json_file, update_json_file
-from openpilot.frogpilot.common.frogpilot_variables import ACTIVE_THEME_PATH, RESOURCES_REPO, THEME_SAVE_PATH
+from openpilot.frogpilot.common.frogpilot_variables import ACTIVE_THEME_PATH, RANDOM_EVENTS_PATH, RESOURCES_REPO, THEME_SAVE_PATH
 
 CANCEL_DOWNLOAD_PARAM = "CancelThemeDownload"
 DOWNLOAD_PROGRESS_PARAM = "ThemeDownloadProgress"
@@ -542,11 +542,13 @@ class ThemeManager:
 
     self.update_theme_params(downloadable_colors, downloadable_distance_icons, downloadable_icons, downloadable_signals, downloadable_sounds, downloadable_wheels)
 
-  def update_wheel_image(self, image, boot_run=False):
+  def update_wheel_image(self, image, boot_run=False, random_event=False):
     wheel_save_location = ACTIVE_THEME_PATH / "steering_wheel"
 
     if self.holiday_theme != "stock":
       wheel_location = HOLIDAY_THEME_PATH / self.holiday_theme / "steering_wheel"
+    elif random_event:
+      wheel_location = RANDOM_EVENTS_PATH / "steering_wheels"
     elif image == "stock":
       wheel_location = STOCKOP_THEME_PATH / "steering_wheel"
     elif image in HOLIDAY_SLUGS:

frogpilot/controls/frogpilot_planner.py

@@ -20,13 +20,13 @@ from openpilot.frogpilot.controls.lib.frogpilot_following import FrogPilotFollow
 from openpilot.frogpilot.controls.lib.frogpilot_vcruise import FrogPilotVCruise
 
 class FrogPilotPlanner:
-  def __init__(self, error_log):
+  def __init__(self, error_log, ThemeManager):
     self.params = Params(return_defaults=True)
     self.params_memory = Params(memory=True)
 
     self.frogpilot_acceleration = FrogPilotAcceleration(self)
     self.frogpilot_cem = ConditionalExperimentalMode(self)
-    self.frogpilot_events = FrogPilotEvents(self, error_log)
+    self.frogpilot_events = FrogPilotEvents(self, error_log, ThemeManager)
     self.frogpilot_following = FrogPilotFollowing(self)
     self.frogpilot_vcruise = FrogPilotVCruise(self)
 

frogpilot/controls/lib/frogpilot_events.py

@@ -1,18 +1,33 @@
 #!/usr/bin/env python3
+import random
+
+from openpilot.common.constants import ACCELERATION_DUE_TO_GRAVITY, CV
+from openpilot.common.realtime import DT_MDL
 from openpilot.selfdrive.selfdrived.events import ET, EVENT_NAME, FROGPILOT_EVENT_NAME, EventName, FrogPilotEventName, Events
 
-from openpilot.frogpilot.common.frogpilot_variables import NON_DRIVING_GEARS
+from openpilot.frogpilot.common.frogpilot_variables import CRUISING_SPEED, NON_DRIVING_GEARS
+
+DEJA_VU_G_FORCE = 0.75
+RANDOM_EVENTS_CHANCE = 0.01 * DT_MDL
+RANDOM_EVENTS_LENGTH = 5
+
+RANDOM_EVENT_START = FrogPilotEventName.accel30
+RANDOM_EVENT_END = FrogPilotEventName.youveGotMail
 
 class FrogPilotEvents:
-  def __init__(self, FrogPilotPlanner, error_log):
+  def __init__(self, FrogPilotPlanner, error_log, ThemeManager):
     self.frogpilot_planner = FrogPilotPlanner
+    self.theme_manager = ThemeManager
 
     self.events = Events(frogpilot=True)
 
+    self.always_on_lateral_enabled_previously = False
+    self.random_event_playing = False
     self.startup_seen = False
     self.stopped_for_light = False
 
     self.max_acceleration = 0
+    self.random_event_timer = 0
     self.tracked_lead_distance = 0
 
     self.played_events = set()
@@ -63,8 +78,105 @@ class FrogPilotEvents:
     if "nnffLoaded" not in self.played_events and self.startup_seen and alerts_empty and len(self.events) == 0 and self.frogpilot_planner.params.get("NNFFModelName") is not None and frogpilot_toggles.nnff:
       self.events.add(FrogPilotEventName.nnffLoaded)
 
+    if self.random_event_playing:
+      self.random_event_timer += DT_MDL
+
+      if self.random_event_timer >= RANDOM_EVENTS_LENGTH:
+        self.theme_manager.update_wheel_image(frogpilot_toggles.wheel_image)
+        self.frogpilot_planner.params_memory.put_bool("UpdateWheelImage", True)
+
+        self.random_event_playing = False
+        self.random_event_timer = 0
+
+    if not self.random_event_playing and frogpilot_toggles.random_events:
+      if "accel30" not in self.played_events and 3.5 > self.max_acceleration >= 3.0 and acceleration < 1.5:
+        self.events.add(FrogPilotEventName.accel30)
+
+        self.theme_manager.update_wheel_image("accel30", random_event=True)
+        self.frogpilot_planner.params_memory.put_bool("UpdateWheelImage", True)
+
+        self.max_acceleration = 0
+
+      elif "accel35" not in self.played_events and 4.0 > self.max_acceleration >= 3.5 and acceleration < 1.5:
+        self.events.add(FrogPilotEventName.accel35)
+
+        self.theme_manager.update_wheel_image("accel35", random_event=True)
+        self.frogpilot_planner.params_memory.put_bool("UpdateWheelImage", True)
+
+        self.max_acceleration = 0
+
+      elif "accel40" not in self.played_events and self.max_acceleration >= 4.0 and acceleration < 1.5:
+        self.events.add(FrogPilotEventName.accel40)
+
+        self.theme_manager.update_wheel_image("accel40", random_event=True)
+        self.frogpilot_planner.params_memory.put_bool("UpdateWheelImage", True)
+
+        self.max_acceleration = 0
+
+      if "dejaVuCurve" not in self.played_events and sm["carState"].vEgo > CRUISING_SPEED:
+        if self.frogpilot_planner.lateral_acceleration >= DEJA_VU_G_FORCE * ACCELERATION_DUE_TO_GRAVITY:
+          self.events.add(FrogPilotEventName.dejaVuCurve)
+
+      if "hal9000" not in self.played_events and (ET.NO_ENTRY in current_alert or ET.NO_ENTRY in current_frogpilot_alert):
+        self.events.add(FrogPilotEventName.hal9000)
+
+      if f"{EVENT_NAME[EventName.steerSaturated]}/" in current_alert or f"{FROGPILOT_EVENT_NAME[FrogPilotEventName.goatSteerSaturated]}/" in current_frogpilot_alert:
+        event_choices = []
+        if "firefoxSteerSaturated" not in self.played_events:
+          event_choices.append("firefoxSteerSaturated")
+        if "goatSteerSaturated" not in self.played_events:
+          event_choices.append("goatSteerSaturated")
+        if "thisIsFineSteerSaturated" not in self.played_events:
+          event_choices.append("thisIsFineSteerSaturated")
+
+        if event_choices and random.random() < RANDOM_EVENTS_CHANCE:
+          event_choice = random.choice(event_choices)
+
+          if event_choice == "firefoxSteerSaturated":
+            self.events.add(FrogPilotEventName.firefoxSteerSaturated)
+
+            self.theme_manager.update_wheel_image("firefoxSteerSaturated", random_event=True)
+            self.frogpilot_planner.params_memory.put_bool("UpdateWheelImage", True)
+          elif event_choice == "goatSteerSaturated":
+            self.events.add(FrogPilotEventName.goatSteerSaturated)
+
+            self.theme_manager.update_wheel_image("goatSteerSaturated", random_event=True)
+            self.frogpilot_planner.params_memory.put_bool("UpdateWheelImage", True)
+          elif event_choice == "thisIsFineSteerSaturated":
+            self.events.add(FrogPilotEventName.thisIsFineSteerSaturated)
+
+            self.theme_manager.update_wheel_image("thisIsFineSteerSaturated", random_event=True)
+            self.frogpilot_planner.params_memory.put_bool("UpdateWheelImage", True)
+
+      if "vCruise69" not in self.played_events and 70 > max(sm["carState"].vCruise, sm["carState"].vCruiseCluster) * (1 if frogpilot_toggles.is_metric else CV.KPH_TO_MPH) >= 69:
+        self.events.add(FrogPilotEventName.vCruise69)
+
+      if f"{EVENT_NAME[EventName.fcw]}/" in current_alert or f"{EVENT_NAME[EventName.stockAeb]}/" in current_alert:
+        event_choices = []
+        if "toBeContinued" not in self.played_events:
+          event_choices.append("toBeContinued")
+        if "yourFrogTriedToKillMe" not in self.played_events:
+          event_choices.append("yourFrogTriedToKillMe")
+
+        if event_choices:
+          event_choice = random.choice(event_choices)
+          if event_choice == "toBeContinued":
+            self.events.add(FrogPilotEventName.toBeContinued)
+          elif event_choice == "yourFrogTriedToKillMe":
+            self.events.add(FrogPilotEventName.yourFrogTriedToKillMe)
+
+      if "youveGotMail" not in self.played_events and sm["frogpilotCarState"].alwaysOnLateralEnabled and not self.always_on_lateral_enabled_previously:
+        if random.random() < RANDOM_EVENTS_CHANCE / DT_MDL:
+          self.events.add(FrogPilotEventName.youveGotMail)
+
+      self.always_on_lateral_enabled_previously = sm["frogpilotCarState"].alwaysOnLateralEnabled
+      self.random_event_playing |= bool({event for event in self.events.names if RANDOM_EVENT_START <= event <= RANDOM_EVENT_END})
+
     if self.error_log.is_file():
-      self.events.add(FrogPilotEventName.openpilotCrashed)
+      if frogpilot_toggles.random_events:
+        self.events.add(FrogPilotEventName.openpilotCrashedRandomEvent)
+      else:
+        self.events.add(FrogPilotEventName.openpilotCrashed)
 
     self.startup_seen |= sm["frogpilotSelfdriveState"].alertText1 == frogpilot_toggles.startup_alert_top and sm["frogpilotSelfdriveState"].alertText2 == frogpilot_toggles.startup_alert_bottom
 

frogpilot/frogpilot_process.py

@@ -108,7 +108,7 @@ def frogpilot_thread():
 
       run_update_checks = True
     elif started and not started_previously:
-      frogpilot_planner = FrogPilotPlanner(error_log)
+      frogpilot_planner = FrogPilotPlanner(error_log, theme_manager)
       frogpilot_tracking = FrogPilotTracking(frogpilot_planner, frogpilot_toggles)
 
       transition_onroad(error_log)