Release 0.8.0

.github/workflows/build-debug.yml

@@ -0,0 +1,31 @@
+# .github/workflows/debug-build.yml
+name: PR Debug Build (Development)
+
+on:
+  pull_request:
+    branches:
+      - Development
+
+jobs:
+  debug-build:
+    runs-on: windows-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup .NET SDK
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: '8.0.x'
+
+      - name: Restore dependencies
+        run: dotnet restore
+
+      - name: Build solution (Debug)
+        run: dotnet build ./STROOP.sln -c Debug -o ./artifacts --no-restore
+
+      - name: Upload debug build artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: debug-build
+          path: ./artifacts

.github/workflows/build-release-candidate.yml

@@ -0,0 +1,57 @@
+# .github/workflows/build-release-candidate.yml
+name: Release Candidate Build
+
+on:
+    push:
+        branches:
+            - release-*
+
+jobs:
+    release-build:
+        runs-on: windows-latest
+        steps:
+            - name: Checkout repository
+              uses: actions/checkout@v4
+
+            - name: Setup .NET SDK
+              uses: actions/setup-dotnet@v3
+              with:
+                  dotnet-version: '8.0.x'
+
+            - name: Restore dependencies
+              run: dotnet restore
+
+            - name: Build solution (Release)
+              run: dotnet build ./STROOP.sln -c Release -o ./artifacts --no-restore
+
+            - name: Determine release branch name and short commit
+              id: meta
+              shell: bash
+              run: |
+                  # Get branch name from ref (refs/heads/release-...)
+                  BRANCH_REF="${GITHUB_REF#refs/heads/}"
+                  # sanitize branch for filenames: replace slashes with -
+                  BRANCH_NAME="${BRANCH_REF//\//-}"
+                  SHORT_SHA="${GITHUB_SHA::7}"
+                  echo "branch=${BRANCH_NAME}" >> "$GITHUB_OUTPUT"
+                  echo "short_sha=${SHORT_SHA}" >> "$GITHUB_OUTPUT"
+
+            - name: Write release metadata file
+              run: |
+                  echo "branch=${{ steps.meta.outputs.branch }}" > ./artifacts/release-info.txt
+                  echo "commit=${{ steps.meta.outputs.short_sha }}" >> ./artifacts/release-info.txt
+                  echo "built_at=$(date -u +"%Y-%m-%dT%H:%M:%SZ")" >> ./artifacts/release-info.txt
+              shell: bash
+
+            - name: Prepare artifact filename
+              id: filename
+              shell: bash
+              run: |
+                  TARGET="release-build-${{ steps.meta.outputs.branch }}-${{ steps.meta.outputs.short_sha }}"
+                  echo "name=${TARGET}" >> "$GITHUB_OUTPUT"
+
+            - name: Upload release build artifact
+              uses: actions/upload-artifact@v4
+              with:
+                  name: ${{ steps.filename.outputs.name }}
+                  path: ./artifacts

.github/workflows/build-release.yml

@@ -0,0 +1,31 @@
+# .github/workflows/build-release.yml
+name: Release Build
+
+on:
+  push:
+    branches:
+      - Release
+
+jobs:
+  release-build:
+    runs-on: windows-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup .NET SDK
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: '8.0.x'
+
+      - name: Restore dependencies
+        run: dotnet restore
+
+      - name: Build solution (Release)
+        run: dotnet build ./STROOP.sln -c Release -o ./artifacts --no-restore
+
+      - name: Upload release build artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-build
+          path: ./artifacts

STROOP.Core/CoreLoop.cs

@@ -0,0 +1,48 @@
+using System.Diagnostics;
+
+namespace STROOP.Core;
+
+public class CoreLoop
+{
+    private List<double> _fpsTimes = new List<double>();
+    private byte[] _ram;
+    private object _mStreamProcess = new object();
+
+    public double FpsInPractice => _fpsTimes.Count == 0 ? 0 : 1 / _fpsTimes.Average();
+    public double lastFrameTime => _fpsTimes.Count == 0 ? double.NaN : _fpsTimes.Last();
+
+    public void Run(CancellationToken cancellationToken, Action handleEvents, Func<double> getTargetedFps)
+    {
+        Stopwatch frameStopwatch = Stopwatch.StartNew();
+
+        while (!cancellationToken.IsCancellationRequested)
+        {
+            double timeToWait;
+            lock (_mStreamProcess)
+            {
+                ProcessStream.Instance.RefreshRam();
+                ProcessStream.Instance.OnUpdate?.Invoke();
+            }
+
+            handleEvents();
+
+            // Calculate delay to match correct FPS
+            frameStopwatch.Stop();
+            double timePassed = frameStopwatch.ElapsedTicks / (double)Stopwatch.Frequency;
+            timeToWait = getTargetedFps() - timePassed;
+            timeToWait = Math.Max(timeToWait, 0);
+
+            // Calculate Fps
+            while (_fpsTimes.Count() >= 10)
+                _fpsTimes.RemoveAt(0);
+            _fpsTimes.Add(timePassed + timeToWait);
+
+            frameStopwatch.Restart();
+
+            if (timeToWait > 0)
+                Thread.Sleep(new TimeSpan((long)(timeToWait * 10000000)));
+            else
+                Thread.Yield();
+        }
+    }
+}

STROOP.Core/Emulator.cs

@@ -0,0 +1,12 @@
+namespace STROOP.Core;
+
+public class Emulator
+{
+    public string Name;
+    public string ProcessName;
+    public uint RamStart;
+    public bool AllowAutoDetect;
+    public string Dll;
+    public Type IOType;
+    public EndiannessType Endianness = EndiannessType.Little;
+}

STROOP.Core/EndiannessType.cs

@@ -0,0 +1,7 @@
+namespace STROOP.Core;
+
+public enum EndiannessType
+{
+    Big,
+    Little,
+}

STROOP.Core/EndiannessUtilities.cs

@@ -0,0 +1,93 @@
+namespace STROOP.Core;
+
+public static class EndiannessUtilities
+{
+    private static readonly byte[] _fixAddress = { 0x00, 0x03, 0x02, 0x01, 0x00 };
+
+    public static UIntPtr SwapAddressEndianness(UIntPtr address, int dataSize)
+    {
+        switch (dataSize)
+        {
+            case 1:
+            case 2:
+            case 3:
+                return new UIntPtr(address.ToUInt64() & ~0x03UL | _fixAddress[dataSize] - address.ToUInt64() & 0x03UL);
+            default:
+                if (AddressIsMisaligned(address))
+                    throw new Exception("Misaligned data");
+                return address;
+        }
+    }
+
+    public static uint SwapAddressEndianness(uint address, int dataSize)
+    {
+        switch (dataSize)
+        {
+            case 1:
+            case 2:
+            case 3:
+                return (uint)(address & ~0x03) | _fixAddress[dataSize] - address & 0x03;
+            default:
+                if (AddressIsMisaligned(address))
+                    throw new Exception("Misaligned data");
+                return address;
+        }
+    }
+
+    public static bool DataIsMisaligned(UIntPtr address, int dataSize, EndiannessType endianness)
+    {
+        // Get the number of bytes remaining to alignment for the address
+        int bytesToAlignment = NumberOfBytesToAlignment(address);
+        if (endianness == EndiannessType.Little) // Little endianess goes backwards in count, not forwards
+            bytesToAlignment = _fixAddress[bytesToAlignment];
+
+        // All datasize greater than 4 must already have an aligned address, and an aligned data size (multiple of 4)
+        if (dataSize >= 4)
+            return bytesToAlignment != 0 || dataSize % 4 != 0;
+
+        // If we are already aligned, we really have 4 bytes remaining
+        if (bytesToAlignment == 0)
+            bytesToAlignment = 4;
+
+        // Be sure the bytes fit in the remaining section and do go past the 4-byte alignment
+        return bytesToAlignment < dataSize;
+    }
+
+    public static bool AddressIsMisaligned(UIntPtr address) => (address.ToUInt64() & 0x03) != 0;
+
+    public static bool AddressIsMisaligned(uint address) => (address & 0x03) != 0;
+
+    private static readonly byte[] _bytesToAlignment = new byte[] { 0x00, 0x03, 0x02, 0x01 };
+
+    public static int NumberOfBytesToAlignment(UIntPtr address) => _bytesToAlignment[address.ToUInt64() & 0x03];
+
+    public static int NumberOfBytesToAlignment(uint address) => _bytesToAlignment[address & 0x03];
+
+    public static uint AlignedAddressFloor(uint address) => address & ~0x03U;
+
+    public static UIntPtr AlignedAddressFloor(UIntPtr address) => (UIntPtr)(address.ToUInt64() & ~0x03U);
+
+    public static uint AlignedAddressCeil(uint address) => (address & ~0x03U) + 4;
+
+    public static UIntPtr AlignedAddressCeil(UIntPtr address) => (UIntPtr)((address.ToUInt64() & ~0x03U) + 4);
+
+    public static byte[] SwapByteEndianness(byte[] bytes)
+    {
+        if (bytes.Length < 3)
+            return bytes.Reverse().ToArray();
+
+        if (bytes.Length % 4 != 0)
+            throw new ArgumentException("Bytes are not a multiple of 4");
+
+        byte[] result = new byte[bytes.Length];
+        for (int i = 0; i < bytes.Length; i += 4)
+        {
+            result[i] = bytes[i + 3];
+            result[i + 1] = bytes[i + 2];
+            result[i + 2] = bytes[i + 1];
+            result[i + 3] = bytes[i];
+        }
+
+        return result;
+    }
+}