A few f_pc files (#26)

* f_pc_base, one non matching

* some of f_pc_manager

* f_pc_node OK

* f_pc_pause partly

* started node_req

* more progress

* most of node req

* delete unused asm

* node req header and param names

* param renaming

* header for manager

* review comment struct names

* fpcM_Management OK

* int -> s32

* merge master

* most of f_pc_create_iter

* f_pc_stdcreate_req OK

* f_pc_fstcreate OK

* f_pc_leaf OK

* f_pc_draw OK

* f_pc_deletor partly

* fix parameter type in f_pc_pause

* review

* review, use cPh enum and fix process_profile_definition struct

* convert f_pc files to C

* matched more functions

* fix global.h

* fix variable types

* format

* mpre Phs enum

* fix merge errors

* fix gamepad stopPatternedRumble

* format

* delete leftover files from merge

* move asm to correct folder

* revert f_pc from C to CPP

* remove C hacks and format

* format

* OK

include/f/f_pc/asm/80020A40.s

@@ -0,0 +1,23 @@
+/* 80020A40 0001D980  94 21 FF F0 */	stwu r1, -0x10(r1)
+/* 80020A44 0001D984  7C 08 02 A6 */	mflr r0
+/* 80020A48 0001D988  90 01 00 14 */	stw r0, 0x14(r1)
+/* 80020A4C 0001D98C  7C 85 23 78 */	mr r5, r4
+/* 80020A50 0001D990  80 83 00 0C */	lwz r4, 0xc(r3)
+/* 80020A54 0001D994  80 64 00 44 */	lwz r3, 0x44(r4)
+/* 80020A58 0001D998  80 63 00 0C */	lwz r3, 0xc(r3)
+/* 80020A5C 0001D99C  80 05 00 00 */	lwz r0, 0(r5)
+/* 80020A60 0001D9A0  7C 03 00 40 */	cmplw r3, r0
+/* 80020A64 0001D9A4  40 82 00 1C */	bne lbl_80020A80
+/* 80020A68 0001D9A8  80 64 00 40 */	lwz r3, 0x40(r4)
+/* 80020A6C 0001D9AC  80 85 00 08 */	lwz r4, 8(r5)
+/* 80020A70 0001D9B0  81 85 00 04 */	lwz r12, 4(r5)
+/* 80020A74 0001D9B4  7D 89 03 A6 */	mtctr r12
+/* 80020A78 0001D9B8  4E 80 04 21 */	bctrl 
+/* 80020A7C 0001D9BC  48 00 00 08 */	b lbl_80020A84
+lbl_80020A80:
+/* 80020A80 0001D9C0  38 60 00 00 */	li r3, 0
+lbl_80020A84:
+/* 80020A84 0001D9C4  80 01 00 14 */	lwz r0, 0x14(r1)
+/* 80020A88 0001D9C8  7C 08 03 A6 */	mtlr r0
+/* 80020A8C 0001D9CC  38 21 00 10 */	addi r1, r1, 0x10
+/* 80020A90 0001D9D0  4E 80 00 20 */	blr 

include/f/f_pc/asm/80023844.s

@@ -0,0 +1,9 @@
+/* 80023844 00020784  54 84 06 3E */	clrlwi r4, r4, 0x18
+/* 80023848 00020788  88 03 00 0B */	lbz r0, 0xb(r3)
+/* 8002384C 0002078C  7C 80 00 38 */	and r0, r4, r0
+/* 80023850 00020790  7C 64 00 50 */	subf r3, r4, r0
+/* 80023854 00020794  30 03 FF FF */	addic r0, r3, -1
+/* 80023858 00020798  7C 00 19 10 */	subfe r0, r0, r3
+/* 8002385C 0002079C  7C 00 00 34 */	cntlzw r0, r0
+/* 80023860 000207A0  54 03 D9 7E */	srwi r3, r0, 5
+/* 80023864 000207A4  4E 80 00 20 */	blr 

include/f/f_pc/f_pc_base.h

@@ -3,40 +3,49 @@
 #define F_PC_BASE_H
 
 #include "SComponent/c_tag.h"
+#include "global.h"
+// #include "f/f_pc/f_pc_method.h"
 #include "f/f_pc/f_pc_delete_tag.h"
 #include "f/f_pc/f_pc_layer_tag.h"
 #include "f/f_pc/f_pc_line_tag.h"
 #include "f/f_pc/f_pc_priority.h"
-#include "global.h"
+#include "f/f_pc/f_pc_profile.h"
 
 struct create_request;
 struct profile_method_class;
 
-struct base_process_class {
+typedef struct base_process_class {
     u32 mBsType;
     u32 mBsPcId;
     s16 mProcName;
-    u8 mUnk0;
+    s8 mUnk0;
     u8 mPauseFlag;
     s8 mInitState;
     u8 mUnk2;
     s16 mBsTypeId;
-    void* mpProf;
-    create_request* mpCtRq;
+    process_profile_definition* mpProf;
+    struct create_request* mpCtRq;
     layer_management_tag_class mLyTg;
     line_tag mLnTg;
     delete_tag_class mDtTg;
     process_priority_class mPi;
-    profile_method_class* mpPcMtd;
+    process_method_class* mpPcMtd;
     void* mpUserData;
     u32 mParameters;
     u32 mSubType;
-};
+} base_process_class;
 
 extern "C" {
 
-int fpcBs_Is_JustOfType(int a, int b);
-int fpcBs_Execute(base_process_class* pProc);
+BOOL fpcBs_Is_JustOfType(s32 pType1, s32 pType2);
+s32 fpcBs_MakeOfType(s32* pType);
+s32 fpcBs_MakeOfId(void);
+s32 fpcBs_Execute(base_process_class* pProc);
+void fpcBs_DeleteAppend(base_process_class* pProc);
+s32 fpcBs_IsDelete(base_process_class* pProc);
+s32 fpcBs_Delete(base_process_class* pProc);
+base_process_class* fpcBs_Create(s16 pProcTypeID, u32 pProcID, void* pData);
+s32 fpcBs_SubCreate(base_process_class* pProc);
 };
 
 #endif

include/f/f_pc/f_pc_create_iter.h

@@ -2,12 +2,33 @@
 #ifndef F_PC_CREATE_ITER_H
 #define F_PC_CREATE_ITER_H
 
-#include "SComponent/c_node_iter.h"
+#include "SComponent/c_list_iter.h"
+#include "SComponent/c_tag_iter.h"
+#include "f/f_pc/f_pc_create_tag.h"
+#include "global.h"
+
+typedef struct node_method_data {
+    cNdIt_MethodFunc mFunc;
+    void* mpUserData;
+} node_method_data;
+
+typedef struct node_judge_data {
+    cNdIt_JudgeFunc mFunc;
+    void* mpUserData;
+} node_judge_data;
+
+typedef struct fpcCtIt_jilprm_c {
+    u32 mUnk0;
+    cNdIt_JudgeFunc mFunc;
+    void* mpUserData;
+} fpcCtIt_jilprm_c;
 
 extern "C" {
 
-int fpcCtIt_Method(cNdIt_MethodFunc pJudge, void* pUserData);
+s32 fpcCtIt_Method(cNdIt_MethodFunc pJudge, void* pUserData);
 void* fpcCtIt_Judge(cNdIt_JudgeFunc pJudge, void* pUserData);
+void* fpcCtIt_filter_JudgeInLayer(create_tag*, fpcCtIt_jilprm_c*);
+void* fpcCtIt_JudgeInLayer(u32 pUnk0, cNdIt_JudgeFunc pFunc, void* pUserData);
 };
 
 #endif

include/f/f_pc/f_pc_create_req.h

@@ -5,41 +5,42 @@
 #include "SComponent/c_phase.h"
 #include "SComponent/c_tag.h"
 #include "f/f_pc/f_pc_create_tag.h"
+#include "f/f_pc/f_pc_layer.h"
 #include "f/f_pc/f_pc_method.h"
 #include "f/f_pc/f_pc_method_tag.h"
 #include "global.h"
 
 struct base_process_class;
-struct layer_class;
 
-struct create_request_method_class {
+typedef struct create_request_method_class {
     cPhs__Handler mpHandler;
     process_method_func mpCancel;
     process_method_func mpDelete;
-};
+} create_request_method_class;
 
-struct create_request : public create_tag {
+typedef struct create_request {
+    create_tag mBase;
     s8 mbIsCreating;
     s8 mbIsCancelling;
     process_method_tag_class mMtdTg;
     create_request_method_class* mpCtRqMtd;
     void* mpUnk1;
-    int mBsPcId;
-    base_process_class* mpRes;
+    s32 mBsPcId;
+    struct base_process_class* mpRes;
     layer_class* mpLayer;
-};
+} create_request;  // Size: 0x48
 
 extern "C" {
 
-bool fpcCtRq_isCreatingByID(create_tag* pTag, int* pId);
-bool fpcCtRq_IsCreatingByID(unsigned int id);
+BOOL fpcCtRq_isCreatingByID(create_tag* pTag, s32* pId);
+BOOL fpcCtRq_IsCreatingByID(u32 id);
 void fpcCtRq_CreateQTo(create_request* pReq);
 void fpcCtRq_ToCreateQ(create_request* pReq);
-bool fpcCtRq_Delete(create_request* pReq);
-bool fpcCtRq_Cancel(create_request* pReq);
-int fpcCtRq_IsDoing(create_request* pReq);
+BOOL fpcCtRq_Delete(create_request* pReq);
+BOOL fpcCtRq_Cancel(create_request* pReq);
+s32 fpcCtRq_IsDoing(create_request* pReq);
 void fpcCtRq_Handler(void);
-create_request* fpcCtRq_Create(layer_class* pLayer, unsigned long size,
+create_request* fpcCtRq_Create(layer_class* pLayer, u32 size,
                                create_request_method_class* pCtRqMtd);
 };
 

include/f/f_pc/f_pc_create_tag.h

@@ -5,13 +5,15 @@
 #include "SComponent/c_tag.h"
 #include "global.h"
 
-struct create_tag : public create_tag_class {};
+typedef struct create_tag {
+    create_tag_class mBase;
+} create_tag;
 
 extern "C" {
 
 void fpcCtTg_ToCreateQ(create_tag_class* pTag);
 void fpcCtTg_CreateQTo(create_tag_class* pTag);
-int fpcCtTg_Init(create_tag* pTag, void* pUserData);
+s32 fpcCtTg_Init(create_tag* pTag, void* pUserData);
 };
 
 #endif

include/f/f_pc/f_pc_creator.h

@@ -8,9 +8,9 @@ struct base_process_class;
 
 extern "C" {
 
-bool fpcCt_IsCreatingByID(unsigned int id);
-int fpcCt_IsDoing(base_process_class* pProc);
-void fpcCt_Abort(base_process_class* pProc);
+BOOL fpcCt_IsCreatingByID(u32 id);
+s32 fpcCt_IsDoing(struct base_process_class* pProc);
+BOOL fpcCt_Abort(struct base_process_class* pProc);
 void fpcCt_Handler(void);
 };
 

include/f/f_pc/f_pc_delete_tag.h

@@ -3,24 +3,24 @@
 #define F_PC_DELETE_TAG_H
 
 #include "SComponent/c_tag.h"
+#include "f/f_pc/f_pc_layer.h"
 #include "global.h"
 
-struct layer_class;
+typedef s32 (*delete_tag_func)(void*);
 
-typedef int (*delete_tag_func)(void*);
-
-struct delete_tag_class : public create_tag_class {
+typedef struct delete_tag_class {
+    create_tag_class mBase;
     layer_class* mpLayer;
     s16 mTimer;
-};
+} delete_tag_class;
 
 extern "C" {
 
-bool fpcDtTg_IsEmpty(delete_tag_class* pTag);
+BOOL fpcDtTg_IsEmpty(void);
 void fpcDtTg_ToDeleteQ(delete_tag_class* pTag);
 void fpcDtTg_DeleteQTo(delete_tag_class* pTag);
-int fpcDtTg_Do(delete_tag_class* pTag, delete_tag_func pFunc);
-int fpcDtTg_Init(delete_tag_class* pTag, void* pUserData);
+s32 fpcDtTg_Do(delete_tag_class* pTag, delete_tag_func pFunc);
+s32 fpcDtTg_Init(delete_tag_class* pTag, void* pUserData);
 };
 
 #endif

include/f/f_pc/f_pc_deletor.h

@@ -2,17 +2,17 @@
 #ifndef F_PC_DELETOR_H
 #define F_PC_DELETOR_H
 
-#include "global.h"
+#include "f/f_pc/f_pc_base.h"
 
 struct base_process_class;
 
 extern "C" {
 
-bool fpcDt_IsComplete(void);
-int fpcDt_ToDeleteQ(base_process_class* pProc);
-int fpcDt_ToQueue(base_process_class* pProc);
+BOOL fpcDt_IsComplete(void);
+s32 fpcDt_ToDeleteQ(base_process_class* pProc);
+s32 fpcDt_ToQueue(base_process_class* pProc);
 void fpcDt_Handler(void);
-int fpcDt_Delete(base_process_class* pProc);
+s32 fpcDt_Delete(base_process_class* pProc);
 };
 
 #endif

include/f/f_pc/f_pc_draw.h

@@ -0,0 +1,16 @@
+#ifndef F_PC_DRAW_H
+#define F_PC_DRAW_H
+
+#include "SComponent/c_node_iter.h"
+#include "f/f_pc/f_pc_base.h"
+#include "global.h"
+
+typedef s32 (*cNdIt_MethodFuncFunc)(cNdIt_MethodFunc);
+
+extern "C" {
+
+s32 fpcDw_Execute(base_process_class* pProc);
+s32 fpcDw_Handler(cNdIt_MethodFuncFunc param_1, cNdIt_MethodFunc param_2);
+};
+
+#endif

include/f/f_pc/f_pc_draw_priority.h

@@ -2,15 +2,17 @@
 #ifndef F_PC_DRAW_PRIORITY_H
 #define F_PC_DRAW_PRIORITY_H
 
-struct draw_priority_class {
-    short mPriority;
-};
+#include "global.h"
+
+typedef struct draw_priority_class {
+    s16 mPriority;
+} draw_priority_class;
 
 extern "C" {
 
-int fpcDwPi_Get(draw_priority_class* pDwPi);
-void fpcDwPi_Set(draw_priority_class* pDwPi, int p);
-void fpcDwPi_Init(draw_priority_class* pDwPi, int p);
+s32 fpcDwPi_Get(draw_priority_class* pDwPi);
+void fpcDwPi_Set(draw_priority_class* pDwPi, s32 p);
+void fpcDwPi_Init(draw_priority_class* pDwPi, s32 p);
 };
 
 #endif

include/f/f_pc/f_pc_executor.h

@@ -3,14 +3,17 @@
 #define F_PC_EXECUTOR_H
 
 #include "SComponent/c_node_iter.h"
-
-struct base_process_class;
+#include "f/f_pc/f_pc_base.h"
 
 extern "C" {
 
-int fpcEx_ToLineQ(base_process_class* pProc);
-int fpcEx_ExecuteQTo(base_process_class* pProc);
-int fpcEx_ToExecuteQ(base_process_class* pProc);
+base_process_class* fpcEx_Search(void* pFunc, void* pUserData);
+base_process_class* fpcEx_SearchByID(u32 id);
+BOOL fpcEx_IsExist(s32 id);
+s32 fpcEx_ToLineQ(base_process_class* pProc);
+s32 fpcEx_ExecuteQTo(base_process_class* pProc);
+s32 fpcEx_Execute(base_process_class* pProc);
+s32 fpcEx_ToExecuteQ(base_process_class* pProc);
 void fpcEx_Handler(cNdIt_MethodFunc pFunc);
 };
 

include/f/f_pc/f_pc_fstcreate_req.h

@@ -0,0 +1,26 @@
+#ifndef F_PC_FSTCREATE_REQ_H
+#define F_PC_FSTCREATE_REQ_H
+
+#include "f/f_pc/f_pc_base.h"
+#include "f/f_pc/f_pc_create_req.h"
+#include "f/f_pc/f_pc_layer.h"
+#include "global.h"
+
+typedef s32 (*fstCreateFunc)(void*, void*);
+
+typedef struct fast_create_request {
+    /* 0x00 */ create_request mBase;
+    /* 0x48 */ fstCreateFunc mpFastCreateFunc;
+    /* 0x4C */ void* mpFastCreateData;
+} fast_create_request;  // Size: 0x50
+
+extern "C" {
+
+s32 fpcFCtRq_Do(fast_create_request* pFstCreateReq);
+s32 fpcFCtRq_Delete(fast_create_request*);
+base_process_class* fpcFCtRq_Request(layer_class* pLayer, s16 pProcTypeID,
+                                     fstCreateFunc pFastCreateFunc, void* pFastCreateData,
+                                     void* pData);
+};
+
+#endif

include/f/f_pc/f_pc_layer.h

@@ -8,49 +8,50 @@
 #include "global.h"
 
 struct process_method_tag_class;
-struct process_node_class;
+typedef struct process_node_class process_node_class;
 
-struct layer_class {
-    node_class mNode;  // generates different asm for struct copy if using inheritance
+typedef struct layer_class {
+    node_class mNode;
     u32 mLayerID;
     node_lists_tree_class mNodeListTree;
     process_node_class* mpPcNode;
     node_list_class mCancelList;
-    s32 mCreatingCount : 16;  // for some reason, the compiler only optimized these into a single
-                              // word load/store instead of 2 halfword load/store, but only if they
-                              // are written like this
-    s32 mDeletingCount : 16;
-};
+    struct {
+        s16 mCreatingCount;
+        s16 mDeletingCount;
+    } counts;
+} layer_class;
 
 extern "C" {
 
 void fpcLy_SetCurrentLayer(layer_class* pLayer);
 layer_class* fpcLy_CurrentLayer(void);
 layer_class* fpcLy_RootLayer(void);
-layer_class* fpcLy_Layer(unsigned int id);
-layer_class* fpcLy_Search(unsigned int id);
+layer_class* fpcLy_Layer(u32 id);
+layer_class* fpcLy_Search(u32 id);
 void fpcLy_Regist(layer_class* pLayer);
 
 void fpcLy_CreatedMesg(layer_class* pLayer);
 void fpcLy_CreatingMesg(layer_class* pLayer);
 void fpcLy_DeletedMesg(layer_class* pLayer);
 void fpcLy_DeletingMesg(layer_class* pLayer);
-bool fpcLy_IsCreatingMesg(layer_class* pLayer);
-bool fpcLy_IsDeletingMesg(layer_class* pLayer);
+BOOL fpcLy_IsCreatingMesg(layer_class* pLayer);
+BOOL fpcLy_IsDeletingMesg(layer_class* pLayer);
 
-int fpcLy_IntoQueue(layer_class* pLayer, int treeListIdx, create_tag_class* pTag, int idx);
-int fpcLy_ToQueue(layer_class* pLayer, int treeListIdx, create_tag_class* pTag);
-int fpcLy_QueueTo(layer_class* pLayer, create_tag_class* pTag);
+s32 fpcLy_IntoQueue(layer_class* pLayer, s32 treeListIdx, create_tag_class* pTag, s32 idx);
+s32 fpcLy_ToQueue(layer_class* pLayer, s32 treeListIdx, create_tag_class* pTag);
+s32 fpcLy_QueueTo(layer_class* pLayer, create_tag_class* pTag);
 
 void fpcLy_Cancel(layer_class* pLayer);
-bool fpcLy_CancelMethod(process_method_tag_class* pLayer);
+BOOL fpcLy_CancelMethod(struct process_method_tag_class* pLayer);
 
-void fpcLy_CancelQTo(process_method_tag_class* pMthd);
-int fpcLy_ToCancelQ(layer_class* pLayer, process_method_tag_class* pMthd);
+void fpcLy_CancelQTo(struct process_method_tag_class* pMthd);
+s32 fpcLy_ToCancelQ(layer_class* pLayer, struct process_method_tag_class* pMthd);
 
-void fpcLy_Create(layer_class* pLayer, process_node_class* pPcNode, node_list_class* pLists,
-                  int listNum);
-int fpcLy_Delete(layer_class* pLayer);
+void fpcLy_Create(layer_class* pLayer, struct process_node_class* pPcNode, node_list_class* pLists,
+                  s32 listNum);
+
+s32 fpcLy_Delete(layer_class* pLayer);
 };
 
 #endif

include/f/f_pc/f_pc_layer_iter.h

@@ -5,17 +5,17 @@
 #include "f/f_pc/f_pc_layer.h"
 #include "global.h"
 
-struct layer_iter {
+typedef struct layer_iter {
     void* mpFunc;
     void* mpUserData;
-};
+} layer_iter;
 
 extern "C" {
 
-int fpcLyIt_OnlyHere(layer_class* pLayer, cNdIt_MethodFunc pFunc, void* pUserData);
-int fpcLyIt_OnlyHereLY(layer_class* pLayer, cNdIt_MethodFunc pFunc, void* pUserData);
+s32 fpcLyIt_OnlyHere(layer_class* pLayer, cNdIt_MethodFunc pFunc, void* pUserData);
+s32 fpcLyIt_OnlyHereLY(layer_class* pLayer, cNdIt_MethodFunc pFunc, void* pUserData);
 void* fpcLyIt_Judge(layer_class* pLayer, cNdIt_MethodFunc pFunc, void* pUserData);
 void* fpcLyIt_AllJudge(cNdIt_MethodFunc pFunc, void* pUserData);
-}
+};
 
-#endif
+#endif

include/f/f_pc/f_pc_layer_tag.h

@@ -3,16 +3,15 @@
 #define F_PC_LAYER_TAG_H
 
 #include "SComponent/c_tag.h"
+#include "f/f_pc/f_pc_layer.h"
 #include "global.h"
 
-struct layer_class;
-
-struct layer_management_tag_class {
+typedef struct layer_management_tag_class {
     create_tag_class mCreateTag;
     layer_class* mpLayer;
     u16 mNodeListID;
     u16 mNodeListIdx;
-};
+} layer_management_tag_class;
 
 extern "C" {
 
@@ -20,6 +19,6 @@ s32 fpcLyTg_QueueTo(layer_management_tag_class* pTag);
 s32 fpcLyTg_ToQueue(layer_management_tag_class* pTag, u32 layerID, u16 listID, u16 listPrio);
 s32 fpcLyTg_Move(layer_management_tag_class*, u32, u16, u16);
 s32 fpcLyTg_Init(layer_management_tag_class*, u32, void*);
-}
+};
 
 #endif

include/f/f_pc/f_pc_leaf.h

@@ -5,23 +5,38 @@
 #include "f/f_pc/f_pc_base.h"
 #include "f/f_pc/f_pc_draw_priority.h"
 #include "f/f_pc/f_pc_method.h"
+#include "global.h"
 
-struct leafdraw_method_class : public process_method_class {
+typedef struct leafdraw_method_class {
+    process_method_class mBase;
     process_method_func mpDrawFunc;
-};
+} leafdraw_method_class;
 
-struct leafdraw_class : public base_process_class {
+typedef struct leafdraw_class {
+    base_process_class mBase;
     leafdraw_method_class* mpDrawMtd;
-    u8 mbUnk0;
+    s8 mbUnk0;
     u8 mbUnk1;
     draw_priority_class mDwPi;
-};
+} leafdraw_class;
+
+typedef struct leaf_process_profile_definition {
+    process_profile_definition mBase;
+    leafdraw_method_class* mLfDrwMth;
+    s16 unk20;
+    u8 unk22[2];
+    s32 unk24;
+} leaf_process_profile_definition;
 
 extern "C" {
 
-int fpcLf_GetPriority(leafdraw_class* pLeaf);
-int fpcLf_DrawMethod(leafdraw_method_class* pMthd, void* pUserData);
-int fpcLf_Draw(leafdraw_class* pMthd);
+s32 fpcLf_GetPriority(leafdraw_class* pLeaf);
+s32 fpcLf_DrawMethod(leafdraw_method_class* pMthd, void* pUserData);
+s32 fpcLf_Draw(leafdraw_class* pMthd);
+s32 fpcLf_Execute(leafdraw_class* pLeaf);
+s32 fpcLf_IsDelete(leafdraw_class* pLeaf);
+s32 fpcLf_Delete(leafdraw_class* pLeaf);
+s32 fpcLf_Create(leafdraw_class* pLeaf);
 };
 
 #endif

include/f/f_pc/f_pc_line.h

@@ -0,0 +1,9 @@
+#ifndef F_PC_LINE_H
+#define F_PC_LINE_H
+
+extern "C" {
+
+void fpcLn_Create(void);
+};
+
+#endif

include/f/f_pc/f_pc_line_tag.h

@@ -3,16 +3,18 @@
 #define F_PC_LINE_TAG_H
 
 #include "SComponent/c_tag.h"
+#include "global.h"
 
-struct line_tag : public create_tag_class {
-    int mLineListID;
-};
+typedef struct line_tag {
+    create_tag_class mBase;
+    s32 mLineListID;
+} line_tag;
 
 extern "C" {
 
-int fpcLnTg_Move(line_tag* pLineTag, int newLineListID);
+s32 fpcLnTg_Move(line_tag* pLineTag, s32 newLineListID);
 void fpcLnTg_QueueTo(line_tag* pLineTag);
-int fpcLnTg_ToQueue(line_tag* pLineTag, int lineListID);
+s32 fpcLnTg_ToQueue(line_tag* pLineTag, s32 lineListID);
 void fpcLnTg_Init(line_tag* pLineTag, void* pData);
 };
 

include/f/f_pc/f_pc_load.h

@@ -6,10 +6,10 @@
 
 extern "C" {
 
-bool fpcLd_Use(u16 procName);
-int fpcLd_IsLoaded(u16 procName);
+BOOL fpcLd_Use(u16 procName);
+s32 fpcLd_IsLoaded(u16 procName);
 void fpcLd_Free(u16 procName);
-int fpcLd_Load(u16 procName);
+s32 fpcLd_Load(u16 procName);
 };
 
 #endif