metaforce/Runtime/MP1/CMemoryCardDriver.cpp

#include "CMemoryCardDriver.hpp"
#include "MP1.hpp"
#include "CCRC32.hpp"

namespace urde
{
namespace MP1
{

static const char* SaveFileNames[] =
{
    "MetroidPrime A",
    "MetroidPrime B"
};

using ECardResult = CMemoryCardSys::ECardResult;
using EMemoryCardPort = CMemoryCardSys::EMemoryCardPort;

ECardResult CMemoryCardDriver::SFileInfo::Open()
{
    //CARDOpen(GetFileCardPort(), x14_name.data(), &x0_fileInfo);
    return ECardResult::CARD_RESULT_READY;
}

ECardResult CMemoryCardDriver::SFileInfo::Close()
{
    auto backup = GetFileCardPort();
    ECardResult result = ECardResult::CARD_RESULT_READY;
    //result = CARDClose(backup);
    x0_fileInfo.x0_cardPort = backup;
    return result;
}

CMemoryCardSys::ECardResult CMemoryCardDriver::SFileInfo::StartRead()
{
    CMemoryCardSys::CARDStat stat = {};
    ECardResult result = CMemoryCardSys::GetStatus(GetFileCardPort(), GetFileNo(), stat);
    if (result != ECardResult::CARD_RESULT_READY)
        return result;

    u32 length = stat.GetFileLength();
    x34_saveData.clear();
    x24_saveFileData.resize(length);
    //return CARDReadAsync(&x0_fileInfo, x24_saveFileData.data(), length, 0, 0);
    return ECardResult::CARD_RESULT_READY;
}

ECardResult CMemoryCardDriver::SFileInfo::TryFileRead()
{
    ECardResult res = CMemoryCardSys::GetResultCode(GetFileCardPort());
    if (res == ECardResult::CARD_RESULT_READY)
        res = FileRead();
    return res;
}

ECardResult CMemoryCardDriver::SFileInfo::FileRead()
{
    x34_saveData.clear();
    u32 existingCrc = hecl::SBig(*reinterpret_cast<u32*>(x24_saveFileData.data()));
    u32 newCrc = CCRC32::Calculate(x24_saveFileData.data() + 4, x24_saveFileData.size() - 4);
    if (existingCrc == newCrc)
    {
        u32 saveDataOff;
        ECardResult result = GetSaveDataOffset(saveDataOff);
        if (result != ECardResult::CARD_RESULT_READY)
        {
            x24_saveFileData.clear();
            return result;
        }

        u32 saveSize = x24_saveFileData.size() - saveDataOff;
        x34_saveData.resize(saveSize);
        memmove(x34_saveData.data(), x24_saveFileData.data() + saveDataOff, saveSize);
        x24_saveFileData.clear();
        return ECardResult::CARD_RESULT_READY;
    }
    else
    {
        x24_saveFileData.clear();
        return ECardResult::CARD_RESULT_CRC_MISMATCH;
    }
}

ECardResult CMemoryCardDriver::SFileInfo::GetSaveDataOffset(u32& offOut)
{
    CMemoryCardSys::CARDStat stat = {};
    ECardResult result = CMemoryCardSys::GetStatus(GetFileCardPort(), GetFileNo(), stat);
    if (result != ECardResult::CARD_RESULT_READY)
    {
        offOut = -1;
        return result;
    }

    offOut = 4;
    offOut += 64;
    switch (stat.GetBannerFormat())
    {
    case 1:
        offOut += 3584;
        break;
    case 2:
        offOut += 6144;
        break;
    default: break;
    }

    int idx = 0;
    bool paletteIcon = false;
    while (u32 fmt = stat.GetIconFormat(idx))
    {
        if (fmt == 1)
        {
            paletteIcon = true;
            offOut += 1024;
        }
        else
            offOut += 2048;
        ++idx;
    }

    if (paletteIcon)
        offOut += 512;

    return ECardResult::CARD_RESULT_READY;
}

CMemoryCardDriver::SGameFileSlot::SGameFileSlot()
{
    InitializeFromGameState();
}

CMemoryCardDriver::SGameFileSlot::SGameFileSlot(CMemoryInStream& in)
{
    in.readBytesToBuf(x0_saveBuffer, 940);
    x944_fileInfo = CGameState::LoadGameFileState(x0_saveBuffer);
}

void CMemoryCardDriver::SGameFileSlot::InitializeFromGameState()
{
    CBitStreamWriter w(x0_saveBuffer, 940);
    g_GameState->PutTo(w);
    x944_fileInfo = CGameState::LoadGameFileState(x0_saveBuffer);
}

CMemoryCardDriver::SFileInfo::SFileInfo(EMemoryCardPort port,
                                        const std::string& name)
: x14_name(name)
{
    x0_fileInfo.x0_cardPort = port;
}

CMemoryCardDriver::CMemoryCardDriver(EMemoryCardPort cardPort, ResId saveBanner,
                                     ResId saveIcon0, ResId saveIcon1, bool importPersistent)
: x0_cardPort(cardPort), x4_saveBanner(saveBanner),
  x8_saveIcon0(saveIcon0), xc_saveIcon1(saveIcon1), x19d_doImportPersistent(importPersistent)
{
    x100_mcFileInfos.reserve(2);
    x100_mcFileInfos.emplace_back(0, SFileInfo(x0_cardPort, SaveFileNames[0]));
    x100_mcFileInfos.emplace_back(0, SFileInfo(x0_cardPort, SaveFileNames[1]));
}

void CMemoryCardDriver::FinishedLoading()
{
    x10_state = EState::TwentyFive;
    x14_error = EError::Zero;
    FinishedLoading2();
}

void CMemoryCardDriver::FinishedLoading2()
{
    auto result = CMemoryCardSys::CardProbe(x0_cardPort);
    switch (result.x0_error)
    {
    case ECardResult::CARD_RESULT_READY:
        if (result.x8_sectorSize != 0x2000)
        {
            x10_state = EState::Twelve;
            x14_error = EError::Seven;
            return;
        }
        x10_state = EState::CardNeedsMount;
        MountCard();
        break;
    case ECardResult::CARD_RESULT_BUSY:
        break;
    case ECardResult::CARD_RESULT_WRONGDEVICE:
        x10_state = EState::Twelve;
        x14_error = EError::Four;
        break;
    default:
        NoCardFound();
        break;
    }
}

void CMemoryCardDriver::NoCardFound()
{
    x10_state = EState::NoCard;
    static_cast<CMain*>(g_Main)->SetCardInserted(false);
}

void CMemoryCardDriver::MountCard()
{
    x10_state = EState::CardMount;
    x14_error = EError::Zero;
    ECardResult result = CMemoryCardSys::MountCard(x0_cardPort);
    if (result != ECardResult::CARD_RESULT_READY)
        Case26(result);
}

void CMemoryCardDriver::CheckCard()
{
    ECardResult result = CMemoryCardSys::CheckCard(x0_cardPort);
    if (result != ECardResult::CARD_RESULT_READY)
        Case27(result);
}

CGameState::GameFileStateInfo* CMemoryCardDriver::GetGameFileStateInfo(int idx)
{
    SGameFileSlot* slot = xe4_fileSlots[idx].get();
    if (!slot)
        return nullptr;
    return &slot->x944_fileInfo;
}

CMemoryCardDriver::SSaveHeader CMemoryCardDriver::LoadSaveHeader(CMemoryInStream& in)
{
    SSaveHeader ret;
    ret.x0_version = in.readUint32Big();
    for (int i=0 ; i<3 ; ++i)
        ret.x4_savePresent[i] = in.readBool();
    return ret;
}

std::unique_ptr<CMemoryCardDriver::SGameFileSlot> CMemoryCardDriver::LoadSaveFile(CMemoryInStream& in)
{
    return std::make_unique<CMemoryCardDriver::SGameFileSlot>(in);
}

void CMemoryCardDriver::ReadFinished()
{
    CMemoryCardSys::CARDStat stat = {};
    SFileInfo& fileInfo = x100_mcFileInfos[x194_fileIdx].second;
    if (CMemoryCardSys::GetStatus(x0_cardPort, fileInfo.GetFileNo(), stat) != ECardResult::CARD_RESULT_READY)
    {
        NoCardFound();
        return;
    }

    x20_fileTime = stat.GetTime();
    CMemoryInStream r(fileInfo.x34_saveData.data(), 3004);
    SSaveHeader header = LoadSaveHeader(r);
    r.readBytesToBuf(x30_systemData, 174);

    for (int i=0 ; i<3 ; ++i)
        xe4_fileSlots[i] = LoadSaveFile(r);

    if (x19d_doImportPersistent)
        ImportPersistentOptions();
}

void CMemoryCardDriver::ImportPersistentOptions()
{
    CBitStreamReader r(x30_systemData, 174);
    CPersistentOptions opts(r);
    g_GameState->ImportPersistentOptions(opts);
}

void CMemoryCardDriver::ExportPersistentOptions()
{
    CBitStreamReader r(x30_systemData, 174);
    CPersistentOptions opts(r);
    g_GameState->ExportPersistentOptions(opts);
    CBitStreamWriter w(x30_systemData, 174);
    opts.PutTo(w);
}

void CMemoryCardDriver::DeleteFile()
{
    x14_error = EError::Zero;
    x10_state = EState::Thirty;
    SFileInfo& fileInfo = x100_mcFileInfos[!bool(x194_fileIdx)].second;
    ECardResult result = CMemoryCardSys::FastDeleteFile(x0_cardPort, fileInfo.GetFileNo());
    if (result != ECardResult::CARD_RESULT_READY)
        Case30(result);
}

void CMemoryCardDriver::CheckCardCapacity()
{
    if (x18_cardFreeBytes < 0x2000 || !x1c_cardFreeFiles)
        x14_error = EError::Six;
}

void CMemoryCardDriver::Case26(ECardResult result)
{
    switch (result)
    {
    case ECardResult::CARD_RESULT_READY:
        x10_state = EState::CardMountDone;
        CheckCard();
        break;
    case ECardResult::CARD_RESULT_BROKEN:
        x10_state = EState::CardMountDone;
        x14_error = EError::One;
        CheckCard();
        break;
    default:
        HandleCardError(result, EState::Thirteen);
        break;
    }
}

void CMemoryCardDriver::Case27(ECardResult result)
{
    switch (result)
    {
    case ECardResult::CARD_RESULT_READY:
        x10_state = EState::SelectCardFile;
        if (!GetCardFreeBytes())
            return;
        if (CMemoryCardSys::GetSerialNo(x0_cardPort, x28_cardSerial) == ECardResult::CARD_RESULT_READY)
            return;
        NoCardFound();
        break;
    case ECardResult::CARD_RESULT_BROKEN:
        x10_state = EState::Fourteen;
        x14_error = EError::One;
        break;
    default:
        HandleCardError(result, EState::Fourteen);
    }
}

void CMemoryCardDriver::Case28(ECardResult result)
{
    if (result == ECardResult::CARD_RESULT_READY)
    {
        x100_mcFileInfos[x194_fileIdx].first = 1;
        if (x100_mcFileInfos[!bool(x194_fileIdx)].first == 3)
        {
            x10_state = EState::Seventeen;
            GoTo28();
        }
        else
        {
            x10_state = EState::SelectCardFile;
            if (!GetCardFreeBytes())
                return;
            GoTo17();
        }
    }
    else
        HandleCardError(result, EState::Fifteen);
}

void CMemoryCardDriver::Case29(ECardResult result)
{
    if (result == ECardResult::CARD_RESULT_READY)
    {
        auto& fileInfo = x100_mcFileInfos[x194_fileIdx];
        ECardResult readRes = fileInfo.second.TryFileRead();
        if (fileInfo.second.Close() != ECardResult::CARD_RESULT_READY)
        {
            NoCardFound();
            return;
        }

        u32 fileIdx = !bool(x194_fileIdx);
        if (readRes == ECardResult::CARD_RESULT_READY)
        {
            x10_state = EState::Ready;
            ReadFinished();
            u32 fileId = x100_mcFileInfos[fileIdx].first;
            if (fileId == 1)
                CheckCardCapacity();
            else
                DeleteFile();
            return;
        }

        if (readRes == ECardResult::CARD_RESULT_CRC_MISMATCH)
        {
            x100_mcFileInfos[x194_fileIdx].first = 3;
            if (x100_mcFileInfos[fileIdx].first == 2)
            {
                x10_state = EState::SelectCardFile;
                GoTo17();
            }
            else
            {
                x10_state = EState::Seventeen;
                x14_error = EError::Nine;
            }
        }
    }
    else
        HandleCardError(result, EState::Seventeen);
}

void CMemoryCardDriver::Case30(ECardResult result)
{
    if (result == ECardResult::CARD_RESULT_READY)
    {
        x10_state = EState::Ready;
        if (GetCardFreeBytes())
            CheckCardCapacity();
    }
    else
        HandleCardError(result, EState::Sixteen);
}

void CMemoryCardDriver::Case31(ECardResult result)
{
    if (result == ECardResult::CARD_RESULT_READY)
    {
        x10_state = EState::WillWrite;
        GoTo32();
    }
    else
        HandleCardError(result, EState::Eighteen);
}

void CMemoryCardDriver::Case32(ECardResult result)
{
    if (result == ECardResult::CARD_RESULT_READY)
    {
        ECardResult xferResult = x198_fileInfo->PumpCardTransfer();
        if (xferResult == ECardResult::CARD_RESULT_READY)
        {
            x10_state = EState::Ready;
            if (x198_fileInfo->Close() == ECardResult::CARD_RESULT_READY)
                return;
            NoCardFound();
            return;
        }
        if (xferResult == ECardResult::CARD_RESULT_BUSY)
            return;
        if (xferResult == ECardResult::CARD_RESULT_IOERROR)
        {
            x10_state = EState::Nineteen;
            x14_error = EError::Three;
            return;
        }
        NoCardFound();
    }
    else
        HandleCardError(result, EState::Nineteen);
}

void CMemoryCardDriver::Case33(ECardResult result)
{
    if (result == ECardResult::CARD_RESULT_READY)
    {
        x10_state = EState::Nine;
        GoTo34();
    }
    else
        HandleCardError(result, EState::Twenty);
}

void CMemoryCardDriver::Case34(ECardResult result)
{
    if (result == ECardResult::CARD_RESULT_READY)
    {
        ECardResult xferResult = x198_fileInfo->PumpCardTransfer();
        if (xferResult == ECardResult::CARD_RESULT_READY)
        {
            x10_state = EState::Ten;
            if (x198_fileInfo->Close() != ECardResult::CARD_RESULT_READY)
            {
                NoCardFound();
                return;
            }
            GoTo35();
            return;
        }
        if (xferResult == ECardResult::CARD_RESULT_BUSY)
            return;
        if (xferResult == ECardResult::CARD_RESULT_IOERROR)
        {
            x10_state = EState::TwentyOne;
            x14_error = EError::Three;
            return;
        }
        NoCardFound();
    }
    else
        HandleCardError(result, EState::TwentyOne);
}

void CMemoryCardDriver::Case35(ECardResult result)
{
    if (result == ECardResult::CARD_RESULT_READY)
    {
        x10_state = EState::Eleven;
        if (GetCardFreeBytes())
            GoTo36();
    }
    else
        HandleCardError(result, EState::TwentyTwo);
}

void CMemoryCardDriver::Case36(ECardResult result)
{
    if (result == ECardResult::CARD_RESULT_READY)
    {
        x10_state = EState::RuntimeBackup;
        WriteBackupBuf();
    }
    else
        HandleCardError(result, EState::TwentyThree);
}

void CMemoryCardDriver::Case37(ECardResult result)
{
    if (result == ECardResult::CARD_RESULT_READY)
        x10_state = EState::CardFormatted;
    else if (result == ECardResult::CARD_RESULT_BROKEN)
    {
        x10_state = EState::CardFormatBroken;
        x14_error = EError::Three;
    }
    else
        HandleCardError(result, EState::CardFormatBroken);
}

void CMemoryCardDriver::GoTo17()
{
    x14_error = EError::Zero;
    for (std::pair<u32, SFileInfo>& info : x100_mcFileInfos)
    {
        if (info.first == 0)
        {
            ECardResult result = info.second.Open();
            if (result == ECardResult::CARD_RESULT_NOFILE)
            {
                info.first = 1;
                continue;
            }
            else if (result == ECardResult::CARD_RESULT_READY)
            {
                CMemoryCardSys::CARDStat stat = {};
                if (CMemoryCardSys::GetStatus(x0_cardPort, info.second.GetFileNo(), stat) ==
                        ECardResult::CARD_RESULT_READY)
                {
                    u32 comment = stat.GetCommentAddr();
                    if (comment == -1)
                        info.first = 3;
                    else
                        info.first = 2;
                }
                else
                {
                    NoCardFound();
                    return;
                }
                if (info.second.Close() == ECardResult::CARD_RESULT_NOCARD)
                {
                    NoCardFound();
                    return;
                }
            }
            else
            {
                NoCardFound();
                return;
            }
        }
    }

    if (x100_mcFileInfos[0].first == 2)
    {
        if (x100_mcFileInfos[1].first == 2)
        {
            CMemoryCardSys::CARDStat stat = {};
            if (CMemoryCardSys::GetStatus(x0_cardPort, x100_mcFileInfos[0].second.GetFileNo(), stat) ==
                    ECardResult::CARD_RESULT_READY)
            {
                u32 timeA = stat.GetTime();
                if (CMemoryCardSys::GetStatus(x0_cardPort, x100_mcFileInfos[1].second.GetFileNo(), stat) ==
                        ECardResult::CARD_RESULT_READY)
                {
                    u32 timeB = stat.GetTime();
                    if (timeA > timeB)
                        x194_fileIdx = 0;
                    else
                        x194_fileIdx = 1;
                    GoTo29();
                    return;
                }
                NoCardFound();
                return;
            }
            NoCardFound();
            return;
        }
        x194_fileIdx = 0;
        GoTo29();
        return;
    }

    if (x100_mcFileInfos[1].first == 2)
    {
        x194_fileIdx = 1;
        GoTo29();
        return;
    }

    if (x100_mcFileInfos[0].first == 3 || x100_mcFileInfos[1].first == 3)
    {
        x10_state = EState::Seventeen;
        x14_error = EError::Nine;
    }
    else
    {
        x10_state = EState::Seventeen;
        x14_error = EError::Eight;
    }
}

void CMemoryCardDriver::GoTo28()
{
    x14_error = EError::Zero;
    x10_state = EState::TwentyEight;
    int idx = 0;
    for (std::pair<u32, SFileInfo>& info : x100_mcFileInfos)
    {
        if (info.first == 3)
        {
            x194_fileIdx = idx;
            ECardResult result = CMemoryCardSys::FastDeleteFile(x0_cardPort, info.second.GetFileNo());
            if (result != ECardResult::CARD_RESULT_READY)
            {
                Case28(result);
                return;
            }
        }
        ++idx;
    }
}

void CMemoryCardDriver::GoTo29()
{
    x14_error = EError::Zero;
    x10_state = EState::TwentyNine;
    ECardResult result = x100_mcFileInfos[x194_fileIdx].second.Open();
    if (result != ECardResult::CARD_RESULT_READY)
    {
        Case29(result);
        return;
    }

    result = x100_mcFileInfos[x194_fileIdx].second.StartRead();
    if (result != ECardResult::CARD_RESULT_READY)
        Case29(result);
}

void CMemoryCardDriver::GoTo31()
{
    x14_error = EError::Zero;
    x10_state = EState::ThirtyOne;
    if (x18_cardFreeBytes < 8192 || x1c_cardFreeFiles < 2)
    {
        x10_state = EState::Eighteen;
        x14_error = EError::Five;
        return;
    }

    x198_fileInfo = std::make_unique<CMemoryCardSys::CCardFileInfo>(x0_cardPort, SaveFileNames[x194_fileIdx]);
    InitializeFileInfo();
    ECardResult result = x198_fileInfo->CreateFile();
    if (result != ECardResult::CARD_RESULT_READY)
        Case31(result);
}

void CMemoryCardDriver::GoTo32()
{
    x14_error = EError::Zero;
    x10_state = EState::ThirtyTwo;
    ECardResult result = x198_fileInfo->Write();
    if (result != ECardResult::CARD_RESULT_READY)
        Case32(result);
}

void CMemoryCardDriver::GoTo33()
{
    x14_error = EError::Zero;
    x10_state = EState::FileBuild;
    ClearFileInfo();
    if (x18_cardFreeBytes < 8192 || !x1c_cardFreeFiles)
    {
        x10_state = EState::Twenty;
        x14_error = EError::Five;
        return;
    }

    x198_fileInfo = std::make_unique<CMemoryCardSys::CCardFileInfo>(x0_cardPort, SaveFileNames[x194_fileIdx]);
    InitializeFileInfo();
    ECardResult result = x198_fileInfo->CreateFile();
    if (result != ECardResult::CARD_RESULT_READY)
        Case33(result);
}

void CMemoryCardDriver::GoTo34()
{
    x14_error = EError::Zero;
    x10_state = EState::FileWrite;
    ECardResult result = x198_fileInfo->Write();
    if (result != ECardResult::CARD_RESULT_READY)
        Case34(result);
}

void CMemoryCardDriver::GoTo35()
{
    x14_error = EError::Zero;
    x10_state = EState::ThirtyFive;
    ECardResult result = CMemoryCardSys::DeleteFile(x0_cardPort,
                                                    SaveFileNames[!bool(x194_fileIdx)]);
    if (result != ECardResult::CARD_RESULT_READY)
        Case35(result);
}

void CMemoryCardDriver::GoTo36()
{
    if (x194_fileIdx == 1)
    {
        x14_error = EError::Zero;
        x10_state = EState::FileRename;
        ECardResult result = CMemoryCardSys::Rename(x0_cardPort,
                                                    SaveFileNames[x194_fileIdx],
                                                    SaveFileNames[!bool(x194_fileIdx)]);
        if (result != ECardResult::CARD_RESULT_READY)
            Case36(result);
    }
    else
    {
        x10_state = EState::RuntimeBackup;
        WriteBackupBuf();
    }
}

void CMemoryCardDriver::GoTo37()
{
    x14_error = EError::Zero;
    x10_state = EState::CardFormat;
    ECardResult result = CMemoryCardSys::FormatCard(x0_cardPort);
    if (result != ECardResult::CARD_RESULT_READY)
        Case37(result);
}

void CMemoryCardDriver::InitializeFileInfo()
{
    ExportPersistentOptions();

    OSCalendarTime time = CBasics::ToCalendarTime(std::chrono::system_clock::now());
    char timeString[32];
    snprintf(timeString, 32, "%02d.%02d.%02d  %02d:%02d",
             time.x10_mon + 1, time.xc_mday, time.x14_year % 100,
             time.x8_hour, time.x4_min);
    std::string comment("Metroid Prime                   ");
    comment += timeString;
    x198_fileInfo->SetComment(comment);

    x198_fileInfo->LockBannerToken(x4_saveBanner, *g_SimplePool);
    x198_fileInfo->LockIconToken(x8_saveIcon0, 2, *g_SimplePool);

    CMemoryOutStream w = x198_fileInfo->BeginMemoryOut(3004);

    SSaveHeader header;
    for (int i=0 ; i<3 ; ++i)
        header.x4_savePresent[i] = xe4_fileSlots[i].operator bool();
    header.DoPut(w);

    w.writeBytes(x30_systemData, 174);

    for (int i=0 ; i<3 ; ++i)
        if (xe4_fileSlots[i])
            xe4_fileSlots[i]->DoPut(w);
}

void CMemoryCardDriver::WriteBackupBuf()
{
    g_GameState->WriteBackupBuf();
    g_GameState->SetCardSerial(x28_cardSerial);
}

bool CMemoryCardDriver::GetCardFreeBytes()
{
    ECardResult result = CMemoryCardSys::GetNumFreeBytes(x0_cardPort,
                                                         x18_cardFreeBytes,
                                                         x1c_cardFreeFiles);
    if (result == ECardResult::CARD_RESULT_READY)
        return true;
    NoCardFound();
    return false;
}

void CMemoryCardDriver::HandleCardError(ECardResult result, EState state)
{
    switch (result)
    {
    case ECardResult::CARD_RESULT_WRONGDEVICE:
        x10_state = state;
        x14_error = EError::Four;
        break;
    case ECardResult::CARD_RESULT_NOCARD:
        NoCardFound();
        break;
    case ECardResult::CARD_RESULT_IOERROR:
        x10_state = state;
        x14_error = EError::Three;
    case ECardResult::CARD_RESULT_ENCODING:
        x10_state = state;
        x14_error = EError::Two;
        break;
    default: break;
    }
}

void CMemoryCardDriver::Update()
{
    CMemoryCardSys::CardProbeResults result = CMemoryCardSys::CardProbe(x0_cardPort);

    if (result.x0_error == ECardResult::CARD_RESULT_NOCARD)
    {
        if (x10_state != EState::NoCard)
            NoCardFound();
        static_cast<CMain*>(g_Main)->SetCardInserted(false);
        return;
    }

    if (x10_state == EState::TwentyFive)
    {
        FinishedLoading2();
        static_cast<CMain*>(g_Main)->SetCardInserted(false);
        return;
    }


    ECardResult resultCode = g_MemoryCardSys->GetResultCode(x0_cardPort);
    bool cardInserted = false;

    if (InCardInsertedRange(x10_state))
    {
        cardInserted = true;

        switch (x10_state)
        {
        case EState::CardMount:
            Case26(resultCode);
            break;
        case EState::TwentySeven:
            Case27(resultCode);
            break;
        case EState::TwentyEight:
            Case28(resultCode);
            break;
        case EState::TwentyNine:
            Case29(resultCode);
            break;
        case EState::Thirty:
            Case30(resultCode);
            break;
        case EState::ThirtyOne:
            Case31(resultCode);
            break;
        case EState::ThirtyTwo:
            Case32(resultCode);
            break;
        case EState::FileBuild:
            Case33(resultCode);
            break;
        case EState::FileWrite:
            Case34(resultCode);
            break;
        case EState::ThirtyFive:
            Case35(resultCode);
            break;
        case EState::FileRename:
            Case36(resultCode);
            break;
        case EState::CardFormat:
            Case37(resultCode);
            break;
        default: break;
        }
    }

    static_cast<CMain*>(g_Main)->SetCardInserted(cardInserted);
}

}
}