Merge pull request #60 from speyejack/main

Release v1.1.0 - v1.3.0
Merge commit 'd5b49b2'
2023-09-12 15:01:30 -07:00 · 2023-09-12 13:36:12 -07:00 · 2023-09-12 13:35:35 -07:00 · 2023-09-12 13:28:45 -07:00 · 2023-09-02 13:03:18 -07:00 · 2023-09-02 12:58:53 -07:00
145 changed files with 5785 additions and 1534 deletions
--- a/.github/actions/attach/action.yml
+++ b/.github/actions/attach/action.yml
@ -27,7 +27,7 @@ runs:
    shell : bash
    run: |
      cd  ./starlight_patch_100/
-      zip  -rmT9  ${{ inputs.filename }}.zip  ./*
+      zip  -rmT9  "${{ inputs.filename }}.zip"  ./*
  -
    name : Attach to release
    uses : actions/upload-release-asset@v1
@ -36,5 +36,10 @@ runs:
    with:
      upload_url         : ${{ inputs.upload_url }}
      asset_path         : ./starlight_patch_100/${{ inputs.filename }}.zip
-      asset_name         : ${{ inputs.filename }}.zip
+      asset_name         : "${{ inputs.filename }}.zip"
      asset_content_type : application/zip
+  -
+    name  : Cleanup artifacts
+    shell : bash
+    run: |
+      rm -rf ./starlight_patch_100/
--- a/.github/actions/build/action.yml
+++ b/.github/actions/build/action.yml
@ -6,6 +6,14 @@ inputs:
    description : 'version tag'
    required    : false
    default     : ''
+  prefix:
+    description : 'filename prefix'
+    required    : false
+    default     : ''
+  emu:
+    description : 'what system the build is for: Switch, Ryujinx or yuzu'
+    required    : false
+    default     : 'Switch'


 outputs:
@ -23,8 +31,8 @@ runs:
    shell : bash
    run: |
      VERS=${{ inputs.tag }}
-      echo "::set-output name=version::${VERS:1}"
-      echo "::set-output name=filename::SMO_Online${{ (inputs.tag != '' && format('_{0}', inputs.tag)) || '' }}"
+      echo "version=${VERS:1}" >>$GITHUB_OUTPUT
+      echo "filename=${{ inputs.prefix }}SMO_Online${{ (inputs.tag != '' && format('_{0}', inputs.tag)) || '' }}_for_${{ inputs.emu }}" >>$GITHUB_OUTPUT
  -
    name : Set up Docker Buildx
    uses : docker/setup-buildx-action@v2
@ -45,13 +53,25 @@ runs:
    name  : Build mod
    shell : bash
    run: |
-      docker  run  --rm     \
-        -u `id -u`:`id -g`  \
-        -v "/$PWD/":/app/   \
+      docker  run  --rm             \
+        -u `id -u`:`id -g`          \
+        -v "/$PWD/":/app/           \
+        -e ISEMU=${{ (inputs.emu != 'Switch' && '1') || '0' }}  \
        ${{ (steps.env.outputs.version != '' && format('-e BUILDVER={0}', steps.env.outputs.version)) || '' }}  \
        smoo-build-env      \
      ;
      cp  -r  ./romfs/  ./starlight_patch_100/atmosphere/contents/0100000000010000/.
+  -
+    name  : Yuzu
+    shell : bash
+    if    : ${{ inputs.emu == 'yuzu' }}
+    run: |
+      cd  ./starlight_patch_100/
+      mkdir  ./SMOO/
+      mv  ./atmosphere/contents/0100000000010000/exefs  ./SMOO/exefs
+      mv  ./atmosphere/contents/0100000000010000/romfs  ./SMOO/romfs
+      mv  ./atmosphere/exefs_patches/StarlightBase/3CA12DFAAF9C82DA064D1698DF79CDA1.ips  ./SMOO/exefs/
+      rm  -rf  ./atmosphere/
  -
    name : Upload artifacts
    uses : actions/upload-artifact@v3
--- a/.github/actions/release/action.yml
+++ b/.github/actions/release/action.yml
@ -30,7 +30,7 @@ runs:
      GITHUB_TOKEN: ${{ inputs.GITHUB_TOKEN }}
    with:
      tag_name     : ${{ inputs.tag }}
-      release_name : Release ${{ inputs.tag }}
+      release_name : ${{ inputs.tag }}
      body         : ''
      draft        : true
      prerelease   : false
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@ -5,9 +5,13 @@ on:
  push:
    branches:
    - '**'
+    - '!dev'
    tags:
    - '**'
    - '!v[0-9]+.[0-9]+.[0-9]+'
+    - '!v[0-9]+.[0-9]+.[0-9]+\+*'
+    - '!v[0-9]+.[0-9]+.[0-9]+-*'
+    - '!latest-dev'
  pull_request:
    branches:
    - '**'
@ -16,6 +20,9 @@ on:
 jobs:

  build:
+    strategy:
+      matrix:
+        emu : [ Switch, Ryujinx, yuzu ]
    runs-on: ubuntu-latest
    steps:
    -
@ -24,3 +31,5 @@ jobs:
    -
      name : Build artifacts
      uses : ./.github/actions/build
+      with:
+        emu : ${{ matrix.emu }}
--- a/.github/workflows/dev-release.yml
+++ b/.github/workflows/dev-release.yml
@ -0,0 +1,103 @@
+name: Dev Release
+
+
+on:
+  push:
+    branches:
+    - 'dev'
+
+
+env:
+  TAG : 'latest-dev'
+
+
+concurrency:
+  group: ${{ github.workflow }}
+  cancel-in-progress: true
+
+
+jobs:
+
+  build:
+    strategy:
+      matrix:
+        emu : [ Switch, Ryujinx, yuzu ]
+    runs-on: ubuntu-latest
+    outputs:
+      filename1: ${{ steps.set-output.outputs.filename-Switch }}
+      filename2: ${{ steps.set-output.outputs.filename-Ryujinx }}
+      filename3: ${{ steps.set-output.outputs.filename-yuzu }}
+    steps:
+    -
+      name : Checkout
+      uses : actions/checkout@v3
+    -
+      name  : Environment
+      id    : env
+      shell : bash
+      run: |
+        echo "prefix=$(date +'%Y%m%d_%H%M%S_' --utc)" >>$GITHUB_OUTPUT
+    -
+      name : Build artifacts
+      id   : build
+      uses : ./.github/actions/build
+      with:
+        prefix : ${{ steps.env.outputs.prefix }}
+        emu    : ${{ matrix.emu }}
+    -
+      name  : Set output
+      id    : set-output
+      shell : bash
+      run   : |
+        echo "filename-${{ matrix.emu }}=${{ steps.build.outputs.filename }}" >>$GITHUB_OUTPUT
+
+  attach:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+    -
+      name : Checkout
+      uses : actions/checkout@v3
+    -
+      name  : Get release info
+      id    : release
+      shell : bash
+      run: |
+        url=`curl -sS --fail ${{ github.api_url }}/repos/${{ github.repository }}/releases/tags/${{ env.TAG }} | jq .upload_url -r`
+        echo "upload_url=$url" >>$GITHUB_OUTPUT
+    -
+      name : Attach build artifacts to release (Switch)
+      uses : ./.github/actions/attach
+      with:
+        filename     : ${{ needs.build.outputs.filename1 }}
+        upload_url   : ${{ steps.release.outputs.upload_url }}
+        GITHUB_TOKEN : ${{ secrets.GITHUB_TOKEN }}
+    -
+      name : Attach build artifacts to release (Ryujinx)
+      uses : ./.github/actions/attach
+      with:
+        filename     : ${{ needs.build.outputs.filename2 }}
+        upload_url   : ${{ steps.release.outputs.upload_url }}
+        GITHUB_TOKEN : ${{ secrets.GITHUB_TOKEN }}
+    -
+      name : Attach build artifacts to release (yuzu)
+      uses : ./.github/actions/attach
+      with:
+        filename     : ${{ needs.build.outputs.filename3 }}
+        upload_url   : ${{ steps.release.outputs.upload_url }}
+        GITHUB_TOKEN : ${{ secrets.GITHUB_TOKEN }}
+
+  move:
+    needs: attach
+    runs-on: ubuntu-latest
+    steps:
+    -
+      name : Checkout
+      uses : actions/checkout@v3
+    -
+      name  : Move ${{ env.TAG }} tag
+      shell : bash
+      run: |
+        git config user.email "${{ github.actor }}@users.noreply.github.com"
+        git tag -f ${{ env.TAG }}
+        git push --force origin ${{ env.TAG }}
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@ -5,14 +5,21 @@ on:
  push:
    tags:
    - 'v[0-9]+.[0-9]+.[0-9]+'
+    - 'v[0-9]+.[0-9]+.[0-9]+\+*'
+    - 'v[0-9]+.[0-9]+.[0-9]+-*'


 jobs:

  build:
+    strategy:
+      matrix:
+        emu : [ Switch, Ryujinx, yuzu ]
    runs-on: ubuntu-latest
    outputs:
-      filename: ${{ steps.build.outputs.filename }}
+      filename1: ${{ steps.set-output.outputs.filename-Switch }}
+      filename2: ${{ steps.set-output.outputs.filename-Ryujinx }}
+      filename3: ${{ steps.set-output.outputs.filename-yuzu }}
    steps:
    -
      name : Checkout
@ -23,6 +30,13 @@ jobs:
      uses : ./.github/actions/build
      with:
        tag : ${{ github.ref_name }}
+        emu : ${{ matrix.emu }}
+    -
+      name  : Set output
+      id    : set-output
+      shell : bash
+      run   : |
+        echo "::set-output name=filename-${{ matrix.emu }}::${{ steps.build.outputs.filename }}"

  release:
    needs: build
@ -39,9 +53,23 @@ jobs:
        tag          : ${{ github.ref_name }}
        GITHUB_TOKEN : ${{ secrets.GITHUB_TOKEN }}
    -
-      name : Attach build artifacts to release
+      name : Attach build artifacts to release (Switch)
      uses : ./.github/actions/attach
      with:
-        filename     : ${{ needs.build.outputs.filename }}
+        filename     : ${{ needs.build.outputs.filename1 }}
+        upload_url   : ${{ steps.release.outputs.upload_url }}
+        GITHUB_TOKEN : ${{ secrets.GITHUB_TOKEN }}
+    -
+      name : Attach build artifacts to release (Ryujinx)
+      uses : ./.github/actions/attach
+      with:
+        filename     : ${{ needs.build.outputs.filename2 }}
+        upload_url   : ${{ steps.release.outputs.upload_url }}
+        GITHUB_TOKEN : ${{ secrets.GITHUB_TOKEN }}
+    -
+      name : Attach build artifacts to release (yuzu)
+      uses : ./.github/actions/attach
+      with:
+        filename     : ${{ needs.build.outputs.filename3 }}
        upload_url   : ${{ steps.release.outputs.upload_url }}
        GITHUB_TOKEN : ${{ secrets.GITHUB_TOKEN }}
--- a/.gitignore
+++ b/.gitignore
@ -5,5 +5,7 @@ romfs stuff/**
 Crash Reports/**
 .cache/**
 Custom Stage Builds/**
+*.lst
+*.disabled

 compile_commands.json
--- a/17
+++ b/17
@ -1,26 +1,13 @@
-FROM  ubuntu:20.04  as  builder
+FROM  devkitpro/devkita64:latest  as  builder

 # install dependencies
 RUN   apt-get  update       \
  &&  apt-get  install  -y  \
-    curl                    \
-    apt-transport-https     \
    python3                 \
    python3-pip             \
-  &&  pip  install  keystone-engine  \
-;
-
-# install devkitpro
-RUN   ln  -s  /proc/self/mounts  /etc/mtab  \
-  &&  mkdir  /devkitpro/  \
-  &&  echo "deb [signed-by=/devkitpro/pub.gpg] https://apt.devkitpro.org stable main" >/etc/apt/sources.list.d/devkitpro.list  \
-  &&  curl --fail  -o /devkitpro/pub.gpg  https://apt.devkitpro.org/devkitpro-pub.gpg  \
-  &&  apt-get update  \
-  &&  DEBIAN_FRONTEND=noninteractive  apt-get  install  -y  devkitpro-pacman  \
-  &&  dkp-pacman  --noconfirm  -S switch-dev  \
+  &&  pip3  install  keystone-engine  \
 ;

 WORKDIR  /app/

-ENV  DEVKITPRO  /opt/devkitpro
 ENTRYPOINT  make
--- a/16
+++ b/16
@ -4,17 +4,19 @@
 .PHONY: all clean starlight send

 SMOVER ?= 100
-BUILDVER ?= 99.37
-IP ?= 10.0.0.221
+BUILDVER ?= 101 
+BUILDVERSTR ?= 1.0.1 
+IP ?= 10.0.0.221 # ftp server ip (usually is switch's local IP)
 DEBUGLOG ?= 0 # defaults to disable debug logger 
 SERVERIP ?= 0.0.0.0 # put debug logger server IP here
+ISEMU ?= 0 # set to 1 to compile for emulators

 PROJNAME ?= StarlightBase

 all: starlight

 starlight:
-	$(MAKE) all -f MakefileNSO SMOVER=$(SMOVER) BUILDVER=$(BUILDVER) DEBUGLOG=$(DEBUGLOG) SERVERIP=${SERVERIP}
+	$(MAKE) all -f MakefileNSO SMOVER=$(SMOVER) BUILDVERSTR=$(BUILDVERSTR) BUILDVER=$(BUILDVER) DEBUGLOG=$(DEBUGLOG) SERVERIP=${SERVERIP} EMU=${ISEMU}
 	$(MAKE) starlight_patch_$(SMOVER)/*.ips
 	
 	mkdir -p starlight_patch_$(SMOVER)/atmosphere/exefs_patches/$(PROJNAME)/
@ -23,15 +25,17 @@ starlight:
 	mv starlight_patch_$(SMOVER)/3CA12DFAAF9C82DA064D1698DF79CDA1.ips starlight_patch_$(SMOVER)/atmosphere/exefs_patches/$(PROJNAME)/3CA12DFAAF9C82DA064D1698DF79CDA1.ips
 	mv $(shell basename $(CURDIR))$(SMOVER).elf starlight_patch_$(SMOVER)/subsdk1.elf
 	mv $(shell basename $(CURDIR))$(SMOVER).nso starlight_patch_$(SMOVER)/atmosphere/contents/0100000000010000/exefs/subsdk1
+	
+	cp -R romfs starlight_patch_$(SMOVER)/atmosphere/contents/0100000000010000

 starlight_patch_$(SMOVER)/*.ips: patches/*.slpatch patches/configs/$(SMOVER).config patches/maps/$(SMOVER)/*.map \
 								build$(SMOVER)/$(shell basename $(CURDIR))$(SMOVER).map scripts/genPatch.py
 	@rm -f starlight_patch_$(SMOVER)/*.ips
 	python3 scripts/genPatch.py $(SMOVER)

-# builds project with the file structure used in the yuzu emulator
-yuzu:
-	$(MAKE) all -f MakefileNSO SMOVER=$(SMOVER) BUILDVER=$(BUILDVER)
+# builds project with the file structure and flags used for emulators
+emu:
+	$(MAKE) all -f MakefileNSO SMOVER=$(SMOVER) BUILDVERSTR=$(BUILDVERSTR) BUILDVER=$(BUILDVER) EMU=1
 	$(MAKE) starlight_patch_$(SMOVER)/*.ips

 	mkdir -p starlight_patch_$(SMOVER)/yuzu/
--- a/9
+++ b/9
@ -32,7 +32,8 @@ include $(DEVKITPRO)/libnx/switch_rules
 #---------------------------------------------------------------------------------
 TARGET		?=	$(notdir $(CURDIR))$(SMOVER)
 BUILD		?=	build$(SMOVER)
-SOURCES		:=  source/sead/time source/sead source/puppets source/server source/layouts source/states source/cameras source
+SOURCES		:=  source/sead/time source/sead source/puppets source/server/hns source/server/gamemode source/server/gamemode/modifiers source/server source/layouts source/states source/cameras source/nx source
+SOURCES     +=  source/al/execute
 DATA		:=	data
 INCLUDES	:=	include include/sead

@ -44,14 +45,14 @@ ARCH	:=	-march=armv8-a -mtune=cortex-a57 -mtp=soft -fPIC -ftls-model=local-exec
 CFLAGS	:=	-g -Wall -ffunction-sections \
 			$(ARCH) $(DEFINES)

-CFLAGS	+=	$(INCLUDE) -D__SWITCH__ -DSMOVER=$(SMOVER) -O3 -DNNSDK -DSWITCH -DBUILDVER=$(BUILDVER) -DDEBUGLOG=$(DEBUGLOG) -DSERVERIP=$(SERVERIP)
+CFLAGS	+=	$(INCLUDE) -D__SWITCH__ -DSMOVER=$(SMOVER) -O3 -DNNSDK -DSWITCH -DBUILDVERSTR=$(BUILDVERSTR) -DBUILDVER=$(BUILDVER) -DDEBUGLOG=$(DEBUGLOG) -DSERVERIP=$(SERVERIP) -DEMU=$(EMU)

-CXXFLAGS	:= $(CFLAGS) -fno-rtti -fomit-frame-pointer -fno-exceptions -fno-asynchronous-unwind-tables -fno-unwind-tables -std=gnu++20
+CXXFLAGS	:= $(CFLAGS) -Wno-invalid-offsetof -Wno-volatile -fno-rtti -fomit-frame-pointer -fno-exceptions -fno-asynchronous-unwind-tables -fno-unwind-tables -std=gnu++20

 ASFLAGS	:=	-g $(ARCH)
 LDFLAGS  =  -specs=../switch.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map) -Wl,--version-script=$(TOPDIR)/exported.txt -Wl,-init=__custom_init -Wl,-fini=__custom_fini -nostdlib

-LIBS	:= -lnx
+LIBS	:=

 #---------------------------------------------------------------------------------
 # list of directories containing libraries, this must be the top level containing
--- a/docker-build.sh
+++ b/docker-build.sh
@ -1,10 +1,13 @@
 #!/bin/bash

+ISEMU=${1:-0}
+
 export DOCKER_BUILDKIT=1
 docker  build  .  -t smoo-client-build
 docker  run  --rm       \
  -u $(id -u):$(id -g)  \
  -v "/$PWD/":/app/     \
+  -e ISEMU=${ISEMU}     \
  smoo-client-build     \
 ;
 docker  rmi  smoo-client-build
--- a/include/Keyboard.hpp
+++ b/include/Keyboard.hpp
@ -7,14 +7,15 @@
 #include "nn/swkbd/swkbd.h"

 #include "logger.hpp"
-#include "sead/prim/seadSafeString.h"
+
+typedef void (*KeyboardSetup)(nn::swkbd::KeyboardConfig&);

 class Keyboard {
    public:
        Keyboard(ulong strSize);
        void keyboardThread();

-        void openKeyboard(const char* initialText);
+        void openKeyboard(const char* initialText, KeyboardSetup setup);

        const char* getResult() {
            if (mThread->isDone()) {
@ -23,6 +24,8 @@ class Keyboard {
            return nullptr;
        };

+        bool isKeyboardCancelled() const { return mIsCancelled; }
+
        bool isThreadDone() { return mThread->isDone(); }

        void setHeaderText(const char16_t* text) { mHeaderText = text; }
@ -33,12 +36,13 @@ class Keyboard {
        al::AsyncFunctorThread* mThread;
        nn::swkbd::String mResultString;

-        bool mIsDoneKeyboard;
-
-        sead::FixedSafeString<0x10> mInitialText;
+        hostname mInitialText;
+        KeyboardSetup mSetupFunc;

        const char16_t *mHeaderText = u"Enter Server IP Here!";
-        const char16_t *mSubText = u"Must be a Valid Address.";
+        const char16_t* mSubText = u"Must be a Valid Address.";
+
+        bool mIsCancelled = false;
        
        char* mWorkBuf;
        int mWorkBufSize;
@ -46,4 +50,4 @@ class Keyboard {
        int mTextCheckSize;
        char* mCustomizeDicBuf;
        int mCustomizeDicSize;
-};
+};
--- a/include/SocketBase.hpp
+++ b/include/SocketBase.hpp
@ -12,16 +12,17 @@ class SocketBase {
        SocketBase(const char *name);

        virtual nn::Result init(const char * ip, u16 port) = 0;
+        virtual bool closeSocket();

        const char *getStateChar();
        u8 getLogState();
-        s32 getSocket();
+        s32 getFd();

        void set_sock_flags(int flags);

-        bool closeSocket();

        void setName(const char *name) {strcpy(sockName, name);};
+        u32 socket_errno;

    protected:
        s32 socket_log(const char* str);
@ -31,9 +32,9 @@ class SocketBase {
        const char *sock_ip;

        u16 port;
-        u8 socket_log_state;
+        u8 socket_log_state = SOCKET_LOG_UNINITIALIZED;
        s32 socket_log_socket;
-        
+
        int sock_flags;
 };

--- a/include/actors/PuppetActor.h
+++ b/include/actors/PuppetActor.h
@ -33,6 +33,16 @@ class PuppetActor : public al::LiveActor {
        virtual void movement(void) override;
        virtual void makeActorAlive(void) override;
        virtual void makeActorDead(void) override;
+        virtual void calcAnim(void) override;
+        
+        virtual void attackSensor(al::HitSensor *, al::HitSensor *) override;
+        virtual bool receiveMsg(const al::SensorMsg*, al::HitSensor*, al::HitSensor*) override;
+
+        virtual const char* getName() const override {
+            if (mInfo)
+                return mInfo->puppetName;
+            return mActorName;
+        }

        void initOnline(PuppetInfo *pupInfo);

@ -47,8 +57,6 @@ class PuppetActor : public al::LiveActor {

        PuppetInfo* getInfo() { return mInfo; }

-        const char *getPuppetName() { return mInfo->puppetName; }
-
        bool addCapture(PuppetHackActor *capture, const char *hackType);

        al::LiveActor* getCurrentModel();
@ -59,27 +67,34 @@ class PuppetActor : public al::LiveActor {

        void debugTeleportCapture(const sead::Vector3f& pos, int index);

-        bool mIsDebug = false;
+        void emitJoinEffect();

-        float mClosingSpeed = 0;
+        bool mIsDebug = false;
        
-        NameTag *mNameTag = nullptr; // temp public 
    private:
        void changeModel(const char* newModel);

        bool setCapture(const char* captureName);

        void syncPose();
-        
+
        PlayerCostumeInfo *mCostumeInfo = nullptr;
        PuppetInfo *mInfo = nullptr;
        PuppetCapActor *mPuppetCap = nullptr;
        PlayerModelHolder *mModelHolder = nullptr;
        HackModelHolder* mCaptures = nullptr;
+        NameTag *mNameTag = nullptr;

        CaptureTypes::Type mCurCapture = CaptureTypes::Type::Unknown;

        bool mIs2DModel = false;

        bool mIsCaptureModel = false;
+
+        float mClosingSpeed = 0;
 };
+
+PlayerCostumeInfo* initMarioModelPuppet(al::LiveActor* player, const al::ActorInitInfo& initInfo,
+                                        char const* bodyName, char const* capName, int subActorNum,
+                                        al::AudioKeeper* audioKeeper);
+PlayerHeadCostumeInfo* initMarioHeadCostumeInfo(al::LiveActor* player, const al::ActorInitInfo &initInfo, const char* headModelName, const char* capModelName, const char* headType, const char* headSuffix);
--- a/include/agl/RenderBuffer.h
+++ b/include/agl/RenderBuffer.h
@ -7,6 +7,7 @@

 #include "RenderTargetColor.h"
 #include "RenderTargetDepth.h"
+#include "DrawContext.h"

 #include "sead/gfx/seadFrameBuffer.h"

--- a/include/al/LiveActor/LiveActor.h
+++ b/include/al/LiveActor/LiveActor.h
@ -19,6 +19,7 @@
 #include "al/sensor/HitSensorKeeper.h"
 #include "al/switch/StageSwitchKeeper.h"
 #include "al/actor/SubActorKeeper.h"
+#include "al/model/ModelKeeper.h"

 // vtable for LiveActor: 1C4EB58

@ -31,7 +32,6 @@ namespace al
    class ActorScoreKeeper;
    class Collider;
    class CollisionParts;
-    class ModelKeeper;
    class ShadowKeeper;
    class ActorPrePassLightKeeper;
    class ActorOcclusionKeeper;
@ -61,8 +61,10 @@ namespace al
        virtual void draw() const;
        virtual void startClipped();
        virtual void endClipped();
-        virtual void attackSensor(HitSensor *, HitSensor *);
-        virtual bool receiveMsg(const SensorMsg *, HitSensor *, HitSensor *);
+        // source = sensor belonging to this actor
+        // target = sensor belonging to other actor
+        virtual void attackSensor(HitSensor *source, HitSensor *target);
+        virtual bool receiveMsg(const SensorMsg *msg, HitSensor *source, HitSensor *target);
        virtual bool receiveMsgScreenPoint(const SensorMsg *, ScreenPointer *, ScreenPointTarget *);

        virtual const char *getName() const { return this->mActorName; };
@ -91,11 +93,13 @@ namespace al
        virtual al::CameraDirector *getCameraDirector() const { return this->mSceneInfo->mCameraDirector; };

        virtual void initStageSwitchKeeper() { this->mStageSwitchKeeper = new StageSwitchKeeper(); };
-
+        
        virtual void control();

        virtual void updateCollider();

+        void initSubActorKeeper(al::SubActorKeeper *);
+
        const char *mActorName;                                // 0x48
        al::ActorPoseKeeperBase *mPoseKeeper;                  // 0x50
        al::ActorExecuteInfo *mLayoutExecuteInfo;              // 0x58
--- a/include/al/PlayerHolder/PlayerHolder.h
+++ b/include/al/PlayerHolder/PlayerHolder.h
@ -1,5 +1,6 @@
 #pragma once

+#include "game/Player/PlayerActorBase.h"
 #include "sead/math/seadVector.h"
 #include "al/scene/Scene.h"
 #include "al/LiveActor/LiveActor.h"
@ -15,8 +16,8 @@ namespace al {
            PlayerHolder(int bufSize);
            void clear(void);
            void registerPlayer(al::LiveActor *, al::PadRumbleKeeper *);
-            PlayerActorHakoniwa *getPlayer(int) const;
-            PlayerActorHakoniwa *tryGetPlayer(int) const;
+            PlayerActorBase *getPlayer(int) const;
+            PlayerActorBase *tryGetPlayer(int) const;
            int getPlayerNum() const;
            int getBufferSize() const {return bufferSize;};
            bool isFull(void) const;
--- a/include/al/actor/ActorActionKeeper.h
+++ b/include/al/actor/ActorActionKeeper.h
@ -1,14 +1,13 @@
 #pragma once
-
-#include "al/LiveActor/LiveActor.h"
 #include "al/action/ActionEffectCtrl.h"

+#include "al/resource/ActorResource.h"
 #include "sead/math/seadVector.h"

 namespace al
 {
+    class LiveActor;

-    class ActorResource;
    class ActionAnimCtrl;
    class NerveActionCtrl;
    class ActionFlagCtrl;
--- a/include/al/actor/ActorSceneInfo.h
+++ b/include/al/actor/ActorSceneInfo.h
@ -6,6 +6,7 @@
 #include "al/scene/SceneObjHolder.h"
 #include "al/layout/LayoutInitInfo.h"
 #include "game/GameData/GameDataHolderBase.h"
+#include "al/gfx/GraphicsSystemInfo.h"

 namespace al {

@ -19,7 +20,6 @@ namespace al {
    struct ScreenCoverCtrl;
    struct ShadowDirector;
    struct ModelGroup;
-    struct GraphicsSystemInfo;
    struct PlayerHolder;
    struct ModelDrawBufferCounter;

--- a/include/al/actor/SubActorKeeper.h
+++ b/include/al/actor/SubActorKeeper.h
@ -1,7 +1,8 @@
 #pragma once

-
+#include "al/actor/ActorInitInfo.h"
 #include "container/seadPtrArray.h"
+
 namespace al {
    struct SubActorInfo {
        struct LiveActor* mActor;
@ -10,6 +11,13 @@ namespace al {
    };

    class SubActorKeeper {
+    public:
+        SubActorKeeper(al::LiveActor*);
+        static SubActorKeeper *tryCreate(al::LiveActor*, char const*, int);
+        static SubActorKeeper *create(al::LiveActor*);
+        void registerSubActor(al::LiveActor*, unsigned int);
+        void init(al::ActorInitInfo const&, char const*, int);
+
        al::LiveActor* mRootActor;
        sead::PtrArray<SubActorInfo> mArray;
    };
--- a/include/al/area/ChangeStageInfo.h
+++ b/include/al/area/ChangeStageInfo.h
@ -31,9 +31,9 @@ class ChangeStageInfo {

        sead::FixedSafeString<0x80> changeStageId; // 0x0 (Size: 0x98)
        sead::FixedSafeString<0x80> changeStageName; // 0xA0
-        sead::FixedSafeString<0x80> placementString; // 0x138
+        sead::FixedSafeString<0x80> placementString; // 0x130
        bool isReturn; // 0x1C8
-        int scenarioNo; // 0x1CC or 0x134
+        int scenarioNo; // 0x1CC
        SubScenarioType subType; // 0x1D0
        sead::FixedSafeString<0x80> wipeType; // 0x1D8
        int hintPriority; // 0x270
--- a/include/al/execute/ExecuteDirector.h
+++ b/include/al/execute/ExecuteDirector.h
@ -1,8 +1,48 @@
 #pragma once

+#include "al/async/FunctorBase.h"
+
+#include "IUseExecutor.h"
+#include "ExecuteSystemInitInfo.h"
+#include "ExecuteRequestKeeper.h"
+#include "ExecuteTableHolderDraw.h"
+#include "ExecuteTableHolderUpdate.h"
+#include "container/seadPtrArray.h"
+#include "container/seadBuffer.h"
+
 namespace al
 {
+
+    class LiveActor;
+    class LayoutActor;
+    
    class ExecuteDirector {
-        public:
+    public:
+        ExecuteDirector(int);
+        virtual ~ExecuteDirector();
+        void init(al::ExecuteSystemInitInfo const&);
+        void registerActorUpdate(al::LiveActor*, char const*);
+        void registerActorDraw(al::LiveActor*, char const*);
+        void registerActorModelDraw(al::LiveActor*, char const*);
+        void registerLayoutUpdate(al::LayoutActor*, char const*);
+        void registerLayoutDraw(al::LayoutActor*, char const*);
+        void registerUser(al::IUseExecutor*, char const*);
+        void registerFunctor(al::FunctorBase const&, char const*);
+        void registerFunctorDraw(al::FunctorBase const&, char const*);
+        void createExecutorListTable();
+        void execute(char const*) const;
+        void executeList(char const*, char const*) const;
+        void draw(char const*) const;
+        void drawList(char const*, char const*) const;
+        void isActiveDraw(char const*) const;
+
+        int mRequestMax;  // 0x8
+
+        int mUpdateTableCount;
+        al::ExecuteTableHolderUpdate **mUpdateTables;
+        int mDrawTableCount;
+        al::ExecuteTableHolderDraw **mDrawTables;
+
+        al::ExecuteRequestKeeper *mRequestKeeper;
    };
 } // namespace al
--- a/include/al/execute/ExecuteOrder.h
+++ b/include/al/execute/ExecuteOrder.h
@ -0,0 +1,11 @@
+#pragma once
+
+namespace al {
+    struct ExecuteOrder
+    {
+        const char *mListName;
+        const char *mExecuteGroup;
+        int mListMaxSize;
+        const char *mGroupType;
+    };
+}
--- a/include/al/execute/ExecuteRequestKeeper.h
+++ b/include/al/execute/ExecuteRequestKeeper.h
@ -0,0 +1,25 @@
+#pragma once
+
+#include "types.h"
+
+namespace al {
+  struct LiveActor;
+}
+
+namespace al {
+class ExecuteRequestKeeper {
+    public:
+        ExecuteRequestKeeper(int);
+        void executeRequestActorMovementAllOn();
+        void executeRequestActorMovementAllOff();
+        void executeRequestActorDrawAllOn();
+        void executeRequestActorDrawAllOff();
+        void request(al::LiveActor*, int);
+
+        void *mActorMovementAllOn; // 0x0
+        void *mActorMovementAllOff; // 0x8
+        void *mActorDrawAllOn; // 0x10
+        void *mActorDrawAllOff; // 0x18
+
+   };
+}
--- a/include/al/execute/ExecuteSystemInitInfo.h
+++ b/include/al/execute/ExecuteSystemInitInfo.h
@ -0,0 +1,9 @@
+#pragma once
+
+#include "agl/DrawContext.h"
+
+namespace al {
+    struct ExecuteSystemInitInfo {
+        agl::DrawContext *mDrawCtx;
+    };
+}
--- a/include/al/execute/ExecuteTable.h
+++ b/include/al/execute/ExecuteTable.h
@ -0,0 +1,12 @@
+#pragma once
+
+#include "ExecuteOrder.h"
+
+namespace al {
+    struct ExecuteTable
+    {
+        const char *mName;
+        const al::ExecuteOrder* mExecuteOrders;
+        int mExecuteOrderCount;
+    };
+}
--- a/include/al/execute/ExecuteTableHolderDraw.h
+++ b/include/al/execute/ExecuteTableHolderDraw.h
@ -0,0 +1,65 @@
+#pragma once
+
+#include <cstring>
+#include <string_view>
+#include "ExecuteOrder.h"
+#include "al/async/FunctorBase.h"
+#include "al/execute/ExecuteTable.h"
+#include "al/execute/ExecutorListBase.h"
+#include "al/execute/IUseExecutor.h"
+
+#include "container/seadPtrArray.h"
+#include "types.h"
+
+namespace al {
+    struct ExecuteSystemInitInfo;
+    struct ExecutorListActorModelDrawBase;
+    struct ExecutorListActorDraw;
+    struct ExecutorListLayoutDrawBase;
+    struct ExecutorListIUseExecutorDraw;
+    struct ExecutorListFunctor;
+    struct ExecutorListBase;
+    struct LiveActor;
+    struct LayoutActor;
+}
+
+namespace al {
+class ExecuteTableHolderDraw {
+    public:
+        ExecuteTableHolderDraw();
+        virtual ~ExecuteTableHolderDraw();
+        void init(char const*, al::ExecuteSystemInitInfo const&, al::ExecuteOrder const*, int);
+        void registerExecutorListActorModel(al::ExecutorListActorModelDrawBase*);
+        void registerExecutorListActor(al::ExecutorListActorDraw*);
+        void registerExecutorListLayout(al::ExecutorListLayoutDrawBase*);
+        void registerExecutorListUser(al::ExecutorListIUseExecutorDraw*);
+        void registerExecutorListFunctor(al::ExecutorListFunctor*);
+        void registerExecutorListAll(al::ExecutorListBase*);
+        void tryRegisterActor(al::LiveActor*, char const*);
+        void tryRegisterActorModel(al::LiveActor*, char const*);
+        void tryRegisterLayout(al::LayoutActor*, char const*);
+        void tryRegisterUser(al::IUseExecutor*, char const*);
+        void tryRegisterFunctor(al::FunctorBase const&, char const*);
+        void createExecutorListTable();
+        void execute() const;
+        void executeList(char const*) const;
+        bool isActive() const;
+
+        const char* mName;
+
+        sead::PtrArray<al::ExecutorListBase> mActiveExecutors;
+        sead::PtrArray<al::ExecutorListBase> mExecutorsAll;
+        sead::PtrArray<al::ExecutorListActorDraw> mExecutorsActor;
+        sead::PtrArray<al::ExecutorListActorModelDrawBase> mExecutorsActorModel;
+        sead::PtrArray<al::ExecutorListLayoutDrawBase> mExecutorsLayout;
+        sead::PtrArray<al::ExecutorListIUseExecutorDraw> mExecutorsUser;
+        sead::PtrArray<al::ExecutorListFunctor> mExecutorsFunctor;
+
+   };
+}
+
+extern "C" al::ExecuteTable gameDrawTable[]; // pointer to original draw table found in the exefs
+
+extern const al::ExecuteTable drawTable[];
+
+extern int drawTableSize;
--- a/include/al/execute/ExecuteTableHolderUpdate.h
+++ b/include/al/execute/ExecuteTableHolderUpdate.h
@ -0,0 +1,58 @@
+#pragma once
+
+#include "ExecuteOrder.h"
+#include "al/async/FunctorBase.h"
+#include "al/execute/ExecuteTable.h"
+#include "al/execute/ExecutorListBase.h"
+#include "al/execute/IUseExecutor.h"
+#include "ExecuteSystemInitInfo.h"
+
+#include "container/seadPtrArray.h"
+#include "types.h"
+
+namespace al {
+    struct ExecutorListActorExecuteBase;
+    struct ExecutorListLayoutUpdate;
+    struct ExecutorListIUseExecutorUpdate;
+    struct ExecutorListFunctor;
+    struct ExecutorListBase;
+    struct LiveActor;
+    struct LayoutActor;
+}
+
+namespace al {
+class ExecuteTableHolderUpdate {
+    public:
+        ExecuteTableHolderUpdate();
+        virtual ~ExecuteTableHolderUpdate();
+        void init(char const*, al::ExecuteSystemInitInfo const&, al::ExecuteOrder const*, int);
+        void registerExecutorListActor(al::ExecutorListActorExecuteBase*);
+        void registerExecutorListLayout(al::ExecutorListLayoutUpdate*);
+        void registerExecutorListUser(al::ExecutorListIUseExecutorUpdate*);
+        void registerExecutorListFunctor(al::ExecutorListFunctor*);
+        void registerExecutorListAll(al::ExecutorListBase*);
+        void tryRegisterActor(al::LiveActor*, char const*);
+        void tryRegisterLayout(al::LayoutActor*, char const*);
+        void tryRegisterUser(al::IUseExecutor*, char const*);
+        void tryRegisterFunctor(al::FunctorBase const&, char const*);
+        void createExecutorListTable();
+        void execute() const;
+        void executeList(char const*) const;
+
+        const char *mName;
+        sead::PtrArray<al::ExecutorListBase> mActiveExecutors;
+        sead::PtrArray<al::ExecutorListBase> mExecutorsAll;
+        sead::PtrArray<al::ExecutorListActorExecuteBase> mExecutorsActor;
+        sead::PtrArray<al::ExecutorListLayoutUpdate> mExecutorsLayout;
+        sead::PtrArray<al::ExecutorListIUseExecutorUpdate> mExecutorsUser;
+        sead::PtrArray<al::ExecutorListFunctor> mExecutorsFunctor;
+
+   };
+}  // namespace al
+
+extern "C" al::ExecuteTable gameUpdateTable[]; // pointer to original update table found in the exefs
+
+extern const al::ExecuteTable updateTable[];
+
+extern int updateTableSize;
+
--- a/include/al/execute/ExecutorListBase.h
+++ b/include/al/execute/ExecutorListBase.h
@ -0,0 +1,15 @@
+#pragma once
+
+#include "types.h"
+
+namespace al {
+    class ExecutorListBase {
+    public:
+        ExecutorListBase(char const*);
+        virtual ~ExecutorListBase();
+        virtual void executeList() const;
+        virtual bool isActive() const;
+
+        const char *mName;
+    };
+}
--- a/include/al/gfx/GraphicsSystemInfo.h
+++ b/include/al/gfx/GraphicsSystemInfo.h
@ -0,0 +1,193 @@
+#pragma once
+
+#include "al/execute/ExecuteDirector.h"
+#include "al/model/ModelMaterialCategory.h"
+#include "al/resource/Resource.h"
+#include "container/seadPtrArray.h"
+#include "gfx/seadCamera.h"
+
+#include "UniformBlock.h"
+#include "types.h"
+
+namespace al {
+    struct GraphicsInitArg;
+    struct GraphicsUpdateInfo;
+    struct GraphicsCalcGpuInfo;
+    struct PartsGraphics;
+    struct GraphicsRenderInfo;
+    struct GraphicsCopyInfo;
+    struct GraphicsComputeInfo;
+    struct AreaObjDirector;
+    struct EffectSystem;
+    struct SceneCameraInfo;
+    struct ShaderHolder;
+    struct GBufferArray;
+    struct Projection;
+    struct RenderVariables;
+    struct ShaderCubeMapKeeper;
+    struct ShaderMirrorDirector;
+    struct SubCameraRenderer;
+    struct GraphicsParamFilePath;
+    struct PlayerHolder;
+}
+
+namespace agl {
+    struct DrawContext;
+
+    namespace utl {
+        struct ParameterOfBool { char size[0x20]; };
+        struct ParameterOfInt { char size[0x20]; };
+        struct ParameterOfFloat { char size[0x20]; };
+        struct IParameterObj { char size[0x30]; };
+        struct IParameterIO { char size[0x1D0]; };
+    }
+}
+
+namespace al {
+    class GraphicsSystemInfo {
+    public:
+        GraphicsSystemInfo();
+        ~GraphicsSystemInfo();
+        void getModelEnv() const;
+        void getDrawContext() const;
+        void getShaderCubeMapKeeper() const;
+        void getViewIndexedUboArray(char const*) const;
+        void setViewIndexedUboArray(char const*, sead::PtrArray<al::UniformBlock> const*);
+        void initAtmosScatter(al::ExecuteDirector*);
+        void init(al::GraphicsInitArg const&, al::AreaObjDirector*, al::ExecuteDirector*, al::EffectSystem*, al::PlayerHolder*, al::SceneCameraInfo*, al::ShaderHolder*);
+        void initProjectResource();
+        void initStageResource(al::Resource const*, char const*, char const*);
+        void endInit();
+        void initAfterPlacement();
+        void initAfterCreateDrawTable();
+        void setDrawEnv(int, al::GBufferArray*, sead::Camera const*, al::Projection const*);
+        void clearGraphicsRequest();
+        void cancelLerp();
+        void updateGraphics();
+        void updatePartsGraphics(al::GraphicsUpdateInfo const&);
+        void preDrawGraphics(al::SceneCameraInfo const*);
+        void calcGpuPartsGraphics(al::GraphicsCalcGpuInfo const&);
+        void updateViewGpu(int, sead::Camera const*, al::Projection const*);
+        void updateViewVolume(sead::Matrix34f const&, sead::Matrix44<float> const&);
+        void clearViewVolume();
+        void tryGetAtmosLightDir(sead::Vector3f*) const;
+        void tryDirectionalLightInfo(sead::Vector3f*) const;
+        void activateDirLitColorTex() const;
+        void activateDirLitColorTex(agl::DrawContext*) const;
+        void registPartsGraphics(al::PartsGraphics*);
+        void drawSystemPartsGraphics(al::GraphicsRenderInfo const*) const;
+        void doPartsGraphicsCommandBufferCopy(al::GraphicsCopyInfo const&) const;
+        void doPartsGraphicsCompute(al::GraphicsComputeInfo const&) const;
+        void drawPartsGraphics(al::GraphicsRenderInfo const&, al::RenderVariables const&) const;
+        void drawPartsGraphicsGBufferAfterSky(al::GraphicsRenderInfo const&) const;
+        void drawPartsGraphicsDeferred(al::GraphicsRenderInfo const&) const;
+        void drawPartsGraphicsLdr(al::GraphicsRenderInfo const&) const;
+        void drawPartsGraphicsIndirect(al::GraphicsRenderInfo const&, al::RenderVariables const&) const;
+        void drawPartsGraphicsCubemap(al::GraphicsRenderInfo const&) const;
+
+        void *qword0;
+        void *qword8;
+        void *qword10;
+        void *qword18;
+        char gap20[5];
+        char byte25;
+        u16 word26;
+        int dword28;
+        int dword2C;
+        int dword30;
+        int dword34;
+        int dword38;
+        int dword3C;
+        char byte40;
+        int dword44;
+        char byte48;
+        int dword4C;
+        int dword50;
+        int dword54;
+        int dword58;
+        int dword5C;
+        void *qword60;
+        char char68;
+        al::ShaderCubeMapKeeper **field_70;
+        char gap78[56];
+        al::ShadowDirector *field_B0;
+        char gapB8[16];
+        al::ShaderMirrorDirector *field_C8;
+        char gapD0[320];
+        char char210;
+        void *qword218;
+        void *qword220;
+        void *qword228;
+        void *qword230;
+        al::MaterialCategoryKeeper *mMaterialCategoryKeeper;
+        void *qword240;
+        void *qword248;
+        void *qword250;
+        void *qword258;
+        void *qword260;
+        void *qword268;
+        void *qword270;
+        void *qword278;
+        void *qword280;
+        al::GpuMemAllocator *field_288;
+        char gap290[8];
+        void *qword298;
+        void *qword2A0;
+        char gap2A8[8];
+        void *qword2B0;
+        al::SubCameraRenderer *field_2B8;
+        void *qword2C0;
+        void *qword2C8;
+        void *qword2D0;
+        void *qword2D8;
+        void *qword2E0;
+        void *qword2E8;
+        int dword2F0;
+        __attribute__((packed)) __attribute__((aligned(1))) void *qword2F4;
+        __attribute__((packed)) __attribute__((aligned(1))) void *qword2FC;
+        __attribute__((packed)) __attribute__((aligned(1))) void *qword304;
+        int dword30C;
+        al::GraphicsParamFilePath *mParamFilePath;
+        agl::utl::IParameterIO agl__utl__iparameterio318;
+        agl::utl::IParameterObj agl__utl__iparameterobj4E8;
+        agl::utl::ParameterOfInt field_518;
+        agl::utl::ParameterOfInt field_538;
+        agl::utl::ParameterOfBool field_558;
+        agl::utl::ParameterOfBool field_578;
+        agl::utl::ParameterOfInt field_598;
+        agl::utl::IParameterIO field_5B8;
+        agl::utl::IParameterObj field_788;
+        agl::utl::ParameterOfBool field_7B8;
+        agl::utl::ParameterOfBool field_7D8;
+        agl::utl::ParameterOfBool field_7F8;
+        agl::utl::ParameterOfFloat field_818;
+        agl::utl::ParameterOfFloat field_838;
+        agl::utl::ParameterOfFloat field_858;
+        agl::utl::ParameterOfFloat field_878;
+        agl::utl::ParameterOfFloat field_898;
+        agl::utl::ParameterOfFloat field_8B8;
+        agl::utl::ParameterOfFloat field_8D8;
+        agl::utl::ParameterOfFloat field_8F8;
+        void *qword918;
+        void *qword920;
+        void *qword928;
+        void *qword930;
+        void *qword938;
+        void *qword940;
+        void *qword948;
+        void *qword950;
+        void *qword958;
+        int dword960;
+        void *qword968;
+        void *qword970;
+        int dword978;
+        void *qword980;
+        al::ModelOcclusionCullingDirector *field_988;
+        void *qword990;
+        al::ModelShaderHolder *field_998;
+        al::PrepassTriangleCulling *field_9A0;
+        char byte9A8;
+        void *field_9B0;
+
+   };
+}
--- a/include/al/gfx/UniformBlock.h
+++ b/include/al/gfx/UniformBlock.h
@ -0,0 +1,12 @@
+#pragma once
+
+#include "types.h"
+
+namespace al {
+    class UniformBlock { 
+        UniformBlock();
+        ~UniformBlock();
+        void swap();
+
+    };
+}
--- a/include/al/model/ModelCtrl.h
+++ b/include/al/model/ModelCtrl.h
@ -0,0 +1,107 @@
+#pragma once
+
+#include "agl/DisplayList.h"
+#include "al/resource/Resource.h"
+#include "math/seadMatrix.h"
+#include "nn/g3d/ResModel.h"
+
+namespace  al {
+    struct ShaderHolder;
+    struct ModelShaderHolder;
+    struct ModelOcclusionCullingDirector;
+    struct ShadowDirector;
+    struct PrepassTriangleCulling;
+    struct ModelLodCtrl;
+    struct DitherAnimator;
+    struct ModelMaterialCategory;
+    struct GpuMemAllocator;
+}
+
+namespace nn { namespace g3d {
+    struct Sphere;
+}}
+
+namespace al {
+    class ModelCtrl {
+    public:
+        ModelCtrl();
+        ~ModelCtrl();
+        void initialize(nn::g3d::ResModel*, int, int, sead::Heap*, al::ShaderHolder*);
+        void tryBindShader();
+        void tryUpdateModelAdditionalInfoUbo(int);
+        void updateWorldMatrix(sead::Matrix34f const&, sead::Vector3f const&);
+        void updateGpuBuffer(int);
+        void calcBounding();
+        void getLodLevel() const;
+        void getLodLevelDepthShadow() const;
+        void calcBoundingLod(int);
+        void updateQueryBox();
+        void updateModelDrawBuffer(int);
+        void updateGpuBufferAll();
+        void isShapeVisible(int) const;
+        void setCubeMapIndexAllShape(int);
+        void recreateDisplayList();
+        void setMaterialProgrammable(int, bool);
+        void isMaterialProgrammable(int);
+        void setSkeletonUpdateInfo(bool, sead::Matrix34f const&, sead::Vector3f const&);
+        void setDirtyTexture();
+        void onZPrePass();
+        void offZPrePass();
+        void getEnvTexInfo(int) const;
+        void requestModelAdditionalInfoUbo();
+        void setLodCtrl(al::ModelLodCtrl*);
+        void getLodLevelMax() const;
+        void getLodLevelMaterial() const;
+        void getLodLevelNoClamp() const;
+        void setLodLevelForce(int);
+        void updateLodCtrl();
+        void setDitherAnimator(al::DitherAnimator*);
+        void updateDitherAnimator();
+        void checkChangeDisplayList();
+        void addToDrawerCulling();
+        void removeFromDrawerCulling();
+        void updateSubMesh();
+        void setModelMaterialCategory(al::ModelMaterialCategory const*);
+        void setModelAlphaMask(float);
+        void setModelUvOffset(sead::Vector2f const&);
+        void setModelProjMtx0(sead::Matrix44<float> const&);
+        void setModelProjMtx1(sead::Matrix44<float> const&);
+        void setModelProjMtx2(sead::Matrix44<float> const&);
+        void setModelProgProjMtx0(sead::Matrix44<float> const&);
+        void setModelProgProjMtx1(sead::Matrix44<float> const&);
+        void setModelProgProjMtx2(sead::Matrix44<float> const&);
+        void setModelProgProjMtx3(sead::Matrix44<float> const&);
+        void setModelProgConstant0(float);
+        void setModelProgConstant1(float);
+        void setModelProgConstant2(float);
+        void setModelProgConstant3(float);
+        void setModelProgConstant4(float);
+        void setModelProgConstant5(float);
+        void setModelProgConstant6(float);
+        void setModelProgConstant7(float);
+        void setNormalAxisXScale(float);
+        void calcCameraToBoundingSphereDistance() const;
+        void isUseLocalShadowMap() const;
+        void validateOcclusionQuery();
+        void invalidateOcclusionQuery();
+        void isValidOcclusionQuery() const;
+        void createUniqShader();
+        void isCreateUniqShader(int);
+        void getUniqModelShader(int);
+        void getUniqModelShaderAssgin(int);
+        void pushDisplayListModel(agl::DisplayList*);
+        void pushDisplayListShape(agl::DisplayList*, int);
+        void getModelShapeCtrl(int) const;
+        void initResource(al::Resource*, al::Resource*);
+        void initModel(al::GpuMemAllocator*, al::ModelShaderHolder*, al::ModelOcclusionCullingDirector*, al::ShadowDirector*, al::PrepassTriangleCulling*, int, int);
+        void tryCreateCulledIndexBuffer();
+        void show();
+        void hide();
+        void calc(sead::Matrix34f const&, sead::Vector3f const&);
+        void calcView();
+        void calcModelObjBoundingWithOffset(nn::g3d::Sphere*) const;
+        void setCameraInfo(sead::Matrix34f const*, sead::Matrix34f const*, sead::Matrix44<float> const*, sead::Matrix44<float> const*);
+        void getShapeObj(int) const;
+
+   };
+}
--- a/include/al/model/ModelKeeper.h
+++ b/include/al/model/ModelKeeper.h
@ -0,0 +1,46 @@
+#pragma once
+
+#include "al/resource/ActorResource.h"
+#include "math/seadMatrix.h"
+#include "types.h"
+#include "ModelCtrl.h"
+
+namespace al {
+    struct ModelLodCtrl;
+    struct DitherAnimator;
+    struct GpuMemAllocator;
+    struct ModelShaderHolder;
+    struct ModelOcclusionCullingDirector;
+    struct ShadowDirector;
+    struct PrepassTriangleCulling;
+}
+
+namespace al {
+    class ModelKeeper {
+    public:
+        ModelKeeper();
+        virtual ~ModelKeeper();
+        void initResource(al::ActorResource const*);
+        void createMatAnimForProgram(int);
+        void getAnimResource() const;
+        void getModelResource() const;
+        void setDisplayRootJointMtxPtr(sead::Matrix34f const*);
+        void setModelLodCtrl(al::ModelLodCtrl*);
+        void setDitherAnimator(al::DitherAnimator*);
+        void initModel(int, al::GpuMemAllocator*, al::ModelShaderHolder*, al::ModelOcclusionCullingDirector*, al::ShadowDirector*, al::PrepassTriangleCulling*);
+        void show();
+        void hide();
+        void update();
+        void updateLast();
+        void calc(sead::Matrix34f const&, sead::Vector3f const&);
+        void getBaseMtx() const;
+        void getWorldMtxPtrByIndex(int) const;
+
+        const char *mResourceName;
+        al::ModelCtrl *mModelCtrl;
+        const al::ActorResource *mResource;
+        char gap20[67];
+        bool field_63;
+
+   };
+}
--- a/include/al/model/ModelMaterialCategory.h
+++ b/include/al/model/ModelMaterialCategory.h
@ -0,0 +1,19 @@
+#pragma once
+
+#include "ModelCtrl.h"
+#include "al/byaml/ByamlIter.h"
+
+namespace al {
+    struct MaterialCategoryKeeper;
+
+    class ModelMaterialCategory {
+        public:
+        ModelMaterialCategory(al::ModelCtrl*, al::MaterialCategoryKeeper*);
+        void init(char const*);
+        void init(al::ByamlIter const&);
+        void getCategoryIdFromMaterialName(char const*) const;
+        void getCategoryIdFromMaterialIndex(int) const;
+        static void tryCreate(al::ModelCtrl*, al::Resource const*, char const*, al::MaterialCategoryKeeper*);
+        static void tryCreate(al::ModelCtrl*, char const*, al::MaterialCategoryKeeper*);
+    };
+}
--- a/include/al/model/PartsModel.h
+++ b/include/al/model/PartsModel.h
@ -0,0 +1,42 @@
+#pragma once
+
+#include "al/LiveActor/LiveActor.h"
+#include "types.h"
+
+namespace al {
+class PartsModel : public al::LiveActor {
+    public:
+        PartsModel(char const*);
+        void endClipped() override;
+        void calcAnim() override;
+        void attackSensor(al::HitSensor*, al::HitSensor*) override;
+        bool receiveMsg(al::SensorMsg const*, al::HitSensor*, al::HitSensor*) override;
+
+        void initPartsDirect(al::LiveActor*, al::ActorInitInfo const&, char const*, sead::Matrix34f const*, sead::Vector3f const&, sead::Vector3f const&, sead::Vector3f const&, bool);
+        void initPartsSuffix(al::LiveActor*, al::ActorInitInfo const&, char const*, char const*, sead::Matrix34f const*, bool);
+        void initPartsMtx(al::LiveActor*, al::ActorInitInfo const&, char const*, sead::Matrix34f const*, bool);
+        void initPartsFixFile(al::LiveActor*, al::ActorInitInfo const&, char const*, char const*, char const*);
+        void initPartsFixFileNoRegister(al::LiveActor*, al::ActorInitInfo const&, char const*,
+                                        char const*, char const*);
+        
+        void updatePose();
+        void offSyncAppearAndHide();
+        void onSyncAppearAndHide();
+
+        void *unkPtr1; // 0x108
+        void* unkPtr2; // 0x110
+        int unkInt1;   // 0x118
+        int unkInt2; // 0x11C
+        int unkInt3; // 0x120
+        int unkInt4; // 0x124
+        int unkInt5;  // 0x128
+        int unkInt6;  // 0x12C
+        int unkInt7;  // 0x130
+        float unkFloat1; // 0x134
+        float unkFloat2; // 0x138
+        float unkFloat3;  // 0x13C
+        bool unkBool; // 0x140
+        bool unkBool2; // 0x141
+        bool unkBool3; // 0x142
+   };
+}
--- a/include/al/resource/ActorResource.h
+++ b/include/al/resource/ActorResource.h
@ -0,0 +1,35 @@
+#pragma once
+
+#include "prim/seadSafeString.h"
+#include "types.h"
+#include "Resource.h"
+
+namespace al {
+
+    class AnimInfoTable { char size[0x18]; };
+
+    struct InitResourceDataAnim {
+        al::AnimInfoTable *mInfoTable; // 0x0
+        al::AnimInfoTable *mFclAnim; // 0x8
+        al::AnimInfoTable *mFtsAnim; // 0x10
+        al::AnimInfoTable *mFtpAnim; // 0x18
+        al::AnimInfoTable *mInfoTable2; // 0x18
+    };
+
+    class ActorResource {
+        public:
+        ActorResource(sead::SafeString const&, al::Resource*, al::Resource*);
+        virtual ~ActorResource();
+
+        void initResourceData(char const*, bool);
+
+        sead::FixedSafeString<0x80> unkStr;  // 0x8
+        al::Resource *mResourceModel; // 0xA0
+        al::Resource *mResourceAnim;  // 0xA8
+        bool unkBool1;        // 0xB0
+        al::InitResourceDataAnim *mAnimResData; // 0xB8
+        void *unkPtr2; // 0xC0
+    };
+}
+
+static_assert(sizeof(al::ActorResource) == 0xC8, "ActorResource Size");
--- a/include/al/resource/ActorResourceHolder.h
+++ b/include/al/resource/ActorResourceHolder.h
@ -0,0 +1,20 @@
+#pragma once
+
+#include "Resource.h"
+#include "types.h"
+
+namespace al {
+    class ActorResourceHolder {
+
+        ActorResourceHolder(int);
+        ~ActorResourceHolder();
+
+        void tryFindActorResource(sead::SafeString const&);
+        void findActorResourceImpl(sead::SafeString const&);
+        void createActorResource(sead::SafeString const&, al::Resource*, al::Resource*);
+        void removeAll();
+        void eraseResourceUser(al::Resource*);
+        void freeErasedActorResource();
+
+    };
+}
--- a/include/al/resource/Resource.h
+++ b/include/al/resource/Resource.h
@ -0,0 +1,48 @@
+#pragma once
+
+#include <heap/seadHeap.h>
+#include <prim/seadSafeString.h>
+#include <resource/seadArchiveRes.h>
+#include <filedevice/seadArchiveFileDevice.h>
+
+#include "nn/g3d/g3d_ResFile.h"
+
+namespace al {
+    class Resource {
+    public:
+        Resource(sead::SafeString const&);
+        Resource(sead::SafeString const&, sead::ArchiveRes*);
+
+        bool isExistFile(sead::SafeString const&) const;
+        bool isExistByml(char const*) const;
+
+        int getSize() const;
+
+        int getEntryNum(sead::SafeString const&) const;
+        const char *getEntryName(sead::BufferedSafeString*, sead::SafeString const&, unsigned int) const;
+
+        void getFileSize(sead::SafeString const&) const;
+        void getByml(sead::SafeString const&) const;
+        void getFile(sead::SafeString const&) const;
+        void tryGetByml(sead::SafeString const&) const;
+        void getKcl(sead::SafeString const&) const;
+        void tryGetKcl(sead::SafeString const&) const;
+        void getPa(sead::SafeString const&) const;
+        void tryGetPa(sead::SafeString const&) const;
+        void getOtherFile(sead::SafeString const&) const;
+        const char* getArchiveName() const;
+        
+        bool tryCreateResGraphicsFile(sead::SafeString const&, nn::g3d::ResFile*);
+        void cleanupResGraphicsFile();
+
+        sead::ArchiveRes* mArc;                // 0x0
+        sead::ArchiveFileDevice *mFileDevice;  // 0x8
+        sead::FixedSafeString<0x80> mArcName;  // 0x10
+        sead::Heap* mCurrentHeap;              // 0xA8
+        void *unkPtr;                          // 0xB0
+        nn::g3d::ResFile *mResGfxFile;         // 0xB8
+
+    };
+}  // namespace al
+
+static_assert(sizeof(al::Resource) == 0xC0, "al::Resource Size");    
--- a/include/al/scene/Scene.h
+++ b/include/al/scene/Scene.h
@ -5,11 +5,19 @@
 #include "al/audio/AudioKeeper.h"
 #include "al/camera/CameraDirector.h"
 #include "al/scene/SceneObjHolder.h"
+#include "prim/seadSafeString.h"

 namespace al
 {

    class GraphicsInitArg;
+    class StageResourceKeeper;
+    class LiveActorKit;
+    class LayoutKit;
+    class SceneStopCtrl;   
+    class SceneMsgCtrl;    
+    class ScreenCoverCtrl; 
+    class AudioDirector;   

    class Scene : public al::NerveExecutor, public al::IUseAudioKeeper, public al::IUseCamera, public al::IUseSceneObjHolder
    {
@ -32,6 +40,17 @@ namespace al

        void initLiveActorKitWithGraphics(al::GraphicsInitArg const &, al::SceneInitInfo const &, int, int, int);

-        unsigned char _28[0xD8-0x28];
+        bool mIsAlive;
+        sead::FixedSafeString<0x40> mName;
+        al::StageResourceKeeper *mStageResourceKeeper;
+        al::LiveActorKit *mActorKit;
+        al::LayoutKit *mLayoutKit;
+        al::SceneObjHolder *mSceneObjHolder;
+        al::SceneStopCtrl *mSceneStopCtrl;
+        al::SceneMsgCtrl *mSceneMsgCtrl;
+        al::ScreenCoverCtrl *mScreenCoverCtrl;
+        al::AudioDirector *mAudioDirector;
+        al::AudioKeeper *mAudioKeeper;
+        al::NerveKeeper *mNerveKeeper;
    };
 };
--- a/include/al/scene/SceneCreator.h
+++ b/include/al/scene/SceneCreator.h
@ -8,6 +8,6 @@ namespace al
    {
    public:
        virtual al::SceneCreator* getSceneCreator() const = 0;
-        virtual al::SceneCreator* setSceneCreator() const = 0;
+        virtual void setSceneCreator(al::SceneCreator* ) = 0;
    };
 };
--- a/include/al/scene/SceneObjFactory.h
+++ b/include/al/scene/SceneObjFactory.h
@ -0,0 +1,89 @@
+#pragma once
+
+#include "al/scene/ISceneObj.h"
+#include "al/scene/SceneObjHolder.h"
+#include "SceneObjs.h"
+
+al::ISceneObj *sub_4C4300(int objIndex) {
+    switch (objIndex)
+    {
+        case 0:
+            return new AmiiboNpcDirector();
+        case 1:
+            return new BgmAnimeSyncDirector();
+        case 3:
+            return new CapManHeroDemoDirector();
+        case 4:
+            return new CapMessageDirector();
+        case 5:
+            return new CapMessageMoonNotifier();
+        case 7:
+            return new CoinCollectHolder();
+        case 8:
+            return new CoinCollectWatcher();
+        case 9:
+            return new CollectBgmPlayer();
+        case 11:
+            return new EchoEmitterHolder();
+        case 12:
+            return new ElectricWireCameraTicketHolder();
+        case 17:
+            return new FukankunZoomObjHolder();
+        case 21:
+            return new GrowPlantDirector();
+        case 22:
+            return new GuidePosInfoHolder();
+        case 23:
+            return new HintPhotoLayoutHolder();
+        case 26:
+            return new HtmlViewerRequester();
+        case 29:
+            return new KidsModeLayoutAccessor();
+        case 34:
+            return new LoginLotteryDirector();
+        case 36:
+            return new MoviePlayer();
+        case 39:
+            return new PaintObjHolder();
+        case 42:
+            return new PlayerStartInfoHolder();
+        case 44:
+            return new QuestInfoHolder(64);
+        case 49:
+            return new RandomItemSelector();
+        case 52:
+            return nullptr;
+        case 53:
+            return new RhyhtmInfoWatcher("");
+        case 55:
+            return new RouteGuideDirector();
+        case 56:
+            return new SceneEventNotifier();
+        case 60:
+            return new al::StageSyncCounter();
+        case 62:
+            return new TalkNpcParamHolder();
+        case 63:
+            return new TalkNpcSceneEventSwitcher();
+        case 64:
+            return new TestStageTimeDirector();
+        case 65:
+            return new TimeBalloonDirector();
+        case 70:
+            return new TsukkunTraceHolder();
+        case 71:
+            return new WipeHolderRequester();
+        case 72:
+            return new YoshiFruitWatcher();
+        case 73:
+            return new HelpAmiiboDirector();
+        default:
+            return nullptr;
+    }
+}
+
+class SceneObjFactory {
+public:
+    al::SceneObjHolder *createSceneObjHolder(void) { return new al::SceneObjHolder(&sub_4C4300, 0x4A);}
+};
+
--- a/include/al/scene/SceneObjHolder.h
+++ b/include/al/scene/SceneObjHolder.h
@ -4,9 +4,11 @@

 namespace al {

+    typedef al::ISceneObj* (*SceneObjCreator)(int);
+
    class SceneObjHolder {
    public:
-        SceneObjHolder(al::ISceneObj* (*)(int), int);
+        SceneObjHolder(SceneObjCreator, int);
        
        ISceneObj *tryGetObj(int) const; // unsafe get still
        void setSceneObj(al::ISceneObj *,int);
@ -15,8 +17,14 @@ namespace al {
        ISceneObj *getObj(int) const;
        void create(int);

+        SceneObjCreator mObjCreator;
+        al::ISceneObj **mSceneObjs;
+        int mMaxObjCount;
+        
    };

+    static_assert(sizeof(SceneObjHolder) == 0x18, "SceneObjHolder Size");
+
    class IUseSceneObjHolder
    {
    public:
--- a/include/al/scene/SceneObjs.h
+++ b/include/al/scene/SceneObjs.h
@ -0,0 +1,179 @@
+#pragma once
+
+#include "al/scene/ISceneObj.h"
+#include "al/scene/SceneObjHolder.h"
+#include "game/SceneObjs/RouteGuideDirector.h"
+
+// temp header to cleanup SceneObjFactory
+
+namespace al {
+    struct StageSyncCounter : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+    };
+}
+
+struct AmiiboNpcDirector : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct BgmAnimeSyncDirector : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct CapManHeroDemoDirector : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct CapMessageDirector : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct CapMessageMoonNotifier : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct CoinCollectHolder : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct CoinCollectWatcher : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct CollectBgmPlayer : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct EchoEmitterHolder : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct ElectricWireCameraTicketHolder : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct FukankunZoomObjHolder : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct GrowPlantDirector : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct GuidePosInfoHolder : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct HintPhotoLayoutHolder : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct HtmlViewerRequester : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct KidsModeLayoutAccessor : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct LoginLotteryDirector : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct MoviePlayer : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct PaintObjHolder : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct PlayerStartInfoHolder : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct RandomItemSelector : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct SceneEventNotifier : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct TalkNpcParamHolder : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct TalkNpcSceneEventSwitcher : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct TestStageTimeDirector : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct TimeBalloonDirector : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct TsukkunTraceHolder : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct WipeHolderRequester : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct YoshiFruitWatcher : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+struct HelpAmiiboDirector : public al::ISceneObj {
+        virtual const char* getSceneObjName() override;
+        virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+        virtual void initSceneObj(void) override;
+};
+
+struct QuestInfoHolder : public al::ISceneObj {
+    QuestInfoHolder(int);
+    virtual const char* getSceneObjName() override;
+    virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+    virtual void initSceneObj(void) override;
+};
+struct RhyhtmInfoWatcher : public al::ISceneObj {
+    RhyhtmInfoWatcher(const char*);
+    virtual const char* getSceneObjName() override;
+    virtual void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+    virtual void initSceneObj(void) override;
+};
--- a/include/al/sensor/HitSensorKeeper.h
+++ b/include/al/sensor/HitSensorKeeper.h
@ -1,7 +1,6 @@
 #pragma once

 #include "types.h"
-#include "al/LiveActor/LiveActor.h"
 #include "al/sensor/SensorHitGroup.h"
 #include "sead/math/seadVector.h"
 #include "sead/math/seadMatrix.h"
@ -9,6 +8,9 @@

 namespace al
 {
+
+    class LiveActor;
+
    class HitSensorKeeper
    {
    public:
--- a/include/al/sequence/Sequence.h
+++ b/include/al/sequence/Sequence.h
@ -1,12 +1,61 @@
 #pragma once

+#include "al/audio/AudioDirector.h"
 #include "al/nerve/NerveExecutor.h"
 #include "al/audio/AudioKeeper.h"
 #include "al/scene/SceneCreator.h"
+#include "game/System/GameDrawInfo.h"

 namespace al {
+
+    class GameSystemInfo;
+    class SequenceInitInfo;
+    class AudioSystemInfo;
+    class Scene;
+
    class Sequence : public al::NerveExecutor, public al::IUseAudioKeeper, public al::IUseSceneCreator {
        public:
-            Sequence(const char *seqName);
+            Sequence(const char* name);
+            virtual ~Sequence() override;
+            virtual void init(const al::SequenceInitInfo& initInfo);
+            virtual void update();
+            virtual void kill();
+            virtual void drawMain() const;
+            virtual void drawSub() const;
+            virtual bool isDisposable() { return false; }
+            al::Scene* getCurrentScene() const;
+            al::SceneCreator* getSceneCreator() const override;
+            void setSceneCreator(al::SceneCreator* sceneCreator) override;
+
+            al::AudioKeeper* getAudioKeeper() const override;
+            void initAudio(const al::GameSystemInfo&, const char*, int, int, int, const char*);
+            void initAudioKeeper(const char*);
+            void initDrawSystemInfo(const al::SequenceInitInfo&);
+            al::AudioSystemInfo* getAudioSystemInfo();
+
+            al::GameDrawInfo* getDrawInfo() const {
+                return mGameDrawInfo;
+            }
+
+            al::AudioDirector* getAudioDirector() const {
+                return mAudioDirector;
+            }
+
+            void setNextScene(al::Scene* scene) {
+                mNextScene = scene;
+            }
+
+            const sead::SafeString& getName() const {
+                return mName;
+            }
+
+            const sead::FixedSafeString<0x40> mName;
+            al::Scene* mNextScene;
+            al::Scene* mCurrentScene;
+            al::SceneCreator* mSceneCreator;
+            al::AudioDirector* mAudioDirector;
+            al::AudioKeeper* mAudioKeeper;
+            al::GameDrawInfo* mGameDrawInfo;
+            bool mIsAlive;
    };
 }
--- a/include/al/util.hpp
+++ b/include/al/util.hpp
@ -10,6 +10,7 @@
 #include "al/util/MathUtil.h"
 #include "al/util/NerveUtil.h"
 #include "al/util/CameraUtil.h"
+#include "al/util/KitUtil.h"

 namespace al
 {
@ -72,6 +73,9 @@ namespace al
    PlayerActorBase *tryGetPlayerActor(al::PlayerHolder const *, int);

    sead::Heap *getCurrentHeap(void);
+    sead::Heap* getStationedHeap();
+    sead::Heap* getSequenceHeap();
+    sead::Heap* getSceneHeap();

    al::Projection *getProjection(al::IUseCamera const *, int);

@ -242,7 +246,7 @@ namespace al
    bool tryGetByamlColor(sead::Color4f *,al::ByamlIter const&);
    bool tryGetByamlColor(sead::Color4f *,al::ByamlIter const&,char const*);
    bool tryGetByamlBool(bool *,al::ByamlIter const&,char const*);
-    bool tryGetByamlKeyStringOrNULL(al::ByamlIter const&,char const*);
+    const char * tryGetByamlKeyStringOrNULL(al::ByamlIter const&,char const*);
    bool tryGetByamlKeyIntOrZero(al::ByamlIter const&,char const*);
    bool tryGetByamlKeyU32OrZero(al::ByamlIter const&,char const*);
    bool tryGetByamlKeyFloatOrZero(al::ByamlIter const&,char const*);
--- a/include/al/util/KitUtil.h
+++ b/include/al/util/KitUtil.h
@ -0,0 +1,17 @@
+#pragma once
+
+#include "al/scene/Scene.h"
+
+namespace al {
+
+    class LayoutKit;
+    class LiveActorKit;
+
+    void updateKitList(al::Scene *,char const*,char const*);
+    void updateKitList(al::Scene*, char const*);
+    
+    void executeUpdateList(al::LayoutKit *,char const*,char const*);
+    void executeUpdateList(al::LiveActorKit*, char const*, char const*);
+
+    void executeDrawList(al::LiveActorKit const*,char const*,char const*);
+}
--- a/include/al/util/LiveActorUtil.h
+++ b/include/al/util/LiveActorUtil.h
@ -7,6 +7,7 @@
 #include "al/LiveActor/LiveActor.h"
 #include "al/async/FunctorBase.h"
 #include "al/collision/Collider.h"
+#include "game/Player/PlayerActorBase.h"
 #include "game/Player/PlayerActorHakoniwa.h"
 #include "al/layout/LayoutActor.h"
 #include "al/layout/LayoutInitInfo.h"
@ -25,11 +26,14 @@ namespace al {
    void onSyncClippingSubActor(LiveActor*, const LiveActor*);
    void onSyncHideSubActor(LiveActor*, const LiveActor*);
    void onSyncAlphaMaskSubActor(LiveActor*, const LiveActor*);
+    void onSyncAppearSubActor(al::LiveActor *,al::LiveActor const*);
+    void onSyncAppearSubActor(al::LiveActor *,char const*);
+    void onSyncAppearSubActorAll(al::LiveActor *);
    void setMaterialProgrammable(LiveActor*);
    void startAction(LiveActor*, char const*);
    void startAction(IUseLayoutAction*, const char *, const char *);
    void startFreezeActionEnd(IUseLayoutAction *,char const*,char const*);
-    void startHitReaction(LiveActor*, char const*);
+    void startHitReaction(const LiveActor *, char const*);
    void invalidateClipping(const LiveActor *);
    void validateClipping(const LiveActor *);
    void setNerveAtActionEnd(LiveActor*, const al::Nerve*);
@ -40,6 +44,8 @@ namespace al {
    void turnToTarget(LiveActor*, const al::LiveActor *, float);

    void expandClippingRadiusByShadowLength(LiveActor *,sead::Vector3f *, float);
+    void addPartialSklAnimPartsListRecursive(al::LiveActor*, char const*, int);
+    void setMaterialProgrammable(al::LiveActor *);

    void initJointLocalXRotator(const LiveActor *,const float *,const char *);
    void initJointLocalYRotator(const LiveActor *,const float *,const char *);
@ -55,7 +61,23 @@ namespace al {
    void initActorPoseTQGSV(al::LiveActor *);
    void initActorPoseTQGMSV(al::LiveActor *);
    void initActorPoseT(al::LiveActor *,sead::Vector3<float> const&);
-    void initActorPoseTR(al::LiveActor *,sead::Vector3<float> const&,sead::Vector3<float> const&);
+    void initActorPoseTR(al::LiveActor*, sead::Vector3<float> const&, sead::Vector3<float> const&);
+
+    void initActorSRT(al::LiveActor*, al::ActorInitInfo const&);
+    void initActorSceneInfo(al::LiveActor *, al::ActorInitInfo const&);
+    void initActorModelKeeper(al::LiveActor *,al::ActorInitInfo const&,al::ActorResource const*,int);
+    void initActorModelKeeper(al::LiveActor*, al::ActorInitInfo const&, char const*, int,
+                              char const*);
+    void initActorEffectKeeper(al::LiveActor*, al::ActorInitInfo const&, char const*);
+    void initActorActionKeeper(al::LiveActor *,al::ActorInitInfo const&,char const*,char const*);
+    void initActorActionKeeper(al::LiveActor*, al::ActorResource const*, char const*, char const*);
+    void initActorClipping(al::LiveActor *,al::ActorInitInfo const&);
+    void initPartialSklAnim(al::LiveActor*, int, int, int);
+
+    bool tryGetActorInitFileIterAndName(al::ByamlIter *,sead::BufferedSafeStringBase<char> *,al::Resource const*,char const*,char const*);
+    bool tryGetActorInitFileIter(al::ByamlIter *,al::Resource const*,char const*,char const*);
+    bool tryGetActorInitFileIterAndName(al::ByamlIter *,sead::BufferedSafeStringBase<char> *,al::LiveActor const*,char const*,char const*);
+    bool tryGetActorInitFileIter(al::ByamlIter *,al::LiveActor const*,char const*,char const*);

    void initLayoutPartsActor(LayoutActor*, LayoutActor*, const LayoutInitInfo&, char const*,
                              char const*);
@ -91,7 +113,7 @@ namespace al {

    bool tryOnSwitchDeadOn(IUseStageSwitch *);
    bool trySyncStageSwitchAppear(LiveActor *);
-    PlayerActorHakoniwa* tryFindNearestPlayerActor(const LiveActor *);
+    PlayerActorBase* tryFindNearestPlayerActor(const LiveActor *);
    bool tryFindNearestPlayerPos(sead::Vector3f *, const LiveActor *);
    bool tryAddRippleMiddle(LiveActor*);
    bool tryStartActionIfNotPlaying(LiveActor*, const char*);
--- a/include/al/util/ResourceUtil.h
+++ b/include/al/util/ResourceUtil.h
@ -0,0 +1,17 @@
+#pragma once
+
+#include "al/LiveActor/LiveActor.h"
+#include "al/resource/ActorResourceHolder.h"
+#include "al/resource/ActorResource.h"
+
+namespace al {
+
+    al::ActorResource *findOrCreateActorResource(al::ActorResourceHolder *,char const*,char const*);
+    al::ActorResource* findOrCreateActorResourceWithAnimResource(al::ActorResourceHolder*,
+                                                                 char const*, char const*,
+                                                                 char const*, bool);
+
+    al::Resource *getModelResource(al::LiveActor const*);
+    al::Resource *getModelResourceYaml(al::LiveActor const*,char const*,char const*);
+
+}
--- a/include/al/util/SensorUtil.h
+++ b/include/al/util/SensorUtil.h
@ -0,0 +1,480 @@
+#pragma once
+
+#include "al/sensor/HitSensor.h"
+#include "al/sensor/HitSensorKeeper.h"
+#include "al/sensor/SensorHitGroup.h"
+
+#include "al/LiveActor/LiveActor.h" // for SensorMsg
+
+#include <math/seadVector.h>
+
+struct SaveObjInfo;
+struct HackEndParam;
+struct IUsePlayerCollision;
+struct IUsePlayerHack;
+
+struct DigPoint;
+struct TouchTargetInfo;
+struct WhipTargetInfo;
+struct CapTargetInfo;
+struct GotogotonMark;
+struct FishingFish;
+
+typedef unsigned int uint;
+
+namespace al
+{
+
+    struct ComboCounter;
+    struct EventFlowExecutor;
+    struct ParabolicPath;
+
+    sead::Vector3f *getSensorPos(al::HitSensor const *);
+    sead::Vector3f* getActorTrans(al::HitSensor const*);
+
+    bool tryReceiveMsgPushAndAddVelocity(al::LiveActor*, al::SensorMsg const*, al::HitSensor const*,
+                                         al::HitSensor const*, float);
+
+    bool isSensorTypeYoshiEnableSendPush(al::HitSensor const*);
+    bool isSensorTypeYoshiMsgReceivable(al::HitSensor const*);
+    bool isSensorValid(al::HitSensor const*);
+    bool isSensorName(al::HitSensor const*, char const*);
+    bool isSensorHostName(al::HitSensor const*, char const*);
+    bool isSensorHost(al::HitSensor const*, al::LiveActor const*);
+    bool isSensorValid(al::LiveActor const*, char const*);
+    bool isSensorBindableAll(al::HitSensor const*);
+    bool isSensorEnemy(al::HitSensor const*);
+    bool isSensorEnemyAttack(al::HitSensor const*);
+    bool isSensorEnemyBody(al::HitSensor const*);
+    bool isSensorEye(al::HitSensor const*);
+    bool isSensorMapObj(al::HitSensor const*);
+    bool isSensorNpc(al::HitSensor const*);
+    bool isSensorPlayerAll(al::HitSensor const*);
+    bool isSensorRide(al::HitSensor const*);
+    bool isSensorPlayerAttack(al::HitSensor const*);
+    bool isSensorPlayer(al::HitSensor const*);
+    bool isSensorPlayerFoot(al::HitSensor const*);
+    bool isSensorPlayerDecoration(al::HitSensor const*);
+    bool isSensorPlayerEye(al::HitSensor const*);
+    bool isSensorPlayerOrPlayerWeapon(al::HitSensor const*);
+    bool isSensorCollision(al::HitSensor const*);
+    bool isSensorPlayerFireBall(al::HitSensor const*);
+    bool isSensorHoldObj(al::HitSensor const*);
+    bool isSensorLookAt(al::HitSensor const*);
+    bool isSensorBindableGoal(al::HitSensor const*);
+    bool isSensorBindableAllPlayer(al::HitSensor const*);
+    bool isSensorBindableBubbleOutScreen(al::HitSensor const*);
+    bool isSensorBindableKoura(al::HitSensor const*);
+    bool isSensorBindableRouteDokan(al::HitSensor const*);
+    bool isSensorBindableBubblePadInput(al::HitSensor const*);
+    bool isSensorBindable(al::HitSensor const*);
+    bool isSensorSimple(al::HitSensor const*);
+    bool isSensorHitAnyPlane(al::HitSensor const*,al::HitSensor const*, sead::Vector3<float> const&);
+    bool isSensorHitRingShape(al::HitSensor const*, al::HitSensor const*, float);
+
+    bool isMsgRequestPlayerStainWet(al::SensorMsg const *, int *);
+    bool isMsgPushAll(al::SensorMsg const *);
+    bool isMsgPush(al::SensorMsg const *);
+    bool isMsgPushStrong(al::SensorMsg const *);
+    bool isMsgPushVeryStrong(al::SensorMsg const *);
+    bool isMsgHoldReleaseAll(al::SensorMsg const *);
+    bool isMsgHoldCancel(al::SensorMsg const *);
+    bool isMsgPlayerRelease(al::SensorMsg const *);
+    bool isMsgPlayerReleaseBySwing(al::SensorMsg const *);
+    bool isMsgPlayerReleaseDead(al::SensorMsg const *);
+    bool isMsgPlayerReleaseDamage(al::SensorMsg const *);
+    bool isMsgPlayerReleaseDemo(al::SensorMsg const *);
+    bool isMsgItemGetDirectAll(al::SensorMsg const *);
+    bool isMsgPlayerItemGet(al::SensorMsg const *);
+    bool isMsgRideAllPlayerItemGet(al::SensorMsg const *);
+    bool isMsgPlayerTailAttack(al::SensorMsg const *);
+    bool isMsgItemGetByObjAll(al::SensorMsg const *);
+    bool isMsgBallItemGet(al::SensorMsg const *);
+    bool isMsgKickKouraItemGet(al::SensorMsg const *);
+    bool isMsgKillerItemGet(al::SensorMsg const *);
+    bool isMsgItemGetAll(al::SensorMsg const *);
+    bool isMsgFloorTouch(al::SensorMsg const *);
+    bool isMsgPlayerFloorTouch(al::SensorMsg const *);
+    bool isMsgEnemyFloorTouch(al::SensorMsg const *);
+    bool isMsgUpperPunch(al::SensorMsg const *);
+    bool isMsgPlayerUpperPunch(al::SensorMsg const *);
+    bool isMsgEnemyUpperPunch(al::SensorMsg const *);
+    bool isMsgPlayerTrample(al::SensorMsg const *);
+    bool isMsgPlayerTrampleReflect(al::SensorMsg const *);
+    bool isMsgPlayerHipDropAll(al::SensorMsg const *);
+    bool isMsgPlayerStatueDrop(al::SensorMsg const *);
+    bool isMsgPlayerObjHipDropAll(al::SensorMsg const *);
+    bool isMsgPlayerObjStatueDrop(al::SensorMsg const *);
+    bool isMsgPlayerObjHipDropReflectAll(al::SensorMsg const *);
+    bool isMsgPlayerObjStatueDropReflect(al::SensorMsg const *);
+    bool isMsgPlayerObjHipDropHighJump(al::SensorMsg const *);
+    bool isMsgPlayerHipDropKnockDown(al::SensorMsg const *);
+    bool isMsgPlayerObjStatueDropReflectNoCondition(al::SensorMsg const *);
+    bool isMsgPlayerStatueTouch(al::SensorMsg const *);
+    bool isMsgPlayerObjUpperPunch(al::SensorMsg const *);
+    bool isMsgPlayerRollingAttack(al::SensorMsg const *);
+    bool isMsgPlayerRollingReflect(al::SensorMsg const *);
+    bool isMsgPlayerObjRollingAttack(al::SensorMsg const *);
+    bool isMsgPlayerObjRollingAttackFailure(al::SensorMsg const *);
+    bool isMsgPlayerInvincibleAttack(al::SensorMsg const *);
+    bool isMsgPlayerFireBallAttack(al::SensorMsg const *);
+    bool isMsgPlayerRouteDokanFireBallAttack(al::SensorMsg const *);
+    bool isMsgPlayerKick(al::SensorMsg const *);
+    bool isMsgPlayerCatch(al::SensorMsg const *);
+    bool isMsgPlayerSlidingAttack(al::SensorMsg const *);
+    bool isMsgPlayerBoomerangAttack(al::SensorMsg const *);
+    bool isMsgPlayerBoomerangAttackCollide(al::SensorMsg const *);
+    bool isMsgPlayerBoomerangReflect(al::SensorMsg const *);
+    bool isMsgPlayerBoomerangBreak(al::SensorMsg const *);
+    bool isMsgPlayerBodyAttack(al::SensorMsg const *);
+    bool isMsgPlayerBodyLanding(al::SensorMsg const *);
+    bool isMsgPlayerBodyAttackReflect(al::SensorMsg const *);
+    bool isMsgPlayerClimbAttack(al::SensorMsg const *);
+    bool isMsgPlayerSpinAttack(al::SensorMsg const *);
+    bool isMsgPlayerGiantAttack(al::SensorMsg const *);
+    bool isMsgPlayerCooperationHipDrop(al::SensorMsg const *);
+    bool isMsgPlayerClimbSlidingAttack(al::SensorMsg const *);
+    bool isMsgPlayerClimbRollingAttack(al::SensorMsg const *);
+    bool isMsgPlayerGiantHipDrop(al::SensorMsg const *);
+    bool isMsgPlayerDisregard(al::SensorMsg const *);
+    bool isMsgPlayerDash(al::SensorMsg const *);
+    bool isMsgPlayerDamageTouch(al::SensorMsg const *);
+    bool isMsgPlayerFloorTouchBind(al::SensorMsg const *);
+    bool isMsgPlayerTouch(al::SensorMsg const *);
+    bool isMsgPlayerInvincibleTouch(al::SensorMsg const *);
+    bool isMsgPlayerGiantTouch(al::SensorMsg const *);
+    bool isMsgPlayerObjTouch(al::SensorMsg const *);
+    bool isMsgPlayerPutOnEquipment(al::SensorMsg const *);
+    bool isMsgPlayerReleaseEquipment(al::SensorMsg const *);
+    bool isMsgPlayerReleaseEquipmentGoal(al::SensorMsg const *);
+    bool isMsgPlayerCarryFront(al::SensorMsg const *);
+    bool isMsgPlayerCarryFrontWallKeep(al::SensorMsg const *);
+    bool isMsgPlayerCarryUp(al::SensorMsg const *);
+    bool isMsgPlayerCarryKeepDemo(al::SensorMsg const *);
+    bool isMsgPlayerCarryWarp(al::SensorMsg const *);
+    bool isMsgPlayerLeave(al::SensorMsg const *);
+    bool isMsgPlayerToss(al::SensorMsg const *);
+    bool isMsgEnemyAttack(al::SensorMsg const *);
+    bool isMsgEnemyAttackFire(al::SensorMsg const *);
+    bool isMsgEnemyAttackKnockDown(al::SensorMsg const *);
+    bool isMsgEnemyAttackBoomerang(al::SensorMsg const *);
+    bool isMsgEnemyAttackNeedle(al::SensorMsg const *);
+    bool isMsgEnemyItemGet(al::SensorMsg const *);
+    bool isMsgEnemyRouteDokanAttack(al::SensorMsg const *);
+    bool isMsgEnemyRouteDokanFire(al::SensorMsg const *);
+    bool isMsgExplosion(al::SensorMsg const *);
+    bool isMsgExplosionCollide(al::SensorMsg const *);
+    bool isMsgBindStart(al::SensorMsg const *);
+    bool isMsgBindInit(al::SensorMsg const *);
+    bool isMsgBindEnd(al::SensorMsg const *);
+    bool isMsgBindCancel(al::SensorMsg const *);
+    bool isMsgBindCancelByDemo(al::SensorMsg const *);
+    bool isMsgBindDamage(al::SensorMsg const *);
+    bool isMsgBindSteal(al::SensorMsg const *);
+    bool isMsgBindGiant(al::SensorMsg const *);
+    bool isMsgPressureDeath(al::SensorMsg const *);
+    bool isMsgNpcTouch(al::SensorMsg const *);
+    bool isMsgHit(al::SensorMsg const *);
+    bool isMsgHitStrong(al::SensorMsg const *);
+    bool isMsgHitVeryStrong(al::SensorMsg const *);
+    bool isMsgKnockDown(al::SensorMsg const *);
+    bool isMsgMapPush(al::SensorMsg const *);
+    bool isMsgVanish(al::SensorMsg const *);
+    bool isMsgChangeAlpha(al::SensorMsg const *);
+    bool isMsgShowModel(al::SensorMsg const *);
+    bool isMsgHideModel(al::SensorMsg const *);
+    bool isMsgRestart(al::SensorMsg const *);
+    bool isMsgEnemyTouch(al::SensorMsg const *);
+    bool isMsgEnemyTrample(al::SensorMsg const *);
+    bool isMsgMapObjTrample(al::SensorMsg const *);
+    bool isMsgNeedleBallAttack(al::SensorMsg const *);
+    bool isMsgPunpunFloorTouch(al::SensorMsg const *);
+    bool isMsgInvalidateFootPrint(al::SensorMsg const *);
+    bool isMsgKickKouraAttack(al::SensorMsg const *);
+    bool isMsgKickKouraAttackCollide(al::SensorMsg const *);
+    bool isMsgKickKouraReflect(al::SensorMsg const *);
+    bool isMsgKickKouraCollideNoReflect(al::SensorMsg const *);
+    bool isMsgKickKouraBreak(al::SensorMsg const *);
+    bool isMsgKickKouraBlow(al::SensorMsg const *);
+    bool isMsgKickStoneAttack(al::SensorMsg const *);
+    bool isMsgKickStoneAttackCollide(al::SensorMsg const *);
+    bool isMsgKickStoneAttackHold(al::SensorMsg const *);
+    bool isMsgKickStoneAttackReflect(al::SensorMsg const *);
+    bool isMsgKickStoneTrample(al::SensorMsg const *);
+    bool isMsgKillerAttack(al::SensorMsg const *);
+    bool isMsgLiftGeyser(al::SensorMsg const *);
+    bool isMsgWarpStart(al::SensorMsg const *);
+    bool isMsgWarpEnd(al::SensorMsg const *);
+    bool isMsgHoleIn(al::SensorMsg const *);
+    bool isMsgJumpInhibit(al::SensorMsg const *);
+    bool isMsgGoalKill(al::SensorMsg const *);
+    bool isMsgGoal(al::SensorMsg const *);
+    bool isMsgBallAttack(al::SensorMsg const *);
+    bool isMsgBallRouteDokanAttack(al::SensorMsg const *);
+    bool isMsgBallAttackHold(al::SensorMsg const *);
+    bool isMsgBallAttackDRCHold(al::SensorMsg const *);
+    bool isMsgBallAttackCollide(al::SensorMsg const *);
+    bool isMsgBallTrample(al::SensorMsg const *);
+    bool isMsgBallTrampleCollide(al::SensorMsg const *);
+    bool isMsgFireBallCollide(al::SensorMsg const *);
+    bool isMsgFireBallFloorTouch(al::SensorMsg const *);
+    bool isMsgDokanBazookaAttack(al::SensorMsg const *);
+    bool isMsgSwitchOn(al::SensorMsg const *);
+    bool isMsgSwitchOnInit(al::SensorMsg const *);
+    bool isMsgSwitchOffInit(al::SensorMsg const *);
+    bool isMsgSwitchKillOn(al::SensorMsg const *);
+    bool isMsgSwitchKillOnInit(al::SensorMsg const *);
+    bool isMsgSwitchKillOffInit(al::SensorMsg const *);
+    bool isMsgAskSafetyPoint(al::SensorMsg const *);
+    bool isMsgTouchAssist(al::SensorMsg const *);
+    bool isMsgTouchAssistNoPat(al::SensorMsg const *);
+    bool isMsgTouchAssistTrig(al::SensorMsg const *);
+    bool isMsgTouchAssistTrigOff(al::SensorMsg const *);
+    bool isMsgTouchAssistTrigNoPat(al::SensorMsg const *);
+    bool isMsgTouchAssistBurn(al::SensorMsg const *);
+    bool isMsgTouchAssistAll(al::SensorMsg const *);
+    bool isMsgTouchCarryItem(al::SensorMsg const *);
+    bool isMsgTouchReleaseItem(al::SensorMsg const *);
+    bool isMsgTouchStroke(al::SensorMsg const *);
+    bool isMsgIsNerveSupportFreeze(al::SensorMsg const *);
+    bool isMsgOnSyncSupportFreeze(al::SensorMsg const *);
+    bool isMsgOffSyncSupportFreeze(al::SensorMsg const *);
+    bool isMsgScreenPointInvalidCollisionParts(al::SensorMsg const *);
+    bool isMsgBlockUpperPunch(al::SensorMsg const *);
+    bool isMsgBlockLowerPunch(al::SensorMsg const *);
+    bool isMsgBlockItemGet(al::SensorMsg const *);
+    bool isMsgPlayerKouraAttack(al::SensorMsg const *);
+    bool isMsgLightFlash(al::SensorMsg const *);
+    bool isMsgForceAbyss(al::SensorMsg const *);
+    bool isMsgSwordAttackHigh(al::SensorMsg const *);
+    bool isMsgSwordAttackHighLeft(al::SensorMsg const *);
+    bool isMsgSwordAttackHighRight(al::SensorMsg const *);
+    bool isMsgSwordAttackLow(al::SensorMsg const *);
+    bool isMsgSwordAttackLowLeft(al::SensorMsg const *);
+    bool isMsgSwordAttackLowRight(al::SensorMsg const *);
+    bool isMsgSwordBeamAttack(al::SensorMsg const *);
+    bool isMsgSwordBeamReflectAttack(al::SensorMsg const *);
+    bool isMsgSwordAttackJumpUnder(al::SensorMsg const *);
+    bool isMsgShieldGuard(al::SensorMsg const *);
+    bool isMsgAskMultiPlayerEnemy(al::SensorMsg const *);
+    bool isMsgItemGettable(al::SensorMsg const *);
+    bool isMsgKikkiThrow(al::SensorMsg const *);
+    bool isMsgIsKikkiThrowTarget(al::SensorMsg const *);
+    bool isMsgPlayerCloudGet(al::SensorMsg const *);
+    bool isMsgAutoJump(al::SensorMsg const *);
+    bool isMsgPlayerTouchShadow(al::SensorMsg const *);
+    bool isMsgPlayerPullOutShadow(al::SensorMsg const *);
+    bool isMsgPlayerAttackShadow(al::SensorMsg const *);
+    bool isMsgPlayerAttackShadowStrong(al::SensorMsg const *);
+    bool isMsgPlayerAttackChangePos(al::SensorMsg const *);
+    bool isMsgAtmosOnlineLight(al::SensorMsg const *);
+    bool isMsgLightBurn(al::SensorMsg const *);
+    bool isMsgMoonLightBurn(al::SensorMsg const *);
+    bool isMsgString(al::SensorMsg const *);
+    bool isMsgStringV4fPtr(al::SensorMsg const *);
+    bool isMsgStringV4fSensorPtr(al::SensorMsg const *);
+    bool isMsgStringVoidPtr(al::SensorMsg const *);
+    bool isMsgPlayerTrampleForCrossoverSensor(al::SensorMsg const *, al::HitSensor const *, al::HitSensor const *);
+    bool isMsgPlayerTrampleReflectForCrossoverSensor(al::SensorMsg const *, al::HitSensor const *, al::HitSensor const *);
+    bool isMsgPlayerUpperPunchForCrossoverSensor(al::SensorMsg const *, al::HitSensor const *, al::HitSensor const *, float);
+    bool isMsgKickStoneTrampleForCrossoverSensor(al::SensorMsg const *, al::HitSensor const *, al::HitSensor const *);
+
+    bool sendMsgPlayerAttackTrample(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerTrampleReflect(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerReflectOrTrample(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerHipDrop(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerObjHipDrop(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerObjHipDropReflect(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerObjHipDropHighJump(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerHipDropKnockDown(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerStatueDrop(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerObjStatueDrop(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerObjStatueDropReflect(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerObjStatueDropReflectNoCondition(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerStatueTouch(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerUpperPunch(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerObjUpperPunch(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerRollingAttack(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerRollingReflect(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerObjRollingAttack(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerObjRollingAttackFailure(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerInvincibleAttack(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerFireBallAttack(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerRouteDokanFireBallAttack(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerTailAttack(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerTouch(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerKick(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerCatch(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerSlidingAttack(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerBoomerangAttack(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerBoomerangAttackCollide(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerBoomerangReflect(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerBoomerangBreak(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerBodyAttack(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerBodyLanding(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerBodyAttackReflect(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerClimbAttack(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerSpinAttack(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerGiantAttack(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerCooperationHipDrop(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerClimbSlidingAttack(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerClimbRollingAttack(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerGiantHipDrop(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPlayerDisregard(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerItemGet(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerPutOnEquipment(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerReleaseEquipment(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerReleaseEquipmentGoal(al::HitSensor *, al::HitSensor *, uint);
+    bool sendMsgPlayerFloorTouch(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerDamageTouch(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerCarryFront(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerCarryFrontWallKeep(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerCarryUp(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerCarryKeepDemo(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerCarryWarp(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerLeave(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerRelease(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerReleaseBySwing(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerReleaseDamage(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerReleaseDead(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerReleaseDemo(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerToss(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerInvincibleTouch(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgEnemyAttack(al::HitSensor *, al::HitSensor *);
+    bool sendMsgEnemyAttackBoomerang(al::HitSensor *, al::HitSensor *);
+    bool sendMsgEnemyAttackFire(al::HitSensor *, al::HitSensor *, char const *);
+    bool sendMsgEnemyAttackNeedle(al::HitSensor *, al::HitSensor *);
+    bool sendMsgEnemyFloorTouch(al::HitSensor *, al::HitSensor *);
+    bool sendMsgEnemyItemGet(al::HitSensor *, al::HitSensor *);
+    bool sendMsgEnemyRouteDokanAttack(al::HitSensor *, al::HitSensor *);
+    bool sendMsgEnemyRouteDokanFire(al::HitSensor *, al::HitSensor *);
+    bool sendMsgEnemyTouch(al::HitSensor *, al::HitSensor *);
+    bool sendMsgEnemyUpperPunch(al::HitSensor *, al::HitSensor *);
+    bool sendMsgEnemyTrample(al::HitSensor *, al::HitSensor *);
+    bool sendMsgMapObjTrample(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPressureDeath(al::HitSensor *, al::HitSensor *);
+    bool sendMsgNpcTouch(al::HitSensor *, al::HitSensor *);
+    bool sendMsgExplosion(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgExplosionCollide(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgPush(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPushStrong(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPushVeryStrong(al::HitSensor *, al::HitSensor *);
+    bool sendMsgHit(al::HitSensor *, al::HitSensor *);
+    bool sendMsgHitStrong(al::HitSensor *, al::HitSensor *);
+    bool sendMsgHitVeryStrong(al::HitSensor *, al::HitSensor *);
+    bool sendMsgKnockDown(al::HitSensor *, al::HitSensor *);
+    bool sendMsgMapPush(al::HitSensor *, al::HitSensor *);
+    bool sendMsgVanish(al::HitSensor *, al::HitSensor *);
+    bool sendMsgChangeAlpha(al::LiveActor *, float);
+    bool sendMsgShowModel(al::HitSensor *, al::HitSensor *);
+    bool sendMsgHideModel(al::HitSensor *, al::HitSensor *);
+    bool sendMsgRestart(al::HitSensor *, al::HitSensor *);
+    bool sendMsgNeedleBallAttack(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPunpunFloorTouch(al::HitSensor *, al::HitSensor *);
+    bool sendMsgInvalidateFootPrint(al::HitSensor *, al::HitSensor *);
+    bool sendMsgKickKouraAttack(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgKickKouraAttackCollide(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgKickKouraGetItem(al::HitSensor *, al::HitSensor *);
+    bool sendMsgKickKouraReflect(al::HitSensor *, al::HitSensor *);
+    bool sendMsgKickKouraCollideNoReflect(al::HitSensor *, al::HitSensor *);
+    bool sendMsgKickKouraBreak(al::HitSensor *, al::HitSensor *);
+    bool sendMsgKickKouraBlow(al::HitSensor *, al::HitSensor *);
+    bool sendMsgKickStoneAttack(al::HitSensor *, al::HitSensor *);
+    bool sendMsgKickStoneAttackCollide(al::HitSensor *, al::HitSensor *);
+    bool sendMsgKickStoneAttackHold(al::HitSensor *, al::HitSensor *);
+    bool sendMsgKickStoneAttackReflect(al::HitSensor *, al::HitSensor *);
+    bool sendMsgKickStoneTrample(al::HitSensor *, al::HitSensor *);
+    bool sendMsgKillerAttack(al::HitSensor *, al::HitSensor *);
+    bool sendMsgLiftGeyser(al::HitSensor *, al::HitSensor *);
+    bool sendMsgWarpStart(al::HitSensor *, al::HitSensor *);
+    bool sendMsgWarpEnd(al::HitSensor *, al::HitSensor *);
+    bool sendMsgHoldCancel(al::HitSensor *, al::HitSensor *);
+    bool sendMsgHoleIn(al::HitSensor *, al::HitSensor *);
+    bool sendMsgJumpInhibit(al::HitSensor *, al::HitSensor *);
+    bool sendMsgGoalKill(al::HitSensor *, al::HitSensor *);
+    bool sendMsgGoal(al::HitSensor *, al::HitSensor *);
+    bool sendMsgBindStart(al::HitSensor *, al::HitSensor *);
+    bool sendMsgBindInit(al::HitSensor *, al::HitSensor *, uint);
+    bool sendMsgBindEnd(al::HitSensor *, al::HitSensor *);
+    bool sendMsgBindCancel(al::HitSensor *, al::HitSensor *);
+    bool sendMsgBindCancelByDemo(al::HitSensor *, al::HitSensor *);
+    bool sendMsgBindDamage(al::HitSensor *, al::HitSensor *);
+    bool sendMsgBindSteal(al::HitSensor *, al::HitSensor *);
+    bool sendMsgBindGiant(al::HitSensor *, al::HitSensor *);
+    bool sendMsgBallAttack(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgBallRouteDokanAttack(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgBallAttackHold(al::HitSensor *, al::HitSensor *);
+    bool sendMsgBallAttackDRCHold(al::HitSensor *, al::HitSensor *);
+    bool sendMsgBallAttackCollide(al::HitSensor *, al::HitSensor *);
+    bool sendMsgBallTrample(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgBallTrampleCollide(al::HitSensor *, al::HitSensor *);
+    bool sendMsgBallItemGet(al::HitSensor *, al::HitSensor *);
+    bool sendMsgFireBalCollide(al::HitSensor *, al::HitSensor *);
+    bool sendMsgFireBallFloorTouch(al::HitSensor *, al::HitSensor *);
+    bool sendMsgDokanBazookaAttack(al::HitSensor *, al::HitSensor *);
+    bool sendMsgRideAllPlayerItemGet(al::HitSensor *, al::HitSensor *);
+    bool sendMsgHideModel(al::LiveActor *);
+    bool sendMsgShowModel(al::LiveActor *);
+    bool sendMsgRestart(al::LiveActor *);
+    bool sendMsgCollisionImpulse(al::HitSensor *, al::HitSensor *, sead::Vector3f *, sead::Vector3f const &, float, sead::Vector3f const &, float);
+    bool sendMsgSwitchOn(al::LiveActor *);
+    bool sendMsgSwitchOnInit(al::LiveActor *);
+    bool sendMsgSwitchOffInit(al::LiveActor *);
+    bool sendMsgSwitchKillOn(al::LiveActor *);
+    bool sendMsgSwitchKillOnInit(al::LiveActor *);
+    bool sendMsgSwitchKillOffInit(al::LiveActor *);
+    bool sendMsgPlayerFloorTouchToColliderGround(al::LiveActor *, al::HitSensor *);
+    bool sendMsgPlayerUpperPunchToColliderCeiling(al::LiveActor *, al::HitSensor *);
+    bool sendMsgEnemyFloorTouchToColliderGround(al::LiveActor *, al::HitSensor *);
+    bool sendMsgEnemyUpperPunchToColliderCeiling(al::LiveActor *, al::HitSensor *);
+    bool sendMsgAskSafetyPoint(al::HitSensor *, al::HitSensor *, sead::Vector3f **);
+    bool sendMsgAskSafetyPointToColliderGround(al::LiveActor *, al::HitSensor *, sead::Vector3f **);
+    bool sendMsgTouchAssist(al::HitSensor *, al::HitSensor *);
+    bool sendMsgTouchAssistTrig(al::HitSensor *, al::HitSensor *);
+    bool sendMsgTouchStroke(al::HitSensor *, al::HitSensor *);
+    bool sendMsgScreenPointInvalidCollisionParts(al::HitSensor *, al::HitSensor *);
+    bool sendMsgBlockUpperPunch(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgBlockLowerPunch(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgBlockItemGet(al::HitSensor *, al::HitSensor *);
+    bool sendMsgKillerItemGet(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerKouraAttack(al::HitSensor *, al::HitSensor *, al::ComboCounter *);
+    bool sendMsgLightFlash(al::HitSensor *, al::HitSensor *);
+    bool sendMsgForceAbyss(al::HitSensor *, al::HitSensor *);
+    bool sendMsgIsNerveSupportFreeze(al::HitSensor *, al::HitSensor *);
+    bool sendMsgOnSyncSupportFreeze(al::HitSensor *, al::HitSensor *);
+    bool sendMsgOffSyncSupportFreeze(al::HitSensor *, al::HitSensor *);
+    bool sendMsgSwordAttackHighLeft(al::HitSensor *, al::HitSensor *);
+    bool sendMsgSwordAttackLowLeft(al::HitSensor *, al::HitSensor *);
+    bool sendMsgSwordAttackHighRight(al::HitSensor *, al::HitSensor *);
+    bool sendMsgSwordAttackLowRight(al::HitSensor *, al::HitSensor *);
+    bool sendMsgSwordAttackJumpUnder(al::HitSensor *, al::HitSensor *);
+    bool sendMsgSwordBeamAttack(al::HitSensor *, al::HitSensor *);
+    bool sendMsgSwordBeamReflectAttack(al::HitSensor *, al::HitSensor *);
+    bool sendMsgShieldGuard(al::HitSensor *, al::HitSensor *);
+    bool sendMsgEnemyAttackKnockDown(al::HitSensor *, al::HitSensor *);
+    bool sendMsgAskMultiPlayerEnemy(al::HitSensor *, al::HitSensor *);
+    bool sendMsgItemGettable(al::HitSensor *, al::HitSensor *);
+    bool sendMsgKikkiThrow(al::HitSensor *, al::HitSensor *);
+    bool sendMsgIsKikkiThrowTarget(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerCloudGet(al::HitSensor *, al::HitSensor *);
+    bool sendMsgAutoJump(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerTouchShadow(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerPullOutShadow(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerAttackShadow(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerAttackShadowStrong(al::HitSensor *, al::HitSensor *);
+    bool sendMsgPlayerAttackChangePos(al::HitSensor *, al::HitSensor *, sead::Vector3f *);
+    bool sendMsgAtmosOnlineLight(al::HitSensor *, al::HitSensor *);
+    bool sendMsgLightBurn(al::HitSensor *, al::HitSensor *);
+    bool sendMsgMoonLightBurn(al::HitSensor *, al::HitSensor *);
+    bool sendMsgString(al::HitSensor *, al::HitSensor *, char const *);
+    bool sendMsgStringV4fPtr(al::HitSensor *, al::HitSensor *, char const *, sead::Vector4f *);
+    bool sendMsgStringV4fSensorPtr(al::HitSensor *, al::HitSensor *, char const *, sead::Vector4f *);
+    bool sendMsgStringVoidPtr(al::HitSensor *, al::HitSensor *, char const *, void *);
+    bool sendMsgEnemyAttackForCrossoverSensor(al::HitSensor *, al::HitSensor *);
+    bool sendMsgEnemyAttackForCrossoverCylinderSensor(al::HitSensor *, al::HitSensor *, sead::Vector3f const &, sead::Vector3f const &, float);
+    bool sendMsgPushAndKillVelocityToTarget(al::LiveActor *, al::HitSensor *, al::HitSensor *);
+    bool sendMsgPushAndKillVelocityToTargetH(al::LiveActor *, al::HitSensor *, al::HitSensor *);
+    bool sendMsgCollidePush(al::HitSensor *, al::HitSensor *, sead::Vector3f const &);
+    bool sendMsgScreenPointTarget(al::SensorMsg const &, al::ScreenPointer *, al::ScreenPointTarget *);
+
+} // namespace al
--- a/include/algorithms/CaptureAnims.h
+++ b/include/algorithms/CaptureAnims.h
@ -488,6 +488,10 @@ namespace CaptureAnims {
    }

    static constexpr const char *FindStr(Type type) {
-        return s_Strs.at(ToValue(type));
+        const s16 type_ = (s16)type;
+        if (0 <= type_ && type_ < s_Strs.size())
+            return s_Strs[type_];
+        else
+            return "";
    }
 }
--- a/include/algorithms/CaptureTypes.h
+++ b/include/algorithms/CaptureTypes.h
@ -98,6 +98,10 @@ namespace CaptureTypes {
    }

    static constexpr const char *FindStr(Type type) {
-        return s_Strs.at(ToValue(type));
+        const s16 type_ = (s16)type;
+        if (0 <= type_ && type_ < s_Strs.size())
+            return s_Strs[type_];
+        else
+            return "";
    }
 }
--- a/include/algorithms/PlayerAnims.h
+++ b/include/algorithms/PlayerAnims.h
@ -1154,6 +1154,10 @@ namespace PlayerAnims {
    }

    static constexpr const char *FindStr(Type type) {
-        return s_Strs.at(ToValue(type));
+        const s16 type_ = (s16)type;
+        if (0 <= type_ && type_ < s_Strs.size())
+            return s_Strs[type_];
+        else
+            return "";
    }
 }
--- a/include/algorithms/WipeTypes.h
+++ b/include/algorithms/WipeTypes.h
@ -72,6 +72,10 @@ namespace WipeTypes {
    }

    static constexpr const char *FindStr(Type type) {
-        return s_Strs.at(ToValue(type));
+        const s16 type_ = (s16)type;
+        if (0 <= type_ && type_ < s_Strs.size())
+            return s_Strs[type_];
+        else
+            return "";
    }
 }
--- a/include/cameras/CameraVerticalAbsorber2DGalaxy.h
+++ b/include/cameras/CameraVerticalAbsorber2DGalaxy.h
@ -0,0 +1,38 @@
+#pragma once
+
+#include "al/camera/CameraPoser.h"
+#include "al/nerve/NerveExecutor.h"
+#include "math/seadVector.h"
+
+namespace al {
+class CameraVerticalAbsorber2DGalaxy : public al::NerveExecutor {
+public:
+    CameraVerticalAbsorber2DGalaxy(void);
+    
+    void start(al::CameraPoser const*);
+    void update(al::CameraPoser const*);
+    void applyLimit(sead::Vector3f* output);
+
+    void exeNone(void);
+    void exeGround(void);
+    void exeLimit(void);
+    void exeLimitOver(void);
+    void exeLimitAfter(void);
+
+    sead::Vector3f mTargetTrans;
+    sead::Vector3f mTargetGravity;
+    sead::Vector3f mTargetUp;
+    bool mIsTargetCollideGround;
+    sead::Vector3f mPrevTargetTrans;
+    sead::Vector3f mPrevTargetGravity;
+    float unkFloat;
+    sead::Vector3f mLimit;
+    sead::Vector3f unkVec;
+    float unkFloat2;
+
+};
+
+static_assert(sizeof(CameraVerticalAbsorber2DGalaxy) == 0x70, "");
+
+
+}
--- a/include/game/Actors/Shine.h
+++ b/include/game/Actors/Shine.h
@ -8,6 +8,12 @@
 #include "game/Interfaces/IUseDimension.h"
 #include "al/LiveActor/LiveActor.h"

+enum ShineType { Normal, Dot, Grand };
+
+namespace al {
+    struct RateParamV3f;
+}
+
 class Shine : public al::LiveActor , public IUseDimension {
    public:
        Shine(const char* actorName);
@ -16,23 +22,79 @@ class Shine : public al::LiveActor , public IUseDimension {

        void offAppear();
        void onAppear();
-        
        void getDirectWithDemo(void);
        void getDirect();
        void get();
-
        void onSwitchGet(void);
-        
        bool isGot() const;
-
        void setGrandShine(void);

-        unsigned char padding[0x10];
-        // 0x11C mIsEmptyShine
+        void *qword110;
+        int dword118;
+        bool mIsGotShine;
        ShineInfo *curShineInfo; // 0x120
-        unsigned char padding_290[0x278 - 0x128];
+        unsigned char padding_188[0x188 - 0x128];
+        al::RateParamV3f *mRateParam;
+        void * qword190;
+        void * qword198;
+        ShineType mModelType;
+        void * qword1A8;
+        bool byte1B0;
+        void * qword1B8;
+        int dword1C0;
+        int dword1C4;
+        sead::FixedSafeString<0x80> mShineLabel;
+        void * qword260;
+        int dword268;
+        bool byte26C;
+        void * qword270;
        QuestInfo *shineQuestInfo; // 0x278
        void *unkPtr1; // 0x280
        ActorDimensionKeeper *mDimensionKeeper; // 0x288
-        int shineId; // 0x290
-};
+        int mShineIdx;                            // 0x290
+        bool mIsMainShine;
+        void *qword298;
+        void *qword2A0;
+        void *qword2A8;
+        void *qword2B0;
+        void *qword2B8;
+        int dword2C0;
+        __attribute__((packed)) void * qword2C4;
+        int dword2CC;
+        int dword2D0;
+        bool mIsAddHeight;
+        int dword2D8;
+        al::LiveActor *mModelEmpty;
+        al::LiveActor *mModelShine;
+        int dword2F0;
+        u16 word2F4;
+        int dword2F8;
+        bool mIsNoRotate;
+        void * qword300;
+        bool mIsUseDemoCam;
+        struct WaterSurfaceShadow *mWaterShadow;
+        void * qword318;
+        int dword320;
+        int dword324;
+        bool byte328;
+        void * qword330;
+        bool mIsCheckGroundHeightMoon;
+        bool mIsHintPhoto;
+        void * qword340;
+        bool byte348;
+        void * qword350;
+        bool mIsUseAppearDemoForce;
+        int dword35C;
+        int dword360;
+        int dword364;
+        int dword368;
+        bool mIsPowerStar;
+        bool mIsAppearDemoHeightHigh;
+        void * qword370;
+        u16 word378;
+        int dword37C;
+};
+
+namespace rs {
+    void setStageShineAnimFrame(al::LiveActor *,char const*,int,bool);
+}
--- a/include/game/GameData/GameDataFile.h
+++ b/include/game/GameData/GameDataFile.h
@ -6,8 +6,11 @@
 #pragma once

 #include "al/scene/SceneObjHolder.h"
+#include "container/seadPtrArray.h"
+#include "prim/seadSafeString.h"
 #include "types.h"
 #include "UniqueObjInfo.h"
+#include "GameProgressData.h"

 #include "sead/math/seadVector.h"
 #include "sead/stream/seadStream.h"
@ -16,7 +19,24 @@ namespace al {
    class ActorInitInfo;
    class PlacementInfo;
    class PlacementId;
-}
+    }  // namespace al
+
+class SphinxQuizData;
+class TimeBalloonSaveData;
+class WorldWarpTalkData;
+class VisitStageData;
+class MoonRockData;
+class BossSaveData;
+class AchievementSaveData;
+class SearchAmiiboDataTable;
+class NetworkUploadFlag;
+class SequenceDemoSkipData;
+class HintPhotoData;
+class ShopTalkData;
+class RaceRecord;
+
+class PlayerHitPointData;
+

 class GameDataHolder;
 class ShineInfo;
@ -24,7 +44,48 @@ class ShineInfo;
 class GameDataFile
 {
    public:
-        GameDataFile(GameDataHolder *);
+        GameDataFile(GameDataHolder*);
+
+        struct HintInfo {
+            void clear(void);
+            bool isDisableByWorldWarpHole(bool) const;
+            bool isEnableUnlock(int, bool, int, bool) const;
+            bool isHintStatusUnlock(int, int, bool) const;
+            bool isHintStatusUnlockByNpc(void) const;
+            bool isHintStatusUnlockByAmiibo(void) const;
+            bool isEnableNameUnlockByScenario(int, int, bool) const;
+
+            sead::FixedSafeString<0x80> mStageName;     // 0x0
+            sead::FixedSafeString<0x80> mObjId;         // 0x98
+            sead::FixedSafeString<0x40> mScenarioName;  // 0x130
+            const char *mObjectName;                    // 0x188
+            sead::Vector3f mTrans;                      // 0x190
+            sead::Vector3f mTransAgain;                 // 0x19C
+            void *unkPtr1;                              // 0x1A8
+            void *unkPtr2;                              // 0x1B0
+            void *unkPtr3;                              // 0x1B8
+            void *unkPtr4;                              // 0x1C0
+            s32 mMainScenarioNo;                        // 0x1C8 
+            int mWorldIndex;                            // 0x1CC
+            bool mIsMoonRock;                           // 0x1D0 
+            bool unkBool1;                              // 0x1D1 
+            bool mIsAchievement;                        // 0x1D2 
+            bool mIsGrand;                              // 0x1D3 
+            bool mIsShopMoon;                           // 0x1D4
+            int unkInt;                                 // 0x1D8
+            int unkInt2;                                // 0x1DC
+            void *unkPtr6;                              // 0x1E0
+            void *unkPtr7;                              // 0x1E8
+            int mUniqueID;                              // 0x1F0
+            int mHintIdx;                               // 0x1F4
+            sead::FixedSafeString<0x20> mOptionalID;    // 0x1F8
+            uint mProcessBitflag;                       // 0x230
+            bool unkBool2;                              // 0x234
+            bool unkBool3;                              // 0x235
+        };
+
+        static_assert(sizeof(HintInfo) == 0x238, "size of HintInfo");
+        
        void initializeData(void);
        void tryReadByamlData(uchar const*);
        void tryFindCoinCollectInfo(char const*,char const*);
@ -132,7 +193,7 @@ class GameDataFile
        void wearCostume(char const*);
        void wearCap(char const*);
        void addHackDictionary(char const*);
-        void findShine(int,int);
+        HintInfo* findShine(int worldIndex, int shineIndex);
        void calcShineNumInOneShine(int,int);
        void checkAchievementShine(int,int);
        void winRace(void);
@ -176,7 +237,7 @@ class GameDataFile
        void tryFindUniqueId(ShineInfo const*);
        void findUnlockShineNumCurrentWorld(bool *);
        void trySetCollectedBgm(char const*,char const*);
-        // void setGotShine(GameDataFile::HintInfo const*);
+        void setGotShine(GameDataFile::HintInfo const*);
        // void tryWriteByByaml(al::ByamlWriter *);
        
        int getTotalShineNum(void);
@ -210,7 +271,7 @@ class GameDataFile
        void getPlayerHitPointData(void);
        void getLastUpdateTime(void);
        void getPlayTimeTotal(void);
-        void getMainScenarioNo(int);
+        int getMainScenarioNo(int) const;
        void getCollectedBgmMaxNum(void);
        int getScenarioNo(void) const;
        void getMiniGameName(int);
@ -295,16 +356,192 @@ class GameDataFile
        bool isGameClear(void) const;
        bool isEmpty(void) const;
        bool isKidsMode(void) const;
+
+        // custom methods
+
+        // custom impl of findShine that uses shine UID instead of index to get the right HintInfo
+        HintInfo* findShine(int shineUid) {
+            for (int x = 0; x < 0x400; x++) {
+                GameDataFile::HintInfo* curInfo = &mShineHintList[x];
+                if (curInfo->mUniqueID == shineUid) {
+                    return curInfo;
+                }
+            }
+            return nullptr;
+        }
        
-        undefined padding[0x5C8];
-        UniqObjInfo** mUniqueInfo;  // 0x5C8
-        void *unkPtr1; // 0x5D0
-        void *unkPtr2; // 0x5D8
-        void *unkPtr3; // 0x5E0
-        void* unkPtr4;  // 0x5E8
-        void* unkPtr5;  // 0x5F0
-        bool unkBool1; // 0x5F8
-        bool unkBool2; // 0x5F9
-        bool mIsCapEnable; // 0x5FA
+        // end custom methods
+        
+        ShineInfo **mShineInfoArray;
+        ShineInfo **mShineInfoArray2;
+        ShineInfo *mShineInfo;
+        void *qword18;
+        void *qword20;
+        int dword28;
+        int dword2C;
+        sead::FixedSafeString<0x80> char30;
+        sead::FixedSafeString<0x80> charC8;
+        sead::FixedSafeString<0x80> char160;
+        sead::FixedSafeString<0x80> char1F8;
+        sead::FixedSafeString<0x80> char290;
+        sead::FixedSafeString<0x80> char328;
+        sead::FixedSafeString<0x80> char3C0;
+        u16 word458;
+        char gap45A[6];
+        void *qword460;
+        void *qword468;
+        void *qword470;
+        void *qword478;
+        void *qword480;
+        void *qword488;
+        sead::FixedSafeString<0x100> char490;
+        void *qword5A8;
+        bool byte5B0;
+        void *qword5B4;
+        sead::FixedSafeString<0x80> *qword5C0;
+        UniqObjInfo** mUniqueObjInfoArr;
+        void *qword5D0;
+        void *qword5D8;
+        void *qword5E0;
+        void *qword5E8;
+        void *qword5F0;
+        u16 word5F8;
+        bool mIsEnableCap;
+        void *qword600;
+        int dword608;
+        bool byte60C;
+        SphinxQuizData *mSphinxQuizData;
+        void *qword618;
+        void *qword620;
+        void *qword628;
+        TimeBalloonSaveData *qword630;
+        sead::FixedSafeString<0x40> char638;
+        int dword690;
+        WorldWarpTalkData *mWorldWarpTalkData;
+        VisitStageData *mVisitStageData;
+        GameProgressData *mGameProgressData;
+        MoonRockData *mMoonRockData;
+        BossSaveData *mBossSaveData;
+        AchievementSaveData *mAchievementSaveData;
+        SearchAmiiboDataTable *mSearchAmiiboDataTable;
+        NetworkUploadFlag *mNetworkUploadFlag;
+        SequenceDemoSkipData *mSequenceDemoSkipData;
+        HintPhotoData *mHintPhotoData;
+        void *qword6E8;
+        void *qword6F0;
+        void *qword6F8;
+        void *qword700;
+        void *qword708;
+        sead::FixedSafeString<0x40> char710;
+        sead::FixedSafeString<0x40> char768;
+        u16 word7C0;
+        void *qword7C8;
+        u16 word7D0;
+        void *qword7D8;
+        sead::PtrArray<RaceRecord> mLatestRaceRecords;
+        void *qword7F0;
+        void *qword7F8;
+        void *qword800;
+        void *qword808;
+        void *qword810;
+        bool byte818;
+        void *qword820;
+        bool byte828;
+        sead::PtrArrayImpl sead__ptrarrayimpl830;
+        u16 word840;
+        bool byte842;
+        int dword844;
+        bool byte848;
+        GameDataHolder *mGameDataHolder;
+        void *qword858;
+        PlayerHitPointData *mPlayerHintPointData;
+        sead::FixedSafeString<0x80> char868;
+        bool byte900;
+        bool byte901;
+        int dword904;
+        sead::FixedSafeString<0x80> char908;
+        HintInfo *mShineHintList; // 0x9A0
+        sead::PtrArrayImpl sead__ptrarrayimpl9A8;
+        sead::PtrArrayImpl sead__ptrarrayimpl9B8;
+        sead::PtrArrayImpl sead__ptrarrayimpl9C8;
+        sead::PtrArrayImpl sead__ptrarrayimpl9D8;
+        void *qword9E8;
+        int mCurWorldID;
+        void *qword9F8;
+        void *qwordA00;
+        u16 wordA08;
+        bool byteA0A;
+        void *qwordA10;
+        void *qwordA18;
+        int dwordA20;
+        int dwordA24;
+        int dwordA28;
+        bool byteA2C;
+        ChangeStageInfo *mChangeStageInfo;
+        ChangeStageInfo *mChangeStageInfo2;
+        void *qwordA40;
+        void *qwordA48;
+        void *qwordA50;
+        void *qwordA58;
+        ShopTalkData *mShopTalkData;
+        void *qwordA68;
+        bool byteA70;
+        char gapA71[3];
+        void *qwordA74;
+        void *qwordA7C;
+        int dwordA84;
+        bool byteA88;
+        char gapA89[3];
+        void *qwordA8C;
+        int dwordA94;
+        bool byteA98;
+        char gapA99[3];
+        void *qwordA9C;
+        int dwordAA4;
+        bool byteAA8;
+        char gapAA9[3];
+        void *qwordAAC;
+        int dwordAB4;
+        bool byteAB8;
+        char gapAB9[3];
+        void *qwordABC;
+        int dwordAC4;
+        bool byteAC8;
+        char gapAC9[3];
+        void *qwordACC;
+        int dwordAD4;
+        bool byteAD8;
+        char gapAD9[3];
+        void *qwordADC;
+        int dwordAE4;
+        bool byteAE8;
+        char gapAE9[3];
+        void *qwordAEC;
+        int dwordAF4;
+        bool byteAF8;
+        char gapAF9[3];
+        void *qwordAFC;
+        int dwordB04;
+        bool byteB08;
+        char gapB09[3];
+        void *qwordB0C;
+        int dwordB14;
+        bool byteB18;
+        char gapB19[3];
+        void *qwordB1C;
+        int dwordB24;
+        bool byteB28;
+        char gapB29[7];
+        void *qwordB30;
+        bool byteB38;
+        char gapB39[7];
+        void *qwordB40;
+        int dwordB48;
+        char gapB4C[4];
+        void *qwordB50;
+        int dwordB58;
+        int dwordB5C;
+        int dwordB60;
+        u16 wordB64;
 };
        
--- a/include/game/GameData/GameDataFunction.h
+++ b/include/game/GameData/GameDataFunction.h
@ -67,6 +67,12 @@ public:
    // checks save file if shine is collected by shine index only (0 through 725)
    static bool isGotShine(GameDataHolderAccessor, int);

+    // checks save file if shine is collected using the shines ShineInfo
+    static bool isGotShine(GameDataHolderAccessor, ShineInfo const*);
+
+    // checks save file if shine is collected using the shines stage and obj ID
+    static bool isGotShine(GameDataHolderAccessor, const char *stageName, const char *objID);
+
    // Gets Index for X Kingdom
    static s32 getWorldIndexWaterfall(void);
    static s32 getWorldIndexMoon(void);
@ -138,4 +144,32 @@ public:
    // subtracts the supplied int value from the current coin count
    static void subCoin(GameDataHolderWriter, int value);

-};
+    static bool isUnlockedWorld(GameDataHolderAccessor, int);
+
+    static bool isUnlockedNextWorld(GameDataHolderAccessor);
+
+    static bool isUnlockedAllWorld(GameDataHolderAccessor);
+
+    static bool isUnlockedCurrentWorld(GameDataHolderAccessor);
+
+    static bool isUnlockWorld(int);
+
+    static bool isUnlockFirstForest(void);
+    
+    static bool isUnlockFirstSea(void);
+};
+
+namespace CustomGameDataFunction {
+    static GameDataFile::HintInfo* getHintInfoByUniqueID(GameDataHolderAccessor accessor, int uid) {
+        return accessor.mData->mGameDataFile->findShine(uid);
+    }
+
+    static const GameDataFile::HintInfo* getHintInfoByIndex(GameDataHolderAccessor accessor, int index) {
+        return &accessor.mData->mGameDataFile->mShineHintList[index];
+    }
+
+    static const GameDataFile::HintInfo* getHintInfoByIndex(al::LiveActor* actor, int index) {
+        GameDataHolderAccessor accessor(actor);
+        return getHintInfoByIndex(accessor, index);
+    }
+}
--- a/include/game/GameData/GameDataHolderAccessor.h
+++ b/include/game/GameData/GameDataHolderAccessor.h
@ -18,4 +18,5 @@ class GameDataHolderAccessor : public GameDataHolderWriter
    public:
        GameDataHolderAccessor(al::IUseSceneObjHolder const *IUseObjHolder) {mData = (GameDataHolder*)al::getSceneObj(IUseObjHolder, 18);}
        GameDataHolderAccessor(al::SceneObjHolder const *objHolder) {mData = (GameDataHolder*)objHolder->getObj(18); }
+        GameDataHolderAccessor() {mData = nullptr; } // default ctor
 };
--- a/include/game/HakoniwaSequence/HakoniwaSequence.h
+++ b/include/game/HakoniwaSequence/HakoniwaSequence.h
@ -21,12 +21,18 @@
 #include "HakoniwaStateSimpleDemo.h"
 #include "HakoniwaStateBootLoadData.h"

-namespace al
-{
+namespace al {
    class WipeHolder;
    class ScreenCaptureExecutor;
-    class BootLayout;
-} // namespace al
+    class SeadAudioPlayer;
+    class AudioBusSendFader;
+    class SimpleAudioUser;
+}  // namespace al
+    
+class BootLayout;
+class TimeBalloonSequenceInfo;
+class CollectBgmPlayer;
+class LoadLayoutCtrl;

 class HakoniwaSequence : public al::Sequence {
    public:
@ -40,62 +46,59 @@ class HakoniwaSequence : public al::Sequence {
        void update(void);
        bool isEnableSave(void);
        void drawMain(void);
-        al::Scene *getCurrentScene(void) const; // {return this->curScene}
+        al::Scene* getCurrentScene(void) const;  // {return this->curScene}

-        void* qword20;
-        void* qword28;
-        void* qword30;
-        void* qword38;
-        void* qword40;
-        void* qword48;
-        void* qword50;
-        void* qword58;
-        void* qword60;
-        void* qword68;
-        void* qword70;
-        void* qword78;
-        void* qword80;
-        void* qword88;
-        al::AudioDirector *mAudioDirector; // 0x90
-        void *qword98;
-        void *qwordA0;
-        void *qwordA8;
-        al::Scene *curScene; // 0xB0
-        GameDataHolderAccessor mGameDataHolder; // 0xB8
-        al::GamePadSystem *mGamepadSys; // 0xC0
-        HakoniwaStateDemoOpening *mDemoOpening; // 0xC8
-        HakoniwaStateDemoEnding *mDemoEnding; // 0xD0
+        void exeBootLoadData();
+        void exeDemoOpening();
+        void exeLoadWorldResource();
+        void exeLoadWorldResourceWithBoot();
+        void exeLoadStage();
+        void exePlayStage();
+        void exeDemoWorldWarp();
+        void exeDemoEnding();
+        void exeDestroy();
+        void exeMiss();
+        void exeMissCoinSub();
+        void exeMissEnd();
+        void exeDemoLava();
+        void exeFadeToNewGame();
+
+        al::Scene *curScene;                        // 0xB0
+        GameDataHolderAccessor mGameDataHolder;     // 0xB8
+        al::GamePadSystem *mGamepadSys;             // 0xC0
+        HakoniwaStateDemoOpening *mDemoOpening;     // 0xC8
+        HakoniwaStateDemoEnding *mDemoEnding;       // 0xD0
        HakoniwaStateDemoWorldWarp *mDemoWorldWarp; // 0xD8
-        HakoniwaStateSimpleDemo *mSimpleDemo; // 0xE0
-        HakoniwaStateBootLoadData *mBootLoadData; // 0xE8
-        HakoniwaStateDeleteScene *mDeleteScene; // 0xF0
-        al::LayoutKit* mLytKit;                 // 0xF8
-
-        // al::initSceneCreator(al::IUseSceneCreator *,al::SequenceInitInfo const&,al::GameDataHolderBase *,al::AudioDirector *,al::ScreenCaptureExecutor *,alSceneFunction::SceneFactory *)	.text	00000000009F2270	0000007C	00000050	FFFFFFFFFFFFFFF8	R	.	.	.	B	.	.
-
-
-        // undefined * * field_0x0;
-        // undefined padding_120[0x120];
-        //                     al::Scene * curScene;
-        // undefined padding_8[0x8];
-        //                     al::AudioDirector * field_0x90;
-        // undefined padding_24[0x24];
-        //                     StageScene * stageScene;
-        //                     GameDataHolderAccessor *gameDataHolder;
-        // undefined padding_024[0x24];
-        //                     HakoniwaStateDemoWorldWarp * stateDemoWorldWarp;
-        // undefined padding_192[0x192];
-        //                     int nextScenarioNo;
-        // undefined padding_12[0x12];
-        //                     al::WipeHolder * field_0x1b0;
-        // undefined padding_0024[0x24];
-        //                     long * field_0x1d0;
-        // undefined padding_48[0x48];
-        //                     WorldResourceLoader * worldResourceLoader;
-        // undefined padding_0x16[0x16];
-        // undefined * field_0x220;
-        // undefined padding_0x144[0x144];
-        // undefined * field_0x2b8;
-        // undefined padding_0x160[0x160];
-        // undefined8 field_0x360;
+        HakoniwaStateSimpleDemo *mSimpleDemo;       // 0xE0
+        HakoniwaStateBootLoadData *mBootLoadData;   // 0xE8
+        HakoniwaStateDeleteScene *mDeleteScene;     // 0xF0
+        al::LayoutKit* mLytKit;                     // 0xF8
+        bool mYBalls;                                   
+        sead::FixedSafeString<0x80> stageName;  
+        int scenarioNum;    
+        al::ScreenCaptureExecutor* mScreenCapExecutor;
+        al::WipeHolder* mWipeHolder;
+        bool mMissEnd;
+        al::SimpleLayoutAppearWaitEnd* mCounterMiss;
+        int mCurCoins;
+        int mFinalCoins;
+        BootLayout* mBootLayout;
+        al::EffectSystem* mEffectSystem;
+        al::AsyncFunctorThread* mInitThread;
+        bool mInitialized;
+        al::SeadAudioPlayer* mSeAudioPlayer;
+        al::SeadAudioPlayer* mBgmAudioPlayer;
+        al::AudioBusSendFader* mBusSendFader;
+        WorldResourceLoader* mResourceLoader;
+        sead::Heap* mPlayerResHeap;
+        sead::FixedSafeString<0x80> mCapName;
+        sead::FixedSafeString<0x80> mCostumeName;
+        al::SimpleAudioUser* mPlayerAudioUser;
+        bool mHackEnd;
+        TimeBalloonSequenceInfo* mBalloonSeqInfo;
+        CollectBgmPlayer* mCollectBgmPlayer;
+        sead::FixedSafeString<0x80> mLanguage;
+        int mFileId;
+        LoadLayoutCtrl* mLoadLayoutCtrl;
+        bool mKidsMode;
 };
--- a/include/game/Info/ShineInfo.h
+++ b/include/game/Info/ShineInfo.h
@ -30,7 +30,7 @@ class ShineInfo {

        sead::FixedSafeString<0x80> stageName = sead::FixedSafeString<0x80>(); // 0x0 (Size: 0x98)
        sead::FixedSafeString<0x80> objectId = sead::FixedSafeString<0x80>(); // 0xA0
-        sead::FixedSafeString<0x80> scenObjId = sead::FixedSafeString<0x80>(); // 0x138
+        sead::FixedSafeString<0x80> mShineLabel = sead::FixedSafeString<0x80>(); // 0x138

        int shineId; // 1C8
        const QuestInfo *curQuest; // 1D0
--- a/include/game/Interfaces/IUsePlayerHack.h
+++ b/include/game/Interfaces/IUsePlayerHack.h
@ -6,5 +6,6 @@
 */

 class IUsePlayerHack {
-
+public:
+    virtual struct PlayerHackKeeper *getPlayerHackKeeper() const = 0;
 };
--- a/include/game/Layouts/CommonVerticalList.h
+++ b/include/game/Layouts/CommonVerticalList.h
@ -6,7 +6,10 @@
 #include "prim/seadSafeString.h"

 struct RollPartsData {
-
+    int mRollMsgCount = 0; // 0x0
+    const char16_t **mRollMsgList; // 0x8
+    int unkInt1 = 0;         // 0x10
+    bool mUnkBool = false;   // 0x14
 };

 class CommonVerticalList : public al::NerveExecutor {
@ -75,14 +78,14 @@ public:
    void *unkPtr3;                                  // 0x50
    sead::Vector2f mCursorPos;                      // 0x58
    void *unkPtr4;                                  // 0x60
-    void *unkPtr5;                                  // 0x68
+    int unkInt1;                                    // 0x68
    sead::WFixedSafeString<0x200> **mStringDataArr; // 0x70
    sead::FixedSafeString<0x90> **mPaneNameList;    // 0x78
    void *unkPtr8;                                  // 0x80
    void *unkPtr9;                                  // 0x88
    const bool *mIsEnableData;                      // 0x90
    int mStringDataCount;                           // 0x98
-    int unkInt2;                                    // 0x9C
+    int mDataCount;                                 // 0x9C
    void *unkPtr12;                                 // 0xA0
    void *unkPtr13;                                 // 0xA8
    void *unkPtr14;                                 // 0xB0
--- a/include/game/Player/HackCap.h
+++ b/include/game/Player/HackCap.h
@ -14,9 +14,9 @@

 #include "HackCapThrowParam.h"
 #include "HackCap/HackCapJointControlKeeper.h"
+#include "HackCap/PlayerCapActionHistory.h"

 class PlayerWallActionHistory;
-class PlayerCapActionHistory;
 class PlayerEyeSensorHitHolder;
 class IUsePlayerHeightCheck;
 class PlayerWetControl;
@ -201,6 +201,9 @@ class HackCap : public al::LiveActor {
        al::LiveActor *mCapEyes; // 0x120
        PlayerActorHakoniwa *mPlayerActor; // 0x128
        unsigned char padding_220[0x220-0x130];
-        HackCapThrowParam throwParam; // 0x220
+        HackCapThrowParam *throwParam; // 0x220
+        unsigned char padding_2B8[0x2B8-0x228];
+        PlayerCapActionHistory *mCapActionHistory; // 0x2B8
+        unsigned char padding_2E0[0x2E0-0x2C0];
        HackCapJointControlKeeper *mJointKeeper; // 0x2E0
 };
--- a/include/game/Player/HackCap/PlayerCapActionHistory.h
+++ b/include/game/Player/HackCap/PlayerCapActionHistory.h
@ -0,0 +1,29 @@
+#pragma once
+
+#include "al/LiveActor/LiveActor.h"
+#include "game/Interfaces/IUsePlayerCollision.h"
+#include "game/Player/PlayerConst.h"
+#include "math/seadVector.h"
+
+class PlayerCapActionHistory {
+public:
+    PlayerCapActionHistory(al::LiveActor const*,PlayerConst const*,struct PlayerTrigger const*,IUsePlayerCollision const*);
+    void update(void);
+    void clearLandLimit(void);
+    void clearLimitHeight(void);
+    void clearCapJump(void);
+    void clearLandLimitStandAngle(void);
+    void clearWallAirLimit(void);
+    void recordLimitHeight(void);
+    bool isOverLimitHeight(void) const;
+
+    al::LiveActor* mHostActor;       // 0x0
+    PlayerConst* mPlayerConst;       // 0x8
+    PlayerTrigger* mPlayerTrigger;   // 0x10
+    IUsePlayerCollision* mCollider;  // 0x18
+    struct PlayerCounterAfterCapCatch* mCapCatchCounter;  // 0x20
+    bool mIsCapBounced = false;                           // 0x28
+    sead::Vector3f mUnkVec = sead::Vector3f::zero;        // 0x2C
+    bool mIsCapJumpReady = true;                          // 0x38
+    bool mIsLimited = true;                               // 0x39 (unsure what this actually is called)
+};
--- a/include/game/Player/PlayerActorBase.h
+++ b/include/game/Player/PlayerActorBase.h
@ -7,11 +7,61 @@

 #include "PlayerHackKeeper.h"
 #include "al/LiveActor/LiveActor.h"
+#include "game/Interfaces/IUsePlayerCollision.h"
 #include "game/Interfaces/IUsePlayerHack.h"
+#include "game/Player/PlayerCollider.h"
+#include "game/Player/PlayerInfo.h"
+#include "game/Player/PlayerInitInfo.h"
+#include "game/Player/PlayerPuppet.h"

-class PlayerActorBase : public al::LiveActor , public IUsePlayerHack {
+class PlayerActorBase : public al::LiveActor, public IUsePlayerHack {
    public: 
-        PlayerHackKeeper *getPlayerHackKeeper() const; 
-        void movement(void);
-        int getPortNo();
+        PlayerActorBase(char const*);
+
+        virtual void movement(void) override;
+        virtual void init(al::ActorInitInfo const&) override;
+        virtual void initPlayer(al::ActorInitInfo const&, PlayerInitInfo const&);
+        virtual int getPortNo(void);
+        virtual sead::Matrix34f *getViewMtx(void) const;
+        virtual IUsePlayerCollision* getPlayerCollision(void) const;
+        virtual PlayerHackKeeper* getPlayerHackKeeper() const override;
+
+        virtual bool isEnableDemo(void);
+        virtual void startDemo(void);
+        virtual void endDemo(void);
+
+        virtual void startDemoPuppetable(void);
+        virtual void endDemoPuppetable(void);
+
+        virtual void startDemoShineGet(void);
+        virtual void endDemoShineGet(void);
+
+        virtual void startDemoMainShineGet(void);
+        virtual void endDemoMainShineGet(void);
+
+        virtual void startDemoHack(void);
+        virtual void endDemoHack(void);
+
+        virtual void startDemoKeepBind(void);
+        virtual void noticeDemoKeepBindExecute(void);
+        virtual void endDemoKeepBind(void);
+
+        virtual void startDemoKeepCarry(void);
+        virtual void endDemoKeepCarry(void);
+
+        virtual void getDemoActor(void);
+        virtual void getDemoAnimator(void);
+
+        virtual bool isDamageStopDemo(void) const;
+
+        virtual PlayerPuppet *getPlayerPuppet(void);
+        virtual PlayerInfo *getPlayerInfo(void) const;
+
+        virtual bool checkDeathArea(void);
+        virtual void sendCollisionMsg(void);
+
+        virtual bool receivePushMsg(al::SensorMsg const*,al::HitSensor *,al::HitSensor *,float);
+
+        sead::Matrix34f* mViewMtx;  // 0x110
+        int mPortNo; // 0x118
 };
--- a/include/game/Player/PlayerActorHakoniwa.h
+++ b/include/game/Player/PlayerActorHakoniwa.h
@ -25,7 +25,9 @@

 #include "Attacks/PlayerSpinCapAttack.h"

-#define PACTORSIZE 0xC8
+namespace al {
+class WaterSurfaceFinder;
+}

 class PlayerActorHakoniwa : public PlayerActorBase , public IUseDimension {
    public: 
@ -36,11 +38,10 @@ class PlayerActorHakoniwa : public PlayerActorBase , public IUseDimension {
        void startPlayerPuppet(void);
        void initPlayer(al::ActorInitInfo const&, PlayerInitInfo const&);

-        unsigned char padding[0x18]; // 0x108
        PlayerInfo *mPlayerInfo; // 0x128
        PlayerConst *mPlayerConst; // 0x130
        PlayerInput *mPlayerInput; //0x138 
-        unsigned char padding_148[0x8]; // PlayerTrigger
+        PlayerTrigger *mPlayerTrigger; // 0x140
        HackCap *mHackCap; // 0x148
        ActorDimensionKeeper *mDimKeeper; // 0x150
        PlayerModelKeeper *mPlayerModelKeeper; // 0x158
@ -48,27 +49,117 @@ class PlayerActorHakoniwa : public PlayerActorBase , public IUseDimension {
        PlayerAnimator *mPlayerAnimator; // 0x168 
        PlayerColliderHakoniwa *mPlayerCollider; // 0x170
        PlayerPuppet *mPlayerPuppet; // 0x178
-        // 0x180 PlayerAreaChecker
-        // 0x188 WaterSurfaceFinder
-        // 0x190 unk
-        // 0x198 unk
-        // 0x1A0 unk
-        // 0x1A8 unk
-        // 0x1B0 unk
-        // 0x1B8 unk
-        // 0x1C0 unk
-        // 0x1C8 unk
-        // 0x1D0 unk
-        // 0x1D8 unk
-        // 0x1E0 unk
-        // 0x1E8 unk
-        // 0x1F0 unk
-        // 0x1F8 PlayerBindKeeper
-        unsigned char padding_208[0x208 - 0x180];
+        PlayerAreaChecker *mAreaChecker; // 0x180
+        al::WaterSurfaceFinder *mWaterSurfaceFinder; // 0x188
+        PlayerOxygen* mPlayerOxygen; // 0x190
+        PlayerDamageKeeper* mPlayerDamageKeeper; // 0x198
+        PlayerDemoActionFlag* mPlayerDemoActionFlag; // 0x1A0
+        PlayerCapActionHistory* mPlayerCapActionHistory; // 0x1A8
+        PlayerCapManHeroEyesControl* mPlayerCapManHeroEyesControl; // 0x1B0
+        struct PlayerContinuousJump* mPlayerContinuousJump; // 0x1B8
+        struct PlayerContinuousLongJump* mPlayerContinuousLongJump; // 0x1C0
+        struct PlayerCounterAfterUpperPunch* mPlayerCounterAfterUpperPunch; // 0x1C8
+        struct PlayerCounterForceRun* mPlayerCounterForceRun; // 0x1D0
+        PlayerCounterIceWater* mPlayerCounterIceWater; // 0x1D8
+        struct PlayerCounterQuickTurnJump* mPlayerCounterQuickTurnJump; // 0x1E0
+        PlayerWallActionHistory* mPlayerWallActionHistory; // 0x1E8
+        PlayerBindKeeper* mPlayerBindKeeper; // 0x1F0
+        PlayerCarryKeeper* mPlayerCarryKeeper; // 0x1F8
+        PlayerEquipmentUser* mPlayerEquipmentUser; // 0x200
        PlayerHackKeeper *mHackKeeper; // 0x208
        PlayerFormSensorCollisionArranger *mCollArranger; // 0x210
-        void *unkPtr2; // 0x218
-        void *unkPtr3; // 0x220
-        PlayerSpinCapAttack *mSpinCapAttack; // 0x228
-        
+        struct PlayerJumpMessageRequest* mPlayerJumpMessageRequest; // 0x218
+        struct PlayerSandSinkAffect* mPlayerSandSinkAffect; // 0x220
+        PlayerSpinCapAttack* mSpinCapAttack;  // 0x228
+        struct PlayerActionDiveInWater* mPlayerActionDiveInWater;
+        struct PlayerEffect* mPlayerEffect;
+        PlayerEyeSensorHitHolder* mPlayerEyeSensorHitHolder;
+        struct PlayerPushReceiver* mPlayerPushReceiver;
+        struct PlayerHitPush* mPlayerHitPush;
+        struct PlayerExternalVelocity* mPlayerExternalVelocity;
+        PlayerJointControlKeeper* mPlayerJointControlKeeper;
+        PlayerPainPartsKeeper* mPlayerPainPartsKeeper;
+        PlayerRecoverySafetyPoint* mPlayerRecoverySafetyPoint;
+        struct PlayerRippleGenerator* mPlayerRippleGenerator;
+        PlayerSeparateCapFlag* mPlayerSeparateCapFlag;
+        PlayerWetControl* mPlayerWetControl;
+        PlayerStainControl* mPlayerStainControl;
+        al::FootPrintHolder* mFootPrintHolder;
+        struct GaugeAir* mGaugeAir;
+        struct WaterSurfaceShadow* mWaterSurfaceShadow;
+        WorldEndBorderKeeper* mWorldEndBorderKeeper;
+        void* gap;
+        struct PlayerSeCtrl* mPlayerSeCtrl;
+        al::HitSensor* mBodyHitSensor;
+        bool mIsLongShadow;
+        struct PlayerStateWait* mPlayerStateWait;
+        struct PlayerStateSquat* mPlayerStateSquat;
+        struct PlayerStateRunHakoniwa2D3D* mPlayerStateRunHakoniwa2D3D;
+        struct PlayerStateSlope* mPlayerStateSlope;
+        struct PlayerStateRolling* mPlayerStateRolling;
+        struct PlayerStateSpinCap* mPlayerStateSpinCap;
+        struct PlayerStateJump* mPlayerStateJump;
+        struct PlayerStateCapCatchPop* mPlayerStateCapCatchPop;
+        struct PlayerStateWallAir* mPlayerStateWallAir;
+        struct PlayerStateWallCatch* mPlayerStateWallCatch;
+        struct PlayerStateGrabCeil* mPlayerStateGrabCeil;
+        struct PlayerStatePoleClimb* mPlayerStatePoleClimb;
+        struct PlayerStateHipDrop* mPlayerStateHipDrop;
+        struct PlayerStateHeadSliding* mPlayerStateHeadSliding;
+        struct PlayerStateLongJump* mPlayerStateLongJump;
+        struct PlayerStateFallHakoniwa* mPlayerStateFallHakoniwa;
+        struct PlayerStateSandSink* mPlayerStateSandSink;
+        struct ActorStateSandGeyser* mActorStateSandGeyser;
+        struct PlayerStateRise* mPlayerStateRise;
+        struct PlayerStateSwim* mPlayerStateSwim;
+        struct PlayerStateDamageLife* mPlayerStateDamageLife;
+        struct PlayerStateDamageSwim* mPlayerStateDamageSwim;
+        struct PlayerStateDamageFire* mPlayerStateDamageFire;
+        struct PlayerStatePress* mPlayerStatePress;
+        struct PlayerStateBind* mPlayerStateBind;
+        struct PlayerStateHack* mPlayerStateHack;
+        struct PlayerStateEndHack* mPlayerStateEndHack;
+        struct PlayerStateCameraSubjective* mPlayerStateCameraSubjective;
+        struct PlayerStateAbyss* mPlayerStateAbyss;
+        struct PlayerJudgeAirForceCount* mPlayerJudgeAirForceCount;
+        struct PlayerJudgeCameraSubjective* mPlayerJudgeCameraSubjective;
+        struct PlayerJudgeCapCatchPop* mPlayerJudgeCapCatchPop;
+        struct PlayerJudgeDeadWipeStart* mPlayerJudgeDeadWipeStart;
+        struct PlayerJudgeDirectRolling* mPlayerJudgeDirectRolling;
+        struct PlayerJudgeEnableStandUp* mPlayerJudgeEnableStandUp;
+        struct PlayerJudgeForceLand* mPlayerJudgeForceLand;
+        struct PlayerJudgeForceSlopeSlide* mPlayerJudgeForceSlopeSlide;
+        struct PlayerJudgeForceRolling* mPlayerJudgeForceRolling;
+        struct PlayerJudgeGrabCeil* mPlayerJudgeGrabCeil;
+        struct PlayerJudgeInWater* mPlayerJudgeInWater1;
+        struct PlayerJudgeInWater* mPlayerJudgeInWater2;
+        struct PlayerJudgeInWater* mPlayerJudgeInWater3;
+        struct PlayerJudgeInWater* mPlayerJudgeInWater4;
+        struct PlayerJudgeInvalidateInputFall* mPlayerJudgeInvalidateInputFall;
+        struct PlayerJudgeLongFall* mPlayerJudgeLongFall;
+        struct PlayerJudgeOutInWater* mPlayerJudgeOutInWater;
+        struct PlayerJudgeRecoveryLifeFast* mPlayerJudgeRecoveryLifeFast;
+        struct PlayerJudgeSandSink* mPlayerJudgeSandSink;
+        struct PlayerJudgeSpeedCheckFall* mPlayerJudgeSpeedCheckFall;
+        struct PlayerJudgeStartHipDrop* mPlayerJudgeStartHipDrop;
+        struct PlayerJudgeStartRise* mPlayerJudgeStartRise;
+        struct PlayerJudgeStartRolling* mPlayerJudgeStartRolling;
+        struct PlayerJudgeStartRun* mPlayerJudgeStartRun;
+        struct PlayerJudgeStartSquat* mPlayerJudgeStartSquat;
+        struct PlayerJudgeStartWaterSurfaceRun* mPlayerJudgeStartWaterSurfaceRun;
+        struct PlayerJudgeSlopeSlide* mPlayerJudgeSlopeSlide;
+        struct PlayerJudgePoleClimb* mPlayerJudgePoleClimb;
+        struct PlayerJudgePreInputJump* mPlayerJudgePreInputJump;
+        struct PlayerJudgePreInputCapThrow* mPlayerJudgePreInputCapThrow;
+        struct PlayerJudgePreInputHackAction* mPlayerJudgePreInputHackAction;
+        struct HackCapJudgePreInputHoveringJump* mHackCapJudgePreInputHoveringJump;
+        struct HackCapJudgePreInputSeparateThrow* mHackCapJudgePreInputSeparateThrow;
+        struct HackCapJudgePreInputSeparateJump* mHackCapJudgePreInputSeparateJump;
+        struct PlayerJudgeWallCatch* mPlayerJudgeWallCatch;
+        struct PlayerJudgeWallCatchInputDir* mPlayerJudgeWallCatchInputDir;
+        struct PlayerJudgeWallHitDown* mPlayerJudgeWallHitDown;
+        struct PlayerJudgeWallHitDownForceRun* mPlayerJudgeWallHitDownForceRun;
+        struct PlayerJudgeWallHitDownRolling* mPlayerJudgeWallHitDownRolling;
+        struct PlayerJudgeWallKeep* mPlayerJudgeWallKeep;
+        void* gap_2;
 };
--- a/include/game/Player/PlayerCostumeFunction.h
+++ b/include/game/Player/PlayerCostumeFunction.h
@ -0,0 +1,9 @@
+#pragma once
+
+#include "al/resource/Resource.h"
+#include "game/Player/PlayerCostumeInfo.h"
+
+namespace PlayerCostumeFunction {
+    PlayerBodyCostumeInfo *createBodyCostumeInfo(al::Resource *,char const*);
+    PlayerHeadCostumeInfo *createHeadCostumeInfo(al::Resource *,char const*,bool);
+}
--- a/include/game/Player/PlayerFunction.h
+++ b/include/game/Player/PlayerFunction.h
@ -1,11 +1,26 @@
 #pragma once

 #include "al/LiveActor/LiveActor.h"
+#include "al/actor/ActorInitInfo.h"
+#include "al/actor/SubActorKeeper.h"
+#include "al/byaml/ByamlIter.h"
+#include "al/model/ModelCtrl.h"
+#include "al/model/ModelMaterialCategory.h"
+#include "al/model/PartsModel.h"
+#include "al/resource/ActorResource.h"
+#include "al/string/StringTmp.h"
+#include "al/util.hpp"
+#include "al/util/LiveActorUtil.h"
+#include "al/util/ResourceUtil.h"

+#include "game/Player/PlayerCostumeFunction.h"
 #include "game/Player/PlayerJointControlPartsDynamics.h"
 #include "game/Player/PlayerConst.h"

+#include "rs/util/LiveActorUtil.h"
+
 #include "PlayerCostumeInfo.h"
+#include "math/seadVector.h"

 namespace al {
    class Resource;
@ -31,7 +46,33 @@ class PlayerFunction
        static al::Resource *initCapModelActor(al::LiveActor *, al::ActorInitInfo const &, char const *);
        static al::Resource *initCapModelActorDemo(al::LiveActor *, al::ActorInitInfo const &, char const *);
        static PlayerCostumeInfo *initMarioModelActor(al::LiveActor *player, const al::ActorInitInfo &initInfo, const char *modelName, const char *capType, al::AudioKeeper *keeper, bool isCloset);
-        // joint, init, pconst, nosescale, earscale
-        static PlayerCostumeInfo *initMarioModelActorDemo(PlayerJointControlPartsDynamics **jointCtrlPtr, al::LiveActor *player, const al::ActorInitInfo &initInfo, char const *bodyName, char const *capName, PlayerConst const *pConst,sead::Vector3f *noseScale, sead::Vector3f *earScale, bool isCloset);
-        static PlayerCostumeInfo *initMarioModelCommon(al::LiveActor *player, const al::ActorInitInfo &initInfo, char const *bodyName, char const *capName, int subActorNum, bool isDemo, al::AudioKeeper *audioKeeper, bool guessIsChromaKey, bool isCloset);
+        
+        static PlayerCostumeInfo* initMarioModelActorDemo(PlayerJointControlPartsDynamics** jointCtrlPtr,
+                                al::LiveActor* player, const al::ActorInitInfo& initInfo,
+                                char const* bodyName, char const* capName,
+                                PlayerConst const* pConst, sead::Vector3f* noseScale,
+                                sead::Vector3f* earScale, bool isCloset);
+
+        static PlayerCostumeInfo* initMarioModelCommon(al::LiveActor* player,
+                                                       const al::ActorInitInfo& initInfo,
+                                                       char const* bodyName, char const* capName,
+                                                       int subActorNum, bool isDemo,
+                                                       al::AudioKeeper* audioKeeper,
+                                                       bool guessIsChromaKey, bool isCloset);
+        // not a real symbol, func at 0x445A24
+        static void initMarioAudio(al::LiveActor* player, const al::ActorInitInfo& initInfo,
+                                   al::Resource* modelRes, bool isDemo,
+                                   al::AudioKeeper* audioKeeper);
+        // not a real symbol, func at 0x448B8C
+        static void initMarioSubModel(al::LiveActor* subactor, const al::ActorInitInfo& initInfo,
+                                      bool isInvisible, bool isDemo, bool isChromaKey,
+                                      bool isCloset);
+        // not a real symbol, func at 0x445128
+        static PlayerHeadCostumeInfo* initMarioHeadCostumeInfo(al::LiveActor* player,
+                                                               const al::ActorInitInfo& initInfo,
+                                                               const char*, const char*,
+                                                               const char*, const char*, bool, bool,
+                                                               bool, bool, bool);
+        // not a real symbol, func at 0x445DF4
+        static void initMarioDepthModel(al::LiveActor *player, bool isDemo, bool isChromaKey);
 };
--- a/include/game/Player/PlayerInfo.h
+++ b/include/game/Player/PlayerInfo.h
@ -9,6 +9,10 @@
 #include "PlayerCostumeInfo.h"
 #include "PlayerModelChangerHakoniwa.h"

+namespace al {
+struct FootPrintHolder;
+}
+
 class PlayerInfo {
    public:
        PlayerInfo();
@ -26,7 +30,7 @@ class PlayerInfo {
        struct PlayerJointControlKeeper *pJoinControlKeeper; // 0x50
        struct PlayerCounterIceWater *pCounterIceWater; // 0x58
        struct PlayerStainControl *pStainControl; // 0x60
-        struct FootPrintHolder *mFootPrintHolder; // 0x68
+        al::FootPrintHolder *mFootPrintHolder; // 0x68
        al::HitSensor *mHitSensor; // 0x70
        struct PlayerFormSensorCollisionArranger *pSensorCollArranger; // 0x78
        PlayerInput *pInput; // 0x80
--- a/include/game/SaveData/SaveDataAccessFunction.h
+++ b/include/game/SaveData/SaveDataAccessFunction.h
@ -0,0 +1,19 @@
+#pragma once
+
+#include "game/GameData/GameDataHolder.h"
+
+namespace SaveDataAccessFunction {
+    void startSaveDataInit(GameDataHolder *);
+    void startSaveDataInitSync(GameDataHolder *);
+    void startSaveDataLoadFile(GameDataHolder *);
+    void startSaveDataReadSync(GameDataHolder *);
+    void startSaveDataReadAll(GameDataHolder *);
+    void startSaveDataWrite(GameDataHolder *);
+    void startSaveDataWriteWithWindow(GameDataHolder *);
+    void startSaveDataCopyWithWindow(GameDataHolder *,int,int);
+    void startSaveDataDeleteWithWindow(GameDataHolder *,int);
+    void startSaveDataWriteSync(GameDataHolder *);
+    bool updateSaveDataAccess(GameDataHolder *,bool);
+    bool isEnableSave(GameDataHolder const*);
+    bool isDoneSave(GameDataHolder *);
+}
--- a/include/game/SceneObjs/RouteGuideDirector.h
+++ b/include/game/SceneObjs/RouteGuideDirector.h
@ -0,0 +1,31 @@
+#pragma once
+
+#include "al/LiveActor/LiveActor.h"
+#include "al/scene/ISceneObj.h"
+
+class RouteGuideDirector : public al::LiveActor, public al::ISceneObj {
+public:
+    RouteGuideDirector();
+
+    void initAfterPlacementSceneObj(al::ActorInitInfo const&) override;
+
+    bool isValidate(void) const;
+    void offGuideSystem(void);
+    void deactivateGuide(void);
+    void onGuideSystem(void);
+    void activateGuide(void);
+    void offGuideByActor(al::LiveActor *);
+    void addInvidateList(al::LiveActor *);
+    void onGuideByActor(al::LiveActor *);
+    void removeInvidateList(al::LiveActor const*);
+    void addRouteGuidePointBufferCount(int);
+    void registerRouteGuidePoint(struct RouteGuidePoint *);
+    void addRouteGuideArrowBufferCount(int);
+    void registerRouteGuideArrow(struct RouteGuideArrowBase*);
+    
+    void exeOff(void);
+    void exeOn(void);
+
+    virtual const char* getSceneObjName() override;
+    virtual void initSceneObj(void) override;
+};
--- a/include/game/Sequence/SequenceFactory.h
+++ b/include/game/Sequence/SequenceFactory.h
@ -0,0 +1,6 @@
+#pragma once
+
+class SequenceFactory {
+public:
+    static void createSequence(const char *);
+};
--- a/include/game/StageScene/StageScene.h
+++ b/include/game/StageScene/StageScene.h
@ -4,22 +4,113 @@
 #include "game/StageScene/StageSceneLayout.h"
 #include "game/StageScene/StageSceneStatePauseMenu.h"

-#define INHERITSIZE sizeof(al::Scene)
+namespace al {
+struct LayoutTextureRenderer;
+struct SimpleAudioUser;
+struct ParabolicPath;
+struct DemoSyncedEventKeeper;
+struct ChromakeyDrawer;
+struct WipeHolder;
+}

 class StageScene : public al::Scene
 {
    public:
        bool isPause() const;
-        // 0x88 StageResourceKeeper *
-        // 0x90 LiveActorKit *
-        // 0x98 LayoutKit *
-        // 0xA0 SceneObjHolder *
-        // 0xA8 SceneStopCtrl *

-        unsigned char padding_180[0x180 - INHERITSIZE];
-        StageSceneStatePauseMenu *mStatePauseMenu; // 0x180
-        unsigned char padding_2D0[0x148];
-        GameDataHolderAccessor mHolder; // 0x2D0
-        unsigned char padding_2F8[0x20];
-        StageSceneLayout *stageSceneLayout; // 0x2F8
+        sead::FixedSafeString<0x40> mStageName;
+        int field_130;
+        struct StageSceneStateWorldMap *field_138;
+        struct StageSceneStateShop *field_140;
+        struct StageSceneStateSnapShot *field_148;
+        struct StageSceneStateGetShine *field_150;
+        struct StageSceneStateGetShineMain *field_158;
+        struct StageSceneStateGetShineGrand *field_160;
+        struct StageSceneStateCollectBgm *field_168;
+        struct StageSceneStateCollectionList *field_170;
+        struct StageSceneStateMiniGameRanking *field_178;
+        struct StageSceneStatePauseMenu *field_180;
+        struct StageSceneStateCloset *field_188;
+        struct StageSceneStateSkipDemo *field_190;
+        struct StageSceneStateCheckpointWarp *field_198;
+        struct StageSceneStateCarryMeat *field_1A0;
+        void *field_1A8;
+        void *field_1B0;
+        struct StageSceneStateMiss *field_1B8;
+        struct StageSceneStateYukimaruRace *field_1C0;
+        struct StageSceneStateYukimaruRaceTutorial *field_1C8;
+        struct StageSceneStateRaceManRace *field_1D0;
+        struct StageSceneStateRadicon *field_1D8;
+        struct StageSceneStateScenarioCamera *field_1E0;
+        struct StageSceneStateRecoverLife *field_1E8;
+        struct StageSceneStateGetShineMainSandWorld *field_1F0;
+        void *field_1F8;
+        struct StageSceneStateWarp *field_200;
+        void *field_208;
+        struct ScenarioStartCameraHolder *field_210;
+        sead::FixedSafeString<0x40> field_218;
+        sead::FixedSafeString<0x40> field_270;
+        void *qword2C8;
+        GameDataHolderAccessor mHolder;
+        void *qword2D8;
+        al::LayoutTextureRenderer *qword2E0;
+        struct PlayGuideSkip *qword2E8;
+        struct CinemaCaption *qword2F0;
+        StageSceneLayout *mSceneLayout;
+        char field_300;
+        char field_301;
+        al::SimpleLayoutAppearWaitEnd *char308;
+        al::SimpleLayoutAppearWaitEnd *field_310;
+        al::SimpleLayoutAppearWaitEnd *field_318;
+        struct ControllerGuideSnapShotCtrl *field_320;
+        InputSeparator *field_328;
+        al::WipeSimple *field_330;
+        al::WipeHolder *field_338;
+        void *field_340;
+        al::WindowConfirm *field_348;
+        struct MiniGameMenu *field_350;
+        bool field_358;
+        char gap359[15];
+        char char368;
+        struct MapLayout *field_370;
+        al::SimpleLayoutAppearWaitEnd *field_378;
+        al::LiveActorGroup *field_380;
+        void *field_388;
+        void *mKoopaLv1Actor;
+        struct TimeBalloonNpc *mTimeBalloonNpc;
+        struct ProjectItemDirector *field_3A0;
+        struct Pyramid *field_3A8;
+        void *field_3B0;
+        al::Nerve *field_3B8;
+        SceneAudioSystemPauseController *field_3C0;
+        struct DemoSoundSynchronizer *mDemoSoundSynchronizer;
+        al::SimpleAudioUser *mStageStartAtmosSe;
+        al::SimpleAudioUser *mSePlayArea;
+        al::SimpleAudioUser *mSnapShotCameraCtrlAudio;
+        struct ProjectSeNamedList *field_3E8;
+        void *field_3F0;
+        struct TimeBalloonDirector *mTimeBalloonDirector;
+        struct TimeBalloonSequenceInfo *mTimeBalloonSequenceInfo;
+        void *qword408;
+        void *qword410;
+        sead::Vector3f qword418;
+        sead::Vector3f qword424;
+        void *qword430;
+        int dword438;
+        const al::LiveActor *field_440;
+        al::ParabolicPath *field_448;
+        al::LiveActor *field_450;
+        void *qword458;
+        int dword460;
+        struct CollectBgmPlayer *qword468;
+        struct CollectBgmRegister *qword470;
+        struct BgmAnimeSyncDirector *qword478;
+        al::DemoSyncedEventKeeper *field_480;
+        void *field_488;
+        int field_490;
+        struct NpcEventDirector *qword498;
+        al::ChromakeyDrawer *field_4A0;
+        void *qword4A8;
+        ProjectNfpDirector *qword4B0;
+        void *qword4B8;
 };
--- a/include/game/StageScene/StageSceneLayout.h
+++ b/include/game/StageScene/StageSceneLayout.h
@ -44,7 +44,7 @@ class StageSceneLayout : public al::NerveStateBase {
        void startShineChipCompleteAnim(void);
        void tryStartDemoGetLifeMaxUpItem(bool);
        void startCloset(void);
-        void startShineCountAnim(bool);
+        void startShineCountAnim(bool isGameClear);

        void exeAppear(void);
        void exeWait(void);
--- a/include/game/StageScene/StageSceneStateOption.h
+++ b/include/game/StageScene/StageSceneStateOption.h
@ -125,4 +125,6 @@ class StageSceneStateOption : public al::HostStateBase<al::Scene>, public al::IU
        bool field_0x180;
        al::MessageSystem *mMsgSystem;
        InputSeparator *mInputSeperator;
-};
+};
+
+static_assert(sizeof(StageSceneStateOption) == 0x198, "StageSceneStateOption Size");
--- a/include/game/StageScene/StageSceneStateServerConfig.hpp
+++ b/include/game/StageScene/StageSceneStateServerConfig.hpp
@ -17,6 +17,7 @@

 #include "logger.hpp"
 #include "server/gamemode/GameModeConfigMenu.hpp"
+#include "server/gamemode/GameModeConfigMenuFactory.hpp"

 class FooterParts;

@ -28,8 +29,8 @@ class StageSceneStateServerConfig : public al::HostStateBase<al::Scene>, public
        enum ServerConfigOption {
            GAMEMODECONFIG,
            GAMEMODESWITCH,
-            RECONNECT,
-            SETIP
+            SETIP,
+            SETPORT
        };

        virtual al::MessageSystem* getMessageSystem(void) const override;
@ -38,10 +39,11 @@ class StageSceneStateServerConfig : public al::HostStateBase<al::Scene>, public
        virtual void kill(void) override;

        void exeMainMenu();
-        void exeOpenKeyboard();
-        void exeRestartServer();
+        void exeOpenKeyboardIP();
+        void exeOpenKeyboardPort();
        void exeGamemodeConfig();
        void exeGamemodeSelect();
+        void exeSaveData();

        void endSubMenu();

@ -58,25 +60,30 @@ class StageSceneStateServerConfig : public al::HostStateBase<al::Scene>, public
        
        SimpleLayoutMenu* mCurrentMenu = nullptr;
        CommonVerticalList* mCurrentList = nullptr;
-        // Root Page, contains buttons for gamemode config, server reconnecting, and server ip address changing
+        // Root Page, contains buttons for gamemode config, and server ip address changing
        SimpleLayoutMenu* mMainOptions = nullptr;
        CommonVerticalList *mMainOptionsList = nullptr;
-        // Sub-Page for Mode configuration, has buttons for selecting current gamemode and configuring currently selected mode (if no mode is chosen, button will not do anything)
-        SimpleLayoutMenu* mGamemodeConfig = nullptr;
-        CommonVerticalList* mGameModeConfigList = nullptr;
        // Sub-Page of Mode config, used to select a gamemode for the client to use
        SimpleLayoutMenu* mModeSelect = nullptr;
        CommonVerticalList* mModeSelectList = nullptr;
-        // Controls what shows up in specific gamemode config page
-        GameModeConfigMenu *mGamemodeConfigMenu = nullptr;
+
+        // Sub-Pages for Mode configuration, has buttons for selecting current gamemode and configuring currently selected mode (if no mode is chosen, button will not do anything)
+        struct GameModeEntry {
+            GameModeConfigMenu* mMenu;
+            SimpleLayoutMenu* mLayout = nullptr;
+            CommonVerticalList* mList = nullptr;
+        };
+        sead::SafeArray<GameModeEntry, GameModeConfigMenuFactory::getMenuCount()> mGamemodeConfigMenus;
+        GameModeEntry *mGamemodeConfigMenu = nullptr;

        bool mIsDecideConfig = false;
 };

 namespace {
    NERVE_HEADER(StageSceneStateServerConfig, MainMenu)
-    NERVE_HEADER(StageSceneStateServerConfig, OpenKeyboard)
-    NERVE_HEADER(StageSceneStateServerConfig, RestartServer)
+    NERVE_HEADER(StageSceneStateServerConfig, OpenKeyboardIP)
+    NERVE_HEADER(StageSceneStateServerConfig, OpenKeyboardPort)
    NERVE_HEADER(StageSceneStateServerConfig, GamemodeConfig)
    NERVE_HEADER(StageSceneStateServerConfig, GamemodeSelect)
-}
+    NERVE_HEADER(StageSceneStateServerConfig, SaveData)
+}
--- a/include/game/WorldList/WorldResourceLoader.h
+++ b/include/game/WorldList/WorldResourceLoader.h
@ -1,7 +1,48 @@
 #pragma once

-class WorldResourceLoader {
-    public:
-        void loadWorldResource(int,int,bool,char const *);
-        bool requestLoadWorldHomeStageResource(int worldIndex, int scenario);
-};
+#include "al/async/AsyncFunctorThread.h"
+#include "al/hio/HioNode.h"
+#include "game/GameData/GameDataHolder.h"
+#include "heap/seadHeap.h"
+
+
+class WorldResourceLoader : public al::HioNode {
+public:
+    WorldResourceLoader(GameDataHolder *);
+    virtual ~WorldResourceLoader();
+
+    void loadResource(void);
+    void cancelLoadWorldResource(void);
+    void tryDestroyWorldResource(void);
+    bool requestLoadWorldHomeStageResource(int worldIndex, int scenario);
+    bool isEndLoadWorldResource(void) const; // { return mResourceLoadThread->isDone(); };
+    void requestLoadWorldResourceCommon(int);
+    void requestLoadWorldResource(int);
+    void createResourcePlayer(void);
+    void tryDestroyWorldResourceOnlyCap(void);
+    void calcLoadPercent(void);
+    void getLoadWorldId(void);
+    bool tryLoadResource(char const*,char const*,char const*);
+    void loadWorldResource(int,int,bool,char const*);
+    void calcWorldResourceHeapSize(void);
+
+    al::AsyncFunctorThread* mResourceLoadThread; // 0x8
+    sead::Heap* mWorldResHeap = nullptr;         // 0x10
+    sead::Heap* mCapHeap = nullptr;              // 0x18
+    sead::Heap* mWaterfallHeap = nullptr;        // 0x20
+    int mCurWorld = -1;                          // 0x28 
+    int mCurScenario = -1;                       // 0x2C
+    bool unkBool = true;                         // 0x30
+    bool mIsCancelLoad = true;                   // 0x31
+    void *unkPtr4 = nullptr;                     // 0x38
+    void* unkPtr5 = nullptr;                     // 0x40
+    int unkInt3 = 0;                             // 0x48
+    bool unkBool3 = true;                        // 0x4C
+    int unkInt4 = 0;                             // 0x50
+    int unkInt5 = 1;                             // 0x5C
+    GameDataHolder* mDataHolder;                 // 0x58
+    bool mIsDoneLoadingArcs = false;             // 0x60
+    int mArcCount = 0;                           // 0x64
+};
+
+static_assert(sizeof(WorldResourceLoader) == 0x68, "WorldResourceLoader size");
--- a/include/helpers.hpp
+++ b/include/helpers.hpp
@ -14,14 +14,6 @@

 #include "game/GameData/GameDataFunction.h"

-#define RAD(deg) (deg * (M_PI / 180)) // converts Degrees to Radians
-#define DEG(rad) (rad * (180 / M_PI)) // converts Radians to Degrees
-#define BTOC(bool) (bool ? "True" : "False") // converts boolean to true/false char
-#define ACNT(arr) (sizeof(arr) / sizeof(arr[0]))  // returns size of inputted array
-// used to convert macro values to strings
-#define STRINGIFY(x) #x
-#define TOSTRING(x) STRINGIFY(x)
-
 bool isPartOf(const char* w1, const char* w2);

 int indexOf(char *w1, char c1);
--- a/include/main.hpp
+++ b/include/main.hpp
@ -51,8 +51,6 @@
 #include "Keyboard.hpp"
 #include "server/DeltaTime.hpp"

-static const int playBufSize = 8;
-
 static bool isInGame = false;

 static bool debugMode = false;
--- a/include/nn/account.h
+++ b/include/nn/account.h
@ -33,7 +33,11 @@ namespace nn
                return *this;
            }

-            inline void print() {
+            inline bool isEmpty() const {
+                return *this == EmptyId;
+            }
+
+            inline void print() const {
                Logger::log("Player ID: 0x");
                Logger::disableName();
                for (size_t i = 0; i < 0x10; i++) { Logger::log("%02X", data[i]); }
@ -41,13 +45,15 @@ namespace nn
                Logger::enableName();
            }

-            inline void print(const char *prefix) {
+            inline void print(const char *prefix) const {
                Logger::log("%s: 0x", prefix);
                Logger::disableName();
                for (size_t i = 0; i < 0x10; i++) { Logger::log("%02X", data[i]); }
                Logger::log("\n");
                Logger::enableName();
            }
+
+            static const Uid EmptyId; 
        };

        typedef u64 NetworkServiceAccountId;
--- a/include/nn/socket.h
+++ b/include/nn/socket.h
@ -17,6 +17,15 @@ struct sockaddr
    u8 _8[8];           // 8
 };

+struct hostent
+{
+    char*   h_name;
+    char**  h_aliases;
+    int     h_addrtype;
+    int     h_length;
+    char**  h_addr_list;
+};
+

 namespace nn { namespace socket {

@ -34,4 +43,8 @@ s32 Recv(s32 socket, void* out, ulong outLen, s32 flags);
 u16 InetHtons(u16 val);
 s32 InetAton(const char* addressStr, in_addr* addressOut);

+struct hostent* GetHostByName(const char* name);
+
+u32 GetLastErrno();
+
 } }
--- a/include/nn/swkbd/swkbd.h
+++ b/include/nn/swkbd/swkbd.h
@ -2,13 +2,23 @@

 #include <cstdint>
 #include <cstdlib>
+#include "types.h"
 typedef unsigned long int ulong;
 typedef unsigned short int ushort;
 typedef unsigned int uint;
 typedef unsigned char uchar;

-namespace nn
-{
+namespace nn {
+
+    namespace applet {
+    enum ExitReason {
+            Normal = 0,
+            Canceled = 1,
+            Abnormal = 2,
+            Unexpected = 10
+        };
+    }
+
    namespace swkbd
    {
        enum Preset
@ -103,40 +113,18 @@ namespace nn
            Max_DictionaryLang
        };

+        enum CloseResult
+        {
+            Enter,
+            Cancel
+        };
+
        struct DictionaryInfo
        {
            uint offset; // 0x0
            ushort size; // 0x4
            DictionaryLang lang; // 0x6
        };
-
-        // KeyboardMode keyboardMode; // 0x0
-        // const char okText[0x8]; // 0x8
-        // char leftOptionalSymbolKey; // 0x10
-        // char rightOptionalSymbolKey; // 0x12
-        // bool isPredictionEnabled; // 0x14
-        // InvalidChar invalidCharFlag; // 0x18
-        // InitialCursorPos initialCursorPos; // 0x1C
-        // const char headerText[0x40]; // 0x20
-        // const char subText[0x80]; // 0x28
-        // const char guideText[0x100]; // 0x30
-        // int textMaxLength; // 0x38
-        // int textMinLength; // 0x3C
-        // PasswordMode passwordMode; // 0x40
-        // InputFormMode inputFormMode; // 0x44
-        // bool isUseNewLine; // 0x48
-        // bool isUseUtf8; // 0x49
-        // bool isUseBlurBackground; // 0x4A
-        // int _initialStringOffset; // 0x4C
-        // int _initialStringLength; // 0x50
-        // int _userDictionaryOffset; // 0x54
-        // int _userDictionaryNum; // 0x58
-        // bool _isUseTextCheck; // 0x5C
-        // void *_textCheckCallback; // 0x60
-        // int* separateTextPos; // 0x68
-        // DictionaryInfo* _customizedDicInfoList; // 0x70
-        // unsigned char _customizedDicCount; // 0x78
-        // unsigned char* _reserved;          // 0x80
        
        struct KeyboardConfig
        {
@ -193,6 +181,7 @@ namespace nn

        ulong GetRequiredWorkBufferSize(bool);
        ulong GetRequiredStringBufferSize(void);
+        nn::applet::ExitReason getExitReason();
        void MakePreset(nn::swkbd::KeyboardConfig *,nn::swkbd::Preset);
        //void SetHeaderText(nn::swkbd::KeyboardConfig *,char16_t const*);
        //void SetSubText(nn::swkbd::KeyboardConfig*, char16_t const*);
@ -211,7 +200,9 @@ namespace nn
        void SetInitialText(nn::swkbd::ShowKeyboardArg *,char16_t const*);
        void SetInitialTextUtf8(nn::swkbd::ShowKeyboardArg *,char const*);
        //void SetUserWordList(nn::swkbd::ShowKeyboardArg *,nn::swkbd::UserWord const*,int);
-        void ShowKeyboard(nn::swkbd::String *,nn::swkbd::ShowKeyboardArg const&);
+        int ShowKeyboard(nn::swkbd::String*, nn::swkbd::ShowKeyboardArg const&);
+
+        __attribute__((used)) static nn::applet::ExitReason g_ExitReason;
        
    } // namespace swkbd
 } // namespace nn
--- a/include/nn/system_settings.ini
+++ b/include/nn/system_settings.ini
@ -1,53 +0,0 @@
-; Disable uploading error reports to Nintendo
-[eupld]
-; upload_enabled = u8!0x0
-; Control whether RO should ease its validation of NROs.
-; (note: this is normally not necessary, and ips patches can be used.)
-[ro]
-; ease_nro_restriction = u8!0x1
-; Atmosphere custom settings
-[atmosphere]
-; Reboot from fatal automatically after some number of milliseconds.
-; If field is not present or 0, fatal will wait indefinitely for user input.
-; fatal_auto_reboot_interval = u64!0x0
-; Make the power menu's "reboot" button reboot to payload.
-; Set to "normal" for normal reboot, "rcm" for rcm reboot.
-; power_menu_reboot_function = str!payload
-; Controls whether dmnt cheats should be toggled on or off by
-; default. 1 = toggled on by default, 0 = toggled off by default.
-; dmnt_cheats_enabled_by_default = u8!0x1
-; Controls whether dmnt should always save cheat toggle state
-; for restoration on new game launch. 1 = always save toggles,
-; 0 = only save toggles if toggle file exists.
-; dmnt_always_save_cheat_toggles = u8!0x0
-; Enable writing to BIS partitions for HBL.
-; This is probably undesirable for normal usage.
-; enable_hbl_bis_write = u8!0x0
-; Enable reading the CAL0 partition for HBL.
-; This is probably undesirable for normal usage.
-; enable_hbl_cal_read = u8!0x0
-; Controls whether fs.mitm should redirect save files
-; to directories on the sd card.
-; 0 = Do not redirect, 1 = Redirect.
-; NOTE: EXPERIMENTAL
-; If you do not know what you are doing, do not touch this yet.
-; fsmitm_redirect_saves_to_sd = u8!0x0
-; Controls whether to enable the deprecated hid mitm
-; to fix compatibility with old homebrew.
-; 0 = Do not enable, 1 = Enable.
-; Please note this setting may be removed in a
-; future release of Atmosphere.
-; enable_deprecated_hid_mitm = u8!0x0
-; Controls whether am sees system settings "DebugModeFlag" as
-; enabled or disabled.
-; 0 = Disabled (not debug mode), 1 = Enabled (debug mode)
-; enable_am_debug_mode = u8!0x0
-[hbloader]
-; Controls the size of the homebrew heap when running as applet.
-; If set to zero, all available applet memory is used as heap.
-; The default is zero.
-; applet_heap_size = u64!0x0
-; Controls the amount of memory to reserve when running as applet
-; for usage by other applets. This setting has no effect if
-; applet_heap_size is non-zero. The default is 0x8600000.
-; applet_heap_reservation_size = u64!0x8600000
--- a/include/nx/svc.h
+++ b/include/nx/svc.h
@ -0,0 +1,20 @@
+/**
+ * @file svc.h
+ * @brief Wrappers for kernel syscalls.
+ * @copyright libnx Authors
+ */
+#pragma once
+
+extern "C" {
+
+/**
+ * @brief Outputs debug text, if used during debugging.
+ * @param[in] str Text to output.
+ * @param[in] size Size of the text in bytes.
+ * @return Result code.
+ * @note Syscall number 0x27.
+ */
+Result svcOutputDebugString(const char *str, u64 size);
+
+
+}
--- a/include/packets/CaptureInf.h
+++ b/include/packets/CaptureInf.h
@ -2,12 +2,12 @@

 #include "Packet.h"

-struct CaptureInf : Packet {
+struct PACKED CaptureInf : Packet {
    CaptureInf() : Packet() {
        this->mType = PacketType::CAPTUREINF;
        mPacketSize = sizeof(CaptureInf) - sizeof(Packet);
    };

    char hackName[0x20] = {};
-    
+
 };
--- a/include/packets/ChangeStagePacket.h
+++ b/include/packets/ChangeStagePacket.h
@ -2,7 +2,7 @@

 #include "Packet.h"

-struct ChangeStagePacket : Packet {
+struct PACKED ChangeStagePacket : Packet {
    ChangeStagePacket() : Packet() {
        this->mType = PacketType::CHANGESTAGE;
        mPacketSize = sizeof(ChangeStagePacket) - sizeof(Packet);
--- a/include/packets/CostumeInf.h
+++ b/include/packets/CostumeInf.h
@ -2,7 +2,7 @@

 #include "Packet.h"

-struct CostumeInf : Packet {
+struct PACKED CostumeInf : Packet {
    CostumeInf() : Packet() {this->mType = PacketType::COSTUMEINF;  mPacketSize = sizeof(CostumeInf) - sizeof(Packet);};
    CostumeInf(const char* body, const char* cap) : Packet() {
        this->mType = PacketType::COSTUMEINF;
--- a/include/packets/GameInf.h
+++ b/include/packets/GameInf.h
@ -3,10 +3,10 @@
 #include "Packet.h"
 #include "al/util.hpp"

-struct GameInf : Packet {
+struct PACKED GameInf : Packet {
    GameInf() : Packet() {this->mType = PacketType::GAMEINF; mPacketSize = sizeof(GameInf) - sizeof(Packet);};
-    bool is2D = false;
-    u8 scenarioNo = -1;
+    bool1 is2D = false;
+    u8 scenarioNo = 255;
    char stageName[0x40] = {};

    bool operator==(const GameInf &rhs) const {
@ -19,4 +19,4 @@ struct GameInf : Packet {

    bool operator!=(const GameInf& rhs) const { return !operator==(rhs); }

-};
+};
--- a/include/packets/HackCapInf.h
+++ b/include/packets/HackCapInf.h
@ -2,10 +2,10 @@

 #include "Packet.h"

-struct HackCapInf : Packet {
+struct PACKED HackCapInf : Packet {
    HackCapInf() : Packet() {this->mType = PacketType::HACKCAPINF; mPacketSize = sizeof(HackCapInf) - sizeof(Packet);};
    sead::Vector3f capPos;
    sead::Quatf capQuat;
-    bool isCapVisible = false;
+    bool1 isCapVisible = false;
    char capAnim[PACKBUFSIZE] = {};
 };
--- a/include/packets/InitPacket.h
+++ b/include/packets/InitPacket.h
@ -2,7 +2,7 @@

 #include "Packet.h"

-struct InitPacket : Packet {
+struct PACKED InitPacket : Packet {
    InitPacket() : Packet() {this->mType = PacketType::CLIENTINIT; mPacketSize = sizeof(InitPacket) - sizeof(Packet);};
    u16 maxPlayers = 0;
 };
--- a/include/packets/Packet.h
+++ b/include/packets/Packet.h
@ -5,6 +5,8 @@

 #include "nn/account.h"

+#include "types.h"
+
 #define PACKBUFSIZE      0x30
 #define COSTUMEBUFSIZE   0x20

@ -23,12 +25,14 @@ enum PacketType : short {
    SHINECOLL,
    CAPTUREINF,
    CHANGESTAGE,
-    CMD
+    CMD,
+    End // end of enum for bounds checking
 };

 // attribute otherwise the build log is spammed with unused warnings
-__attribute((used)) static const char *packetNames[] = {
+USED static const char *packetNames[] = {
    "Unknown",
+    "Client Initialization",
    "Player Info",
    "Player Cap Info",
    "Game Info",
@ -38,6 +42,7 @@ __attribute((used)) static const char *packetNames[] = {
    "Costume Info",
    "Moon Collection",
    "Capture Info",
+    "Change Stage",
    "Server Command"
 };

@ -59,7 +64,7 @@ static const char *senderNames[] = {
 };
 */

-struct Packet {
+struct PACKED Packet {
    nn::account::Uid mUserID; // User ID of the packet owner
    PacketType mType = PacketType::UNKNOWN;
    short mPacketSize = 0; // represents packet size without size of header
--- a/include/packets/PlayerConnect.h
+++ b/include/packets/PlayerConnect.h
@ -2,9 +2,11 @@

 #include "Packet.h"

-struct PlayerConnect : Packet {
+#include <cstdint>
+
+struct PACKED PlayerConnect : Packet {
    PlayerConnect() : Packet() {this->mType = PacketType::PLAYERCON; mPacketSize = sizeof(PlayerConnect) - sizeof(Packet);};
    ConnectionTypes conType;
-    u16 maxPlayerCount;
+    u16 maxPlayerCount = USHRT_MAX;
    char clientName[COSTUMEBUFSIZE] = {};
 };
--- a/include/packets/PlayerDC.h
+++ b/include/packets/PlayerDC.h
@ -2,6 +2,6 @@

 #include "Packet.h"

-struct PlayerDC : Packet {
+struct PACKED PlayerDC : Packet {
    PlayerDC() : Packet() {this->mType = PacketType::PLAYERDC; mPacketSize = sizeof(PlayerDC) - sizeof(Packet);};
 };
--- a/include/packets/PlayerInfPacket.h
+++ b/include/packets/PlayerInfPacket.h
@ -4,9 +4,9 @@
 #include "al/util.hpp"
 #include "algorithms/PlayerAnims.h"

-struct PlayerInf : Packet {
+struct PACKED PlayerInf : Packet {
    PlayerInf() : Packet() {mType = PacketType::PLAYERINF; mPacketSize = sizeof(PlayerInf) - sizeof(Packet);};
-    sead::Vector3f playerPos; 
+    sead::Vector3f playerPos;
    sead::Quatf playerRot;
    float animBlendWeights[6];
    PlayerAnims::Type actName;
--- a/include/packets/ServerCommand.h
+++ b/include/packets/ServerCommand.h
@ -2,7 +2,7 @@

 #include "Packet.h"

-struct ServerCommand : Packet {
+struct PACKED ServerCommand : Packet {
    ServerCommand(const char *command) : Packet() {this->mType = PacketType::CMD; strcpy(srvCmd, command); mPacketSize = sizeof(ServerCommand) - sizeof(Packet);};
    char srvCmd[PACKBUFSIZE] = {};
 };
--- a/include/packets/ShineCollect.h
+++ b/include/packets/ShineCollect.h
@ -2,8 +2,8 @@

 #include "Packet.h"

-struct ShineCollect : Packet {
+struct PACKED ShineCollect : Packet {
    ShineCollect() : Packet() {this->mType = PacketType::SHINECOLL; mPacketSize = sizeof(ShineCollect) - sizeof(Packet);};
    int shineId = -1;
-    bool isGrand = false;
+    bool1 isGrand = false;
 };
--- a/include/packets/TagInf.h
+++ b/include/packets/TagInf.h
@ -8,10 +8,10 @@ enum TagUpdateType : u8 {
    STATE                = 1 << 1
 };

-struct TagInf : Packet {
+struct PACKED TagInf : Packet {
    TagInf() : Packet() { this->mType = PacketType::TAGINF; mPacketSize = sizeof(TagInf) - sizeof(Packet);};
    TagUpdateType updateType;
-    bool isIt = false;
+    bool1 isIt = false;
    u8 seconds;
    u16 minutes;
 };
--- a/include/puppets/PuppetHolder.hpp
+++ b/include/puppets/PuppetHolder.hpp
@ -28,8 +28,10 @@ class PuppetHolder {

        void clearPuppets() { mPuppetArr.clear(); }

+        bool resizeHolder(int size);
+
    private:
-        sead::PtrArray<PuppetActor> mPuppetArr;
+        sead::PtrArray<PuppetActor> mPuppetArr = sead::PtrArray<PuppetActor>();

        PuppetActor *mDebugPuppet;

--- a/include/rs/util.hpp
+++ b/include/rs/util.hpp
@ -2,6 +2,7 @@

 #include "game/GameData/GameDataFile.h"
 #include "game/Info/QuestInfoHolder.h"
+#include "game/Player/PlayerActorBase.h"
 #include "sead/math/seadVector.h"
 #include "al/util.hpp"
 #include "al/sensor/SensorMsg.h"
@ -10,6 +11,10 @@

 namespace rs {

+    bool updateNormalStateExcludeGraphics(al::Scene*);
+
+    void updateEffectSystemEnv(al::Scene *);
+
    bool isModeE3Rom(void);

    bool isModeE3LiveRom(void);
@ -33,7 +38,7 @@ namespace rs {

    bool isPlayerDamageStopDemo(const al::LiveActor *);

-    PlayerActorHakoniwa * getPlayerActor(const al::Scene *);
+    PlayerActorBase * getPlayerActor(const al::Scene *);

    void get2DAreaPos(sead::Vector3<f32> *, al::AreaObj const *);

@ -75,5 +80,9 @@ namespace rs {

    void calcGroundNormalOrGravityDir(sead::Vector3f *result, al::LiveActor const *actor, IUsePlayerCollision const *col);

-    void calcPlayerFrontDir(sead::Vector3f *result, al::LiveActor const *);
+    void calcPlayerFrontDir(sead::Vector3f* result, al::LiveActor const*);
+
+    int getStageShineAnimFrame(al::LiveActor const*, char const*);
+    const char* getStageShineArchiveName(al::LiveActor const*, char const*);
+    const char* getStageShineEmptyArchiveName(al::LiveActor const*, char const*);
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jack Garrard	f548de2117	Merge pull request #60 from speyejack/main Release v1.1.0 - v1.3.0	2023-09-12 15:01:30 -07:00
Jack Garrard	cdac0a8679	Merge commit 'd5b49b2'	2023-09-12 13:36:12 -07:00
Jack Garrard	3570175752	Merge commit '4339847'	2023-09-12 13:35:35 -07:00
Jack Garrard	89154d6c20	Merge commit 'd4df8f0'	2023-09-12 13:28:45 -07:00
Jack Garrard	d5b49b2ea9	Merge pull request #37 from speyejack/packet-acceptance Packet acceptance	2023-09-02 13:03:18 -07:00
Jack Garrard	7064122902	Merge branch 'dev' into packet-acceptance	2023-09-02 12:58:53 -07:00
Jack Garrard	8d94cf7856	Merge pull request #54 from Istador/resend-packets fix: `TagInf` and `CaptureInf` synchronization issues	2023-08-25 18:51:28 -07:00
Jack Garrard	9bf07b3e0d	Merge pull request #53 from Istador/isit-with-active fix: mark player as not a seeker when H&S is disabled	2023-08-24 23:42:13 -07:00
Jack Garrard	125e2bdde2	Merge pull request #55 from Istador/ui-improvements UI improvements	2023-08-24 23:11:31 -07:00
Robin C. Ladiges	45cd4442c8	recycle the reconnect error to warn about the default Ryujinx profile ID	2023-07-08 20:45:53 +02:00
Robin C. Ladiges	c736878df1	`Toggle H&S Gravity` with real toggle functionality	2023-07-08 04:31:56 +02:00
Robin C. Ladiges	366ad5e888	remove reconnect button	2023-07-07 23:46:11 +02:00
Robin C. Ladiges	f810e8f07d	fix: send empty TagInf and CaptureInf on first connection Because other players might still have old values saved in their puppet.	2023-06-24 04:09:47 +02:00
Robin C. Ladiges	2bef6f796e	fix: resend CaptureInf packet on reconnect and for new players	2023-06-24 02:42:54 +02:00
Robin C. Ladiges	4835692672	fix: resend TagInf packet on reconnect and for new players	2023-06-24 01:27:14 +02:00
Robin C. Ladiges	27b9a095f7	fix: mark player as not a seeker when H&S is disabled If a player is a seeker and then disables H&S, they should no longer be considered as a seeker by other players. (Because staying as a seeker will kill hiders when touching them).	2023-06-23 04:18:41 +02:00
Robin C. Ladiges	4339847da5	fix yuzu build Accidentially moved it into the wrong directory.	2022-12-16 16:24:37 -06:00
Robin C. Ladiges	f60fc956d6	for Emulators => for Ryujinx & for yuzu	2022-12-16 13:21:07 -06:00
Robin C. Ladiges	7f6df57f4a	patch out deprecated ::set-output ::set-output currently triggers deprecation warnings and will stop working at 2023-06-01. https://github.blog/changelog/2022-10-11-github-actions-deprecating-save-state-and-set-output-commands/	2022-12-16 13:21:07 -06:00
Robin C. Ladiges	6a5b5146b8	use devkitpro docker image installing it via pacman everytime is unsupported and will lead to http 403 errors.	2022-12-16 13:21:07 -06:00
Robin C. Ladiges	36f9343f83	don't send empty GameInf and CostumeInf packets and resend them on reconnect Resend because: on server restarts the server will lose the stage and costume information. If only one client is connected to the server, the packets currently aren't resent, so the server doesn't know in which stage the client is and what costume it wears (which I'd like to display on the website). With more then one client connected it already works, because when another client joins the server, the client will send both packets.	2022-12-16 13:19:54 -06:00
Jack Garrard	64b56c32da	Add race protection to message queues	2022-10-27 01:02:32 -07:00
Jack Garrard	89415e6f96	Hopefully prevent close socket race condition	2022-10-27 01:00:58 -07:00
Jack Garrard	7c17db2d93	Fix free issue from wrong heap if unknown packet	2022-10-23 14:41:16 -07:00
Jack Garrard	f6408e2b1e	Merge branch 'dev' into packet-acceptance	2022-10-15 00:18:57 -07:00
CraftyBoss	13c873aae0	Merge pull request #35 from Istador/emu-build separate build for emulators	2022-09-04 20:11:38 -07:00
Robin C. Ladiges	65d6ffb4fc	separate build for emulators	2022-09-05 02:30:30 +02:00
CraftyBoss	cc4c1d7c67	Merge branch 'dev' of https://github.com/CraftyBoss/SuperMarioOdysseyOnline into dev	2022-09-04 02:23:16 -07:00
CraftyBoss	d4eabffff1	executor table re-impl, shine sync changes, send/recv netcode refactored	2022-09-04 02:23:02 -07:00
Jack Garrard	b18671f113	Move packet type check to after packet data recv	2022-08-27 01:56:20 -07:00
CraftyBoss	d4df8f030c	Merge pull request #32 from Istador/dev-releases Automatically attach dev builds into one common release	2022-08-13 14:33:17 -07:00
Robin C. Ladiges	81a0726836	move latest-dev tag	2022-08-13 22:58:59 +02:00
Robin C. Ladiges	2898a762d4	attach dev builds all into one release Requirements: - there exists a tag named `latest-dev` already - there exists a release on that tag	2022-08-13 22:58:12 +02:00
Robin C. Ladiges	aff422a6e0	allow build or pre-release details in release tags Examples: - v1.2.3-rc.1 (release candidate 1) - v1.2.3-dev+2 (dev pre-release, build 2)	2022-08-13 22:50:36 +02:00
Robin C. Ladiges	89a76aedab	don't start release names with "Release " the title of the page will otherwise read "Release Release v..."	2022-08-13 22:46:59 +02:00
Robin C. Ladiges	71ff477bb9	github workflow to build and release	2022-08-10 15:30:28 -07:00
Robin C. Ladiges	3325c50c00	build w/ docker	2022-08-10 15:30:28 -07:00
Sanae	b3a30b09f7	Remove a check which blocks players from being updated Oops! teehee SmileW	2022-08-10 16:10:16 -06:00
CraftyBoss	d3b1935899	Merge pull request #20 from Istador/dns on invalid IPv4 addresses, assume it's a hostname and do a DNS lookup	2022-08-10 15:00:35 -07:00
CraftyBoss	71a9da11bf	copy romfs folder to build folder	2022-08-10 14:52:27 -07:00
CraftyBoss	b245408ae6	Merge branch 'Sanae6-main' into dev	2022-08-10 14:40:38 -07:00
CraftyBoss	550b82fc1f	Merge branch 'main' of https://github.com/Sanae6/SuperMarioOdysseyOnline into Sanae6-main	2022-08-10 14:40:16 -07:00
CraftyBoss	dc0930063d	Merge branch 'dev' of https://github.com/CraftyBoss/SuperMarioOdysseyOnline into dev	2022-08-10 14:12:00 -07:00
CraftyBoss	8f4fac417f	change recieve logs, update headers, fix bound bowl crash	2022-08-10 14:11:52 -07:00
Sanae	d18276d255	Fix switching modes between scenes	2022-08-10 15:10:28 -06:00
Sanae	34691affb0	Overhaul gamemode management	2022-08-07 15:57:18 -06:00
Sanae	5f1a91161f	Merge pull request #23 from Link4565/dev	2022-07-24 16:42:07 -06:00
Robin C. Ladiges	ce5b799593	change KeyboardMode from Numeric to ASCII	2022-07-18 03:49:42 +02:00
Robin C. Ladiges	dd4f3202ae	change default IP This might otherwise cause confusion with the server.json setting, which should stay at 0.0.0.0. 127.0.0.1 might at least work with emulators running on the same PC out of the box. Whereas 0.0.0.0 should be invalid (except on some systems that map it to localhost).	2022-07-18 03:48:53 +02:00
Robin C. Ladiges	b3b49bd547	on invalid IPv4 addresses, assume it's a hostname and do a DNS lookup Enable the full keyboard to enter non-numbers and increase max length from 15 to 50 for longer hostnames. I know FQDNs can be longer than 50 characters, but that's less common (and painful to type on the Switch).	2022-07-10 08:13:28 +02:00
CraftyBoss	3c4a20a6d4	only save ip/port changes if actually changed, reconnect fixes	2022-07-09 18:24:00 -07:00
CraftyBoss	4f2bb984f2	begin work on join/disconnect particle effect, fix index oob error	2022-07-08 15:09:04 -07:00
CraftyBoss	88de1dcecf	shift to sead singleton for Client, new custom heap for Client usage	2022-07-08 01:02:28 -07:00
CraftyBoss	1df21b2a3e	added new headers, puppet actor archive, basic player interaction impl	2022-07-07 22:36:29 -07:00
Link4565	c9b1dfa911	Disable blocking on Recv calls Adding non-blocking support to emulators prevents them from stalling with this change	2022-07-06 22:42:41 +01:00
CraftyBoss	2e2909e908	Merge pull request #19 from VelocityRa/fixes1 packets: Make bools take up 1 byte	2022-07-05 19:49:54 -07:00
CraftyBoss	3ce0f03650	Merge branch 'dev' of https://github.com/CraftyBoss/SuperMarioOdysseyOnline into dev	2022-07-05 19:34:48 -07:00
CraftyBoss	b00540b1d9	impl saving after ip/port change, add sceneobj headers, rework puppet info system a bit	2022-07-05 12:45:22 -07:00
Nick Renieris	0e9fde9289	packets: Make bools take up 1 byte	2022-06-28 13:26:26 +03:00
CraftyBoss	dc07fa96a2	Merge pull request #14 from VelocityRa/fixes0 Sync more info on connect, logging/debugging improvements, etc	2022-06-26 17:59:12 -07:00
Nick Renieris	951844e428	main: Fix debug puppet index incrementing The last one was empty.	2022-06-26 10:42:28 +03:00
Nick Renieris	a416458e73	tcpServer: Support specifying port number	2022-06-26 10:42:28 +03:00
Nick Renieris	740f562906	server/logger: Support trying additional ports	2022-06-26 10:42:28 +03:00
Nick Renieris	62cc2a5102	SocketClient: Log packets by default (also recv), excluding Player and Cap They're too spammy.	2022-06-26 10:42:28 +03:00
Nick Renieris	86de220619	Client: Sync Player & Costume info on connect	2022-06-26 06:11:06 +03:00
CraftyBoss	4b83934a47	Merge pull request #13 from VelocityRa/serverconfig-fixes Server Config fixes	2022-06-25 19:55:22 -07:00
Nick Renieris	71b4237d84	Client: Don't erroneously log some errors	2022-06-26 00:55:14 +03:00
Nick Renieris	90f09a8340	states: Fix "Change Server Port" dialog	2022-06-26 00:55:14 +03:00
Nick Renieris	733f239d68	socketBase: Initialize state	2022-06-26 00:55:14 +03:00
Nick Renieris	d1e4466fba	tcpServer: Handle connection reset	2022-06-26 00:55:14 +03:00
Nick Renieris	0bfd7a70b2	main: Log puppet costume	2022-06-25 03:59:25 +03:00
Nick Renieris	23cdf1442d	Make "Reconnect to Server" option work if initial socket conn failed	2022-06-25 03:59:25 +03:00
Nick Renieris	8f21d43bc3	packets/PlayerConnect: Initialize maxPlayerCount It was sending bad data since it wasn't getting inited anywhere.	2022-06-23 20:56:05 -04:00
Nick Renieris	60a5179e4b	Anims/Types: Handle out of bounds FindStr accesses without throwing Throwing tries to call `std::__throw_out_of_range_fmt` which results in a crash. The cause of the out of bounds accesses needs to be investigated.	2022-06-23 20:56:05 -04:00
Nick Renieris	7e4a80b934	packet: Add missing packetNames entries	2022-06-23 20:56:05 -04:00
Nick Renieris	9227e37623	packets: Fix struct packing related bugs - sizeof(bool) is implementation defined. The server assumes it's 4 but for me it was 1 (tested with Release too) which caused some bugs - Structs aren't guaranteed to be packed. The compiler is free to change the layout, which we wouldn't want to for the Packet structs that we deserialize on the server.	2022-06-23 20:56:05 -04:00
Nick Renieris	5c71569545	tcpServer: Don't print intermittent newlines	2022-06-23 20:56:05 -04:00
CraftyBoss	063e20677f	Merge pull request #2 from CraftyBoss/revert-1-dev Revert "remove fixed buffer size from logger (+ run clang-format)"	2022-06-19 23:56:57 -07:00
CraftyBoss	cbadd82b21	Revert "remove fixed buffer size from logger (+ run clang-format)"	2022-06-19 23:56:37 -07:00
CraftyBoss	52c3345633	Merge pull request #1 from fruityloops1/dev remove fixed buffer size from logger (+ run clang-format)	2022-06-19 19:56:19 -07:00
fruityloops1	3b3c5584d9	remove fixed buffer size from runner (+ run clang-format)	2022-06-19 16:10:20 +02:00
Somebody Whoisbored	9b275da22b	Implement Client::setLastUsedPort	2022-06-18 21:42:59 -07:00
Somebody Whoisbored	f8b4bd690d	Enable music by default	2022-06-18 18:38:46 -07:00
Somebody Whoisbored	a7715c15da	Correct socket option/levels	2022-06-18 18:37:46 -07:00
Somebody Whoisbored	0657047d9c	Fix DEBUGLOG check	2022-06-18 18:36:46 -07:00
Somebody Whoisbored	8bddc5622c	Remove libnx link	2022-06-18 18:36:17 -07:00
Somebody Whoisbored	b25cad8812	Add socket errno display	2022-06-18 18:36:00 -07:00
Somebody Whoisbored	41746805c2	Ignore .lst build artifact	2022-06-18 18:26:11 -07:00
Somebody Whoisbored	2b7ca6d914	Add svcOutputDebugString	2022-06-18 18:25:15 -07:00
Sanae	7c7b06542b	Improve keyboard support and add port selection	2022-06-18 18:48:37 -06:00