Files
wii-ipl/src/scene/memoryCard/iplMemoryCardManager.cpp

460 lines
16 KiB
C++

#define IPL_MEMORY_CARD_MANAGER_CPP
#include "scene/memoryCard/iplMemoryCardManager.h"
#include "utility/iplCharacterCode.h"
#include <revolution/sc.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
struct MemoryCardSortEntry {
u32 fileNo;
u32 flags;
s64 key;
};
extern "C" int compareMemoryCardSortEntries(const void* first, const void* second) {
const MemoryCardSortEntry* a = static_cast<const MemoryCardSortEntry*>(first);
const MemoryCardSortEntry* b = static_cast<const MemoryCardSortEntry*>(second);
s64 bKey = b->key;
s64 aKey = a->key;
if (bKey < aKey) {
return 1;
}
if (aKey < bKey) {
return -1;
}
u32 bIndex = b->fileNo;
u32 aIndex = a->fileNo;
if (aIndex > bIndex) {
return 1;
}
return -(int)(aIndex < bIndex);
}
namespace ipl {
namespace scene {
typedef memorycard::FileInfo CardDirectory[0x7f];
typedef memorycard::IconState CardIcons[0x7f];
void MemoryCardManager::calc() {
memorycard::probeCard();
update_change_cardstate(0);
update_change_cardstate(1);
update_icon_anm();
}
bool MemoryCardManager::isSlotReady(u8 slot) {
memorycard::CardState* states = memorycard::getCardSlotState();
return states[slot].state == 4;
}
bool MemoryCardManager::isSlotNoCard(u8 slot) {
memorycard::CardState* states = memorycard::getCardSlotState();
return states[slot].state == 0;
}
long MemoryCardManager::isSlotWrongDevice(u8 slot) {
memorycard::CardState* states = memorycard::getCardSlotState();
int result = 1;
memorycard::CardState* state = &states[slot];
bool isWrong = true;
bool isUnsupported = true;
bool isUnformatted = true;
bool isInvalid = true;
if (state->state != 5 && state->state != 6) {
isInvalid = false;
}
if (!isInvalid && state->state != 7) {
isUnformatted = false;
}
if (!isUnformatted && state->state != 8) {
isUnsupported = false;
}
if (!isUnsupported && state->state != 9) {
isWrong = false;
}
if (!isWrong && state->state != 10) {
result = 0;
}
return result;
}
void MemoryCardManager::sort_file_array(u8 slot) {
CardDirectory* dirs = reinterpret_cast<CardDirectory*>(memorycard::getCardDirState());
for (long file = 0; file < 0x7f; file++) {
if (dirs[slot][file].fileNo != 0) {
mFile[slot][file].fileNo = file;
mFile[slot][file].sortKey = dirs[slot][file].key;
mFile[slot][file].unk_0x08 = 0;
} else {
mFile[slot][file].fileNo = file;
mFile[slot][file].sortKey = -1 - file;
mFile[slot][file].unk_0x08 = 0;
}
}
qsort(mFile[slot], 0x7f, sizeof(MCFile), compareMemoryCardSortEntries);
}
void MemoryCardManager::sendCardCmdMove(u8 slot, s16 index) {
u32 file = mFile[slot][index].fileNo;
mLastCmd = 2;
if (isDistSlot(slot, NULL)) {
memorycard::sendCardMoveCmd(slot, file);
mLastResult = -0x15;
mLastCmd = 3;
} else {
mLastResult = -0x17;
}
}
void MemoryCardManager::sendCardCmdCopy(u8 slot, s16 index) {
u32 file = mFile[slot][index].fileNo;
if (isDistSlot(slot, NULL)) {
memorycard::sendCardCopyCmd(slot, file);
mLastResult = -0x15;
mLastCmd = 2;
} else {
mLastResult = -0x17;
}
}
void MemoryCardManager::sendCardCmdDelete(u8 slot, s16 index) {
memorycard::sendCardDeleteCmd(slot, mFile[slot][index].fileNo);
mLastResult = -0x15;
mLastCmd = 4;
}
void MemoryCardManager::sendCardCmdFormat(u8 slot) {
memorycard::sendCardFormatCmd(slot);
mLastResult = -0x15;
mLastCmd = 1;
}
bool MemoryCardManager::isDistSlot(u8 slot, long* state) {
u32 other = slot ^ 1;
memorycard::CardState* states = memorycard::getCardSlotState();
if (state != NULL) {
*state = states[other].state;
}
if (states[other].state == 4) {
return true;
}
return false;
}
bool MemoryCardManager::isMoveEnable(u8 slot, u32 index, long* code) {
CardDirectory* dirs = reinterpret_cast<CardDirectory*>(memorycard::getCardDirState());
memorycard::CardState* states = memorycard::getCardSlotState();
u32 file = mFile[slot][index].fileNo;
memorycard::FileInfo* dir = NULL;
long result;
bool enabled = false;
if (isDistSlot(slot, NULL) &&
((dir = &dirs[slot][file])->canMove != 0) &&
states[slot].key == states[slot ^ 1].key &&
states[slot ^ 1].freeBlocks >= dir->size && states[slot ^ 1].unk_0x0E != 0 &&
dir->unk_0x06 == 0) {
result = -0x15;
enabled = true;
} else {
long destinationState;
if (!isDistSlot(slot, &destinationState)) {
if (destinationState == 0) {
result = -0x17;
} else if (destinationState == 5 || destinationState == 7 || destinationState == 9) {
result = -0x16;
} else {
result = -0x1c;
}
} else if ((dir = &dirs[slot][file])->canMove == 0) {
result = -0x1a;
} else if (states[slot].key != states[slot ^ 1].key) {
result = -0x1b;
} else if (states[slot ^ 1].freeBlocks < dir->size || states[slot ^ 1].unk_0x0E == 0) {
result = -0x19;
} else if (dir->unk_0x06 != 0) {
result = -0x18;
}
}
if (code != NULL) {
*code = result;
}
return enabled;
}
bool MemoryCardManager::isCopyEnable(u8 slot, u32 index, long* code) {
CardDirectory* dirs = reinterpret_cast<CardDirectory*>(memorycard::getCardDirState());
memorycard::CardState* states = memorycard::getCardSlotState();
u32 file = mFile[slot][index].fileNo;
memorycard::FileInfo* dir = NULL;
long result;
bool enabled = false;
if (isDistSlot(slot, NULL) &&
((dir = &dirs[slot][file])->canCopy != 0) &&
states[slot].key == states[slot ^ 1].key &&
states[slot ^ 1].freeBlocks >= dir->size && states[slot ^ 1].unk_0x0E != 0 &&
dir->unk_0x06 == 0) {
result = -0x15;
enabled = true;
} else {
long destinationState;
if (!isDistSlot(slot, &destinationState)) {
if (destinationState == 0) {
result = -0x17;
} else if (destinationState == 5 || destinationState == 7 || destinationState == 9) {
result = -0x16;
} else {
result = -0x1c;
}
} else if ((dir = &dirs[slot][file])->canCopy == 0) {
result = -0x1a;
} else if (states[slot].key != states[slot ^ 1].key) {
result = -0x1b;
} else if (states[slot ^ 1].freeBlocks < dir->size || states[slot ^ 1].unk_0x0E == 0) {
result = -0x19;
} else if (dir->unk_0x06 != 0) {
result = -0x18;
}
}
if (code != NULL) {
*code = result;
}
return enabled;
}
bool MemoryCardManager::isIconValidate(u8 slot, s16 index) {
u32 cardSlot = slot;
if (cardSlot > 1 || index < 0 || index >= 0x7f) {
return false;
}
CardDirectory* dirs = reinterpret_cast<CardDirectory*>(memorycard::getCardDirState());
if (mFile[cardSlot][index].fileNo >= 0x7f) {
return false;
}
return dirs[cardSlot][mFile[cardSlot][index].fileNo].fileNo != 0;
}
bool MemoryCardManager::isBannerEnable(u8 slot, s16 index) {
CardIcons* icons = reinterpret_cast<CardIcons*>(memorycard::getIconStateArray());
u32 file = mFile[slot][index].fileNo;
memorycard::IconState* icon = &icons[slot][file];
u8 enabled = icon->bannerEnable;
return enabled != 0;
}
void MemoryCardManager::update_icon_anm() {
CardIcons* icons = reinterpret_cast<CardIcons*>(memorycard::getIconStateArray());
CardDirectory* dirs = reinterpret_cast<CardDirectory*>(memorycard::getCardDirState());
int slot = 0;
do {
int index = 0;
for (int remaining = 0x7f; remaining > 0; remaining--, index++) {
u32 file = mFile[slot][index].fileNo;
if (file < 0x7f && dirs[slot][file].fileNo != 0) {
memorycard::IconState* icon = icons[slot] + file;
s8 delta = icon->anmDelta;
s16 currentFrame = mFileCell[slot][file].iconAnmCounter;
s32 frame = currentFrame + delta;
mFileCell[slot][file].iconAnmCounter = frame;
if ((s16)frame >= icons[slot][file].anmMax) {
if (icon->anmType == 4) {
mFileCell[slot][file].iconAnmCounter = icons[slot][file].anmMax - icon->unk_0x07 - 1;
icon->anmDelta = -1;
} else {
mFileCell[slot][file].iconAnmCounter = 0;
icon->anmDelta = 1;
}
}
if (mFileCell[slot][file].iconAnmCounter < 0) {
if (icon->anmType == 4) {
mFileCell[slot][file].iconAnmCounter = icon->unk_0x06;
} else {
mFileCell[slot][file].iconAnmCounter = 0;
}
icon->anmDelta = 1;
}
}
}
slot++;
} while (slot < 2);
}
void MemoryCardManager::update_file_array(u8 slot) {
memorycard::CardState* states = memorycard::getCardSlotState();
states[slot].changed = 0;
sort_file_array(slot);
long command = mLastCmd;
if ((u32)(command - 1) <= 3) {
if (mLastResult == -0x15) {
mLastResult = memorycard::getCardLastCMDFCmdResult();
}
if (mLastResult == 0) {
switch (mLastCmd) {
case 3:
mpEventHandler->onMemEvent(2, slot);
mLastCmd = 6;
break;
case 2:
mpEventHandler->onMemEvent(1, slot);
mLastCmd = 5;
break;
case 4:
mpEventHandler->onMemEvent(3, slot);
mLastCmd = 7;
break;
case 1:
mpEventHandler->onMemEvent(4, slot);
mLastCmd = 8;
break;
}
}
}
}
void MemCardEventHandler::onMemEvent(long event, u8 slot) {
}
void MemoryCardManager::update_change_cardstate(u8 slot) {
memorycard::CardState* states = memorycard::getCardSlotState();
if (states[slot].changed == 1) {
if (states[slot].state == 4) {
update_file_array(slot);
} else if (states[slot].state == 8 || states[slot].state == 6) {
mpEventHandler->onMemEvent(0, slot);
states[slot].changed = 0;
}
if (mLastResult == 0 && memorycard::getCardLastSendCmd() == 9 &&
slot == memorycard::getCardLastSrcSlot()) {
mpEventHandler->onMemEvent(5, slot);
states[slot].changed = 0;
for (int file = 0; file < 0x7f; file++) {
mFile[slot][file].fileNo = -1;
mFile[slot][file].sortKey = -1;
mFile[slot][file].unk_0x08 = 0;
mFileCell[slot][file].iconAnmCounter = 0;
wmemset(mFileCell[slot][file].comment[0], 0, 0x40);
}
}
}
if (states[slot].state != 4 && states[slot].state != 6 && states[slot].state != 8) {
mpEventHandler->onMemEvent(6, slot);
}
}
GXTexObj* MemoryCardManager::create_icon(u8 slot, s16 index) {
memorycard::IconState (*icons)[0x7f] = reinterpret_cast<memorycard::IconState(*)[0x7f]>(memorycard::getIconStateArray());
int total = 0;
s16 frame = 0;
u32 file = mFile[slot][index].fileNo;
do {
total += ((icons[slot][file].anmFrameBits >> (frame++ << 1)) & 3) * 4;
if (mFileCell[slot][file].iconAnmCounter <= total) {
break;
}
} while (frame <= 8);
return _create_icon(slot, file, frame - 1);
}
GXTexObj* MemoryCardManager::create_icon(u8 slot, s16 index, long start) {
memorycard::getIconStateArray();
u32 file = mFile[slot][index].fileNo;
return _create_icon(slot, file, 0);
}
GXTexObj* MemoryCardManager::_create_icon(u8 slot, s16 file, long start) {
CardDirectory* dirs = reinterpret_cast<CardDirectory*>(memorycard::getCardDirState());
if (dirs[slot][file].fileNo == 0) {
return NULL;
}
CardIcons* icons = reinterpret_cast<CardIcons*>(memorycard::getIconStateArray());
memorycard::IconState* icon = &icons[slot][file];
if ((int)icon->iconFmt[start] == GX_TF_RGB5A3) {
GXInitTexObj(&mFileCell[slot][file].icon, reinterpret_cast<u8*>(icon) + icon->iconOffset[start], 0x20, 0x20, GX_TF_RGB5A3, GX_CLAMP, GX_CLAMP, GX_FALSE);
GXLoadTexObj(&mFileCell[slot][file].icon, GX_TEXMAP0);
} else if ((int)icon->iconFmt[start] == GX_TF_C8) {
GXInitTexObjCI(&mFileCell[slot][file].icon, reinterpret_cast<u8*>(icon) + icon->iconOffset[start], 0x20, 0x20, GX_TF_C8, GX_CLAMP, GX_CLAMP, GX_FALSE, GX_TLUT0);
GXInitTlutObj(&mFileCell[slot][file].iconTlut, reinterpret_cast<u8*>(icon) + icons[slot][file].iconTlutOffset, GX_TL_RGB5A3, 0x100);
GXLoadTlut(&mFileCell[slot][file].iconTlut, GX_TLUT0);
GXLoadTexObj(&mFileCell[slot][file].icon, GX_TEXMAP0);
} else {
return NULL;
}
return &mFileCell[slot][file].icon;
}
const wchar_t* MemoryCardManager::getComment(u8 slot, s16 index, int which) {
u32 file = mFile[slot][index].fileNo;
wmemset(mFileCell[slot][file].comment[which], 0, 0x40);
char comment[33] = {0};
const char* comments = memorycard::getIconComment(slot, file);
memcpy(comment, comments + which * 0x20, 0x20);
const u8* encoded = reinterpret_cast<const u8*>(comment);
char* tail = comment + 0x1f;
char* end = tail;
for (; *end == ' ' || *end == '\n' || *end == 0;) {
*tail = 0;
end--;
tail--;
}
if (SCGetLanguage() == 0) {
utility::CharacterCode::shiftJISToUTF16(mFileCell[slot][file].comment[which], encoded, 0x20);
for (int pos = 0x1f;
mFileCell[slot][file].comment[which][pos] == 0x20 ||
mFileCell[slot][file].comment[which][pos] == 0x3000 ||
mFileCell[slot][file].comment[which][pos] == 10 ||
mFileCell[slot][file].comment[which][pos] == 0;) {
mFileCell[slot][file].comment[which][pos--] = 0;
}
} else {
utility::CharacterCode::ANSIToUTF16(mFileCell[slot][file].comment[which], encoded, 0x20);
}
bool found = false;
int count = 0;
while (mFileCell[slot][file].comment[which][count] != 0 && count < 0x20) {
if (found) {
mFileCell[slot][file].comment[which][count] = 0;
} else if (mFileCell[slot][file].comment[which][count] == 10 || mFileCell[slot][file].comment[which][count] == 0xd0a) {
mFileCell[slot][file].comment[which][count] = 0;
found = true;
}
count++;
}
return mFileCell[slot][file].comment[which];
}
GXTexObj* MemoryCardManager::create_banner(u8 slot, s16 index) {
CardDirectory* dirs = reinterpret_cast<CardDirectory*>(memorycard::getCardDirState());
CardIcons* icons = reinterpret_cast<CardIcons*>(memorycard::getIconStateArray());
u32 file = mFile[slot][index].fileNo;
if (dirs[slot][file].fileNo == 0 || !icons[slot][file].bannerEnable) {
return NULL;
}
memorycard::IconState* icon = &icons[slot][file];
if ((int)icon->bannerType == GX_TF_RGB5A3) {
GXInitTexObj(&mFileCell[slot][file].banner, reinterpret_cast<u8*>(icon) + icon->bannerOffset,
0x60, 0x20, GX_TF_RGB5A3, GX_CLAMP, GX_CLAMP, GX_FALSE);
GXLoadTexObj(&mFileCell[slot][file].banner, GX_TEXMAP0);
} else if ((int)icon->bannerType == GX_TF_C8) {
GXInitTexObjCI(&mFileCell[slot][file].banner, reinterpret_cast<u8*>(icon) + icon->bannerOffset,
0x60, 0x20, GX_TF_C8, GX_CLAMP, GX_CLAMP, GX_FALSE, GX_TLUT0);
GXInitTlutObj(&mFileCell[slot][file].bannerTlut, reinterpret_cast<u8*>(icon) + icons[slot][file].bannerTlutOffset, GX_TL_RGB5A3, 0x100);
GXLoadTlut(&mFileCell[slot][file].bannerTlut, GX_TLUT0);
GXLoadTexObj(&mFileCell[slot][file].banner, GX_TEXMAP0);
}
return &mFileCell[slot][file].banner;
}
u16 MemoryCardManager::getBlocks(u8 slot, s16 index) {
CardDirectory* dirs = reinterpret_cast<CardDirectory*>(memorycard::getCardDirState());
return dirs[slot][mFile[slot][index].fileNo].size;
}
u16 MemoryCardManager::getFreeBlocks(u8 slot) {
memorycard::CardState* states = memorycard::getCardSlotState();
return states[slot].freeBlocks;
}
}
}