pmret/papermario
1
0
Fork 0
mirror of https://github.com/pmret/papermario.git synced 2024-09-18 23:42:35 +02:00
Code Issues Packages Projects Releases Wiki Activity

Shiftability work + splat update (#783)

Browse Source 
* evt bss + shiftability work

* entity BSS

* more BSS

* another follows_vram

* more shift goodz

* git subrepo pull --force tools/splat

subrepo:
  subdir:   "tools/splat"
  merged:   "9af40c5265"
upstream:
  origin:   "https://github.com/ethteck/splat.git"
  branch:   "master"
  commit:   "9af40c5265"
git-subrepo:
  version:  "0.4.3"
  origin:   "https://github.com/ingydotnet/git-subrepo"
  commit:   "2f68596"
This commit is contained in:
Ethan Roseman 2022-09-25 00:21:54 +09:00 committed by GitHub
parent 3706178f3a
commit 87179cdf3f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
60 changed files with 898 additions and 1318 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
include/variables.h
View File

@ -35,18 +35,8 @@ extern s32 gBattleDmaDest;
extern ActionCommandStatus gActionCommandStatus;
extern ScriptList gWorldScriptList;
extern ScriptList gBattleScriptList;
extern ScriptList* gCurrentScriptListPtr;
extern s32 gNumScripts;
extern s32 D_802DAC98;
extern s32 gScriptListCount;
extern s32 gScriptIdList[MAX_SCRIPTS];
extern s32 gScriptIndexList[MAX_SCRIPTS];
extern s32 gMoveScriptTable[][4];
extern EntityList gWorldEntityList;
@ -84,16 +74,6 @@ extern HiddenPanelsData gCurrentHiddenPanels;
extern BackgroundHeader gBackgroundImage;
extern MessagePrintState* gCurrentPrintContext;
extern s32 D_802DB264;
extern MessagePrintState* D_802DB268;
extern s32 SaveBlockTutorialPrinterClosed;
extern s32 SaveBlockResultPrinterClosed;
extern MessagePrintState* SaveBlockTutorialPrinter;
extern MessagePrintState* SaveBlockResultPrinter;
extern Entity* SwitchToLink;
extern s32 CreateEntityVarArgBuffer[4];
extern f32 D_800F7B74;
@ -105,10 +85,6 @@ extern AnimatedMeshList* gCurrentAnimMeshListPtr;
extern PartnerAnimations gPartnerAnimations[12];
extern AnimatedModelList gBattleMeshAnimationList;
extern AnimatedModelList gWorldMeshAnimationList;
extern AnimatedModelList* gCurrentMeshAnimationListPtr;
// Triggers
extern s16 gTriggerCount;
extern TriggerList wTriggerList;
@ -205,15 +181,6 @@ extern Vec3s btl_actorHomePositions[];
extern SaveData gCurrentSaveFile;
extern u32* gMapFlags;
extern s32* gMapVars;
extern u32 gWorldMapVars[MAX_MAPVARS];
extern u32 gBattleMapVars[MAX_MAPVARS];
extern u32 gWorldMapFlags[MAX_MAPFLAGS];
extern u32 gBattleMapFlags[MAX_MAPFLAGS];
extern s32 D_8009A5D0;
extern s32 timeFreezeMode;
extern s32 D_8009A678;
@ -222,7 +189,6 @@ extern u8 D_800779B0;
extern u32 D_80078174;
extern u8 D_800A0963;
extern struct EffectInstance* TriggerBlockVanishEffect;
extern s32 D_802EA310[];
extern s32 Entity_WoodenCrate_RenderShatteredScript[];
@ -256,14 +222,9 @@ extern s32 D_802920C0[];
extern s32 D_802920E8[];
extern s32 D_80292110[];
extern s32 D_8029FBD0;
extern AnimID KoopatrolDisguiseExtraAnims[];
extern AnimID HammerBroDisguiseExtraAnims[];
//various
extern s32 D_802C05CC;
extern s16 gCurrentCamID;
extern HeapNode gSpriteHeapPtr;

20
src/16F740.c
View File

@ -18,16 +18,16 @@ extern s32 D_80281454[];
extern EvtScript D_80284A20[];
extern EvtScript D_80284A30[];
extern s32 D_8029F240;
extern u8 D_8029F244;
extern s32 D_8029F248;
extern s32 D_8029F24C;
extern s32 D_8029F250;
extern s32 D_8029F254;
extern s32 D_8029F258;
extern s32 D_8029F25C;
extern s32 D_8029F260;
extern s32 D_8029F264;
BSS s32 D_8029F240;
BSS u8 D_8029F244;
BSS s32 D_8029F248;
BSS s32 D_8029F24C;
BSS s32 D_8029F250;
BSS s32 D_8029F254;
BSS s32 D_8029F258;
BSS s32 D_8029F25C;
BSS s32 D_8029F260;
BSS s32 D_8029F264;
void btl_merlee_on_start_turn(void) {
BattleStatus* battleStatus = &gBattleStatus;

35
src/16c8e0.c
View File

@ -13,6 +13,23 @@ s16 D_802809F6 = -1;
s16 D_802809F8 = 0;
u16 D_802809FA = 0;
BSS s32 bSavedPartner;
BSS s32 bSavedOverrideFlags;
BSS s32 D_8029DA38[2]; // unused?
BSS s32 D_8029DA40;
BSS s32 D_8029DA44;
BSS s32 D_8029DA48;
BSS s32 D_8029DA4C;
BSS Camera D_8029DA50[ARRAY_COUNT(gCameras)];
BSS f32 D_8029EFB0;
BSS f32 D_8029EFB4;
BSS f32 D_8029EFB8;
BSS s32 D_8029EFBC;
BSS s32 D_8029EFC0[10];
BSS s32 D_8029EFE8[10];
BSS s32 D_8029F010[10];
BSS s16 D_8029F038[0x100];
extern HudScript HES_HPDigit0;
extern HudScript HES_HPDigit1;
extern HudScript HES_HPDigit2;
@ -78,24 +95,6 @@ EvtScript BtlBringPartnerOut = {
EVT_END
};
extern s32 bSavedPartner;
extern s32 bSavedOverrideFlags;
extern s32 D_8029DA40;
extern s32 D_8029DA44;
extern s32 D_8029DA48;
extern s32 D_8029DA4C;
extern Camera D_8029DA50[ARRAY_COUNT(gCameras)];
extern f32 D_8029EFB0;
extern f32 D_8029EFB4;
extern f32 D_8029EFB8;
extern s32 D_8029EFBC;
extern s32 D_8029EFC0[10];
extern s32 D_8029EFE8[10];
extern s32 D_8029F010[10];
extern s16 D_8029F038[0x100];
extern HudScript HES_HPBar;
extern HudScript HES_Item_SmallStarPoint;
extern HudScript HES_Item_StarPoint;

22
src/17D6A0.c
View File

@ -1115,19 +1115,19 @@ s32 bActorMessages[] = {
};
PopupMessage* D_802838F8 = NULL;
// BSS
extern s16 D_80159E7E;
extern PopupMessage popupMessages[32];
extern s16 D_8029F640;
extern s16 D_8029F642;
extern s16 D_8029F644;
extern s16 D_8029F646;
extern s16 D_8029F648;
extern s16 D_8029F64A;
extern s16 D_8029F64C;
extern s16 D_8029F64E;
extern s16 D_8029F650;
// BSS
BSS PopupMessage popupMessages[32];
BSS s16 D_8029F640;
BSS s16 D_8029F642;
BSS s16 D_8029F644;
BSS s16 D_8029F646;
BSS s16 D_8029F648;
BSS s16 D_8029F64A;
BSS s16 D_8029F64C;
BSS s16 D_8029F64E;
BSS s16 D_8029F650;
extern HudScript HES_AButton;
extern HudScript HES_AButtonDown;

16
src/181810.c
View File

@ -1,13 +1,15 @@
#include "common.h"
#include "battle/battle.h"
extern MessagePrintState* gSpeakingActorPrintCtx;
extern MessagePrintState* D_8029FA64;
extern s32 gSpeakingActorPrintIsDone; // unk_08
extern s32 gSpeakingActorTalkAnim;
extern s32 gSpeakingActorIdleAnim;
extern Actor* gSpeakingActor;
extern ActorPart* gSpeakingActorPart;
BSS char D_8029FA660[0x400]; // unused?
BSS MessagePrintState* gSpeakingActorPrintCtx;
BSS MessagePrintState* D_8029FA64;
BSS s32 gSpeakingActorPrintIsDone; // unk_08
BSS s32 gSpeakingActorTalkAnim;
BSS s32 gSpeakingActorIdleAnim;
BSS Actor* gSpeakingActor;
BSS ActorPart* gSpeakingActorPart;
ApiStatus ActorSpeak(Evt* script, s32 isInitialCall) {
Bytecode* args = script->ptrReadPos;

65
src/18C790.c
View File

@ -15,39 +15,40 @@ extern HudScript* D_802841C0[3][10];
extern HudScript* D_80284238[3][10];
extern EvtScript D_802842B0;
extern EvtScript D_80284880;
extern EvtScript PlayerScriptDispatcher;
extern HudScript HES_ProjectorBeam;
extern s32 D_8029FA88;
extern s32 D_8029FAA8;
extern s32 D_8029FAC4;
extern s32 D_8029FB4C;
extern s32 D_8029FB50;
extern s32 D_8029FB54;
extern s32 D_8029FB6C;
extern s32 D_8029FB70;
extern s32 D_8029FB74;
extern Evt* D_8029FB7C;
extern s32 D_8029FB80;
extern s32 D_8029FB84;
BSS s32 D_8029FA80[4];
BSS s32 D_8029FA90[3][7];
BSS s32 D_8029FAE4; // unused?
BSS s32 D_8029FAE8;
BSS s32 D_8029FAEC[23]; // unused?
BSS s32 D_8029FB48;
BSS s32 D_8029FB4C;
BSS s32 D_8029FB50;
BSS s32 D_8029FB54;
BSS s32 D_8029FB58[2]; // unused?
BSS s32 D_8029FB60[3];
BSS s32 D_8029FB6C;
BSS s32 D_8029FB70;
BSS s32 D_8029FB74;
BSS s32 D_8029FB78;
BSS Evt* D_8029FB7C;
BSS s32 D_8029FB80;
BSS s32 D_8029FB84;
BSS s32 D_8029FB88;
BSS s32 D_8029FB8C;
extern HudScript D_802A9F34;
extern HudScript D_802A9F5C;
extern HudScript D_802A9F84;
extern HudScript D_802A9F0C;
extern HudScript D_802A9FAC;
extern HudScript D_802AA320;
extern HudScript D_802AA694;
extern HudScript D_802AAA08;
extern HudScript D_802AAA30;
extern HudScript HES_ProjectorBeam;
extern EvtScript PlayerScriptDispatcher;
extern s32 D_8029FA80[4];
extern s32 D_8029FA90[3][7];
extern s32 D_8029FAE8;
extern s32 D_8029FB48;
extern s32 D_8029FB60[];
extern s32 D_8029FB78;
extern s32 D_8029FB88;
extern s32 D_8029FB8C;
extern HudScript D_802A9F34;
extern HudScript D_802A9F5C;
extern HudScript D_802A9F84;
extern HudScript D_802A9FAC;
s32* virtual_entity_get_by_index(s32);
@ -421,7 +422,7 @@ void btl_state_update_celebration(void) {
}
if (is_ability_active(ABILITY_FP_PLUS)) {
id = D_8029FAA8;
id = D_8029FA90[0][6];
hud_element_set_script(id, gItemHudScripts[gItemTable[248].hudElemID].enabled);
hud_element_clear_flags(id, HUD_ELEMENT_FLAGS_DISABLED);
hud_element_set_scale(id, 0.5f);
@ -490,7 +491,7 @@ void btl_state_update_celebration(void) {
}
if (is_ability_active(ABILITY_HP_PLUS)) {
id = D_8029FAC4;
id = D_8029FA90[1][6];
hud_element_set_script(id, gItemHudScripts[gItemTable[231].hudElemID].enabled);
hud_element_clear_flags(id, HUD_ELEMENT_FLAGS_DISABLED);
hud_element_set_scale(id, 0.5f);
@ -601,7 +602,7 @@ void btl_state_update_celebration(void) {
hud_element_set_render_pos(id, x, y);
}
id = D_8029FA88;
id = D_8029FA80[2];
hud_element_get_render_pos(id, &x, &y);
x += 20;
hud_element_set_render_pos(id, x, y);
@ -722,7 +723,7 @@ void btl_state_update_celebration(void) {
hud_element_set_flags(D_8029FA80[3], HUD_ELEMENT_FLAGS_DISABLED);
break;
case 2:
hud_element_set_flags(D_8029FA88, HUD_ELEMENT_FLAGS_DISABLED);
hud_element_set_flags(D_8029FA80[2], HUD_ELEMENT_FLAGS_DISABLED);
break;
}
} else {
@ -735,7 +736,7 @@ void btl_state_update_celebration(void) {
hud_element_clear_flags(D_8029FA80[3], HUD_ELEMENT_FLAGS_DISABLED);
break;
case 2:
hud_element_clear_flags(D_8029FA88, HUD_ELEMENT_FLAGS_DISABLED);
hud_element_clear_flags(D_8029FA80[2], HUD_ELEMENT_FLAGS_DISABLED);
break;
}
}

18
src/18F340.c
View File

@ -5,15 +5,15 @@
extern HudScript HES_Happy;
extern HudScript HES_HPDrain;
extern s32 D_8029FB90;
extern f32 D_8029FB94;
extern EffectInstance* BattleMerleeOrbEffect;
extern EffectInstance* BattleMerleeWaveEffect;
extern s32 D_8029FBA0;
extern s16 D_8029FBA4;
extern s32 D_8029FBA8;
extern s32 D_8029FBAC;
extern s32 D_8029FBB0[];
BSS s32 D_8029FB90;
BSS f32 D_8029FB94;
BSS EffectInstance* BattleMerleeOrbEffect;
BSS EffectInstance* BattleMerleeWaveEffect;
BSS s32 D_8029FBA0;
BSS s16 D_8029FBA4;
BSS s32 D_8029FBA8;
BSS s32 D_8029FBAC;
BSS s32 D_8029FBB0[3];
void func_80260A60(void) {
BattleStatus* battleStatus = &gBattleStatus;

6
src/196AA0.c
View File

@ -26,7 +26,11 @@
// TODO: move to src/battle/action_cmd.c
extern void* actionCommandDmaTable[23];
extern s32 D_8029FBC0;
BSS s32 D_8029FBC0;
BSS s32 D_8029FBC4[3]; // unused?
BSS s32 D_8029FBD0;
BSS s8 D_8029FBD4;
void action_command_jump_draw_hud_elements(void);
void action_command_hammer_draw_hud_elements(void);

245
src/415D90.c
View File

@ -252,114 +252,133 @@ s32 D_802AB738[] = {
MSG_Menus_Party_Bow, MSG_Menus_Party_Goombaria, MSG_Menus_Party_Twink, MSG_Menus_Party_Peach, 0x00000000
};
extern s32 D_802ACC60;
extern s32 D_802ACC64;
extern s32 D_802ACC68;
extern s32 D_802ACC6C;
extern s32 D_802ACC70[];
extern s8 D_802AD000;
extern s8 D_802AD001;
extern s8 D_802AD002;
extern s8 D_802AD003;
extern s8 D_802AD004;
extern s16 D_802AD006;
extern s16 D_802AD008;
extern s16 D_802AD00A;
extern s32 D_802AD010[];
extern s32 D_802AD028[];
extern s32 D_802AD040;
extern s32 D_802AD044;
extern s32 D_802AD048;
extern s32 D_802AD04C;
extern s32 D_802AD05C;
extern s32 D_802AD050;
extern s32 D_802AD054;
extern s32 D_802AD058;
extern s32 D_802AD060;
extern s32 D_802AD064;
extern s8 D_802AD068;
extern s8 D_802AD069;
extern s8 D_802AD06A;
extern s8 D_802AD06B;
extern f32 D_802AD06C;
extern f32 D_802AD070;
extern HudScript* main_battle_menu_JumpHudScripts[];
extern s32 battle_menu_messageIDs[];
extern s32 main_menu_numOptions;
extern s32 D_802AD0A8;
extern s32 D_802AD0B0;
extern s8 D_802AD0B3;
extern s32 battle_menu_submenuIDs[];
extern s32 battle_menu_isEnabled[];
extern s32 battle_menu_isMessageDisabled[];
extern s32 D_802AD100;
extern s32 D_802AD104;
extern s8 battle_menu_moveState;
extern s8 battle_menu_moveCursorPos;
extern s8 D_802AD10A;
extern s8 D_802AD10B;
extern s8 battle_menu_moveScrollLine;
extern s8 D_802AD10D;
extern s8 D_802AD10E;
extern s8 D_802AD10F;
extern s16 battle_menu_moveScrollOffset;
extern s16 D_802AD112;
extern s16 battle_menu_moveTextColor;
extern s16 battle_menu_moveTextOpacity;
extern s32 battle_menu_moveCursorIcon;
extern s32 battle_menu_moveUpArrowIcon;
extern s32 battle_menu_moveDownArrowIcon;
extern s32 battle_menu_moveOptionIconIDs[24];
extern s32 battle_menu_moveTitleIcon;
extern s32 battle_menu_moveOptionCostUnitIconIDs[24];
extern s16 battle_menu_moveX;
extern s16 battle_menu_moveY;
extern s32 battle_menu_moveOptionIndexMap[24];
extern s32 D_802AD258;
extern HudScript* battle_menu_moveOptionIconScripts[];
extern s32 battle_menu_moveOptionNames[];
extern s32 battle_menu_moveOptionDisplayCosts[];
extern s32 battle_menu_moveOptionDisplayCostReductions[];
extern s32 battle_menu_moveOptionDisplayCostReductionColors[];
extern s32 battle_menu_moveOptionBPCosts[];
extern s32 battle_menu_hasSpiritsMenu;
extern s32 battle_menu_moveOptionCount;
extern s32 D_802AD4A8;
extern s32 battle_menu_moveOptionsEnabled[];
extern s32 battle_menu_moveOptionDescriptions[24];
extern s8 battle_menu_moveOptionSortPriorities[];
extern s8 battle_menu_moveOptionCantUseTypes[];
extern s32 battle_menu_moveOptionActive;
extern s8 D_802AD604;
extern s8 D_802AD605;
extern s8 D_802AD606;
extern s8 D_802AD607;
extern s8 D_802AD608;
extern s8 D_802AD609;
extern s8 D_802AD60A;
extern s8 D_802AD60B;
extern s16 D_802AD60C;
extern s16 D_802AD60E;
extern s16 D_802AD610;
extern s16 D_802AD612;
extern s8 D_802AD614;
extern s32 D_802AD618;
extern s32 D_802AD61C;
extern s32 D_802AD620;
extern s32 D_802AD624;
extern s32 D_802AD628[];
extern s16 D_802AD63C;
extern s16 D_802AD63E;
extern HudScript* D_802AD640[];
extern s32 D_802AD658[]; // msg IDs
extern s32 D_802AD66C;
extern u8 D_802AD66F;
extern s8 D_802AD673;
extern s32 D_802AD678[];
extern s32 D_802AD690[];
extern s32 D_802AD6A8[];
extern s32 D_802AD6C0[];
extern s32 D_802AD6D4;
BSS s32 D_802ACC60;
BSS s32 D_802ACC64;
BSS s32 D_802ACC68;
BSS s32 D_802ACC6C;
BSS s32 D_802ACC70[24];
BSS s32 D_802ACCD0;
BSS s32 D_802ACCD4[0xC5]; // unused?
BSS s32 D_802ACFE8;
BSS s32 D_802ACFEC;
BSS s32 D_802ACFF0;
BSS s32 D_802ACFF4;
BSS s32 D_802ACFF8;
BSS s8 D_802ACFFC;
BSS s8 D_802ACFFD;
BSS s16 D_802ACFFE; // unused?
BSS s8 D_802AD000;
BSS s8 D_802AD001;
BSS s8 D_802AD002;
BSS s8 D_802AD003;
BSS s8 D_802AD004;
BSS s16 D_802AD006;
BSS s16 D_802AD008;
BSS s16 D_802AD00A;
BSS s16 D_802AD00C; // unused?
BSS s32 D_802AD010[6];
BSS s32 D_802AD028[6];
BSS s32 D_802AD040;
BSS s32 D_802AD044;
BSS s32 D_802AD048;
BSS s32 D_802AD04C;
BSS s32 D_802AD050;
BSS s32 D_802AD054;
BSS s32 D_802AD058;
BSS s32 D_802AD05C;
BSS s32 D_802AD060;
BSS s32 D_802AD064;
BSS s8 D_802AD068;
BSS s8 D_802AD069;
BSS s8 D_802AD06A;
BSS s8 D_802AD06B;
BSS f32 D_802AD06C;
BSS f32 D_802AD070;
BSS s32 D_802AD074; // unused?
BSS HudScript* main_battle_menu_JumpHudScripts[6];
BSS s32 battle_menu_messageIDs[6];
BSS s32 D_802AD0A8;
BSS s32 main_menu_numOptions;
BSS s32 D_802AD0B0;
BSS s32 D_802AD0B4; // unused?
BSS s32 battle_menu_submenuIDs[6];
BSS s32 battle_menu_isEnabled[6];
BSS s32 battle_menu_isMessageDisabled[6];
BSS s32 D_802AD100;
BSS s32 D_802AD104;
BSS s8 battle_menu_moveState;
BSS s8 battle_menu_moveCursorPos;
BSS s8 D_802AD10A;
BSS s8 D_802AD10B;
BSS s8 battle_menu_moveScrollLine;
BSS s8 D_802AD10D;
BSS s8 D_802AD10E;
BSS s8 D_802AD10F;
BSS s16 battle_menu_moveScrollOffset;
BSS s16 D_802AD112;
BSS s16 battle_menu_moveTextColor;
BSS s16 battle_menu_moveTextOpacity;
BSS s32 battle_menu_moveCursorIcon;
BSS s32 battle_menu_moveUpArrowIcon;
BSS s32 battle_menu_moveDownArrowIcon;
BSS s32 D_802AD124; // unused?
BSS s32 battle_menu_moveOptionIconIDs[24];
BSS s32 battle_menu_moveTitleIcon;
BSS s32 D_802AD18C; // unused?
BSS s32 battle_menu_moveOptionCostUnitIconIDs[24];
BSS s16 battle_menu_moveX;
BSS s16 battle_menu_moveY;
BSS s32 D_802AD1F4; // unused?
BSS s32 battle_menu_moveOptionIndexMap[24];
BSS s32 D_802AD258;
BSS s32 D_802AD25C; // unused?
BSS HudScript* battle_menu_moveOptionIconScripts[24];
BSS s32 battle_menu_moveOptionNames[24];
BSS s32 battle_menu_moveOptionDisplayCosts[24];
BSS s32 battle_menu_moveOptionDisplayCostReductions[24];
BSS s32 battle_menu_moveOptionDisplayCostReductionColors[24];
BSS s32 battle_menu_moveOptionBPCosts[24];
BSS s32 battle_menu_hasSpiritsMenu;
BSS s32 battle_menu_moveOptionCount;
BSS s32 D_802AD4A8;
BSS s32 D_802AD4AC; // unused?
BSS s32 battle_menu_moveIndices[24];
BSS s32 battle_menu_moveOptionsEnabled[24];
BSS s32 battle_menu_moveOptionDescriptions[24];
BSS s8 battle_menu_moveOptionSortPriorities[24];
BSS s8 battle_menu_moveOptionCantUseTypes[24];
BSS s32 battle_menu_moveOptionActive;
BSS s8 D_802AD604;
BSS s8 D_802AD605;
BSS s8 D_802AD606;
BSS s8 D_802AD607;
BSS s8 D_802AD608;
BSS s8 D_802AD609;
BSS s8 D_802AD60A;
BSS s8 D_802AD60B;
BSS s16 D_802AD60C;
BSS s16 D_802AD60E;
BSS s16 D_802AD610;
BSS s16 D_802AD612;
BSS s8 D_802AD614;
BSS s32 D_802AD618;
BSS s32 D_802AD61C;
BSS s32 D_802AD620;
BSS s32 D_802AD624;
BSS s32 D_802AD628[5];
BSS s16 D_802AD63C;
BSS s16 D_802AD63E;
BSS HudScript* D_802AD640[6];
BSS s32 D_802AD658[5]; // msg IDs
BSS s32 D_802AD66C;
BSS char D_802AD670[3];
BSS s8 D_802AD673;
BSS s32 D_802AD674; // unused?
BSS s32 D_802AD678[6];
BSS s32 D_802AD690[6];
BSS s32 D_802AD6A8[6];
BSS s32 D_802AD6C0[5];
BSS s32 D_802AD6D4;
void func_802A3C98(s32 x, s32 y);
void func_802A43DC(s32 arg0, s32 x, s32 y);
@ -437,10 +456,10 @@ s32 func_802A11B0(void) {
D_802AD064 = 173;
D_802AD070 = 0.3f;
D_802AD004 = 0;
D_802AD06B = D_802AD0B3;
D_802AD069 = -D_802AD0B3;
D_802AD06B = D_802AD0B0;
D_802AD069 = -D_802AD0B0;
D_802AD06A = main_menu_numOptions - 1;
D_802AD06A -= D_802AD0B3;
D_802AD06A -= D_802AD0B0;
for (i = 0; i < main_menu_numOptions; i++) {
D_802AD010[i] = id = hud_element_create(main_battle_menu_JumpHudScripts[i]);
@ -1803,7 +1822,7 @@ s32 func_802A4A54(void) {
}
if (D_802AD605 < 0) {
D_802AD605 = D_802AD66F - 1;
D_802AD605 = D_802AD66C - 1;
}
if (D_802AD66C - 1 < D_802AD605) {
D_802AD605 = 0;
@ -2374,7 +2393,7 @@ void btl_state_update_peach_menu(void) {
}
if (temp_s0_2 != 0) {
set_animation(0, 0, 0xA0002);
battleStatus->currentSubmenu = D_802AD0BB[temp_s0_2 - 1];
battleStatus->currentSubmenu = battle_menu_submenuIDs[temp_s0_2 - 1];
func_802A1030();
D_802ACC60 = 8;
D_802ACC6C = 4;

1
src/actor_api.c
View File

@ -2,6 +2,7 @@
#include "effects.h"
#include "battle/battle.h"
extern s32 D_8029FBD0;
extern s8 D_8029FBD4;
s32 count_targets(Actor* actor, s32 targetHomeIndex, s32 targetSelectionFlags) {

56
src/battle_cam.c
View File

@ -2,34 +2,34 @@
#include "script_api/battle.h"
#define LERP(a, b, alpha) ((a) * (alpha) + (b) * (1.0f-(alpha)))
// battle cam
extern f32 BattleCam_PosX;
extern f32 BattleCam_PosY;
extern f32 BattleCam_PosZ;
extern s16 BattleCam_TargetActor;
extern s16 BattleCam_TargetActorPart;
extern s16 BattleCam_BoomLength;
extern s16 BattleCam_BoomYaw;
extern s16 BattleCam_BoomPitch;
extern s16 BattleCam_BoomZOffset;
extern f32 D_8029F288;
extern f32 BattleCam_InitialBoomLength;
extern f32 BattleCam_InitialBoomYaw;
extern f32 BattleCam_InitialBoomPitch;
extern f32 BattleCam_InitialBoomZOffset;
extern s8 BattleCam_DoneMoving;
extern s16 BattleCam_MoveTimeLeft;
extern s16 BattleCam_MoveTimeTotal;
extern s8 BattleCam_ModeY;
extern s8 BattleCam_ModeX;
extern s8 BattleCam_SetImmediately;
extern s8 BattleCam_UseLinearInterp;
extern s8 D_8029F2A6;
extern s8 D_8029F2A7;
extern f32 BattleCam_InitialPosX;
extern f32 BattleCam_InitialPosY;
extern f32 BattleCam_InitialPosZ;
extern EvtScript* BattleCam_ControlScript;
static f32 BattleCam_PosX;
static f32 BattleCam_PosY;
static f32 BattleCam_PosZ;
static s16 BattleCam_TargetActor;
static s16 BattleCam_TargetActorPart;
static s16 BattleCam_BoomLength;
static s16 BattleCam_BoomYaw;
static s16 BattleCam_BoomPitch;
static s16 BattleCam_BoomZOffset;
static f32 D_8029F288;
static f32 BattleCam_InitialBoomLength;
static f32 BattleCam_InitialBoomYaw;
static f32 BattleCam_InitialBoomPitch;
static f32 BattleCam_InitialBoomZOffset;
static s8 BattleCam_DoneMoving;
static s16 BattleCam_MoveTimeLeft;
static s16 BattleCam_MoveTimeTotal;
static s8 BattleCam_ModeY;
static s8 BattleCam_ModeX;
static s8 BattleCam_SetImmediately;
static s8 BattleCam_UseLinearInterp;
static s8 D_8029F2A6;
static s8 D_8029F2A7;
static f32 BattleCam_InitialPosX;
static f32 BattleCam_InitialPosY;
static f32 BattleCam_InitialPosZ;
static EvtScript* BattleCam_ControlScript;
s8 BattleCam_IsFrozen = FALSE;
s32 BattleCam_CurrentPresetID = -1;

4
src/entity/HeartBlock.c
View File

@ -3,8 +3,6 @@
#include "ld_addrs.h"
#include "entity.h"
extern u32 HeartBlockPrinterClosed;
extern EntityModelScript Entity_HeartBlockContent_RenderScriptIdle;
extern EntityModelScript Entity_HeartBlockContent_RenderScriptAfterHit;
extern EntityModelScript Entity_HeartBlockContent_RenderScriptHit;
@ -16,6 +14,8 @@ extern Gfx Entity_HeartBlockContent_RenderHeartSleeping[];
extern Gfx Entity_HeartBlockContent_RenderHeartAwake[];
extern Gfx Entity_HeartBlockContent_RenderHeartHappy[];
BSS u32 HeartBlockPrinterClosed;
f32 entity_HeartBlockContent_get_previous_yaw(HeartBlockContentData* data, s32 lagTime) {
s32 bufIdx = data->yawBufferPos - lagTime;
if (bufIdx < 0) {

2
src/entity/ItemBlock.c
View File

@ -18,6 +18,8 @@ extern EntityBlueprint Entity_HitGroundedYellowBlock;
extern EntityBlueprint Entity_HitFloatingYellowBlock;
extern EntityBlueprint Entity_HitRedBlock;
BSS EffectInstance* TriggerBlockVanishEffect;
f32 player_get_camera_facing_angle(void);
void entity_inactive_block_hit_init(Entity*);
void entity_inactive_block_hit_anim(Entity*);

6
src/entity/SaveBlock.c
View File

@ -11,6 +11,11 @@ extern Gfx Entity_SaveBlock_RenderNone[];
extern s32 Entity_SaveBlock_ScriptResume[];
BSS s32 SaveBlockTutorialPrinterClosed;
BSS s32 SaveBlockResultPrinterClosed;
BSS MessagePrintState* SaveBlockTutorialPrinter;
BSS MessagePrintState* SaveBlockResultPrinter;
void entity_SaveBlock_setupGfx(s32 index) {
Gfx* gfxPos = gMasterGfxPos;
Entity* entity = get_entity_by_index(index);
@ -149,6 +154,7 @@ EntityScript Entity_SaveBlock_Script = {
es_Restart
es_End
};
EntityScript Entity_SaveBlock_ScriptResume = {
es_Call(entity_SaveBlock_resume_game)
es_SetCallback(NULL, 2)

2
src/entity/Switch.c
View File

@ -10,6 +10,8 @@ extern Gfx Entity_RedSwitch_Render[];
extern Gfx Entity_BlueSwitch_Render[];
extern Gfx Entity_GreenStompSwitch_Render[];
BSS Entity* SwitchToLink;
void entity_GreenStompSwitch_idle(Entity* entity) {
PlayerStatus* playerStatus = &gPlayerStatus;
SwitchData* data = entity->dataBuf.swtch;

4
src/evt/demo_api.c
View File

@ -6,6 +6,10 @@ u8 D_802D9D71 = 0xFE;
u8 D_802D9D72 = 0x00;
u8 D_802D9D73 = 0xFF;
extern s32 D_802DBB60;
extern s32 D_802DBB64; // unused?
extern s32 D_802DBB68;
INCLUDE_ASM(ApiStatus, "evt/demo_api", SetSpriteShading, Evt* script, s32 isInitialCall);
ApiStatus EnableSpriteShading(Evt* script, s32 isInitialCall) {

8
src/evt/evt.c
View File

@ -1,5 +1,10 @@
#include "common.h"
extern u32* gMapFlags;
extern s32* gMapVars;
extern char evtDebugPrintBuffer[0x100];
Bytecode* evt_find_label(Evt* script, s32 arg1);
Bytecode* evt_skip_if(Evt* script);
Bytecode* evt_skip_else(Evt* script);
@ -7,9 +12,6 @@ Bytecode* evt_goto_end_case(Evt* script);
Bytecode* evt_goto_next_case(Evt* script);
Bytecode* evt_goto_end_loop(Evt* script);
// BSS
extern char evtDebugPrintBuffer[];
f32 evt_fixed_var_to_float(Bytecode scriptVar) {
if (scriptVar <= EVT_FIXED_CUTOFF) {
return EVT_FIXED_TO_FLOAT(scriptVar);

10
src/evt/fa4c0_len_3bf0.c
View File

@ -3,12 +3,14 @@
#include "hud_element.h"
#include "world/partners.h"
ApiStatus PollMusicEvents(Evt* script, s32 isInitialCall);
AuResult bgm_set_track_volumes(s32 playerIndex, s16 trackVolSet);
static ApiStatus PollMusicEvents(Evt* script, s32 isInitialCall);
extern MusicEvent* MusicEventList;
extern s32 D_802DB7D4; // unused?
extern Evt* RunningMusicEvents[10];
extern s32 RunningMusicEventIDs[10];
extern s32 D_802DB828[2]; // unused?
extern PopupMenu D_802DB830;
s32 MusicEventPollCount = 0;
@ -19,14 +21,14 @@ static EvtScript EVS_MusicEventMonitor = {
EVT_END
};
static s32 PollMusicEvents(Evt* script, s32 isInitialCall) {
ApiStatus PollMusicEvents(Evt* script, s32 isInitialCall) {
MusicEventTrigger* list;
s32 musicEventID, scriptSelector;
u32 count;
s32 i;
bgm_poll_music_events(&list, &count);
for (i = 0; i < count; i++, list++) {
MusicEvent* cur = MusicEventList;
musicEventID = (*list & 0xFF0000) >> 0x10;
@ -107,7 +109,7 @@ ApiStatus FadeInMusic(Evt* script, s32 isInitialCall) {
s16 fadeStartVolume = evt_get_variable(script, *args++);
s16 fadeEndVolume = evt_get_variable(script, *args++);
if (func_8014A964(musicPlayer, songID, variation, fadeTime, fadeStartVolume, fadeEndVolume)) {
if (func_8014A964(musicPlayer, songID, variation, fadeTime, fadeStartVolume, fadeEndVolume)) {
return ApiStatus_DONE2;
} else {
return ApiStatus_BLOCK;

4
src/evt/model_api.c
View File

@ -1,5 +1,9 @@
#include "model.h"
extern AnimatedModelList gBattleMeshAnimationList;
extern AnimatedModelList gWorldMeshAnimationList;
extern AnimatedModelList* gCurrentMeshAnimationListPtr;
void update_animated_models(void) {
s32 i;

5
src/evt/msg_api.c
View File

@ -2,6 +2,11 @@
extern s32 D_802DAE50;
extern s32 D_802DAE54;
extern s32 D_802DAE58[2]; // unused?
extern char D_802DAE60[0x400]; // unused?
extern MessagePrintState* gCurrentPrintContext;
extern s32 D_802DB264;
extern MessagePrintState* D_802DB268;
ApiStatus _show_message(Evt* script, s32 isInitialCall, s32 arg2);

6
src/evt/player_api.c
View File

@ -2,13 +2,15 @@
#include "npc.h"
#include "sprite.h"
Npc* playerNpc = (Npc*) 0x802DB270; // TODO: raw ptr, shiftability
extern Npc playerNpcData;
extern u16 D_802DB5B0;
extern s32 D_802DB5B4[3]; // unused
extern VirtualEntityList D_802DB5C0;
extern VirtualEntityList D_802DB6C0;
extern VirtualEntityList* D_802DB7C0;
Npc* playerNpc = &playerNpcData;
void virtual_entity_list_render_world(void);
void virtual_entity_list_render_UI(void);

77
src/evt/script_list.c
View File

@ -1,9 +1,86 @@
#include "common.h"
#include "hud_element.h"
s32 gStaticScriptCounter = 1;
s32 gIsUpdatingScripts = 0;
f32 gGlobalTimeSpace = 1.0f;
// script_list
BSS u32* gMapFlags;
BSS s32* gMapVars;
BSS s32 gNumScripts;
BSS s32 D_802DA48C; // unused?
BSS ScriptList gWorldScriptList;
BSS ScriptList gBattleScriptList;
BSS ScriptList* gCurrentScriptListPtr;
BSS s32 D_802DA894; // unused?
BSS s32 gScriptIndexList[MAX_SCRIPTS];
BSS s32 gScriptIdList[MAX_SCRIPTS];
BSS s32 gScriptListCount;
BSS s32 D_802DAC9C; // unused?
// evt
BSS char evtDebugPrintBuffer[0x100];
// map_api
BSS struct LavaReset* gLavaResetList;
BSS s32 D_802DADA4;
BSS s32 D_802DADA8[2]; // unused?
// model_api
BSS AnimatedModelList gBattleMeshAnimationList;
BSS AnimatedModelList gWorldMeshAnimationList;
BSS AnimatedModelList* gCurrentMeshAnimationListPtr;
BSS s32 D_802DAE34[3]; // unused?
// npc_api
BSS s32 wExtraPartnerID;
BSS s32 wExtraPartnerNpcID;
BSS s32 D_802DAE4C[2]; // unused?
// msg_api
BSS s32 D_802DAE50;
BSS s32 D_802DAE54;
BSS s32 D_802DAE58[2]; // unused?
BSS char D_802DAE60[0x400]; // unused?
BSS MessagePrintState* gCurrentPrintContext;
BSS s32 D_802DB264;
BSS MessagePrintState* D_802DB268;
BSS s32 D_802DB26C; // unused?
// player_api
BSS Npc playerNpcData;
BSS u16 D_802DB5B0;
BSS s32 D_802DB5B4[3]; // unused
BSS VirtualEntityList D_802DB5C0;
BSS VirtualEntityList D_802DB6C0;
BSS VirtualEntityList* D_802DB7C0;
BSS s32 D_802DB7C4[3]; // unused
// fa4c0_len_3bf0
BSS MusicEvent* MusicEventList;
BSS s32 D_802DB7D4; // unused?
BSS Evt* RunningMusicEvents[10];
BSS s32 RunningMusicEventIDs[10];
BSS s32 D_802DB828[2]; // unused?
BSS PopupMenu D_802DB830;
// demo_api
BSS s32 D_802DBB60;
BSS s32 D_802DBB64; // unused?
BSS s32 D_802DBB68;
BSS s32 D_802DB8B6C; // unused?
BSS char D_802DBB70[0x100];
// why is this at the end? com section vs bss?
BSS u32 gWorldMapFlags[MAX_MAPFLAGS];
BSS s32 DoorModelsSwingCW[3];
BSS PushBlockGrid* D_802DBC88[8];
BSS u32 gWorldMapVars[MAX_MAPVARS];
BSS u32 gBattleMapVars[MAX_MAPVARS];
BSS s32 DoorModelsSwingCCW[3];
BSS u32 gBattleMapFlags[MAX_MAPFLAGS];
void sort_scripts(void) {
s32 temp_a0;
s32 temp_a1;

12
src/world/action/misc.c
View File

@ -2,6 +2,8 @@
#include "world/actions.h"
#include "world/partner/goombario.h"
BSS f32 D_802B6770_E27C80;
s32 action_update_ride(void) {
PartnerActionStatus* partnerActionStatus = &gPartnerActionStatus;
PlayerStatus* playerStatus = &gPlayerStatus;
@ -19,7 +21,7 @@ s32 action_update_ride(void) {
playerStatus->pitch = 0.0f;
}
if (playerStatus->animFlags & PA_FLAGS_400000) {
if (playerStatus->animFlags & PA_FLAGS_400000) {
if (partnerActionStatus->actingPartner == PARTNER_LAKILESTER) {
return func_802BD100_317020(oldFlags);
}
@ -33,8 +35,6 @@ s32 action_update_ride(void) {
#endif
}
extern f32 D_802B6770_E27C80;
void action_update_state_23(void) {
PlayerStatus* playerStatus = &gPlayerStatus;
f32 hitDirZ;
@ -80,7 +80,7 @@ void action_update_state_23(void) {
miscTempVariable = sinTheta * miscTempVariable;
sin_cos_rad(DEG_TO_RAD(D_802B6770_E27C80), &sinTheta, &cosTheta);
playerXOffset = sinTheta * miscTempVariable;
playerZOffset = cosTheta * miscTempVariable;
@ -91,7 +91,7 @@ void action_update_state_23(void) {
}
playerXOffset = playerOffsetTempVar;
}
if (fabs(playerZOffset) < 0.1) {
playerOffsetTempVar = 0.1f;
if (playerZOffset < 0.0f) {
@ -99,7 +99,7 @@ void action_update_state_23(void) {
}
playerZOffset = playerOffsetTempVar;
}
playerStatus->position.x += playerXOffset;
playerStatus->position.z -= playerZOffset;
outX = playerStatus->position.x;

16
src/world/action/slide.c
View File

@ -1,13 +1,13 @@
#include "common.h"
static f32 SlideAcceleration;
static f32 MaxSlideAccel;
static f32 MaxSlideVelocity;
static f32 SlideLaunchSpeed;
static f32 D_802B6790;
static f32 D_802B6794;
static f32 D_802B6798;
static s32 D_802B679C;
BSS f32 SlideAcceleration;
BSS f32 MaxSlideAccel;
BSS f32 MaxSlideVelocity;
BSS f32 SlideLaunchSpeed;
BSS f32 D_802B6790;
BSS f32 D_802B6794;
BSS f32 D_802B6798;
BSS s32 D_802B679C;
enum {
SUBSTATE_SLIDING = 0,

14
src/world/action/sneaky_parasol.c
View File

@ -26,7 +26,7 @@ enum {
SUBSTATE_DISGUISE_FINISH_SPIN = 7,
SUBSTATE_DISGUISE_DONE = 8,
SUBSTATE_REVERT_INIT = 20, // begin undisguise process
SUBSTATE_REVERT_WAIT_FOR_ANGLE = 21,
SUBSTATE_REVERT_WAIT_FOR_ANGLE = 21,
SUBSTATE_SPIN_DOWN = 22,
SUBSTATE_FINISH_SPIN = 23,
SUBSTATE_REVERT_DONE = 24,
@ -35,7 +35,7 @@ enum {
SUBSTATE_BLOCKED = 50, // cant raise parasol due to collisions with world
};
extern TransformationData ParasolTransformation;
BSS TransformationData ParasolTransformation;
void parasol_update_spin(void);
@ -88,7 +88,7 @@ void action_update_parasol(void) {
playerStatus->unk_C2 = 0;
playerStatus->currentSpeed = 0;
playerStatus->pitch = 0;
if (playerStatus->spriteFacingAngle >= 90 && playerStatus->spriteFacingAngle < 270) {
phi_f4 = 2;
} else {
@ -346,13 +346,13 @@ void action_update_parasol(void) {
}
if (transformation->disguiseTime <= 10 && transformation->disguiseTime & 1) {
f64 tempX, tempZ;
fx_sparkles(FX_SPARKLES_3,
transformation->position.x - 8,
transformation->position.y + 50,
transformation->position.z,
2);
/*
TODO something like:
angle = DEG_TO_RAD((cam->currentYaw + playerStatus->spriteFacingAngle) - 90);
@ -360,8 +360,8 @@ void action_update_parasol(void) {
transformation->position.z -= (10.0 * cos_rad(angle));
*/
angle = DEG_TO_RAD((cam->currentYaw + playerStatus->spriteFacingAngle) - 90);
angle = DEG_TO_RAD((cam->currentYaw + playerStatus->spriteFacingAngle) - 90);
tempX = transformation->position.x;
tempX += 10.0 * sin_rad(angle);
transformation->position.x = tempX;

10
src/world/action/use_munchlesia.c
View File

@ -1,10 +1,10 @@
#include "common.h"
extern f32 Munchlesia_LaunchVelocity;
extern f32 Munchlesia_LateralVelocity;
extern f32 Munchlesia_LaunchAccel;
extern f32 Munchlesia_LaunchYaw;
extern s32 D_802B62E0;
BSS f32 Munchlesia_LaunchVelocity;
BSS f32 Munchlesia_LateralVelocity;
BSS f32 Munchlesia_LaunchAccel;
BSS f32 Munchlesia_LaunchYaw;
BSS s32 D_802B62E0;
enum {
SUBSTATE_INIT = 0,

21
src/world/action/use_spinning_flower.c
View File

@ -1,15 +1,16 @@
#include "common.h"
extern s32 SpinningFlower_EntityIndex;
extern f32 D_802B6ED4;
extern f32 D_802B6ED8;
extern f32 D_802B6EDC;
extern f32 D_802B6EE0;
extern f32 D_802B6EE4;
extern f32 D_802B6EE8;
extern f32 SpinningFlower_AngleToCenter;
extern f32 D_802B6EF0;
extern f32 D_802B6EF4;
BSS s32 SpinningFlower_EntityIndex;
BSS f32 D_802B6ED4;
BSS f32 D_802B6ED8;
BSS f32 D_802B6EDC;
BSS f32 D_802B6EE0;
BSS f32 D_802B6EE4;
BSS f32 D_802B6EE8;
BSS f32 SpinningFlower_AngleToCenter;
BSS f32 D_802B6EF0;
BSS f32 D_802B6EF4;
extern s16 D_802BCE30;
extern s16 D_802BCE32;
extern s16 D_802BCE34;

2
tools/splat/.github/workflows/mypy.yml vendored
View File

@ -23,4 +23,4 @@ jobs:
- name: mypy
run: mypy --show-column-numbers --hide-error-context .
- name: black
run: black .
run: black --check .

4
tools/splat/.gitrepo
View File

@ -6,7 +6,7 @@
[subrepo]
remote = https://github.com/ethteck/splat.git
branch = master
commit = 6c02ec5ecdc1c742ce8ad6cd57480ad65bc802cd
parent = c09278de7a93519feec010692b0be377d5e860de
commit = 9af40c526558452a14b113c3d44b0382d038d65c
parent = 268eb8e88164dcb3858634f62d9f33f8f41407c1
method = merge
cmdver = 0.4.3

12
tools/splat/CHANGELOG.md
View File

@ -1,6 +1,16 @@
# splat Release Notes
### 0.10.0: The Linker Script Update
## 0.11.0: Spimdisasm Returns
Spimdisasm now handles data (data, rodata, bss) disassembly in splat! This includes a few changes in behavior:
* Rodata will be migrated to c files' asm function files when a .rodata subsegment is used that corresponds with an identically-named c file. Some symbols may not be automatically migrated to functions when it is not clear if they belong to the function itself (an example of which being const arrays). In this case, the `partial_migration` option can be enabled for the given .rodata subsegment and splat will create .s files for these unmigrated rodata symbols. These files can then be included in your c files, or you can go ahead and migrate these symbols to c and disable the `partial_migration` feature.
* BSS can now be disassembled as well, and the size of a code segment's bss section can be specified with the `bss_size` option. This option will tell splat how large the bss section is in bytes so BSS can properly be handled during disassembly. For bss subsegments, the rom address will of course not change, but the vram address should still be specified. This currently can only be done in the dict form of segment representation, rather than the list form.
Thanks again to [AngheloAlf](https://github.com/AngheloAlf) for adding this functionality and continuing to improve splat's disassembler.
## 0.10.0: The Linker Script Update
Linker scripts splat produces are now capable of being shift-friendly. Rom addresses will automatically shift, and ram addresses will still be hard-coded unless the new segment option `follows_vram` is specified. The value of this option should be the name of a segment (a) that this segment (b) should follow in memory. If a grows or shrinks, b's start address will also do so to accommodate it.

1
tools/splat/create_config.py
View File

@ -36,7 +36,6 @@ options:
# undefined_syms_auto: True
# undefined_syms_auto_path: undefined_syms_auto.txt
# symbol_addrs_path: symbol_addrs.txt
# undefined_syms_path: undefined_syms.txt
# asm_path: asm
# src_path: src
# build_path: build

4
tools/splat/requirements.txt
View File

@ -2,8 +2,8 @@ PyYAML
pylibyaml
pypng
colorama
spimdisasm>=1.2.1
rabbitizer
spimdisasm>=1.5.3
rabbitizer>=1.2.0
pygfxd
tqdm
intervaltree

4
tools/splat/segtypes/common/asm.py
View File

@ -21,7 +21,7 @@ class CommonSegAsm(CommonSegCodeSubsegment):
return []
def split(self, rom_bytes: bytes):
if not self.rom_start == self.rom_end:
if not self.rom_start == self.rom_end and self.spim_section is not None:
out_path = self.out_path()
if out_path:
out_path.parent.mkdir(parents=True, exist_ok=True)
@ -31,4 +31,4 @@ class CommonSegAsm(CommonSegCodeSubsegment):
with open(out_path, "w", newline="\n") as f:
for line in self.get_file_header():
f.write(line + "\n")
f.write(self.text_section.disassemble())
f.write(self.spim_section.disassemble())

55
tools/splat/segtypes/common/bss.py
View File

@ -1,28 +1,51 @@
import spimdisasm
from typing import List
from segtypes.common.data import CommonSegData
from segtypes.linker_entry import LinkerEntry
from util import options, log
from typing import List
from util import options, symbols
class CommonSegBss(CommonSegData):
def get_linker_section(self) -> str:
return ".bss"
def scan(self, rom_bytes: bytes):
pass
def disassemble_data(self, rom_bytes: bytes):
assert isinstance(self.rom_start, int)
assert isinstance(self.rom_end, int)
def split(self, rom_bytes: bytes):
pass
segment_rom_start = self.get_most_parent().rom_start
assert isinstance(segment_rom_start, int)
def get_linker_entries(self) -> "List[LinkerEntry]":
if self.sibling:
path = self.sibling.out_path()
next_subsegment = self.parent.get_next_subsegment_for_ram(self.vram_start)
if next_subsegment is None:
bss_end = self.get_most_parent().vram_end
assert isinstance(bss_end, int)
else:
path = self.out_path()
bss_end = next_subsegment.vram_start
if path:
return [LinkerEntry(self, [path], path, self.get_linker_section())]
else:
return []
self.spim_section = spimdisasm.mips.sections.SectionBss(
symbols.spim_context,
self.rom_start,
self.rom_end,
self.vram_start,
bss_end,
self.name,
segment_rom_start,
self.get_exclusive_ram_id(),
)
for symbol_list in self.seg_symbols.values():
symbols.add_symbol_to_spim_section(self.spim_section, symbol_list[0])
for sym in symbols.all_symbols:
if sym.user_declared:
symbols.add_symbol_to_spim_section(self.spim_section, sym)
self.spim_section.analyze()
self.spim_section.setCommentOffset(self.rom_start)
for spim_sym in self.spim_section.symbolList:
symbols.create_symbol_from_spim_symbol(
self.get_most_parent(), spim_sym.contextSym
)

100
tools/splat/segtypes/common/c.py
View File

@ -1,11 +1,11 @@
from segtypes.common.codesubsegment import CommonSegCodeSubsegment
from segtypes.common.group import CommonSegGroup
from segtypes.common.rodata import CommonSegRodata
from typing import Optional, Set
import os
import re
from pathlib import Path
import spimdisasm
import rabbitizer
from util import log, options
from util.compiler import GCC, SN64
@ -134,8 +134,10 @@ class CommonSegC(CommonSegCodeSubsegment):
self.create_c_file(asm_out_dir, c_path)
is_new_c_file = True
for func in self.text_section.symbolList:
assert self.spim_section is not None
for func in self.spim_section.symbolList:
assert func.vram is not None
assert isinstance(func, spimdisasm.mips.symbols.SymbolFunction)
func_sym = self.get_symbol(
func.vram, in_segment=True, type="func", local_only=True
)
@ -166,7 +168,7 @@ class CommonSegC(CommonSegCodeSubsegment):
break
def create_c_asm_file(
self, func: spimdisasm.mips.symbols.SymbolBase, out_dir, func_sym: Symbol
self, func: spimdisasm.mips.symbols.SymbolFunction, out_dir, func_sym: Symbol
):
outpath = Path(os.path.join(out_dir, self.name, func_sym.name + ".s"))
assert func.vram is not None
@ -175,53 +177,67 @@ class CommonSegC(CommonSegCodeSubsegment):
if outpath.exists() and not func_sym.extract:
return
out_lines = []
if options.asm_inc_header():
out_lines.extend(options.asm_inc_header().split("\n"))
if self.parent and isinstance(self.parent, CommonSegGroup):
if (
options.get_migrate_rodata_to_functions()
and func.vram in self.parent.rodata_syms
):
func_rodata = list(
{s for s in self.parent.rodata_syms[func.vram] if s.disasm_str}
)
func_rodata.sort(key=lambda s: s.vram_start)
if len(func_rodata) > 0:
rsub = self.parent.get_subsegment_for_ram(func_rodata[0].vram_start)
if rsub and rsub.type != "rodata":
out_lines.append(".section .rodata")
for sym in func_rodata:
if sym.extract and sym.disasm_str:
out_lines.append("")
out_lines.append(
f"{options.get_asm_data_macro()} {sym.name}"
)
out_lines.extend(
sym.disasm_str.replace("\n\n", "\n").split("\n")
)
out_lines.append("")
out_lines.append(".section .text")
out_lines.append("")
out_lines.append(func.disassemble())
outpath.parent.mkdir(parents=True, exist_ok=True)
with open(outpath, "w", newline="\n") as f:
newline_sep = options.c_newline()
f.write(newline_sep.join(out_lines))
if options.asm_inc_header():
f.write(options.c_newline().join(options.asm_inc_header().split("\n")))
if self.parent and isinstance(self.parent, CommonSegGroup):
if (
options.get_migrate_rodata_to_functions()
and func.vram in self.parent.rodata_syms
):
func_rodata = list({s for s in self.parent.rodata_syms[func.vram]})
func_rodata.sort(key=lambda s: s.vram_start)
rdata_list = []
late_rodata_list = []
late_rodata_size = 0
processed_rodata_segments = set()
for func_rodata_symbol in func_rodata:
rsub = self.parent.get_subsegment_for_ram(
func_rodata_symbol.vram_start
)
if rsub is not None and isinstance(rsub, CommonSegRodata):
if (
rsub in processed_rodata_segments
or rsub.spim_section is None
):
continue
assert isinstance(
rsub.spim_section,
spimdisasm.mips.sections.SectionRodata,
)
(
rdata_list_aux,
late_rodata_list_aux,
late_rodata_size_aux,
) = spimdisasm.mips.FilesHandlers.getRdataAndLateRodataForFunctionFromSection(
func, rsub.spim_section
)
rdata_list += rdata_list_aux
late_rodata_list += late_rodata_list_aux
late_rodata_size += late_rodata_size_aux
processed_rodata_segments.add(rsub)
spimdisasm.mips.FilesHandlers.writeFunctionRodataToFile(
f, func, rdata_list, late_rodata_list, late_rodata_size
)
f.write(func.disassemble())
self.log(f"Disassembled {func_sym.name} to {outpath}")
def create_c_file(self, asm_out_dir, c_path):
assert self.spim_section is not None
c_lines = self.get_c_preamble()
for func in self.text_section.symbolList:
for func in self.spim_section.symbolList:
assert isinstance(func, spimdisasm.mips.symbols.SymbolFunction)
# Terrible hack to "auto-decompile" empty functions

15
tools/splat/segtypes/common/code.py
View File

@ -67,21 +67,6 @@ class CommonSegCode(CommonSegGroup):
else:
return None
# def ram_to_rom(self, ram_addr: int) -> Optional[int]:
# size_no_bss = self.vram_start + self.size
# # Do not return a rom address if this is a BSS symbol
# if ram_addr > size_no_bss:
# return None
# if not self.contains_vram(ram_addr) and ram_addr != self.vram_end:
# return None
# if self.vram_start is not None and isinstance(self.rom_start, int):
# return self.rom_start + ram_addr - self.vram_start
# else:
# return None
# Prepare symbol for migration to the function
def check_rodata_sym(self, func_addr: int, sym: Symbol):
if self.section_boundaries[".rodata"].is_complete():

154
tools/splat/segtypes/common/codesubsegment.py
View File

@ -1,39 +1,55 @@
from typing import Optional
from util import options
from segtypes.common.code import CommonSegCode
import spimdisasm
import rabbitizer
from segtypes.segment import Segment
from util.symbols import Symbol
from segtypes import segment
from util import symbols
# abstract class for c, asm, data, etc
class CommonSegCodeSubsegment(Segment):
double_mnemonics = [
rabbitizer.InstrId.cpu_ldc1,
rabbitizer.InstrId.cpu_sdc1,
]
word_mnemonics = [
rabbitizer.InstrId.cpu_addiu,
rabbitizer.InstrId.cpu_sw,
rabbitizer.InstrId.cpu_lw,
]
float_mnemonics = [
rabbitizer.InstrId.cpu_lwc1,
rabbitizer.InstrId.cpu_swc1,
]
short_mnemonics = [
rabbitizer.InstrId.cpu_addiu,
rabbitizer.InstrId.cpu_lh,
rabbitizer.InstrId.cpu_sh,
rabbitizer.InstrId.cpu_lhu,
]
byte_mnemonics = [
rabbitizer.InstrId.cpu_lb,
rabbitizer.InstrId.cpu_sb,
rabbitizer.InstrId.cpu_lbu,
]
def __init__(
self,
rom_start,
rom_end,
type,
name,
vram_start,
extract,
given_subalign,
exclusive_ram_id,
given_dir,
symbol_name_format,
symbol_name_format_no_rom,
args,
yaml,
):
vram = segment.parse_segment_vram(yaml)
if vram is not None:
vram_start = vram
self.partial_migration: bool = (
yaml.get("partial_migration", False) if isinstance(yaml, dict) else False
)
super().__init__(
rom_start,
rom_end,
type,
name,
vram_start,
extract,
given_subalign,
exclusive_ram_id=exclusive_ram_id,
given_dir=given_dir,
symbol_name_format=symbol_name_format,
symbol_name_format_no_rom=symbol_name_format_no_rom,
args=args,
yaml=yaml,
)
self.spim_section: Optional[spimdisasm.mips.sections.SectionBase] = None
@property
def needs_symbols(self) -> bool:
@ -43,30 +59,36 @@ class CommonSegCodeSubsegment(Segment):
return ".text"
def scan_code(self, rom_bytes, is_asm=False):
self.text_section = spimdisasm.mips.sections.SectionText(
assert isinstance(self.rom_start, int)
assert isinstance(self.rom_end, int)
segment_rom_start = self.get_most_parent().rom_start
assert isinstance(segment_rom_start, int)
self.spim_section = spimdisasm.mips.sections.SectionText(
symbols.spim_context,
self.rom_start,
self.rom_end,
self.vram_start,
self.name,
rom_bytes,
self.get_most_parent().rom_start,
segment_rom_start,
self.get_exclusive_ram_id(),
)
for symbol_list in self.seg_symbols.values():
symbols.add_symbol_to_spim_section(self.text_section, symbol_list[0])
symbols.add_symbol_to_spim_section(self.spim_section, symbol_list[0])
for sym in symbols.all_symbols:
if sym.user_declared:
symbols.add_symbol_to_spim_section(self.text_section, sym)
symbols.add_symbol_to_spim_section(self.spim_section, sym)
self.text_section.isHandwritten = is_asm
self.spim_section.isHandwritten = is_asm
self.text_section.analyze()
self.text_section.setCommentOffset(self.rom_start)
self.spim_section.analyze()
self.spim_section.setCommentOffset(self.rom_start)
for func in self.text_section.symbolList:
for func in self.spim_section.symbolList:
assert isinstance(func, spimdisasm.mips.symbols.SymbolFunction)
self.process_insns(func)
@ -78,7 +100,7 @@ class CommonSegCodeSubsegment(Segment):
jtbl_label_vram, True, type="jtbl_label", define=True
)
sym.type = "jtbl_label"
symbols.add_symbol_to_spim_section(self.text_section, sym)
symbols.add_symbol_to_spim_section(self.spim_section, sym)
def process_insns(
self,
@ -87,6 +109,7 @@ class CommonSegCodeSubsegment(Segment):
assert isinstance(self.parent, CommonSegCode)
assert func_spim.vram is not None
assert func_spim.vramEnd is not None
assert self.spim_section is not None
self.parent: CommonSegCode = self.parent
symbols.create_symbol_from_spim_symbol(
@ -95,7 +118,7 @@ class CommonSegCodeSubsegment(Segment):
# Gather symbols found by spimdisasm and create those symbols in splat's side
for referenced_vram in func_spim.instrAnalyzer.referencedVrams:
context_sym = self.text_section.getSymbol(
context_sym = self.spim_section.getSymbol(
referenced_vram, tryPlusOffset=False
)
if context_sym is not None:
@ -116,7 +139,7 @@ class CommonSegCodeSubsegment(Segment):
if instr_offset in func_spim.instrAnalyzer.symbolInstrOffset:
sym_address = func_spim.instrAnalyzer.symbolInstrOffset[instr_offset]
context_sym = self.text_section.getSymbol(
context_sym = self.spim_section.getSymbol(
sym_address, tryPlusOffset=False
)
if context_sym is not None:
@ -124,68 +147,41 @@ class CommonSegCodeSubsegment(Segment):
self.get_most_parent(), context_sym
)
if any(
insn.uniqueId in mnemonics
for mnemonics in (
self.double_mnemonics,
self.word_mnemonics,
self.float_mnemonics,
self.short_mnemonics,
self.byte_mnemonics,
)
):
self.update_access_mnemonic(sym, insn)
if self.parent:
self.parent.check_rodata_sym(func_spim.vram, sym)
def update_access_mnemonic(self, sym: Symbol, insn: rabbitizer.Instruction):
if not sym.access_mnemonic:
sym.access_mnemonic = insn.uniqueId
elif sym.access_mnemonic in self.double_mnemonics:
return
elif (
sym.access_mnemonic in self.float_mnemonics
and insn.uniqueId in self.double_mnemonics
):
sym.access_mnemonic = insn.uniqueId
elif sym.access_mnemonic == rabbitizer.InstrId.cpu_addiu:
sym.access_mnemonic = insn.uniqueId
elif sym.access_mnemonic in self.short_mnemonics:
return
elif sym.access_mnemonic in self.byte_mnemonics:
return
else:
sym.access_mnemonic = insn.uniqueId
def print_file_boundaries(self):
if not options.find_file_boundaries():
if not options.find_file_boundaries() or not self.spim_section:
return
for in_file_offset in self.text_section.fileBoundaries:
assert isinstance(self.rom_start, int)
for in_file_offset in self.spim_section.fileBoundaries:
if (in_file_offset % 16) != 0:
continue
if not self.parent.reported_file_split:
self.parent.reported_file_split = True
# Look up for the last function in this boundary
func_addr = 0
for func in self.text_section.symbolList:
funcOffset = func.inFileOffset - self.text_section.inFileOffset
if in_file_offset == funcOffset:
# Look up for the last symbol in this boundary
sym_addr = 0
for sym in self.spim_section.symbolList:
symOffset = sym.inFileOffset - self.spim_section.inFileOffset
if in_file_offset == symOffset:
break
func_addr = func.vram
sym_addr = sym.vram
print(
f"Segment {self.name}, function at vram {func_addr:X} ends with extra nops, indicating a likely file split."
f"\nSegment {self.name}, symbol at vram {sym_addr:X} ends with extra nops, indicating a likely file split."
)
print(
"File split suggestions for this segment will follow in config yaml format:"
)
print(f" - [0x{self.rom_start+in_file_offset:X}, asm]")
print(f" - [0x{self.rom_start+in_file_offset:X}, {self.type}]")
def gather_jumptable_labels(self, rom_bytes):
assert isinstance(self.rom_start, int)
# TODO: use the seg_symbols for this
# jumptables = [j.type == "jtbl" for j in self.seg_symbols]
for jumptable in self.parent.jumptables:
@ -213,4 +209,4 @@ class CommonSegCodeSubsegment(Segment):
)
def should_split(self) -> bool:
return self.extract and options.mode_active("code")
return self.extract and (self.partial_migration or options.mode_active("code"))

435
tools/splat/segtypes/common/data.py
View File

@ -1,11 +1,10 @@
from segtypes.common.code import CommonSegCode
import spimdisasm
from segtypes.common.codesubsegment import CommonSegCodeSubsegment
from segtypes.common.group import CommonSegGroup
from pathlib import Path
from typing import List, Optional
import rabbitizer
from util.symbols import Symbol
from util import floats, options
from typing import Optional
from util import options, symbols
class CommonSegData(CommonSegCodeSubsegment, CommonSegGroup):
@ -25,21 +24,31 @@ class CommonSegData(CommonSegCodeSubsegment, CommonSegGroup):
CommonSegGroup.scan(self, rom_bytes)
if super().should_scan():
self.file_text = self.disassemble_data(rom_bytes)
else:
self.file_text = None
self.disassemble_data(rom_bytes)
def split(self, rom_bytes: bytes):
CommonSegGroup.split(self, rom_bytes)
super().split(rom_bytes)
if not self.type.startswith(".") and self.file_text:
if (
not self.type.startswith(".")
and self.spim_section
and self.should_self_split()
):
path = self.out_path()
if path:
path.parent.mkdir(parents=True, exist_ok=True)
self.print_file_boundaries()
with open(path, "w", newline="\n") as f:
f.write(self.file_text)
f.write('.include "macro.inc"\n\n')
f.write(f".section {self.get_linker_section()}\n\n")
f.write(self.spim_section.disassemble())
def should_self_split(self) -> bool:
return options.mode_active("data")
def should_split(self) -> bool:
return True
@ -56,374 +65,50 @@ class CommonSegData(CommonSegCodeSubsegment, CommonSegGroup):
def get_linker_entries(self):
return CommonSegCodeSubsegment.get_linker_entries(self)
# Check symbols marked as jump tables to be valid
def check_jtbls(self, rom_bytes, syms: List[Symbol]):
endianness = options.get_endianess()
for i, sym in enumerate(syms):
if sym.type == "jtbl":
start = self.get_most_parent().ram_to_rom(syms[i].vram_start)
assert isinstance(start, int)
end = self.get_most_parent().ram_to_rom(syms[i + 1].vram_start)
sym_bytes = rom_bytes[start:end]
b = 0
last_bits = 0
while b < len(sym_bytes):
bits = int.from_bytes(sym_bytes[b : b + 4], endianness)
if (
last_bits != 0
and bits != 0
and abs(last_bits - bits) > 0x100000
):
new_sym_rom_start = start + b
new_sym_ram_start = self.get_most_parent().rom_to_ram(
new_sym_rom_start
)
assert sym.rom is not None
assert new_sym_ram_start is not None
sym.given_size = new_sym_rom_start - sym.rom
# It turns out this isn't a valid jump table, so create a new symbol where it breaks
syms.insert(
i + 1,
self.create_symbol(
new_sym_ram_start, True, define=True, local_only=True
),
)
return False
if bits != 0:
last_bits = bits
b += 4
return True
def get_symbols(self, rom_bytes) -> List[Symbol]:
symset = set()
endian = options.get_endianess()
# Find inter-data symbols
assert isinstance(self.rom_start, int) and isinstance(self.rom_end, int)
for i in range(self.rom_start, self.rom_end, 4):
bits = int.from_bytes(rom_bytes[i : i + 4], endian)
if self.contains_vram(bits):
symset.add(
self.create_symbol(
bits, in_segment=True, define=True, local_only=True
)
)
for symbol_addr in self.seg_symbols:
for symbol in self.seg_symbols[symbol_addr]:
if not symbol.dead and self.contains_vram(symbol.vram_start):
symset.add(symbol)
ret: List[Symbol] = list(symset)
ret.sort(key=lambda s: s.vram_start)
# Ensure we start at the beginning
if len(ret) == 0 or ret[0].vram_start != self.vram_start:
ret.insert(
0,
self.create_symbol(
self.vram_start, in_segment=True, define=True, local_only=True
),
)
# Make a dummy symbol here that marks the end of the previous symbol's disasm range
assert self.vram_end is not None
ret.append(Symbol(self.vram_end))
while True:
valid = self.check_jtbls(rom_bytes, ret)
if valid:
break
return ret
def are_null(chars):
for b in chars:
if b != "\x00":
return False
return True
@staticmethod
def is_valid_ascii(bytes):
null_char = "\x00"
valid_chars = (
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890[]():%!#=-_ "
)
invalid_chars = ""
duplicate_limit = 10
last_char = 0
true_end = None
consecutive_duplicates = 0
valid_count = 0
if len(bytes) <= 4 or bytes[0] == 0:
return False
try:
chars = bytes.decode("EUC-JP")
except:
return False
if len(chars) <= 4:
return False
for i, c in enumerate(chars):
# Ensure null bytes are only at the end of ascii strings
# TODO: if we find null bytes in the middle, break this into multiple strings ?
if c == null_char:
if true_end is None:
if CommonSegData.are_null(chars[i:]):
true_end = i
else:
pass
# return False
# Ensure we're not seeing a ton of the same character in a row
if last_char == c:
consecutive_duplicates += 1
if consecutive_duplicates >= duplicate_limit and last_char != null_char:
return False
else:
consecutive_duplicates = 0
if c in valid_chars:
valid_count += 1
elif c in invalid_chars:
return False
last_char = c
# Ensure the number of valid characters is sufficient
if true_end is not None:
# If there are more than 16 null chars at the end, something is afoot
if len(chars) - true_end > 16:
return False
end = true_end
else:
end = len(chars)
valid_ratio = valid_count / end
if valid_ratio >= 0.75:
return True
return False
# TODO if we see a new function's jtbl, split it
def is_valid_jtbl(self, sym: Symbol, bytes) -> bool:
min_jtbl_len = 16
if len(bytes) % 4 != 0:
return False
# Jump tables must have at least 3 labels
if len(bytes) < min_jtbl_len:
return False
most_parent = self.get_most_parent()
assert isinstance(most_parent, CommonSegCode)
# Grab the first word and see if its value is an address within a function
word = int.from_bytes(bytes[0:4], options.get_endianess())
jtbl_func: Optional[Symbol] = self.get_most_parent().get_func_for_addr(word)
if not jtbl_func:
return False
# A label of a jump table shouldn't point to the start of the function
if word == jtbl_func.vram_start:
return False
for i in range(4, len(bytes), 4):
word = int.from_bytes(bytes[i : i + 4], options.get_endianess())
# If the word doesn't contain an address in the current function, this isn't a valid jump table
if not jtbl_func.contains_vram(word):
# Allow jump tables that are of a minimum length and end in 0s
if i < min_jtbl_len or any(b != 0 for b in bytes[i:]):
return False
# A label of a jump table shouldn't point to the start of the function
if word == jtbl_func.vram_start:
return False
# Mark this symbol as a jump table and record the jump table for later
sym.type = "jtbl"
most_parent.jumptables[sym.vram_start] = (
jtbl_func.vram_start,
jtbl_func.vram_end,
)
return True
def disassemble_symbol(self, sym_bytes, sym_type):
endian = options.get_endianess()
if sym_type == "jtbl":
sym_str = ".word "
else:
sym_str = f".{sym_type} "
if sym_type == "double":
slen = 8
elif sym_type == "short":
slen = 2
elif sym_type == "byte":
slen = 1
else:
slen = 4
if sym_type == "ascii":
try:
ascii_str = sym_bytes.decode("EUC-JP")
# ascii_str = ascii_str.rstrip("\x00")
ascii_str = ascii_str.replace("\\", "\\\\") # escape back slashes
ascii_str = ascii_str.replace('"', '\\"') # escape quotes
ascii_str = ascii_str.replace("\x00", "\\0")
ascii_str = ascii_str.replace("\n", "\\n")
sym_str += f'"{ascii_str}"'
return sym_str
except:
return self.disassemble_symbol(sym_bytes, "word")
i = 0
while i < len(sym_bytes):
adv_amt = min(slen, len(sym_bytes) - i)
bits = int.from_bytes(sym_bytes[i : i + adv_amt], endian)
if sym_type == "jtbl":
if bits == 0:
byte_str = "0"
else:
sym = self.get_symbol(bits, True)
if sym is not None:
byte_str = sym.name
else:
byte_str = f"0x{bits:X}"
elif slen == 4 and bits >= 0x80000000:
sym = self.get_symbol(bits, reference=True)
if sym and sym.type not in ["label", "jtbl"]:
byte_str = sym.name
else:
byte_str = "0x{0:0{1}X}".format(bits, 2 * slen)
else:
byte_str = "0x{0:0{1}X}".format(bits, 2 * slen)
if sym_type in ["float", "double"]:
if sym_type == "float":
float_str = floats.format_f32_imm(bits)
else:
float_str = floats.format_f64_imm(bits)
# Fall back to .word if we see weird float values
# TODO: cut the symbol in half maybe where we see the first nan or something
if "e-" in float_str or "nan" in float_str:
return self.disassemble_symbol(sym_bytes, "word")
else:
byte_str = float_str
sym_str += byte_str
i += adv_amt
if i < len(sym_bytes):
sym_str += ", "
return sym_str
def disassemble_data(self, rom_bytes):
rodata_encountered = "rodata" in self.type
ret = '.include "macro.inc"\n\n'
ret += f".section {self.get_linker_section()}"
assert isinstance(self.rom_start, int)
assert isinstance(self.rom_end, int)
if self.size == 0:
return None
segment_rom_start = self.get_most_parent().rom_start
assert isinstance(segment_rom_start, int)
syms = self.get_symbols(rom_bytes)
self.spim_section = spimdisasm.mips.sections.SectionData(
symbols.spim_context,
self.rom_start,
self.rom_end,
self.vram_start,
self.name,
rom_bytes,
segment_rom_start,
self.get_exclusive_ram_id(),
)
for i in range(len(syms) - 1):
mnemonic = syms[i].access_mnemonic
sym = self.create_symbol(
syms[i].vram_start, in_segment=True, define=True, local_only=True
for symbol_list in self.seg_symbols.values():
symbols.add_symbol_to_spim_section(self.spim_section, symbol_list[0])
for sym in symbols.all_symbols:
if sym.user_declared:
symbols.add_symbol_to_spim_section(self.spim_section, sym)
self.spim_section.analyze()
self.spim_section.setCommentOffset(self.rom_start)
rodata_encountered = False
for symbol in self.spim_section.symbolList:
symbols.create_symbol_from_spim_symbol(
self.get_most_parent(), symbol.contextSym
)
dis_start = self.get_most_parent().ram_to_rom(syms[i].vram_start)
dis_end = self.get_most_parent().ram_to_rom(syms[i + 1].vram_start)
assert dis_start is not None and dis_end is not None
sym_len = dis_end - dis_start
if self.type == "bss":
disasm_str = f".space 0x{sym_len:X}"
else:
sym_bytes = rom_bytes[dis_start:dis_end]
# Checking if the mnemonic is addiu may be too picky - we'll see
if (
self.is_valid_ascii(sym_bytes)
and mnemonic == rabbitizer.InstrId.cpu_addiu
):
stype = "ascii"
elif sym.type == "jtbl":
stype = "jtbl"
elif self.is_valid_jtbl(sym, sym_bytes):
stype = "jtbl"
elif (
len(sym_bytes) % 8 == 0
and mnemonic in CommonSegCodeSubsegment.double_mnemonics
):
stype = "double"
elif (
len(sym_bytes) % 4 == 0
and mnemonic in CommonSegCodeSubsegment.float_mnemonics
):
stype = "float"
elif (
len(sym_bytes) % 4 == 0
and sym.vram_start % 4 == 0
and (
mnemonic in CommonSegCodeSubsegment.word_mnemonics
or not mnemonic
)
):
stype = "word"
elif (
len(sym_bytes) % 2 == 0
and sym.vram_start % 2 == 0
and (
mnemonic in CommonSegCodeSubsegment.short_mnemonics
or not mnemonic
)
):
stype = "short"
else:
stype = "byte"
# If we're starting from a weird place, make sure our container size is correct
if dis_start % 4 != 0 and stype != "byte" and sym_len > 1:
stype = "short"
if dis_start % 2 != 0:
stype = "byte"
# Hint to the user that we are now in the .rodata section and no longer in the .data section (assuming rodata follows data)
if (
not rodata_encountered
and stype == "jtbl"
and self.get_most_parent().rodata_follows_data
):
# Hint to the user that we are now in the .rodata section and no longer in the .data section (assuming rodata follows data)
if not rodata_encountered and self.get_most_parent().rodata_follows_data:
if symbol.contextSym.isJumpTable():
rodata_encountered = True
ret += "\n\n\n.section .rodata"
disasm_str = self.disassemble_symbol(sym_bytes, stype)
sym.disasm_str = disasm_str
name_str = f"\n\n{options.get_asm_data_macro()} {sym.name}\n"
ret += name_str + disasm_str
ret += "\n"
return ret
print(
f"Data segment {self.name}, symbol at vram {symbol.contextSym.vram:X} is a jumptable, indicating the start of the rodata section _may_ be near here."
)
print(
f"Please note the real start of the rodata section may be way before this point."
)
if symbol.contextSym.vromAddress is not None:
print(f" - [0x{symbol.contextSym.vromAddress:X}, rodata]")

14
tools/splat/segtypes/common/group.py
View File

@ -129,3 +129,17 @@ class CommonSegGroup(CommonSegment):
if sub.contains_vram(addr):
return sub
return None
def get_next_subsegment_for_ram(self, addr: int) -> Optional[Segment]:
"""
Returns the first subsegment which comes after the specified address,
or None in case this address belongs to the last subsegment of this group
"""
for sub in self.subsegments:
if sub.vram_start == "auto":
continue
assert isinstance(sub.vram_start, int)
if sub.vram_start > addr:
return sub
return None

4
tools/splat/segtypes/common/hasm.py
View File

@ -3,7 +3,7 @@ from segtypes.common.asm import CommonSegAsm
class CommonSegHasm(CommonSegAsm):
def split(self, rom_bytes: bytes):
if not self.rom_start == self.rom_end:
if not self.rom_start == self.rom_end and self.spim_section is not None:
out_path = self.out_path()
if out_path and not out_path.exists():
out_path.parent.mkdir(parents=True, exist_ok=True)
@ -13,4 +13,4 @@ class CommonSegHasm(CommonSegAsm):
with open(out_path, "w", newline="\n") as f:
for line in self.get_file_header():
f.write(line + "\n")
f.write(self.text_section.disassemble())
f.write(self.spim_section.disassemble())

4
tools/splat/segtypes/common/rdata.py
View File

@ -1,6 +1,6 @@
from segtypes.common.data import CommonSegData
from segtypes.common.rodata import CommonSegRodata
class CommonSegRdata(CommonSegData):
class CommonSegRdata(CommonSegRodata):
def get_linker_section(self) -> str:
return ".rdata"

57
tools/splat/segtypes/common/rodata.py
View File

@ -1,6 +1,63 @@
import spimdisasm
from segtypes.common.data import CommonSegData
from util import symbols, options
class CommonSegRodata(CommonSegData):
def get_linker_section(self) -> str:
return ".rodata"
def disassemble_data(self, rom_bytes):
assert isinstance(self.rom_start, int)
assert isinstance(self.rom_end, int)
segment_rom_start = self.get_most_parent().rom_start
assert isinstance(segment_rom_start, int)
self.spim_section = spimdisasm.mips.sections.SectionRodata(
symbols.spim_context,
self.rom_start,
self.rom_end,
self.vram_start,
self.name,
rom_bytes,
segment_rom_start,
self.get_exclusive_ram_id(),
)
for symbol_list in self.seg_symbols.values():
symbols.add_symbol_to_spim_section(self.spim_section, symbol_list[0])
for sym in symbols.all_symbols:
if sym.user_declared:
symbols.add_symbol_to_spim_section(self.spim_section, sym)
self.spim_section.analyze()
self.spim_section.setCommentOffset(self.rom_start)
for symbol in self.spim_section.symbolList:
symbols.create_symbol_from_spim_symbol(
self.get_most_parent(), symbol.contextSym
)
def split(self, rom_bytes: bytes):
# Disassemble the file itself
super().split(rom_bytes)
if options.get_migrate_rodata_to_functions():
if self.spim_section and (
not self.type.startswith(".") or self.partial_migration
):
path_folder = options.get_data_path() / self.dir
path_folder.parent.mkdir(parents=True, exist_ok=True)
for rodataSym in self.spim_section.symbolList:
if not rodataSym.isRdata():
continue
path = path_folder / f"{rodataSym.getName()}.s"
with open(path, "w", newline="\n") as f:
f.write('.include "macro.inc"\n\n')
f.write(".section .rodata\n\n")
f.write(rodataSym.disassemble())

40
tools/splat/segtypes/linker_entry.py
View File

@ -207,9 +207,17 @@ class LinkerWriter:
# Create new linker section for BSS
if entering_bss or leaving_bss:
# If this is the last entry of its type, add the END marker for the section we're ending
if entry in last_seen_sections and section_labels[entry.section_type].started:
if (
entry in last_seen_sections
and section_labels[entry.section_type].started
):
seg_name_section = to_cname(
f"{seg_name}{last_seen_sections[entry].upper()}"
)
self._write_symbol(f"{seg_name_section}_END", ".")
self._write_symbol(
f"{seg_name}{last_seen_sections[entry].upper()}_END", "."
f"{seg_name_section}_SIZE",
f"ABSOLUTE({seg_name_section}_END - {seg_name_section}_START)",
)
section_labels[last_seen_sections[entry]].ended = True
@ -231,15 +239,25 @@ class LinkerWriter:
# If this is the last entry of its type, add the END marker for the section we're ending
if entry in last_seen_sections:
self._write_symbol(f"{seg_name}{cur_section.upper()}_END", ".")
seg_name_section = to_cname(f"{seg_name}{cur_section.upper()}")
self._write_symbol(f"{seg_name_section}_END", ".")
self._write_symbol(
f"{seg_name_section}_SIZE",
f"ABSOLUTE({seg_name_section}_END - {seg_name_section}_START)",
)
section_labels[cur_section].ended = True
prev_section = cur_section
# End all un-ended sections
for section in section_labels.values():
if (section.started and not section.ended):
self._write_symbol(f"{seg_name}_{section.name.upper()}_END", ".")
if section.started and not section.ended:
seg_name_section = to_cname(f"{seg_name}{section.name.upper()}")
self._write_symbol(f"{seg_name_section}_END", ".")
self._write_symbol(
f"{seg_name_section}_SIZE",
f"ABSOLUTE({seg_name_section}_END - {seg_name_section}_START)",
)
all_bss = all(e.section == ".bss" for e in entries)
self._end_segment(segment, next_segment, all_bss)
@ -304,7 +322,11 @@ class LinkerWriter:
if segment.follows_vram_segment:
vram_str = get_segment_cname(segment.follows_vram_segment) + "_VRAM_END "
else:
vram_str = f"0x{segment.vram_start:X} " if isinstance(segment.vram_start, int) else ""
vram_str = (
f"0x{segment.vram_start:X} "
if isinstance(segment.vram_start, int)
else ""
)
name = get_segment_cname(segment)
@ -319,7 +341,11 @@ class LinkerWriter:
if segment.follows_vram_segment:
vram_str = get_segment_cname(segment.follows_vram_segment) + "_VRAM_END "
else:
vram_str = f"0x{segment.vram_start:X} " if isinstance(segment.vram_start, int) else ""
vram_str = (
f"0x{segment.vram_start:X} "
if isinstance(segment.vram_start, int)
else ""
)
name = get_segment_cname(segment) + "_bss"

10
tools/splat/segtypes/n64/asm.py
View File

@ -10,11 +10,13 @@ class N64SegAsm(CommonSegAsm):
ret.append('.include "macro.inc"')
ret.append("")
ret.append("# assembler directives")
ret.append(".set noat # allow manual use of $at")
ret.append(".set noreorder # don't insert nops after branches")
ret.append("/* assembler directives */")
ret.append(".set noat /* allow manual use of $at */")
ret.append(".set noreorder /* don't insert nops after branches */")
if options.get_add_set_gp_64():
ret.append(".set gp=64 # allow use of 64-bit general purpose registers")
ret.append(
".set gp=64 /* allow use of 64-bit general purpose registers */"
)
ret.append("")
preamble = options.get_generated_s_preamble()
if preamble:

10
tools/splat/segtypes/n64/hasm.py
View File

@ -10,11 +10,13 @@ class N64SegHasm(CommonSegHasm):
ret.append('.include "macro.inc"')
ret.append("")
ret.append("# assembler directives")
ret.append(".set noat # allow manual use of $at")
ret.append(".set noreorder # don't insert nops after branches")
ret.append("/* assembler directives */")
ret.append(".set noat /* allow manual use of $at */")
ret.append(".set noreorder /* don't insert nops after branches */")
if options.get_add_set_gp_64():
ret.append(".set gp=64 # allow use of 64-bit general purpose registers")
ret.append(
".set gp=64 /* allow use of 64-bit general purpose registers */"
)
ret.append("")
preamble = options.get_generated_s_preamble()
if preamble:

6
tools/splat/segtypes/psx/asm.py
View File

@ -12,9 +12,9 @@ class PsxSegAsm(CommonSegAsm):
ret.append('.include "macro.inc"')
ret.append("")
ret.append("# assembler directives")
ret.append(".set noat # allow manual use of $at")
ret.append(".set noreorder # don't insert nops after branches")
ret.append("/* assembler directives */")
ret.append(".set noat /* allow manual use of $at */")
ret.append(".set noreorder /* don't insert nops after branches */")
ret.append("")
preamble = options.get_generated_s_preamble()
if preamble:

29
tools/splat/split.py
View File

@ -20,7 +20,7 @@ from util.symbols import Symbol
from intervaltree import Interval, IntervalTree
VERSION = "0.10.0"
VERSION = "0.11.0"
parser = argparse.ArgumentParser(
description="Split a rom given a rom, a config, and output directory"
@ -457,6 +457,33 @@ def main(config_path, base_dir, target_path, modes, verbose, use_cache=True):
with open(options.get_cache_path(), "wb") as f4:
pickle.dump(cache, f4)
if options.dump_symbols():
from pathlib import Path
splat_hidden_folder = Path(".splat/")
splat_hidden_folder.mkdir(exist_ok=True)
with open(splat_hidden_folder / "splat_symbols.csv", "w") as f:
f.write(
"vram_start,given_name,name,type,given_size,size,rom,defined,user_declared,referenced,dead,extract\n"
)
for s in sorted(symbols.all_symbols, key=lambda x: x.vram_start):
f.write(f"{s.vram_start:X},{s.given_name},{s.name},{s.type},")
if s.given_size is not None:
f.write(f"0x{s.given_size:X},")
else:
f.write(f"None,")
f.write(f"{s.size},")
if s.rom is not None:
f.write(f"0x{s.rom:X},")
else:
f.write(f"None,")
f.write(
f"{s.defined},{s.user_declared},{s.referenced},{s.dead},{s.extract}\n"
)
symbols.spim_context.saveContextToFile(splat_hidden_folder / "spim_context.csv")
if __name__ == "__main__":
args = parser.parse_args()

2
tools/splat/util/compiler.py
View File

@ -13,7 +13,7 @@ class Compiler:
GCC = Compiler(
"GCC",
asm_inc_header=".set noat # allow manual use of $at\n.set noreorder # don't insert nops after branches\n\n",
asm_inc_header=".set noat /* allow manual use of $at */\n.set noreorder /* don't insert nops after branches */\n\n",
)
SN64 = Compiler(

9
tools/splat/util/options.py
View File

@ -51,6 +51,10 @@ def verbose() -> bool:
return opts.get("verbose", False)
def dump_symbols() -> bool:
return opts.get("dump_symbols", False)
################################################################################
# Global options
#
@ -305,11 +309,6 @@ def find_file_boundaries() -> bool:
return opts.get("find_file_boundaries", True)
# Determines the maximum number of instructions to attempt to match hi/lo pairs for symbols when disassembling
def hi_lo_max_distance() -> int:
return opts.get("hi_lo_max_distance", 6)
# Determines whether to attempt to automatically migrate rodata into functions (only works in certain circumstances)
def get_migrate_rodata_to_functions() -> bool:
return opts.get("migrate_rodata_to_functions", True)

3
tools/splat/util/symbols.py
View File

@ -1,6 +1,5 @@
from typing import Dict, List, Optional, TYPE_CHECKING, Set
import spimdisasm
import rabbitizer
import tqdm
# circular import
@ -373,8 +372,6 @@ class Symbol:
self.type = type
self.given_size = given_size
self.given_name = given_name
self.access_mnemonic: Optional[rabbitizer.Enum] = None
self.disasm_str: Optional[str] = None
self.dead: bool = False
self.extract: bool = True
self.user_declared: bool = False

4
ver/us/asm/nonmatchings/16c8e0/func_8023F088.s
View File

@ -51,8 +51,8 @@ glabel func_8023F088
/* 16DA20 8023F140 0000902D */ daddu $s2, $zero, $zero
/* 16DA24 8023F144 0280182D */ daddu $v1, $s4, $zero
/* 16DA28 8023F148 0040902D */ daddu $s2, $v0, $zero
/* 16DA2C 8023F14C 3C02802A */ lui $v0, %hi(D_8029F236)
/* 16DA30 8023F150 2442F236 */ addiu $v0, $v0, %lo(D_8029F236)
/* 16DA2C 8023F14C 3C02802A */ lui $v0, %hi(D_8029F038+0x1FE)
/* 16DA30 8023F150 2442F236 */ addiu $v0, $v0, %lo(D_8029F038+0x1FE)
.L8023F154:
/* 16DA34 8023F154 A4430000 */ sh $v1, ($v0)
/* 16DA38 8023F158 2652FFFF */ addiu $s2, $s2, -1

36
ver/us/asm/nonmatchings/415D90/btl_state_update_partner_menu.s
View File

@ -279,8 +279,8 @@ glabel btl_state_update_partner_menu
/* 41D358 802A85C8 8C63B590 */ lw $v1, %lo(battle_menu_PartnerMoveHudScripts)($v1)
/* 41D35C 802A85CC 8EC20018 */ lw $v0, 0x18($s6)
/* 41D360 802A85D0 24050006 */ addiu $a1, $zero, 6
/* 41D364 802A85D4 3C01802B */ lui $at, %hi(D_802AD0BC)
/* 41D368 802A85D8 AC25D0BC */ sw $a1, %lo(D_802AD0BC)($at)
/* 41D364 802A85D4 3C01802B */ lui $at, %hi(battle_menu_submenuIDs+0x4)
/* 41D368 802A85D8 AC25D0BC */ sw $a1, %lo(battle_menu_submenuIDs+0x4)($at)
/* 41D36C 802A85DC AE700004 */ sw $s0, 4($s3)
/* 41D370 802A85E0 AFC20004 */ sw $v0, 4($fp)
/* 41D374 802A85E4 AE430004 */ sw $v1, 4($s2)
@ -331,8 +331,8 @@ glabel btl_state_update_partner_menu
/* 41D41C 802A868C 8EC5002C */ lw $a1, 0x2c($s6)
/* 41D420 802A8690 96830070 */ lhu $v1, 0x70($s4)
/* 41D424 802A8694 24020001 */ addiu $v0, $zero, 1
/* 41D428 802A8698 3C01802B */ lui $at, %hi(D_802AD0C0)
/* 41D42C 802A869C AC27D0C0 */ sw $a3, %lo(D_802AD0C0)($at)
/* 41D428 802A8698 3C01802B */ lui $at, %hi(battle_menu_submenuIDs+0x8)
/* 41D42C 802A869C AC27D0C0 */ sw $a3, %lo(battle_menu_submenuIDs+0x8)($at)
/* 41D430 802A86A0 AE620008 */ sw $v0, 8($s3)
/* 41D434 802A86A4 AEA00008 */ sw $zero, 8($s5)
/* 41D438 802A86A8 30630800 */ andi $v1, $v1, 0x800
@ -431,9 +431,9 @@ glabel btl_state_update_partner_menu
/* 41D58C 802A87FC 8063D06B */ lb $v1, %lo(D_802AD06B)($v1)
/* 41D590 802A8800 00431021 */ addu $v0, $v0, $v1
/* 41D594 802A8804 00021080 */ sll $v0, $v0, 2
/* 41D598 802A8808 3C01802B */ lui $at, %hi(D_802AD0BB)
/* 41D598 802A8808 3C01802B */ lui $at, %hi(battle_menu_submenuIDs+0x3)
/* 41D59C 802A880C 00220821 */ addu $at, $at, $v0
/* 41D5A0 802A8810 9022D0BB */ lbu $v0, %lo(D_802AD0BB)($at)
/* 41D5A0 802A8810 9022D0BB */ lbu $v0, %lo(battle_menu_submenuIDs+0x3)($at)
/* 41D5A4 802A8814 0C0A842E */ jal func_802A10B8
/* 41D5A8 802A8818 A282005C */ sb $v0, 0x5c($s4)
/* 41D5AC 802A881C 080AA5DD */ j .L802A9774
@ -463,9 +463,9 @@ glabel btl_state_update_partner_menu
/* 41D600 802A8870 0000282D */ daddu $a1, $zero, $zero
/* 41D604 802A8874 2602FFFF */ addiu $v0, $s0, -1
/* 41D608 802A8878 00021080 */ sll $v0, $v0, 2
/* 41D60C 802A887C 3C01802B */ lui $at, %hi(D_802AD0BB)
/* 41D60C 802A887C 3C01802B */ lui $at, %hi(battle_menu_submenuIDs+0x3)
/* 41D610 802A8880 00220821 */ addu $at, $at, $v0
/* 41D614 802A8884 9022D0BB */ lbu $v0, %lo(D_802AD0BB)($at)
/* 41D614 802A8884 9022D0BB */ lbu $v0, %lo(battle_menu_submenuIDs+0x3)($at)
/* 41D618 802A8888 A282004A */ sb $v0, 0x4a($s4)
/* 41D61C 802A888C 8283004A */ lb $v1, 0x4a($s4)
/* 41D620 802A8890 24050007 */ addiu $a1, $zero, 7
@ -769,9 +769,9 @@ glabel btl_state_update_partner_menu
/* 41DA5C 802A8CCC 8282004B */ lb $v0, 0x4b($s4)
/* 41DA60 802A8CD0 A2830178 */ sb $v1, 0x178($s4)
/* 41DA64 802A8CD4 00021080 */ sll $v0, $v0, 2
/* 41DA68 802A8CD8 3C01802B */ lui $at, %hi(D_802AD4B2)
/* 41DA68 802A8CD8 3C01802B */ lui $at, %hi(battle_menu_moveIndices+0x2)
/* 41DA6C 802A8CDC 00220821 */ addu $at, $at, $v0
/* 41DA70 802A8CE0 9422D4B2 */ lhu $v0, %lo(D_802AD4B2)($at)
/* 41DA70 802A8CE0 9422D4B2 */ lhu $v0, %lo(battle_menu_moveIndices+0x2)($at)
/* 41DA74 802A8CE4 A682017C */ sh $v0, 0x17c($s4)
/* 41DA78 802A8CE8 00021400 */ sll $v0, $v0, 0x10
/* 41DA7C 802A8CEC 00021403 */ sra $v0, $v0, 0x10
@ -781,8 +781,8 @@ glabel btl_state_update_partner_menu
/* 41DA8C 802A8CFC 3C018009 */ lui $at, %hi(gMoveTable + 0x4)
/* 41DA90 802A8D00 00230821 */ addu $at, $at, $v1
/* 41DA94 802A8D04 8C23F064 */ lw $v1, %lo(gMoveTable + 0x4)($at)
/* 41DA98 802A8D08 3C02802B */ lui $v0, %hi(D_802AD603)
/* 41DA9C 802A8D0C 9042D603 */ lbu $v0, %lo(D_802AD603)($v0)
/* 41DA98 802A8D08 3C02802B */ lui $v0, %hi(battle_menu_moveOptionActive + 0x3)
/* 41DA9C 802A8D0C 9042D603 */ lbu $v0, %lo(battle_menu_moveOptionActive + 0x3)($v0)
/* 41DAA0 802A8D10 24040011 */ addiu $a0, $zero, 0x11
/* 41DAA4 802A8D14 A282005D */ sb $v0, 0x5d($s4)
/* 41DAA8 802A8D18 2402000E */ addiu $v0, $zero, 0xe
@ -1239,9 +1239,9 @@ glabel btl_state_update_partner_menu
/* 41E12C 802A939C 24020002 */ addiu $v0, $zero, 2
.L802A93A0:
/* 41E130 802A93A0 00021080 */ sll $v0, $v0, 2
/* 41E134 802A93A4 3C01802B */ lui $at, %hi(D_802AD4B3)
/* 41E134 802A93A4 3C01802B */ lui $at, %hi(battle_menu_moveIndices+0x3)
/* 41E138 802A93A8 00220821 */ addu $at, $at, $v0
/* 41E13C 802A93AC 9022D4B3 */ lbu $v0, %lo(D_802AD4B3)($at)
/* 41E13C 802A93AC 9022D4B3 */ lbu $v0, %lo(battle_menu_moveIndices+0x3)($at)
/* 41E140 802A93B0 0C0A89F4 */ jal func_802A27D0
/* 41E144 802A93B4 A282004B */ sb $v0, 0x4b($s4)
/* 41E148 802A93B8 0C0A840C */ jal func_802A1030
@ -1288,8 +1288,8 @@ glabel btl_state_update_partner_menu
/* 41E1E4 802A9454 3C058009 */ lui $a1, %hi(gMoveTable + 0x4)
/* 41E1E8 802A9458 00A22821 */ addu $a1, $a1, $v0
/* 41E1EC 802A945C 8CA5F064 */ lw $a1, %lo(gMoveTable + 0x4)($a1)
/* 41E1F0 802A9460 3C02802B */ lui $v0, %hi(D_802AD603)
/* 41E1F4 802A9464 9042D603 */ lbu $v0, %lo(D_802AD603)($v0)
/* 41E1F0 802A9460 3C02802B */ lui $v0, %hi(battle_menu_moveOptionActive + 0x3)
/* 41E1F4 802A9464 9042D603 */ lbu $v0, %lo(battle_menu_moveOptionActive + 0x3)($v0)
/* 41E1F8 802A9468 00031E00 */ sll $v1, $v1, 0x18
/* 41E1FC 802A946C 00031E03 */ sra $v1, $v1, 0x18
/* 41E200 802A9470 A683017A */ sh $v1, 0x17a($s4)
@ -1419,9 +1419,9 @@ glabel btl_state_update_partner_menu
/* 41E3D0 802A9640 24020002 */ addiu $v0, $zero, 2
.L802A9644:
/* 41E3D4 802A9644 00031080 */ sll $v0, $v1, 2
/* 41E3D8 802A9648 3C01802B */ lui $at, %hi(D_802AD67B)
/* 41E3D8 802A9648 3C01802B */ lui $at, %hi(D_802AD678 + 0x3)
/* 41E3DC 802A964C 00220821 */ addu $at, $at, $v0
/* 41E3E0 802A9650 9022D67B */ lbu $v0, %lo(D_802AD67B)($at)
/* 41E3E0 802A9650 9022D67B */ lbu $v0, %lo(D_802AD678 + 0x3)($at)
/* 41E3E4 802A9654 A2830063 */ sb $v1, 0x63($s4)
/* 41E3E8 802A9658 A282004A */ sb $v0, 0x4a($s4)
/* 41E3EC 802A965C 8283004A */ lb $v1, 0x4a($s4)

4
ver/us/asm/nonmatchings/415D90/btl_state_update_peach_menu.s
View File

@ -272,9 +272,9 @@ glabel btl_state_update_peach_menu
/* 41ECB4 802A9F24 34C60002 */ ori $a2, $a2, 2
/* 41ECB8 802A9F28 2602FFFF */ addiu $v0, $s0, -1
/* 41ECBC 802A9F2C 00021080 */ sll $v0, $v0, 2
/* 41ECC0 802A9F30 3C01802B */ lui $at, %hi(D_802AD0BB)
/* 41ECC0 802A9F30 3C01802B */ lui $at, %hi(battle_menu_submenuIDs+0x3)
/* 41ECC4 802A9F34 00220821 */ addu $at, $at, $v0
/* 41ECC8 802A9F38 9022D0BB */ lbu $v0, %lo(D_802AD0BB)($at)
/* 41ECC8 802A9F38 9022D0BB */ lbu $v0, %lo(battle_menu_submenuIDs+0x3)($at)
/* 41ECCC 802A9F3C 0C0A840C */ jal func_802A1030
/* 41ECD0 802A9F40 A2420048 */ sb $v0, 0x48($s2)
/* 41ECD4 802A9F44 24020008 */ addiu $v0, $zero, 8

36
ver/us/asm/nonmatchings/415D90/btl_state_update_player_menu.s
View File

@ -602,9 +602,9 @@ glabel btl_state_update_player_menu
/* 41AFC0 802A6230 8063D06B */ lb $v1, %lo(D_802AD06B)($v1)
/* 41AFC4 802A6234 00431021 */ addu $v0, $v0, $v1
/* 41AFC8 802A6238 00021080 */ sll $v0, $v0, 2
/* 41AFCC 802A623C 3C01802B */ lui $at, %hi(D_802AD0BB)
/* 41AFCC 802A623C 3C01802B */ lui $at, %hi(battle_menu_submenuIDs+0x3)
/* 41AFD0 802A6240 00220821 */ addu $at, $at, $v0
/* 41AFD4 802A6244 9022D0BB */ lbu $v0, %lo(D_802AD0BB)($at)
/* 41AFD4 802A6244 9022D0BB */ lbu $v0, %lo(battle_menu_submenuIDs+0x3)($at)
/* 41AFD8 802A6248 0C0A842E */ jal func_802A10B8
/* 41AFDC 802A624C A2C2004C */ sb $v0, 0x4c($s6)
/* 41AFE0 802A6250 080A9F71 */ j .L802A7DC4
@ -637,9 +637,9 @@ glabel btl_state_update_player_menu
/* 41B044 802A62B4 34C60004 */ ori $a2, $a2, 4
/* 41B048 802A62B8 2602FFFF */ addiu $v0, $s0, -1
/* 41B04C 802A62BC 00021080 */ sll $v0, $v0, 2
/* 41B050 802A62C0 3C01802B */ lui $at, %hi(D_802AD0BB)
/* 41B050 802A62C0 3C01802B */ lui $at, %hi(battle_menu_submenuIDs+0x3)
/* 41B054 802A62C4 00220821 */ addu $at, $at, $v0
/* 41B058 802A62C8 9022D0BB */ lbu $v0, %lo(D_802AD0BB)($at)
/* 41B058 802A62C8 9022D0BB */ lbu $v0, %lo(battle_menu_submenuIDs+0x3)($at)
/* 41B05C 802A62CC 0000982D */ daddu $s3, $zero, $zero
/* 41B060 802A62D0 A2C20048 */ sb $v0, 0x48($s6)
/* 41B064 802A62D4 A2C2004C */ sb $v0, 0x4c($s6)
@ -1148,9 +1148,9 @@ glabel btl_state_update_player_menu
/* 41B77C 802A69EC 24020001 */ addiu $v0, $zero, 1
.L802A69F0:
/* 41B780 802A69F0 00021080 */ sll $v0, $v0, 2
/* 41B784 802A69F4 3C01802B */ lui $at, %hi(D_802AD4B3)
/* 41B784 802A69F4 3C01802B */ lui $at, %hi(battle_menu_moveIndices+0x3)
/* 41B788 802A69F8 00220821 */ addu $at, $at, $v0
/* 41B78C 802A69FC 9022D4B3 */ lbu $v0, %lo(D_802AD4B3)($at)
/* 41B78C 802A69FC 9022D4B3 */ lbu $v0, %lo(battle_menu_moveIndices+0x3)($at)
/* 41B790 802A6A00 82C30048 */ lb $v1, 0x48($s6)
/* 41B794 802A6A04 A2C20049 */ sb $v0, 0x49($s6)
/* 41B798 802A6A08 00021600 */ sll $v0, $v0, 0x18
@ -1159,24 +1159,24 @@ glabel btl_state_update_player_menu
/* 41B7A4 802A6A14 904201DE */ lbu $v0, 0x1de($v0)
/* 41B7A8 802A6A18 14600004 */ bnez $v1, .L802A6A2C
/* 41B7AC 802A6A1C A6C2017C */ sh $v0, 0x17c($s6)
/* 41B7B0 802A6A20 3C02802B */ lui $v0, %hi(D_802AD603)
/* 41B7B4 802A6A24 9042D603 */ lbu $v0, %lo(D_802AD603)($v0)
/* 41B7B0 802A6A20 3C02802B */ lui $v0, %hi(battle_menu_moveOptionActive + 0x3)
/* 41B7B4 802A6A24 9042D603 */ lbu $v0, %lo(battle_menu_moveOptionActive + 0x3)($v0)
/* 41B7B8 802A6A28 A2C2004D */ sb $v0, 0x4d($s6)
.L802A6A2C:
/* 41B7BC 802A6A2C 82C30048 */ lb $v1, 0x48($s6)
/* 41B7C0 802A6A30 24020001 */ addiu $v0, $zero, 1
/* 41B7C4 802A6A34 14620004 */ bne $v1, $v0, .L802A6A48
/* 41B7C8 802A6A38 00000000 */ nop
/* 41B7CC 802A6A3C 3C02802B */ lui $v0, %hi(D_802AD603)
/* 41B7D0 802A6A40 9042D603 */ lbu $v0, %lo(D_802AD603)($v0)
/* 41B7CC 802A6A3C 3C02802B */ lui $v0, %hi(battle_menu_moveOptionActive + 0x3)
/* 41B7D0 802A6A40 9042D603 */ lbu $v0, %lo(battle_menu_moveOptionActive + 0x3)($v0)
/* 41B7D4 802A6A44 A2C2004E */ sb $v0, 0x4e($s6)
.L802A6A48:
/* 41B7D8 802A6A48 82C40048 */ lb $a0, 0x48($s6)
/* 41B7DC 802A6A4C 24020002 */ addiu $v0, $zero, 2
/* 41B7E0 802A6A50 14820007 */ bne $a0, $v0, .L802A6A70
/* 41B7E4 802A6A54 0080182D */ daddu $v1, $a0, $zero
/* 41B7E8 802A6A58 3C02802B */ lui $v0, %hi(D_802AD603)
/* 41B7EC 802A6A5C 9042D603 */ lbu $v0, %lo(D_802AD603)($v0)
/* 41B7E8 802A6A58 3C02802B */ lui $v0, %hi(battle_menu_moveOptionActive + 0x3)
/* 41B7EC 802A6A5C 9042D603 */ lbu $v0, %lo(battle_menu_moveOptionActive + 0x3)($v0)
/* 41B7F0 802A6A60 14640003 */ bne $v1, $a0, .L802A6A70
/* 41B7F4 802A6A64 A2C2004F */ sb $v0, 0x4f($s6)
/* 41B7F8 802A6A68 080A9FE1 */ j .L802A7F84
@ -1921,11 +1921,11 @@ glabel btl_state_update_player_menu
/* 41C280 802A74F0 24020001 */ addiu $v0, $zero, 1
.L802A74F4:
/* 41C284 802A74F4 00021080 */ sll $v0, $v0, 2
/* 41C288 802A74F8 3C01802B */ lui $at, %hi(D_802AD4B3)
/* 41C288 802A74F8 3C01802B */ lui $at, %hi(battle_menu_moveIndices+0x3)
/* 41C28C 802A74FC 00220821 */ addu $at, $at, $v0
/* 41C290 802A7500 9022D4B3 */ lbu $v0, %lo(D_802AD4B3)($at)
/* 41C294 802A7504 3C03802B */ lui $v1, %hi(D_802AD603)
/* 41C298 802A7508 9063D603 */ lbu $v1, %lo(D_802AD603)($v1)
/* 41C290 802A7500 9022D4B3 */ lbu $v0, %lo(battle_menu_moveIndices+0x3)($at)
/* 41C294 802A7504 3C03802B */ lui $v1, %hi(battle_menu_moveOptionActive + 0x3)
/* 41C298 802A7508 9063D603 */ lbu $v1, %lo(battle_menu_moveOptionActive + 0x3)($v1)
/* 41C29C 802A750C A2C20049 */ sb $v0, 0x49($s6)
/* 41C2A0 802A7510 0C0A89F4 */ jal func_802A27D0
/* 41C2A4 802A7514 A2C30052 */ sb $v1, 0x52($s6)
@ -2429,9 +2429,9 @@ glabel btl_state_update_player_menu
/* 41C9C8 802A7C38 24020001 */ addiu $v0, $zero, 1
.L802A7C3C:
/* 41C9CC 802A7C3C 00031080 */ sll $v0, $v1, 2
/* 41C9D0 802A7C40 3C01802B */ lui $at, %hi(D_802AD67B)
/* 41C9D0 802A7C40 3C01802B */ lui $at, %hi(D_802AD678 + 0x3)
/* 41C9D4 802A7C44 00220821 */ addu $at, $at, $v0
/* 41C9D8 802A7C48 9022D67B */ lbu $v0, %lo(D_802AD67B)($at)
/* 41C9D8 802A7C48 9022D67B */ lbu $v0, %lo(D_802AD678 + 0x3)($at)
/* 41C9DC 802A7C4C A2C30053 */ sb $v1, 0x53($s6)
/* 41C9E0 802A7C50 A2C20048 */ sb $v0, 0x48($s6)
/* 41C9E4 802A7C54 82C30048 */ lb $v1, 0x48($s6)

4
ver/us/asm/nonmatchings/415D90/btl_state_update_twink_menu.s
View File

@ -308,9 +308,9 @@ glabel btl_state_update_twink_menu
/* 41F29C 802AA50C 34C60008 */ ori $a2, $a2, 8
/* 41F2A0 802AA510 2602FFFF */ addiu $v0, $s0, -1
/* 41F2A4 802AA514 00021080 */ sll $v0, $v0, 2
/* 41F2A8 802AA518 3C01802B */ lui $at, %hi(D_802AD0BB)
/* 41F2A8 802AA518 3C01802B */ lui $at, %hi(battle_menu_submenuIDs+0x3)
/* 41F2AC 802AA51C 00220821 */ addu $at, $at, $v0
/* 41F2B0 802AA520 9022D0BB */ lbu $v0, %lo(D_802AD0BB)($at)
/* 41F2B0 802AA520 9022D0BB */ lbu $v0, %lo(battle_menu_submenuIDs+0x3)($at)
/* 41F2B4 802AA524 0C0A840C */ jal func_802A1030
/* 41F2B8 802AA528 A2420048 */ sb $v0, 0x48($s2)
/* 41F2BC 802AA52C 24020008 */ addiu $v0, $zero, 8

8
ver/us/asm/nonmatchings/415D90/func_802A11B0.s
View File

@ -67,8 +67,8 @@ glabel func_802A11B0
/* 416028 802A1298 3C013E99 */ lui $at, 0x3e99
/* 41602C 802A129C 3421999A */ ori $at, $at, 0x999a
/* 416030 802A12A0 44810000 */ mtc1 $at, $f0
/* 416034 802A12A4 3C04802B */ lui $a0, %hi(D_802AD0B3)
/* 416038 802A12A8 9084D0B3 */ lbu $a0, %lo(D_802AD0B3)($a0)
/* 416034 802A12A4 3C04802B */ lui $a0, %hi(D_802AD0B0+0x3)
/* 416038 802A12A8 9084D0B3 */ lbu $a0, %lo(D_802AD0B0+0x3)($a0)
/* 41603C 802A12AC 3C05802B */ lui $a1, %hi(main_menu_numOptions)
/* 416040 802A12B0 24A5D0AC */ addiu $a1, $a1, %lo(main_menu_numOptions)
/* 416044 802A12B4 3C01802B */ lui $at, %hi(D_802AD064)
@ -567,9 +567,9 @@ glabel func_802A11B0
/* 4167D4 802A1A44 82430000 */ lb $v1, ($s2)
/* 4167D8 802A1A48 00431021 */ addu $v0, $v0, $v1
/* 4167DC 802A1A4C 00021080 */ sll $v0, $v0, 2
/* 4167E0 802A1A50 3C03802B */ lui $v1, %hi(D_802AD0EB)
/* 4167E0 802A1A50 3C03802B */ lui $v1, %hi(battle_menu_isMessageDisabled+0x3)
/* 4167E4 802A1A54 00621821 */ addu $v1, $v1, $v0
/* 4167E8 802A1A58 9063D0EB */ lbu $v1, %lo(D_802AD0EB)($v1)
/* 4167E8 802A1A58 9063D0EB */ lbu $v1, %lo(battle_menu_isMessageDisabled+0x3)($v1)
/* 4167EC 802A1A5C 24020064 */ addiu $v0, $zero, 0x64
/* 4167F0 802A1A60 A2020000 */ sb $v0, ($s0)
/* 4167F4 802A1A64 3C01802B */ lui $at, %hi(D_802AD068)

8
ver/us/asm/nonmatchings/415D90/func_802A4A54.s
View File

@ -253,8 +253,8 @@ glabel func_802A4A54
/* 419B88 802A4DF8 82020000 */ lb $v0, ($s0)
/* 419B8C 802A4DFC 04410005 */ bgez $v0, .L802A4E14
/* 419B90 802A4E00 00000000 */ nop
/* 419B94 802A4E04 3C02802B */ lui $v0, %hi(D_802AD66F)
/* 419B98 802A4E08 9042D66F */ lbu $v0, %lo(D_802AD66F)($v0)
/* 419B94 802A4E04 3C02802B */ lui $v0, %hi(D_802AD66C + 0x3)
/* 419B98 802A4E08 9042D66F */ lbu $v0, %lo(D_802AD66C + 0x3)($v0)
/* 419B9C 802A4E0C 2442FFFF */ addiu $v0, $v0, -1
/* 419BA0 802A4E10 A2020000 */ sb $v0, ($s0)
.L802A4E14:
@ -333,9 +333,9 @@ glabel func_802A4A54
/* 419CAC 802A4F1C 2404021D */ addiu $a0, $zero, 0x21d
/* 419CB0 802A4F20 82020000 */ lb $v0, ($s0)
/* 419CB4 802A4F24 00021080 */ sll $v0, $v0, 2
/* 419CB8 802A4F28 3C03802B */ lui $v1, %hi(D_802AD6AA)
/* 419CB8 802A4F28 3C03802B */ lui $v1, %hi(D_802AD6A8 + 0x2)
/* 419CBC 802A4F2C 00621821 */ addu $v1, $v1, $v0
/* 419CC0 802A4F30 9463D6AA */ lhu $v1, %lo(D_802AD6AA)($v1)
/* 419CC0 802A4F30 9463D6AA */ lhu $v1, %lo(D_802AD6A8 + 0x2)($v1)
/* 419CC4 802A4F34 24020028 */ addiu $v0, $zero, 0x28
/* 419CC8 802A4F38 3C01802B */ lui $at, %hi(D_802AD604)
/* 419CCC 802A4F3C A022D604 */ sb $v0, %lo(D_802AD604)($at)

6
ver/us/splat.yaml
View File

@ -869,7 +869,7 @@ segments:
type: code
start: 0xFEE30
vram: 0x802DBD40
# follows_vram: evt
follows_vram: evt
subsegments:
- [0x0FEE30, c, sprite]
- [0x101B90, c, 101b90_len_8f0]
@ -925,6 +925,7 @@ segments:
type: code
start: 0x10CC10
vram: 0x802EB3D0
follows_vram: entity
subsegments:
- [0x10CC10, data] # font width data
- type: group
@ -1185,7 +1186,7 @@ segments:
- [0x1776B0, c, battle_cam]
- [0x17D6A0, c, 17D6A0]
- [0x17FEB0, c]
- [0x181810, c]
- [0x181810, c, 181810]
- [0x182B30, c, 182B30]
- [0x18C790, c, 18C790]
- [0x18F340, c, 18F340]
@ -2402,6 +2403,7 @@ segments:
- type: code
start: 0x316A70
vram: 0x80200080
follows_vram: 3169F0
subsegments:
- [0x316A70, c, 316a70]
- type: code

39
ver/us/symbol_addrs.txt
View File

@ -26647,7 +26647,6 @@ gPauseBadgesNumItems = 0x80270384; // type:data
D_80270388 = 0x80270388; // type:data
gPauseBadgesCurrentScrollPos = 0x8027038C; // type:data
gPauseBadgesTargetScrollPos = 0x80270390; // type:data
D_80270394 = 0x80270394; // type:data
gPauseBadgesTargetScrollIndex = 0x80270394; // type:data
gPauseBadgesLevel = 0x80270398; // type:data
gPauseBadgesCurrentTab = 0x8027039C; // type:data
@ -26655,13 +26654,10 @@ gPauseBadgesBShowNotEnoughBP = 0x802703A0; // type:data
gPauseBadgesShowNotEnoughBP = 0x802703A0; // type:data
D_802703A4 = 0x802703A4; // type:data
gPauseBadgesIconIDs = 0x802703A8; // type:data
D_802703FC = 0x802703FC; // type:data
gPauseItemsItemIDs = 0x80270400; // type:data
gPauseItemsCurrentPage = 0x802704C8; // type:data
D_802704CC = 0x802704CC; // type:data
gPauseItemsPages = 0x802704D0; // type:data
D_802704D1 = 0x802704D1; // type:data
D_802704D2 = 0x802704D2; // type:data
gPauseItemsSelectedIndex = 0x802705C0; // type:data
D_802705C4 = 0x802705C4; // type:data
gPauseItemsSelectedItem = 0x802705C8; // type:data
@ -26673,7 +26669,6 @@ gPauseItemsTargetScrollIndex = 0x802705DC; // type:data
gPauseItemsLevel = 0x802705E0; // type:data
gPauseItemsCurrentTab = 0x802705E4; // type:data
gPauseItemsIconIDs = 0x802705E8; // type:data
D_80270634 = 0x80270634; // type:data
gPausePartnersIconIDs = 0x80270640; // type:data
gPausePartnersSpriteIDs = 0x80270660; // type:data
gPausePartnersPartnerIdx = 0x80270680; // type:data
@ -26757,7 +26752,6 @@ D_80294440 = 0x80294440; // type:data
D_80294460 = 0x80294460; // type:data
D_802944A0 = 0x802944A0; // type:data
bSavedPartner = 0x8029DA30; // type:data
D_8029DA33 = 0x8029DA33; // type:data
bSavedOverrideFlags = 0x8029DA34; // type:data
D_8029DA40 = 0x8029DA40; // type:data
D_8029DA44 = 0x8029DA44; // type:data
@ -26772,7 +26766,6 @@ D_8029EFC0 = 0x8029EFC0; // type:data
D_8029EFE8 = 0x8029EFE8; // type:data
D_8029F010 = 0x8029F010; // type:data
D_8029F038 = 0x8029F038; // type:data
D_8029F236 = 0x8029F236; // type:data
D_8029F240 = 0x8029F240; // type:data
D_8029F244 = 0x8029F244; // type:data
D_8029F248 = 0x8029F248; // type:data
@ -26828,10 +26821,7 @@ gSpeakingActorIdleAnim = 0x8029FA70; //
gSpeakingActor = 0x8029FA74; //
gSpeakingActorPart = 0x8029FA78; //
D_8029FA80 = 0x8029FA80; // type:data
D_8029FA88 = 0x8029FA88; // type:data
D_8029FA90 = 0x8029FA90; // type:data
D_8029FAA8 = 0x8029FAA8; // type:data
D_8029FAC4 = 0x8029FAC4; // type:data
D_8029FAE8 = 0x8029FAE8; // type:data
D_8029FB48 = 0x8029FB48; // type:data
D_8029FB4C = 0x8029FB4C; // type:data
@ -27018,11 +27008,7 @@ battle_menu_messageIDs = 0x802AD090; // type:data
D_802AD0A8 = 0x802AD0A8; // type:data
main_menu_numOptions = 0x802AD0AC; // type:data
D_802AD0B0 = 0x802AD0B0; // type:data
D_802AD0B3 = 0x802AD0B3; // type:data
battle_menu_submenuIDs = 0x802AD0B8; // type:data
D_802AD0BB = 0x802AD0BB; // type:data
D_802AD0BC = 0x802AD0BC; // type:data
D_802AD0C0 = 0x802AD0C0; // type:data
battle_menu_isEnabled = 0x802AD0D0; // type:data
battle_menu_isMessageDisabled = 0x802AD0E8; // type:data
D_802AD0EB = 0x802AD0EB; // type:data
@ -27058,11 +27044,8 @@ battle_menu_moveOptionDisplayCostReductionColors = 0x802AD3E0; // type:data
battle_menu_moveOptionBPCosts = 0x802AD440; // type:data
battle_menu_hasSpiritsMenu = 0x802AD4A0; // type:data
battle_menu_moveOptionCount = 0x802AD4A4; // type:data
D_802AD4A7 = 0x802AD4A7; // type:data
D_802AD4A8 = 0x802AD4A8; // type:data
battle_menu_moveIndices = 0x802AD4B0; // type:data
D_802AD4B2 = 0x802AD4B2; // type:data
D_802AD4B3 = 0x802AD4B3; // type:data
battle_menu_moveOptionsEnabled = 0x802AD510; // type:data
battle_menu_moveOptionDescriptions = 0x802AD570; // type:data
battle_menu_moveOptionSortPriorities = 0x802AD5D0; // type:data
@ -27092,36 +27075,21 @@ D_802AD63E = 0x802AD63E; // type:data
D_802AD640 = 0x802AD640; // type:data
D_802AD658 = 0x802AD658; // type:data
D_802AD66C = 0x802AD66C; // type:data
D_802AD66F = 0x802AD66F; // type:data
D_802AD670 = 0x802AD670; // type:data
D_802AD673 = 0x802AD673; // type:data
D_802AD678 = 0x802AD678; // type:data
D_802AD67B = 0x802AD67B; // type:data
D_802AD690 = 0x802AD690; // type:data
D_802AD6A8 = 0x802AD6A8; // type:data
D_802AD6AA = 0x802AD6AA; // type:data
D_802AD6C0 = 0x802AD6C0; // type:data
D_802AD6D4 = 0x802AD6D4; // type:data
D_802B6240 = 0x802B6240; // type:data
D_802B62B0 = 0x802B62B0; // type:data
Munchlesia_LaunchVelocity = 0x802B62D0; // type:data
Munchlesia_LateralVelocity = 0x802B62D4; // type:data
Munchlesia_LaunchAccel = 0x802B62D8; // type:data
Munchlesia_LaunchYaw = 0x802B62DC; // type:data
D_802B62E0 = 0x802B62E0; // type:data
D_802B6730 = 0x802B6730; // type:data
D_802B6780 = 0x802B6780; // type:data
D_802B6784 = 0x802B6784; // type:data
D_802B6788 = 0x802B6788; // type:data
D_802B678C = 0x802B678C; // type:data
D_802B6790 = 0x802B6790; // type:data
D_802B6794 = 0x802B6794; // type:data
D_802B6798 = 0x802B6798; // type:data
D_802B679C = 0x802B679C; // type:data
D_802B68B0 = 0x802B68B0; // type:data
D_802B68B4 = 0x802B68B4; // type:data
D_802B68B8 = 0x802B68B8; // type:data
D_802B68BC = 0x802B68BC; // type:data
ParasolTransformation = 0x802B6E80; // type:data
SpinningFlower_EntityIndex = 0x802B6ED0; // type:data
D_802B6ED4 = 0x802B6ED4; // type:data
@ -27156,7 +27124,6 @@ D_802BFEF0 = 0x802BFEF0; // type:data
D_802BFEFC = 0x802BFEFC; // type:data
D_802BFF30 = 0x802BFF30; // type:data
D_802C0000 = 0x802C0000; // type:data
D_802C05CC = 0x802C05CC; // type:data
D_802D9D80 = 0x802D9D80; // type:data
gMapFlags = 0x802DA480; //
gMapVars = 0x802DA484; //
@ -27230,7 +27197,6 @@ D_802E9170 = 0x802E9170; // type:data
D_802E91F0 = 0x802E91F0; // type:data
D_802E9270 = 0x802E9270; // type:data
D_802E92B0 = 0x802E92B0; // type:data
D_802E99DC = 0x802E99DC; // type:data
D_802E9E54 = 0x802E9E54; // type:data
D_802E9E80 = 0x802E9E80; // type:data
Entity_InertYellowBlock = 0x802EA07C; // type:data
@ -27245,9 +27211,7 @@ D_802EA728 = 0x802EA728; // type:data
D_802EA744 = 0x802EA744; // type:data
D_802EA760 = 0x802EA760; // type:data
Entity_HeartBlockContent = 0x802EA7BC; // type:data
D_802EA862 = 0x802EA862; // type:data
D_802EA870 = 0x802EA870; // type:data
D_802EA871 = 0x802EA871; // type:data
Entity_SuperBlockContent = 0x802EA934; // type:data
D_802EAAE0 = 0x802EAAE0; // type:data
D_802EAB30 = 0x802EAB30; // type:data
@ -27328,7 +27292,6 @@ D_A6000000 = 0xA6000000; // type:data
D_B0000000 = 0xB0000000; // type:data
D_B0000008 = 0xB0000008; // type:data
D_B0000010 = 0xB0000010; // type:data
D_D9FCFFFF = 0xD9FCFFFF; // type:data
D_E0002760 = 0xE0002760; // type:data
D_E0002788 = 0xE0002788; // type:data
D_E00027B0 = 0xE00027B0; // type:data
@ -27952,11 +27915,9 @@ D_E0200724 = 0xE0200724; // type:data
D_E0200728 = 0xE0200728; // type:data
D_E020072C = 0xE020072C; // type:data
D_E0200730 = 0xE0200730; // type:data
D_E1000010 = 0xE1000010; // type:data
D_E7000008 = 0xE7000008; // type:data
D_E8000008 = 0xE8000008; // type:data
D_F0000008 = 0xF0000008; // type:data
D_F1FFFFFF = 0xF1FFFFFF; // type:data
D_F5000007 = 0xF5000007; // type:data
D_F79DDD0F = 0xF79DDD0F; // type:data
D_FA000028 = 0xFA000028; // type:data

373
ver/us/undefined_syms.txt
View File

@ -20,24 +20,20 @@ D_A6000000 = 0xA6000000;
D_B0000000 = 0xB0000000;
D_B0000008 = 0xB0000008;
D_B0000010 = 0xB0000010;
D_D9FCFFFF = 0xD9FCFFFF;
D_E1000010 = 0xE1000010;
D_E7000008 = 0xE7000008;
D_E8000008 = 0xE8000008;
D_F0000008 = 0xF0000008;
D_F1FFFFFF = 0xF1FFFFFF;
D_F5000007 = 0xF5000007;
D_F79DDD0F = 0xF79DDD0F;
D_FA000028 = 0xFA000028;
D_FD100008 = 0xFD100008;
D_7599F6D8 = 0x7599F6D8;
// Obfuscation symbols
obfuscated_battle_heap_create = battle_heap_create - 0xFEFFFFF;
obfuscated_general_heap_create = general_heap_create - 0xFEFEFEF;
obfuscated_load_engine_data = load_engine_data - 0x315;
obfuscated_create_audio_system = create_audio_system - 0x7B;
D_7599F6D8 = 0x7599F6D8;
D_F79DDD0F = 0xF79DDD0F;
fx_sun_undeclared = fx_sun;
@ -342,14 +338,31 @@ osTvType = 0x80000300;
osRomBase = 0x80000308;
osMemSize = 0x80000318;
gBackgroundImage = 0x80200000;
D_80200000 = 0x80200000;
D_8000030C = 0x8000030C;
D_8000031C = 0x8000031C;
D_800A08C0 = 0x800A08C0;
// effect tlb stuff
D_80197000 = 0x80197000;
D_801A6000 = 0x801A6000;
// heap stuff
D_801A7000 = 0x801A7000;
AuHeapBase = 0x801AA000;
heap_collisionHead = 0x80268000;
heap_generalHead = 0x802FB800;
gSpriteHeapPtr = 0x8034F800;
heap_battleHead = 0x803DA800;
D_80210000 = 0x80210000;
func_80242040_8B20B0 = 0x80242040;
spiked_goomba = 0x8021B0AC;
paragoomba = 0x8021CD00;
D_802C05CC = 0x802C05CC;
D_802442D0 = 0x802442D0;
D_802AB513 = 0x802AB513;
D_802E99DC = 0x802E99DC;
D_80247AF0_CCB300 = 0x80247AF0;
D_802491C0_CA70E0 = 0x802491C0;
D_80246568_C8C018 = 0x80246568;
@ -362,16 +375,9 @@ D_803B5000 = 0x803B5000;
D_802EF0D0 = 0x802EF0D0;
D_800FBB60 = 0x800FBB60;
D_800FBBE0 = 0x800FBBE0;
D_80200000 = 0x80200000;
D_8000030C = 0x8000030C;
D_8000031C = 0x8000031C;
D_800A08C0 = 0x800A08C0;
D_80164000 = 0x80164000;
D_80197000 = 0x80197000;
D_801A6000 = 0x801A6000;
D_801A7000 = 0x801A7000;
AuHeapBase = 0x801AA000;
D_80210000 = 0x80210000;
D_80164000 = 0x80164000; // display contexts, part of bss3
D_8022AD80_4C3F70 = 0x8022AD80;
D_8022ADD0 = 0x8022ADD0;
D_8022B550 = 0x8022B550;
@ -792,121 +798,10 @@ D_80262A70 = 0x80262A70;
mac_01_LetterDelivery_SavedNpcAnim = 0x80262C34;
D_80262C38 = 0x80262C38;
D_80262F68 = 0x80262F68;
heap_collisionHead = 0x80268000;
D_8027037C = 0x8027037C;
D_80270388 = 0x80270388;
D_80270394 = 0x80270394;
D_802703FC = 0x802703FC;
D_802704D1 = 0x802704D1;
D_802704D2 = 0x802704D2;
D_802705C4 = 0x802705C4;
D_802705D0 = 0x802705D0;
D_80270634 = 0x80270634;
bMarioHideAnims = 0x80283370;
bSavedPartner = 0x8029DA30;
D_8029DA33 = 0x8029DA33;
bSavedOverrideFlags = 0x8029DA34;
D_8029DA40 = 0x8029DA40;
D_8029DA44 = 0x8029DA44;
D_8029DA48 = 0x8029DA48;
D_8029DA4C = 0x8029DA4C;
D_8029DA50 = 0x8029DA50;
D_8029EFB0 = 0x8029EFB0;
D_8029EFB4 = 0x8029EFB4;
D_8029EFB8 = 0x8029EFB8;
D_8029EFBC = 0x8029EFBC;
D_8029EFC0 = 0x8029EFC0;
D_8029EFE8 = 0x8029EFE8;
D_8029F010 = 0x8029F010;
D_8029F038 = 0x8029F038;
D_8029F236 = 0x8029F236;
D_8029F240 = 0x8029F240;
D_8029F244 = 0x8029F244;
D_8029F248 = 0x8029F248;
D_8029F24C = 0x8029F24C;
D_8029F250 = 0x8029F250;
D_8029F254 = 0x8029F254;
D_8029F258 = 0x8029F258;
D_8029F25C = 0x8029F25C;
D_8029F260 = 0x8029F260;
D_8029F264 = 0x8029F264;
BattleCam_PosX = 0x8029F270;
BattleCam_PosY = 0x8029F274;
BattleCam_PosZ = 0x8029F278;
BattleCam_TargetActor = 0x8029F27C;
BattleCam_TargetActorPart = 0x8029F27E;
BattleCam_BoomLength = 0x8029F280;
BattleCam_BoomYaw = 0x8029F282;
BattleCam_BoomPitch = 0x8029F284;
BattleCam_BoomZOffset = 0x8029F286;
D_8029F288 = 0x8029F288;
BattleCam_InitialBoomLength = 0x8029F28C;
BattleCam_InitialBoomYaw = 0x8029F290;
BattleCam_InitialBoomPitch = 0x8029F294;
BattleCam_InitialBoomZOffset = 0x8029F298;
BattleCam_DoneMoving = 0x8029F29C;
BattleCam_MoveTimeLeft = 0x8029F29E;
BattleCam_MoveTimeTotal = 0x8029F2A0;
BattleCam_ModeY = 0x8029F2A2;
BattleCam_ModeX = 0x8029F2A3;
BattleCam_SetImmediately = 0x8029F2A4;
BattleCam_UseLinearInterp = 0x8029F2A5;
D_8029F2A6 = 0x8029F2A6;
D_8029F2A7 = 0x8029F2A7;
BattleCam_InitialPosX = 0x8029F2A8;
BattleCam_InitialPosY = 0x8029F2AC;
BattleCam_InitialPosZ = 0x8029F2B0;
BattleCam_ControlScript = 0x8029F2B4;
popupMessages = 0x8029F2C0;
D_8029F640 = 0x8029F640;
D_8029F642 = 0x8029F642;
D_8029F644 = 0x8029F644;
D_8029F646 = 0x8029F646;
D_8029F648 = 0x8029F648;
D_8029F64A = 0x8029F64A;
D_8029F64C = 0x8029F64C;
D_8029F64E = 0x8029F64E;
D_8029F650 = 0x8029F650;
gSpeakingActorPrintCtx = 0x8029FA60;
D_8029FA64 = 0x8029FA64;
gSpeakingActorPrintIsDone = 0x8029FA68;
gSpeakingActorTalkAnim = 0x8029FA6C;
gSpeakingActorIdleAnim = 0x8029FA70;
gSpeakingActor = 0x8029FA74;
gSpeakingActorPart = 0x8029FA78;
D_8029FA80 = 0x8029FA80;
D_8029FA88 = 0x8029FA88;
D_8029FA90 = 0x8029FA90;
D_8029FAA8 = 0x8029FAA8;
D_8029FAC4 = 0x8029FAC4;
D_8029FAE8 = 0x8029FAE8;
D_8029FB48 = 0x8029FB48;
D_8029FB4C = 0x8029FB4C;
D_8029FB50 = 0x8029FB50;
D_8029FB54 = 0x8029FB54;
D_8029FB60 = 0x8029FB60;
D_8029FB6C = 0x8029FB6C;
D_8029FB70 = 0x8029FB70;
D_8029FB74 = 0x8029FB74;
D_8029FB78 = 0x8029FB78;
D_8029FB7C = 0x8029FB7C;
D_8029FB80 = 0x8029FB80;
D_8029FB84 = 0x8029FB84;
D_8029FB88 = 0x8029FB88;
D_8029FB8C = 0x8029FB8C;
D_8029FB90 = 0x8029FB90;
D_8029FB94 = 0x8029FB94;
BattleMerleeOrbEffect = 0x8029FB98;
BattleMerleeWaveEffect = 0x8029FB9C;
D_8029FBA0 = 0x8029FBA0;
D_8029FBA4 = 0x8029FBA4;
D_8029FBA8 = 0x8029FBA8;
D_8029FBAC = 0x8029FBAC;
D_8029FBB0 = 0x8029FBB0;
D_8029FBC0 = 0x8029FBC0;
D_8029FBD0 = 0x8029FBD0;
D_8029FBD4 = 0x8029FBD4;
// more bss for 16c8e0's segment
gActionCommandStatus = 0x8029FBE0;
D_802A19B0 = 0x802A19B0;
D_802A19C0 = 0x802A19C0;
D_802A1A90 = 0x802A1A90;
@ -956,223 +851,16 @@ D_802AA320 = 0x802AA320;
D_802AA694 = 0x802AA694;
D_802AAA08 = 0x802AAA08;
D_802AAA30 = 0x802AAA30;
D_802ACC60 = 0x802ACC60;
D_802ACC64 = 0x802ACC64;
D_802ACC68 = 0x802ACC68;
D_802ACC6C = 0x802ACC6C;
D_802ACC70 = 0x802ACC70;
D_802ACCD0 = 0x802ACCD0;
D_802ACFE8 = 0x802ACFE8;
D_802ACFEC = 0x802ACFEC;
D_802ACFF0 = 0x802ACFF0;
D_802ACFF4 = 0x802ACFF4;
D_802ACFFC = 0x802ACFFC;
D_802ACFFD = 0x802ACFFD;
D_802AD000 = 0x802AD000;
D_802AD001 = 0x802AD001;
D_802AD002 = 0x802AD002;
D_802AD003 = 0x802AD003;
D_802AD004 = 0x802AD004;
D_802AD006 = 0x802AD006;
D_802AD008 = 0x802AD008;
D_802AD00A = 0x802AD00A;
D_802AD010 = 0x802AD010;
D_802AD028 = 0x802AD028;
D_802AD040 = 0x802AD040;
D_802AD044 = 0x802AD044;
D_802AD048 = 0x802AD048;
D_802AD04C = 0x802AD04C;
D_802AD050 = 0x802AD050;
D_802AD054 = 0x802AD054;
D_802AD058 = 0x802AD058;
D_802AD05C = 0x802AD05C;
D_802AD060 = 0x802AD060;
D_802AD064 = 0x802AD064;
D_802AD068 = 0x802AD068;
D_802AD069 = 0x802AD069;
D_802AD06A = 0x802AD06A;
D_802AD06B = 0x802AD06B;
D_802AD06C = 0x802AD06C;
D_802AD070 = 0x802AD070;
main_battle_menu_JumpHudScripts = 0x802AD078;
battle_menu_messageIDs = 0x802AD090;
D_802AD0A8 = 0x802AD0A8;
main_menu_numOptions = 0x802AD0AC;
D_802AD0B0 = 0x802AD0B0;
D_802AD0B3 = 0x802AD0B3;
battle_menu_submenuIDs = 0x802AD0B8;
D_802AD0BB = 0x802AD0BB;
D_802AD0BC = 0x802AD0BC;
D_802AD0C0 = 0x802AD0C0;
battle_menu_isEnabled = 0x802AD0D0;
battle_menu_isMessageDisabled = 0x802AD0E8;
D_802AD0EB = 0x802AD0EB;
D_802AD100 = 0x802AD100;
D_802AD104 = 0x802AD104;
battle_menu_moveState = 0x802AD108;
battle_menu_moveCursorPos = 0x802AD109;
D_802AD10A = 0x802AD10A;
D_802AD10B = 0x802AD10B;
battle_menu_moveScrollLine = 0x802AD10C;
D_802AD10D = 0x802AD10D;
D_802AD10E = 0x802AD10E;
D_802AD10F = 0x802AD10F;
battle_menu_moveScrollOffset = 0x802AD110;
D_802AD112 = 0x802AD112;
battle_menu_moveTextColor = 0x802AD114;
battle_menu_moveTextOpacity = 0x802AD116;
battle_menu_moveCursorIcon = 0x802AD118;
battle_menu_moveUpArrowIcon = 0x802AD11C;
battle_menu_moveDownArrowIcon = 0x802AD120;
battle_menu_moveOptionIconIDs = 0x802AD128;
battle_menu_moveTitleIcon = 0x802AD188;
battle_menu_moveOptionCostUnitIconIDs = 0x802AD190;
battle_menu_moveX = 0x802AD1F0;
battle_menu_moveY = 0x802AD1F2;
battle_menu_moveOptionIndexMap = 0x802AD1F8;
D_802AD258 = 0x802AD258;
battle_menu_moveOptionIconScripts = 0x802AD260;
battle_menu_moveOptionNames = 0x802AD2C0;
battle_menu_moveOptionDisplayCosts = 0x802AD320;
battle_menu_moveOptionDisplayCostReductions = 0x802AD380;
battle_menu_moveOptionDisplayCostReductionColors = 0x802AD3E0;
battle_menu_moveOptionBPCosts = 0x802AD440;
battle_menu_hasSpiritsMenu = 0x802AD4A0;
battle_menu_moveOptionCount = 0x802AD4A4;
D_802AD4A7 = 0x802AD4A7;
D_802AD4A8 = 0x802AD4A8;
battle_menu_moveIndices = 0x802AD4B0;
D_802AD4B2 = 0x802AD4B2;
D_802AD4B3 = 0x802AD4B3;
battle_menu_moveOptionsEnabled = 0x802AD510;
battle_menu_moveOptionDescriptions = 0x802AD570;
battle_menu_moveOptionSortPriorities = 0x802AD5D0;
battle_menu_moveOptionCantUseTypes = 0x802AD5E8;
battle_menu_moveOptionActive = 0x802AD600;
D_802AD603 = 0x802AD603;
D_802AD604 = 0x802AD604;
D_802AD605 = 0x802AD605;
D_802AD606 = 0x802AD606;
D_802AD607 = 0x802AD607;
D_802AD608 = 0x802AD608;
D_802AD609 = 0x802AD609;
D_802AD60A = 0x802AD60A;
D_802AD60B = 0x802AD60B;
D_802AD60C = 0x802AD60C;
D_802AD60E = 0x802AD60E;
D_802AD610 = 0x802AD610;
D_802AD612 = 0x802AD612;
D_802AD614 = 0x802AD614;
D_802AD618 = 0x802AD618;
D_802AD61C = 0x802AD61C;
D_802AD620 = 0x802AD620;
D_802AD624 = 0x802AD624;
D_802AD628 = 0x802AD628;
D_802AD63C = 0x802AD63C;
D_802AD63E = 0x802AD63E;
D_802AD640 = 0x802AD640;
D_802AD658 = 0x802AD658;
D_802AD66C = 0x802AD66C;
D_802AD66F = 0x802AD66F;
D_802AD670 = 0x802AD670;
D_802AD673 = 0x802AD673;
D_802AD678 = 0x802AD678;
D_802AD67B = 0x802AD67B;
D_802AD690 = 0x802AD690;
D_802AD6A8 = 0x802AD6A8;
D_802AD6AA = 0x802AD6AA;
D_802AD6C0 = 0x802AD6C0;
D_802AD6D4 = 0x802AD6D4;
D_802B6240 = 0x802B6240;
D_802B62B0 = 0x802B62B0;
Munchlesia_LaunchVelocity = 0x802B62D0;
Munchlesia_LateralVelocity = 0x802B62D4;
Munchlesia_LaunchAccel = 0x802B62D8;
Munchlesia_LaunchYaw = 0x802B62DC;
D_802B62E0 = 0x802B62E0;
D_802B6730 = 0x802B6730;
D_802B6770_E27C80 = 0x802B6770;
D_802B6780 = 0x802B6780;
D_802B6784 = 0x802B6784;
D_802B6788 = 0x802B6788;
D_802B678C = 0x802B678C;
D_802B6790 = 0x802B6790;
D_802B6794 = 0x802B6794;
D_802B6798 = 0x802B6798;
D_802B679C = 0x802B679C;
D_802B68B0 = 0x802B68B0;
D_802B68B4 = 0x802B68B4;
D_802B68B8 = 0x802B68B8;
D_802B68BC = 0x802B68BC;
ParasolTransformation = 0x802B6E80;
D_802B6E90_E2A300 = 0x802B6E90;
SpinningFlower_EntityIndex = 0x802B6ED0;
D_802B6ED4 = 0x802B6ED4;
D_802B6ED8 = 0x802B6ED8;
D_802B6EDC = 0x802B6EDC;
D_802B6EE0 = 0x802B6EE0;
D_802B6EE4 = 0x802B6EE4;
D_802B6EE8 = 0x802B6EE8;
SpinningFlower_AngleToCenter = 0x802B6EEC;
D_802B6EF0 = 0x802B6EF0;
D_802B6EF4 = 0x802B6EF4;
mdl_clearRenderTasks = 0x802B7E00;
D_802C0000 = 0x802C0000;
D_802C05CC = 0x802C05CC;
gMapFlags = 0x802DA480;
gMapVars = 0x802DA484;
gNumScripts = 0x802DA488;
gWorldScriptList = 0x802DA490;
gBattleScriptList = 0x802DA690;
gCurrentScriptListPtr = 0x802DA890;
gScriptIndexList = 0x802DA898;
gScriptIdList = 0x802DAA98;
gScriptListCount = 0x802DAC98;
evtDebugPrintBuffer = 0x802DACA0;
gLavaResetList = 0x802DADA0;
D_802DADA4 = 0x802DADA4;
gBattleMeshAnimationList = 0x802DADB0;
gWorldMeshAnimationList = 0x802DADF0;
gCurrentMeshAnimationListPtr = 0x802DAE30;
wExtraPartnerID = 0x802DAE40;
wExtraPartnerNpcID = 0x802DAE44;
D_802DAE50 = 0x802DAE50;
D_802DAE54 = 0x802DAE54;
gCurrentPrintContext = 0x802DB260;
D_802DB264 = 0x802DB264;
D_802DB268 = 0x802DB268;
D_802DB5B0 = 0x802DB5B0;
D_802DB5C0 = 0x802DB5C0;
D_802DB6C0 = 0x802DB6C0;
D_802DB7C0 = 0x802DB7C0;
MusicEventList = 0x802DB7D0;
RunningMusicEvents = 0x802DB7D8;
RunningMusicEventIDs = 0x802DB800;
D_802DB830 = 0x802DB830;
D_802DBB60 = 0x802DBB60;
D_802DBB68 = 0x802DBB68;
gWorldMapFlags = 0x802DBC70;
DoorModelsSwingCW = 0x802DBC7C;
D_802DBC88 = 0x802DBC88;
gWorldMapVars = 0x802DBCA8;
gBattleMapVars = 0x802DBCE8;
DoorModelsSwingCCW = 0x802DBD28;
gBattleMapFlags = 0x802DBD34;
SaveBlockTutorialPrinterClosed = 0x802EB390;
SaveBlockResultPrinterClosed = 0x802EB394;
SaveBlockTutorialPrinter = 0x802EB398;
SaveBlockResultPrinter = 0x802EB39C;
SwitchToLink = 0x802EB3A0;
TriggerBlockVanishEffect = 0x802EB3B0;
HeartBlockPrinterClosed = 0x802EB3C0;
D_802ED970 = 0x802ED970;
D_802EE8D0 = 0x802EE8D0;
D_802F39D0 = 0x802F39D0;
D_802F4560 = 0x802F4560;
heap_generalHead = 0x802FB800;
gSpriteHeapPtr = 0x8034F800;
heap_battleHead = 0x803DA800;
D_802465D0_kzn_02 = 0x802465D0;
D_80247420_kzn_03 = 0x80247420;
D_80248380_kzn_19 = 0x80248380;
@ -1190,8 +878,5 @@ D_80246560_kkj_19 = 0x80246560;
end_01_CreditsProjMatrices = 0x8024B9D0;
end_01_CreditsDataPtr = 0x8024A2C4;
D_80242568_filemenu = 0x80242568;
D_802EA871 = 0x802EA871;
D_802EA862 = 0x802EA862;
D_802EA862 = 0x802EA862;
D_80243390_omo_12 = 0x80243390;
D_8024F580_hos_05 = 0x8024F580;