etc
/
SuperMarioOdysseyOnline
mirror of https://github.com/CraftyBoss/SuperMarioOdysseyOnline.git
0
0
Fork 0
Code Issues 1 Projects Releases Wiki Activity

Merge pull request #60 from speyejack/main 

Release v1.1.0 - v1.3.0
This commit is contained in:
Jack Garrard 2023-09-12 15:01:30 -07:00 committed by GitHub
parent 261848fdd3 cdac0a8679
commit f548de2117
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
145 changed files with 5785 additions and 1534 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
.github/actions/attach/action.yml vendored
View File

@ -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/

30
.github/actions/build/action.yml vendored
View File

@ -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

2
.github/actions/release/action.yml vendored
View File

@ -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

9
.github/workflows/build.yml vendored
View File

@ -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 }}

103
.github/workflows/dev-release.yml vendored Normal file
View File

@ -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 }}

34
.github/workflows/release.yml vendored
View File

@ -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 }}

2
.gitignore vendored
View File

@ -5,5 +5,7 @@ romfs stuff/**
Crash Reports/**
.cache/**
Custom Stage Builds/**
*.lst
*.disabled
compile_commands.json

17
Dockerfile
View File

@ -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

16
Makefile
View File

@ -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/

9
MakefileNSO
View File

@ -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

3
docker-build.sh
View File

@ -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

18
include/Keyboard.hpp
View File

@ -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;
};
};

9
include/SocketBase.hpp
View File

@ -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;
};

27
include/actors/PuppetActor.h
View File

@ -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);

1
include/agl/RenderBuffer.h
View File

@ -7,6 +7,7 @@
#include "RenderTargetColor.h"
#include "RenderTargetDepth.h"
#include "DrawContext.h"
#include "sead/gfx/seadFrameBuffer.h"

12
include/al/LiveActor/LiveActor.h
View File

@ -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

5
include/al/PlayerHolder/PlayerHolder.h
View File

@ -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;

5
include/al/actor/ActorActionKeeper.h
View File

@ -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;

2
include/al/actor/ActorSceneInfo.h
View File

@ -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;

10
include/al/actor/SubActorKeeper.h
View File

@ -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;
};

4
include/al/area/ChangeStageInfo.h
View File

@ -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

42
include/al/execute/ExecuteDirector.h
View File

@ -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

11
include/al/execute/ExecuteOrder.h Normal file
View File

@ -0,0 +1,11 @@
#pragma once
namespace al {
struct ExecuteOrder
{
const char *mListName;
const char *mExecuteGroup;
int mListMaxSize;
const char *mGroupType;
};
}

25
include/al/execute/ExecuteRequestKeeper.h Normal file
View File

@ -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
};
}

9
include/al/execute/ExecuteSystemInitInfo.h Normal file
View File

@ -0,0 +1,9 @@
#pragma once
#include "agl/DrawContext.h"
namespace al {
struct ExecuteSystemInitInfo {
agl::DrawContext *mDrawCtx;
};
}

12
include/al/execute/ExecuteTable.h Normal file
View File

@ -0,0 +1,12 @@
#pragma once
#include "ExecuteOrder.h"
namespace al {
struct ExecuteTable
{
const char *mName;
const al::ExecuteOrder* mExecuteOrders;
int mExecuteOrderCount;
};
}

65
include/al/execute/ExecuteTableHolderDraw.h Normal file
View File

@ -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;

58
include/al/execute/ExecuteTableHolderUpdate.h Normal file
View File

@ -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;

15
include/al/execute/ExecutorListBase.h Normal file
View File

@ -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;
};
}

193
include/al/gfx/GraphicsSystemInfo.h Normal file
View File

@ -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;
};
}

12
include/al/gfx/UniformBlock.h Normal file
View File

@ -0,0 +1,12 @@
#pragma once
#include "types.h"
namespace al {
class UniformBlock {
UniformBlock();
~UniformBlock();
void swap();
};
}

107
include/al/model/ModelCtrl.h Normal file
View File

@ -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;
};
}

46
include/al/model/ModelKeeper.h Normal file
View File

@ -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;
};
}

19
include/al/model/ModelMaterialCategory.h Normal file
View File

@ -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*);
};
}

42
include/al/model/PartsModel.h Normal file
View File

@ -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
};
}

35
include/al/resource/ActorResource.h Normal file
View File

@ -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");

20
include/al/resource/ActorResourceHolder.h Normal file
View File

@ -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();
};
}

48
include/al/resource/Resource.h Normal file
View File

@ -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");

21
include/al/scene/Scene.h
View File

@ -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;
};
};

2
include/al/scene/SceneCreator.h
View File

@ -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;
};
};

89
include/al/scene/SceneObjFactory.h Normal file
View File

@ -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);}
};

10
include/al/scene/SceneObjHolder.h
View File

@ -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:

179
include/al/scene/SceneObjs.h Normal file
View File

@ -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;
};

4
include/al/sensor/HitSensorKeeper.h
View File

@ -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:

51
include/al/sequence/Sequence.h
View File

@ -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;
};
}

6
include/al/util.hpp
View File

@ -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*);

17
include/al/util/KitUtil.h Normal file
View File

@ -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*);
}

28
include/al/util/LiveActorUtil.h
View File

@ -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*);

17
include/al/util/ResourceUtil.h Normal file
View File

@ -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*);
}

480
include/al/util/SensorUtil.h Normal file
View File

@ -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

6
include/algorithms/CaptureAnims.h
View File

@ -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 "";
}
}

6
include/algorithms/CaptureTypes.h
View File

@ -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 "";
}
}

6
include/algorithms/PlayerAnims.h
View File

@ -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 "";
}
}

6
include/algorithms/WipeTypes.h
View File

@ -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 "";
}
}

38
include/cameras/CameraVerticalAbsorber2DGalaxy.h Normal file
View File

@ -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, "");
}

80
include/game/Actors/Shine.h
View File

@ -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);
}

267
include/game/GameData/GameDataFile.h
View File

@ -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;
};

36
include/game/GameData/GameDataFunction.h
View File

@ -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);
}
}

1
include/game/GameData/GameDataHolderAccessor.h
View File

@ -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
};

123
include/game/HakoniwaSequence/HakoniwaSequence.h
View File

@ -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;
};

2
include/game/Info/ShineInfo.h
View File

@ -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

3
include/game/Interfaces/IUsePlayerHack.h
View File

@ -6,5 +6,6 @@
*/
class IUsePlayerHack {
public:
virtual struct PlayerHackKeeper *getPlayerHackKeeper() const = 0;
};

9
include/game/Layouts/CommonVerticalList.h
View File

@ -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

7
include/game/Player/HackCap.h
View File

@ -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
};

29
include/game/Player/HackCap/PlayerCapActionHistory.h Normal file
View File

@ -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)
};

58
include/game/Player/PlayerActorBase.h
View File

@ -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
};

139
include/game/Player/PlayerActorHakoniwa.h
View File

@ -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;
};

9
include/game/Player/PlayerCostumeFunction.h Normal file
View File

@ -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);
}

47
include/game/Player/PlayerFunction.h
View File

@ -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);
};

6
include/game/Player/PlayerInfo.h
View File

@ -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

19
include/game/SaveData/SaveDataAccessFunction.h Normal file
View File

@ -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 *);
}

31
include/game/SceneObjs/RouteGuideDirector.h Normal file
View File

@ -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;
};

6
include/game/Sequence/SequenceFactory.h Normal file
View File

@ -0,0 +1,6 @@
#pragma once
class SequenceFactory {
public:
static void createSequence(const char *);
};

115
include/game/StageScene/StageScene.h
View File

@ -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;
};

2
include/game/StageScene/StageSceneLayout.h
View File

@ -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);

4
include/game/StageScene/StageSceneStateOption.h
View File

@ -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");

33
include/game/StageScene/StageSceneStateServerConfig.hpp
View File

@ -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)
}

51
include/game/WorldList/WorldResourceLoader.h
View File

@ -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");

8
include/helpers.hpp
View File

@ -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);

2
include/main.hpp
View File

@ -51,8 +51,6 @@
#include "Keyboard.hpp"
#include "server/DeltaTime.hpp"
static const int playBufSize = 8;
static bool isInGame = false;
static bool debugMode = false;

10
include/nn/account.h
View File

@ -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;

13
include/nn/socket.h
View File

@ -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();
} }

53
include/nn/swkbd/swkbd.h
View File

@ -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

53
include/nn/system_settings.ini
View File

@ -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

20
include/nx/svc.h Normal file
View File

@ -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);
}

4
include/packets/CaptureInf.h
View File

@ -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] = {};
};

2
include/packets/ChangeStagePacket.h
View File

@ -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);

2
include/packets/CostumeInf.h
View File

@ -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;

8
include/packets/GameInf.h
View File

@ -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); }
};
};

4
include/packets/HackCapInf.h
View File

@ -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] = {};
};

2
include/packets/InitPacket.h
View File

@ -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;
};

11
include/packets/Packet.h
View File

@ -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

6
include/packets/PlayerConnect.h
View File

@ -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] = {};
};

2
include/packets/PlayerDC.h
View File

@ -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);};
};

4
include/packets/PlayerInfPacket.h
View File

@ -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;

2
include/packets/ServerCommand.h
View File

@ -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] = {};
};

4
include/packets/ShineCollect.h
View File

@ -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;
};

4
include/packets/TagInf.h
View File

@ -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;
};

4
include/puppets/PuppetHolder.hpp
View File

@ -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;

13
include/rs/util.hpp
View File

@ -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*);
}

Some files were not shown because too many files have changed in this diff Show More