Start and Shutdown of scheduler in simulator

core/src/nova64_core.c

@@ -2,6 +2,7 @@
 #include "FreeRTOS.h"
 #include "queue.h"
 #include "task.h"
+#include <stdarg.h>
 #include <stdio.h>
 
 #if defined(ESP_PLATFORM)
@@ -19,23 +20,179 @@
 #endif
 
 static bool is_initialized = false;
+static nova64_io_interface_t g_io_interface_storage;
+static const nova64_io_interface_t *g_io_interface = NULL;
 static QueueHandle_t event_queue = NULL;
+static TaskHandle_t boot_task_handle = NULL;
+static TaskHandle_t launcher_task_handle = NULL;
+static TaskHandle_t shutdown_task_handle = NULL;
+static volatile bool shutdown_requested = false;
 
+static const char *const kInternalLauncherPath = "SYS:/launcher.wasm";
 
-NOVA64_API bool nova64_init_io(const nova64_io_interface_t *io_interface) {
-  printf("[Nova64 Core] System Initializing...\n");
+static void nova64_log(const char *format, ...) {
+  char buffer[512];
+  va_list args;
+  va_start(args, format);
+  vsnprintf(buffer, sizeof(buffer), format, args);
+  va_end(args);
+
+  if (g_io_interface && g_io_interface->log_message) {
+    g_io_interface->log_message(buffer);
+  } else {
+    fputs(buffer, stdout);
+  }
+}
+
+static bool initialize_wasm_runtime(void) {
+  nova64_log("[Core] Initializing WASM runtime...\n");
+  // TODO: Replace this stub with real WAMR initialization.
+  return true;
+}
+
+static bool load_launcher_from_internal_storage(void) {
+  nova64_log("[Core] Loading launcher from internal storage (%s)...\n",
+             kInternalLauncherPath);
+  // TODO: Implement the actual internal storage filesystem and launcher load.
+  return true;
+}
+
+static void nova64_wasm_launcher_task(void *params) {
+  (void)params;
+  nova64_log("[Core] WASM launcher task started.\n");
+
+  // TODO: Execute the loaded WASM launcher module here with the WAMR engine.
+  for (;;) {
+    vTaskDelay(pdMS_TO_TICKS(1000));
+  }
+}
+
+static bool start_launcher_task(void) {
+  BaseType_t result = xTaskCreate(nova64_wasm_launcher_task, "Nova64Launcher",
+                                  4096 / sizeof(StackType_t), NULL,
+                                  tskIDLE_PRIORITY + 1, &launcher_task_handle);
+
+  if (result != pdPASS) {
+    nova64_log("[Core] Failed to create launcher task.\n");
+    return false;
+  }
+
+  nova64_log("[Core] Launcher task created successfully.\n");
+  return true;
+}
+
+static void nova64_shutdown_task(void *params) {
+  (void)params;
+
+  nova64_log("[Core] Shutdown task started.\n");
+  for (;;) {
+    if (shutdown_requested) {
+      nova64_log("[Core] Shutdown requested; ending scheduler.\n");
+      vTaskEndScheduler();
+      return;
+    }
+    vTaskDelay(pdMS_TO_TICKS(100));
+  }
+}
+
+static bool start_shutdown_task(void) {
+  BaseType_t result = xTaskCreate(nova64_shutdown_task, "Nova64Shutdown",
+                                  2048 / sizeof(StackType_t), NULL,
+                                  tskIDLE_PRIORITY + 2, &shutdown_task_handle);
+
+  if (result != pdPASS) {
+    nova64_log("[Core] Failed to create shutdown task.\n");
+    return false;
+  }
+
+  nova64_log("[Core] Shutdown task created successfully.\n");
+  return true;
+}
+
+static void nova64_boot_task(void *params) {
+  (void)params;
+  nova64_log("[Core] Boot task started.\n");
+
+  if (!initialize_wasm_runtime()) {
+    nova64_log("[Core] WASM runtime initialization failed.\n");
+    vTaskDelete(NULL);
+    return;
+  }
+
+  if (!load_launcher_from_internal_storage()) {
+    nova64_log("[Core] Launcher loading failed.\n");
+    vTaskDelete(NULL);
+    return;
+  }
+
+  if (!start_launcher_task()) {
+    nova64_log("[Core] Launcher startup failed.\n");
+    vTaskDelete(NULL);
+    return;
+  }
+
+  nova64_log("[Core] Boot process completed.\n");
+  vTaskDelete(NULL);
+}
+
+NOVA64_API bool nova64_init(const nova64_io_interface_t *io_interface) {
+  if (is_initialized || io_interface == NULL) {
+    return false;
+  }
+
+  g_io_interface_storage = *io_interface;
+  g_io_interface = &g_io_interface_storage;
+  shutdown_requested = false;
+
+  nova64_log("[Core] System Initializing...\n");
 
   event_queue = xQueueCreate(10, sizeof(uint32_t));
+  if (event_queue == NULL) {
+    nova64_log("[Core] Failed to create event queue.\n");
+    return false;
+  }
+
+  if (!start_shutdown_task()) {
+    return false;
+  }
+
+  nova64_log("[Core] Starting boot process...\n");
+  BaseType_t created =
+      xTaskCreate(nova64_boot_task, "Nova64Boot", 4096 / sizeof(StackType_t),
+                  NULL, tskIDLE_PRIORITY + 2, &boot_task_handle);
+  if (created != pdPASS) {
+    nova64_log("[Core] Failed to create boot task.\n");
+    return false;
+  }
 
   is_initialized = true;
   return true;
 }
 
-NOVA64_API int32_t nova64_process_tick(uint32_t delta_ms) {
-  if (!is_initialized)
+NOVA64_API int32_t nova64_main() {
+  if (!is_initialized) {
     return -1;
-  // Core Game-Logic & State Machine Ticks
-  return 0; // OK
+  }
+
+  nova64_log(
+      "[Core] Entering main runtime and starting FreeRTOS scheduler...\n");
+  vTaskStartScheduler();
+
+  // vTaskStartScheduler only returns if the scheduler fails to start or if
+  // the scheduler is shut down by vTaskEndScheduler().
+  nova64_log("[Core] vTaskStartScheduler returned.\n");
+  is_initialized = false;
+  return -1;
+}
+
+NOVA64_API bool nova64_shutdown(void) {
+  if (!is_initialized) {
+    return false;
+  }
+
+  nova64_log("[Core] Scheduler shutdown requested from host.\n");
+  shutdown_requested = true;
+  return true;
 }
 
 NOVA64_API uint32_t nova64_get_version(void) {