Added submodule filesHEADmaster

1 files changed, 1002 insertions, 0 deletions

diff --git a/gearboy/src/GearboyCore.cpp b/gearboy/src/GearboyCore.cpp
new file mode 100644
index 00000000..5e3ff7e6
--- /dev/null
+++ b/gearboy/src/GearboyCore.cpp
@@ -0,0 +1,1002 @@
+/*
+ * Gearboy - Nintendo Game Boy Emulator
+ * Copyright (C) 2012  Ignacio Sanchez
+
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see http://www.gnu.org/licenses/
+ *
+ */
+
+#include "GearboyCore.h"
+#include "Memory.h"
+#include "Processor.h"
+#include "Video.h"
+#include "Audio.h"
+#include "Input.h"
+#include "Cartridge.h"
+#include "MemoryRule.h"
+#include "CommonMemoryRule.h"
+#include "IORegistersMemoryRule.h"
+#include "RomOnlyMemoryRule.h"
+#include "MBC1MemoryRule.h"
+#include "MBC2MemoryRule.h"
+#include "MBC3MemoryRule.h"
+#include "MBC5MemoryRule.h"
+#include "MultiMBC1MemoryRule.h"
+
+GearboyCore::GearboyCore()
+{
+    InitPointer(m_pMemory);
+    InitPointer(m_pProcessor);
+    InitPointer(m_pVideo);
+    InitPointer(m_pAudio);
+    InitPointer(m_pInput);
+    InitPointer(m_pCartridge);
+    InitPointer(m_pCommonMemoryRule);
+    InitPointer(m_pIORegistersMemoryRule);
+    InitPointer(m_pRomOnlyMemoryRule);
+    InitPointer(m_pMBC1MemoryRule);
+    InitPointer(m_pMultiMBC1MemoryRule);
+    InitPointer(m_pMBC2MemoryRule);
+    InitPointer(m_pMBC3MemoryRule);
+    InitPointer(m_pMBC5MemoryRule);
+    InitPointer(m_pRamChangedCallback);
+    m_bCGB = false;
+    m_bGBA = false;
+    m_bPaused = false;
+    m_bForceDMG = false;
+    m_iRTCUpdateCount = 0;
+    m_pixelFormat = GB_PIXEL_RGB565;
+}
+
+GearboyCore::~GearboyCore()
+{
+    SafeDelete(m_pMBC5MemoryRule);
+    SafeDelete(m_pMBC3MemoryRule);
+    SafeDelete(m_pMBC2MemoryRule);
+    SafeDelete(m_pMultiMBC1MemoryRule);
+    SafeDelete(m_pMBC1MemoryRule);
+    SafeDelete(m_pRomOnlyMemoryRule);
+    SafeDelete(m_pIORegistersMemoryRule);
+    SafeDelete(m_pCommonMemoryRule);
+    SafeDelete(m_pCartridge);
+    SafeDelete(m_pInput);
+    SafeDelete(m_pAudio);
+    SafeDelete(m_pVideo);
+    SafeDelete(m_pProcessor);
+    SafeDelete(m_pMemory);
+}
+
+void GearboyCore::Init(GB_Color_Format pixelFormat)
+{
+    Log("--== %s %s by Ignacio Sanchez ==--", GEARBOY_TITLE, GEARBOY_VERSION);
+
+    m_pixelFormat = pixelFormat;
+
+    m_pMemory = new Memory();
+    m_pProcessor = new Processor(m_pMemory);
+    m_pVideo = new Video(m_pMemory, m_pProcessor);
+    m_pAudio = new Audio();
+    m_pInput = new Input(m_pMemory, m_pProcessor);
+    m_pCartridge = new Cartridge();
+
+    m_pMemory->Init();
+    m_pProcessor->Init();
+    m_pVideo->Init();
+    m_pAudio->Init();
+    m_pInput->Init();
+    m_pCartridge->Init();
+
+    InitMemoryRules();
+    InitDMGPalette();
+}
+
+bool GearboyCore::RunToVBlank(u16* pFrameBuffer, s16* pSampleBuffer, int* pSampleCount, bool bDMGbuffer, bool step, bool stopOnBreakpoints)
+{
+    bool breakpoint = false;
+
+    if (!m_bPaused && m_pCartridge->IsLoadedROM())
+    {
+        bool vblank = false;
+        int totalClocks = 0;
+        while (!vblank)
+        {
+            #ifdef PERFORMANCE
+                unsigned int clockCycles = m_pProcessor->RunFor(75);
+            #else
+                unsigned int clockCycles = m_pProcessor->RunFor(1);
+            #endif
+
+            m_pProcessor->UpdateTimers(clockCycles);
+            m_pProcessor->UpdateSerial(clockCycles);
+            
+            vblank = m_pVideo->Tick(clockCycles, pFrameBuffer, m_pixelFormat);
+            m_pAudio->Tick(clockCycles);
+            m_pInput->Tick(clockCycles);
+
+            totalClocks += clockCycles;
+
+#ifndef GEARBOY_DISABLE_DISASSEMBLER
+            if ((step || (stopOnBreakpoints && m_pProcessor->BreakpointHit())) && !m_pProcessor->Halted() && !m_pProcessor->DuringOpCode())
+            {
+                vblank = true;
+                if (m_pProcessor->BreakpointHit())
+                    breakpoint = true;
+            }
+#endif
+
+            if (totalClocks > 702240)
+                vblank = true;
+        }
+
+        m_pAudio->EndFrame(pSampleBuffer, pSampleCount);
+
+        m_iRTCUpdateCount++;
+        if (m_iRTCUpdateCount == 20)
+        {
+            m_iRTCUpdateCount = 0;
+            m_pCartridge->UpdateCurrentRTC();
+        }
+
+        if (!m_bCGB && !bDMGbuffer)
+        {
+            RenderDMGFrame(pFrameBuffer);
+        }
+    }
+
+    return breakpoint;
+}
+
+bool GearboyCore::LoadROM(const char* szFilePath, bool forceDMG, Cartridge::CartridgeTypes forceType, bool forceGBA)
+{
+    if (m_pCartridge->LoadFromFile(szFilePath))
+    {
+        m_bForceDMG = forceDMG;
+        Reset(m_bForceDMG ? false : m_pCartridge->IsCGB(), forceGBA);
+        m_pMemory->ResetDisassembledMemory();
+        m_pMemory->LoadBank0and1FromROM(m_pCartridge->GetTheROM());
+        bool romTypeOK = AddMemoryRules(forceType);
+#ifndef GEARBOY_DISABLE_DISASSEMBLER
+        m_pProcessor->Disassemble(m_pProcessor->GetState()->PC->GetValue());
+#endif
+
+        if (!romTypeOK)
+        {
+            Log("There was a problem with the cartridge header. File: %s...", szFilePath);
+        }
+
+        return romTypeOK;
+    }
+    else
+        return false;
+}
+
+bool GearboyCore::LoadROMFromBuffer(const u8* buffer, int size, bool forceDMG, Cartridge::CartridgeTypes forceType, bool forceGBA)
+{
+    if (m_pCartridge->LoadFromBuffer(buffer, size))
+    {
+        m_bForceDMG = forceDMG;
+        Reset(m_bForceDMG ? false : m_pCartridge->IsCGB(), forceGBA);
+        m_pMemory->ResetDisassembledMemory();
+        m_pMemory->LoadBank0and1FromROM(m_pCartridge->GetTheROM());
+        bool romTypeOK = AddMemoryRules(forceType);
+
+        if (!romTypeOK)
+        {
+            Log("There was a problem with the cartridge header.");
+        }
+
+        return romTypeOK;
+    }
+    else
+        return false;
+}
+
+void GearboyCore::SaveMemoryDump()
+{
+    if (m_pCartridge->IsLoadedROM() && (strlen(m_pCartridge->GetFilePath()) > 0))
+    {
+        using namespace std;
+
+        char path[512];
+
+        strcpy(path, m_pCartridge->GetFilePath());
+        strcat(path, ".dump");
+
+        Log("Saving Memory Dump %s...", path);
+
+        m_pMemory->MemoryDump(path);
+
+        Log("Memory Dump Saved");
+    }
+}
+
+void GearboyCore::SaveDisassembledROM()
+{
+    Memory::stDisassembleRecord** romMap = m_pMemory->GetDisassembledROMMemoryMap();
+
+    if (m_pCartridge->IsLoadedROM() && (strlen(m_pCartridge->GetFilePath()) > 0) && IsValidPointer(romMap))
+    {
+        using namespace std;
+
+        char path[512];
+
+        strcpy(path, m_pCartridge->GetFilePath());
+        strcat(path, ".dis");
+
+        Log("Saving Disassembled ROM %s...", path);
+
+        ofstream myfile(path, ios::out | ios::trunc);
+
+        if (myfile.is_open())
+        {
+            for (int i = 0; i < 65536; i++)
+            {
+                if (IsValidPointer(romMap[i]) && (romMap[i]->name[0] != 0))
+                {
+                    myfile << "0x" << hex << i << "\t " << romMap[i]->name << "\n";
+                    i += (romMap[i]->size - 1);
+                }
+            }
+
+            myfile.close();
+        }
+
+        Log("Disassembled ROM Saved");
+    }
+}
+
+Memory* GearboyCore::GetMemory()
+{
+    return m_pMemory;
+}
+
+Cartridge* GearboyCore::GetCartridge()
+{
+    return m_pCartridge;
+}
+
+Processor* GearboyCore::GetProcessor()
+{
+    return m_pProcessor;
+}
+
+Audio* GearboyCore::GetAudio()
+{
+    return m_pAudio;
+}
+
+Video* GearboyCore::GetVideo()
+{
+    return m_pVideo;
+}
+
+void GearboyCore::KeyPressed(Gameboy_Keys key)
+{
+    m_pInput->KeyPressed(key);
+}
+
+void GearboyCore::KeyReleased(Gameboy_Keys key)
+{
+    m_pInput->KeyReleased(key);
+}
+
+void GearboyCore::Pause(bool paused)
+{
+    m_bPaused = paused;
+}
+
+bool GearboyCore::IsPaused()
+{
+    return m_bPaused;
+}
+
+void GearboyCore::ResetROM(bool forceDMG, Cartridge::CartridgeTypes forceType, bool forceGBA)
+{
+    if (m_pCartridge->IsLoadedROM())
+    {
+        m_bForceDMG = forceDMG;
+        Reset(m_bForceDMG ? false : m_pCartridge->IsCGB(), forceGBA);
+        m_pMemory->LoadBank0and1FromROM(m_pCartridge->GetTheROM());
+        AddMemoryRules(forceType);
+#ifndef GEARBOY_DISABLE_DISASSEMBLER
+        m_pProcessor->Disassemble(m_pProcessor->GetState()->PC->GetValue());
+#endif
+    }
+}
+
+void GearboyCore::ResetROMPreservingRAM(bool forceDMG, Cartridge::CartridgeTypes forceType, bool forceGBA)
+{
+    if (m_pCartridge->IsLoadedROM())
+    {
+        Log("Resetting preserving RAM...");
+
+        using namespace std;
+        stringstream stream;
+
+        m_pMemory->GetCurrentRule()->SaveRam(stream);
+
+        ResetROM(forceDMG, forceType, forceGBA);
+
+        stream.seekg(0, stream.end);
+        s32 size = (s32)stream.tellg();
+        stream.seekg(0, stream.beg);
+
+        m_pMemory->GetCurrentRule()->LoadRam(stream, size);
+    }
+}
+
+void GearboyCore::ResetSound()
+{
+    m_pAudio->Reset(m_bCGB);
+}
+
+void GearboyCore::SetSoundSampleRate(int rate)
+{
+    m_pAudio->SetSampleRate(rate);
+}
+
+void GearboyCore::SetSoundVolume(float volume)
+{
+    m_pAudio->SetVolume(volume);
+}
+
+u16* GearboyCore::GetDMGInternalPalette()
+{
+    return m_DMGPalette;
+}
+
+void GearboyCore::SetDMGPalette(GB_Color& color1, GB_Color& color2, GB_Color& color3,
+        GB_Color& color4)
+{
+    bool format_565 = (m_pixelFormat == GB_PIXEL_RGB565) || (m_pixelFormat == GB_PIXEL_BGR565);
+    bool order_RGB = (m_pixelFormat == GB_PIXEL_RGB565) || (m_pixelFormat == GB_PIXEL_RGB555);
+
+    int multiplier = format_565 ? 63 : 31;
+    int shift = format_565 ? 11 : 10;
+
+    if (order_RGB)
+    {
+        m_DMGPalette[0] = (((color1.red * 31) / 255) << shift ) | (((color1.green * multiplier) / 255) << 5 ) | ((color1.blue * 31) / 255);
+        m_DMGPalette[1] = (((color2.red * 31) / 255) << shift ) | (((color2.green * multiplier) / 255) << 5 ) | ((color2.blue * 31) / 255);
+        m_DMGPalette[2] = (((color3.red * 31) / 255) << shift ) | (((color3.green * multiplier) / 255) << 5 ) | ((color3.blue * 31) / 255);
+        m_DMGPalette[3] = (((color4.red * 31) / 255) << shift ) | (((color4.green * multiplier) / 255) << 5 ) | ((color4.blue * 31) / 255);        
+    }
+    else
+    {
+        m_DMGPalette[0] = (((color1.blue * 31) / 255) << shift ) | (((color1.green * multiplier) / 255) << 5 ) | ((color1.red * 31) / 255);
+        m_DMGPalette[1] = (((color2.blue * 31) / 255) << shift ) | (((color2.green * multiplier) / 255) << 5 ) | ((color2.red * 31) / 255);
+        m_DMGPalette[2] = (((color3.blue * 31) / 255) << shift ) | (((color3.green * multiplier) / 255) << 5 ) | ((color3.red * 31) / 255);
+        m_DMGPalette[3] = (((color4.blue * 31) / 255) << shift ) | (((color4.green * multiplier) / 255) << 5 ) | ((color4.red * 31) / 255);
+    }   
+
+    if (!format_565)
+    {
+        m_DMGPalette[0] |= 0x8000;
+        m_DMGPalette[1] |= 0x8000;
+        m_DMGPalette[2] |= 0x8000;
+        m_DMGPalette[3] |= 0x8000;
+    }
+}
+
+void GearboyCore::SaveRam()
+{
+    SaveRam(NULL);
+}
+
+void GearboyCore::SaveRam(const char* szPath, bool fullPath)
+{
+    if (m_pCartridge->IsLoadedROM() && m_pCartridge->HasBattery() && IsValidPointer(m_pMemory->GetCurrentRule()))
+    {
+        Log("Saving RAM...");
+
+        using namespace std;
+
+        string path = "";
+
+        if (IsValidPointer(szPath))
+        {
+            path += szPath;
+
+            if (!fullPath)
+            {
+                path += "/";
+                path += m_pCartridge->GetFileName();
+            }
+        }
+        else
+        {
+            path = m_pCartridge->GetFilePath();
+        }
+
+        string::size_type i = path.rfind('.', path.length());
+
+        if (i != string::npos) {
+            path.replace(i + 1, 3, "sav");
+        }
+
+        Log("Save file: %s", path.c_str());
+
+        ofstream file(path.c_str(), ios::out | ios::binary);
+
+        m_pMemory->GetCurrentRule()->SaveRam(file);
+
+        Log("RAM saved");
+    }
+}
+
+void GearboyCore::LoadRam()
+{
+    LoadRam(NULL);
+}
+
+void GearboyCore::LoadRam(const char* szPath, bool fullPath)
+{
+    if (m_pCartridge->IsLoadedROM() && m_pCartridge->HasBattery() && IsValidPointer(m_pMemory->GetCurrentRule()))
+    {
+        Log("Loading RAM...");
+
+        using namespace std;
+
+        string sav_path = "";
+
+        if (IsValidPointer(szPath))
+        {
+            sav_path += szPath;
+
+            if (!fullPath)
+            {
+                sav_path += "/";
+                sav_path += m_pCartridge->GetFileName();
+            }
+        }
+        else
+        {
+            sav_path = m_pCartridge->GetFilePath();
+        }
+
+        string rom_path = sav_path;
+
+        string::size_type i = sav_path.rfind('.', sav_path.length());
+
+        if (i != string::npos) {
+            sav_path.replace(i + 1, 3, "sav");
+        }
+
+        Log("Opening save file: %s", sav_path.c_str());
+
+        ifstream file;
+
+        file.open(sav_path.c_str(), ios::in | ios::binary);
+
+        // check for old .gearboy saves
+        if (file.fail())
+        {
+            Log("Save file doesn't exist");
+            string old_sav_file = rom_path + ".gearboy";
+
+            Log("Opening old save file: %s", old_sav_file.c_str());
+            file.open(old_sav_file.c_str(), ios::in | ios::binary);
+        }
+
+        if (!file.fail())
+        {
+            file.seekg(0, file.end);
+            s32 fileSize = (s32)file.tellg();
+            file.seekg(0, file.beg);
+
+            if (m_pMemory->GetCurrentRule()->LoadRam(file, fileSize))
+            {
+                Log("RAM loaded");
+            }
+            else
+            {
+                Log("Save file size incorrect: %d", fileSize);
+            }
+        }
+        else
+        {
+            Log("Save file doesn't exist");
+        }
+    }
+}
+
+void GearboyCore::SaveState(int index)
+{
+    if (m_pMemory->IsBootromRegistryEnabled())
+    {
+        Log("Save states disabled when running bootrom");
+        return;
+    }
+
+    Log("Creating save state %d...", index);
+
+    SaveState(NULL, index);
+
+    Log("Save state %d created", index);
+}
+
+void GearboyCore::SaveState(const char* szPath, int index)
+{
+    if (m_pMemory->IsBootromRegistryEnabled())
+    {
+        Log("Save states disabled when running bootrom");
+        return;
+    }
+
+    Log("Saving state...");
+
+    using namespace std;
+
+    size_t size;
+    SaveState(NULL, size);
+
+    u8* buffer = new u8[size];
+    string path = "";
+
+    if (IsValidPointer(szPath))
+    {
+        path += szPath;
+        path += "/";
+        path += m_pCartridge->GetFileName();
+    }
+    else
+    {
+        path = m_pCartridge->GetFilePath();
+    }
+
+    string::size_type i = path.rfind('.', path.length());
+
+    if (i != string::npos) {
+        path.replace(i + 1, 3, "state");
+    }
+
+    std::stringstream sstm;
+
+    if (index < 0)
+        sstm << szPath;
+    else
+        sstm << path << index;
+
+    Log("Save state file: %s", sstm.str().c_str());
+
+    ofstream file(sstm.str().c_str(), ios::out | ios::binary);
+
+    SaveState(file, size);
+
+    SafeDeleteArray(buffer);
+
+    file.close();
+
+    Log("Save state created");
+}
+
+bool GearboyCore::SaveState(u8* buffer, size_t& size)
+{
+    if (m_pMemory->IsBootromRegistryEnabled())
+    {
+        Log("Save states disabled when running bootrom");
+        return false;
+    }
+
+    bool ret = false;
+
+    if (m_pCartridge->IsLoadedROM() && IsValidPointer(m_pMemory->GetCurrentRule()))
+    {
+        using namespace std;
+
+        stringstream stream;
+
+        if (SaveState(stream, size))
+            ret = true;
+
+        if (IsValidPointer(buffer))
+        {
+            Log("Saving state to buffer [%d bytes]...", size);
+            memcpy(buffer, stream.str().c_str(), size);
+            ret = true;
+        }
+    }
+    else
+    {
+        Log("Invalid rom or memory rule.");
+    }
+
+    return ret;
+}
+
+bool GearboyCore::SaveState(std::ostream& stream, size_t& size)
+{
+    if (m_pMemory->IsBootromRegistryEnabled())
+    {
+        Log("Save states disabled when running bootrom");
+        return false;
+    }
+
+    if (m_pCartridge->IsLoadedROM() && IsValidPointer(m_pMemory->GetCurrentRule()))
+    {
+        Log("Gathering save state data...");
+
+        using namespace std;
+
+        m_pMemory->SaveState(stream);
+        m_pProcessor->SaveState(stream);
+        m_pVideo->SaveState(stream);
+        m_pInput->SaveState(stream);
+        m_pAudio->SaveState(stream);
+        m_pMemory->GetCurrentRule()->SaveState(stream);
+
+        size = static_cast<size_t>(stream.tellp());
+
+        size += (sizeof(u32) * 2);
+
+        u32 header_magic = SAVESTATE_MAGIC;
+        u32 header_size = static_cast<u32>(size);
+
+        stream.write(reinterpret_cast<const char*> (&header_magic), sizeof(header_magic));
+        stream.write(reinterpret_cast<const char*> (&header_size), sizeof(header_size));
+
+        Log("Save state size: %d", static_cast<size_t>(stream.tellp()));
+
+        return true;
+    }
+
+    Log("Invalid rom or memory rule.");
+
+    return false;
+}
+
+void GearboyCore::LoadState(int index)
+{
+    if (m_pMemory->IsBootromRegistryEnabled())
+    {
+        Log("Save states disabled when running bootrom");
+        return;
+    }
+
+    Log("Loading save state %d...", index);
+
+    LoadState(NULL, index);
+
+    Log("State %d file loaded", index);
+}
+
+void GearboyCore::LoadState(const char* szPath, int index)
+{
+    if (m_pMemory->IsBootromRegistryEnabled())
+    {
+        Log("Save states disabled when running bootrom");
+        return;
+    }
+
+    Log("Loading save state...");
+
+    using namespace std;
+
+    string sav_path = "";
+
+    if (IsValidPointer(szPath))
+    {
+        sav_path += szPath;
+        sav_path += "/";
+        sav_path += m_pCartridge->GetFileName();
+    }
+    else
+    {
+        sav_path = m_pCartridge->GetFilePath();
+    }
+
+    string rom_path = sav_path;
+
+    string::size_type i = sav_path.rfind('.', sav_path.length());
+
+    if (i != string::npos) {
+        sav_path.replace(i + 1, 3, "state");
+    }
+
+    std::stringstream sstm;
+
+    if (index < 0)
+        sstm << szPath;
+    else
+        sstm << sav_path << index;
+
+    Log("Opening save file: %s", sstm.str().c_str());
+
+    ifstream file;
+
+    file.open(sstm.str().c_str(), ios::in | ios::binary);
+
+    if (!file.fail())
+    {
+        if (LoadState(file))
+        {
+            Log("Save state loaded");
+        }
+    }
+    else
+    {
+        Log("Save state file doesn't exist");
+    }
+
+    file.close();
+}
+
+bool GearboyCore::LoadState(const u8* buffer, size_t size)
+{
+    if (m_pMemory->IsBootromRegistryEnabled())
+    {
+        Log("Save states disabled when running bootrom");
+        return false;
+    }
+
+    if (m_pCartridge->IsLoadedROM() && IsValidPointer(m_pMemory->GetCurrentRule()) && (size > 0) && IsValidPointer(buffer))
+    {
+        Log("Gathering load state data [%d bytes]...", size);
+
+        using namespace std;
+
+        stringstream stream;
+
+        stream.write(reinterpret_cast<const char*> (buffer), size);
+
+        return LoadState(stream);
+    }
+
+    Log("Invalid rom or memory rule.");
+
+    return false;
+}
+
+bool GearboyCore::LoadState(std::istream& stream)
+{
+    if (m_pMemory->IsBootromRegistryEnabled())
+    {
+        Log("Save states disabled when running bootrom");
+        return false;
+    }
+
+    if (m_pCartridge->IsLoadedROM() && IsValidPointer(m_pMemory->GetCurrentRule()))
+    {
+        using namespace std;
+
+        u32 header_magic = 0;
+        u32 header_size = 0;
+
+        stream.seekg(0, ios::end);
+        size_t size = static_cast<size_t>(stream.tellg());
+
+        Log("Load state stream size: %d", size);
+
+        stream.seekg(size - (2 * sizeof(u32)), ios::beg);
+        stream.read(reinterpret_cast<char*> (&header_magic), sizeof(header_magic));
+        stream.read(reinterpret_cast<char*> (&header_size), sizeof(header_size));
+        stream.seekg(0, ios::beg);
+
+        Log("Load state magic: 0x%08x", header_magic);
+        Log("Load state size: %d", header_size);
+
+        if ((header_size == size) && (header_magic == SAVESTATE_MAGIC))
+        {
+            Log("Loading state...");
+
+            m_pMemory->LoadState(stream);
+            m_pProcessor->LoadState(stream);
+            m_pVideo->LoadState(stream);
+            m_pInput->LoadState(stream);
+            m_pAudio->LoadState(stream);
+            m_pMemory->GetCurrentRule()->LoadState(stream);
+
+            return true;
+        }
+        else
+        {
+            Log("Invalid save state size");
+        }
+    }
+    else
+    {
+        Log("Invalid rom or memory rule");
+    }
+
+    return false;
+}
+
+void GearboyCore::SetCheat(const char* szCheat)
+{
+    std::string s = szCheat;
+    if ((s.length() == 7) || (s.length() == 11))
+    {
+        m_pCartridge->SetGameGenieCheat(szCheat);
+        if (m_pCartridge->IsLoadedROM())
+            m_pMemory->LoadBank0and1FromROM(m_pCartridge->GetTheROM());
+    }
+    else
+    {
+        m_pProcessor->SetGameSharkCheat(szCheat);
+    }
+}
+
+void GearboyCore::ClearCheats()
+{
+    m_pCartridge->ClearGameGenieCheats();
+    m_pProcessor->ClearGameSharkCheats();
+    if (m_pCartridge->IsLoadedROM())
+        m_pMemory->LoadBank0and1FromROM(m_pCartridge->GetTheROM());
+}
+
+void GearboyCore::SetRamModificationCallback(RamChangedCallback callback)
+{
+    m_pRamChangedCallback = callback;
+}
+
+bool GearboyCore::IsCGB()
+{
+    return m_bCGB;
+}
+
+bool GearboyCore::IsGBA()
+{
+    return m_bGBA;
+}
+
+void GearboyCore::InitDMGPalette()
+{
+    GB_Color color[4];
+
+    color[0].red = 0x87;
+    color[0].green = 0x96;
+    color[0].blue = 0x03;
+
+    color[1].red = 0x4d;
+    color[1].green = 0x6b;
+    color[1].blue = 0x03;
+
+    color[2].red = 0x2b;
+    color[2].green = 0x55;
+    color[2].blue = 0x03;
+
+    color[3].red = 0x14;
+    color[3].green = 0x44;
+    color[3].blue = 0x03;
+
+    SetDMGPalette(color[0], color[1], color[2], color[3]);
+}
+
+void GearboyCore::InitMemoryRules()
+{
+    m_pIORegistersMemoryRule = new IORegistersMemoryRule(m_pProcessor, m_pMemory, m_pVideo, m_pInput, m_pAudio);
+
+    m_pCommonMemoryRule = new CommonMemoryRule(m_pMemory);
+
+    m_pRomOnlyMemoryRule = new RomOnlyMemoryRule(m_pProcessor, m_pMemory,
+            m_pVideo, m_pInput, m_pCartridge, m_pAudio);
+
+    m_pMBC1MemoryRule = new MBC1MemoryRule(m_pProcessor, m_pMemory,
+            m_pVideo, m_pInput, m_pCartridge, m_pAudio);
+
+    m_pMultiMBC1MemoryRule = new MultiMBC1MemoryRule(m_pProcessor, m_pMemory,
+            m_pVideo, m_pInput, m_pCartridge, m_pAudio);
+
+    m_pMBC2MemoryRule = new MBC2MemoryRule(m_pProcessor, m_pMemory,
+            m_pVideo, m_pInput, m_pCartridge, m_pAudio);
+
+    m_pMBC3MemoryRule = new MBC3MemoryRule(m_pProcessor, m_pMemory,
+            m_pVideo, m_pInput, m_pCartridge, m_pAudio);
+
+    m_pMBC5MemoryRule = new MBC5MemoryRule(m_pProcessor, m_pMemory,
+            m_pVideo, m_pInput, m_pCartridge, m_pAudio);
+
+    m_pMemory->SetCurrentRule(m_pRomOnlyMemoryRule);
+    m_pMemory->SetIORule(m_pIORegistersMemoryRule);
+    m_pMemory->SetCommonRule(m_pCommonMemoryRule);
+}
+
+bool GearboyCore::AddMemoryRules(Cartridge::CartridgeTypes forceType)
+{
+    m_pMemory->SetIORule(m_pIORegistersMemoryRule);
+    m_pMemory->SetCommonRule(m_pCommonMemoryRule);
+
+    Cartridge::CartridgeTypes type = m_pCartridge->GetType();
+
+    bool notSupported = false;
+
+    if (forceType != Cartridge::CartridgeNotSupported)
+        type = forceType;
+
+    switch (type)
+    {
+        case Cartridge::CartridgeNoMBC:
+            m_pMemory->SetCurrentRule(m_pRomOnlyMemoryRule);
+            break;
+        case Cartridge::CartridgeMBC1:
+            m_pMemory->SetCurrentRule(m_pMBC1MemoryRule);
+            break;
+        case Cartridge::CartridgeMBC1Multi:
+            m_pMemory->SetCurrentRule(m_pMultiMBC1MemoryRule);
+            break;
+        case Cartridge::CartridgeMBC2:
+            m_pMemory->SetCurrentRule(m_pMBC2MemoryRule);
+            break;
+        case Cartridge::CartridgeMBC3:
+            m_pMemory->SetCurrentRule(m_pMBC3MemoryRule);
+            break;
+        case Cartridge::CartridgeMBC5:
+            m_pMemory->SetCurrentRule(m_pMBC5MemoryRule);
+            break;
+        case Cartridge::CartridgeNotSupported:
+            notSupported = true;
+            break;
+        default:
+            notSupported = true;
+    }
+
+    if (!notSupported)
+    {
+        m_pMemory->GetCurrentRule()->SetRamChangedCallback(m_pRamChangedCallback);
+    }
+
+    return !notSupported;
+}
+
+void GearboyCore::Reset(bool bCGB, bool bGBA)
+{
+    m_bCGB = bCGB;
+    m_bGBA = bGBA;
+
+    if (m_bGBA && m_bCGB)
+    {
+        Log("Reset: Switching to Game Boy Advance");
+    }
+    else if (m_bCGB)
+    {
+        Log("Reset: Switching to Game Boy Color");
+    }
+    else
+    {
+        Log("Reset: Defaulting to Game Boy DMG");
+    }
+
+    m_pMemory->Reset(m_bCGB);
+    m_pProcessor->Reset(m_bCGB, m_bGBA);
+    m_pVideo->Reset(m_bCGB);
+    m_pAudio->Reset(m_bCGB);
+    m_pInput->Reset();
+    m_pCartridge->UpdateCurrentRTC();
+    m_iRTCUpdateCount = 0;
+
+    m_pCommonMemoryRule->Reset(m_bCGB);
+    m_pRomOnlyMemoryRule->Reset(m_bCGB);
+    m_pMBC1MemoryRule->Reset(m_bCGB);
+    m_pMultiMBC1MemoryRule->Reset(m_bCGB);
+    m_pMBC2MemoryRule->Reset(m_bCGB);
+    m_pMBC3MemoryRule->Reset(m_bCGB);
+    m_pMBC5MemoryRule->Reset(m_bCGB);
+    m_pIORegistersMemoryRule->Reset(m_bCGB);
+
+    m_bPaused = false;
+}
+
+void GearboyCore::RenderDMGFrame(u16* pFrameBuffer) const
+{
+    if (IsValidPointer(pFrameBuffer))
+    {
+        int pixels = GAMEBOY_WIDTH * GAMEBOY_HEIGHT;
+        const u8* pGameboyFrameBuffer = m_pVideo->GetFrameBuffer();
+
+        for (int i = 0; i < pixels; i++)
+        {
+            pFrameBuffer[i] = m_DMGPalette[pGameboyFrameBuffer[i]];
+        }
+    }
+}