├── Assets
    ├── Resources
    │   ├── .gitignore
    │   └── CPU.bytes
    ├── Scenes
    │   ├── Start.unity
    │   └── Start.unity.meta
    ├── Scripts
    │   ├── State
    │   │   ├── State.cs
    │   │   ├── State.cs.meta
    │   │   ├── SaveState.cs.meta
    │   │   └── SaveState.cs
    │   ├── Input.meta
    │   ├── State.meta
    │   ├── VM.meta
    │   ├── Graphics.meta
    │   ├── Graphics
    │   │   ├── TileData.cs
    │   │   ├── Lcd.cs.meta
    │   │   ├── Drawer.cs.meta
    │   │   ├── Screen.cs.meta
    │   │   ├── TileData.cs.meta
    │   │   ├── Drawer.cs
    │   │   ├── Lcd.cs
    │   │   └── Screen.cs
    │   ├── CPU.cs.meta
    │   ├── Clock.cs.meta
    │   ├── Core.cs.meta
    │   ├── Data.cs.meta
    │   ├── Loader.cs.meta
    │   ├── Memory.cs.meta
    │   ├── Utils.cs.meta
    │   ├── Settings.cs.meta
    │   ├── TickTables.cs.meta
    │   ├── VM
    │   │   ├── MainVM.cs.meta
    │   │   └── ExtendedVM.cs.meta
    │   ├── Input
    │   │   ├── KeyButton.cs.meta
    │   │   ├── Keyboard.cs.meta
    │   │   ├── LoaderButton.cs.meta
    │   │   ├── LoaderButton.cs
    │   │   ├── KeyButton.cs
    │   │   └── Keyboard.cs
    │   ├── Settings.cs
    │   ├── Utils.cs
    │   ├── CPU.cs
    │   ├── Loader.cs
    │   ├── TickTables.cs
    │   ├── Clock.cs
    │   ├── Core.cs
    │   ├── Data.cs
    │   └── Memory.cs
    ├── Resources.meta
    ├── Scenes.meta
    └── Scripts.meta
├── ProjectSettings
    ├── ProjectVersion.txt
    ├── TagManager.asset
    ├── AudioManager.asset
    ├── InputManager.asset
    ├── NavMeshAreas.asset
    ├── TimeManager.asset
    ├── DynamicsManager.asset
    ├── EditorSettings.asset
    ├── NetworkManager.asset
    ├── ProjectSettings.asset
    ├── QualitySettings.asset
    ├── GraphicsSettings.asset
    ├── Physics2DSettings.asset
    ├── ClusterInputManager.asset
    ├── EditorBuildSettings.asset
    └── UnityConnectSettings.asset
├── .gitignore
├── LICENSE
└── README.md


/Assets/Resources/.gitignore:
--------------------------------------------------------------------------------
1 | 
2 | 
3 | 


--------------------------------------------------------------------------------
/ProjectSettings/ProjectVersion.txt:
--------------------------------------------------------------------------------
1 | m_EditorVersion: 5.6.1p1
2 | 


--------------------------------------------------------------------------------
/Assets/Resources/CPU.bytes:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andresgutierrez/em/HEAD/Assets/Resources/CPU.bytes


--------------------------------------------------------------------------------
/Assets/Scenes/Start.unity:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andresgutierrez/em/HEAD/Assets/Scenes/Start.unity


--------------------------------------------------------------------------------
/Assets/Scripts/State/State.cs:
--------------------------------------------------------------------------------
1 | 
2 | namespace GB
3 | {
4 |     public class State
5 |     {
6 |         
7 |     }
8 | }


--------------------------------------------------------------------------------
/ProjectSettings/TagManager.asset:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andresgutierrez/em/HEAD/ProjectSettings/TagManager.asset


--------------------------------------------------------------------------------
/ProjectSettings/AudioManager.asset:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andresgutierrez/em/HEAD/ProjectSettings/AudioManager.asset


--------------------------------------------------------------------------------
/ProjectSettings/InputManager.asset:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andresgutierrez/em/HEAD/ProjectSettings/InputManager.asset


--------------------------------------------------------------------------------
/ProjectSettings/NavMeshAreas.asset:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andresgutierrez/em/HEAD/ProjectSettings/NavMeshAreas.asset


--------------------------------------------------------------------------------
/ProjectSettings/TimeManager.asset:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andresgutierrez/em/HEAD/ProjectSettings/TimeManager.asset


--------------------------------------------------------------------------------
/ProjectSettings/DynamicsManager.asset:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andresgutierrez/em/HEAD/ProjectSettings/DynamicsManager.asset


--------------------------------------------------------------------------------
/ProjectSettings/EditorSettings.asset:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andresgutierrez/em/HEAD/ProjectSettings/EditorSettings.asset


--------------------------------------------------------------------------------
/ProjectSettings/NetworkManager.asset:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andresgutierrez/em/HEAD/ProjectSettings/NetworkManager.asset


--------------------------------------------------------------------------------
/ProjectSettings/ProjectSettings.asset:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andresgutierrez/em/HEAD/ProjectSettings/ProjectSettings.asset


--------------------------------------------------------------------------------
/ProjectSettings/QualitySettings.asset:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andresgutierrez/em/HEAD/ProjectSettings/QualitySettings.asset


--------------------------------------------------------------------------------
/ProjectSettings/GraphicsSettings.asset:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andresgutierrez/em/HEAD/ProjectSettings/GraphicsSettings.asset


--------------------------------------------------------------------------------
/ProjectSettings/Physics2DSettings.asset:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andresgutierrez/em/HEAD/ProjectSettings/Physics2DSettings.asset


--------------------------------------------------------------------------------
/ProjectSettings/ClusterInputManager.asset:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andresgutierrez/em/HEAD/ProjectSettings/ClusterInputManager.asset


--------------------------------------------------------------------------------
/ProjectSettings/EditorBuildSettings.asset:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andresgutierrez/em/HEAD/ProjectSettings/EditorBuildSettings.asset


--------------------------------------------------------------------------------
/ProjectSettings/UnityConnectSettings.asset:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andresgutierrez/em/HEAD/ProjectSettings/UnityConnectSettings.asset


--------------------------------------------------------------------------------
/Assets/Scenes/Start.unity.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: c79e0f6becadc4c97a8f13e0f5c801ba
3 | timeCreated: 1497107141
4 | licenseType: Pro
5 | DefaultImporter:
6 |   userData: 
7 |   assetBundleName: 
8 |   assetBundleVariant: 
9 | 


--------------------------------------------------------------------------------
/Assets/Resources.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: f9219ad7393544403ae80c2bfd042f37
 3 | folderAsset: yes
 4 | timeCreated: 1497108509
 5 | licenseType: Pro
 6 | DefaultImporter:
 7 |   userData: 
 8 |   assetBundleName: 
 9 |   assetBundleVariant: 
10 | 


--------------------------------------------------------------------------------
/Assets/Scenes.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: b82c1a64fa2f14398a2104fa5ad58a78
 3 | folderAsset: yes
 4 | timeCreated: 1497107642
 5 | licenseType: Pro
 6 | DefaultImporter:
 7 |   userData: 
 8 |   assetBundleName: 
 9 |   assetBundleVariant: 
10 | 


--------------------------------------------------------------------------------
/Assets/Scripts.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 7ad7ecc18c17c43eaa6457da9445eb77
 3 | folderAsset: yes
 4 | timeCreated: 1497107658
 5 | licenseType: Pro
 6 | DefaultImporter:
 7 |   userData: 
 8 |   assetBundleName: 
 9 |   assetBundleVariant: 
10 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Input.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 51236dced3ef54fc488cd72c4152fc50
 3 | folderAsset: yes
 4 | timeCreated: 1497214613
 5 | licenseType: Pro
 6 | DefaultImporter:
 7 |   userData: 
 8 |   assetBundleName: 
 9 |   assetBundleVariant: 
10 | 


--------------------------------------------------------------------------------
/Assets/Scripts/State.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: a2bf7a5c3321b409a85929ce1380d6f9
 3 | folderAsset: yes
 4 | timeCreated: 1497333108
 5 | licenseType: Pro
 6 | DefaultImporter:
 7 |   userData: 
 8 |   assetBundleName: 
 9 |   assetBundleVariant: 
10 | 


--------------------------------------------------------------------------------
/Assets/Scripts/VM.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: a82dc8d7d7fb74d4b822234c97376f68
 3 | folderAsset: yes
 4 | timeCreated: 1497203077
 5 | licenseType: Pro
 6 | DefaultImporter:
 7 |   userData: 
 8 |   assetBundleName: 
 9 |   assetBundleVariant: 
10 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Graphics.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 63544ee9482f54034945123cb2f08309
 3 | folderAsset: yes
 4 | timeCreated: 1497202770
 5 | licenseType: Pro
 6 | DefaultImporter:
 7 |   userData: 
 8 |   assetBundleName: 
 9 |   assetBundleVariant: 
10 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Graphics/TileData.cs:
--------------------------------------------------------------------------------
 1 | 
 2 | using System;
 3 | 
 4 | namespace GB.Graphics
 5 | {
 6 |     [Serializable]
 7 |     public class TileData
 8 |     {
 9 |         public bool initialized;
10 |         public bool transparent;
11 |         public int[] tiles;
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/Assets/Scripts/CPU.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: f31bb1d29523e4f94a263bcd4976a877
 3 | timeCreated: 1497212660
 4 | licenseType: Pro
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Clock.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 1f21e729554ce4746b2696b03521136f
 3 | timeCreated: 1497202339
 4 | licenseType: Pro
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Core.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: d4cd65f25952f45c9a40550fc95b45da
 3 | timeCreated: 1497107681
 4 | licenseType: Pro
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Data.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 811ce5fb0e7bf45879065c68fb6aa850
 3 | timeCreated: 1497113032
 4 | licenseType: Pro
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Loader.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: af8253fb6ece64b10b2e1564f436987b
 3 | timeCreated: 1497108409
 4 | licenseType: Pro
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Memory.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 87e22381175a64d42be3e59e0bf468dc
 3 | timeCreated: 1497205932
 4 | licenseType: Pro
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Utils.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 8560ca4717be24a359939eede82dcc3e
 3 | timeCreated: 1497326193
 4 | licenseType: Pro
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Graphics/Lcd.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: f2bd1e0268bed4238a751c3d38e01960
 3 | timeCreated: 1497115895
 4 | licenseType: Pro
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Settings.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 419721b016f83449d9314d2a6de62a95
 3 | timeCreated: 1497122698
 4 | licenseType: Pro
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Assets/Scripts/State/State.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 864025171c4ff4f45a31b3bda25fad6e
 3 | timeCreated: 1497332710
 4 | licenseType: Pro
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Assets/Scripts/TickTables.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: e3c113ac47ec84a978fb481474ccfb75
 3 | timeCreated: 1497124668
 4 | licenseType: Pro
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Assets/Scripts/VM/MainVM.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: cfa2a5af73d5d471faafc1c1524e7d56
 3 | timeCreated: 1497129243
 4 | licenseType: Pro
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Graphics/Drawer.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 36cfa1708af2742978d45a1081718961
 3 | timeCreated: 1497104794
 4 | licenseType: Pro
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Graphics/Screen.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 76006f8a813bf499ea8c50b549783fc9
 3 | timeCreated: 1497198026
 4 | licenseType: Pro
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Graphics/TileData.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: a2b25273c57444b7bb0a44c66e6d5e48
 3 | timeCreated: 1497204450
 4 | licenseType: Pro
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Input/KeyButton.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: bd54b724b36884777988e56e5381cb7c
 3 | timeCreated: 1497227781
 4 | licenseType: Pro
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Input/Keyboard.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 779e268a103ef464db1a27f67e86250d
 3 | timeCreated: 1497214623
 4 | licenseType: Pro
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Assets/Scripts/State/SaveState.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 19371c28b563e45f9aa466f567f445eb
 3 | timeCreated: 1497333365
 4 | licenseType: Pro
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Assets/Scripts/VM/ExtendedVM.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: e552c08451e32417bb2c21c1cb0cf5b7
 3 | timeCreated: 1497134602
 4 | licenseType: Pro
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Input/LoaderButton.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 6d65d1dc1dba04702b9f4cdd40c17178
 3 | timeCreated: 1497227781
 4 | licenseType: Pro
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Assets/Scripts/State/SaveState.cs:
--------------------------------------------------------------------------------
 1 | using GB;
 2 | using UnityEngine;
 3 | using UnityEngine.UI;
 4 | 
 5 | public class SaveState : MonoBehaviour
 6 | {
 7 |     private void Start()
 8 |     {
 9 |         GetComponent<Button>().onClick.AddListener(Save);
10 |     }
11 | 
12 |     private void Save()
13 |     {
14 |         Loader.instance.core.memory.SaveState();
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Input/LoaderButton.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | using UnityEngine.EventSystems;
 3 | 
 4 | namespace GB.Input
 5 | {
 6 |     public class LoaderButton : MonoBehaviour, IPointerUpHandler
 7 |     {
 8 |         [SerializeField]
 9 |         private string name;
10 | 
11 |         public void OnPointerUp(PointerEventData eventData)
12 |         {
13 |             Loader.instance.Load(name);
14 |         }
15 |     }
16 | }


--------------------------------------------------------------------------------
/Assets/Scripts/Input/KeyButton.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | using UnityEngine.EventSystems;
 3 | 
 4 | namespace GB.Input
 5 | {
 6 |     public class KeyButton : MonoBehaviour, IPointerUpHandler, IPointerDownHandler
 7 |     {
 8 |         [SerializeField]
 9 |         private KeyCode key;
10 | 
11 |         public void OnPointerUp(PointerEventData eventData)
12 |         {
13 |             Loader.instance.core.keyboard.JoyPadEvent(key, false);
14 |         }
15 | 
16 |         public void OnPointerDown(PointerEventData eventData)
17 |         {
18 |             Loader.instance.core.keyboard.JoyPadEvent(key, true);
19 |         }
20 |     }
21 | }


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | /[Ll]ibrary/
 2 | /[Tt]emp/
 3 | /[Oo]bj/
 4 | /[Bb]uild/
 5 | /[Bb]uilds/
 6 | /Assets/AssetStoreTools*
 7 | 
 8 | # Visual Studio 2015 cache directory
 9 | /.vs/
10 | 
11 | # Autogenerated VS/MD/Consulo solution and project files
12 | ExportedObj/
13 | .consulo/
14 | *.csproj
15 | *.unityproj
16 | *.sln
17 | *.suo
18 | *.tmp
19 | *.user
20 | *.userprefs
21 | *.pidb
22 | *.booproj
23 | *.svd
24 | *.pdb
25 | 
26 | # Unity3D generated meta files
27 | *.pidb.meta
28 | 
29 | # Unity3D Generated File On Crash Reports
30 | sysinfo.txt
31 | 
32 | # Builds
33 | *.apk
34 | *.unitypackage
35 | 
36 | Assets/Resources/*.bytes
37 | Assets/Resources/*.bytes.meta
38 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Settings.cs:
--------------------------------------------------------------------------------
 1 | 
 2 | namespace GB
 3 | {
 4 |     public class Settings
 5 |     {
 6 |         public static int audioGranularity = 20;
 7 | 
 8 |         public static bool autoFrameskip = true;
 9 | 
10 |         public static bool colorize = false;
11 | 
12 |         public static int frameskipAmout = 0;
13 | 
14 |         public static int frameskipBaseFactor = 10;
15 | 
16 |         public static int frameskipMax = 29;
17 | 
18 |         public static int loopInterval = 17;
19 | 
20 | #if UNITY_EDITOR
21 |         public static int machineCyclesPerLoop = 17826;
22 | #else
23 |         public static int machineCyclesPerLoop = (int)(17826 * 2.5);
24 | #endif
25 | 
26 |         public static bool overrideMBC = true;
27 | 
28 |         public static bool priorizeGameBoyMode = false;
29 |     }
30 | }


--------------------------------------------------------------------------------
/Assets/Scripts/Utils.cs:
--------------------------------------------------------------------------------
 1 | 
 2 | namespace GB
 3 | {
 4 |     public class Utils
 5 |     {
 6 |         public static long Usbtsb(long ubyte)
 7 |         {
 8 |             //Unsigned byte to signed byte:
 9 |             return (ubyte > 0x7F) ? ((ubyte & 0x7F) - 0x80) : ubyte;
10 |         }
11 | 
12 |         public static long Unswtuw(long uword)
13 |         {
14 |             //Keep an unsigned word unsigned:
15 |             if (uword < 0)
16 |                 uword += 0x10000;
17 |             return uword; //If this function is called, no wrapping requested.
18 |         }
19 | 
20 |         public static long Unsbtub(long ubyte)
21 |         {
22 |             //Keep an unsigned byte unsigned:
23 |             if (ubyte < 0)
24 |                 ubyte += 0x100;
25 |             return ubyte; //If this function is called, no wrapping requested.
26 |         }
27 | 
28 |         public static long Nswtuw(long uword)
29 |         {
30 |             //Keep an unsigned word unsigned:
31 |             if (uword < 0)
32 |                 uword += 0x10000;
33 |             return uword & 0xFFFF; //Wrap also...
34 |         }
35 |     }
36 | }


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2017 Andres Gutierrez
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Assets/Scripts/CPU.cs:
--------------------------------------------------------------------------------
 1 | 
 2 | using System;
 3 | 
 4 | namespace GB
 5 | {
 6 |     [Serializable]
 7 |     public class CPU
 8 |     {
 9 |         [NonSerialized]
10 |         private Core core;
11 | 
12 |         public long registerA;
13 | 
14 |         public long registerB;
15 | 
16 |         public long registerC;
17 | 
18 |         public long registerD;
19 | 
20 |         public long registerE;
21 | 
22 |         public bool flagZero;
23 | 
24 |         public bool flagSubtract;
25 | 
26 |         public bool flagHalfCarry;
27 | 
28 |         public bool flagCarry;
29 | 
30 |         public long registersHL;
31 | 
32 |         public long programCounter;
33 | 
34 |         public long stackPointer;
35 | 
36 |         public CPU(Core core)
37 |         {
38 |             this.core = core;
39 |         }
40 | 
41 |         public void Initialize()
42 |         {
43 |             programCounter = 0x100;
44 |             stackPointer = 0xFFFE;
45 |             registerA = core.cGBC ? 0x11 : 0x1;
46 |             registerB = 0;
47 |             registerC = 0x13;
48 |             registerD = 0;
49 |             registerE = 0xD8;
50 |             flagZero = true;
51 |             flagSubtract = false;
52 |             flagHalfCarry = true;
53 |             flagCarry = true;
54 |             registersHL = 0x014D;
55 |         }
56 |     }
57 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | 
 2 | # Em
 3 | 
 4 | ![GB1](https://thumbs.gfycat.com/PlainWellwornAffenpinscher-size_restricted.gif)
 5 | ![GB2](https://thumbs.gfycat.com/WeirdHighKitty-size_restricted.gif)
 6 | 
 7 | Em is a GameBoy emulator written in Unity/C# for iPhone/iPad/Android. Other platforms should work fine as well.
 8 | Only GameBoy ROMs are supported, GameBoy Color ROMs are work in progress.
 9 | 
10 | ## Requirements
11 | 
12 | Unity 5.6+ is required to execute and generate builds of the emulator. iOS builds were using XCode 8.3.
13 | 
14 | ## Documentation
15 | 
16 | You can find information about the many details and internals of Game Boy Development [here](https://github.com/avivace/awesome-gbdev).
17 | 
18 | ## Tests
19 | 
20 | CPU instruction set accuracy test results ([Blargg's cpu_instrs.gb](http://gbdev.gg8.se/files/roms/blargg-gb-tests/) test ROM):
21 | 
22 | <img src="https://s23.postimg.org/uox8s2et7/Screen_Shot_2017-06-12_at_11.21.37_PM.png" width="200">
23 | 
24 | ## TODO
25 | 
26 | - [x] Support Game Boy Classic ROMs
27 | - [x] Keyboard/Mobile Controls
28 | - [x] Support Game Boy Color ROMs
29 | - [x] MBCRAM/SRAM memory is persisted between sessions
30 | - [ ] Improve UI
31 | - [ ] Sound
32 | - [ ] Save/Restore state
33 | 
34 | ## Known Issues
35 | 
36 | GBC emulation have some minor graphic glitches
37 | 
38 | ## Credits
39 | 
40 | Memory Management partially ported from GameBoyCore.
41 | Partially ported video, HDMA, and double speed mode procedure from the STOP opcode from MeBoy 2.2
42 | 
43 | ## License
44 | 
45 | Em is open-source software released under [MIT license](https://en.wikipedia.org/wiki/MIT_License).
46 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Input/Keyboard.cs:
--------------------------------------------------------------------------------
 1 | 
 2 | using UnityEngine;
 3 | 
 4 | namespace GB.Input
 5 | {
 6 |     public class Keyboard
 7 |     {
 8 |         private Core core;
 9 | 
10 |         public long JoyPad = 0xFF;
11 | 
12 |         public Keyboard(Core core)
13 |         {
14 |             this.core = core;
15 |         }
16 | 
17 |         public void JoyPadEvent(KeyCode key, bool down)
18 |         {
19 |             int keyCode = 0;
20 | 
21 |             switch (key)
22 |             {
23 |                 case KeyCode.RightArrow:
24 |                     keyCode = 0;
25 |                     break;
26 |                 case KeyCode.LeftArrow:
27 |                     keyCode = 1;
28 |                     break;
29 |                 case KeyCode.UpArrow:
30 |                     keyCode = 2;
31 |                     break;
32 |                 case KeyCode.DownArrow:
33 |                     keyCode = 3;
34 |                     break;
35 |                 case KeyCode.Z:
36 |                     keyCode = 4;
37 |                     break;
38 |                 case KeyCode.X:
39 |                     keyCode = 5;
40 |                     break;
41 |                 case KeyCode.RightShift:
42 |                     keyCode = 6;
43 |                     break;
44 |                 case KeyCode.Return:
45 |                     keyCode = 7;
46 |                     break;
47 |             }
48 | 
49 |             if (down)
50 |                 JoyPad &= 0xFF ^ (1 << keyCode);
51 |             else
52 |                 JoyPad |= (1 << keyCode);
53 | 
54 |             core.memory.memory[0xFF00] = (core.memory.memory[0xFF00] & 0x30) + ((((core.memory.memory[0xFF00] & 0x20) == 0) ? (JoyPad >> 4) : 0xF) & (((core.memory.memory[0xFF00] & 0x10) == 0) ? (JoyPad & 0xF) : 0xF));
55 |         }
56 |     }
57 | 
58 | }
59 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Loader.cs:
--------------------------------------------------------------------------------
 1 | 
 2 | using GB.Graphics;
 3 | using UnityEngine;
 4 | using UnityInput = UnityEngine.Input;
 5 | 
 6 | namespace GB
 7 | {
 8 |     public class Loader : MonoBehaviour
 9 |     {
10 |         public static Loader instance;
11 | 
12 |         [SerializeField]
13 |         public Drawer drawer;
14 | 
15 |         public Core core;
16 | 
17 |         private KeyCode[] keys = {
18 |             KeyCode.UpArrow, KeyCode.DownArrow, KeyCode.LeftArrow, KeyCode.RightArrow,
19 |             KeyCode.X, KeyCode.Z, KeyCode.Return, KeyCode.RightShift
20 |         };
21 | 
22 |         private void Awake()
23 |         {
24 |             if (instance == null)
25 |                 instance = this;
26 |         }
27 | 
28 |         private void Start()
29 |         {
30 |             Load("CPU");
31 |         }
32 | 
33 |         public void Load(string path)
34 |         {
35 |             if (core != null)
36 |             {
37 |                 SaveSRAM();
38 |                 core.initialized = false;
39 |             }
40 | 
41 |             core = new Core(Resources.Load(path) as TextAsset, drawer);
42 |             core.Start();
43 |         }
44 | 
45 |         private void Update()
46 |         {
47 |             if (core.initialized)
48 |             {
49 |                 core.Run();
50 | 
51 | #if UNITY_EDITOR
52 |                 for (int i = 0; i < keys.Length; i++)
53 |                 {
54 |                     if (UnityInput.GetKeyDown(keys[i]))
55 |                         core.keyboard.JoyPadEvent(keys[i], true);
56 | 
57 |                     if (UnityInput.GetKeyUp(keys[i]))
58 |                         core.keyboard.JoyPadEvent(keys[i], false);
59 |                 }
60 | #endif
61 |             }
62 |         }
63 | 
64 |         private void SaveSRAM()
65 |         {
66 |             if (core.initialized)
67 |                 core.memory.SaveSRAM();
68 |         }
69 | 
70 |         private void OnApplicationQuit()
71 |         {
72 |             SaveSRAM();
73 |         }
74 |     }
75 | }


--------------------------------------------------------------------------------
/Assets/Scripts/TickTables.cs:
--------------------------------------------------------------------------------
 1 | 
 2 | namespace GB
 3 | {
 4 |     class TICKTables
 5 |     {
 6 |         public static long[] primary = new long[] {
 7 |             //Number of machine cycles for each instruction:
 8 | 	        /*  0, 1, 2, 3, 4, 5, 6, 7,     8, 9, A, B, C, D, E, F*/
 9 | 	        1, 3, 2, 2, 1, 1, 2, 1, 5, 2, 2, 2, 1, 1, 2, 1, //0
10 | 	        1, 3, 2, 2, 1, 1, 2, 1, 3, 2, 2, 2, 1, 1, 2, 1, //1
11 | 	        2, 3, 2, 2, 1, 1, 2, 1, 2, 2, 2, 2, 1, 1, 2, 1, //2
12 | 	        2, 3, 2, 2, 3, 3, 3, 1, 2, 2, 2, 2, 1, 1, 2, 1, //3
13 | 
14 | 	        1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, //4
15 | 	        1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, //5
16 | 	        1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, //6
17 | 	        2, 2, 2, 2, 2, 2, 1, 2, 1, 1, 1, 1, 1, 1, 2, 1, //7
18 | 
19 | 	        1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, //8
20 | 	        1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, //9
21 | 	        1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, //A
22 | 	        1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, //B
23 | 
24 | 	        2, 3, 3, 4, 3, 4, 2, 4, 2, 4, 3, 2, 3, 6, 2, 4, //C
25 | 	        2, 3, 3, 1, 3, 4, 2, 4, 2, 4, 3, 1, 3, 1, 2, 4, //D
26 | 	        3, 3, 2, 1, 1, 4, 2, 4, 4, 1, 4, 1, 1, 1, 2, 4, //E
27 | 	        3, 3, 2, 1, 1, 4, 2, 4, 3, 2, 4, 1, 0, 1, 2, 4, //F
28 |          };
29 | 
30 |         public static long[] secondary = new long[]  {
31 |             //Number of machine cycles for each 0xCBXX instruction:
32 | 	        /*  0, 1, 2, 3, 4, 5, 6, 7,     8, 9, A, B, C, D, E, F*/
33 | 	        2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2, //0
34 | 	        2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2, //1
35 | 	        2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2, //2
36 | 	        2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2, //3
37 | 
38 | 	        2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2, //4
39 | 	        2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2, //5
40 | 	        2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2, //6
41 | 	        2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2, //7
42 | 
43 | 	        2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2, //8
44 | 	        2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2, //9
45 | 	        2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2, //A
46 | 	        2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2, //B
47 | 
48 | 	        2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2, //C
49 | 	        2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2, //D
50 | 	        2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2, //E
51 | 	        2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2, //F
52 |         };
53 |     }
54 | }


--------------------------------------------------------------------------------
/Assets/Scripts/Graphics/Drawer.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | 
 3 | namespace GB.Graphics
 4 | {
 5 |     public class Drawer : MonoBehaviour
 6 |     {
 7 |         private Texture2D mainTexture;
 8 | 
 9 |         private SpriteRenderer sr;
10 | 
11 |         private Rect rect;
12 | 
13 |         private Vector2 pivot;
14 | 
15 |         private long[] prevCanvasBuffer;
16 | 
17 |         private void Awake()
18 |         {
19 |             mainTexture = new Texture2D(160, 144);
20 |             rect = new Rect(0, 0, mainTexture.width, mainTexture.height);
21 |             pivot = new Vector2(0.5f, 0.5f);
22 |             sr = GetComponent<SpriteRenderer>();
23 |         }
24 | 
25 |         public void Draw(long[] canvasBuffer)
26 |         {
27 |             if (prevCanvasBuffer != null && AreEquals(prevCanvasBuffer, canvasBuffer))
28 |                 return;
29 | 
30 |             Color black = Color.black;
31 |             Color white = Color.white;
32 | 
33 |             for (int j = 0; j < 144; j++)
34 |             {
35 |                 for (int i = 0; i < 160; i++)
36 |                 {
37 |                     int pixelCanvasNumber = i + (160 * j);
38 | 
39 |                     long pixel = canvasBuffer[pixelCanvasNumber];
40 |                     long prevPixel = prevCanvasBuffer != null ? prevCanvasBuffer[pixelCanvasNumber] : -1;
41 | 
42 |                     if (pixel != prevPixel)
43 |                     {
44 |                         if (pixel != 0)
45 |                         {
46 |                             long r = (pixel >> 16) & 0xFF;
47 |                             long g = (pixel >> 8) & 0xFF;
48 |                             long b = pixel & 0xFF;
49 |                             mainTexture.SetPixel(i, j, new Color(r / 255f, g / 255f, b / 255f));
50 |                         }
51 |                         else
52 |                             mainTexture.SetPixel(i, j, white);
53 |                     }
54 |                 }
55 |             }
56 | 
57 |             mainTexture.Apply();
58 | 
59 |             if (sr.sprite == null)
60 |                 sr.sprite = Sprite.Create(mainTexture, rect, pivot, 1);
61 | 
62 |             if (prevCanvasBuffer == null)
63 |                 prevCanvasBuffer = new long[canvasBuffer.Length];
64 | 
65 |             for (int i = 0; i < canvasBuffer.Length; i++)
66 |                 prevCanvasBuffer[i] = canvasBuffer[i];
67 |         }
68 | 
69 |         private bool AreEquals(long[] a, long[] b)
70 |         {
71 |             for (int i = 0; i < a.Length; i++)
72 |                 if (a[i] != b[i])
73 |                     return false;
74 |             return true;
75 |         }
76 |     }
77 | }


--------------------------------------------------------------------------------
/Assets/Scripts/Clock.cs:
--------------------------------------------------------------------------------
  1 | 
  2 | using System;
  3 | using UnityEngine;
  4 | 
  5 | namespace GB
  6 | {
  7 |     [Serializable]
  8 |     public class Clock
  9 |     {
 10 |         [NonSerialized]
 11 |         private Core core;
 12 | 
 13 |         private bool RTCisLatched = true;
 14 | 
 15 |         private long RTCSeconds;
 16 | 
 17 |         private long RTCMinutes;
 18 | 
 19 |         private long RTCHours = 0;
 20 | 
 21 |         private long RTCDays = 0;
 22 | 
 23 |         private bool RTCDayOverFlow = false;
 24 | 
 25 |         private bool RTCHALT = false;
 26 | 
 27 |         private long latchedSeconds;
 28 | 
 29 |         private long latchedMinutes;
 30 | 
 31 |         private long latchedHours;
 32 | 
 33 |         private long latchedLDays;
 34 | 
 35 |         private long latchedHDays;
 36 | 
 37 |         private bool enabled;
 38 | 
 39 |         public float lastIteration;
 40 | 
 41 |         public bool Enabled
 42 |         {
 43 |             get { return enabled; }
 44 |             set { enabled = value; }
 45 |         }
 46 | 
 47 |         public Clock(Core core, bool enabled = false)
 48 |         {
 49 |             this.core = core;
 50 |             this.enabled = enabled;
 51 |         }
 52 | 
 53 |         public void Update()
 54 |         {
 55 |             if (Settings.autoFrameskip || enabled)
 56 |             {
 57 |                 float currentTime = Time.time;
 58 |                 float timeElapsed = currentTime - lastIteration;
 59 | 
 60 |                 if (enabled && !RTCHALT)
 61 |                 {
 62 |                     DateTime now = DateTime.Now;
 63 |                     RTCSeconds = now.Second;
 64 |                     RTCHours = now.Hour;
 65 |                     RTCMinutes = now.Minute;
 66 |                     RTCDays = now.DayOfYear;
 67 |                 }
 68 | 
 69 |                 if (Settings.autoFrameskip)
 70 |                 {
 71 |                     if (timeElapsed > Settings.loopInterval)
 72 |                     {
 73 |                         if (Settings.frameskipAmout < Settings.frameskipMax)
 74 |                             ++Settings.frameskipAmout;
 75 |                     }
 76 |                     else if (Settings.frameskipAmout > 0)
 77 |                     {
 78 |                         --Settings.frameskipAmout;
 79 |                     }
 80 |                 }
 81 | 
 82 |                 lastIteration = Time.time;
 83 |             }
 84 |         }
 85 | 
 86 |         public void CheckLatched(long data)
 87 |         {
 88 |             if (data == 0)
 89 |             {
 90 |                 RTCisLatched = false;
 91 |                 return;
 92 |             }
 93 | 
 94 |             if (!RTCisLatched)
 95 |             {
 96 |                 RTCisLatched = true;
 97 |                 latchedSeconds = RTCSeconds;
 98 |                 latchedMinutes = RTCMinutes;
 99 |                 latchedHours = RTCHours;
100 |                 latchedLDays = RTCDays & 0xFF;
101 |                 latchedHDays = RTCDays >> 8;
102 |             }
103 |         }
104 | 
105 |         public void SetClock(long address, long data, long currMBCRAMBank, long currMBCRAMBankPosition)
106 |         {
107 |             switch (currMBCRAMBank)
108 |             {
109 |                 case 0x00:
110 |                 case 0x01:
111 |                 case 0x02:
112 |                 case 0x03:
113 |                     core.memory.MBCRam[address + currMBCRAMBankPosition] = data;
114 |                     break;
115 | 
116 |                 case 0x08:
117 |                     if (data < 60)
118 |                         RTCSeconds = data;
119 |                     break;
120 | 
121 |                 case 0x09:
122 |                     if (data < 60)
123 |                         RTCMinutes = data;
124 |                     break;
125 | 
126 |                 case 0x0A:
127 |                     if (data < 24)
128 |                         RTCHours = data;
129 |                     break;
130 | 
131 |                 case 0x0B:
132 |                     RTCDays = (data & 0xFF) | (RTCDays & 0x100);
133 |                     break;
134 | 
135 |                 case 0x0C:
136 |                     RTCDayOverFlow = (data & 0x80) == 0x80;
137 |                     RTCHALT = (data & 0x40) == 0x40;
138 |                     RTCDays = ((data & 0x1) << 8) | (RTCDays & 0xFF);
139 |                     break;
140 |             }
141 |         }
142 | 
143 |         public long GetTime(long currMBCRAMBank, long currMBCRAMBankPosition, long address)
144 |         {
145 |             switch (currMBCRAMBank)
146 |             {
147 |                 case 0x00:
148 |                 case 0x01:
149 |                 case 0x02:
150 |                 case 0x03:
151 |                     return core.memory.MBCRam[address + currMBCRAMBankPosition];
152 |                 case 0x08:
153 |                     return latchedSeconds;
154 |                 case 0x09:
155 |                     return latchedMinutes;
156 |                 case 0x0A:
157 |                     return latchedHours;
158 |                 case 0x0B:
159 |                     return latchedLDays;
160 |                 case 0x0C:
161 |                     return (((RTCDayOverFlow) ? 0x80 : 0) + ((RTCHALT) ? 0x40 : 0)) + latchedHDays;
162 |             }
163 | 
164 |             return 0xFF; //memoryReadBAD
165 |         }
166 |     }
167 | }


--------------------------------------------------------------------------------
/Assets/Scripts/Graphics/Lcd.cs:
--------------------------------------------------------------------------------
  1 | 
  2 | using System;
  3 | using UnityEngine;
  4 | 
  5 | namespace GB.Graphics
  6 | {
  7 |     public class Lcd
  8 |     {
  9 |         private Core core;
 10 | 
 11 |         private Memory memory;
 12 | 
 13 |         public long currentScanLine = 0;
 14 | 
 15 |         public bool LCDisOn = false;
 16 | 
 17 |         public bool LYCMatchTriggerSTAT = false;
 18 | 
 19 |         public long modeSTAT = 0;
 20 | 
 21 |         public bool mode0TriggerSTAT = false;
 22 | 
 23 |         public bool mode1TriggerSTAT = false;
 24 | 
 25 |         public bool mode2TriggerSTAT = false;
 26 | 
 27 |         public long STATTracker = 0;
 28 | 
 29 |         public Lcd(Core core)
 30 |         {
 31 |             this.core = core;
 32 |             this.memory = core.memory;
 33 |         }
 34 | 
 35 |         public void CheckIfLYCMatch()
 36 |         {
 37 |             // LY - LYC Compare
 38 |             // If LY==LCY
 39 |             if (memory.memory[0xFF44] == memory.memory[0xFF45])
 40 |             {
 41 |                 memory.memory[0xFF41] |= 0x04; // set STAT bit 2: LY-LYC coincidence flag
 42 |                 if (LYCMatchTriggerSTAT)
 43 |                     memory.memory[0xFF0F] |= 0x2; // set IF bit 1                
 44 |             }
 45 |             else
 46 |             {
 47 |                 core.memory.memory[0xFF41] &= 0xFB; // reset STAT bit 2 (LY!=LYC)
 48 |             }
 49 |         }
 50 | 
 51 |         private void NotifyScanline()
 52 |         {
 53 |             if (currentScanLine == 0)
 54 |                 core.screen.windowSourceLine = 0;
 55 | 
 56 |             // determine the left edge of the window (160 if window is inactive)
 57 |             long windowLeft = (core.screen.gfxWindowDisplay && core.memory.memory[0xFF4A] <= currentScanLine) ? Math.Min(160, core.memory.memory[0xFF4B] - 7) : 160;
 58 | 
 59 |             // step 1: background+window
 60 |             bool skippedAnything = core.screen.DrawBackgroundForLine(currentScanLine, windowLeft, 0);
 61 | 
 62 |             // At this point, the high (alpha) byte in the frameBuffer is 0xff for colors 1,2,3 and
 63 |             // 0x00 for color 0. Foreground sprites draw on all colors, background sprites draw on
 64 |             // top of color 0 only.
 65 |             // step 2: sprites
 66 |             core.screen.DrawSpritesForLine(currentScanLine);
 67 | 
 68 |             // step 3: prio tiles+windo
 69 |             if (skippedAnything)
 70 |                 core.screen.DrawBackgroundForLine(currentScanLine, windowLeft, 0x80);
 71 | 
 72 |             if (windowLeft < 160)
 73 |                 ++core.screen.windowSourceLine;
 74 |         }
 75 | 
 76 |         public void ScanLine(long line)
 77 |         {
 78 |             //When turned off = Do nothing!
 79 |             if (LCDisOn)
 80 |             {
 81 |                 if (line < 143)
 82 |                 {
 83 |                     //We're on a normal scan line:
 84 |                     if (core.LCDTicks < 20)
 85 |                         ScanLineMode2(); // mode2: 80 cycles                    
 86 |                     else if (core.LCDTicks < 63)
 87 |                         ScanLineMode3(); // mode3: 172 cycles                    
 88 |                     else if (core.LCDTicks < 114)
 89 |                         ScanLineMode0(); // mode0: 204 cycles                    
 90 |                     else
 91 |                     {
 92 |                         core.LCDTicks -= 114;
 93 |                         currentScanLine = ++memory.memory[0xFF44];
 94 |                         CheckIfLYCMatch();
 95 |                         if (STATTracker != 2)
 96 |                         {
 97 |                             if (core.hdmaRunning && !core.halt && LCDisOn)
 98 |                                 core.screen.PerformHDMA();
 99 |                             
100 |                             if (mode0TriggerSTAT)
101 |                                 memory.memory[0xFF0F] |= 0x2; // set IF bit 1                            
102 |                         }
103 |                         STATTracker = 0;
104 |                         ScanLineMode2();
105 |                         if (core.LCDTicks >= 114)
106 |                         {
107 |                             core.NotifyScanline();
108 |                             ScanLine(currentScanLine);
109 |                         }
110 |                     }
111 |                 }
112 |                 else if (line == 143)
113 |                 {
114 |                     if (core.LCDTicks < 20)
115 |                         ScanLineMode2();
116 |                     else if (core.LCDTicks < 63)
117 |                         ScanLineMode3();
118 |                     else if (core.LCDTicks < 114)
119 |                         ScanLineMode0();
120 |                     else
121 |                     {
122 |                         //Starting V-Blank:
123 |                         //Just finished the last visible scan line:
124 |                         core.LCDTicks -= 114;
125 |                         currentScanLine = ++memory.memory[0xFF44];
126 |                         CheckIfLYCMatch();
127 | 
128 |                         if (mode1TriggerSTAT)
129 |                             memory.memory[0xFF0F] |= 0x2; // set IF bit 1                        
130 | 
131 |                         if (STATTracker != 2)
132 |                         {
133 |                             if (core.hdmaRunning && !core.halt && LCDisOn)
134 |                                 core.screen.PerformHDMA();                            
135 | 
136 |                             if (mode0TriggerSTAT)
137 |                                 memory.memory[0xFF0F] |= 0x2; // set IF bit 1                            
138 |                         }
139 | 
140 |                         STATTracker = 0;
141 |                         modeSTAT = 1;
142 |                         memory.memory[0xFF0F] |= 0x1;
143 | 
144 |                         if (core.screen.drewBlank > 0)
145 |                             --core.screen.drewBlank;
146 | 
147 |                         if (core.LCDTicks >= 114)
148 |                             ScanLine(currentScanLine);
149 |                     }
150 |                 }
151 |                 else if (line < 153)
152 |                 {
153 |                     //In VBlank
154 |                     if (core.LCDTicks >= 114)
155 |                     {
156 |                         //We're on a new scan line:
157 |                         core.LCDTicks -= 114;
158 |                         currentScanLine = ++core.memory.memory[0xFF44];
159 |                         CheckIfLYCMatch();
160 |                         if (core.LCDTicks >= 114)
161 |                             ScanLine(currentScanLine);
162 |                     }
163 |                 }
164 |                 else
165 |                 {
166 |                     //VBlank Ending (We're on the last actual scan line)
167 |                     if (memory.memory[0xFF44] == 153)
168 |                     {
169 |                         memory.memory[0xFF44] = 0; //LY register resets to 0 early.
170 |                         CheckIfLYCMatch(); //LY==LYC Test is early here (Fixes specific one-line glitches (example: Kirby2 intro)).
171 |                     }
172 |                     if (core.LCDTicks >= 114)
173 |                     {
174 |                         //We reset back to the beginning:
175 |                         core.LCDTicks -= 114;
176 |                         currentScanLine = 0;
177 |                         ScanLineMode2(); // mode2: 80 cycles
178 |                         if (core.LCDTicks >= 114)
179 |                         {
180 |                             //We need to skip 1 or more scan lines:
181 |                             ScanLine(currentScanLine); //Scan Line and STAT Mode Control
182 |                         }
183 |                     }
184 |                 }
185 |             }
186 |         }
187 | 
188 |         public void ScanLineMode0()
189 |         {
190 |             // H-Blank
191 |             if (modeSTAT != 0)
192 |             {
193 |                 if (core.hdmaRunning && !core.halt && LCDisOn)
194 |                     core.screen.PerformHDMA();
195 | 
196 |                 if (mode0TriggerSTAT || (mode2TriggerSTAT && STATTracker == 0))
197 |                     memory.memory[0xFF0F] |= 0x2; // if STAT bit 3 . set IF bit1  
198 | 
199 |                 NotifyScanline();
200 |                 STATTracker = 2;
201 |                 modeSTAT = 0;
202 |             }
203 |         }
204 | 
205 |         public void ScanLineMode2()
206 |         {
207 |             if (modeSTAT != 2)
208 |             {
209 |                 if (mode2TriggerSTAT)
210 |                     memory.memory[0xFF0F] |= 0x2; // set IF bit 1				
211 |                 STATTracker = 1;
212 |                 modeSTAT = 2;
213 |             }
214 |         }
215 | 
216 |         public void ScanLineMode3()
217 |         {
218 |             if (modeSTAT != 3)
219 |                 if (mode2TriggerSTAT && STATTracker == 0)
220 |                     memory.memory[0xFF0F] |= 0x2; // set IF bit 1				
221 |             STATTracker = 1;
222 |             modeSTAT = 3;
223 |         }
224 |     }
225 | }


--------------------------------------------------------------------------------
/Assets/Scripts/Core.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using GB.Graphics;
  3 | using GB.Input;
  4 | using UnityEngine;
  5 | using Screen = GB.Graphics.Screen;
  6 | 
  7 | namespace GB
  8 | {
  9 |     public class Core
 10 |     {
 11 |         public bool initialized;
 12 | 
 13 |         // 1 Bank = 16 KBytes = 256 Kbits
 14 |         public readonly long[] ROMBanks = new long[] { 2, 4, 8, 16, 32, 64, 128, 256, 512 };
 15 | 
 16 |         public readonly long[] RAMBanks = new long[] { 0, 1, 2, 4, 16 };
 17 | 
 18 |         public long[] VRAM;
 19 | 
 20 |         public string name;
 21 | 
 22 |         public string gameCode;
 23 | 
 24 |         public byte cartridgeType;
 25 | 
 26 |         public bool cMBC1;
 27 | 
 28 |         public bool cMBC2;
 29 | 
 30 |         public bool cMBC3;
 31 | 
 32 |         public bool cMBC5;
 33 | 
 34 |         public bool cHuC3;
 35 | 
 36 |         public bool cSRAM;
 37 | 
 38 |         public bool cBATT;
 39 | 
 40 |         public bool cRUMBLE;
 41 | 
 42 |         public bool cTIMER;
 43 | 
 44 |         public bool IME = true;
 45 | 
 46 |         public bool cGBC;
 47 | 
 48 |         public bool inBootstrap = true;
 49 | 
 50 |         public bool hdmaRunning;
 51 | 
 52 |         public bool TIMAEnabled;
 53 | 
 54 |         public bool bgEnabled = true;
 55 | 
 56 |         public long stopEmulator = 3;
 57 | 
 58 |         public long CPUTicks;
 59 | 
 60 |         public bool halt;
 61 | 
 62 |         public long multiplier = 1;
 63 | 
 64 |         public bool skipPCIncrement;
 65 | 
 66 |         public long untilEnable;
 67 | 
 68 |         private long audioTicks = 0;
 69 | 
 70 |         private long emulatorTicks = 0;
 71 | 
 72 |         private long DIVTicks = 14;
 73 | 
 74 |         public long LCDTicks = 15;
 75 | 
 76 |         private long timerTicks = 0;
 77 | 
 78 |         public long TACClocker = 256;
 79 | 
 80 |         public Lcd lcd;
 81 | 
 82 |         public Memory memory;
 83 | 
 84 |         public Screen screen;
 85 | 
 86 |         public Clock clock;
 87 | 
 88 |         public CPU cpu;
 89 | 
 90 |         public Keyboard keyboard;
 91 | 
 92 |         public Core(TextAsset asset, Drawer drawer)
 93 |         {
 94 |             cpu = new CPU(this);
 95 |             memory = new Memory(this, asset.bytes);
 96 |             clock = new Clock(this);
 97 |             screen = new Screen(this, drawer);
 98 |             lcd = new Lcd(this);
 99 |             keyboard = new Keyboard(this);
100 |         }
101 | 
102 |         public void Start()
103 |         {
104 |             Settings.frameskipAmout = 0;
105 |             memory.InitMemory();
106 |             screen.InitVideoMemory();
107 |             CheckROM(memory.LoadROM());
108 |             screen.InitLCD();
109 |             Run();
110 | 
111 |             if ((stopEmulator & 2) == 0)
112 |                 throw new Exception("GameBoy is already running");
113 | 
114 |             if ((stopEmulator & 2) != 2)
115 |                 throw new Exception("GameBoy is not initialized");
116 | 
117 |             stopEmulator &= 1;
118 |             clock.lastIteration = (int)(Time.time);
119 | 
120 |             initialized = true;
121 |         }
122 | 
123 |         private void CheckROM(byte[] rom)
124 |         {
125 |             name = "";
126 |             for (int address = 0x134; address < 0x13F; address++)
127 |             {
128 |                 if (rom[address] > 0)
129 |                     name += Convert.ToChar(rom[address]);
130 |             }
131 | 
132 |             gameCode = "";
133 |             for (int address = 0x13F; address < 0x143; address++)
134 |             {
135 |                 if (rom[address] > 0)
136 |                     gameCode += Convert.ToChar(rom[address]);
137 |             }
138 | 
139 |             cartridgeType = rom[0x147];
140 | 
141 |             Debug.Log(name + " " + gameCode.Length + " " + cartridgeType);
142 | 
143 |             string MBCType = SetCartridgeFlags();
144 | 
145 |             long numROMBanks = ROMBanks[rom[0x148]];
146 | 
147 |             Debug.Log("Cartridge Type=" + MBCType);
148 |             Debug.Log("Memory RAM=" + RAMBanks[rom[0x149]]);
149 | 
150 |             switch (rom[0x143])
151 |             {
152 |                 case 0x00:
153 |                     cGBC = false;
154 |                     break;
155 |                 case 0x80:
156 |                     cGBC = !Settings.priorizeGameBoyMode;
157 |                     break;
158 |                 case 0xC0:
159 |                     cGBC = true;
160 |                     break;
161 |                 default:
162 |                     cGBC = false;
163 |                     break;
164 |             }
165 | 
166 |             Debug.Log("GBC Mode=" + rom[0x143] + " " + cGBC);
167 | 
168 |             inBootstrap = false;
169 |             memory.InitRAM();
170 |             screen.InitScreen();
171 |             InitSkipBootstrap();
172 | 
173 |             screen.CheckPaletteType();
174 |         }
175 | 
176 |         private string SetCartridgeFlags()
177 |         {
178 |             string MBCType = "";
179 | 
180 |             switch (cartridgeType)
181 |             {
182 |                 case 0x01:
183 |                     cMBC1 = true;
184 |                     MBCType = "MBC1";
185 |                     break;
186 |                 case 0x03:
187 |                     cMBC1 = true;
188 |                     cSRAM = true;
189 |                     cBATT = true;
190 |                     MBCType = "MBC1 + SRAM + BATT";
191 |                     break;
192 |                 case 0x06:
193 |                     cMBC2 = true;
194 |                     cBATT = true;
195 |                     MBCType = "MBC2 + BATT";
196 |                     break;
197 |                 case 0x0F:
198 |                     cMBC3 = true;
199 |                     cTIMER = true;
200 |                     cBATT = true;
201 |                     MBCType = "MBC3 + TIMER + BATT";
202 |                     break;
203 |                 case 0x10:
204 |                     cMBC3 = true;
205 |                     cTIMER = true;
206 |                     cBATT = true;
207 |                     cSRAM = true;
208 |                     MBCType = "MBC3 + TIMER + BATT + SRAM";
209 |                     break;
210 |                 case 0x13:
211 |                     cMBC3 = true;
212 |                     cSRAM = true;
213 |                     cBATT = true;
214 |                     MBCType = "MBC3 + SRAM + BATT";
215 |                     break;
216 |                 case 0x1B:
217 |                     cMBC5 = true;
218 |                     cSRAM = true;
219 |                     cBATT = true;
220 |                     MBCType = "MBC5 + SRAM + BATT";
221 |                     break;
222 |             }
223 | 
224 |             if (cTIMER)
225 |                 clock.Enabled = true;
226 | 
227 |             return MBCType;
228 |         }
229 | 
230 |         private void InitSkipBootstrap()
231 |         {
232 |             IME = true;
233 |             LCDTicks = 15;
234 |             DIVTicks = 14;
235 |             cpu.Initialize();
236 | 
237 |             long address = 0xFF;
238 |             while (address >= 0)
239 |             {
240 |                 if (address >= 0x30 && address < 0x40)
241 |                     memory.Write(0xFF00 + address, Data.ffxxDump[address]);
242 |                 else
243 |                 {
244 |                     switch (address)
245 |                     {
246 |                         case 0x00:
247 |                         case 0x01:
248 |                         case 0x02:
249 |                         case 0x07:
250 |                         case 0x0F:
251 |                         case 0x40:
252 |                         case 0xFF:
253 |                             memory.Write(0xFF00 + address, Data.ffxxDump[address]);
254 |                             break;
255 |                         default:
256 |                             memory.RawWrite(0xFF00 + address, Data.ffxxDump[address]);
257 |                             break;
258 |                     }
259 |                 }
260 |                 --address;
261 |             }
262 |         }
263 | 
264 |         public void Run()
265 |         {
266 |             try
267 |             {
268 |                 if ((stopEmulator & 2) == 0)
269 |                 {
270 |                     if ((stopEmulator & 1) == 1)
271 |                     {
272 |                         stopEmulator = 0;
273 |                         clock.Update();
274 | 
275 |                         if (!halt)
276 |                             ExecuteStep();
277 |                         else
278 |                         {
279 |                             CPUTicks = 1;
280 |                             MainVM.Execute(this, 0x76);
281 | 
282 |                             RunInterrupt();
283 | 
284 |                             UpdateCore();
285 |                             ExecuteStep();
286 |                         }
287 |                     }
288 |                     else
289 |                         throw new Exception("restarted core");
290 |                 }
291 |             }
292 |             catch (Exception e)
293 |             {
294 |                 if (e.Message != "HALT_OVERRUN")
295 |                     Debug.LogError(e.Message + " " + e.StackTrace);
296 |             }
297 |         }
298 | 
299 |         private void RunInterrupt()
300 |         {
301 |             int bitShift = 0;
302 |             long testbit = 1;
303 |             long interrupts = memory.memory[0xFFFF] & memory.memory[0xFF0F];
304 | 
305 |             while (bitShift < 5)
306 |             {
307 |                 if ((testbit & interrupts) == testbit)
308 |                 {
309 |                     IME = false;
310 |                     memory.memory[0xFF0F] -= testbit;
311 | 
312 |                     cpu.stackPointer = Utils.Unswtuw(cpu.stackPointer - 1);
313 |                     memory.Write(cpu.stackPointer, (cpu.programCounter >> 8));
314 |                     cpu.stackPointer = Utils.Unswtuw(cpu.stackPointer - 1);
315 |                     memory.Write(cpu.stackPointer, (cpu.programCounter & 0xFF));
316 | 
317 |                     cpu.programCounter = 0x0040 + (bitShift * 0x08);
318 |                     CPUTicks += 5;
319 |                     break;
320 |                 }
321 |                 testbit = 1 << ++bitShift;
322 |             }
323 |         }
324 | 
325 |         public void UpdateCore()
326 |         {
327 |             DIVTicks += CPUTicks;
328 |             if (DIVTicks >= 0x40)
329 |             {
330 |                 DIVTicks -= 0x40;
331 |                 memory.memory[0xFF04] = (memory.memory[0xFF04] + 1) & 0xFF; // inc DIV
332 |             }
333 | 
334 |             long timedTicks = CPUTicks / multiplier;
335 | 
336 |             LCDTicks += timedTicks;
337 |             lcd.ScanLine(lcd.currentScanLine);
338 | 
339 |             audioTicks += timedTicks;
340 | 
341 |             if (audioTicks >= Settings.audioGranularity)
342 |             {
343 |                 emulatorTicks += audioTicks;
344 |                 if (emulatorTicks >= Settings.machineCyclesPerLoop)
345 |                 {
346 |                     if ((stopEmulator & 1) == 0)
347 |                     {
348 |                         if (screen.drewBlank == 0)
349 |                             screen.DrawToCanvas();
350 |                     }
351 |                     stopEmulator |= 1;
352 |                     emulatorTicks = 0;
353 |                 }
354 |                 audioTicks = 0;
355 |             }
356 | 
357 |             if (TIMAEnabled)
358 |             {
359 |                 timerTicks += CPUTicks;
360 |                 while (timerTicks >= TACClocker)
361 |                 {
362 |                     timerTicks -= TACClocker;
363 |                     if (memory.memory[0xFF05] == 0xFF)
364 |                     {
365 |                         memory.memory[0xFF05] = memory.memory[0xFF06];
366 |                         memory.memory[0xFF0F] |= 0x4; // set IF bit 2
367 |                     }
368 |                     else
369 |                         ++memory.memory[0xFF05];
370 |                 }
371 |             }
372 |         }
373 | 
374 |         private void ExecuteStep()
375 |         {
376 |             long op = 0;
377 | 
378 |             while (stopEmulator == 0)
379 |             {
380 |                 op = memory.Read(cpu.programCounter);
381 | 
382 |                 if (!skipPCIncrement)
383 |                     cpu.programCounter = (cpu.programCounter + 1) & 0xFFFF;
384 | 
385 |                 skipPCIncrement = false;
386 |                 CPUTicks = TICKTables.primary[op];
387 | 
388 |                 //Debug.Log(op + " " + CPUTicks + " " + programCounter);
389 | 
390 |                 MainVM.Execute(this, op);
391 | 
392 |                 switch (untilEnable)
393 |                 {
394 |                     case 1:
395 |                         IME = true;
396 |                         untilEnable--;
397 |                         break;
398 |                     case 2:
399 |                         untilEnable--;
400 |                         break;
401 |                 }
402 | 
403 |                 if (IME)
404 |                     RunInterrupt();
405 | 
406 |                 UpdateCore();
407 |             }
408 |         }
409 | 
410 |         public void NotifyScanline()
411 |         {
412 |             Debug.Log("not implemented");
413 |         }
414 |     }
415 | }


--------------------------------------------------------------------------------
/Assets/Scripts/Data.cs:
--------------------------------------------------------------------------------
  1 | namespace GB
  2 | {
  3 |     class Data
  4 |     {
  5 |         // DAA lookup array from VBA-M
  6 |         public static long[] DAATable = new long[] {
  7 |             0x0080, 0x0100, 0x0200, 0x0300, 0x0400, 0x0500, 0x0600, 0x0700, 0x0800, 0x0900, 0x1000, 0x1100, 0x1200, 0x1300, 0x1400, 0x1500,
  8 |             0x1000, 0x1100, 0x1200, 0x1300, 0x1400, 0x1500, 0x1600, 0x1700, 0x1800, 0x1900, 0x2000, 0x2100, 0x2200, 0x2300, 0x2400, 0x2500,
  9 |             0x2000, 0x2100, 0x2200, 0x2300, 0x2400, 0x2500, 0x2600, 0x2700, 0x2800, 0x2900, 0x3000, 0x3100, 0x3200, 0x3300, 0x3400, 0x3500,
 10 |             0x3000, 0x3100, 0x3200, 0x3300, 0x3400, 0x3500, 0x3600, 0x3700, 0x3800, 0x3900, 0x4000, 0x4100, 0x4200, 0x4300, 0x4400, 0x4500,
 11 |             0x4000, 0x4100, 0x4200, 0x4300, 0x4400, 0x4500, 0x4600, 0x4700, 0x4800, 0x4900, 0x5000, 0x5100, 0x5200, 0x5300, 0x5400, 0x5500,
 12 |             0x5000, 0x5100, 0x5200, 0x5300, 0x5400, 0x5500, 0x5600, 0x5700, 0x5800, 0x5900, 0x6000, 0x6100, 0x6200, 0x6300, 0x6400, 0x6500,
 13 |             0x6000, 0x6100, 0x6200, 0x6300, 0x6400, 0x6500, 0x6600, 0x6700, 0x6800, 0x6900, 0x7000, 0x7100, 0x7200, 0x7300, 0x7400, 0x7500,
 14 |             0x7000, 0x7100, 0x7200, 0x7300, 0x7400, 0x7500, 0x7600, 0x7700, 0x7800, 0x7900, 0x8000, 0x8100, 0x8200, 0x8300, 0x8400, 0x8500,
 15 |             0x8000, 0x8100, 0x8200, 0x8300, 0x8400, 0x8500, 0x8600, 0x8700, 0x8800, 0x8900, 0x9000, 0x9100, 0x9200, 0x9300, 0x9400, 0x9500,
 16 |             0x9000, 0x9100, 0x9200, 0x9300, 0x9400, 0x9500, 0x9600, 0x9700, 0x9800, 0x9900, 0x0090, 0x0110, 0x0210, 0x0310, 0x0410, 0x0510,
 17 |             0x0090, 0x0110, 0x0210, 0x0310, 0x0410, 0x0510, 0x0610, 0x0710, 0x0810, 0x0910, 0x1010, 0x1110, 0x1210, 0x1310, 0x1410, 0x1510,
 18 |             0x1010, 0x1110, 0x1210, 0x1310, 0x1410, 0x1510, 0x1610, 0x1710, 0x1810, 0x1910, 0x2010, 0x2110, 0x2210, 0x2310, 0x2410, 0x2510,
 19 |             0x2010, 0x2110, 0x2210, 0x2310, 0x2410, 0x2510, 0x2610, 0x2710, 0x2810, 0x2910, 0x3010, 0x3110, 0x3210, 0x3310, 0x3410, 0x3510,
 20 |             0x3010, 0x3110, 0x3210, 0x3310, 0x3410, 0x3510, 0x3610, 0x3710, 0x3810, 0x3910, 0x4010, 0x4110, 0x4210, 0x4310, 0x4410, 0x4510,
 21 |             0x4010, 0x4110, 0x4210, 0x4310, 0x4410, 0x4510, 0x4610, 0x4710, 0x4810, 0x4910, 0x5010, 0x5110, 0x5210, 0x5310, 0x5410, 0x5510,
 22 |             0x5010, 0x5110, 0x5210, 0x5310, 0x5410, 0x5510, 0x5610, 0x5710, 0x5810, 0x5910, 0x6010, 0x6110, 0x6210, 0x6310, 0x6410, 0x6510,
 23 |             0x6010, 0x6110, 0x6210, 0x6310, 0x6410, 0x6510, 0x6610, 0x6710, 0x6810, 0x6910, 0x7010, 0x7110, 0x7210, 0x7310, 0x7410, 0x7510,
 24 |             0x7010, 0x7110, 0x7210, 0x7310, 0x7410, 0x7510, 0x7610, 0x7710, 0x7810, 0x7910, 0x8010, 0x8110, 0x8210, 0x8310, 0x8410, 0x8510,
 25 |             0x8010, 0x8110, 0x8210, 0x8310, 0x8410, 0x8510, 0x8610, 0x8710, 0x8810, 0x8910, 0x9010, 0x9110, 0x9210, 0x9310, 0x9410, 0x9510,
 26 |             0x9010, 0x9110, 0x9210, 0x9310, 0x9410, 0x9510, 0x9610, 0x9710, 0x9810, 0x9910, 0xA010, 0xA110, 0xA210, 0xA310, 0xA410, 0xA510,
 27 |             0xA010, 0xA110, 0xA210, 0xA310, 0xA410, 0xA510, 0xA610, 0xA710, 0xA810, 0xA910, 0xB010, 0xB110, 0xB210, 0xB310, 0xB410, 0xB510,
 28 |             0xB010, 0xB110, 0xB210, 0xB310, 0xB410, 0xB510, 0xB610, 0xB710, 0xB810, 0xB910, 0xC010, 0xC110, 0xC210, 0xC310, 0xC410, 0xC510,
 29 |             0xC010, 0xC110, 0xC210, 0xC310, 0xC410, 0xC510, 0xC610, 0xC710, 0xC810, 0xC910, 0xD010, 0xD110, 0xD210, 0xD310, 0xD410, 0xD510,
 30 |             0xD010, 0xD110, 0xD210, 0xD310, 0xD410, 0xD510, 0xD610, 0xD710, 0xD810, 0xD910, 0xE010, 0xE110, 0xE210, 0xE310, 0xE410, 0xE510,
 31 |             0xE010, 0xE110, 0xE210, 0xE310, 0xE410, 0xE510, 0xE610, 0xE710, 0xE810, 0xE910, 0xF010, 0xF110, 0xF210, 0xF310, 0xF410, 0xF510,
 32 |             0xF010, 0xF110, 0xF210, 0xF310, 0xF410, 0xF510, 0xF610, 0xF710, 0xF810, 0xF910, 0x0090, 0x0110, 0x0210, 0x0310, 0x0410, 0x0510,
 33 |             0x0090, 0x0110, 0x0210, 0x0310, 0x0410, 0x0510, 0x0610, 0x0710, 0x0810, 0x0910, 0x1010, 0x1110, 0x1210, 0x1310, 0x1410, 0x1510,
 34 |             0x1010, 0x1110, 0x1210, 0x1310, 0x1410, 0x1510, 0x1610, 0x1710, 0x1810, 0x1910, 0x2010, 0x2110, 0x2210, 0x2310, 0x2410, 0x2510,
 35 |             0x2010, 0x2110, 0x2210, 0x2310, 0x2410, 0x2510, 0x2610, 0x2710, 0x2810, 0x2910, 0x3010, 0x3110, 0x3210, 0x3310, 0x3410, 0x3510,
 36 |             0x3010, 0x3110, 0x3210, 0x3310, 0x3410, 0x3510, 0x3610, 0x3710, 0x3810, 0x3910, 0x4010, 0x4110, 0x4210, 0x4310, 0x4410, 0x4510,
 37 |             0x4010, 0x4110, 0x4210, 0x4310, 0x4410, 0x4510, 0x4610, 0x4710, 0x4810, 0x4910, 0x5010, 0x5110, 0x5210, 0x5310, 0x5410, 0x5510,
 38 |             0x5010, 0x5110, 0x5210, 0x5310, 0x5410, 0x5510, 0x5610, 0x5710, 0x5810, 0x5910, 0x6010, 0x6110, 0x6210, 0x6310, 0x6410, 0x6510,
 39 |             0x0600, 0x0700, 0x0800, 0x0900, 0x0A00, 0x0B00, 0x0C00, 0x0D00, 0x0E00, 0x0F00, 0x1000, 0x1100, 0x1200, 0x1300, 0x1400, 0x1500,
 40 |             0x1600, 0x1700, 0x1800, 0x1900, 0x1A00, 0x1B00, 0x1C00, 0x1D00, 0x1E00, 0x1F00, 0x2000, 0x2100, 0x2200, 0x2300, 0x2400, 0x2500,
 41 |             0x2600, 0x2700, 0x2800, 0x2900, 0x2A00, 0x2B00, 0x2C00, 0x2D00, 0x2E00, 0x2F00, 0x3000, 0x3100, 0x3200, 0x3300, 0x3400, 0x3500,
 42 |             0x3600, 0x3700, 0x3800, 0x3900, 0x3A00, 0x3B00, 0x3C00, 0x3D00, 0x3E00, 0x3F00, 0x4000, 0x4100, 0x4200, 0x4300, 0x4400, 0x4500,
 43 |             0x4600, 0x4700, 0x4800, 0x4900, 0x4A00, 0x4B00, 0x4C00, 0x4D00, 0x4E00, 0x4F00, 0x5000, 0x5100, 0x5200, 0x5300, 0x5400, 0x5500,
 44 |             0x5600, 0x5700, 0x5800, 0x5900, 0x5A00, 0x5B00, 0x5C00, 0x5D00, 0x5E00, 0x5F00, 0x6000, 0x6100, 0x6200, 0x6300, 0x6400, 0x6500,
 45 |             0x6600, 0x6700, 0x6800, 0x6900, 0x6A00, 0x6B00, 0x6C00, 0x6D00, 0x6E00, 0x6F00, 0x7000, 0x7100, 0x7200, 0x7300, 0x7400, 0x7500,
 46 |             0x7600, 0x7700, 0x7800, 0x7900, 0x7A00, 0x7B00, 0x7C00, 0x7D00, 0x7E00, 0x7F00, 0x8000, 0x8100, 0x8200, 0x8300, 0x8400, 0x8500,
 47 |             0x8600, 0x8700, 0x8800, 0x8900, 0x8A00, 0x8B00, 0x8C00, 0x8D00, 0x8E00, 0x8F00, 0x9000, 0x9100, 0x9200, 0x9300, 0x9400, 0x9500,
 48 |             0x9600, 0x9700, 0x9800, 0x9900, 0x9A00, 0x9B00, 0x9C00, 0x9D00, 0x9E00, 0x9F00, 0x0090, 0x0110, 0x0210, 0x0310, 0x0410, 0x0510,
 49 |             0x0610, 0x0710, 0x0810, 0x0910, 0x0A10, 0x0B10, 0x0C10, 0x0D10, 0x0E10, 0x0F10, 0x1010, 0x1110, 0x1210, 0x1310, 0x1410, 0x1510,
 50 |             0x1610, 0x1710, 0x1810, 0x1910, 0x1A10, 0x1B10, 0x1C10, 0x1D10, 0x1E10, 0x1F10, 0x2010, 0x2110, 0x2210, 0x2310, 0x2410, 0x2510,
 51 |             0x2610, 0x2710, 0x2810, 0x2910, 0x2A10, 0x2B10, 0x2C10, 0x2D10, 0x2E10, 0x2F10, 0x3010, 0x3110, 0x3210, 0x3310, 0x3410, 0x3510,
 52 |             0x3610, 0x3710, 0x3810, 0x3910, 0x3A10, 0x3B10, 0x3C10, 0x3D10, 0x3E10, 0x3F10, 0x4010, 0x4110, 0x4210, 0x4310, 0x4410, 0x4510,
 53 |             0x4610, 0x4710, 0x4810, 0x4910, 0x4A10, 0x4B10, 0x4C10, 0x4D10, 0x4E10, 0x4F10, 0x5010, 0x5110, 0x5210, 0x5310, 0x5410, 0x5510,
 54 |             0x5610, 0x5710, 0x5810, 0x5910, 0x5A10, 0x5B10, 0x5C10, 0x5D10, 0x5E10, 0x5F10, 0x6010, 0x6110, 0x6210, 0x6310, 0x6410, 0x6510,
 55 |             0x6610, 0x6710, 0x6810, 0x6910, 0x6A10, 0x6B10, 0x6C10, 0x6D10, 0x6E10, 0x6F10, 0x7010, 0x7110, 0x7210, 0x7310, 0x7410, 0x7510,
 56 |             0x7610, 0x7710, 0x7810, 0x7910, 0x7A10, 0x7B10, 0x7C10, 0x7D10, 0x7E10, 0x7F10, 0x8010, 0x8110, 0x8210, 0x8310, 0x8410, 0x8510,
 57 |             0x8610, 0x8710, 0x8810, 0x8910, 0x8A10, 0x8B10, 0x8C10, 0x8D10, 0x8E10, 0x8F10, 0x9010, 0x9110, 0x9210, 0x9310, 0x9410, 0x9510,
 58 |             0x9610, 0x9710, 0x9810, 0x9910, 0x9A10, 0x9B10, 0x9C10, 0x9D10, 0x9E10, 0x9F10, 0xA010, 0xA110, 0xA210, 0xA310, 0xA410, 0xA510,
 59 |             0xA610, 0xA710, 0xA810, 0xA910, 0xAA10, 0xAB10, 0xAC10, 0xAD10, 0xAE10, 0xAF10, 0xB010, 0xB110, 0xB210, 0xB310, 0xB410, 0xB510,
 60 |             0xB610, 0xB710, 0xB810, 0xB910, 0xBA10, 0xBB10, 0xBC10, 0xBD10, 0xBE10, 0xBF10, 0xC010, 0xC110, 0xC210, 0xC310, 0xC410, 0xC510,
 61 |             0xC610, 0xC710, 0xC810, 0xC910, 0xCA10, 0xCB10, 0xCC10, 0xCD10, 0xCE10, 0xCF10, 0xD010, 0xD110, 0xD210, 0xD310, 0xD410, 0xD510,
 62 |             0xD610, 0xD710, 0xD810, 0xD910, 0xDA10, 0xDB10, 0xDC10, 0xDD10, 0xDE10, 0xDF10, 0xE010, 0xE110, 0xE210, 0xE310, 0xE410, 0xE510,
 63 |             0xE610, 0xE710, 0xE810, 0xE910, 0xEA10, 0xEB10, 0xEC10, 0xED10, 0xEE10, 0xEF10, 0xF010, 0xF110, 0xF210, 0xF310, 0xF410, 0xF510,
 64 |             0xF610, 0xF710, 0xF810, 0xF910, 0xFA10, 0xFB10, 0xFC10, 0xFD10, 0xFE10, 0xFF10, 0x0090, 0x0110, 0x0210, 0x0310, 0x0410, 0x0510,
 65 |             0x0610, 0x0710, 0x0810, 0x0910, 0x0A10, 0x0B10, 0x0C10, 0x0D10, 0x0E10, 0x0F10, 0x1010, 0x1110, 0x1210, 0x1310, 0x1410, 0x1510,
 66 |             0x1610, 0x1710, 0x1810, 0x1910, 0x1A10, 0x1B10, 0x1C10, 0x1D10, 0x1E10, 0x1F10, 0x2010, 0x2110, 0x2210, 0x2310, 0x2410, 0x2510,
 67 |             0x2610, 0x2710, 0x2810, 0x2910, 0x2A10, 0x2B10, 0x2C10, 0x2D10, 0x2E10, 0x2F10, 0x3010, 0x3110, 0x3210, 0x3310, 0x3410, 0x3510,
 68 |             0x3610, 0x3710, 0x3810, 0x3910, 0x3A10, 0x3B10, 0x3C10, 0x3D10, 0x3E10, 0x3F10, 0x4010, 0x4110, 0x4210, 0x4310, 0x4410, 0x4510,
 69 |             0x4610, 0x4710, 0x4810, 0x4910, 0x4A10, 0x4B10, 0x4C10, 0x4D10, 0x4E10, 0x4F10, 0x5010, 0x5110, 0x5210, 0x5310, 0x5410, 0x5510,
 70 |             0x5610, 0x5710, 0x5810, 0x5910, 0x5A10, 0x5B10, 0x5C10, 0x5D10, 0x5E10, 0x5F10, 0x6010, 0x6110, 0x6210, 0x6310, 0x6410, 0x6510,
 71 |             0x00C0, 0x0140, 0x0240, 0x0340, 0x0440, 0x0540, 0x0640, 0x0740, 0x0840, 0x0940, 0x0A40, 0x0B40, 0x0C40, 0x0D40, 0x0E40, 0x0F40,
 72 |             0x1040, 0x1140, 0x1240, 0x1340, 0x1440, 0x1540, 0x1640, 0x1740, 0x1840, 0x1940, 0x1A40, 0x1B40, 0x1C40, 0x1D40, 0x1E40, 0x1F40,
 73 |             0x2040, 0x2140, 0x2240, 0x2340, 0x2440, 0x2540, 0x2640, 0x2740, 0x2840, 0x2940, 0x2A40, 0x2B40, 0x2C40, 0x2D40, 0x2E40, 0x2F40,
 74 |             0x3040, 0x3140, 0x3240, 0x3340, 0x3440, 0x3540, 0x3640, 0x3740, 0x3840, 0x3940, 0x3A40, 0x3B40, 0x3C40, 0x3D40, 0x3E40, 0x3F40,
 75 |             0x4040, 0x4140, 0x4240, 0x4340, 0x4440, 0x4540, 0x4640, 0x4740, 0x4840, 0x4940, 0x4A40, 0x4B40, 0x4C40, 0x4D40, 0x4E40, 0x4F40,
 76 |             0x5040, 0x5140, 0x5240, 0x5340, 0x5440, 0x5540, 0x5640, 0x5740, 0x5840, 0x5940, 0x5A40, 0x5B40, 0x5C40, 0x5D40, 0x5E40, 0x5F40,
 77 |             0x6040, 0x6140, 0x6240, 0x6340, 0x6440, 0x6540, 0x6640, 0x6740, 0x6840, 0x6940, 0x6A40, 0x6B40, 0x6C40, 0x6D40, 0x6E40, 0x6F40,
 78 |             0x7040, 0x7140, 0x7240, 0x7340, 0x7440, 0x7540, 0x7640, 0x7740, 0x7840, 0x7940, 0x7A40, 0x7B40, 0x7C40, 0x7D40, 0x7E40, 0x7F40,
 79 |             0x8040, 0x8140, 0x8240, 0x8340, 0x8440, 0x8540, 0x8640, 0x8740, 0x8840, 0x8940, 0x8A40, 0x8B40, 0x8C40, 0x8D40, 0x8E40, 0x8F40,
 80 |             0x9040, 0x9140, 0x9240, 0x9340, 0x9440, 0x9540, 0x9640, 0x9740, 0x9840, 0x9940, 0x9A40, 0x9B40, 0x9C40, 0x9D40, 0x9E40, 0x9F40,
 81 |             0xA040, 0xA140, 0xA240, 0xA340, 0xA440, 0xA540, 0xA640, 0xA740, 0xA840, 0xA940, 0xAA40, 0xAB40, 0xAC40, 0xAD40, 0xAE40, 0xAF40,
 82 |             0xB040, 0xB140, 0xB240, 0xB340, 0xB440, 0xB540, 0xB640, 0xB740, 0xB840, 0xB940, 0xBA40, 0xBB40, 0xBC40, 0xBD40, 0xBE40, 0xBF40,
 83 |             0xC040, 0xC140, 0xC240, 0xC340, 0xC440, 0xC540, 0xC640, 0xC740, 0xC840, 0xC940, 0xCA40, 0xCB40, 0xCC40, 0xCD40, 0xCE40, 0xCF40,
 84 |             0xD040, 0xD140, 0xD240, 0xD340, 0xD440, 0xD540, 0xD640, 0xD740, 0xD840, 0xD940, 0xDA40, 0xDB40, 0xDC40, 0xDD40, 0xDE40, 0xDF40,
 85 |             0xE040, 0xE140, 0xE240, 0xE340, 0xE440, 0xE540, 0xE640, 0xE740, 0xE840, 0xE940, 0xEA40, 0xEB40, 0xEC40, 0xED40, 0xEE40, 0xEF40,
 86 |             0xF040, 0xF140, 0xF240, 0xF340, 0xF440, 0xF540, 0xF640, 0xF740, 0xF840, 0xF940, 0xFA40, 0xFB40, 0xFC40, 0xFD40, 0xFE40, 0xFF40,
 87 |             0xA050, 0xA150, 0xA250, 0xA350, 0xA450, 0xA550, 0xA650, 0xA750, 0xA850, 0xA950, 0xAA50, 0xAB50, 0xAC50, 0xAD50, 0xAE50, 0xAF50,
 88 |             0xB050, 0xB150, 0xB250, 0xB350, 0xB450, 0xB550, 0xB650, 0xB750, 0xB850, 0xB950, 0xBA50, 0xBB50, 0xBC50, 0xBD50, 0xBE50, 0xBF50,
 89 |             0xC050, 0xC150, 0xC250, 0xC350, 0xC450, 0xC550, 0xC650, 0xC750, 0xC850, 0xC950, 0xCA50, 0xCB50, 0xCC50, 0xCD50, 0xCE50, 0xCF50,
 90 |             0xD050, 0xD150, 0xD250, 0xD350, 0xD450, 0xD550, 0xD650, 0xD750, 0xD850, 0xD950, 0xDA50, 0xDB50, 0xDC50, 0xDD50, 0xDE50, 0xDF50,
 91 |             0xE050, 0xE150, 0xE250, 0xE350, 0xE450, 0xE550, 0xE650, 0xE750, 0xE850, 0xE950, 0xEA50, 0xEB50, 0xEC50, 0xED50, 0xEE50, 0xEF50,
 92 |             0xF050, 0xF150, 0xF250, 0xF350, 0xF450, 0xF550, 0xF650, 0xF750, 0xF850, 0xF950, 0xFA50, 0xFB50, 0xFC50, 0xFD50, 0xFE50, 0xFF50,
 93 |             0x00D0, 0x0150, 0x0250, 0x0350, 0x0450, 0x0550, 0x0650, 0x0750, 0x0850, 0x0950, 0x0A50, 0x0B50, 0x0C50, 0x0D50, 0x0E50, 0x0F50,
 94 |             0x1050, 0x1150, 0x1250, 0x1350, 0x1450, 0x1550, 0x1650, 0x1750, 0x1850, 0x1950, 0x1A50, 0x1B50, 0x1C50, 0x1D50, 0x1E50, 0x1F50,
 95 |             0x2050, 0x2150, 0x2250, 0x2350, 0x2450, 0x2550, 0x2650, 0x2750, 0x2850, 0x2950, 0x2A50, 0x2B50, 0x2C50, 0x2D50, 0x2E50, 0x2F50,
 96 |             0x3050, 0x3150, 0x3250, 0x3350, 0x3450, 0x3550, 0x3650, 0x3750, 0x3850, 0x3950, 0x3A50, 0x3B50, 0x3C50, 0x3D50, 0x3E50, 0x3F50,
 97 |             0x4050, 0x4150, 0x4250, 0x4350, 0x4450, 0x4550, 0x4650, 0x4750, 0x4850, 0x4950, 0x4A50, 0x4B50, 0x4C50, 0x4D50, 0x4E50, 0x4F50,
 98 |             0x5050, 0x5150, 0x5250, 0x5350, 0x5450, 0x5550, 0x5650, 0x5750, 0x5850, 0x5950, 0x5A50, 0x5B50, 0x5C50, 0x5D50, 0x5E50, 0x5F50,
 99 |             0x6050, 0x6150, 0x6250, 0x6350, 0x6450, 0x6550, 0x6650, 0x6750, 0x6850, 0x6950, 0x6A50, 0x6B50, 0x6C50, 0x6D50, 0x6E50, 0x6F50,
100 |             0x7050, 0x7150, 0x7250, 0x7350, 0x7450, 0x7550, 0x7650, 0x7750, 0x7850, 0x7950, 0x7A50, 0x7B50, 0x7C50, 0x7D50, 0x7E50, 0x7F50,
101 |             0x8050, 0x8150, 0x8250, 0x8350, 0x8450, 0x8550, 0x8650, 0x8750, 0x8850, 0x8950, 0x8A50, 0x8B50, 0x8C50, 0x8D50, 0x8E50, 0x8F50,
102 |             0x9050, 0x9150, 0x9250, 0x9350, 0x9450, 0x9550, 0x9650, 0x9750, 0x9850, 0x9950, 0x9A50, 0x9B50, 0x9C50, 0x9D50, 0x9E50, 0x9F50,
103 |             0xFA40, 0xFB40, 0xFC40, 0xFD40, 0xFE40, 0xFF40, 0x00C0, 0x0140, 0x0240, 0x0340, 0x0440, 0x0540, 0x0640, 0x0740, 0x0840, 0x0940,
104 |             0x0A40, 0x0B40, 0x0C40, 0x0D40, 0x0E40, 0x0F40, 0x1040, 0x1140, 0x1240, 0x1340, 0x1440, 0x1540, 0x1640, 0x1740, 0x1840, 0x1940,
105 |             0x1A40, 0x1B40, 0x1C40, 0x1D40, 0x1E40, 0x1F40, 0x2040, 0x2140, 0x2240, 0x2340, 0x2440, 0x2540, 0x2640, 0x2740, 0x2840, 0x2940,
106 |             0x2A40, 0x2B40, 0x2C40, 0x2D40, 0x2E40, 0x2F40, 0x3040, 0x3140, 0x3240, 0x3340, 0x3440, 0x3540, 0x3640, 0x3740, 0x3840, 0x3940,
107 |             0x3A40, 0x3B40, 0x3C40, 0x3D40, 0x3E40, 0x3F40, 0x4040, 0x4140, 0x4240, 0x4340, 0x4440, 0x4540, 0x4640, 0x4740, 0x4840, 0x4940,
108 |             0x4A40, 0x4B40, 0x4C40, 0x4D40, 0x4E40, 0x4F40, 0x5040, 0x5140, 0x5240, 0x5340, 0x5440, 0x5540, 0x5640, 0x5740, 0x5840, 0x5940,
109 |             0x5A40, 0x5B40, 0x5C40, 0x5D40, 0x5E40, 0x5F40, 0x6040, 0x6140, 0x6240, 0x6340, 0x6440, 0x6540, 0x6640, 0x6740, 0x6840, 0x6940,
110 |             0x6A40, 0x6B40, 0x6C40, 0x6D40, 0x6E40, 0x6F40, 0x7040, 0x7140, 0x7240, 0x7340, 0x7440, 0x7540, 0x7640, 0x7740, 0x7840, 0x7940,
111 |             0x7A40, 0x7B40, 0x7C40, 0x7D40, 0x7E40, 0x7F40, 0x8040, 0x8140, 0x8240, 0x8340, 0x8440, 0x8540, 0x8640, 0x8740, 0x8840, 0x8940,
112 |             0x8A40, 0x8B40, 0x8C40, 0x8D40, 0x8E40, 0x8F40, 0x9040, 0x9140, 0x9240, 0x9340, 0x9440, 0x9540, 0x9640, 0x9740, 0x9840, 0x9940,
113 |             0x9A40, 0x9B40, 0x9C40, 0x9D40, 0x9E40, 0x9F40, 0xA040, 0xA140, 0xA240, 0xA340, 0xA440, 0xA540, 0xA640, 0xA740, 0xA840, 0xA940,
114 |             0xAA40, 0xAB40, 0xAC40, 0xAD40, 0xAE40, 0xAF40, 0xB040, 0xB140, 0xB240, 0xB340, 0xB440, 0xB540, 0xB640, 0xB740, 0xB840, 0xB940,
115 |             0xBA40, 0xBB40, 0xBC40, 0xBD40, 0xBE40, 0xBF40, 0xC040, 0xC140, 0xC240, 0xC340, 0xC440, 0xC540, 0xC640, 0xC740, 0xC840, 0xC940,
116 |             0xCA40, 0xCB40, 0xCC40, 0xCD40, 0xCE40, 0xCF40, 0xD040, 0xD140, 0xD240, 0xD340, 0xD440, 0xD540, 0xD640, 0xD740, 0xD840, 0xD940,
117 |             0xDA40, 0xDB40, 0xDC40, 0xDD40, 0xDE40, 0xDF40, 0xE040, 0xE140, 0xE240, 0xE340, 0xE440, 0xE540, 0xE640, 0xE740, 0xE840, 0xE940,
118 |             0xEA40, 0xEB40, 0xEC40, 0xED40, 0xEE40, 0xEF40, 0xF040, 0xF140, 0xF240, 0xF340, 0xF440, 0xF540, 0xF640, 0xF740, 0xF840, 0xF940,
119 |             0x9A50, 0x9B50, 0x9C50, 0x9D50, 0x9E50, 0x9F50, 0xA050, 0xA150, 0xA250, 0xA350, 0xA450, 0xA550, 0xA650, 0xA750, 0xA850, 0xA950,
120 |             0xAA50, 0xAB50, 0xAC50, 0xAD50, 0xAE50, 0xAF50, 0xB050, 0xB150, 0xB250, 0xB350, 0xB450, 0xB550, 0xB650, 0xB750, 0xB850, 0xB950,
121 |             0xBA50, 0xBB50, 0xBC50, 0xBD50, 0xBE50, 0xBF50, 0xC050, 0xC150, 0xC250, 0xC350, 0xC450, 0xC550, 0xC650, 0xC750, 0xC850, 0xC950,
122 |             0xCA50, 0xCB50, 0xCC50, 0xCD50, 0xCE50, 0xCF50, 0xD050, 0xD150, 0xD250, 0xD350, 0xD450, 0xD550, 0xD650, 0xD750, 0xD850, 0xD950,
123 |             0xDA50, 0xDB50, 0xDC50, 0xDD50, 0xDE50, 0xDF50, 0xE050, 0xE150, 0xE250, 0xE350, 0xE450, 0xE550, 0xE650, 0xE750, 0xE850, 0xE950,
124 |             0xEA50, 0xEB50, 0xEC50, 0xED50, 0xEE50, 0xEF50, 0xF050, 0xF150, 0xF250, 0xF350, 0xF450, 0xF550, 0xF650, 0xF750, 0xF850, 0xF950,
125 |             0xFA50, 0xFB50, 0xFC50, 0xFD50, 0xFE50, 0xFF50, 0x00D0, 0x0150, 0x0250, 0x0350, 0x0450, 0x0550, 0x0650, 0x0750, 0x0850, 0x0950,
126 |             0x0A50, 0x0B50, 0x0C50, 0x0D50, 0x0E50, 0x0F50, 0x1050, 0x1150, 0x1250, 0x1350, 0x1450, 0x1550, 0x1650, 0x1750, 0x1850, 0x1950,
127 |             0x1A50, 0x1B50, 0x1C50, 0x1D50, 0x1E50, 0x1F50, 0x2050, 0x2150, 0x2250, 0x2350, 0x2450, 0x2550, 0x2650, 0x2750, 0x2850, 0x2950,
128 |             0x2A50, 0x2B50, 0x2C50, 0x2D50, 0x2E50, 0x2F50, 0x3050, 0x3150, 0x3250, 0x3350, 0x3450, 0x3550, 0x3650, 0x3750, 0x3850, 0x3950,
129 |             0x3A50, 0x3B50, 0x3C50, 0x3D50, 0x3E50, 0x3F50, 0x4050, 0x4150, 0x4250, 0x4350, 0x4450, 0x4550, 0x4650, 0x4750, 0x4850, 0x4950,
130 |             0x4A50, 0x4B50, 0x4C50, 0x4D50, 0x4E50, 0x4F50, 0x5050, 0x5150, 0x5250, 0x5350, 0x5450, 0x5550, 0x5650, 0x5750, 0x5850, 0x5950,
131 |             0x5A50, 0x5B50, 0x5C50, 0x5D50, 0x5E50, 0x5F50, 0x6050, 0x6150, 0x6250, 0x6350, 0x6450, 0x6550, 0x6650, 0x6750, 0x6850, 0x6950,
132 |             0x6A50, 0x6B50, 0x6C50, 0x6D50, 0x6E50, 0x6F50, 0x7050, 0x7150, 0x7250, 0x7350, 0x7450, 0x7550, 0x7650, 0x7750, 0x7850, 0x7950,
133 |             0x7A50, 0x7B50, 0x7C50, 0x7D50, 0x7E50, 0x7F50, 0x8050, 0x8150, 0x8250, 0x8350, 0x8450, 0x8550, 0x8650, 0x8750, 0x8850, 0x8950,
134 |             0x8A50, 0x8B50, 0x8C50, 0x8D50, 0x8E50, 0x8F50, 0x9050, 0x9150, 0x9250, 0x9350, 0x9450, 0x9550, 0x9650, 0x9750, 0x9850, 0x9950,
135 |         };
136 | 
137 |         //Dump of the post-BOOT I/O register state (From gambatte):
138 |         public static long[] ffxxDump = new long[] {
139 |             0x0F, 0x00, 0x7C, 0xFF, 0x43, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01,
140 |             0x80, 0xBF, 0xF3, 0xFF, 0xBF, 0xFF, 0x3F, 0x00, 0xFF, 0xBF, 0x7F, 0xFF, 0x9F, 0xFF, 0xBF, 0xFF,
141 |             0xFF, 0x00, 0x00, 0xBF, 0x77, 0xF3, 0xF1, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
142 |             0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
143 |             0x91, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x7E, 0xFF, 0xFE,
144 |             0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3E, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
145 |             0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0xFF, 0xC1, 0x00, 0xFE, 0xFF, 0xFF, 0xFF,
146 |             0xF8, 0xFF, 0x00, 0x00, 0x00, 0x8F, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
147 |             0xCE, 0xED, 0x66, 0x66, 0xCC, 0x0D, 0x00, 0x0B, 0x03, 0x73, 0x00, 0x83, 0x00, 0x0C, 0x00, 0x0D,
148 |             0x00, 0x08, 0x11, 0x1F, 0x88, 0x89, 0x00, 0x0E, 0xDC, 0xCC, 0x6E, 0xE6, 0xDD, 0xDD, 0xD9, 0x99,
149 |             0xBB, 0xBB, 0x67, 0x63, 0x6E, 0x0E, 0xEC, 0xCC, 0xDD, 0xDC, 0x99, 0x9F, 0xBB, 0xB9, 0x33, 0x3E,
150 |             0x45, 0xEC, 0x52, 0xFA, 0x08, 0xB7, 0x07, 0x5D, 0x01, 0xFD, 0xC0, 0xFF, 0x08, 0xFC, 0x00, 0xE5,
151 |             0x0B, 0xF8, 0xC2, 0xCE, 0xF4, 0xF9, 0x0F, 0x7F, 0x45, 0x6D, 0x3D, 0xFE, 0x46, 0x97, 0x33, 0x5E,
152 |             0x08, 0xEF, 0xF1, 0xFF, 0x86, 0x83, 0x24, 0x74, 0x12, 0xFC, 0x00, 0x9F, 0xB4, 0xB7, 0x06, 0xD5,
153 |             0xD0, 0x7A, 0x00, 0x9E, 0x04, 0x5F, 0x41, 0x2F, 0x1D, 0x77, 0x36, 0x75, 0x81, 0xAA, 0x70, 0x3A,
154 |             0x98, 0xD1, 0x71, 0x02, 0x4D, 0x01, 0xC1, 0xFF, 0x0D, 0x00, 0xD3, 0x05, 0xF9, 0x00, 0x0B, 0x00,
155 |         };
156 |     }
157 | }
158 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Graphics/Screen.cs:
--------------------------------------------------------------------------------
  1 | 
  2 | /*
  3 |  * Partially ported video, HDMA, and double speed mode procedure from the STOP opcode from MeBoy 2.2
  4 |  * http://arktos.se/meboy/
  5 |  * Copyright(C) 2005-2009 Bjorn Carlin
  6 |  */
  7 | 
  8 | using System;
  9 | using UnityEngine;
 10 | 
 11 | namespace GB.Graphics
 12 | {
 13 |     [Serializable]
 14 |     public class Screen
 15 |     {
 16 |         [NonSerialized]
 17 |         private Core core;
 18 | 
 19 |         [NonSerialized]
 20 |         private Drawer drawer;
 21 | 
 22 |         private readonly long[] colors = new long[] { 0x80EFFFDE, 0x80ADD794, 0x80529273, 0x80183442 };
 23 | 
 24 |         private long[] palette;
 25 | 
 26 |         private long tileCountInvalidator;
 27 | 
 28 |         private long tileCount = 384;
 29 | 
 30 |         private long colorCount = 12;
 31 | 
 32 |         private TileData[] tileData;
 33 | 
 34 |         private int[] tileReadState;
 35 | 
 36 |         private long transparentCutoff = 4;
 37 | 
 38 |         private long[] weaveLookup;
 39 | 
 40 |         private long width = 160;
 41 | 
 42 |         private long height = 144;
 43 | 
 44 |         private long[] canvasBuffer;
 45 | 
 46 |         private long pixelCount;
 47 | 
 48 |         private long frameCount;
 49 | 
 50 |         private long rgbCount;
 51 | 
 52 |         private long[] frameBuffer;
 53 | 
 54 |         private long[] gbPalette;
 55 | 
 56 |         private long[] gbColorizedPalette;
 57 | 
 58 |         public long[] gbcRawPalette;
 59 | 
 60 |         private long[] gbcPalette;
 61 | 
 62 |         public long drewBlank;
 63 | 
 64 |         public long windowSourceLine = 0;
 65 | 
 66 |         public bool spritePriorityEnabled = true;
 67 | 
 68 |         public bool gfxWindowDisplay = false;
 69 | 
 70 |         public bool gfxWindowY;
 71 | 
 72 |         public bool gfxBackgroundX;
 73 | 
 74 |         public bool gfxBackgroundY;
 75 | 
 76 |         public bool gfxSpriteDouble;
 77 | 
 78 |         public bool gfxSpriteShow;
 79 | 
 80 |         private bool colorEnabled = false;
 81 | 
 82 |         public Screen(Core core, Drawer drawer)
 83 |         {
 84 |             this.core = core;
 85 |             this.drawer = drawer;
 86 | 
 87 |             tileCountInvalidator = tileCount * 4;
 88 |             frameCount = Settings.frameskipBaseFactor;
 89 |             pixelCount = width * height;
 90 |             rgbCount = pixelCount * 4;
 91 |         }
 92 | 
 93 |         public void InitLCD()
 94 |         {
 95 |             transparentCutoff = (Settings.colorize || core.cGBC) ? 32 : 4;
 96 |             if (weaveLookup == null)
 97 |             {
 98 |                 weaveLookup = new long[256];
 99 |                 for (int i = 0x1; i <= 0xFF; i++)
100 |                 {
101 |                     for (int d = 0; d < 0x8; d++)
102 |                         weaveLookup[i] += ((i >> d) & 1) << (d * 2);
103 |                 }
104 |             }
105 | 
106 |             width = 160;
107 |             height = 144;
108 | 
109 |             //Blank screen
110 |             if (colorEnabled)
111 |             {
112 |                 canvasBuffer = new long[4 * width * height];
113 |                 for (int i = 0; i < canvasBuffer.Length; i++)
114 |                     canvasBuffer[i] = 255;
115 | 
116 |                 long address = pixelCount;
117 |                 long address2 = rgbCount;
118 |                 while (address > 0)
119 |                 {
120 |                     frameBuffer[--address] = 0x00FFFFFF;
121 |                     canvasBuffer[address2 -= 4] = 0xFF;
122 |                     canvasBuffer[address2 + 1] = 0xFF;
123 |                     canvasBuffer[address2 + 2] = 0xFF;
124 |                     canvasBuffer[address2 + 3] = 0xFF;
125 |                 }
126 |             }
127 |             else
128 |             {
129 |                 canvasBuffer = new long[4 * width * height];
130 |                 frameBuffer = new long[pixelCount];
131 |                 for (int i = 0; i < frameBuffer.Length; i++)
132 |                     frameBuffer[i] = 0x00FFFFFF;
133 |             }
134 | 
135 |             drawer.Draw(canvasBuffer);
136 |         }
137 | 
138 |         public void InitScreen()
139 |         {
140 |             if (core.cGBC)
141 |             {
142 |                 tileCount *= 2;
143 |                 tileCountInvalidator = tileCount * 4;
144 |                 colorCount = 64;
145 |                 transparentCutoff = 32;
146 |             }
147 | 
148 |             tileData = new TileData[tileCount * colorCount];
149 |             for (int i = 0; i < tileData.Length; i++)
150 |                 tileData[i] = new TileData();
151 | 
152 |             tileReadState = new int[tileCount];
153 |         }
154 | 
155 |         public void InitVideoMemory()
156 |         {
157 |             frameBuffer = new long[23040];
158 |             for (int i = 0; i < frameBuffer.Length; i++)
159 |                 frameBuffer[i] = 0x00FFFFFF;
160 | 
161 |             gbPalette = new long[12];
162 |             gbColorizedPalette = new long[12];
163 |             gbcRawPalette = new long[0x80];
164 |             for (int i = 0; i < gbcRawPalette.Length; i++)
165 |                 gbcRawPalette[i] = -1000;
166 | 
167 |             gbcPalette = new long[64];
168 |             gbcPalette[0] = 0x40;
169 | 
170 |             long address = 0x3F;
171 |             while (address >= 0)
172 |             {
173 |                 gbcPalette[address] = (address < 0x20) ? -1 : 0;
174 |                 --address;
175 |             }
176 |         }
177 | 
178 |         public bool DrawBackgroundForLine(long line, long windowLeft, long priority)
179 |         {
180 |             bool skippedTile = false;
181 |             long tileNum = 0;
182 |             long tileXCoord = 0;
183 |             long tileAttrib = 0;
184 |             long sourceY = line + core.memory.memory[0xFF42];
185 |             long sourceImageLine = sourceY & 0x7;
186 |             long tileX = core.memory.memory[0xFF43] >> 3;
187 |             long memStart = ((gfxBackgroundY) ? 0x1C00 : 0x1800) + ((sourceY & 0xF8) << 2);
188 |             long screenX = -(core.memory.memory[0xFF43] & 7);
189 | 
190 |             for (; screenX < windowLeft; tileX++, screenX += 8)
191 |             {
192 |                 tileXCoord = (tileX & 0x1F);
193 |                 long baseAddress = core.memory.memory[0x8000 + memStart + tileXCoord];
194 |                 tileNum = (gfxBackgroundX) ? baseAddress : ((baseAddress > 0x7F) ? ((baseAddress & 0x7F) + 0x80) : (baseAddress + 0x100));
195 |                 if (core.cGBC)
196 |                 {
197 |                     long mapAttrib = core.VRAM[memStart + tileXCoord];
198 |                     if ((mapAttrib & 0x80) != priority)
199 |                     {
200 |                         skippedTile = true;
201 |                         continue;
202 |                     }
203 |                     tileAttrib = ((mapAttrib & 0x07) << 2) + ((mapAttrib >> 5) & 0x03);
204 |                     tileNum += 384 * ((mapAttrib >> 3) & 0x01);
205 |                 }
206 |                 DrawPartCopy(tileNum, screenX, line, sourceImageLine, tileAttrib);
207 |             }
208 | 
209 |             if (windowLeft < 160)
210 |             {
211 |                 long windowStartAddress = (gfxWindowY) ? 0x1C00 : 0x1800;
212 |                 long windowSourceTileY = windowSourceLine >> 3;
213 |                 long tileAddress = windowStartAddress + (windowSourceTileY * 0x20);
214 |                 long windowSourceTileLine = windowSourceLine & 0x7;
215 |                 for (screenX = windowLeft; screenX < 160; tileAddress++, screenX += 8)
216 |                 {
217 |                     long baseaddr = core.memory.memory[0x8000 + tileAddress];
218 |                     tileNum = (gfxBackgroundX) ? baseaddr : ((baseaddr > 0x7F) ? ((baseaddr & 0x7F) + 0x80) : (baseaddr + 0x100));
219 |                     if (core.cGBC)
220 |                     {
221 |                         long mapAttrib = core.VRAM[tileAddress];
222 |                         if ((mapAttrib & 0x80) != priority)
223 |                         {
224 |                             skippedTile = true;
225 |                             continue;
226 |                         }
227 |                         tileAttrib = ((mapAttrib & 0x07) << 2) + ((mapAttrib >> 5) & 0x03);
228 |                         tileNum += 384 * ((mapAttrib >> 3) & 0x01);
229 |                     }
230 |                     DrawPartCopy(tileNum, screenX, line, windowSourceTileLine, tileAttrib);
231 |                 }
232 |             }
233 | 
234 |             return skippedTile;
235 |         }
236 | 
237 |         private void DrawPartCopy(long tileIndex, long x, long y, long sourceLine, long attribs)
238 |         {
239 |             TileData image;
240 | 
241 |             if (tileData[tileIndex + tileCount * attribs].initialized)
242 |                 image = tileData[tileIndex + tileCount * attribs];
243 |             else
244 |                 image = UpdateImage(tileIndex, attribs);
245 | 
246 |             long dst = x + y * 160;
247 |             long src = sourceLine * 8;
248 |             long dstEnd = (x > 152) ? ((y + 1) * 160) : (dst + 8);
249 | 
250 |             if (x < 0)
251 |             {
252 |                 dst -= x;
253 |                 src -= x;
254 |             }
255 | 
256 |             while (dst < dstEnd)
257 |                 frameBuffer[dst++] = image.tiles[src++];
258 |         }
259 | 
260 |         private long VRAMReadGFX(long address, bool gbcBank)
261 |         {
262 |             return (!gbcBank ? core.memory.memory[0x8000 + address] : core.VRAM[address]);
263 |         }
264 | 
265 |         private TileData UpdateImage(long tileIndex, long attribs)
266 |         {
267 |             long address_ = tileIndex + tileCount * attribs;
268 |             bool otherBank = (tileIndex >= 384);
269 |             long offset = otherBank ? ((tileIndex - 384) << 4) : (tileIndex << 4);
270 |             long paletteStart = attribs & 0xFC;
271 |             bool transparent = attribs >= transparentCutoff;
272 |             long pixix = 0;
273 |             long pixixdx = 1;
274 |             long pixixdy = 0;
275 |             int[] tempPix = new int[64];
276 | 
277 |             if ((attribs & 2) != 0)
278 |             {
279 |                 pixixdy = -16;
280 |                 pixix = 56;
281 |             }
282 | 
283 |             if ((attribs & 1) == 0)
284 |             {
285 |                 pixixdx = -1;
286 |                 pixix += 7;
287 |                 pixixdy += 16;
288 |             }
289 | 
290 |             for (int y = 8; --y >= 0;)
291 |             {
292 |                 long num = weaveLookup[VRAMReadGFX(offset++, otherBank)] + (weaveLookup[this.VRAMReadGFX(offset++, otherBank)] << 1);
293 |                 if (num != 0)
294 |                     transparent = false;
295 | 
296 |                 for (int x = 8; --x >= 0;)
297 |                 {
298 |                     long d = paletteStart + (num & 3);
299 |                     tempPix[pixix] = (int)(palette[d] & -1);
300 |                     pixix += pixixdx;
301 |                     num >>= 2;
302 |                 }
303 | 
304 |                 pixix += pixixdy;
305 |             }
306 | 
307 |             tileData[address_].initialized = true;
308 |             if (transparent)
309 |                 tileData[address_].transparent = true;
310 |             else
311 |             {
312 |                 tileData[address_].transparent = false;
313 |                 tileData[address_].tiles = tempPix;
314 |             }
315 | 
316 |             tileReadState[tileIndex] = 1;
317 |             return tileData[address_];
318 |         }
319 | 
320 |         public void DrawSpritesForLine(long line)
321 |         {
322 |             if (!gfxSpriteShow)
323 |                 return;
324 | 
325 |             long minSpriteY = line - ((gfxSpriteDouble) ? 15 : 7);
326 |             long priorityFlag = spritePriorityEnabled ? 0x80 : 0;
327 | 
328 |             for (; priorityFlag >= 0; priorityFlag -= 0x80)
329 |             {
330 |                 long oamIx = 159;
331 |                 while (oamIx >= 0)
332 |                 {
333 |                     long attributes = 0xFF & core.memory.memory[0xFE00 + oamIx--];
334 |                     if ((attributes & 0x80) == priorityFlag || !spritePriorityEnabled)
335 |                     {
336 |                         long tileNum = (0xFF & core.memory.memory[0xFE00 + oamIx--]);
337 |                         long spriteX = (0xFF & core.memory.memory[0xFE00 + oamIx--]) - 8;
338 |                         long spriteY = (0xFF & core.memory.memory[0xFE00 + oamIx--]) - 16;
339 |                         long offset = line - spriteY;
340 | 
341 |                         if (spriteX >= 160 || spriteY < minSpriteY || offset < 0)
342 |                             continue;
343 | 
344 |                         if (gfxSpriteDouble)
345 |                             tileNum = tileNum & 0xFE;
346 | 
347 |                         long spriteAttrib = (attributes >> 5) & 0x03; // flipx: from bit 0x20 to 0x01, flipy: from bit 0x40 to 0x02
348 |                         if (core.cGBC)
349 |                         {
350 |                             spriteAttrib += 0x20 + ((attributes & 0x07) << 2); // palette
351 |                             tileNum += (384 >> 3) * (attributes & 0x08); // tile vram bank
352 |                         }
353 |                         else
354 |                         {
355 |                             // attributes 0x10: 0x00 = OBJ1 palette, 0x10 = OBJ2 palette
356 |                             // spriteAttrib: 0x04: OBJ1 palette, 0x08: OBJ2 palette
357 |                             spriteAttrib += 0x4 + ((attributes & 0x10) >> 2);
358 |                         }
359 | 
360 |                         if (priorityFlag == 0x80)
361 |                         {
362 |                             // background
363 |                             if (gfxSpriteDouble)
364 |                             {
365 |                                 if ((spriteAttrib & 2) != 0)
366 |                                     DrawPartBgSprite((tileNum | 1) - (offset >> 3), spriteX, line, offset & 7, spriteAttrib);
367 |                                 else
368 |                                     DrawPartBgSprite((tileNum & -2) + (offset >> 3), spriteX, line, offset & 7, spriteAttrib);
369 |                             }
370 |                             else
371 |                                 DrawPartBgSprite(tileNum, spriteX, line, offset, spriteAttrib);
372 |                         }
373 |                         else
374 |                         {
375 |                             // foreground
376 |                             if (gfxSpriteDouble)
377 |                             {
378 |                                 if ((spriteAttrib & 2) != 0)
379 |                                     DrawPartFgSprite((tileNum | 1) - (offset >> 3), spriteX, line, offset & 7, spriteAttrib);
380 |                                 else
381 |                                     DrawPartFgSprite((tileNum & -2) + (offset >> 3), spriteX, line, offset & 7, spriteAttrib);
382 |                             }
383 |                             else
384 |                                 DrawPartFgSprite(tileNum, spriteX, line, offset, spriteAttrib);
385 |                         }
386 |                     }
387 |                     else
388 |                     {
389 |                         oamIx -= 3;
390 |                     }
391 |                 }
392 |             }
393 |         }
394 | 
395 |         public void DrawPartBgSprite(long tileIndex, long x, long y, long sourceLine, long attribs)
396 |         {
397 |             TileData im = tileData[tileIndex + tileCount * attribs].initialized ? tileData[tileIndex + tileCount * attribs] : UpdateImage(tileIndex, attribs);
398 |             if (im.transparent)
399 |                 return;
400 | 
401 |             long dst = x + y * 160;
402 |             long src = sourceLine * 8;
403 |             long dstEnd = (x > 152) ? ((y + 1) * 160) : (dst + 8);
404 |             // adjust left
405 |             if (x < 0)
406 |             {
407 |                 dst -= x;
408 |                 src -= x;
409 |             }
410 |             while (dst < dstEnd)
411 |             {
412 |                 //if (im[src] < 0 && this.frameBuffer[dst] >= 0) {
413 |                 frameBuffer[dst] = im.tiles[src];
414 |                 // }
415 |                 ++dst;
416 |                 ++src;
417 |             }
418 |         }
419 | 
420 |         public void DrawPartFgSprite(long tileIndex, long x, long y, long sourceLine, long attribs)
421 |         {
422 |             TileData im = tileData[tileIndex + tileCount * attribs].initialized ? tileData[tileIndex + tileCount * attribs] : UpdateImage(tileIndex, attribs);
423 |             if (im.transparent)
424 |                 return;
425 | 
426 |             long dst = x + y * 160;
427 |             long src = sourceLine * 8;
428 |             long dstEnd = (x > 152) ? ((y + 1) * 160) : (dst + 8);
429 | 
430 |             if (x < 0)
431 |             {
432 |                 dst -= x;
433 |                 src -= x;
434 |             }
435 | 
436 |             while (dst < dstEnd)
437 |             {
438 |                 if (im.tiles[src] < 0)
439 |                     frameBuffer[dst] = im.tiles[src];
440 |                 ++dst;
441 |                 ++src;
442 |             }
443 |         }
444 | 
445 |         public void DisplayShowOff()
446 |         {
447 |             if (drewBlank == 0)
448 |             {
449 |                 canvasBuffer = new long[4 * width * height];
450 |                 if (colorEnabled)
451 |                 {
452 |                     for (int i = 0; i < canvasBuffer.Length; i++)
453 |                         canvasBuffer[i] = 255;
454 |                 }
455 |                 else
456 |                 {
457 |                     for (int i = 0; i < canvasBuffer.Length; i++)
458 |                         canvasBuffer[i] = 0;
459 |                 }
460 | 
461 |                 drawer.Draw(canvasBuffer);
462 |                 drewBlank = 2;
463 |             }
464 |         }
465 | 
466 |         public void DrawToCanvas()
467 |         {
468 |             if (Settings.frameskipAmout == 0 || frameCount > 0)
469 |             {
470 |                 long bufferIndex = pixelCount;
471 |                 long canvasIndex = rgbCount;
472 | 
473 |                 if (colorEnabled)
474 |                 {
475 |                     while (canvasIndex > 3)
476 |                     {
477 |                         canvasBuffer[canvasIndex -= 4] = (frameBuffer[--bufferIndex] >> 16) & 0xFF; //Red                                                                                                   
478 |                         canvasBuffer[canvasIndex + 1] = (frameBuffer[bufferIndex] >> 8) & 0xFF; //Green
479 |                         canvasBuffer[canvasIndex + 2] = frameBuffer[bufferIndex] & 0xFF; //Blue
480 |                     }
481 |                 }
482 |                 else
483 |                 {
484 |                     // Generate gray version
485 |                     while (bufferIndex > 0)
486 |                     {
487 |                         // average for black and white
488 |                         canvasBuffer[bufferIndex] = frameBuffer[--bufferIndex]; //(r + g + b) / 3;
489 |                     }
490 |                 }
491 | 
492 |                 drawer.Draw(canvasBuffer);
493 | 
494 |                 if (Settings.frameskipAmout > 0)
495 |                     frameCount -= Settings.frameskipAmout;
496 |             }
497 |             else
498 |                 frameCount += Settings.frameskipBaseFactor;
499 |         }
500 | 
501 |         public void InvalidateAll(long pal)
502 |         {
503 |             long stop = (pal + 1) * tileCountInvalidator;
504 |             for (long r = pal * tileCountInvalidator; r < stop; ++r)
505 |                 tileData[r].initialized = false;
506 |         }
507 | 
508 |         public void DecodePalette(long startIndex, long data)
509 |         {
510 |             if (!core.cGBC)
511 |             {
512 |                 gbPalette[startIndex] = colors[data & 0x03] & 0x00FFFFFF; // color 0: transparent
513 |                 gbPalette[startIndex + 1] = colors[(data >> 2) & 0x03];
514 |                 gbPalette[startIndex + 2] = colors[(data >> 4) & 0x03];
515 |                 gbPalette[startIndex + 3] = colors[data >> 6];
516 |                 CheckPaletteType();
517 |             }
518 |         }
519 | 
520 |         public void CheckPaletteType()
521 |         {
522 |             if (core.cGBC)
523 |                 palette = gbcPalette;
524 |             else
525 |                 palette = Settings.colorize ? gbColorizedPalette : gbPalette;
526 |         }
527 | 
528 |         public void ChangeTileDataArea(long address, long currVRAMBank)
529 |         {
530 |             long tileIndex = ((address - 0x8000) >> 4) + (384 * currVRAMBank);
531 |             if (tileReadState[tileIndex] == 1)
532 |             {
533 |                 long r = tileData.Length - tileCount + tileIndex;
534 |                 do
535 |                 {
536 |                     tileData[r].initialized = false;
537 |                     r -= tileCount;
538 |                 } while (r >= 0);
539 |                 tileReadState[tileIndex] = 0;
540 |             }
541 |         }
542 | 
543 |         public void SetGBCPalettePre(long address, long data)
544 |         {
545 |             if (gbcRawPalette[address] == data)
546 |                 return;
547 | 
548 |             gbcRawPalette[address] = data;
549 |             if (address >= 0x40 && (address & 0x6) == 0)
550 |                 return;
551 | 
552 |             long value = (gbcRawPalette[address | 1] << 8) + gbcRawPalette[address & -2];
553 |             gbcPalette[address >> 1] = 0x80000000 + ((value & 0x1F) << 19) + ((value & 0x3E0) << 6) + ((value & 0x7C00) >> 7);
554 | 
555 |             InvalidateAll(address >> 3);
556 |         }
557 | 
558 |         public void SetGBCPalette(long address, long data)
559 |         {
560 |             SetGBCPalettePre(address, data);
561 |             if ((address & 0x6) == 0)
562 |                 gbcPalette[address >> 1] &= 0x00FFFFFF;
563 |         }
564 | 
565 |         public void PerformHDMA()
566 |         {
567 |             Memory memory = core.memory;
568 | 
569 |             core.CPUTicks += 1 + (8 * core.multiplier);
570 | 
571 |             long dmaSrc = (memory.memory[0xFF51] << 8) + memory.memory[0xFF52];
572 |             long dmaDstRelative = (memory.memory[0xFF53] << 8) + memory.memory[0xFF54];
573 |             long dmaDstFinal = dmaDstRelative + 0x10;
574 |             long tileRelative = tileData.Length - tileCount;
575 | 
576 |             if (memory.currVRAMBank == 1)
577 |             {
578 |                 while (dmaDstRelative < dmaDstFinal)
579 |                 {
580 |                     if (dmaDstRelative < 0x1800)
581 |                     {
582 |                         long tileIndex = (dmaDstRelative >> 4) + 384;
583 |                         if (tileReadState[tileIndex] == 1)
584 |                         {
585 |                             long r = tileRelative + tileIndex;
586 |                             do
587 |                             {
588 |                                 tileData[r].initialized = false;
589 |                                 r -= tileCount;
590 |                             } while (r >= 0);
591 |                             tileReadState[tileIndex] = 0;
592 |                         }
593 |                     }
594 |                     core.VRAM[dmaDstRelative++] = memory.Read(dmaSrc++);
595 |                 }
596 |             }
597 |             else
598 |             {
599 |                 while (dmaDstRelative < dmaDstFinal)
600 |                 {
601 |                     // Bkg Tile data area
602 |                     if (dmaDstRelative < 0x1800)
603 |                     {
604 |                         long tileIndex = dmaDstRelative >> 4;
605 |                         if (tileReadState[tileIndex] == 1)
606 |                         {
607 |                             long r = tileRelative + tileIndex;
608 |                             do
609 |                             {
610 |                                 tileData[r].initialized = false;
611 |                                 r -= tileCount;
612 |                             } while (r >= 0);
613 |                             tileReadState[tileIndex] = 0;
614 |                         }
615 |                     }
616 |                     memory.memory[0x8000 + dmaDstRelative++] = memory.Read(dmaSrc++);
617 |                 }
618 |             }
619 | 
620 |             memory.memory[0xFF51] = (dmaSrc & 0xFF00) >> 8;
621 |             memory.memory[0xFF52] = dmaSrc & 0x00F0;
622 |             memory.memory[0xFF53] = ((dmaDstFinal & 0x1F00) >> 8);
623 |             memory.memory[0xFF54] = dmaDstFinal & 0x00F0;
624 | 
625 |             if (memory.memory[0xFF55] == 0)
626 |             {
627 |                 core.hdmaRunning = false;
628 |                 memory.memory[0xFF55] = 0xFF;
629 |             }
630 |             else
631 |             {
632 |                 --memory.memory[0xFF55];
633 |             }
634 |         }
635 |     }
636 | }
637 | 


--------------------------------------------------------------------------------
/Assets/Scripts/Memory.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.IO;
  3 | using System.Runtime.Serialization;
  4 | using System.Runtime.Serialization.Formatters.Binary;
  5 | using UnityEngine;
  6 | 
  7 | namespace GB
  8 | {
  9 |     [Serializable]
 10 |     public class Memory
 11 |     {
 12 |         [NonSerialized]
 13 |         private Core core;
 14 | 
 15 |         private byte[] rom;
 16 | 
 17 |         private byte[] rawRom;
 18 | 
 19 |         public long[] memory;
 20 | 
 21 |         private long[] GBCMemory;
 22 | 
 23 |         private long[] SRAM;
 24 | 
 25 |         private long currentROMBank;
 26 | 
 27 |         private long ROMBank1offs;
 28 | 
 29 |         private long numRAMBanks = 0;
 30 | 
 31 |         private bool MBCRAMBanksEnabled;
 32 | 
 33 |         private long currMBCRAMBank;
 34 | 
 35 |         private long currMBCRAMBankPosition = -0xA000;
 36 | 
 37 |         public long currVRAMBank;
 38 | 
 39 |         private bool MBC1Mode;
 40 | 
 41 |         public long[] MBCRam;
 42 | 
 43 |         private long gbcRamBankPosition = -0xD000;
 44 | 
 45 |         private long gbcRamBankPositionECHO = -0xF000;
 46 | 
 47 |         public Memory(Core core, byte[] assetBytes)
 48 |         {
 49 |             rawRom = assetBytes;
 50 |             this.core = core;
 51 |         }
 52 | 
 53 |         public void InitMemory()
 54 |         {
 55 |             memory = new long[0x10000];
 56 |             SRAM = new long[0xBFFF - 0xA000 + 1];
 57 |         }
 58 | 
 59 |         public void InitRAM()
 60 |         {
 61 |             if (core.cMBC2)
 62 |                 numRAMBanks = 1 / 16;
 63 |             else if (core.cMBC1 || core.cRUMBLE || core.cMBC3 || core.cHuC3)
 64 |                 numRAMBanks = 4;
 65 |             else if (core.cMBC5)
 66 |                 numRAMBanks = 16;
 67 |             else if (core.cSRAM)
 68 |                 numRAMBanks = 1;
 69 | 
 70 |             MBCRam = new long[numRAMBanks * 0x2000];
 71 |             Debug.Log("MBC RAM allocated=" + MBCRam.Length);
 72 | 
 73 |             if (core.cGBC)
 74 |             {
 75 |                 core.VRAM = new long[0x2000];
 76 |                 GBCMemory = new long[0x7000];
 77 |             }
 78 | 
 79 |             LoadSRAM();
 80 |         }
 81 | 
 82 |         public byte[] LoadROM()
 83 |         {
 84 |             rom = new byte[rawRom.Length];
 85 |             for (int i = 0; i < rawRom.Length; i++)
 86 |             {
 87 |                 rom[i] = (byte)(rawRom[i] & 0xFF);
 88 |                 if (i < 0x8000)
 89 |                     memory[i] = rom[i]; //Load in the game ROM.                
 90 |             }
 91 | 
 92 |             return rom;
 93 |         }
 94 | 
 95 |         public long RawRead(long address)
 96 |         {
 97 |             return memory[address];
 98 |         }
 99 | 
100 |         public void RawWrite(long address, long data)
101 |         {
102 |             memory[address] = data;
103 |         }
104 | 
105 |         private void SetCurrentMBC1ROMBank()
106 |         {
107 |             switch (ROMBank1offs)
108 |             {
109 |                 case 0x00:
110 |                 case 0x20:
111 |                 case 0x40:
112 |                 case 0x60:
113 |                     currentROMBank = ROMBank1offs * 0x4000;
114 |                     break;
115 |                 default:
116 |                     currentROMBank = (ROMBank1offs - 1) * 0x4000;
117 |                     break;
118 |             }
119 | 
120 |             while (currentROMBank + 0x4000 >= rom.Length)
121 |                 currentROMBank -= rom.Length;
122 |         }
123 | 
124 |         private void SetCurrentMBC2AND3ROMBank()
125 |         {
126 |             currentROMBank = (long)Mathf.Max(ROMBank1offs - 1, 0) * 0x4000;
127 |             while (currentROMBank + 0x4000 >= rom.Length)
128 |                 currentROMBank -= rom.Length;
129 |         }
130 | 
131 |         private void SetCurrentMBC5ROMBank()
132 |         {
133 |             currentROMBank = (ROMBank1offs - 1) * 0x4000;
134 |             while (currentROMBank + 0x4000 >= rom.Length)
135 |                 currentROMBank -= rom.Length;
136 |         }
137 | 
138 |         private void SetupMBC1(long address, long data)
139 |         {
140 |             if (address < 0x2000)
141 |                 MBCRAMBanksEnabled = ((data & 0x0F) == 0x0A);
142 |             else if (address < 0x4000)
143 |             {
144 |                 ROMBank1offs = (ROMBank1offs & 0x60) | (data & 0x1F);
145 |                 SetCurrentMBC1ROMBank();
146 |             }
147 |             else if (address < 0x6000)
148 |             {
149 |                 if (MBC1Mode)
150 |                 {
151 |                     //4/32 Mode
152 |                     currMBCRAMBank = data & 0x3;
153 |                     currMBCRAMBankPosition = (currMBCRAMBank << 13) - 0xA000;
154 |                 }
155 |                 else
156 |                 {
157 |                     //16/8 Mode
158 |                     ROMBank1offs = ((data & 0x03) << 5) | (ROMBank1offs & 0x1F);
159 |                     SetCurrentMBC1ROMBank();
160 |                 }
161 |             }
162 |             else
163 |             {
164 |                 //MBC1WriteType
165 |                 //MBC1 mode setting:
166 |                 MBC1Mode = ((data & 0x1) == 0x1);
167 |             }
168 |         }
169 | 
170 |         private void SetupMBC2(long address, long data)
171 |         {
172 |             if (address < 0x1000)
173 |                 MBCRAMBanksEnabled = ((data & 0x0F) == 0x0A);
174 |             else if (address >= 0x2100 && address < 0x2200)
175 |             {
176 |                 ROMBank1offs = data & 0x0F;
177 |                 SetCurrentMBC2AND3ROMBank();
178 |             }
179 |         }
180 | 
181 |         private void SetupMBC3(long address, long data)
182 |         {
183 |             if (address < 0x2000)
184 |                 MBCRAMBanksEnabled = ((data & 0x0F) == 0x0A);
185 |             else if (address < 0x4000)
186 |             {
187 |                 ROMBank1offs = data & 0x7F;
188 |                 SetCurrentMBC2AND3ROMBank();
189 |             }
190 |             else if (address < 0x6000)
191 |             {
192 |                 currMBCRAMBank = data;
193 |                 if (data < 4)
194 |                     currMBCRAMBankPosition = ((int)currMBCRAMBank << 13) - 0xA000;
195 |             }
196 |             else
197 |             {
198 |                 core.clock.CheckLatched(data);
199 |             }
200 |         }
201 | 
202 |         private void SetupMBC5(long address, long data)
203 |         {
204 |             if (address < 0x2000)
205 |             {
206 |                 MBCRAMBanksEnabled = ((data & 0x0F) == 0x0A);
207 |             }
208 |             else if (address < 0x3000)
209 |             {
210 |                 ROMBank1offs = (ROMBank1offs & 0x100) | data;
211 |                 SetCurrentMBC5ROMBank();
212 |             }
213 |             else if (address < 0x4000)
214 |             {
215 |                 ROMBank1offs = ((data & 0x01) << 8) | (ROMBank1offs & 0xFF);
216 |                 SetCurrentMBC5ROMBank();
217 |             }
218 |             else if (address < 0x6000)
219 |             {
220 |                 if (core.cRUMBLE)
221 |                 {
222 |                     currMBCRAMBank = data & 0x3;
223 |                     currMBCRAMBankPosition = (currMBCRAMBank << 13) - 0xA000;
224 |                 }
225 |                 else
226 |                 {
227 |                     currMBCRAMBank = data & 0xF;
228 |                     currMBCRAMBankPosition = (currMBCRAMBank << 13) - 0xA000;
229 |                 }
230 |             }
231 |         }
232 | 
233 |         public void Write(long address, long data)
234 |         {
235 |             if (address < 0x8000)
236 |             {
237 |                 if (core.cMBC1)
238 |                 {
239 |                     SetupMBC1(address, data);
240 |                 }
241 |                 else if (core.cMBC2)
242 |                 {
243 |                     SetupMBC2(address, data);
244 |                 }
245 |                 else if (core.cMBC3)
246 |                 {
247 |                     SetupMBC3(address, data);
248 |                 }
249 |                 else if (core.cMBC5 || core.cRUMBLE)
250 |                 {
251 |                     SetupMBC5(address, data);
252 |                 }
253 |                 else if (core.cHuC3)
254 |                 {
255 |                     // cHuC3
256 |                     Debug.Log("not implemented");
257 |                 }
258 |             }
259 |             else if (address < 0xA000)
260 |             {
261 |                 //VRAM cannot be written to during mode 3
262 |                 if (core.lcd.modeSTAT < 3)
263 |                 {
264 |                     // Bkg Tile data area
265 |                     if (address < 0x9800)
266 |                         core.screen.ChangeTileDataArea(address, currVRAMBank);
267 | 
268 |                     if (currVRAMBank == 0)
269 |                         memory[address] = data;
270 |                     else
271 |                         core.VRAM[address - 0x8000] = data;
272 |                 }
273 |             }
274 |             else if (address < 0xC000) // External RAM
275 |             {
276 |                 if (core.cSRAM)
277 |                     SRAM[address - 0xA000] = data;
278 | 
279 |                 if ((numRAMBanks == 1 / 16 && address < 0xA200) || numRAMBanks >= 1)
280 |                 {
281 |                     if (!core.cMBC3)
282 |                     {
283 |                         //memoryWriteMBCRAM
284 |                         if (MBCRAMBanksEnabled || Settings.overrideMBC)
285 |                             MBCRam[address + currMBCRAMBankPosition] = data;
286 |                     }
287 |                     else
288 |                     {
289 |                         //MBC3 RTC + RAM:
290 |                         //memoryWriteMBC3RAM
291 |                         if (MBCRAMBanksEnabled || Settings.overrideMBC)
292 |                             core.clock.SetClock(address, data, currMBCRAMBank, currMBCRAMBankPosition);
293 |                     }
294 |                 }
295 |             }
296 |             else if (address < 0xE000)
297 |             {
298 |                 if (core.cGBC && address >= 0xD000) //memoryWriteGBCRAM              
299 |                     GBCMemory[address + gbcRamBankPosition] = data;
300 |                 else
301 |                     memory[address] = data; //memoryWriteNormal             
302 |             }
303 |             else if (address < 0xFE00)
304 |             {
305 |                 if (core.cGBC && address >= 0xF000)  //memoryWriteECHOGBCRAM             
306 |                     GBCMemory[address + gbcRamBankPositionECHO] = data;
307 |                 else
308 |                     memory[address - 0x2000] = data; // //memoryWriteECHONormal             
309 |             }
310 |             else if (address <= 0xFEA0)
311 |             {
312 |                 //memoryWriteOAMRAM
313 |                 if (core.lcd.modeSTAT < 2)
314 |                     memory[address] = data;
315 |             }
316 |             else if (address < 0xFF00)
317 |             {
318 |                 if (core.cGBC)
319 |                     memory[address] = data; //memoryWriteNormal
320 |             }
321 |             else if (address == 0xFF00) // Keyboard
322 |                 memory[0xFF00] = ((data & 0x30) | ((((data & 0x20) == 0) ? (core.keyboard.JoyPad >> 4) : 0xF) & (((data & 0x10) == 0) ? (core.keyboard.JoyPad & 0xF) : 0xF)));
323 |             else if (address == 0xFF02)
324 |             {
325 |                 // Clocks
326 |                 if (((data & 0x1) == 0x1))
327 |                 {
328 |                     //Internal
329 |                     memory[0xFF02] = (data & 0x7F);
330 |                     memory[0xFF0F] |= 0x8;
331 |                 }
332 |                 else
333 |                 {
334 |                     //External
335 |                     memory[0xFF02] = data;
336 |                 }
337 |             }
338 |             else if (address == 0xFF04)
339 |                 memory[0xFF04] = 0;
340 |             else if (address == 0xFF07)
341 |             {
342 |                 memory[0xFF07] = data & 0x07;
343 |                 core.TIMAEnabled = (data & 0x04) == 0x04;
344 |                 core.TACClocker = (int)Mathf.Pow(4, ((data & 0x3) != 0) ? (data & 0x3) : 4);
345 |             }
346 |             else if (address == 0xFF40)
347 |             {
348 |                 if (core.cGBC)
349 |                 {
350 |                     bool active = (data & 0x80) == 0x80;
351 |                     if (active != core.lcd.LCDisOn)
352 |                     {
353 |                         core.lcd.LCDisOn = active;
354 |                         memory[0xFF41] &= 0xF8;
355 |                         core.lcd.STATTracker = core.lcd.modeSTAT = core.LCDTicks = core.lcd.currentScanLine = memory[0xFF44] = 0;
356 |                         if (core.lcd.LCDisOn)
357 |                             core.lcd.CheckIfLYCMatch();
358 |                         else
359 |                             core.screen.DisplayShowOff();
360 |                         memory[0xFF0F] &= 0xFD;
361 |                     }
362 |                     core.screen.gfxWindowY = (data & 0x40) == 0x40;
363 |                     core.screen.gfxWindowDisplay = (data & 0x20) == 0x20;
364 |                     core.screen.gfxBackgroundX = (data & 0x10) == 0x10;
365 |                     core.screen.gfxBackgroundY = (data & 0x08) == 0x08;
366 |                     core.screen.gfxSpriteDouble = (data & 0x04) == 0x04;
367 |                     core.screen.gfxSpriteShow = (data & 0x02) == 0x02;
368 |                     core.screen.spritePriorityEnabled = (data & 0x01) == 0x01;
369 |                     memory[0xFF40] = data;
370 |                 }
371 |                 else
372 |                 {
373 |                     bool active = (data & 0x80) == 0x80;
374 |                     if (active != core.lcd.LCDisOn)
375 |                     {
376 |                         core.lcd.LCDisOn = active;
377 |                         memory[0xFF41] &= 0xF8;
378 |                         memory[0xFF44] = 0;
379 |                         core.lcd.currentScanLine = 0;
380 |                         core.lcd.STATTracker = core.lcd.modeSTAT = core.LCDTicks = 0;
381 |                         if (core.lcd.LCDisOn)
382 |                             core.lcd.CheckIfLYCMatch();
383 |                         else
384 |                             core.screen.DisplayShowOff();
385 |                         memory[0xFF0F] &= 0xFD;
386 |                     }
387 |                     core.screen.gfxWindowY = (data & 0x40) == 0x40;
388 |                     core.screen.gfxWindowDisplay = (data & 0x20) == 0x20;
389 |                     core.screen.gfxBackgroundX = (data & 0x10) == 0x10;
390 |                     core.screen.gfxBackgroundY = (data & 0x08) == 0x08;
391 |                     core.screen.gfxSpriteDouble = (data & 0x04) == 0x04;
392 |                     core.screen.gfxSpriteShow = (data & 0x02) == 0x02;
393 |                     if ((data & 0x01) == 0)
394 |                     {
395 |                         core.bgEnabled = false;
396 |                         core.screen.gfxWindowDisplay = false;
397 |                     }
398 |                     else
399 |                     {
400 |                         core.bgEnabled = true;
401 |                     }
402 |                     memory[0xFF40] = data;
403 |                 }
404 |             }
405 |             else if (address == 0xFF41)
406 |             {
407 |                 if (core.cGBC)
408 |                 {
409 |                     core.lcd.LYCMatchTriggerSTAT = ((data & 0x40) == 0x40);
410 |                     core.lcd.mode2TriggerSTAT = ((data & 0x20) == 0x20);
411 |                     core.lcd.mode1TriggerSTAT = ((data & 0x10) == 0x10);
412 |                     core.lcd.mode0TriggerSTAT = ((data & 0x08) == 0x08);
413 |                     memory[0xFF41] = (data & 0xF8);
414 |                 }
415 |                 else
416 |                 {
417 |                     core.lcd.LYCMatchTriggerSTAT = ((data & 0x40) == 0x40);
418 |                     core.lcd.mode2TriggerSTAT = ((data & 0x20) == 0x20);
419 |                     core.lcd.mode1TriggerSTAT = ((data & 0x10) == 0x10);
420 |                     core.lcd.mode0TriggerSTAT = ((data & 0x08) == 0x08);
421 |                     memory[0xFF41] = (data & 0xF8);
422 |                     if (core.lcd.LCDisOn && core.lcd.modeSTAT < 2)
423 |                         memory[0xFF0F] |= 0x2;
424 |                 }
425 |             }
426 |             else if (address == 0xFF45)
427 |             {
428 |                 memory[0xFF45] = data;
429 |                 if (core.lcd.LCDisOn)
430 |                     core.lcd.CheckIfLYCMatch();
431 |             }
432 |             else if (address == 0xFF46)
433 |             {
434 |                 memory[0xFF46] = data;
435 |                 if (core.cGBC || data > 0x7F)
436 |                 {
437 |                     data <<= 8;
438 |                     address = 0xFE00;
439 |                     while (address < 0xFEA0)
440 |                         memory[address++] = Read(data++);
441 |                 }
442 |             }
443 |             else if (address == 0xFF47)
444 |             {
445 |                 core.screen.DecodePalette(0, data);
446 |                 if (memory[0xFF47] != data)
447 |                 {
448 |                     memory[0xFF47] = data;
449 |                     core.screen.InvalidateAll(0);
450 |                 }
451 |             }
452 |             else if (address == 0xFF48)
453 |             {
454 |                 core.screen.DecodePalette(4, data);
455 |                 if (memory[0xFF48] != data)
456 |                 {
457 |                     memory[0xFF48] = data;
458 |                     core.screen.InvalidateAll(1);
459 |                 }
460 |             }
461 |             else if (address == 0xFF49)
462 |             {
463 |                 core.screen.DecodePalette(8, data);
464 |                 if (memory[0xFF49] != data)
465 |                 {
466 |                     memory[0xFF49] = data;
467 |                     core.screen.InvalidateAll(2);
468 |                 }
469 |             }
470 |             else if (address == 0xFF4D)
471 |             {
472 |                 if (core.cGBC)
473 |                     memory[0xFF4D] = (data & 0x7F) + (memory[0xFF4D] & 0x80);
474 |                 else
475 |                     memory[0xFF4D] = data;
476 |             }
477 |             else if (address == 0xFF4F)
478 |             {
479 |                 if (core.cGBC)
480 |                     currVRAMBank = data & 0x01;
481 |             }
482 |             else if (address == 0xFF50)
483 |             {
484 |                 if (core.inBootstrap)
485 |                 {
486 |                     core.inBootstrap = false;
487 |                     //disableBootROM(); 
488 |                     memory[0xFF50] = data;
489 |                     Debug.Log("NOT IMPLEMENTED");
490 |                 }
491 |             }
492 |             else if (address == 0xFF51)
493 |             {
494 |                 if (core.cGBC)
495 |                 {
496 |                     if (!core.hdmaRunning)
497 |                         memory[0xFF51] = data;
498 |                 }
499 |             }
500 |             else if (address == 0xFF52)
501 |             {
502 |                 if (core.cGBC)
503 |                 {
504 |                     if (!core.hdmaRunning)
505 |                         memory[0xFF52] = data & 0xF0;
506 |                 }
507 |             }
508 |             else if (address == 0xFF53)
509 |             {
510 |                 if (core.cGBC)
511 |                 {
512 |                     if (!core.hdmaRunning)
513 |                         memory[0xFF53] = data & 0x1F;
514 |                 }
515 |             }
516 |             else if (address == 0xFF54)
517 |             {
518 |                 if (core.cGBC)
519 |                 {
520 |                     if (!core.hdmaRunning)
521 |                         memory[0xFF54] = data & 0xF0;
522 |                 }
523 |             }
524 |             else if (address == 0xFF55)
525 |             {
526 |                 if (core.cGBC)
527 |                 {
528 |                     if (!core.hdmaRunning)
529 |                     {
530 |                         if ((data & 0x80) == 0) //DMA
531 |                         {
532 |                             core.CPUTicks += 1 + ((8 * ((data & 0x7F) + 1)) * core.multiplier);
533 |                             long dmaSrc = (memory[0xFF51] << 8) + memory[0xFF52];
534 |                             long dmaDst = 0x8000 + (memory[0xFF53] << 8) + memory[0xFF54];
535 |                             long endAmount = (((data & 0x7F) * 0x10) + 0x10);
536 |                             for (long loopAmount = 0; loopAmount < endAmount; ++loopAmount)
537 |                                 Write(dmaDst++, Read(dmaSrc++));
538 |                             memory[0xFF51] = (dmaSrc & 0xFF00) >> 8;
539 |                             memory[0xFF52] = dmaSrc & 0x00F0;
540 |                             memory[0xFF53] = (dmaDst & 0x1F00) >> 8;
541 |                             memory[0xFF54] = dmaDst & 0x00F0;
542 |                             memory[0xFF55] = 0xFF;
543 |                         }
544 |                         else //H-Blank DMA
545 |                         {
546 |                             if (data > 0x80)
547 |                             {
548 |                                 core.hdmaRunning = true;
549 |                                 memory[0xFF55] = data & 0x7F;
550 |                             }
551 |                             else
552 |                             {
553 |                                 memory[0xFF55] = 0xFF;
554 |                             }
555 |                         }
556 |                     }
557 |                     else if ((data & 0x80) == 0) //Stop H-Blank DMA
558 |                     {
559 |                         core.hdmaRunning = false;
560 |                         memory[0xFF55] |= 0x80;
561 |                     }
562 |                 }
563 |                 else
564 |                 {
565 |                     memory[0xFF55] = data;
566 |                 }
567 |             }
568 |             else if (address == 0xFF68)
569 |             {
570 |                 if (core.cGBC)
571 |                 {
572 |                     memory[0xFF69] = (long)(0xFF & core.screen.gbcRawPalette[data & 0x3F]);
573 |                     memory[0xFF68] = data;
574 |                 }
575 |                 else
576 |                 {
577 |                     memory[0xFF68] = data;
578 |                 }
579 |             }
580 |             else if (address == 0xFF69)
581 |             {
582 |                 if (core.cGBC)
583 |                 {
584 |                     core.screen.SetGBCPalette(memory[0xFF68] & 0x3F, data);
585 |                     if (Utils.Usbtsb(memory[0xFF68]) < 0)
586 |                     {
587 |                         long next = ((Utils.Usbtsb(memory[0xFF68]) + 1) & 0x3F);
588 |                         memory[0xFF68] = (next | 0x80);
589 |                         memory[0xFF69] = 0xFF & core.screen.gbcRawPalette[next];
590 |                     }
591 |                     else
592 |                     {
593 |                         memory[0xFF69] = data;
594 |                     }
595 |                 }
596 |                 else
597 |                 {
598 |                     memory[0xFF69] = data;
599 |                 }
600 |             }
601 |             else if (address == 0xFF6A)
602 |             {
603 |                 if (core.cGBC)
604 |                 {
605 |                     memory[0xFF6B] = 0xFF & core.screen.gbcRawPalette[(data & 0x3F) | 0x40];
606 |                     memory[0xFF6A] = data;
607 |                 }
608 |                 else
609 |                     memory[0xFF6A] = data;
610 |             }
611 |             else if (address == 0xFF6B)
612 |             {
613 |                 if (core.cGBC)
614 |                 {
615 |                     core.screen.SetGBCPalette((memory[0xFF6A] & 0x3F) + 0x40, data);
616 |                     if (Utils.Usbtsb(memory[0xFF6A]) < 0)
617 |                     {
618 |                         long next = ((memory[0xFF6A] + 1) & 0x3F);
619 |                         memory[0xFF6A] = (next | 0x80);
620 |                         memory[0xFF6B] = 0xFF & core.screen.gbcRawPalette[next | 0x40];
621 |                     }
622 |                     else
623 |                     {
624 |                         memory[0xFF6B] = data;
625 |                     }
626 |                 }
627 |                 else
628 |                     memory[0xFF6B] = data;
629 |             }
630 |             else if (address == 0xFF6C)
631 |             {
632 |                 if (core.inBootstrap)
633 |                 {
634 |                     if (core.inBootstrap)
635 |                     {
636 |                         core.cGBC = (data == 0x80);
637 |                         Debug.Log("Booted to GBC mode");
638 |                     }
639 |                     memory[0xFF6C] = data;
640 |                 }
641 |             }
642 |             else if (address == 0xFF70)
643 |             {
644 |                 if (core.cGBC)
645 |                 {
646 |                     long addressCheck = (memory[0xFF51] << 8) | memory[0xFF52];
647 |                     if (!core.hdmaRunning || addressCheck < 0xD000 || addressCheck >= 0xE000)
648 |                     {
649 |                         long gbcRamBank = Math.Max(data & 0x07, 1);
650 |                         gbcRamBankPosition = ((gbcRamBank - 1) * 0x1000) - 0xD000;
651 |                         gbcRamBankPositionECHO = ((gbcRamBank - 1) * 0x1000) - 0xF000;
652 |                     }
653 |                     memory[0xFF70] = (data | 0x40);
654 |                 }
655 |                 else
656 |                     memory[0xFF70] = data;
657 |             }
658 |             else
659 |             {
660 |                 memory[address] = data;
661 |             }
662 |         }
663 | 
664 |         public long Read(long address)
665 |         {
666 |             if (address < 0x4000)
667 |                 return memory[address];
668 | 
669 |             if (address < 0x8000)
670 |                 return rom[currentROMBank + address];
671 | 
672 |             if (address >= 0x8000 && address < 0xA000) // Character RAM
673 |             {
674 |                 if (core.cGBC)
675 |                     return core.lcd.modeSTAT > 2 ? 0xFF : ((currVRAMBank == 0) ? memory[address] : core.VRAM[address - 0x8000]);
676 | 
677 |                 return core.lcd.modeSTAT > 2 ? 0xFF : memory[address];
678 |             }
679 | 
680 |             if (address >= 0xA000 && address < 0xC000) // External (cartridge) RAM
681 |             {
682 |                 if ((numRAMBanks == 1 / 16 && address < 0xA200) || numRAMBanks >= 1)
683 |                 {
684 |                     if (!core.cMBC3)
685 |                     {
686 |                         if (MBCRAMBanksEnabled || Settings.overrideMBC)
687 |                             return MBCRam[address + currMBCRAMBankPosition];
688 | 
689 |                         //cout("Reading from disabled RAM.", 1);
690 |                         return 0xFF;
691 |                     }
692 | 
693 |                     if (MBCRAMBanksEnabled || Settings.overrideMBC)
694 |                     {
695 |                         long data = core.clock.GetTime(currMBCRAMBank, currMBCRAMBankPosition, address);
696 |                         if (core.cSRAM && data == 0xFF)
697 |                             return SRAM[address - 0xA000];
698 |                     }
699 |                 }
700 | 
701 |                 if (core.cSRAM)
702 |                     return SRAM[address - 0xA000];
703 |             }
704 | 
705 |             if (address >= 0xC000 && address < 0xE000)
706 |             {
707 |                 if (!core.cGBC || address < 0xD000)
708 |                     return memory[address];
709 |                 return GBCMemory[address + gbcRamBankPosition]; //memoryReadGBCMemory               
710 |             }
711 | 
712 |             if (address >= 0xE000 && address < 0xFE00)
713 |             {
714 |                 if (!core.cGBC || address < 0xF000)
715 |                     return memory[address - 0x2000]; //memoryReadECHONormal                             
716 |                 return GBCMemory[address + gbcRamBankPositionECHO]; //memoryReadECHOGBCMemory
717 |             }
718 | 
719 |             if (address < 0xFEA0)
720 |             {
721 |                 //memoryReadOAM
722 |                 return core.lcd.modeSTAT > 1 ? 0xFF : memory[address];
723 |             }
724 | 
725 |             if (core.cGBC && address >= 0xFEA0 && address < 0xFF00)
726 |             {
727 |                 //memoryReadNormal
728 |                 return memory[address];
729 |             }
730 | 
731 |             if (address >= 0xFF00)
732 |             {
733 |                 switch (address)
734 |                 {
735 |                     case 0xFF00:
736 |                         return 0xC0 | memory[0xFF00]; //Top nibble returns as set.
737 |                     case 0xFF01:
738 |                         return ((memory[0xFF02] & 0x1) == 0x1) ? 0xFF : memory[0xFF01];
739 |                     case 0xFF02:
740 |                         if (core.cGBC)
741 |                             return 0x7C | memory[0xFF02];
742 |                         return 0x7E | memory[0xFF02];
743 |                     case 0xFF07:
744 |                         return 0xF8 | memory[0xFF07];
745 |                     case 0xFF0F:
746 |                         return 0xE0 | memory[0xFF0F];
747 |                     case 0xFF10:
748 |                         return 0x80 | memory[0xFF10];
749 |                     case 0xFF11:
750 |                         return 0x3F | memory[0xFF11];
751 |                     case 0xFF14:
752 |                         return 0xBF | memory[0xFF14];
753 |                     case 0xFF16:
754 |                         return 0x3F | memory[0xFF16];
755 |                     case 0xFF19:
756 |                         return 0xBF | memory[0xFF19];
757 |                     case 0xFF1A:
758 |                         return 0x7F | memory[0xFF1A];
759 |                     case 0xFF1B:
760 |                         return 0xFF;
761 |                     case 0xFF1C:
762 |                         return 0x9F | memory[0xFF1C];
763 |                     case 0xFF1E:
764 |                         return 0xBF | memory[0xFF1E];
765 |                     case 0xFF20:
766 |                         return 0xFF;
767 |                     case 0xFF23:
768 |                         return 0xBF | memory[0xFF23];
769 |                     case 0xFF26:
770 |                         return 0x70 | memory[0xFF26];
771 |                     case 0xFF30:
772 |                     case 0xFF31:
773 |                     case 0xFF32:
774 |                     case 0xFF33:
775 |                     case 0xFF34:
776 |                     case 0xFF35:
777 |                     case 0xFF36:
778 |                     case 0xFF37:
779 |                     case 0xFF38:
780 |                     case 0xFF39:
781 |                     case 0xFF3A:
782 |                     case 0xFF3B:
783 |                     case 0xFF3C:
784 |                     case 0xFF3D:
785 |                     case 0xFF3E:
786 |                     case 0xFF3F:
787 |                         return ((memory[0xFF26] & 0x4) == 0x4) ? 0xFF : memory[address];
788 |                     case 0xFF41:
789 |                         return 0x80 | memory[0xFF41] | core.lcd.modeSTAT;
790 |                     case 0xFF44:
791 |                         return core.lcd.LCDisOn ? memory[0xFF44] : 0;
792 |                     case 0xFF4F:
793 |                         return currVRAMBank;
794 |                     default:
795 |                         return memory[address]; //memoryReadNormal
796 |                 }
797 |             }
798 | 
799 |             return 0xFF; //memoryReadBAD
800 |         }
801 | 
802 |         public void SaveSRAM()
803 |         {
804 |             if (!core.cSRAM)
805 |                 return;
806 | 
807 |             byte[] data = new byte[SRAM.Length];
808 | 
809 |             for (int i = 0; i < SRAM.Length; i++)
810 |                 data[i] = (byte)SRAM[i];
811 | 
812 |             PlayerPrefs.SetString("SRAM-" + core.name, Convert.ToBase64String(data));
813 | 
814 |             data = new byte[MBCRam.Length];
815 | 
816 |             for (int i = 0; i < MBCRam.Length; i++)
817 |                 data[i] = (byte)MBCRam[i];
818 | 
819 |             PlayerPrefs.SetString("MBCRAM-" + core.name, Convert.ToBase64String(data));
820 | 
821 |             Debug.Log("Saved MBCRAM + SRAM");
822 |         }
823 | 
824 |         public void LoadSRAM()
825 |         {
826 |             if (!core.cSRAM)
827 |                 return;
828 | 
829 |             string base64data = PlayerPrefs.GetString("SRAM-" + core.name, "");
830 | 
831 |             if (string.IsNullOrEmpty(base64data))
832 |                 return;
833 | 
834 |             byte[] data = Convert.FromBase64String(base64data);
835 | 
836 |             SRAM = new long[data.Length];
837 | 
838 |             for (int i = 0; i < data.Length; i++)
839 |                 SRAM[i] = data[i];
840 | 
841 |             base64data = PlayerPrefs.GetString("MBCRAM-" + core.name, "");
842 | 
843 |             if (string.IsNullOrEmpty(base64data))
844 |                 return;
845 | 
846 |             data = Convert.FromBase64String(base64data);
847 | 
848 |             for (int i = 0; i < data.Length; i++)
849 |                 MBCRam[i] = data[i];
850 | 
851 |             Debug.Log("Restored MBCRAM + SRAM");
852 |         }
853 | 
854 |         public void SaveState()
855 |         {
856 |             IFormatter formatter = new BinaryFormatter();
857 |             Stream stream = new FileStream("/tmp/state", FileMode.Create, FileAccess.Write, FileShare.None);
858 |             formatter.Serialize(stream, this);
859 |             stream.Close();
860 |         }
861 |     }
862 | }


--------------------------------------------------------------------------------