Fixed issues, tried to implement some of Cuyler files.

.gitignore

@@ -1,6 +1,9 @@
 __pycache__/
 .vscode/
 build/
+expected/
+rel/*/*.s
+src/*/*.s
 out/
 dump/*
 !dump/foresta.rel.sha1

README.MD

@@ -14,7 +14,7 @@ Use `--recursive` when cloning to have ppcdis and libyaz0 in the repository.
 
 - Dump a copy of the game and extract **main.dol** and **foresta.rel.szs**.
 - Decompress **foresta.rel.szs** with libyaz0 found in *tools/libyaz0*.
-- Place **main.dol** in *dump/sys/* and **foresta.rel** in *dump/root/*.
+- Place **main.dol** and **foresta.rel** in *dump/*.
 - Place CodeWarrior 1.3.2 in *tools/1.3.2/*.
 - Install DevkitPPC, Ninja and Python:
     - **Only tested with DevkitPPC r41 and Python 3.8.10**, however other versions should work fine.

common.py

@@ -302,8 +302,7 @@ BASE_DOL_CFLAGS = CFLAGS + [
 BASE_REL_CFLAGS = CFLAGS + [
      "-sdata 0",
      f"-sdata2 {REL_SDATA2_SIZE}",
-     "-pool off",
-     "-ordered-fp-compares"
+     "-pool off"
 ]
 
 LOCAL_CFLAGS = [

config/rel_slices.yml

@@ -0,0 +1,8 @@
+# ac_aprilfool_control/aPC_actor_dt.c:
+    # .text: [0x805153f0, 0x8051542C]
+# zurumode/zerucheck_init.c:
+    # .text: [0x8040eb38, 0x8040EB50] WILL TRY TO FIX these later, one wasn't matching and the other's didn't find the symbol when converting to ELF.
+# zurumode/zerucheck_key_check.c:
+    # .text: [0x8040EB50, 0x8040EDA8]
+# zurumode/zurumode_cleanup.c:
+    # .text: [0x8040efc4, 0x8040f008]

configure.py

@@ -205,7 +205,7 @@ n.rule(
 )
 
 n.rule(
-    "css",
+    "ccs",
     command = ALLOW_CHAIN + f"$cpp -M $in -MF $out.d $cppflags && $cc $cflags -S $in -o $out",
     description = "CC -S $in",
     deps = "gcc",

diff_settings.py

@@ -0,0 +1,24 @@
+from argparse import ArgumentParser, Namespace
+import common as c
+
+def apply(config, args: Namespace):
+    if args.rel:
+        config["mapfile"] = c.REL_MAP
+        config["myimg"] = c.REL_PLF
+        config["baseimg"] = c.REL_EXPECTED
+        config["source_directories"] = [c.REL_SRCDIR, c.INCDIR]
+    else:
+        config["mapfile"] = c.DOL_MAP
+        config["myimg"] = c.DOL_ELF
+        config["baseimg"] = c.DOL_EXPECTED
+        config["source_directories"] = [c.DOL_SRCDIR, c.INCDIR]
+    config["make_command"] = ["ninja"]
+    config["makeflags"] = []
+    config["arch"] = "ppc"
+    config["map_format"] = "mw"
+    config["mw_build_dir"] = c.BUILDDIR
+    config["objdump_executable"] = c.OBJDUMP
+    config["show_line_numbers_default"] = True
+
+def add_custom_arguments(parser: ArgumentParser):
+    parser.add_argument("-r", "--rel", action="store_true", help="(SPM) Diff a function in relF.rel")

expected.py

@@ -0,0 +1,17 @@
+"""
+Creates the expected folder for diff.py
+"""
+
+from shutil import copytree, rmtree
+
+import common as c
+
+# Remove it if already existing
+try:
+    rmtree(c.EXPECTED)
+except FileNotFoundError:
+    pass
+
+# Copy in builddir and outdir
+copytree(c.BUILDDIR, f"{c.EXPECTED}/build")
+copytree(c.OUTDIR, f"{c.EXPECTED}/out")

include/types.h

@@ -0,0 +1,31 @@
+#ifndef TYPES_H
+#define TYPES_H
+
+typedef signed char s8;
+typedef signed short s16;
+typedef signed long s32;
+typedef signed long long s64;
+typedef unsigned char u8;
+typedef unsigned short u16;
+typedef unsigned long u32;
+typedef unsigned long size_t;
+typedef unsigned long long u64;
+typedef unsigned int uint;
+
+typedef volatile u8 vu8;
+typedef volatile u16 vu16;
+typedef volatile u32 vu32;
+typedef volatile u64 vu64;
+typedef volatile s8 vs8;
+typedef volatile s16 vs16;
+typedef volatile s32 vs32;
+typedef volatile s64 vs64;
+
+typedef float f32;
+typedef double f64;
+typedef volatile f32 vf32;
+typedef volatile f64 vf64;
+
+#define NULL ((void*)0)
+
+#endif

include/zurumode.h

@@ -0,0 +1,67 @@
+#ifndef ZURUMODE_H
+#define ZURUMODE_H
+
+#include "types.h"
+
+typedef struct zuru_keycheck_s {
+  u8 state;
+  u8 progressing;
+  u16 last_controller;
+  u8 zurumode_enabled;
+} zuru_keycheck;
+
+static zuru_keycheck zuruKeyCheck;
+
+#define ZURUMODE_RESET 0
+#define ZURUMODE_PROGRESSING 1
+
+#define OS_APP_NMI_ZURUMODE_IDX 15
+
+#define FALSE 0
+#define TRUE 1
+
+
+#define BUTTON_NONE 0x0000
+#define BUTTON_CRIGHT 0x0001
+#define BUTTON_CLEFT 0x0002
+#define BUTTON_CDOWN 0x0004
+#define BUTTON_CUP 0x0008
+#define BUTTON_R 0x0010
+#define BUTTON_L 0x0020
+#define BUTTON_X 0x0040
+#define BUTTON_Y 0x0080
+#define BUTTON_DRIGHT 0x0100
+#define BUTTON_DLEFT 0x0200
+#define BUTTON_DDOWN 0x0400
+#define BUTTON_DUP 0x0800
+#define BUTTON_START 0x1000
+#define BUTTON_Z 0x2000
+#define BUTTON_B 0x4000
+#define BUTTON_A 0x8000
+
+enum zurumode_stage {
+  ZURUMODE_STAGE_BEGIN_e = 0,
+
+  ZURUMODE_STAGE_0_e = ZURUMODE_STAGE_BEGIN_e,
+  ZURUMODE_STAGE_1_e,
+  ZURUMODE_STAGE_2_e,
+  ZURUMODE_STAGE_3_e,
+  ZURUMODE_STAGE_4_e,
+  ZURUMODE_STAGE_5_e,
+  ZURUMODE_STAGE_6_e,
+  ZURUMODE_STAGE_7_e,
+  ZURUMODE_STAGE_8_e,
+  ZURUMODE_STAGE_9_e,
+  ZURUMODE_STAGE_91_e = 91,
+  ZURUMODE_STAGE_92_e = 92,
+  ZURUMODE_STAGE_10_e = 10,
+  ZURUMODE_STAGE_11_e,
+
+  ZURUMODE_STAGE_FINAL_e = ZURUMODE_STAGE_11_e
+};
+
+enum zurumode_flags {
+    ZURUMODE_DISABLED_e = 0 << 0,
+    ZURUMODE_ENABLED_e = 1 << 0
+};
+#endif

rel/ac_aprilfool_control/aPC_actor_dt.c

@@ -0,0 +1,4 @@
+void aAPC_actor_dt(void * arg0_r3) {
+    common_data[2].x60F8 = 0;
+    mEv_actor_dying_message(0x11, arg0_r3);
+}

rel/zurumode/zerucheck_init.c

@@ -0,0 +1,8 @@
+#include "zurumode.h"
+
+static int zerucheck_init(zuru_keycheck* key_check) {
+  key_check->zurumode_enabled = FALSE;
+  key_check->state = ZURUMODE_STAGE_BEGIN_e;
+  key_check->progressing = ZURUMODE_RESET;
+  key_check->last_controller = 0;
+}

rel/zurumode/zerucheck_key_check.c

@@ -0,0 +1,171 @@
+#include "zurumode.h"
+
+/**
+ * @brief Checks that the current controller state is correct
+ * and updates zurumode enable progress accordingly
+ *
+ * Zurumode code:
+ *    1) L + R -> L + R + Z (Hold L & R, then press Z)
+ *    2) D-Pad Up
+ *    3) C-Stick Down
+ *    4) C-Stick Up
+ *    5) D-Pad Down
+ *    6) D-Pad Left
+ *    7) C-Stick Left
+ *    8) C-Stick Right
+ *    9) D-Pad Right
+ *    10) A + B
+ *    11) Start
+ *
+ * @param key_check zurumode keycheck struct
+ * @param controller current controller state
+ * @return int zurumodeEnabled
+ */
+static int zerucheck_key_check(zuru_keycheck* key_check, u32 controller) {
+  u32 controller_new;           /* Buttons pressed on the current frame only */
+  int state = key_check->state; /* Keycheck state */
+  int progressing = key_check->progressing; /* Progressing through keycheck */
+
+  if (state != ZURUMODE_STAGE_FINAL_e) {
+    u16 controller_now = controller;
+    controller_new =
+        controller_now & (key_check->last_controller ^ controller_now);
+    key_check->last_controller = controller_now;
+
+    if (controller_now == BUTTON_NONE && progressing == ZURUMODE_PROGRESSING) {
+      progressing = ZURUMODE_RESET;
+    } else if (controller_new != BUTTON_NONE) {
+      if (progressing == ZURUMODE_PROGRESSING) {
+        state = ZURUMODE_STAGE_BEGIN_e;
+      }
+
+      switch (state) {
+        case ZURUMODE_STAGE_BEGIN_e:
+          /* L & R must be held first, then Z */
+          if (controller_now == (BUTTON_R | BUTTON_L | BUTTON_Z) &&
+              controller_new == BUTTON_Z) {
+            state = ZURUMODE_STAGE_1_e;
+            progressing = ZURUMODE_PROGRESSING;
+          }
+          break;
+
+        case ZURUMODE_STAGE_1_e:
+          if (controller_new == BUTTON_DUP) {
+            state = ZURUMODE_STAGE_2_e;
+          } else {
+            state = ZURUMODE_STAGE_BEGIN_e;
+          }
+          break;
+
+        case ZURUMODE_STAGE_2_e:
+          if (controller_new == BUTTON_CDOWN) {
+            state = ZURUMODE_STAGE_3_e;
+            progressing = ZURUMODE_PROGRESSING;
+          } else {
+            state = ZURUMODE_STAGE_BEGIN_e;
+          }
+          break;
+
+        case ZURUMODE_STAGE_3_e:
+          if (controller_new == BUTTON_CUP) {
+            state = ZURUMODE_STAGE_4_e;
+          } else {
+            state = ZURUMODE_STAGE_BEGIN_e;
+          }
+          break;
+
+        case ZURUMODE_STAGE_4_e:
+          if (controller_new == BUTTON_DDOWN) {
+            state = ZURUMODE_STAGE_5_e;
+            progressing = ZURUMODE_PROGRESSING;
+          } else {
+            state = ZURUMODE_STAGE_BEGIN_e;
+          }
+          break;
+
+        case ZURUMODE_STAGE_5_e:
+          if (controller_new == BUTTON_DLEFT) {
+            state = ZURUMODE_STAGE_6_e;
+          } else {
+            state = ZURUMODE_STAGE_BEGIN_e;
+          }
+          break;
+
+        case ZURUMODE_STAGE_6_e:
+          if (controller_new == BUTTON_CLEFT) {
+            state = ZURUMODE_STAGE_7_e;
+            progressing = ZURUMODE_PROGRESSING;
+          } else {
+            state = ZURUMODE_STAGE_BEGIN_e;
+          }
+          break;
+
+        case ZURUMODE_STAGE_7_e:
+          if (controller_new == BUTTON_CRIGHT) {
+            state = ZURUMODE_STAGE_8_e;
+          } else {
+            state = ZURUMODE_STAGE_BEGIN_e;
+          }
+          break;
+
+        case ZURUMODE_STAGE_8_e:
+          if (controller_new == BUTTON_DRIGHT) {
+            state = ZURUMODE_STAGE_9_e;
+            progressing = ZURUMODE_PROGRESSING;
+          } else {
+            state = ZURUMODE_STAGE_BEGIN_e;
+          }
+          break;
+
+        case ZURUMODE_STAGE_9_e:
+          if (controller_new == (BUTTON_B | BUTTON_A)) {
+            state = ZURUMODE_STAGE_10_e;
+          } else if (controller_new == BUTTON_A) {
+            state = ZURUMODE_STAGE_91_e;
+          } else if (controller_new == BUTTON_B) {
+            state = ZURUMODE_STAGE_92_e;
+          } else {
+            state = ZURUMODE_STAGE_BEGIN_e;
+          }
+          break;
+
+        case ZURUMODE_STAGE_91_e:
+          if (controller_new == BUTTON_B) {
+            state = ZURUMODE_STAGE_10_e;
+          } else {
+            state = ZURUMODE_STAGE_BEGIN_e;
+          }
+          break;
+
+        case ZURUMODE_STAGE_92_e:
+          if (controller_new == BUTTON_A) {
+            state = ZURUMODE_STAGE_10_e;
+          } else {
+            state = ZURUMODE_STAGE_BEGIN_e;
+          }
+          break;
+
+        case ZURUMODE_STAGE_10_e:
+          if (controller_new == BUTTON_START) {
+            state = ZURUMODE_STAGE_FINAL_e;
+          } else {
+            state = ZURUMODE_STAGE_BEGIN_e;
+          }
+          break;
+      }
+    }
+  }
+
+  if (state == ZURUMODE_STAGE_FINAL_e) {
+    /* Zurumode code has been correctly input */
+    key_check->zurumode_enabled ^= TRUE;
+    key_check->state = ZURUMODE_STAGE_BEGIN_e;
+    key_check->progressing = ZURUMODE_RESET;
+  } else {
+    key_check->state = state;
+    key_check->progressing = progressing;
+  }
+
+  return key_check->zurumode_enabled;
+}
+

rel/zurumode/zurumode_cleanup.c

@@ -0,0 +1,21 @@
+#include "zurumode.h"
+
+typedef struct {
+    u8 pad_pattern;
+    void (*callback)(void*);
+    void* callback_param;
+    void (*callback2)(void*);
+    void* callback2_param;
+} padmgr;
+
+extern padmgr padmgr_class;
+extern void zurumode_callback(void*);
+extern s32 zurumode_flag;
+
+extern void zurumode_cleanup(void) {
+    if ((padmgr_class.callback2 == &zurumode_callback) && (padmgr_class.callback2_param == &padmgr_class)) {
+        padmgr_class.callback2 = NULL;
+        padmgr_class.callback2_param = NULL;
+    }
+    zurumode_flag = 0;
+}