Import project

Original repository: https://github.com/encounter/ww

include/f_pc/f_pc_base.h

@@ -0,0 +1,51 @@
+
+#ifndef F_PC_BASE_H_
+#define F_PC_BASE_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"
+
+typedef struct create_request create_request;
+typedef struct process_method_class process_method_class; 
+typedef struct process_profile_definition process_profile_definition;
+typedef struct profile_method_class 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

include/f_pc/f_pc_create_iter.h

@@ -0,0 +1,33 @@
+
+#ifndef F_PC_CREATE_ITER_H_
+#define F_PC_CREATE_ITER_H_
+
+#include "dolphin/types.h"
+
+typedef struct create_tag create_tag;
+
+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

include/f_pc/f_pc_create_req.h

@@ -0,0 +1,42 @@
+
+#ifndef F_PC_CREATE_REQ_H_
+#define F_PC_CREATE_REQ_H_
+
+#include "SSystem/SComponent/c_phase.h"
+#include "f_pc/f_pc_create_tag.h"
+#include "f_pc/f_pc_method.h"
+#include "f_pc/f_pc_method_tag.h"
+
+typedef struct base_process_class base_process_class;
+typedef struct layer_class layer_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

include/f_pc/f_pc_create_tag.h

@@ -0,0 +1,18 @@
+
+#ifndef F_PC_CREATE_TAG_H_
+#define F_PC_CREATE_TAG_H_
+
+#include "SSystem/SComponent/c_list.h"
+#include "SSystem/SComponent/c_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

include/f_pc/f_pc_creator.h

@@ -0,0 +1,14 @@
+
+#ifndef F_PC_CREATOR_H_
+#define F_PC_CREATOR_H_
+
+#include "dolphin/types.h"
+
+typedef struct base_process_class base_process_class;
+
+BOOL fpcCt_IsCreatingByID(unsigned int id);
+s32 fpcCt_IsDoing(base_process_class* pProc);
+BOOL fpcCt_Abort(base_process_class* pProc);
+void fpcCt_Handler(void);
+
+#endif

include/f_pc/f_pc_delete_tag.h

@@ -0,0 +1,25 @@
+
+#ifndef F_PC_DELETE_TAG_H_
+#define F_PC_DELETE_TAG_H_
+
+#include "SSystem/SComponent/c_tag.h"
+
+typedef struct layer_class layer_class;
+
+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

include/f_pc/f_pc_deletor.h

@@ -0,0 +1,15 @@
+
+#ifndef F_PC_DELETOR_H_
+#define F_PC_DELETOR_H_
+
+#include "dolphin/types.h"
+
+typedef struct base_process_class 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

include/f_pc/f_pc_draw.h

@@ -0,0 +1,14 @@
+#ifndef F_PC_DRAW_H_
+#define F_PC_DRAW_H_
+
+#include "dolphin/types.h"
+
+typedef struct base_process_class base_process_class;
+
+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

include/f_pc/f_pc_draw_priority.h

@@ -0,0 +1,15 @@
+
+#ifndef F_PC_DRAW_PRIORITY_H_
+#define F_PC_DRAW_PRIORITY_H_
+
+#include "dolphin/types.h"
+
+typedef struct draw_priority_class {
+    s16 mPriority;
+} draw_priority_class;
+
+s16 fpcDwPi_Get(draw_priority_class* pDwPi);
+void fpcDwPi_Set(draw_priority_class* pDwPi, s16 p);
+void fpcDwPi_Init(draw_priority_class* pDwPi, s16 p);
+
+#endif

include/f_pc/f_pc_executor.h

@@ -0,0 +1,27 @@
+
+#ifndef F_PC_EXECUTOR_H_
+#define F_PC_EXECUTOR_H_
+
+#include "f_pc/f_pc_layer_iter.h"
+#include "f_pc/f_pc_line_iter.h"
+
+typedef struct base_process_class base_process_class;
+
+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);
+
+inline base_process_class* i_fpcM_Search(fpcLyIt_JudgeFunc pFunc, void* pUserData) {
+    return fpcEx_Search(pFunc, pUserData);
+}
+
+extern "C" {
+void fpcEx_IsExist__FUi(void);
+}
+
+#endif

include/f_pc/f_pc_fstcreate_req.h

@@ -0,0 +1,23 @@
+#ifndef F_PC_FSTCREATE_REQ_H_
+#define F_PC_FSTCREATE_REQ_H_
+
+#include "f_pc/f_pc_create_req.h"
+
+typedef struct base_process_class base_process_class;
+typedef struct layer_class layer_class;
+
+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

include/f_pc/f_pc_layer.h

@@ -0,0 +1,54 @@
+
+#ifndef F_PC_LAYER_H_
+#define F_PC_LAYER_H_
+
+#include "SSystem/SComponent/c_list.h"
+#include "SSystem/SComponent/c_node.h"
+#include "SSystem/SComponent/c_tree.h"
+#include "dolphin/types.h"
+
+typedef struct create_tag_class create_tag_class;
+typedef struct process_method_tag_class process_method_tag_class;
+typedef struct process_node_class process_node_class;
+
+typedef struct layer_class {
+    /* 0x00 */ node_class mNode;
+    /* 0x0C */ u32 mLayerID;
+    /* 0x10 */ node_lists_tree_class mNodeListTree;
+    /* 0x18 */ process_node_class* mpPcNode;
+    /* 0x1C */ node_list_class mCancelList;
+    struct {
+        /* 0x28 */ s16 mCreatingCount;
+        /* 0x2A */ 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);
+
+s32 fpcLy_Cancel(layer_class* pLayer);
+bool fpcLy_CancelMethod(process_method_tag_class* pLayer);
+
+void fpcLy_CancelQTo(process_method_tag_class* pMthd);
+s32 fpcLy_ToCancelQ(layer_class* pLayer, 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

include/f_pc/f_pc_layer_iter.h

@@ -0,0 +1,21 @@
+#ifndef F_PC_LAYER_ITER_H_
+#define F_PC_LAYER_ITER_H_
+
+#include "dolphin/types.h"
+
+typedef struct layer_class layer_class;
+
+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

include/f_pc/f_pc_layer_tag.h

@@ -0,0 +1,22 @@
+
+#ifndef F_PC_LAYER_TAG_H_
+#define F_PC_LAYER_TAG_H_
+
+#include "SSystem/SComponent/c_tag.h"
+
+typedef struct layer_class layer_class;
+
+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

include/f_pc/f_pc_leaf.h

@@ -0,0 +1,40 @@
+
+#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 "f_pc/f_pc_profile.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* mSubMtd; // Subclass methods
+    /* 0x20 */ s16 mPriority; // mDrawPriority
+} leaf_process_profile_definition;
+
+s16 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);
+
+extern int g_fpcLf_type;
+extern leafdraw_method_class g_fpcLf_Method;
+
+#endif

include/f_pc/f_pc_line.h

@@ -0,0 +1,10 @@
+#ifndef F_PC_LINE_H_
+#define F_PC_LINE_H_
+
+#include "SSystem/SComponent/c_tree.h"
+
+void fpcLn_Create(void);
+
+extern node_lists_tree_class g_fpcLn_Queue;
+
+#endif

include/f_pc/f_pc_line_iter.h

@@ -0,0 +1,9 @@
+
+#ifndef F_PC_LINE_ITER_H_
+#define F_PC_LINE_ITER_H_
+
+typedef int (*fpcLnIt_QueueFunc)(void*, void*);
+
+void fpcLnIt_Queue(fpcLnIt_QueueFunc pFunc);
+
+#endif

include/f_pc/f_pc_line_tag.h

@@ -0,0 +1,17 @@
+
+#ifndef F_PC_LINE_TAG_H_
+#define F_PC_LINE_TAG_H_
+
+#include "SSystem/SComponent/c_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

include/f_pc/f_pc_load.h

@@ -0,0 +1,12 @@
+
+#ifndef F_PC_LOAD_H_
+#define F_PC_LOAD_H_
+
+#include "dolphin/types.h"
+
+BOOL fpcLd_Use(s16 procName);
+s32 fpcLd_IsLoaded(s16 procName);
+void fpcLd_Free(s16 procName);
+s32 fpcLd_Load(s16 procName);
+
+#endif

include/f_pc/f_pc_manager.h

@@ -0,0 +1,91 @@
+#ifndef F_PC_MANAGER_H_
+#define F_PC_MANAGER_H_
+
+#include "f_pc/f_pc_create_iter.h"
+#include "f_pc/f_pc_executor.h"
+#include "f_pc/f_pc_leaf.h"
+#include "f_pc/f_pc_node.h"
+#include "f_pc/f_pc_stdcreate_req.h"
+
+enum {
+    fpcM_ERROR_PROCESS_ID_e = -1,
+};
+
+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;
+}
+inline s16 fpcM_GetName(const void* pActor) {
+    return ((base_process_class*)pActor)->mProcName;
+}
+inline u32 fpcM_GetParam(const void* pActor) {
+    return ((base_process_class*)pActor)->mParameters;
+}
+
+inline void fpcM_SetParam(void* p_actor, u32 param) {
+    ((base_process_class*)p_actor)->mParameters = param;
+}
+
+inline s16 fpcM_GetProfName(const void* pActor) {
+    return ((base_process_class*)pActor)->mBsTypeId;
+}
+
+inline int fpcM_Create(s16 procName, FastCreateReqFunc createFunc, void* process) {
+    return fpcSCtRq_Request(fpcLy_CurrentLayer(), procName, (stdCreateFunc)createFunc, NULL,
+                            process);
+}
+
+inline s16 fpcM_DrawPriority(const void* param_0) {
+    return fpcLf_GetPriority((leafdraw_class*)param_0);
+}
+
+inline s32 fpcM_ChangeLayerID(void* proc, int layerID) {
+    return fpcPi_Change(&((base_process_class*)proc)->mPi, layerID, 0xFFFD, 0xFFFD);
+}
+
+inline s32 fpcM_IsJustType(int type1, int type2) {
+    return fpcBs_Is_JustOfType(type1, type2);
+}
+
+inline bool fpcM_IsFirstCreating(void* proc) {
+    return ((base_process_class*)proc)->mInitState == 0;
+}
+
+inline process_profile_definition* fpcM_GetProfile(void* proc) {
+    return (process_profile_definition*)((base_process_class*)proc)->mpProf;
+}
+
+inline void* fpcM_GetAppend(const void* proc) {
+    return ((base_process_class*)proc)->mpUserData;
+}
+
+inline BOOL fpcM_IsExecuting(unsigned int id) {
+    return fpcEx_IsExist(id);
+}
+
+inline void* fpcM_LyJudge(process_node_class* i_node, fpcLyIt_JudgeFunc i_func, void* i_data) {
+    return fpcLyIt_Judge(&i_node->mLayer, i_func, i_data);
+}
+
+void fpcM_Draw(void* pProc);
+s32 fpcM_DrawIterater(fpcM_DrawIteraterFunc pFunc);
+s32 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

include/f_pc/f_pc_method.h

@@ -0,0 +1,27 @@
+
+#ifndef F_PC_METHOD_H_
+#define F_PC_METHOD_H_
+
+#include "dolphin/types.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

include/f_pc/f_pc_method_iter.h

@@ -0,0 +1,13 @@
+
+#ifndef F_PC_METHOD_ITER_H_
+#define F_PC_METHOD_ITER_H_
+
+#include "dolphin/types.h"
+
+typedef struct node_list_class node_list_class;
+
+typedef int (*fpcMtdIt_MethodFunc)(void*);
+
+int fpcMtdIt_Method(node_list_class* pList, fpcMtdIt_MethodFunc pMethod);
+
+#endif

include/f_pc/f_pc_method_tag.h

@@ -0,0 +1,20 @@
+
+#ifndef F_PC_METHOD_TAG_H_
+#define F_PC_METHOD_TAG_H_
+
+#include "SSystem/SComponent/c_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

include/f_pc/f_pc_node.h

@@ -0,0 +1,40 @@
+
+#ifndef F_PC_NODE_H_
+#define 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"
+#include "f_pc/f_pc_profile.h"
+
+typedef struct nodedraw_method_class {
+    process_method_class mBase;
+    process_method_func mpDrawFunc;
+} nodedraw_method_class;
+
+typedef struct process_node_class {
+    /* 0x00 */ base_process_class mBase;
+    /* 0xB8 */ nodedraw_method_class* mpNodeMtd;
+    /* 0xBC */ layer_class mLayer;
+    /* 0xE8 */ node_list_class mLayerNodeLists[16];
+    /* 0x1A8 */ s8 mUnk0;
+} process_node_class;
+
+typedef struct node_process_profile_definition {
+    /* 0x00 */ process_profile_definition mBase;
+    /* 0x1C */ process_method_class* mSubMtd; // Subclass methods
+} 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;
+extern nodedraw_method_class g_fpcNd_Method;
+
+#endif

include/f_pc/f_pc_node_req.h

@@ -0,0 +1,70 @@
+#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"
+
+typedef struct layer_class layer_class;
+typedef struct process_node_class process_node_class;
+
+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(process_node_class* pProcNode);
+s32 fpcNdRq_IsIng(process_node_class* pProcNode);
+node_create_request* fpcNdRq_Create(u32 pRequestSize);
+node_create_request* fpcNdRq_ChangeNode(u32 pRequestSize, process_node_class* pProcNode,
+                                        s16 param_3, void* param_4);
+node_create_request* fpcNdRq_DeleteNode(u32 pRequestSize, 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, 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

include/f_pc/f_pc_pause.h

@@ -0,0 +1,11 @@
+#ifndef F_PC_PAUSE_
+#define F_PC_PAUSE_
+
+#include "dolphin/types.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

include/f_pc/f_pc_priority.h

@@ -0,0 +1,33 @@
+
+#ifndef F_PC_PRIORITY_H_
+#define F_PC_PRIORITY_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);
+
+extern s8 data_804505F0;  // roomReadId
+
+#endif

include/f_pc/f_pc_profile.h

@@ -0,0 +1,28 @@
+
+#ifndef F_PC_PROFILE_H_
+#define F_PC_PROFILE_H_
+
+#include "dolphin/types.h"
+
+typedef struct nodedraw_method_class nodedraw_method_class;
+typedef struct leafdraw_method_class leafdraw_method_class;
+typedef struct process_method_class process_method_class;
+
+typedef struct process_profile_definition {
+    /* 0x00 */ s32 mLayerID;
+    /* 0x04 */ u16 mListID;
+    /* 0x06 */ u16 mListPrio;
+    /* 0x08 */ s16 mProcName;
+    /* 0x0C */ process_method_class* mSubMtd; // Subclass methods
+    /* 0x10 */ s32 mSize;
+    /* 0x14 */ s32 mSizeOther;
+    /* 0x18 */ s32 mParameters;
+} process_profile_definition;
+
+#define LAYER_DEFAULT (-2)
+
+struct leaf_process_profile_definition;
+process_profile_definition* fpcPf_Get(s16 profileID);
+extern process_profile_definition** g_fpcPf_ProfileList_p;
+
+#endif

include/f_pc/f_pc_profile_lst.h

@@ -0,0 +1,6 @@
+#ifndef F_PC_PROFILE_LST_H
+#define F_PC_PROFILE_LST_H
+
+#include "f_pc/f_pc_profile.h"
+
+#endif /* F_PC_PROFILE_LST_H */

include/f_pc/f_pc_searcher.h

@@ -0,0 +1,19 @@
+
+#ifndef F_PC_SEARCHER_H_
+#define F_PC_SEARCHER_H_
+
+#include "f_pc/f_pc_base.h"
+#include "f_pc/f_pc_layer_iter.h"
+
+void* fpcSch_JudgeForPName(void* pProc, void* pUserData);
+void* fpcSch_JudgeByID(void* pProc, void* pUserData);
+
+extern "C" {
+void fpcSch_JudgeForPName__FPvPv(void);
+}
+
+inline base_process_class* i_fpcM_SearchByName(s16 name) {
+    return (base_process_class*)fpcLyIt_AllJudge(fpcSch_JudgeForPName, &name);
+}
+
+#endif

include/f_pc/f_pc_stdcreate_req.h

@@ -0,0 +1,34 @@
+#ifndef F_PC_STDCREATE_H_
+#define F_PC_STDCREATE_H_
+
+#include "f_pc/f_pc_create_req.h"
+
+typedef struct layer_class layer_class;
+
+typedef int (*stdCreateFunc)(void*, void*);
+
+typedef struct standard_create_request_class {
+    /* 0x00 */ create_request mBase;
+    /* 0x48 */ request_of_phase_process_class mPhase;
+    /* 0x50 */ s16 mProcName;
+    /* 0x54 */ void* mpUserData;
+    /* 0x58 */ stdCreateFunc mpCallBack;
+    /* 0x5C */ void* mpCallBackUserData;
+} 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