ported over f_pc

31 files changed, 711 insertions, 96 deletions

diff --git a/include/SSystem/SStandard/s_basic.h b/include/SSystem/SStandard/s_basic.h
index fe5fd534b9..3fea9ad699 100644
--- a/include/SSystem/SStandard/s_basic.h
+++ b/include/SSystem/SStandard/s_basic.h
@@ -3,4 +3,7 @@
 
 #include "dolphin/types.h"
 
+void sBs_FillArea_s(void* pPtr, u32 pNumBytes, s16 pValue);
+void sBs_ClearArea(void* pPtr, u32 pNumBytes);
+
 #endif /* S_BASIC_H */
diff --git a/include/f_pc/f_pc_base.h b/include/f_pc/f_pc_base.h
index b38e3a8625..baed3a5d7a 100644
--- a/include/f_pc/f_pc_base.h
+++ b/include/f_pc/f_pc_base.h
@@ -1,6 +1,53 @@
-#ifndef F_PC_F_PC_BASE_H
-#define F_PC_F_PC_BASE_H
 
+#ifndef F_PC_BASE_H_
+#define F_PC_BASE_H_
+
+#include "SSystem/SComponent/c_tag.h"
 #include "dolphin/types.h"
+// #include "f/f_pc/f_pc_method.h"
+#include "f_pc/f_pc_delete_tag.h"
+#include "f_pc/f_pc_layer_tag.h"
+#include "f_pc/f_pc_line_tag.h"
+#include "f_pc/f_pc_priority.h"
+#include "f_pc/f_pc_profile.h"
+
+struct create_request;
+struct profile_method_class;
+
+typedef struct base_process_class {
+    /* 0x00 */ u32 mBsType;
+    /* 0x04 */ u32 mBsPcId;
+    /* 0x08 */ s16 mProcName;
+    /* 0x0A */ s8 mUnk0;
+    /* 0x0B */ u8 mPauseFlag;
+    /* 0x0C */ s8 mInitState;
+    /* 0x0D */ u8 mUnk2;
+    /* 0x0E */ s16 mBsTypeId;
+    /* 0x10 */ process_profile_definition* mpProf;
+    /* 0x14 */ struct create_request* mpCtRq;
+    /* 0x18 */ layer_management_tag_class mLyTg;
+    /* 0x34 */ line_tag mLnTg;
+    /* 0x4C */ delete_tag_class mDtTg;
+    /* 0x68 */ process_priority_class mPi;
+    /* 0xA8 */ process_method_class* mpPcMtd;
+    /* 0xAC */ void* mpUserData;
+    /* 0xB0 */ u32 mParameters;
+    /* 0xB4 */ u32 mSubType;
+} base_process_class;  // Size: 0xB8
+
+BOOL fpcBs_Is_JustOfType(int pType1, int pType2);
+s32 fpcBs_MakeOfType(int* 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, unsigned int pProcID, void* pData);
+s32 fpcBs_SubCreate(base_process_class* pProc);
+
+extern "C" {
+void fpcBs_MakeOfType__FPi(void);
+void fpcBs_Is_JustOfType__Fii(void);
+}
 
-#endif /* F_PC_F_PC_BASE_H */
+#endif
diff --git a/include/f_pc/f_pc_create_iter.h b/include/f_pc/f_pc_create_iter.h
index f01fd53db0..05b4cc3e40 100644
--- a/include/f_pc/f_pc_create_iter.h
+++ b/include/f_pc/f_pc_create_iter.h
@@ -1,6 +1,34 @@
-#ifndef F_PC_F_PC_CREATE_ITER_H
-#define F_PC_F_PC_CREATE_ITER_H
 
+#ifndef F_PC_CREATE_ITER_H_
+#define F_PC_CREATE_ITER_H_
+
+#include "SSystem/SComponent/c_list_iter.h"
+#include "SSystem/SComponent/c_tag_iter.h"
+#include "f_pc/f_pc_create_tag.h"
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_CREATE_ITER_H */
+typedef int (*fpcCtIt_MethodFunc)(void*, void*);
+typedef void* (*fpcCtIt_JudgeFunc)(void*, void*);
+
+typedef struct node_method_data {
+    fpcCtIt_MethodFunc mFunc;
+    void* mpUserData;
+} node_method_data;
+
+typedef struct node_judge_data {
+    fpcCtIt_JudgeFunc mFunc;
+    void* mpUserData;
+} node_judge_data;
+
+typedef struct fpcCtIt_jilprm_c {
+    u32 mLayerID;
+    fpcCtIt_JudgeFunc mFunc;
+    void* mpUserData;
+} fpcCtIt_jilprm_c;
+
+s32 fpcCtIt_Method(fpcCtIt_MethodFunc pJudge, void* pUserData);
+void* fpcCtIt_Judge(fpcCtIt_JudgeFunc pJudge, void* pUserData);
+void* fpcCtIt_filter_JudgeInLayer(create_tag*, fpcCtIt_jilprm_c*);
+void* fpcCtIt_JudgeInLayer(unsigned int pUnk0, fpcCtIt_JudgeFunc pFunc, void* pUserData);
+
+#endif
diff --git a/include/f_pc/f_pc_create_req.h b/include/f_pc/f_pc_create_req.h
index 39e4956c87..83763358ec 100644
--- a/include/f_pc/f_pc_create_req.h
+++ b/include/f_pc/f_pc_create_req.h
@@ -1,6 +1,44 @@
-#ifndef F_PC_F_PC_CREATE_REQ_H
-#define F_PC_F_PC_CREATE_REQ_H
 
+#ifndef F_PC_CREATE_REQ_H_
+#define F_PC_CREATE_REQ_H_
+
+#include "SSystem/SComponent/c_phase.h"
+#include "SSystem/SComponent/c_tag.h"
+#include "f_pc/f_pc_create_tag.h"
+#include "f_pc/f_pc_layer.h"
+#include "f_pc/f_pc_method.h"
+#include "f_pc/f_pc_method_tag.h"
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_CREATE_REQ_H */
+struct base_process_class;
+
+typedef struct create_request_method_class {
+    cPhs__Handler mpHandler;
+    process_method_func mpCancel;
+    process_method_func mpDelete;
+} create_request_method_class;
+
+typedef struct create_request {
+    create_tag mBase;
+    s8 mbIsCreating;
+    s8 mbIsCancelling;
+    process_method_tag_class mMtdTg;
+    create_request_method_class* mpCtRqMtd;
+    void* mpUnk1;
+    s32 mBsPcId;
+    struct base_process_class* mpRes;
+    layer_class* mpLayer;
+} create_request;  // Size: 0x48
+
+BOOL fpcCtRq_isCreatingByID(create_tag* pTag, unsigned int* pId);
+BOOL fpcCtRq_IsCreatingByID(unsigned int 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);
+s32 fpcCtRq_IsDoing(create_request* pReq);
+void fpcCtRq_Handler(void);
+create_request* fpcCtRq_Create(layer_class* pLayer, u32 size,
+                               create_request_method_class* pCtRqMtd);
+
+#endif
diff --git a/include/f_pc/f_pc_create_tag.h b/include/f_pc/f_pc_create_tag.h
index 8f3df92c1c..faa6d10249 100644
--- a/include/f_pc/f_pc_create_tag.h
+++ b/include/f_pc/f_pc_create_tag.h
@@ -1,6 +1,18 @@
-#ifndef F_PC_F_PC_CREATE_TAG_H
-#define F_PC_F_PC_CREATE_TAG_H
 
+#ifndef F_PC_CREATE_TAG_H_
+#define F_PC_CREATE_TAG_H_
+
+#include "SSystem/SComponent/c_tag.h"
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_CREATE_TAG_H */
+typedef struct create_tag {
+    create_tag_class mBase;
+} create_tag;
+
+void fpcCtTg_ToCreateQ(create_tag* pTag);
+void fpcCtTg_CreateQTo(create_tag* pTag);
+s32 fpcCtTg_Init(create_tag* pTag, void* pUserData);
+
+extern node_list_class g_fpcCtTg_Queue;
+
+#endif
diff --git a/include/f_pc/f_pc_creator.h b/include/f_pc/f_pc_creator.h
index 86cb3ce434..ebae2011c4 100644
--- a/include/f_pc/f_pc_creator.h
+++ b/include/f_pc/f_pc_creator.h
@@ -1,6 +1,14 @@
-#ifndef F_PC_F_PC_CREATOR_H
-#define F_PC_F_PC_CREATOR_H
+
+#ifndef F_PC_CREATOR_H_
+#define F_PC_CREATOR_H_
 
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_CREATOR_H */
+struct base_process_class;
+
+BOOL fpcCt_IsCreatingByID(unsigned int id);
+s32 fpcCt_IsDoing(struct base_process_class* pProc);
+BOOL fpcCt_Abort(struct base_process_class* pProc);
+void fpcCt_Handler(void);
+
+#endif
diff --git a/include/f_pc/f_pc_delete_tag.h b/include/f_pc/f_pc_delete_tag.h
index 445012d194..d54e609c3c 100644
--- a/include/f_pc/f_pc_delete_tag.h
+++ b/include/f_pc/f_pc_delete_tag.h
@@ -1,6 +1,25 @@
-#ifndef F_PC_F_PC_DELETE_TAG_H
-#define F_PC_F_PC_DELETE_TAG_H
 
+#ifndef F_PC_DELETE_TAG_H_
+#define F_PC_DELETE_TAG_H_
+
+#include "SSystem/SComponent/c_tag.h"
+#include "f_pc/f_pc_layer.h"
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_DELETE_TAG_H */
+typedef int (*delete_tag_func)(void*);
+
+typedef struct delete_tag_class {
+    create_tag_class mBase;
+    layer_class* mpLayer;
+    s16 mTimer;
+} delete_tag_class;
+
+BOOL fpcDtTg_IsEmpty(void);
+void fpcDtTg_ToDeleteQ(delete_tag_class* pTag);
+void fpcDtTg_DeleteQTo(delete_tag_class* pTag);
+s32 fpcDtTg_Do(delete_tag_class* pTag, delete_tag_func pFunc);
+s32 fpcDtTg_Init(delete_tag_class* pTag, void* pUserData);
+
+extern node_list_class g_fpcDtTg_Queue;
+
+#endif
diff --git a/include/f_pc/f_pc_deletor.h b/include/f_pc/f_pc_deletor.h
index 0b1dd35efd..79185d966f 100644
--- a/include/f_pc/f_pc_deletor.h
+++ b/include/f_pc/f_pc_deletor.h
@@ -1,6 +1,15 @@
-#ifndef F_PC_F_PC_DELETOR_H
-#define F_PC_F_PC_DELETOR_H
 
-#include "dolphin/types.h"
+#ifndef F_PC_DELETOR_H_
+#define F_PC_DELETOR_H_
 
-#endif /* F_PC_F_PC_DELETOR_H */
+#include "f_pc/f_pc_base.h"
+
+struct base_process_class;
+
+BOOL fpcDt_IsComplete(void);
+s32 fpcDt_ToDeleteQ(base_process_class* pProc);
+s32 fpcDt_ToQueue(base_process_class* pProc);
+void fpcDt_Handler(void);
+s32 fpcDt_Delete(void* pProc);
+
+#endif
diff --git a/include/f_pc/f_pc_draw.h b/include/f_pc/f_pc_draw.h
index 854766878c..50529291b0 100644
--- a/include/f_pc/f_pc_draw.h
+++ b/include/f_pc/f_pc_draw.h
@@ -1,6 +1,14 @@
-#ifndef F_PC_F_PC_DRAW_H
-#define F_PC_F_PC_DRAW_H
+#ifndef F_PC_DRAW_H_
+#define F_PC_DRAW_H_
 
+#include "SSystem/SComponent/c_node_iter.h"
+#include "f_pc/f_pc_base.h"
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_DRAW_H */
+typedef int (*fpcDw_HandlerFunc)(void*, void*);
+typedef int (*fpcDw_HandlerFuncFunc)(fpcDw_HandlerFunc);
+
+s32 fpcDw_Execute(base_process_class* pProc);
+s32 fpcDw_Handler(fpcDw_HandlerFuncFunc param_1, fpcDw_HandlerFunc param_2);
+
+#endif
\ No newline at end of file
diff --git a/include/f_pc/f_pc_draw_priority.h b/include/f_pc/f_pc_draw_priority.h
index 0a43e0b759..6acd5cba2a 100644
--- a/include/f_pc/f_pc_draw_priority.h
+++ b/include/f_pc/f_pc_draw_priority.h
@@ -1,6 +1,15 @@
-#ifndef F_PC_F_PC_DRAW_PRIORITY_H
-#define F_PC_F_PC_DRAW_PRIORITY_H
+
+#ifndef F_PC_DRAW_PRIORITY_H_
+#define F_PC_DRAW_PRIORITY_H_
 
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_DRAW_PRIORITY_H */
+typedef struct draw_priority_class {
+    s16 mPriority;
+} draw_priority_class;
+
+s32 fpcDwPi_Get(const draw_priority_class* pDwPi);
+void fpcDwPi_Set(draw_priority_class* pDwPi, s16 p);
+void fpcDwPi_Init(draw_priority_class* pDwPi, s16 p);
+
+#endif
diff --git a/include/f_pc/f_pc_executor.h b/include/f_pc/f_pc_executor.h
index 94d378b847..eaf0a22751 100644
--- a/include/f_pc/f_pc_executor.h
+++ b/include/f_pc/f_pc_executor.h
@@ -1,6 +1,23 @@
-#ifndef F_PC_F_PC_EXECUTOR_H
-#define F_PC_F_PC_EXECUTOR_H
 
-#include "dolphin/types.h"
+#ifndef F_PC_EXECUTOR_H_
+#define F_PC_EXECUTOR_H_
 
-#endif /* F_PC_F_PC_EXECUTOR_H */
+#include "SSystem/SComponent/c_node_iter.h"
+#include "f_pc/f_pc_base.h"
+#include "f_pc/f_pc_layer_iter.h"
+#include "f_pc/f_pc_line_iter.h"
+
+base_process_class* fpcEx_Search(fpcLyIt_JudgeFunc pFunc, void* pUserData);
+base_process_class* fpcEx_SearchByID(unsigned int id);
+BOOL fpcEx_IsExist(unsigned int 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(fpcLnIt_QueueFunc pFunc);
+
+extern "C" {
+void fpcEx_IsExist__FUi(void);
+}
+
+#endif
diff --git a/include/f_pc/f_pc_fstcreate_req.h b/include/f_pc/f_pc_fstcreate_req.h
index 89c4a73cdc..e41943f981 100644
--- a/include/f_pc/f_pc_fstcreate_req.h
+++ b/include/f_pc/f_pc_fstcreate_req.h
@@ -1,6 +1,23 @@
-#ifndef F_PC_F_PC_FSTCREATE_REQ_H
-#define F_PC_F_PC_FSTCREATE_REQ_H
+#ifndef F_PC_FSTCREATE_REQ_H_
+#define F_PC_FSTCREATE_REQ_H_
 
+#include "f_pc/f_pc_base.h"
+#include "f_pc/f_pc_create_req.h"
+#include "f_pc/f_pc_layer.h"
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_FSTCREATE_REQ_H */
+typedef int (*fstCreateFunc)(void*, void*);
+
+typedef struct fast_create_request {
+    /* 0x00 */ create_request mBase;
+    /* 0x48 */ fstCreateFunc mpFastCreateFunc;
+    /* 0x4C */ void* mpFastCreateData;
+} fast_create_request;  // Size: 0x50
+
+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
\ No newline at end of file
diff --git a/include/f_pc/f_pc_layer.h b/include/f_pc/f_pc_layer.h
index 0e637ca9a9..4e9e1f793b 100644
--- a/include/f_pc/f_pc_layer.h
+++ b/include/f_pc/f_pc_layer.h
@@ -1,6 +1,53 @@
-#ifndef F_PC_F_PC_LAYER_H
-#define F_PC_F_PC_LAYER_H
 
+#ifndef F_PC_LAYER_H_
+#define F_PC_LAYER_H_
+
+#include "SSystem/SComponent/c_node.h"
+#include "SSystem/SComponent/c_tag.h"
+#include "SSystem/SComponent/c_tree.h"
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_LAYER_H */
+struct process_method_tag_class;
+typedef struct process_node_class process_node_class;
+
+typedef struct layer_class {
+    node_class mNode;
+    u32 mLayerID;
+    node_lists_tree_class mNodeListTree;
+    process_node_class* mpPcNode;
+    node_list_class mCancelList;
+    struct {
+        s16 mCreatingCount;
+        s16 mDeletingCount;
+    } counts;
+} layer_class;
+
+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);
+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);
+
+s32 fpcLy_IntoQueue(layer_class* pLayer, int treeListIdx, create_tag_class* pTag, int idx);
+s32 fpcLy_ToQueue(layer_class* pLayer, int treeListIdx, create_tag_class* pTag);
+s32 fpcLy_QueueTo(layer_class* pLayer, create_tag_class* pTag);
+
+void fpcLy_Cancel(layer_class* pLayer);
+BOOL fpcLy_CancelMethod(struct process_method_tag_class* pLayer);
+
+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, void* pPcNode, node_list_class* pLists, int listNum);
+
+s32 fpcLy_Delete(layer_class* pLayer);
+
+#endif
diff --git a/include/f_pc/f_pc_layer_iter.h b/include/f_pc/f_pc_layer_iter.h
index fa4ea12838..49928636f4 100644
--- a/include/f_pc/f_pc_layer_iter.h
+++ b/include/f_pc/f_pc_layer_iter.h
@@ -1,6 +1,21 @@
-#ifndef F_PC_F_PC_LAYER_ITER_H
-#define F_PC_F_PC_LAYER_ITER_H
+#ifndef F_PC_LAYER_ITER_H_
+#define F_PC_LAYER_ITER_H_
 
+#include "SSystem/SComponent/c_node_iter.h"
+#include "f_pc/f_pc_layer.h"
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_LAYER_ITER_H */
+typedef struct layer_iter {
+    void* mpFunc;
+    void* mpUserData;
+} layer_iter;
+
+typedef int (*fpcLyIt_OnlyHereFunc)(void*, void*);
+typedef void* (*fpcLyIt_JudgeFunc)(void*, void*);
+
+s32 fpcLyIt_OnlyHere(layer_class* pLayer, fpcLyIt_OnlyHereFunc pFunc, void* pUserData);
+s32 fpcLyIt_OnlyHereLY(layer_class* pLayer, fpcLyIt_OnlyHereFunc pFunc, void* pUserData);
+void* fpcLyIt_Judge(layer_class* pLayer, fpcLyIt_JudgeFunc pFunc, void* pUserData);
+void* fpcLyIt_AllJudge(fpcLyIt_JudgeFunc pFunc, void* pUserData);
+
+#endif
diff --git a/include/f_pc/f_pc_layer_tag.h b/include/f_pc/f_pc_layer_tag.h
index 753ab53782..c7e48e15ea 100644
--- a/include/f_pc/f_pc_layer_tag.h
+++ b/include/f_pc/f_pc_layer_tag.h
@@ -1,6 +1,22 @@
-#ifndef F_PC_F_PC_LAYER_TAG_H
-#define F_PC_F_PC_LAYER_TAG_H
 
+#ifndef F_PC_LAYER_TAG_H_
+#define F_PC_LAYER_TAG_H_
+
+#include "SSystem/SComponent/c_tag.h"
+#include "f_pc/f_pc_layer.h"
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_LAYER_TAG_H */
+typedef struct layer_management_tag_class {
+    create_tag_class mCreateTag;
+    layer_class* mpLayer;
+    u16 mNodeListID;
+    u16 mNodeListIdx;
+} layer_management_tag_class;
+
+s32 fpcLyTg_QueueTo(layer_management_tag_class* pTag);
+s32 fpcLyTg_ToQueue(layer_management_tag_class* pTag, unsigned int layerID, u16 listID,
+                    u16 listPrio);
+s32 fpcLyTg_Move(layer_management_tag_class*, unsigned int, u16, u16);
+s32 fpcLyTg_Init(layer_management_tag_class*, unsigned int, void*);
+
+#endif
diff --git a/include/f_pc/f_pc_leaf.h b/include/f_pc/f_pc_leaf.h
index a4aee744f7..1e954c4020 100644
--- a/include/f_pc/f_pc_leaf.h
+++ b/include/f_pc/f_pc_leaf.h
@@ -1,6 +1,41 @@
-#ifndef F_PC_F_PC_LEAF_H
-#define F_PC_F_PC_LEAF_H
 
+#ifndef F_PC_LEAF_H_
+#define F_PC_LEAF_H_
+
+#include "f_pc/f_pc_base.h"
+#include "f_pc/f_pc_draw_priority.h"
+#include "f_pc/f_pc_method.h"
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_LEAF_H */
+typedef struct leafdraw_method_class {
+    /* 0x00 */ process_method_class mBase;
+    /* 0x10 */ process_method_func mpDrawFunc;
+} leafdraw_method_class;
+
+typedef struct leafdraw_class {
+    /* 0x00 */ base_process_class mBase;
+    /* 0xB8 */ leafdraw_method_class* mpDrawMtd;
+    /* 0xBC */ s8 mbUnk0;
+    /* 0xBD */ u8 mbUnk1;
+    /* 0xBE */ draw_priority_class mDwPi;
+} leafdraw_class;
+
+typedef struct leaf_process_profile_definition {
+    /* 0x00 */ process_profile_definition mBase;
+    /* 0x1C */ leafdraw_method_class* mLfDrwMth;
+    /* 0x20 */ s16 unk20;
+    /* 0x22 */ u8 unk22[2];
+    /* 0x24 */ s32 unk24;
+} leaf_process_profile_definition;
+
+s32 fpcLf_GetPriority(const 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);
+
+extern int g_fpcLf_type;
+
+#endif
diff --git a/include/f_pc/f_pc_line.h b/include/f_pc/f_pc_line.h
index af13476e24..82a45f3804 100644
--- a/include/f_pc/f_pc_line.h
+++ b/include/f_pc/f_pc_line.h
@@ -1,6 +1,10 @@
-#ifndef F_PC_F_PC_LINE_H
-#define F_PC_F_PC_LINE_H
+#ifndef F_PC_LINE_H_
+#define F_PC_LINE_H_
 
-#include "dolphin/types.h"
+#include "SSystem/SComponent/c_tree.h"
 
-#endif /* F_PC_F_PC_LINE_H */
+void fpcLn_Create(void);
+
+extern node_lists_tree_class g_fpcLn_Queue;
+
+#endif
\ No newline at end of file
diff --git a/include/f_pc/f_pc_line_iter.h b/include/f_pc/f_pc_line_iter.h
index cf559386d7..4a63c1e5e5 100644
--- a/include/f_pc/f_pc_line_iter.h
+++ b/include/f_pc/f_pc_line_iter.h
@@ -1,6 +1,11 @@
-#ifndef F_PC_F_PC_LINE_ITER_H
-#define F_PC_F_PC_LINE_ITER_H
 
-#include "dolphin/types.h"
+#ifndef F_PC_LINE_ITER_H_
+#define F_PC_LINE_ITER_H_
 
-#endif /* F_PC_F_PC_LINE_ITER_H */
+#include "SSystem/SComponent/c_node_iter.h"
+
+typedef int (*fpcLnIt_QueueFunc)(void*, void*);
+
+void fpcLnIt_Queue(fpcLnIt_QueueFunc pFunc);
+
+#endif
diff --git a/include/f_pc/f_pc_line_tag.h b/include/f_pc/f_pc_line_tag.h
index 6b9255a2d7..c5e3ae5f73 100644
--- a/include/f_pc/f_pc_line_tag.h
+++ b/include/f_pc/f_pc_line_tag.h
@@ -1,6 +1,18 @@
-#ifndef F_PC_F_PC_LINE_TAG_H
-#define F_PC_F_PC_LINE_TAG_H
 
+#ifndef F_PC_LINE_TAG_H_
+#define F_PC_LINE_TAG_H_
+
+#include "SSystem/SComponent/c_tag.h"
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_LINE_TAG_H */
+typedef struct line_tag {
+    create_tag_class mBase;
+    s32 mLineListID;
+} line_tag;
+
+s32 fpcLnTg_Move(line_tag* pLineTag, int newLineListID);
+void fpcLnTg_QueueTo(line_tag* pLineTag);
+s32 fpcLnTg_ToQueue(line_tag* pLineTag, int lineListID);
+void fpcLnTg_Init(line_tag* pLineTag, void* pData);
+
+#endif
diff --git a/include/f_pc/f_pc_load.h b/include/f_pc/f_pc_load.h
index f7abe97989..3fdbdf56a3 100644
--- a/include/f_pc/f_pc_load.h
+++ b/include/f_pc/f_pc_load.h
@@ -1,6 +1,12 @@
-#ifndef F_PC_F_PC_LOAD_H
-#define F_PC_F_PC_LOAD_H
+
+#ifndef F_PC_LOAD_H_
+#define F_PC_LOAD_H_
 
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_LOAD_H */
+BOOL fpcLd_Use(s16 procName);
+s32 fpcLd_IsLoaded(s16 procName);
+void fpcLd_Free(s16 procName);
+s32 fpcLd_Load(s16 procName);
+
+#endif
diff --git a/include/f_pc/f_pc_manager.h b/include/f_pc/f_pc_manager.h
index d15e64ac34..cce48a9f76 100644
--- a/include/f_pc/f_pc_manager.h
+++ b/include/f_pc/f_pc_manager.h
@@ -1,6 +1,36 @@
-#ifndef F_PC_F_PC_MANAGER_H
-#define F_PC_F_PC_MANAGER_H
+#ifndef F_PC_MANAGER_H_
+#define F_PC_MANAGER_H_
 
+#include "SSystem/SComponent/c_node_iter.h"
+#include "SSystem/SComponent/c_tag.h"
+#include "f_pc/f_pc_base.h"
+#include "f_pc/f_pc_create_iter.h"
+#include "f_pc/f_pc_node_req.h"
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_MANAGER_H */
+typedef int (*FastCreateReqFunc)(void*);
+typedef void (*fpcM_ManagementFunc)(void);
+typedef int (*fpcM_DrawIteraterFunc)(void*, void*);
+
+inline u32 fpcM_GetID(const void* pProc) {
+    return pProc != NULL ? ((base_process_class*)pProc)->mBsPcId : 0xFFFFFFFF;
+}
+void fpcM_Draw(void* pProc);
+s32 fpcM_DrawIterater(fpcM_DrawIteraterFunc pFunc);
+void fpcM_Execute(void* pProc);
+s32 fpcM_Delete(void* pProc);
+BOOL fpcM_IsCreating(unsigned int pID);
+void fpcM_Management(fpcM_ManagementFunc pFunc1, fpcM_ManagementFunc pFunc2);
+void fpcM_Init(void);
+base_process_class* fpcM_FastCreate(s16 pProcTypeID, FastCreateReqFunc param_2, void* param_3,
+                                    void* pData);
+s32 fpcM_IsPause(void* pProc, u8 param_2);
+void fpcM_PauseEnable(void* pProc, u8 param_2);
+void fpcM_PauseDisable(void* pProc, u8 param_2);
+void* fpcM_JudgeInLayer(unsigned int pLayerID, fpcCtIt_JudgeFunc pFunc, void* pUserData);
+
+extern "C" {
+void fpcM_Delete__FPv(void);
+}
+
+#endif
\ No newline at end of file
diff --git a/include/f_pc/f_pc_method.h b/include/f_pc/f_pc_method.h
index 7aecf21226..aa7e98dda7 100644
--- a/include/f_pc/f_pc_method.h
+++ b/include/f_pc/f_pc_method.h
@@ -1,6 +1,27 @@
-#ifndef F_PC_F_PC_METHOD_H
-#define F_PC_F_PC_METHOD_H
+
+#ifndef F_PC_METHOD_H_
+#define F_PC_METHOD_H_
 
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_METHOD_H */
+typedef int (*process_method_func)(void*);
+
+typedef struct process_method_class {
+    process_method_func mpCreateFunc;
+    process_method_func mpDeleteFunc;
+    process_method_func mpExecuteFunc;
+    process_method_func mpIsDeleteFunc;
+} process_method_class;
+
+s32 fpcMtd_Method(process_method_func pFunc, void* pUserData);
+s32 fpcMtd_Execute(process_method_class* pMthd, void* pUserData);
+s32 fpcMtd_IsDelete(process_method_class* pMthd, void* pUserData);
+s32 fpcMtd_Delete(process_method_class* pMthd, void* pUserData);
+s32 fpcMtd_Create(process_method_class* pMthd, void* pUserData);
+
+extern "C" {
+void fpcMtd_Execute__FP20process_method_classPv(void);
+void fpcMtd_Create__FP20process_method_classPv(void);
+}
+
+#endif
diff --git a/include/f_pc/f_pc_method_iter.h b/include/f_pc/f_pc_method_iter.h
index 8e989b3915..1c3ad4eec4 100644
--- a/include/f_pc/f_pc_method_iter.h
+++ b/include/f_pc/f_pc_method_iter.h
@@ -1,6 +1,12 @@
-#ifndef F_PC_F_PC_METHOD_ITER_H
-#define F_PC_F_PC_METHOD_ITER_H
 
+#ifndef F_PC_METHOD_ITER_H_
+#define F_PC_METHOD_ITER_H_
+
+#include "SSystem/SComponent/c_list_iter.h"
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_METHOD_ITER_H */
+typedef int (*fpcMtdIt_MethodFunc)(void*);
+
+void fpcMtdIt_Method(node_list_class* pList, fpcMtdIt_MethodFunc pMethod);
+
+#endif
diff --git a/include/f_pc/f_pc_method_tag.h b/include/f_pc/f_pc_method_tag.h
index fe39eb535a..acaa8a8557 100644
--- a/include/f_pc/f_pc_method_tag.h
+++ b/include/f_pc/f_pc_method_tag.h
@@ -1,6 +1,21 @@
-#ifndef F_PC_F_PC_METHOD_TAG_H
-#define F_PC_F_PC_METHOD_TAG_H
 
+#ifndef F_PC_METHOD_TAG_H_
+#define F_PC_METHOD_TAG_H_
+
+#include "SSystem/SComponent/c_tag.h"
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_METHOD_TAG_H */
+typedef int (*process_method_tag_func)(void*);
+
+typedef struct process_method_tag_class {
+    create_tag_class mCreateTag;
+    process_method_tag_func mpFunc;
+    void* mpMthdData;
+} process_method_tag_class;
+
+s32 fpcMtdTg_Do(process_method_tag_class* pMthd);
+s32 fpcMtdTg_ToMethodQ(node_list_class* pList, process_method_tag_class* pMthd);
+void fpcMtdTg_MethodQTo(process_method_tag_class* pMthd);
+s32 fpcMtdTg_Init(process_method_tag_class* pMthd, process_method_tag_func pFunc, void* pMthdData);
+
+#endif
diff --git a/include/f_pc/f_pc_node.h b/include/f_pc/f_pc_node.h
index a7fa12309c..0a6222ab6e 100644
--- a/include/f_pc/f_pc_node.h
+++ b/include/f_pc/f_pc_node.h
@@ -1,6 +1,41 @@
-#ifndef F_PC_F_PC_NODE_H
-#define F_PC_F_PC_NODE_H
 
-#include "dolphin/types.h"
+#ifndef F_PC_NODE_H_
+#define F_PC_NODE_H_
 
-#endif /* F_PC_F_PC_NODE_H */
+#include "f_pc/f_pc_base.h"
+#include "f_pc/f_pc_layer.h"
+#include "f_pc/f_pc_method.h"
+
+typedef struct nodedraw_method_class {
+    process_method_class mBase;
+    process_method_func mNodedrawFunc;
+} nodedraw_method_class;
+
+typedef struct process_node_class {
+    base_process_class mBase;
+    nodedraw_method_class* mpNodeMtd;
+    layer_class mLayer;
+    node_list_class mLayerNodeLists[16];
+    s8 mUnk0;
+} process_node_class;
+
+typedef struct node_process_profile_definition {
+    process_profile_definition mBase;
+    nodedraw_method_class* mNDrwMthCls;
+    s16 unk20;
+    u8 unk22[2];
+    s32 unk24;
+} node_process_profile_definition;
+
+s32 fpcNd_DrawMethod(nodedraw_method_class* pNodeMethod, void* pData);
+s32 fpcNd_Draw(process_node_class* pProcNode);
+s32 fpcNd_Execute(process_node_class* pProcNode);
+void* fpcNd_IsCreatingFromUnder(void* pProcNode);
+s32 fpcNd_IsDeleteTiming(process_node_class* pProcNode);
+s32 fpcNd_IsDelete(process_node_class* pProcNode);
+s32 fpcNd_Delete(process_node_class* pProcNode);
+s32 fpcNd_Create(process_node_class* pProcNode);
+
+extern int g_fpcNd_type;
+
+#endif
diff --git a/include/f_pc/f_pc_node_req.h b/include/f_pc/f_pc_node_req.h
index ac8afd5746..1513d86671 100644
--- a/include/f_pc/f_pc_node_req.h
+++ b/include/f_pc/f_pc_node_req.h
@@ -1,6 +1,69 @@
-#ifndef F_PC_F_PC_NODE_REQ_H
-#define F_PC_F_PC_NODE_REQ_H
+#ifndef F_PC_NODE_REQ_H_
+#define F_PC_NODE_REQ_H_
 
+#include "SSystem/SComponent/c_phase.h"
+#include "f_pc/f_pc_method.h"
+#include "f_pc/f_pc_method_tag.h"
+#include "f_pc/f_pc_node.h"
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_NODE_REQ_H */
+typedef struct node_create_request_method_class {
+    process_method_func mpExecuteFunc;
+    process_method_func mpCancelFunc;
+    process_method_func mpUnkFunc;
+    process_method_func mpPostMethodFunc;
+} node_create_request_method_class;
+// needed to match struct copy
+typedef struct unk_process_node_class {
+    process_node_class* mpNodeProc;
+    u32 mProcId;
+} unk_process_node_class;
+
+typedef struct node_create_request {
+    create_tag_class mCreateTag;
+    process_method_tag_class mProcMthCls;
+    request_of_phase_process_class mReqPhsProc;
+    cPhs__Handler* mpPhsHandler;
+    node_create_request_method_class* mpNodeCrReqMthCls;
+    s32 mParameter;
+    s32 mRequestId;
+    unk_process_node_class mNodeProc;
+    layer_class* mpLayerClass;
+    u32 mCreatingID;
+    s16 mProcName;
+    void* mpUserData;
+    s16 unk_0x60;
+
+} node_create_request;  // Size: 0x64
+
+typedef struct request_node_class {
+    node_class mBase;
+    node_create_request* mNodeCrReq;
+} request_node_class;
+
+void fpcNdRq_RequestQTo(node_create_request* pNodeCreateReq);
+void fpcNdRq_ToRequestQ(node_create_request* pNodeCreateReq);
+s32 fpcNdRq_phase_IsCreated(node_create_request* pNodeCreateReq);
+s32 fpcNdRq_phase_Create(node_create_request* pNodeCreateReq);
+s32 fpcNdRq_phase_IsDeleteTiming(node_create_request* pNodeCreateReq);
+s32 fpcNdRq_phase_IsDeleted(node_create_request* pNodeCreateReq);
+s32 fpcNdRq_phase_Delete(node_create_request* pNodeCreateReq);
+s32 fpcNdRq_DoPhase(node_create_request* pNodeCreateReq);
+s32 fpcNdRq_Execute(node_create_request* pNodeCreateReq);
+s32 fpcNdRq_Delete(node_create_request* pNodeCreateReq);
+s32 fpcNdRq_Cancel(node_create_request* pNodeCreateReq);
+s32 fpcNdRq_Handler(void);
+s32 fpcNdRq_IsPossibleTarget(struct process_node_class* pProcNode);
+s32 fpcNdRq_IsIng(struct process_node_class* pProcNode);
+node_create_request* fpcNdRq_Create(u32 pRequestSize);
+node_create_request* fpcNdRq_ChangeNode(u32 pRequestSize, struct process_node_class* pProcNode,
+                                        s16 param_3, void* param_4);
+node_create_request* fpcNdRq_DeleteNode(u32 pRequestSize, struct process_node_class* pProcNode);
+node_create_request* fpcNdRq_CreateNode(u32 pRequestSize, s16 param_2, void* param_3);
+node_create_request*
+fpcNdRq_Request(u32 param_1, int param_2, struct process_node_class* param_3, s16 param_4,
+                void* param_5, node_create_request_method_class* pNodeCreateRequestMethodClass);
+s32 fpcNdRq_ReChangeNode(unsigned int pRequestId, s16 param_2, void* param_3);
+s32 fpcNdRq_ReRequest(unsigned int pRequestId, s16 param_2, void* param_3);
+
+#endif
\ No newline at end of file
diff --git a/include/f_pc/f_pc_pause.h b/include/f_pc/f_pc_pause.h
index b59a9076ad..9af24aeb05 100644
--- a/include/f_pc/f_pc_pause.h
+++ b/include/f_pc/f_pc_pause.h
@@ -1,6 +1,13 @@
-#ifndef F_PC_F_PC_PAUSE_H
-#define F_PC_F_PC_PAUSE_H
+#ifndef F_PC_PAUSE_
+#define F_PC_PAUSE_
 
+#include "f_pc/f_pc_base.h"
+#include "f_pc/f_pc_node.h"
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_PAUSE_H */
+s32 fpcPause_IsEnable(void* pProc, u8 expected);
+s32 fpcPause_Enable(void* pProc, u8 pauseMask);
+s32 fpcPause_Disable(void* pProc, u8 pauseMask);
+void fpcPause_Init(void* pProc);
+
+#endif
diff --git a/include/f_pc/f_pc_priority.h b/include/f_pc/f_pc_priority.h
index c76b48abaf..81d799eeeb 100644
--- a/include/f_pc/f_pc_priority.h
+++ b/include/f_pc/f_pc_priority.h
@@ -1,6 +1,32 @@
-#ifndef F_PC_F_PC_PRIORITY_H
-#define F_PC_F_PC_PRIORITY_H
 
-#include "dolphin/types.h"
+#ifndef F_PC_PRIORITY_H_
+#define F_PC_PRIORITY_H_
 
-#endif /* F_PC_F_PC_PRIORITY_H */
+#include "SSystem/SComponent/c_tag.h"
+#include "f_pc/f_pc_method_tag.h"
+
+typedef struct process_priority_queue_info {
+    u32 mLayer;
+    u16 mListID;
+    u16 mListPrio;
+} process_priority_queue_info;
+
+typedef struct process_priority_class {
+    /* 0x00 */ create_tag_class mBase;
+    /* 0x14 */ process_method_tag_class mMtdTag;
+    /* 0x30 */ process_priority_queue_info mInfoQ;
+    /* 0x38 */ process_priority_queue_info mInfoCurr;
+} process_priority_class;
+
+s32 fpcPi_IsInQueue(process_priority_class* pPi);
+s32 fpcPi_QueueTo(process_priority_class* pPi);
+s32 fpcPi_ToQueue(process_priority_class* pPi);
+process_priority_class* fpcPi_GetFromQueue(void);
+s32 fpcPi_Delete(process_priority_class* pPi);
+s32 fpcPi_IsNormal(unsigned int layer, u16 listID, u16 priority);
+s32 fpcPi_Change(process_priority_class* pPi, unsigned int layer, u16 listID, u16 priority);
+s32 fpcPi_Handler(void);
+s32 fpcPi_Init(process_priority_class* pPi, void* pUserData, unsigned int layer, u16 listID,
+               u16 priority);
+
+#endif
diff --git a/include/f_pc/f_pc_profile.h b/include/f_pc/f_pc_profile.h
index ad759384ee..db969056e9 100644
--- a/include/f_pc/f_pc_profile.h
+++ b/include/f_pc/f_pc_profile.h
@@ -1,6 +1,26 @@
-#ifndef F_PC_F_PC_PROFILE_H
-#define F_PC_F_PC_PROFILE_H
 
+#ifndef F_PC_PROFILE_H_
+#define F_PC_PROFILE_H_
+
+#include "f_pc/f_pc_method.h"
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_PROFILE_H */
+struct nodedraw_method_class;
+
+typedef struct process_profile_definition {
+    s32 mLayerID;
+    u16 mListID;
+    u16 mListPrio;
+    s16 mProcName;
+    s16 unkA;  // probably padding
+    struct process_method_class* mpPcMtd;
+    s32 mSize;
+    s32 mSizeOther;
+    s32 mParameters;
+} process_profile_definition;
+
+process_profile_definition* fpcPf_Get(s16 profileID);
+
+extern process_profile_definition** g_fpcPf_ProfileList_p;
+
+#endif
diff --git a/include/f_pc/f_pc_searcher.h b/include/f_pc/f_pc_searcher.h
index d3e5e012e8..01b8ed5dd0 100644
--- a/include/f_pc/f_pc_searcher.h
+++ b/include/f_pc/f_pc_searcher.h
@@ -1,6 +1,15 @@
-#ifndef F_PC_F_PC_SEARCHER_H
-#define F_PC_F_PC_SEARCHER_H
 
+#ifndef F_PC_SEARCHER_H_
+#define F_PC_SEARCHER_H_
+
+#include "f_pc/f_pc_base.h"
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_SEARCHER_H */
+void* fpcSch_JudgeForPName(void* pProc, void* pUserData);
+void* fpcSch_JudgeByID(void* pProc, void* pUserData);
+
+extern "C" {
+void fpcSch_JudgeForPName__FPvPv(void);
+}
+
+#endif
diff --git a/include/f_pc/f_pc_stdcreate_req.h b/include/f_pc/f_pc_stdcreate_req.h
index b72e80694c..bb38c1c079 100644
--- a/include/f_pc/f_pc_stdcreate_req.h
+++ b/include/f_pc/f_pc_stdcreate_req.h
@@ -1,6 +1,34 @@
-#ifndef F_PC_F_PC_STDCREATE_REQ_H
-#define F_PC_F_PC_STDCREATE_REQ_H
+#ifndef F_PC_STDCREATE_H_
+#define F_PC_STDCREATE_H_
 
+#include "f_pc/f_pc_create_req.h"
+#include "f_pc/f_pc_layer.h"
 #include "dolphin/types.h"
 
-#endif /* F_PC_F_PC_STDCREATE_REQ_H */
+typedef int (*stdCreateFunc)(void*, void*);
+
+typedef struct standard_create_request_class {
+    /* 0x00 */ create_request mBase;
+    /* 0x48 */ request_of_phase_process_class unk_0x48;
+    /* 0x50 */ s16 mLoadID;
+    /* 0x54 */ void* unk_0x54;
+    /* 0x58 */ stdCreateFunc unk_0x58;
+    /* 0x5C */ void* unk_0x5C;
+} standard_create_request_class;
+
+s32 fpcSCtRq_phase_CreateProcess(standard_create_request_class* pStdCreateReq);
+s32 fpcSCtRq_phase_SubCreateProcess(standard_create_request_class* pStdCreateReq);
+s32 fpcSCtRq_phase_IsComplete(standard_create_request_class* pStdCreateReq);
+s32 fpcSCtRq_phase_PostMethod(standard_create_request_class* pStdCreateReq);
+s32 fpcSCtRq_phase_Done(standard_create_request_class*);
+s32 fpcSCtRq_Handler(standard_create_request_class* pStdCreateReq);
+s32 fpcSCtRq_Delete(standard_create_request_class*);
+s32 fpcSCtRq_Cancel(standard_create_request_class*);
+s32 fpcSCtRq_Request(layer_class* param_1, s16 param_2, stdCreateFunc param_3, void* param_4,
+                     void* param_5);
+
+extern "C" {
+void fpcSCtRq_Request__FP11layer_classsPFPvPv_iPvPv(void);
+}
+
+#endif
\ No newline at end of file