AxioDL/metaforce
2
0
Fork 0
mirror of https://github.com/AxioDL/metaforce.git synced 2025-06-13 07:13:28 +00:00
Code Issues Projects Releases Wiki Activity

Various loader implementations

Browse Source
This commit is contained in:
Phillip Stephens 2018-10-11 15:57:05 -07:00
parent 8b25548482
commit bbfe61efbf
59 changed files with 1136 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
DataSpec/DNAMP1/ScriptObjects/BloodFlower.hpp
View File

@ -28,7 +28,7 @@ struct BloodFlower : IScriptObject
UniqueID32 particle4; UniqueID32 particle4;
Value<float> unknown1; Value<float> unknown1;
UniqueID32 particle5; UniqueID32 particle5;
Value<float> unknown2; Value<atUint32> unknown2;
void addCMDLRigPairs(PAKRouter<PAKBridge>& pakRouter, void addCMDLRigPairs(PAKRouter<PAKBridge>& pakRouter,
std::unordered_map<UniqueID32, std::pair<UniqueID32, UniqueID32>>& addTo) const std::unordered_map<UniqueID32, std::pair<UniqueID32, UniqueID32>>& addTo) const

2
DataSpec/DNAMP1/ScriptObjects/ElitePirate.hpp
View File

@ -44,7 +44,7 @@ struct ElitePirate : IScriptObject
Value<float> unknown13; Value<float> unknown13;
Value<float> unknown14; Value<float> unknown14;
Value<float> unknown15; Value<float> unknown15;
Value<float> unknown16; Value<atUint32> unknown16;
Value<atUint32> soundID3; Value<atUint32> soundID3;
Value<atUint32> soundID4; Value<atUint32> soundID4;
UniqueID32 particle7; UniqueID32 particle7;

2
Runtime/AutoMapper/CMapArea.cpp
View File

@ -291,7 +291,7 @@ void CMapArea::CMapAreaSurface::Draw(const zeus::CVector3f* verts, const zeus::C
{ {
if (instIdx >= m_instances.size()) if (instIdx >= m_instances.size())
return; return;
Instance& instance = const_cast<Instance&>(m_instances[instIdx]); Instance& instance = const_cast<Instance&>(m_instances[instIdx]);
if (surfColor.a) if (surfColor.a)

8
Runtime/CStateManager.cpp
View File

@ -130,7 +130,7 @@ CStateManager::CStateManager(const std::weak_ptr<CRelayTracker>& relayTracker,
x90c_loaderFuncs[int(EScriptObjectType::PuddleToadGamma)] = ScriptLoader::LoadPuddleToadGamma; x90c_loaderFuncs[int(EScriptObjectType::PuddleToadGamma)] = ScriptLoader::LoadPuddleToadGamma;
x90c_loaderFuncs[int(EScriptObjectType::DistanceFog)] = ScriptLoader::LoadDistanceFog; x90c_loaderFuncs[int(EScriptObjectType::DistanceFog)] = ScriptLoader::LoadDistanceFog;
x90c_loaderFuncs[int(EScriptObjectType::FireFlea)] = ScriptLoader::LoadFireFlea; x90c_loaderFuncs[int(EScriptObjectType::FireFlea)] = ScriptLoader::LoadFireFlea;
x90c_loaderFuncs[int(EScriptObjectType::MetareeAlpha)] = ScriptLoader::LoadMetareeAlpha; x90c_loaderFuncs[int(EScriptObjectType::Metaree)] = ScriptLoader::LoadMetaree;
x90c_loaderFuncs[int(EScriptObjectType::DockAreaChange)] = ScriptLoader::LoadDockAreaChange; x90c_loaderFuncs[int(EScriptObjectType::DockAreaChange)] = ScriptLoader::LoadDockAreaChange;
x90c_loaderFuncs[int(EScriptObjectType::ActorRotate)] = ScriptLoader::LoadActorRotate; x90c_loaderFuncs[int(EScriptObjectType::ActorRotate)] = ScriptLoader::LoadActorRotate;
x90c_loaderFuncs[int(EScriptObjectType::SpecialFunction)] = ScriptLoader::LoadSpecialFunction; x90c_loaderFuncs[int(EScriptObjectType::SpecialFunction)] = ScriptLoader::LoadSpecialFunction;
@ -1123,7 +1123,7 @@ void CStateManager::SendScriptMsg(TUniqueId src, TEditorId dest, EScriptObjectMe
{ {
CEntity* ent = ObjectById(src); CEntity* ent = ObjectById(src);
auto search = GetIdListForScript(dest); auto search = GetIdListForScript(dest);
if (ent && search.first != x890_scriptIdMap.cend()) if (search.first != x890_scriptIdMap.cend())
{ {
for (auto it = search.first; it != search.second; ++it) for (auto it = search.first; it != search.second; ++it)
{ {
@ -1278,14 +1278,14 @@ std::pair<TEditorId, TUniqueId> CStateManager::LoadScriptObject(TAreaId aid, ESc
u32 readAmt = in.position() - startPos; u32 readAmt = in.position() - startPos;
if (readAmt > length) if (readAmt > length)
LogModule.report(logvisor::Fatal, "Script object overread"); LogModule.report(logvisor::Fatal, "Script object overread while reading %s", ScriptObjectTypeToStr(type).data());
u32 leftover = length - readAmt; u32 leftover = length - readAmt;
for (u32 i=0 ; i<leftover ; ++i) for (u32 i=0 ; i<leftover ; ++i)
in.readByte(); in.readByte();
if (error || ent == nullptr) if (error || ent == nullptr)
{ {
LogModule.report(logvisor::Fatal, "Script load error"); LogModule.report(logvisor::Error, "Script load error while loading %s", ScriptObjectTypeToStr(type).data());
return {kInvalidEditorId, kInvalidUniqueId}; return {kInvalidEditorId, kInvalidUniqueId};
} }
else else

2
Runtime/Graphics/CGraphics.hpp
View File

@ -10,9 +10,11 @@
#include "zeus/CColor.hpp" #include "zeus/CColor.hpp"
#include "hecl/Runtime.hpp" #include "hecl/Runtime.hpp"
#include "hecl/CVar.hpp"
namespace urde namespace urde
{ {
extern hecl::CVar* g_disableLighting;
class CLight; class CLight;
class CTimeProvider; class CTimeProvider;

6
Runtime/Graphics/CModel.hpp
View File

@ -108,7 +108,11 @@ struct SShader
MaterialSet m_matSet; MaterialSet m_matSet;
std::experimental::optional<GeometryUniformLayout> m_geomLayout; std::experimental::optional<GeometryUniformLayout> m_geomLayout;
int m_matSetIdx; int m_matSetIdx;
SShader(int idx) : m_matSetIdx(idx) {} SShader(int idx) : m_matSetIdx(idx)
{
x0_textures.clear();
m_shaders.clear();
}
void InitializeLayout(const CModel* model) { m_geomLayout.emplace(model, &m_matSet); } void InitializeLayout(const CModel* model) { m_geomLayout.emplace(model, &m_matSet); }
void UnlockTextures(); void UnlockTextures();
std::shared_ptr<hecl::Runtime::ShaderPipelines> std::shared_ptr<hecl::Runtime::ShaderPipelines>

8
Runtime/Graphics/Shaders/CFluidPlaneShaderGLSL.cpp
View File

@ -217,14 +217,14 @@ BOO_GLSL_BINDING_HEAD
" {\n" " {\n"
" vec3 delta = mvPosIn - lights[i].pos.xyz;\n" " vec3 delta = mvPosIn - lights[i].pos.xyz;\n"
" float dist = length(delta);\n" " float dist = length(delta);\n"
" float angDot = clamp(dot(normalize(delta), lights[i].dir.xyz), 0.0, 1.0);\n" " float angDot = clamp(dot(normalize(delta).xyz, lights[i].dir.xyz), 0.0, 1.0);\n"
" float att = 1.0 / (lights[i].linAtt[2] * dist * dist +\n" " float att = 1.0 / (lights[i].linAtt[2] * dist * dist +\n"
" lights[i].linAtt[1] * dist +\n" " lights[i].linAtt[1] * dist +\n"
" lights[i].linAtt[0]);\n" " lights[i].linAtt[0]);\n"
" float angAtt = lights[i].angAtt[2] * angDot * angDot +\n" " float angAtt = lights[i].angAtt[2] * angDot * angDot +\n"
" lights[i].angAtt[1] * angDot +\n" " lights[i].angAtt[1] * angDot +\n"
" lights[i].angAtt[0];\n" " lights[i].angAtt[0];\n"
" ret += lights[i].color * clamp(angAtt, 0.0, 1.0) * att * clamp(dot(normalize(-delta), mvNormIn), 0.0, 1.0);\n" " ret += lights[i].color * clamp(angAtt, 0.0, 1.0) * att * clamp(dot(normalize(-delta).xyz, mvNormIn), 0.0, 1.0);\n"
" }\n" " }\n"
" \n" " \n"
" return ret;\n" " return ret;\n"
@ -554,8 +554,8 @@ static void _BuildFragShader(std::string& finalFS, int& nextTex, const char* tex
// Output reg 0, subtract, clamp, no bias // Output reg 0, subtract, clamp, no bias
combiner += " vec3 lightVec = lights[3].pos.xyz - vtf.mvPos.xyz;\n" combiner += " vec3 lightVec = lights[3].pos.xyz - vtf.mvPos.xyz;\n"
" float lx = dot(vtf.mvTangent, lightVec);\n" " float lx = dot(vtf.mvTangent.xyz, lightVec);\n"
" float ly = dot(vtf.mvBinorm, lightVec);\n"; " float ly = dot(vtf.mvBinorm.xyz, lightVec);\n";
combiner += hecl::Format(" vec4 emboss1 = texture(bumpMap, vtf.uvs[%d]) + vec4(0.5);\n" combiner += hecl::Format(" vec4 emboss1 = texture(bumpMap, vtf.uvs[%d]) + vec4(0.5);\n"
" vec4 emboss2 = texture(bumpMap, vtf.uvs[%d] + vec2(lx, ly));\n", " vec4 emboss2 = texture(bumpMap, vtf.uvs[%d] + vec2(lx, ly));\n",
bumpMapUv, bumpMapUv); bumpMapUv, bumpMapUv);

3
Runtime/MP1/CMainFlow.cpp
View File

@ -100,9 +100,10 @@ void CMainFlow::SetGameState(EClientFlowStates state, CArchitectureQueue& queue)
case EClientFlowStates::Game: case EClientFlowStates::Game:
{ {
g_GameState->GameOptions().EnsureSettings(); g_GameState->GameOptions().EnsureSettings();
std::shared_ptr<CMFGameLoader> gameLoader = std::make_shared<CMFGameLoader>();
main->SetFlowState(EFlowState::Default); main->SetFlowState(EFlowState::Default);
queue.Push(MakeMsg::CreateCreateIOWin(EArchMsgTarget::IOWinManager, 10, 1000, queue.Push(MakeMsg::CreateCreateIOWin(EArchMsgTarget::IOWinManager, 10, 1000,
std::make_shared<CMFGameLoader>())); gameLoader));
break; break;
} }
default: break; default: break;

2
Runtime/MP1/CSamusHud.cpp
View File

@ -1597,7 +1597,7 @@ void CSamusHud::Draw(const CStateManager& mgr, float alpha,
if (x29c_decoIntf && !x2cc_preLoadCountdown) if (x29c_decoIntf && !x2cc_preLoadCountdown)
x29c_decoIntf->Draw(); x29c_decoIntf->Draw();
if (x2bc_nextState >= EHudState::Combat && x2bc_nextState < EHudState::Scan) if (x2bc_nextState >= EHudState::Combat && x2bc_nextState <= EHudState::Scan)
{ {
if (hudVis && if (hudVis &&
helmetVis != CInGameGuiManager::EHelmetVisMode::ReducedUpdate && helmetVis != CInGameGuiManager::EHelmetVisMode::ReducedUpdate &&

5
Runtime/MP1/MP1.cpp
View File

@ -488,6 +488,8 @@ void CMain::Give(hecl::Console* console, const std::vector<std::string>& args)
{ {
pState->IncrPickup(eType, 9999); pState->IncrPickup(eType, 9999);
console->report(hecl::Console::Level::Info, "Cheater....., Greatly increasing Metroid encounters, have fun!"); console->report(hecl::Console::Level::Info, "Cheater....., Greatly increasing Metroid encounters, have fun!");
if (g_StateManager)
g_StateManager->Player()->AsyncLoadSuit(*g_StateManager);
return; return;
} }
@ -517,7 +519,8 @@ void CMain::Give(hecl::Console* console, const std::vector<std::string>& args)
else else
pState->DecrPickup(eType, zeus::clamp(0u, u32(abs(itemAmt)), pState->GetItemAmount(eType))); pState->DecrPickup(eType, zeus::clamp(0u, u32(abs(itemAmt)), pState->GetItemAmount(eType)));
} }
g_StateManager->Player()->AsyncLoadSuit(*g_StateManager); if (g_StateManager)
g_StateManager->Player()->AsyncLoadSuit(*g_StateManager);
console->report(hecl::Console::Level::Info, "Cheater....., Greatly increasing Metroid encounters, have fun!"); console->report(hecl::Console::Level::Info, "Cheater....., Greatly increasing Metroid encounters, have fun!");
} }

14
Runtime/MP1/World/CAtomicAlpha.cpp Normal file
View File

@ -0,0 +1,14 @@
#include "CAtomicAlpha.hpp"
namespace urde::MP1
{
CAtomicAlpha::CAtomicAlpha(TUniqueId uid, std::string_view name, const CEntityInfo& info, const zeus::CTransform& xf,
CModelData&& mData, const CActorParameters& actParms, const CPatternedInfo& pInfo,
CAssetId wpsc, const CDamageInfo& dInfo, float f1, float f2, float f3, CAssetId cmdl,
bool b1, bool b2)
: CPatterned(ECharacter::AtomicAlpha, uid, name, EFlavorType::Zero, info, xf, std::move(mData), pInfo,
EMovementType::Flyer, EColliderType::One, EBodyType::Flyer, actParms, 1)
{
}
}

16
Runtime/MP1/World/CAtomicAlpha.hpp Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include "World/CPatterned.hpp"
namespace urde::MP1
{
class CAtomicAlpha : public CPatterned
{
public:
DEFINE_PATTERNED(AtomicAlpha)
CAtomicAlpha(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&,
const CActorParameters&, const CPatternedInfo&, CAssetId, const CDamageInfo&, float, float, float,
CAssetId, bool, bool);
};
}

42
Runtime/MP1/World/CBabygoth.cpp
View File

@ -0,0 +1,42 @@
#include "CBabygoth.hpp"
namespace urde::MP1
{
CBabygothData::CBabygothData(CInputStream& in)
: x0_(in.readFloatBig())
, x4_(in.readFloatBig())
, x8_(in)
, xc_(in)
, x28_(in)
, x44_(in)
, x48_(in)
, x4c_(in)
, x68_(in)
, xd0_(in)
, x138_(in)
, x13c_(in)
, x140_(in.readFloatBig())
, x144_(CSfxManager::TranslateSFXID(in.readUint32Big()))
, x148_(in)
, x14c_(in)
, x150_(in)
, x154_(in)
, x158_(CSfxManager::TranslateSFXID(in.readUint32Big()))
, x15c_(CSfxManager::TranslateSFXID(in.readUint32Big()))
, x160_(in.readFloatBig())
, x164_(in.readFloatBig())
, x168_(in.readFloatBig())
, x16c_(in)
, x170_(CSfxManager::TranslateSFXID(in.readUint32Big()))
, x174_(in)
{
}
CBabygoth::CBabygoth(TUniqueId uid, std::string_view name, const CEntityInfo& info, const zeus::CTransform& xf,
CModelData&& mData, const CPatternedInfo& pInfo, const CActorParameters& actParms, const CBabygothData& babyData)
: CPatterned(ECharacter::Babygoth, uid, name, EFlavorType::Zero, info, xf, std::move(mData), pInfo, EMovementType::Ground,
EColliderType::One, EBodyType::BiPedal, actParms, 1)
{
}
}

32
Runtime/MP1/World/CBabygoth.hpp
View File

@ -3,37 +3,37 @@
#include "World/CPatterned.hpp" #include "World/CPatterned.hpp"
namespace urde namespace urde::MP1
{ {
class CBabygothData class CBabygothData
{ {
float x0_; float x0_;
float x4_; float x4_;
u32 x8_; CAssetId x8_;
CDamageInfo xc_; CDamageInfo xc_;
CDamageInfo x28_; CDamageInfo x28_;
u32 x44_; CAssetId x44_;
u32 x48_; CAssetId x48_;
CDamageInfo x4c_; CDamageInfo x4c_;
CDamageVulnerability x68_; CDamageVulnerability x68_;
CDamageVulnerability xd0_; CDamageVulnerability xd0_;
u32 x138_; CAssetId x138_;
u32 x13c_; CAssetId x13c_;
float x140_; float x140_;
s16 x144_; s16 x144_;
u32 x148_; CAssetId x148_;
u32 x14c_; CAssetId x14c_;
u32 x150_; CAssetId x150_;
u32 x154_; CAssetId x154_;
s16 x158_; s16 x158_;
s16 x15a_; s16 x15a_;
s16 x15c_; s16 x15c_;
float x160_; float x160_;
float x164_; float x164_;
float x168_; float x168_;
u32 x16c_; CAssetId x16c_;
s16 x170_; s16 x170_;
u32 x174_; CAssetId x174_;
public: public:
CBabygothData(CInputStream&); CBabygothData(CInputStream&);
CAssetId GetShellModelResId() const; CAssetId GetShellModelResId() const;
@ -47,5 +47,13 @@ public:
CAssetId GetFireBreathResId() const; CAssetId GetFireBreathResId() const;
}; };
class CBabygoth : public CPatterned
{
public:
DEFINE_PATTERNED(Babygoth)
CBabygoth(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&,
const CPatternedInfo&, const CActorParameters&, const CBabygothData&);
};
} }
#endif // __URDE_MP1_CBABYGOTH_HPP__ #endif // __URDE_MP1_CBABYGOTH_HPP__

12
Runtime/MP1/World/CBloodFlower.cpp Normal file
View File

@ -0,0 +1,12 @@
#include "CBloodFlower.hpp"
namespace urde::MP1
{
CBloodFlower::CBloodFlower(TUniqueId uid, std::string_view name, const CEntityInfo& info, const zeus::CTransform& xf,
CModelData&& mData, const CPatternedInfo& pInfo, CAssetId partId1, CAssetId wpscId1,
const CActorParameters& actParms, CAssetId wpscId2, const CDamageInfo& dInfo1,
const CDamageInfo& dInfo2, const CDamageInfo& dInfo3, CAssetId partId2, CAssetId partId3,
CAssetId partId4, float f1, CAssetId partId5, u32 soundId)
: CPatterned(ECharacter::BloodFlower, uid, name, EFlavorType::Zero, info, xf, std::move(mData), pInfo,
EMovementType::Ground, EColliderType::One, EBodyType::Restricted, actParms, 1) {}
}

16
Runtime/MP1/World/CBloodFlower.hpp Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include "World/CPatterned.hpp"
namespace urde::MP1
{
class CBloodFlower : public CPatterned
{
public:
DEFINE_PATTERNED(BloodFlower)
CBloodFlower(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&,
const CPatternedInfo&, CAssetId, CAssetId, const CActorParameters&, CAssetId, const CDamageInfo&,
const CDamageInfo&, const CDamageInfo&, CAssetId, CAssetId, CAssetId, float, CAssetId, u32);
};
}

14
Runtime/MP1/World/CBurrower.cpp Normal file
View File

@ -0,0 +1,14 @@
#include "CBurrower.hpp"
namespace urde::MP1
{
CBurrower::CBurrower(TUniqueId uid, std::string_view name, const CEntityInfo& info, const zeus::CTransform& xf,
CModelData&& mData, const CPatternedInfo& pInfo, const CActorParameters& actParms,
CAssetId, CAssetId, CAssetId, const CDamageInfo&, CAssetId, u32, CAssetId)
: CPatterned(ECharacter::Burrower, uid, name, EFlavorType::Zero, info, xf, std::move(mData), pInfo,
EMovementType::Ground, EColliderType::One, EBodyType::BiPedal, actParms, 0)
{
}
}

17
Runtime/MP1/World/CBurrower.hpp Normal file
View File

@ -0,0 +1,17 @@
#pragma once
#include "World/CPatterned.hpp"
namespace urde::MP1
{
class CBurrower : public CPatterned
{
public:
DEFINE_PATTERNED(Burrower)
CBurrower(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&,
const CPatternedInfo&, const CActorParameters&, CAssetId, CAssetId, CAssetId, const CDamageInfo&, CAssetId, u32,
CAssetId);
};
}

26
Runtime/MP1/World/CElitePirate.cpp Normal file
View File

@ -0,0 +1,26 @@
#include "CElitePirate.hpp"
#include "World/ScriptLoader.hpp"
namespace urde::MP1
{
CElitePirateData::CElitePirateData(CInputStream& in, u32 propCount)
: x0_(in.readFloatBig()), x4_(in.readFloatBig()), x8_(in.readFloatBig()), xc_(in.readFloatBig()),
x10_(in.readFloatBig()), x14_(in.readFloatBig()), x18_(in.readFloatBig()), x1c_(in.readFloatBig()), x20_(in),
x24_(CSfxManager::TranslateSFXID(in.readUint32Big())), x28_(ScriptLoader::LoadActorParameters(in)),
x90_(ScriptLoader::LoadAnimationParameters(in)), x9c_(in), xa0_(CSfxManager::TranslateSFXID(in.readUint32Big())),
xa4_(in), xa8_(in), xc4_(in.readFloatBig()), xc8_(in), xcc_(in), xd0_(in), xd4_(in), xd8_(in.readFloatBig()),
xdc_(in.readFloatBig()), xe0_(in.readFloatBig()), xe4_(in.readFloatBig()),
xe8_(zeus::degToRad(in.readFloatBig())), xec_(zeus::degToRad(in.readFloatBig())), xf0_(in.readUint32Big()),
xf4_(CSfxManager::TranslateSFXID(in.readUint32Big())), xf8_(in), xfc_(in), x118_(in),
x11c_(CSfxManager::TranslateSFXID(in.readUint32Big())), x11e_(in.readBool()),
x11f_(propCount < 24 ? true : in.readBool()) {}
CElitePirate::CElitePirate(TUniqueId uid, std::string_view name, const CEntityInfo& info, const zeus::CTransform& xf,
CModelData&& mData, const CPatternedInfo& pInfo, const CActorParameters& actParms,
const CElitePirateData& eliteData)
: CPatterned(ECharacter::ElitePirate, uid, name, EFlavorType::Zero, info, xf, std::move(mData), pInfo,
EMovementType::Ground, EColliderType::One, EBodyType::BiPedal, actParms, 2)
{
}
}

58
Runtime/MP1/World/CElitePirate.hpp Normal file
View File

@ -0,0 +1,58 @@
#pragma once
#include "World/CPatterned.hpp"
#include "World/CActorParameters.hpp"
#include "World/CAnimationParameters.hpp"
namespace urde::MP1
{
class CElitePirateData
{
float x0_;
float x4_;
float x8_;
float xc_;
float x10_;
float x14_;
float x18_;
float x1c_;
CAssetId x20_;
s16 x24_;
CActorParameters x28_;
CAnimationParameters x90_;
CAssetId x9c_;
s16 xa0_;
CAssetId xa4_;
CDamageInfo xa8_;
float xc4_;
CAssetId xc8_;
CAssetId xcc_;
CAssetId xd0_;
CAssetId xd4_;
float xd8_;
float xdc_;
float xe0_;
float xe4_;
float xe8_;
float xec_;
u32 xf0_;
u32 xf4_;
CAssetId xf8_;
CDamageInfo xfc_;
CAssetId x118_;
s16 x11c_;
bool x11e_;
bool x11f_;
public:
CElitePirateData(CInputStream&, u32 propCount);
};
class CElitePirate : public CPatterned
{
public:
DEFINE_PATTERNED(ElitePirate)
CElitePirate(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&,
const CPatternedInfo&, const CActorParameters&, const CElitePirateData&);
};
}

14
Runtime/MP1/World/CEyeball.cpp Normal file
View File

@ -0,0 +1,14 @@
#include "CEyeball.hpp"
namespace urde::MP1
{
CEyeball::CEyeball(TUniqueId uid, std::string_view name, CPatterned::EFlavorType flavor, const CEntityInfo& info,
const zeus::CTransform& xf, CModelData&& mData, const CPatternedInfo& pInfo, float, float,
CAssetId, const CDamageInfo&, CAssetId, CAssetId, CAssetId, CAssetId, u32, u32, u32, u32, u32,
const CActorParameters& actParms, bool)
: CPatterned(ECharacter::EyeBall, uid, name, flavor, info, xf, std::move(mData), pInfo, EMovementType::Flyer,
EColliderType::Zero, EBodyType::Restricted, actParms, 1)
{
}
}

17
Runtime/MP1/World/CEyeball.hpp Normal file
View File

@ -0,0 +1,17 @@
#pragma once
#include "World/CPatterned.hpp"
namespace urde::MP1
{
class CEyeball : public CPatterned
{
public:
DEFINE_PATTERNED(EyeBall)
CEyeball(TUniqueId, std::string_view, EFlavorType, const CEntityInfo&, const zeus::CTransform&,
CModelData&&, const CPatternedInfo&, float, float, CAssetId, const CDamageInfo&, CAssetId, CAssetId,
CAssetId, CAssetId, u32, u32, u32, u32, u32, const CActorParameters&, bool);
};
}

13
Runtime/MP1/World/CFireFlea.cpp Normal file
View File

@ -0,0 +1,13 @@
#include "CFireFlea.hpp"
namespace urde::MP1
{
CFireFlea::CFireFlea(TUniqueId uid, std::string_view name, const CEntityInfo& info, const zeus::CTransform& xf,
CModelData&& mData, const CActorParameters& actParms, const CPatternedInfo& pInfo, float)
: CPatterned(ECharacter::FireFlea, uid, name, EFlavorType::Zero, info, xf, std::move(mData), pInfo,
EMovementType::Flyer, EColliderType::One, EBodyType::NewFlyer, actParms, 0)
{
}
}

15
Runtime/MP1/World/CFireFlea.hpp Normal file
View File

@ -0,0 +1,15 @@
#pragma once
#include "World/CPatterned.hpp"
namespace urde::MP1
{
class CFireFlea : public CPatterned
{
public:
DEFINE_PATTERNED(FireFlea)
CFireFlea(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&,
const CActorParameters&, const CPatternedInfo&, float);
};
}

14
Runtime/MP1/World/CFlickerBat.cpp Normal file
View File

@ -0,0 +1,14 @@
#include "CFlickerBat.hpp"
namespace urde::MP1
{
CFlickerBat::CFlickerBat(TUniqueId uid, std::string_view name, CPatterned::EFlavorType flavor, const CEntityInfo& info,
const zeus::CTransform& xf, CModelData&& mData, const CPatternedInfo& pInfo,
EColliderType colType, bool b1, const CActorParameters& actParms, bool b2)
: CPatterned(ECharacter::FlickerBat, uid, name, flavor, info, xf, std::move(mData), pInfo, EMovementType::Flyer, colType,
EBodyType::Pitchable, actParms, 0)
{
}
}

14
Runtime/MP1/World/CFlickerBat.hpp Normal file
View File

@ -0,0 +1,14 @@
#pragma once
#include "World/CPatterned.hpp"
namespace urde::MP1
{
class CFlickerBat : public CPatterned
{
public:
DEFINE_PATTERNED(FlickerBat)
CFlickerBat(TUniqueId, std::string_view name, EFlavorType, const CEntityInfo&, const zeus::CTransform&, CModelData&&,
const CPatternedInfo&, EColliderType, bool, const CActorParameters&, bool);
};
}

28
Runtime/MP1/World/CMagdolite.cpp Normal file
View File

@ -0,0 +1,28 @@
#include "CMagdolite.hpp"
namespace urde::MP1
{
CMagdolite::CMagdoliteData::CMagdoliteData(CInputStream& in)
: x0_propertyCount(in.readUint32Big())
, x4_(in.readUint32Big())
, x8_(in)
, xc_(in.readUint32Big())
, x10_(in.readFloatBig())
, x18_(in.readFloatBig())
, x1c_(in.readFloatBig())
{
}
CMagdolite::CMagdolite(TUniqueId uid, std::string_view name, const CEntityInfo& info, const zeus::CTransform& xf,
CModelData&& mData, const CPatternedInfo& pInfo, const CActorParameters& actParms, float f1, float f2,
const CDamageInfo& dInfo1, const CDamageInfo& dInfo2, const CDamageVulnerability& dVuln1,
const CDamageVulnerability& dVuln2, CAssetId modelId, CAssetId skinId, float f3, float f4,
float f5, float f6, const urde::MP1::CMagdolite::CMagdoliteData& magData, float f7, float f8, float f9)
: CPatterned(ECharacter::Magdolite, uid, name, EFlavorType::Zero, info, xf, std::move(mData), pInfo,
EMovementType::Flyer, EColliderType::One, EBodyType::BiPedal, actParms, 2)
{
}
}

32
Runtime/MP1/World/CMagdolite.hpp Normal file
View File

@ -0,0 +1,32 @@
#pragma once
#include "World/CPatterned.hpp"
namespace urde::MP1
{
class CMagdolite : public CPatterned
{
public:
class CMagdoliteData
{
u32 x0_propertyCount;
u32 x4_;
CAssetId x8_;
u32 xc_;
float x10_;
float x18_;
float x1c_;
public:
CMagdoliteData(CInputStream&);
};
private:
public:
DEFINE_PATTERNED(Magdolite)
CMagdolite(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&,
const CPatternedInfo&, const CActorParameters&, float, float, const CDamageInfo&, const CDamageInfo&,
const CDamageVulnerability&, const CDamageVulnerability&, CAssetId, CAssetId, float, float, float, float,
const CMagdoliteData&, float, float, float);
};
}

10
Runtime/MP1/World/CMakeLists.txt
View File

@ -2,9 +2,16 @@ set(MP1_WORLD_SOURCES
CNewIntroBoss.hpp CNewIntroBoss.cpp CNewIntroBoss.hpp CNewIntroBoss.cpp
CBeetle.hpp CBeetle.cpp CBeetle.hpp CBeetle.cpp
CWarWasp.hpp CWarWasp.cpp CWarWasp.hpp CWarWasp.cpp
CElitePirate.hpp CElitePirate.cpp
CBloodFlower.hpp CBloodFlower.cpp
CSpacePirate.hpp CSpacePirate.cpp CSpacePirate.hpp CSpacePirate.cpp
CParasite.hpp CParasite.cpp CParasite.hpp CParasite.cpp
CBabygoth.hpp CBabygoth.cpp CBabygoth.hpp CBabygoth.cpp
CTryclops.hpp CTryclops.cpp
CFireFlea.hpp CFireFlea.cpp
CEyeball.hpp CEyeball.cpp
CAtomicAlpha.hpp CAtomicAlpha.cpp
CFlickerBat.hpp CFlickerBat.cpp
CMetroidPrimeRelay.hpp CMetroidPrimeRelay.cpp CMetroidPrimeRelay.hpp CMetroidPrimeRelay.cpp
CMetroidPrimeExo.hpp CMetroidPrimeExo.cpp CMetroidPrimeExo.hpp CMetroidPrimeExo.cpp
CMetroidPrimeProjectile.hpp CMetroidPrimeProjectile.cpp CMetroidPrimeProjectile.hpp CMetroidPrimeProjectile.cpp
@ -13,6 +20,9 @@ set(MP1_WORLD_SOURCES
CMetroidBeta.hpp CMetroidBeta.cpp CMetroidBeta.hpp CMetroidBeta.cpp
CMetroid.hpp CMetroid.cpp CMetroid.hpp CMetroid.cpp
CMetaree.hpp CMetaree.cpp CMetaree.hpp CMetaree.cpp
CBurrower.hpp CBurrower.cpp
CPuffer.hpp CPuffer.cpp
CMagdolite.hpp CMagdolite.cpp
CSeedling.hpp CSeedling.cpp CSeedling.hpp CSeedling.cpp
CRidley.hpp CRidley.cpp CRidley.hpp CRidley.cpp
CPuddleToadGamma.hpp CPuddleToadGamma.cpp CPuddleToadGamma.hpp CPuddleToadGamma.cpp

4
Runtime/MP1/World/CMetaree.cpp
View File

@ -1,7 +1,3 @@
//
// Created by antidote on 8/19/17.
//
#include "CMetaree.hpp" #include "CMetaree.hpp"
namespace urde::MP1 namespace urde::MP1

15
Runtime/MP1/World/CPuffer.cpp Normal file
View File

@ -0,0 +1,15 @@
#include "CPuffer.hpp"
namespace urde::MP1
{
CPuffer::CPuffer(TUniqueId uid, std::string_view name, const CEntityInfo& info, const zeus::CTransform& xf,
CModelData&& modelData, const CActorParameters& actorParameters, const CPatternedInfo& patternedInfo,
float hoverSpeed, CAssetId cloudEffect, const CDamageInfo& cloudDamage, CAssetId cloudSteam, float f2,
bool b1, bool b2, bool b3, const CDamageInfo& explosionDamage, s16 sfxId)
: CPatterned(ECharacter::Puffer, uid, name, EFlavorType::Zero, info, xf, std::move(modelData), patternedInfo,
EMovementType::Flyer, EColliderType::One, EBodyType::RestrictedFlyer, actorParameters, 0)
{
}
}

16
Runtime/MP1/World/CPuffer.hpp Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include "World/CPatterned.hpp"
namespace urde::MP1
{
class CPuffer : public CPatterned
{
public:
DEFINE_PATTERNED(Puffer)
CPuffer(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&,
const CActorParameters&, const CPatternedInfo&, float, CAssetId, const CDamageInfo&, CAssetId,
float, bool, bool, bool, const CDamageInfo&, s16);
};
}

25
Runtime/MP1/World/CRidley.cpp
View File

@ -7,24 +7,23 @@ namespace MP1
{ {
CRidleyData::CRidleyData(CInputStream& in, u32 propCount) CRidleyData::CRidleyData(CInputStream& in, u32 propCount)
: x0_(in), x4_(in), x8_(in), xc_(in), x10_(in), x14_(in), x18_(in), x1c_(in), x20_(in), x24_(in), x28_(in) : x0_(in), x4_(in), x8_(in), xc_(in), x10_(in), x14_(in), x18_(in), x1c_(in), x20_(in), x24_(in), x28_(in),
, x2c_(in), x30_(in), x34_(in.readFloatBig()), x38_(in.readFloatBig()), x3c_(in.readFloatBig()), x40_(in.readFloatBig()) x2c_(in), x30_(in), x34_(in.readFloatBig()), x38_(in.readFloatBig()), x3c_(in.readFloatBig()),
, x44_(in), x48_(in), x64_(in), xa8_(CSfxManager::TranslateSFXID(in.readUint32Big())), xac_(in), xb0_(in) x40_(in.readFloatBig()), x44_(in), x48_(in), x64_(in), xa8_(CSfxManager::TranslateSFXID(in.readUint32Big())),
, xcc_(in), x1a0_(in), x1a4_(in), x1c0_(in), x294_(CSfxManager::TranslateSFXID(in.readUint32Big())) xac_(in), xb0_(in), xcc_(in), x1a0_(in), x1a4_(in), x1c0_(in),
, x298_(in), x2b4_(in), x388_(in.readFloatBig()), x38c_(in.readFloatBig()), x390_(in), x3ac_(in.readFloatBig()) x294_(CSfxManager::TranslateSFXID(in.readUint32Big())), x298_(in), x2b4_(in), x388_(in.readFloatBig()),
, x3b0_(in), x3cc_(in.readFloatBig()), x3d0_(in), x3f4_(in.readFloatBig()), x3f8_(CSfxManager::TranslateSFXID(in.readUint32Big())) x38c_(in.readFloatBig()), x390_(in), x3ac_(in.readFloatBig()), x3b0_(in), x3cc_(in.readFloatBig()), x3d0_(in),
, x3fc_(propCount > 47 ? CDamageInfo(in) : x48_) x3f4_(in.readFloatBig()), x3f8_(CSfxManager::TranslateSFXID(in.readUint32Big())),
x3fc_(propCount > 47 ? CDamageInfo(in) : x48_)
{ {
} }
CRidley::CRidley(TUniqueId uid, std::string_view name, const CEntityInfo& info, CRidley::CRidley(TUniqueId uid, std::string_view name, const CEntityInfo& info,
const zeus::CTransform& xf, CModelData&& mData, const CPatternedInfo& pInfo, const CActorParameters& actParms, CInputStream& in, u32 propCount) const zeus::CTransform& xf, CModelData&& mData, const CPatternedInfo& pInfo,
: CPatterned(ECharacter::Ridley, uid, name, EFlavorType::Zero, info, xf, std::move(mData), pInfo, const CActorParameters& actParms, CInputStream& in, u32 propCount)
EMovementType::Flyer, EColliderType::Zero, EBodyType::Flyer, actParms, 2) : CPatterned(ECharacter::Ridley, uid, name, EFlavorType::Zero, info, xf, std::move(mData), pInfo,
, x568_(in, propCount) EMovementType::Flyer, EColliderType::Zero, EBodyType::Flyer, actParms, 2), x568_(in, propCount)
{ {
} }
void CRidley::Accept(IVisitor &visitor) { visitor.Visit(this); }
} }
} }

2
Runtime/MP1/World/CRidley.hpp
View File

@ -65,8 +65,6 @@ public:
DEFINE_PATTERNED(Ridley) DEFINE_PATTERNED(Ridley)
CRidley(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&, CRidley(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&,
const CPatternedInfo&, const CActorParameters&, CInputStream&, u32); const CPatternedInfo&, const CActorParameters&, CInputStream&, u32);
void Accept(IVisitor&);
}; };
} }
} }

10
Runtime/MP1/World/CTryclops.cpp Normal file
View File

@ -0,0 +1,10 @@
#include "CTryclops.hpp"
namespace urde::MP1
{
CTryclops::CTryclops(urde::TUniqueId uid, std::string_view name, const CEntityInfo& info, const zeus::CTransform& xf,
urde::CModelData&& mData, const urde::CPatternedInfo& pInfo, const urde::CActorParameters& actParms, float, float, float, float)
: CPatterned(ECharacter::Tryclops, uid, name, EFlavorType::Zero, info, xf, std::move(mData), pInfo,
EMovementType::Ground, EColliderType::One, EBodyType::BiPedal, actParms, 0)
{}
}

14
Runtime/MP1/World/CTryclops.hpp Normal file
View File

@ -0,0 +1,14 @@
#pragma once
#include "World/CPatterned.hpp"
namespace urde::MP1
{
class CTryclops : public CPatterned
{
public:
DEFINE_PATTERNED(Tryclops)
CTryclops(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&,
const CPatternedInfo&, const CActorParameters&, float, float, float, float);
};
}

2
Runtime/Particle/CElementGen.cpp
View File

@ -275,7 +275,7 @@ bool CElementGen::Update(double t)
Log.report(logvisor::Info, Log.report(logvisor::Info,
"Running warmup on particle system 0x%08x for %d ticks.", "Running warmup on particle system 0x%08x for %d ticks.",
desc, pswt); desc, pswt);
InternalUpdate(pswt / 60.0); InternalUpdate((1.f / 60.f) * pswt);
x26d_25_warmedUp = true; x26d_25_warmedUp = true;
} }
bool ret = InternalUpdate(t); bool ret = InternalUpdate(t);

2
Runtime/Weapon/CGrappleArm.cpp
View File

@ -251,7 +251,7 @@ void CGrappleArm::LoadSuitPoll()
{ {
if (NWeaponTypes::are_tokens_ready(x19c_suitDeps[int(x3a8_loadedSuit)])) if (NWeaponTypes::are_tokens_ready(x19c_suitDeps[int(x3a8_loadedSuit)]))
{ {
x0_grappleArmModel.emplace(CAnimRes(g_tweakGunRes->x8_grappleArm, 0, x31c_scale, 41, false)); x0_grappleArmModel.emplace(CAnimRes(g_tweakGunRes->x8_grappleArm, int(x3a8_loadedSuit), x31c_scale, 41, false));
x0_grappleArmModel->SetSortThermal(true); x0_grappleArmModel->SetSortThermal(true);
x328_gunController = std::make_unique<CGunController>(*x0_grappleArmModel); x328_gunController = std::make_unique<CGunController>(*x0_grappleArmModel);
x3b2_29_suitLoading = false; x3b2_29_suitLoading = false;

4
Runtime/World/CDamageVulnerability.cpp
View File

@ -188,9 +188,7 @@ bool CDamageVulnerability::WeaponHurts(const CWeaponMode& mode, bool ignoreDirec
return true; return true;
if (chargedHurts && mode.IsCharged()) if (chargedHurts && mode.IsCharged())
return true; return true;
if (comboedHurts && mode.IsComboed()) return comboedHurts && mode.IsComboed();
return true;
return false;
} }
bool CDamageVulnerability::WeaponHits(const CWeaponMode& mode, bool checkDirect) const bool CDamageVulnerability::WeaponHits(const CWeaponMode& mode, bool checkDirect) const

1
Runtime/World/CMakeLists.txt
View File

@ -73,6 +73,7 @@ set(WORLD_SOURCES
CScriptPlayerHint.hpp CScriptPlayerHint.cpp CScriptPlayerHint.hpp CScriptPlayerHint.cpp
CScriptPlayerStateChange.hpp CScriptPlayerStateChange.cpp CScriptPlayerStateChange.hpp CScriptPlayerStateChange.cpp
CScriptTargetingPoint.hpp CScriptTargetingPoint.cpp CScriptTargetingPoint.hpp CScriptTargetingPoint.cpp
CScriptEMPulse.hpp CScriptEMPulse.cpp
CScriptPlayerActor.hpp CScriptPlayerActor.cpp CScriptPlayerActor.hpp CScriptPlayerActor.cpp
CFishCloud.hpp CFishCloud.cpp CFishCloud.hpp CFishCloud.cpp
CFishCloudModifier.hpp CFishCloudModifier.cpp CFishCloudModifier.hpp CFishCloudModifier.cpp

4
Runtime/World/CPatternedInfo.cpp
View File

@ -52,8 +52,6 @@ CPatternedInfo::CPatternedInfo(CInputStream& in, u32 pcount)
std::pair<bool, u32> CPatternedInfo::HasCorrectParameterCount(CInputStream& in) std::pair<bool, u32> CPatternedInfo::HasCorrectParameterCount(CInputStream& in)
{ {
u32 pcount = in.readUint32Big(); u32 pcount = in.readUint32Big();
if (pcount < 35 || pcount > 38) return {(pcount >= 35 && pcount <= 38), pcount};
return {false, pcount};
return {true, pcount};
} }
} }

6
Runtime/World/CPlayer.cpp
View File

@ -5817,7 +5817,7 @@ float CPlayer::JumpInput(const CFinalInput& input, CStateManager& mgr)
float backwards = ControlMapper::GetAnalogInput(ControlMapper::ECommands::Backward, input); float backwards = ControlMapper::GetAnalogInput(ControlMapper::ECommands::Backward, input);
if (forwards < backwards) if (forwards < backwards)
forwards = ControlMapper::GetAnalogInput(ControlMapper::ECommands::Backward, input); forwards = ControlMapper::GetAnalogInput(ControlMapper::ECommands::Backward, input);
return (vDoubleJumpAccel - (vDoubleJumpAccel - hDoubleJumpAccel) * forwards) * xe8_mass * jumpFactor; return ((vDoubleJumpAccel - (vDoubleJumpAccel - hDoubleJumpAccel) * forwards) * xe8_mass) * jumpFactor;
} }
return GetGravity() * xe8_mass; return GetGravity() * xe8_mass;
@ -5831,7 +5831,7 @@ float CPlayer::JumpInput(const CFinalInput& input, CStateManager& mgr)
if (ControlMapper::GetPressInput(ControlMapper::ECommands::JumpOrBoost, input)) if (ControlMapper::GetPressInput(ControlMapper::ECommands::JumpOrBoost, input))
{ {
SetMoveState(EPlayerMovementState::Jump, mgr); SetMoveState(EPlayerMovementState::Jump, mgr);
return vJumpAccel * xe8_mass * jumpFactor; return (vJumpAccel * xe8_mass) * jumpFactor;
} }
return 0.f; return 0.f;
} }
@ -5839,7 +5839,7 @@ float CPlayer::JumpInput(const CFinalInput& input, CStateManager& mgr)
float backwards = ControlMapper::GetAnalogInput(ControlMapper::ECommands::Backward, input); float backwards = ControlMapper::GetAnalogInput(ControlMapper::ECommands::Backward, input);
if (forwards < backwards) if (forwards < backwards)
forwards = ControlMapper::GetAnalogInput(ControlMapper::ECommands::Backward, input); forwards = ControlMapper::GetAnalogInput(ControlMapper::ECommands::Backward, input);
return (vJumpAccel - (vJumpAccel - hJumpAccel) * forwards) * xe8_mass * jumpFactor; return ((vJumpAccel - (vJumpAccel - hJumpAccel) * forwards) * xe8_mass) * jumpFactor;
} }
if (x258_movementState == EPlayerMovementState::Jump) if (x258_movementState == EPlayerMovementState::Jump)

1
Runtime/World/CPlayer.hpp
View File

@ -660,6 +660,7 @@ public:
CPlayerGun* GetPlayerGun() const { return x490_gun.get(); } CPlayerGun* GetPlayerGun() const { return x490_gun.get(); }
CMorphBall* GetMorphBall() const { return x768_morphball.get(); } CMorphBall* GetMorphBall() const { return x768_morphball.get(); }
CPlayerCameraBob* GetCameraBob() const { return x76c_cameraBob.get(); } CPlayerCameraBob* GetCameraBob() const { return x76c_cameraBob.get(); }
float GetStaticTimer() const { return x740_staticTimer; }
float GetDeathTime() const { return x9f4_deathTime; } float GetDeathTime() const { return x9f4_deathTime; }
const CPlayerEnergyDrain& GetEnergyDrain() const { return x274_energyDrain; } const CPlayerEnergyDrain& GetEnergyDrain() const { return x274_energyDrain; }
EPlayerZoneInfo GetOrbitZone() const { return x330_orbitZoneMode; } EPlayerZoneInfo GetOrbitZone() const { return x330_orbitZoneMode; }

2
Runtime/World/CScriptDistanceFog.cpp
View File

@ -6,7 +6,7 @@
namespace urde namespace urde
{ {
CScriptDistanceFog::CScriptDistanceFog(TUniqueId uid, std::string_view name, const CEntityInfo& info, CScriptDistanceFog::CScriptDistanceFog(TUniqueId uid, std::string_view name, const CEntityInfo& info,
const ERglFogMode& mode, const zeus::CColor& color, ERglFogMode mode, const zeus::CColor& color,
const zeus::CVector2f& range, float colorDelta, const zeus::CVector2f& range, float colorDelta,
const zeus::CVector2f& rangeDelta, bool expl, bool active, const zeus::CVector2f& rangeDelta, bool expl, bool active,
float thermalTarget, float thermalSpeed, float xrayTarget, float xraySpeed) float thermalTarget, float thermalSpeed, float xrayTarget, float xraySpeed)

2
Runtime/World/CScriptDistanceFog.hpp
View File

@ -20,7 +20,7 @@ class CScriptDistanceFog : public CEntity
bool x60_explicit; bool x60_explicit;
bool x61_nonZero; bool x61_nonZero;
public: public:
CScriptDistanceFog(TUniqueId, std::string_view, const CEntityInfo&, const ERglFogMode&, CScriptDistanceFog(TUniqueId, std::string_view, const CEntityInfo&, ERglFogMode,
const zeus::CColor&, const zeus::CVector2f&, float, const zeus::CVector2f&, const zeus::CColor&, const zeus::CVector2f&, float, const zeus::CVector2f&,
bool, bool, float, float, float, float); bool, bool, float, float, float, float);

105
Runtime/World/CScriptEMPulse.cpp Normal file
View File

@ -0,0 +1,105 @@
#include "CScriptEMPulse.hpp"
#include "CActorParameters.hpp"
#include "Particle/CGenDescription.hpp"
#include "Particle/CElementGen.hpp"
#include "GameGlobalObjects.hpp"
#include "CSimplePool.hpp"
#include "CStateManager.hpp"
#include "CPlayer.hpp"
#include "Graphics/CBooRenderer.hpp"
#include "TCastTo.hpp"
namespace urde
{
CScriptEMPulse::CScriptEMPulse(TUniqueId uid, std::string_view name, const CEntityInfo& info,
const zeus::CTransform& xf, bool active, float initialRadius, float finalRadius,
float duration,
float interferenceDur, float f5, float interferenceMag, float f7, CAssetId partId)
: CActor(uid, active, name, info, xf, CModelData::CModelDataNull(), CMaterialList(EMaterialTypes::Projectile),
CActorParameters::None().HotInThermal(true), kInvalidUniqueId), xe8_duration(duration),
xec_finalRadius(finalRadius), xf0_currentRadius(initialRadius), xf4_initialRadius(initialRadius),
xf8_interferenceDur(interferenceDur), xfc_(f5), x100_interferenceMag(interferenceMag), x104_(f7),
x108_particleDesc(g_SimplePool->GetObj({SBIG('PART'), partId}))
{
}
void CScriptEMPulse::Accept(IVisitor& visitor)
{
visitor.Visit(this);
}
void CScriptEMPulse::Think(float dt, CStateManager& mgr)
{
if (!GetActive())
return;
xf0_currentRadius += ((xec_finalRadius - xf4_initialRadius) / xe8_duration) * dt;
if (xf0_currentRadius < xec_finalRadius)
mgr.FreeScriptObject(GetUniqueId());
x114_particleGen->Update(dt);
}
void CScriptEMPulse::AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr)
{
CActor::AcceptScriptMsg(msg, uid, mgr);
if (msg == EScriptObjectMessage::Activate)
{
x114_particleGen.reset(new CElementGen(x108_particleDesc, CElementGen::EModelOrientationType::Normal,
CElementGen::EOptionalSystemFlags::One));
x114_particleGen->SetOrientation(GetTransform().getRotation());
x114_particleGen->SetGlobalTranslation(GetTranslation());
x114_particleGen->SetParticleEmission(true);
mgr.GetPlayerState()->GetStaticInterference().AddSource(GetUniqueId(), x100_interferenceMag,
xf8_interferenceDur);
}
}
void CScriptEMPulse::AddToRenderer(const zeus::CFrustum& frustum, CStateManager& mgr) const
{
CActor::AddToRenderer(frustum, mgr);
if (GetActive())
g_Renderer->AddParticleGen(*x114_particleGen);
}
void CScriptEMPulse::CalculateRenderBounds()
{
x9c_renderBounds = CalculateBoundingBox();
}
std::experimental::optional<zeus::CAABox> CScriptEMPulse::GetTouchBounds() const
{
return {CalculateBoundingBox()};
}
void CScriptEMPulse::Touch(CActor& act, CStateManager& mgr)
{
if (!GetActive())
return;
if (TCastToPtr<CPlayer> pl = act)
{
zeus::CVector3f posDiff = GetTranslation() - pl->GetTranslation();
if (posDiff.magnitude() < xec_finalRadius)
{
float dur =
((1.f - (posDiff.magnitude() / xec_finalRadius)) * (xfc_ - xf8_interferenceDur)) + xf8_interferenceDur;
float mag = ((1.f - (posDiff.magnitude() / xec_finalRadius)) * (x104_ - xf8_interferenceDur)) +
x100_interferenceMag;
if (dur > pl->GetStaticTimer())
pl->SetHudDisable(dur, 0.5f, 2.5f);
else
mgr.GetPlayerState()->GetStaticInterference().AddSource(GetUniqueId(), mag, dur);
}
}
}
zeus::CAABox CScriptEMPulse::CalculateBoundingBox() const
{
return zeus::CAABox(GetTranslation() - xf0_currentRadius, GetTranslation() + xf0_currentRadius);
}
}

36
Runtime/World/CScriptEMPulse.hpp Normal file
View File

@ -0,0 +1,36 @@
#ifndef __URDE_CSCRIPTEMPULSE_HPP__
#define __URDE_CSCRIPTEMPULSE_HPP__
#include "CActor.hpp"
namespace urde
{
class CGenDescription;
class CElementGen;
class CScriptEMPulse : public CActor
{
float xe8_duration;
float xec_finalRadius;
float xf0_currentRadius;
float xf4_initialRadius;
float xf8_interferenceDur;
float xfc_;
float x100_interferenceMag;
float x104_;
TCachedToken<CGenDescription> x108_particleDesc;
std::unique_ptr<CElementGen> x114_particleGen;
zeus::CAABox CalculateBoundingBox() const;
public:
CScriptEMPulse(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, bool, float, float, float,
float, float, float, float, CAssetId);
void Accept(IVisitor&);
void Think(float, CStateManager&);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void AddToRenderer(const zeus::CFrustum&, CStateManager&) const;
void CalculateRenderBounds();
std::experimental::optional<zeus::CAABox> GetTouchBounds() const;
void Touch(CActor&, CStateManager&);
};
}
#endif // __URDE_CSCRIPTEMPULSE_HPP__

9
Runtime/World/CScriptEffect.cpp
View File

@ -407,6 +407,13 @@ zeus::CAABox CScriptEffect::GetSortingBounds(const CStateManager& mgr) const
bool CScriptEffect::AreBothSystemsDeleteable() bool CScriptEffect::AreBothSystemsDeleteable()
{ {
return x104_particleSystem->IsSystemDeletable() && xf4_electric->IsSystemDeletable(); bool ret = true;
if (x104_particleSystem && !x104_particleSystem->IsSystemDeletable())
ret = false;
if (xf4_electric && !xf4_electric->IsSystemDeletable())
ret = false;
return ret;
} }
} }

4
Runtime/World/CScriptPickup.hpp
View File

@ -31,6 +31,10 @@ public:
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor);
void Think(float, CStateManager&); void Think(float, CStateManager&);
void Touch(CActor &, CStateManager &); void Touch(CActor &, CStateManager &);
std::experimental::optional<zeus::CAABox> GetTouchBounds() const
{
return CPhysicsActor::GetBoundingBox();
}
float GetPossibility() const { return x264_possibility; } float GetPossibility() const { return x264_possibility; }
CPlayerState::EItemType GetItem() { return x258_itemType; } CPlayerState::EItemType GetItem() { return x258_itemType; }
}; };

3
Runtime/World/CScriptSpawnPoint.cpp
View File

@ -14,12 +14,13 @@ CScriptSpawnPoint::CScriptSpawnPoint(TUniqueId uid, std::string_view name, const
: CEntity(uid, info, active, name), x34_xf(xf), x64_itemCounts(itemCounts) : CEntity(uid, info, active, name), x34_xf(xf), x64_itemCounts(itemCounts)
{ {
#ifndef NDEBUG #ifndef NDEBUG
x64_itemCounts[int(CPlayerState::EItemType::GravitySuit)] = 1;
x64_itemCounts[int(CPlayerState::EItemType::ThermalVisor)] = 1; x64_itemCounts[int(CPlayerState::EItemType::ThermalVisor)] = 1;
x64_itemCounts[int(CPlayerState::EItemType::XRayVisor)] = 1; x64_itemCounts[int(CPlayerState::EItemType::XRayVisor)] = 1;
x64_itemCounts[int(CPlayerState::EItemType::GrappleBeam)] = 1; x64_itemCounts[int(CPlayerState::EItemType::GrappleBeam)] = 1;
x64_itemCounts[int(CPlayerState::EItemType::BoostBall)] = 1; x64_itemCounts[int(CPlayerState::EItemType::BoostBall)] = 1;
x64_itemCounts[int(CPlayerState::EItemType::ChargeBeam)] = 1; x64_itemCounts[int(CPlayerState::EItemType::ChargeBeam)] = 1;
x64_itemCounts[int(CPlayerState::EItemType::PowerBombs)] = 1; x64_itemCounts[int(CPlayerState::EItemType::PowerBombs)] = 8;
#endif #endif
x10c_24_firstSpawn = defaultSpawn; x10c_24_firstSpawn = defaultSpawn;
x10c_25_morphed = morphed; x10c_25_morphed = morphed;

11
Runtime/World/CScriptSpindleCamera.cpp
View File

@ -1,6 +1,8 @@
#include "CScriptSpindleCamera.hpp" #include "CScriptSpindleCamera.hpp"
#include "Camera/CCameraManager.hpp" #include "Camera/CCameraManager.hpp"
#include "CStateManager.hpp"
#include "ScriptLoader.hpp" #include "ScriptLoader.hpp"
#include "Camera/CBallCamera.hpp"
#include "TCastTo.hpp" #include "TCastTo.hpp"
namespace urde namespace urde
@ -43,7 +45,16 @@ void CScriptSpindleCamera::ProcessInput(const CFinalInput& input, CStateManager&
void CScriptSpindleCamera::Reset(const zeus::CTransform& xf, CStateManager& mgr) void CScriptSpindleCamera::Reset(const zeus::CTransform& xf, CStateManager& mgr)
{ {
const CScriptCameraHint* hint = mgr.GetCameraManager()->GetCameraHint(mgr);
if (!GetActive() || hint == nullptr)
return;
x33c_24_ = true;
mgr.GetCameraManager()->GetBallCamera()->UpdateLookAtPosition(0.01f, mgr);
}
void CScriptSpindleCamera::Think(float, CStateManager&)
{
} }
} }

4
Runtime/World/CScriptSpindleCamera.hpp
View File

@ -49,6 +49,7 @@ class CScriptSpindleCamera : public CGameCamera
float x328_ = 0.f; float x328_ = 0.f;
bool x32c_24 = false; bool x32c_24 = false;
zeus::CVector3f x330_lookDir; zeus::CVector3f x330_lookDir;
bool x33c_24_;
public: public:
CScriptSpindleCamera(TUniqueId uid, std::string_view name, const CEntityInfo& info, CScriptSpindleCamera(TUniqueId uid, std::string_view name, const CEntityInfo& info,
const zeus::CTransform& xf, bool active, u32 r9, const zeus::CTransform& xf, bool active, u32 r9,
@ -62,8 +63,9 @@ public:
const SSpindleProperty& seg14, const SSpindleProperty& seg15); const SSpindleProperty& seg14, const SSpindleProperty& seg15);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor);
void ProcessInput(const CFinalInput& input, CStateManager& mgr); void Think(float, CStateManager&);
void Reset(const zeus::CTransform& xf, CStateManager& mgr); void Reset(const zeus::CTransform& xf, CStateManager& mgr);
void ProcessInput(const CFinalInput& input, CStateManager& mgr);
}; };
} }

3
Runtime/World/CScriptWorldTeleporter.cpp
View File

@ -95,8 +95,9 @@ void CScriptWorldTeleporter::AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId
const auto& world = mgr.WorldNC(); const auto& world = mgr.WorldNC();
world->SetLoadPauseState(true); world->SetLoadPauseState(true);
CAssetId currentWorld = g_GameState->CurrentWorldAssetId(); CAssetId currentWorld = g_GameState->CurrentWorldAssetId();
g_GameState->SetCurrentWorldId(x34_worldId);
if (g_ResFactory->GetResourceTypeById(currentWorld) == SBIG('MLVL')) if (g_ResFactory->GetResourceTypeById(x34_worldId) == SBIG('MLVL'))
{ {
StartTransition(mgr); StartTransition(mgr);
g_GameState->SetCurrentWorldId(x34_worldId); g_GameState->SetCurrentWorldId(x34_worldId);

4
Runtime/World/CWorldTransManager.cpp
View File

@ -155,7 +155,7 @@ void CWorldTransManager::UpdateText(float dt)
if (printed >= nextSfxInterval) if (printed >= nextSfxInterval)
{ {
x3c_sfxInterval = nextSfxInterval; x3c_sfxInterval = nextSfxInterval;
//CSfxManager::SfxStart(SFXsfx059E, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId); CSfxManager::SfxStart(SFXsfx059E, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
} }
} }
@ -424,6 +424,7 @@ void CWorldTransManager::EnableTransition(const CAnimRes& samusRes,
else else
x1c_bgHeight = 0.f; x1c_bgHeight = 0.f;
StartTransition();
TouchModels(); TouchModels();
} }
@ -446,6 +447,7 @@ void CWorldTransManager::EnableTransition(CAssetId fontId, CAssetId stringId, u3
x8_textData->SetTypeWriteEffectOptions(true, chFadeTime, chFadeRate); x8_textData->SetTypeWriteEffectOptions(true, chFadeTime, chFadeRate);
xc_strTable = g_SimplePool->GetObj(SObjectTag{FOURCC('STRG'), stringId}); xc_strTable = g_SimplePool->GetObj(SObjectTag{FOURCC('STRG'), stringId});
x8_textData->SetText(u""); x8_textData->SetText(u"");
StartTransition();
} }
void CWorldTransManager::StartTextFadeOut() void CWorldTransManager::StartTextFadeOut()

529
Runtime/World/ScriptLoader.cpp
View File

@ -12,14 +12,18 @@
#include "CScriptAiJumpPoint.hpp" #include "CScriptAiJumpPoint.hpp"
#include "CScriptAreaAttributes.hpp" #include "CScriptAreaAttributes.hpp"
#include "MP1/World/CSeedling.hpp" #include "MP1/World/CSeedling.hpp"
#include "MP1/World/CBurrower.hpp"
#include "CScriptBeam.hpp" #include "CScriptBeam.hpp"
#include "CScriptCameraBlurKeyframe.hpp" #include "CScriptCameraBlurKeyframe.hpp"
#include "CScriptCameraFilterKeyframe.hpp" #include "CScriptCameraFilterKeyframe.hpp"
#include "CScriptCameraHint.hpp" #include "CScriptCameraHint.hpp"
#include "CScriptCameraHintTrigger.hpp" #include "CScriptCameraHintTrigger.hpp"
#include "CAmbientAI.hpp" #include "CAmbientAI.hpp"
#include "MP1/World/CPuffer.hpp"
#include "MP1/World/CTryclops.hpp"
#include "MP1/World/CRidley.hpp" #include "MP1/World/CRidley.hpp"
#include "CScriptCameraPitchVolume.hpp" #include "CScriptCameraPitchVolume.hpp"
#include "MP1/World/CMagdolite.hpp"
#include "CTeamAiMgr.hpp" #include "CTeamAiMgr.hpp"
#include "CSnakeWeedSwarm.hpp" #include "CSnakeWeedSwarm.hpp"
#include "CScriptCameraShaker.hpp" #include "CScriptCameraShaker.hpp"
@ -27,11 +31,15 @@
#include "CScriptColorModulate.hpp" #include "CScriptColorModulate.hpp"
#include "CScriptControllerAction.hpp" #include "CScriptControllerAction.hpp"
#include "CScriptCounter.hpp" #include "CScriptCounter.hpp"
#include "MP1/World/CElitePirate.hpp"
#include "CScriptCoverPoint.hpp" #include "CScriptCoverPoint.hpp"
#include "CScriptSpiderBallWaypoint.hpp"
#include "CScriptDamageableTrigger.hpp" #include "CScriptDamageableTrigger.hpp"
#include "CScriptDebris.hpp" #include "CScriptDebris.hpp"
#include "CScriptDistanceFog.hpp" #include "CScriptDistanceFog.hpp"
#include "CScriptDock.hpp" #include "CScriptDock.hpp"
#include "MP1/World/CFireFlea.hpp"
#include "MP1/World/CMetaree.hpp"
#include "CScriptDockAreaChange.hpp" #include "CScriptDockAreaChange.hpp"
#include "CScriptDoor.hpp" #include "CScriptDoor.hpp"
#include "CScriptEffect.hpp" #include "CScriptEffect.hpp"
@ -44,6 +52,7 @@
#include "CScriptPickup.hpp" #include "CScriptPickup.hpp"
#include "CScriptPickupGenerator.hpp" #include "CScriptPickupGenerator.hpp"
#include "CScriptPlatform.hpp" #include "CScriptPlatform.hpp"
#include "CScriptEMPulse.hpp"
#include "CScriptPlayerActor.hpp" #include "CScriptPlayerActor.hpp"
#include "CFishCloud.hpp" #include "CFishCloud.hpp"
#include "CFishCloudModifier.hpp" #include "CFishCloudModifier.hpp"
@ -57,6 +66,8 @@
#include "CScriptSound.hpp" #include "CScriptSound.hpp"
#include "CScriptSpawnPoint.hpp" #include "CScriptSpawnPoint.hpp"
#include "CScriptSpecialFunction.hpp" #include "CScriptSpecialFunction.hpp"
#include "MP1/World/CBabygoth.hpp"
#include "MP1/World/CEyeball.hpp"
#include "CScriptSteam.hpp" #include "CScriptSteam.hpp"
#include "CScriptRipple.hpp" #include "CScriptRipple.hpp"
#include "CScriptBallTrigger.hpp" #include "CScriptBallTrigger.hpp"
@ -72,6 +83,7 @@
#include "CScriptWorldTeleporter.hpp" #include "CScriptWorldTeleporter.hpp"
#include "CScriptSpiderBallAttractionSurface.hpp" #include "CScriptSpiderBallAttractionSurface.hpp"
#include "CScriptSpindleCamera.hpp" #include "CScriptSpindleCamera.hpp"
#include "MP1/World/CAtomicAlpha.hpp"
#include "CSimplePool.hpp" #include "CSimplePool.hpp"
#include "CStateManager.hpp" #include "CStateManager.hpp"
#include "CWallCrawlerSwarm.hpp" #include "CWallCrawlerSwarm.hpp"
@ -88,12 +100,15 @@
#include "MP1/World/CWarWasp.hpp" #include "MP1/World/CWarWasp.hpp"
#include "MP1/World/CParasite.hpp" #include "MP1/World/CParasite.hpp"
#include "Particle/CWeaponDescription.hpp" #include "Particle/CWeaponDescription.hpp"
#include "MP1/World/CBloodFlower.hpp"
#include "MP1/World/CFlickerBat.hpp"
#include "Camera/CPathCamera.hpp" #include "Camera/CPathCamera.hpp"
namespace urde namespace urde
{ {
static logvisor::Module Log("urde::ScriptLoader"); static logvisor::Module Log("urde::ScriptLoader");
static SObjectTag MorphballDoorANCS = {}; static SObjectTag MorphballDoorANCS = {};
static const SObjectTag& GetMorphballDoorACS() static const SObjectTag& GetMorphballDoorACS()
{ {
if (!MorphballDoorANCS) if (!MorphballDoorANCS)
@ -124,6 +139,7 @@ struct SActorHead
struct SScaledActorHead : SActorHead struct SScaledActorHead : SActorHead
{ {
zeus::CVector3f x40_scale; zeus::CVector3f x40_scale;
SScaledActorHead(SActorHead&& head) : SActorHead(std::move(head)) {} SScaledActorHead(SActorHead&& head) : SActorHead(std::move(head)) {}
}; };
@ -245,11 +261,11 @@ CActorParameters ScriptLoader::LoadActorParameters(CInputStream& in)
if (propCount > 13) if (propCount > 13)
thermalMag = in.readFloatBig(); thermalMag = in.readFloatBig();
std::pair<CAssetId, CAssetId> xray = {}; std::pair <CAssetId, CAssetId> xray = {};
if (g_ResFactory->GetResourceTypeById(xrayModel)) if (g_ResFactory->GetResourceTypeById(xrayModel))
xray = {xrayModel, xraySkin}; xray = {xrayModel, xraySkin};
std::pair<CAssetId, CAssetId> infra = {}; std::pair <CAssetId, CAssetId> infra = {};
if (g_ResFactory->GetResourceTypeById(infraModel)) if (g_ResFactory->GetResourceTypeById(infraModel))
infra = {infraModel, infraSkin}; infra = {infraModel, infraSkin};
@ -374,8 +390,8 @@ zeus::CTransform ScriptLoader::ConvertEditorEulerToTransform4f(const zeus::CVect
const zeus::CVector3f& position) const zeus::CVector3f& position)
{ {
return zeus::CTransform::RotateZ(zeus::degToRad(orientation.z)) * return zeus::CTransform::RotateZ(zeus::degToRad(orientation.z)) *
zeus::CTransform::RotateY(zeus::degToRad(orientation.y)) * zeus::CTransform::RotateY(zeus::degToRad(orientation.y)) *
zeus::CTransform::RotateX(zeus::degToRad(orientation.x)) + zeus::CTransform::RotateX(zeus::degToRad(orientation.x)) +
position; position;
} }
@ -505,8 +521,7 @@ CEntity* ScriptLoader::LoadDoor(CStateManager& mgr, CInputStream& in, int propCo
{ {
if (aParms.GetACSFile() == GetMorphballDoorACS().id) if (aParms.GetACSFile() == GetMorphballDoorACS().id)
isMorphballDoor = true; isMorphballDoor = true;
} } else if (propCount == 14)
else if (propCount == 14)
isMorphballDoor = in.readBool(); isMorphballDoor = in.readBool();
return new CScriptDoor(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, std::move(mData), actParms, return new CScriptDoor(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, std::move(mData), actParms,
@ -528,7 +543,8 @@ CEntity* ScriptLoader::LoadTrigger(CStateManager& mgr, CInputStream& in, int pro
zeus::CVector3f forceVec = zeus::CVector3f::ReadBig(in); zeus::CVector3f forceVec = zeus::CVector3f::ReadBig(in);
ETriggerFlags flags = ETriggerFlags(in.readUint32Big()); ETriggerFlags
flags = ETriggerFlags(in.readUint32Big());
bool active = in.readBool(); bool active = in.readBool();
bool b2 = in.readBool(); bool b2 = in.readBool();
bool b3 = in.readBool(); bool b3 = in.readBool();
@ -656,7 +672,7 @@ CEntity* ScriptLoader::LoadPlatform(CStateManager& mgr, CInputStream& in, int pr
zeus::CAABox aabb = GetCollisionBox(mgr, info.GetAreaId(), extent, centroid); zeus::CAABox aabb = GetCollisionBox(mgr, info.GetAreaId(), extent, centroid);
FourCC dclnType = g_ResFactory->GetResourceTypeById(dclnId); FourCC dclnType = g_ResFactory->GetResourceTypeById(dclnId);
std::experimental::optional<TLockedToken<CCollidableOBBTreeGroupContainer>> dclnToken; std::experimental::optional <TLockedToken<CCollidableOBBTreeGroupContainer>> dclnToken;
if (dclnType) if (dclnType)
{ {
dclnToken.emplace(g_SimplePool->GetObj({SBIG('DCLN'), dclnId})); dclnToken.emplace(g_SimplePool->GetObj({SBIG('DCLN'), dclnId}));
@ -756,22 +772,23 @@ CEntity* ScriptLoader::LoadCamera(CStateManager& mgr, CInputStream& in, int prop
bool active = in.readBool(); bool active = in.readBool();
float shotDuration = in.readFloatBig(); float shotDuration = in.readFloatBig();
bool b2 = in.readBool(); bool lookAtPlayer = in.readBool();
bool b3 = in.readBool(); bool outOfPlayerEye = in.readBool();
bool b4 = in.readBool(); bool intoPlayerEye = in.readBool();
bool b5 = in.readBool(); bool drawPlayer = in.readBool();
bool b6 = in.readBool();
bool disableInput = in.readBool(); bool disableInput = in.readBool();
bool b8 = in.readBool(); bool b7 = in.readBool();
bool finishCineSkip = in.readBool();
float fov = in.readFloatBig(); float fov = in.readFloatBig();
bool b9 = in.readBool(); bool checkFailsafe = in.readBool();
bool b10 = false; bool disableOutOfInto = false;
if (propCount > 14) if (propCount > 14)
b10 = in.readBool(); disableOutOfInto = in.readBool();
u32 flags = u32(b2) | u32(b3) << 1 | u32(b4) << 2 | u32(b5) << 3 | u32(b6) << 4 | u32(disableInput) << 5 | s32 flags = s32(lookAtPlayer) | s32(outOfPlayerEye) << 1 | s32(intoPlayerEye) << 2 | s32(b7) << 3 |
u32(b8) << 6 | u32(b9) << 8; s32(finishCineSkip) << 4 | s32(disableInput) << 5 | s32(drawPlayer) << 6 |
s32(checkFailsafe) << 7 | s32(disableOutOfInto) << 9;
return new CCinematicCamera(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, active, shotDuration, return new CCinematicCamera(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, active, shotDuration,
fov / CCameraManager::Aspect(), CCameraManager::NearPlane(), CCameraManager::FarPlane(), fov / CCameraManager::Aspect(), CCameraManager::NearPlane(), CCameraManager::FarPlane(),
@ -1019,7 +1036,7 @@ CEntity* ScriptLoader::LoadBeetle(CStateManager& mgr, CInputStream& in, int prop
if (animType != SBIG('ANCS')) if (animType != SBIG('ANCS'))
return nullptr; return nullptr;
std::experimental::optional<CStaticRes> abdomenRes; std::experimental::optional <CStaticRes> abdomenRes;
if (flavor == CPatterned::EFlavorType::One) if (flavor == CPatterned::EFlavorType::One)
abdomenRes.emplace(CStaticRes(abdomen, scale)); abdomenRes.emplace(CStaticRes(abdomen, scale));
@ -1220,11 +1237,12 @@ CEntity* ScriptLoader::LoadWater(CStateManager& mgr, CInputStream& in, int propC
CDamageInfo dInfo(in); CDamageInfo dInfo(in);
zeus::CVector3f orientedForce; zeus::CVector3f orientedForce;
orientedForce.readBig(in); orientedForce.readBig(in);
ETriggerFlags triggerFlags = ETriggerFlags(in.readUint32Big()) | ETriggerFlags::DetectProjectiles1 | ETriggerFlags
ETriggerFlags::DetectProjectiles2 | ETriggerFlags::DetectProjectiles3 | triggerFlags = ETriggerFlags(in.readUint32Big()) | ETriggerFlags::DetectProjectiles1 |
ETriggerFlags::DetectProjectiles4 | ETriggerFlags::DetectBombs | ETriggerFlags::DetectProjectiles2 | ETriggerFlags::DetectProjectiles3 |
ETriggerFlags::DetectPowerBombs | ETriggerFlags::DetectProjectiles5 | ETriggerFlags::DetectProjectiles4 | ETriggerFlags::DetectBombs |
ETriggerFlags::DetectProjectiles6 | ETriggerFlags::DetectProjectiles7; ETriggerFlags::DetectPowerBombs | ETriggerFlags::DetectProjectiles5 |
ETriggerFlags::DetectProjectiles6 | ETriggerFlags::DetectProjectiles7;
bool thermalCold = in.readBool(); bool thermalCold = in.readBool();
bool displaySurface = in.readBool(); bool displaySurface = in.readBool();
CAssetId patternMap1 = in.readUint32Big(); CAssetId patternMap1 = in.readUint32Big();
@ -1291,7 +1309,7 @@ CEntity* ScriptLoader::LoadWater(CStateManager& mgr, CInputStream& in, int propC
u32 w22 = in.readUint32Big(); u32 w22 = in.readUint32Big();
bool b5 = in.readBool(); bool b5 = in.readBool();
std::unique_ptr<u32[]> bitset; std::unique_ptr < u32[] > bitset;
u32 bitVal0 = 0; u32 bitVal0 = 0;
u32 bitVal1 = 0; u32 bitVal1 = 0;
@ -1318,7 +1336,8 @@ CEntity* ScriptLoader::LoadWater(CStateManager& mgr, CInputStream& in, int propC
thermalCold, displaySurface, patternMap1, patternMap2, colorMap, bumpMap, envMap, thermalCold, displaySurface, patternMap1, patternMap2, colorMap, bumpMap, envMap,
envBumpMap, {}, bumpLightDir, bumpScale, morphInTime, morphOutTime, active, fluidType, b4, envBumpMap, {}, bumpLightDir, bumpScale, morphInTime, morphOutTime, active, fluidType, b4,
alpha, uvMotion, turbSpeed, turbDistance, turbFreqMax, turbFreqMin, turbPhaseMax, alpha, uvMotion, turbSpeed, turbDistance, turbFreqMax, turbFreqMin, turbPhaseMax,
turbPhaseMin, turbAmplitudeMax, turbAmplitudeMin, splashColor, insideFogColor, splashParticle1, turbPhaseMin, turbAmplitudeMax, turbAmplitudeMin, splashColor, insideFogColor,
splashParticle1,
splashParticle2, splashParticle3, visorRunoffParticle, unmorphVisorRunoffParticle, splashParticle2, splashParticle3, visorRunoffParticle, unmorphVisorRunoffParticle,
visorRunoffSfx, unmorphVisorRunoffSfx, splashSfx1, splashSfx2, splashSfx3, tileSize, visorRunoffSfx, unmorphVisorRunoffSfx, splashSfx1, splashSfx2, splashSfx3, tileSize,
tileSubdivisions, specularMin, specularMax, reflectionSize, rippleIntensity, tileSubdivisions, specularMin, specularMax, reflectionSize, rippleIntensity,
@ -1399,7 +1418,28 @@ CEntity* ScriptLoader::LoadFlyingPirate(CStateManager& mgr, CInputStream& in, in
CEntity* ScriptLoader::LoadElitePirate(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadElitePirate(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{ {
return nullptr; if (!EnsurePropertyCount(propCount, 41, "ElitePirate"))
return nullptr;
SScaledActorHead actHead = LoadScaledActorHead(in, mgr);
auto pair = CPatternedInfo::HasCorrectParameterCount(in);
if (!pair.first)
return nullptr;
CPatternedInfo pInfo(in, pair.second);
CActorParameters actParms = LoadActorParameters(in);
MP1::CElitePirateData elitePirateData(in, propCount);
if (!pInfo.GetAnimationParameters().GetACSFile().IsValid())
return nullptr;
CModelData mData(
CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
actHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
return new MP1::CElitePirate(mgr.AllocateUniqueId(), actHead.x0_name, info, actHead.x10_transform, std::move(mData),
pInfo, actParms, elitePirateData);
} }
CEntity* ScriptLoader::LoadMetroidBeta(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadMetroidBeta(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
@ -1432,17 +1472,82 @@ CEntity* ScriptLoader::LoadCoverPoint(CStateManager& mgr, CInputStream& in, int
CEntity* ScriptLoader::LoadSpiderBallWaypoint(CStateManager& mgr, CInputStream& in, int propCount, CEntity* ScriptLoader::LoadSpiderBallWaypoint(CStateManager& mgr, CInputStream& in, int propCount,
const CEntityInfo& info) const CEntityInfo& info)
{ {
return nullptr; if (!EnsurePropertyCount(propCount, 5, "SpiderBallWaypoint"))
return nullptr;
SActorHead actHead = LoadActorHead(in, mgr);
bool active = in.readBool();
u32 w1 = in.readUint32Big();
return new CScriptSpiderBallWaypoint(mgr.AllocateUniqueId(), actHead.x0_name, info, actHead.x10_transform, active,
w1);
} }
CEntity* ScriptLoader::LoadBloodFlower(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadBloodFlower(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{ {
return nullptr; if (!EnsurePropertyCount(propCount, 18, "BloodFlower"))
return nullptr;
SScaledActorHead actHead = LoadScaledActorHead(in, mgr);
auto pair = CPatternedInfo::HasCorrectParameterCount(in);
if (!pair.first)
return nullptr;
CPatternedInfo pInfo(in, pair.second);
CActorParameters actParms = LoadActorParameters(in);
CAssetId partId1(in);
CAssetId wpsc1(in);
CAssetId wpsc2(in);
CDamageInfo dInfo1(in);
CDamageInfo dInfo2(in);
CDamageInfo dInfo3(in);
CAssetId partId2(in);
CAssetId partId3(in);
CAssetId partId4(in);
float f1 = in.readFloatBig();
CAssetId partId5(in);
u32 soundId = in.readUint32Big();
if (g_ResFactory->GetResourceTypeById(pInfo.GetAnimationParameters().GetACSFile()) != SBIG('ANCS'))
return nullptr;
CModelData mData(
CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
actHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
return new MP1::CBloodFlower(mgr.AllocateUniqueId(), actHead.x0_name, info, actHead.x10_transform, std::move(mData),
pInfo, partId1, wpsc1, actParms, wpsc2, dInfo1, dInfo2, dInfo3, partId2, partId3,
partId4, f1, partId5, soundId);
} }
CEntity* ScriptLoader::LoadFlickerBat(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadFlickerBat(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{ {
return nullptr; if (!EnsurePropertyCount(propCount, 10, "FlickerBat"))
return nullptr;
std::string name = mgr.HashInstanceName(in);
CPatterned::EFlavorType flavor = CPatterned::EFlavorType(in.readUint32Big());
zeus::CTransform xf = LoadEditorTransform(in);
zeus::CVector3f scale = zeus::CVector3f::ReadBig(in);
auto pair = CPatternedInfo::HasCorrectParameterCount(in);
if (!pair.first)
return nullptr;
CPatternedInfo pInfo(in, pair.second);
CActorParameters actParms = LoadActorParameters(in);
bool b1 = in.readBool();
bool b2 = in.readBool();
bool b3 = in.readBool();
if (g_ResFactory->GetResourceTypeById(pInfo.GetAnimationParameters().GetACSFile()) != SBIG('ANCS'))
return nullptr;
CModelData mData(
CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
return new MP1::CFlickerBat(mgr.AllocateUniqueId(), name, flavor, info, xf, std::move(mData), pInfo,
CPatterned::EColliderType(b1), b2, actParms, b3);
} }
CEntity* ScriptLoader::LoadPathCamera(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadPathCamera(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
@ -1543,12 +1648,63 @@ CEntity* ScriptLoader::LoadDistanceFog(CStateManager& mgr, CInputStream& in, int
CEntity* ScriptLoader::LoadFireFlea(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadFireFlea(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{ {
return nullptr; if (!EnsurePropertyCount(propCount, 9, "FireFlea"))
return nullptr;
SScaledActorHead acthead = LoadScaledActorHead(in, mgr);
auto pair = CPatternedInfo::HasCorrectParameterCount(in);
if (!pair.first)
return nullptr;
CPatternedInfo pInfo(in, pair.second);
CActorParameters actParms = LoadActorParameters(in);
in.readBool();
in.readBool();
float f1 = in.readFloatBig();
if (!pInfo.GetAnimationParameters().GetACSFile().IsValid())
return nullptr;
CModelData mData(
CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
acthead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
return new MP1::CFireFlea(mgr.AllocateUniqueId(), acthead.x0_name, info, acthead.x10_transform, std::move(mData),
actParms, pInfo, f1);
} }
CEntity* ScriptLoader::LoadMetareeAlpha(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadMetaree(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{ {
return nullptr; if (!EnsurePropertyCount(propCount, 12, "Metaree"))
return nullptr;
std::string name = mgr.HashInstanceName(in);
zeus::CTransform xf = LoadEditorTransform(in);
zeus::CVector3f scale = zeus::CVector3f::ReadBig(in);
auto pair = CPatternedInfo::HasCorrectParameterCount(in);
if (!pair.first)
return nullptr;
CPatternedInfo pInfo(in, pair.second);
CActorParameters aParms = LoadActorParameters(in);
CDamageInfo dInfo(in);
float f1 = in.readFloatBig();
zeus::CVector3f vec = zeus::CVector3f::ReadBig(in);
float f2 = in.readFloatBig();
float f3 = in.readFloatBig();
if (g_ResFactory->GetResourceTypeById(pInfo.GetAnimationParameters().GetACSFile()) != SBIG('ANCS'))
return nullptr;
float f4 = in.readFloatBig();
CModelData mData(
CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
return new MP1::CMetaree(mgr.AllocateUniqueId(), name, CPatterned::EFlavorType::Zero, info, xf, std::move(mData),
pInfo,
dInfo, f1, vec, f2, EBodyType::Invalid, f3, f4, aParms);
} }
CEntity* ScriptLoader::LoadDockAreaChange(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadDockAreaChange(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
@ -1798,7 +1954,8 @@ CEntity* ScriptLoader::LoadSteam(CStateManager& mgr, CInputStream& in, int propC
zeus::CVector3f v3 = zeus::CVector3f::ReadBig(in); zeus::CVector3f v3 = zeus::CVector3f::ReadBig(in);
ETriggerFlags w1 = ETriggerFlags(in.readUint32Big()); ETriggerFlags
w1 = ETriggerFlags(in.readUint32Big());
bool b1 = in.readBool(); bool b1 = in.readBool();
u32 w2 = in.readUint32Big(); u32 w2 = in.readUint32Big();
float f1 = in.readFloatBig(); float f1 = in.readFloatBig();
@ -1854,7 +2011,22 @@ CEntity* ScriptLoader::LoadTargetingPoint(CStateManager& mgr, CInputStream& in,
CEntity* ScriptLoader::LoadEMPulse(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadEMPulse(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{ {
return nullptr; if (!EnsurePropertyCount(propCount, 12, "EMPulse"))
return nullptr;
SActorHead actorHead = LoadActorHead(in, mgr);
bool active = in.readBool();
float f1 = in.readFloatBig();
float f2 = in.readFloatBig();
float f3 = in.readFloatBig();
float f4 = in.readFloatBig();
float f5 = in.readFloatBig();
float f6 = in.readFloatBig();
float f7 = in.readFloatBig();
CAssetId particleId(in);
return new CScriptEMPulse(mgr.AllocateUniqueId(), actorHead.x0_name, info, actorHead.x10_transform, active, f1, f2,
f3, f4, f5, f6, f7, particleId);
} }
CEntity* ScriptLoader::LoadIceSheegoth(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadIceSheegoth(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
@ -2013,7 +2185,7 @@ CEntity* ScriptLoader::LoadVisorFlare(CStateManager& mgr, CInputStream& in, int
float f2 = in.readFloatBig(); float f2 = in.readFloatBig();
float f3 = in.readFloatBig(); float f3 = in.readFloatBig();
u32 w2 = in.readUint32Big(); u32 w2 = in.readUint32Big();
std::vector<CVisorFlare::CFlareDef> flares; std::vector <CVisorFlare::CFlareDef> flares;
flares.reserve(5); flares.reserve(5);
for (int i = 0; i < 5; ++i) for (int i = 0; i < 5; ++i)
if (auto flare = CVisorFlare::LoadFlareDef(in)) if (auto flare = CVisorFlare::LoadFlareDef(in))
@ -2088,11 +2260,10 @@ CEntity* ScriptLoader::LoadVisorGoo(CStateManager& mgr, CInputStream& in, int pr
s32 sfx = in.readInt32Big(); s32 sfx = in.readInt32Big();
bool forceShow = in.readBool(); bool forceShow = in.readBool();
if (particle.IsValid() || electric.IsValid()) if (!particle.IsValid() && !electric.IsValid())
return new CScriptVisorGoo(mgr.AllocateUniqueId(), name, info, xf, particle, electric, minDist, maxDist, return nullptr;
nearProb, farProb, color, sfx, forceShow, false); return new CScriptVisorGoo(mgr.AllocateUniqueId(), name, info, xf, particle, electric, minDist, maxDist,
nearProb, farProb, color, sfx, forceShow, false);
return nullptr;
} }
CEntity* ScriptLoader::LoadJellyZap(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadJellyZap(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
@ -2399,12 +2570,69 @@ CEntity* ScriptLoader::LoadFogVolume(CStateManager& mgr, CInputStream& in, int p
CEntity* ScriptLoader::LoadBabygoth(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadBabygoth(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{ {
return nullptr; if (!EnsurePropertyCount(propCount, 33, "Babygoth"))
return nullptr;
SScaledActorHead actHead = LoadScaledActorHead(in, mgr);
auto pair = CPatternedInfo::HasCorrectParameterCount(in);
if (!pair.first)
return nullptr;
CPatternedInfo pInfo(in, pair.second);
CActorParameters actParms = LoadActorParameters(in);
MP1::CBabygothData babyData(in);
if (!pInfo.GetAnimationParameters().GetACSFile().IsValid())
return nullptr;
CModelData mData(CAnimRes(pInfo.GetAnimationParameters().GetACSFile(),
pInfo.GetAnimationParameters().GetCharacter(), actHead.x40_scale,
pInfo.GetAnimationParameters().GetInitialAnimation(), true));
return new MP1::CBabygoth(mgr.AllocateUniqueId(), actHead.x0_name, info, actHead.x10_transform, std::move(mData),
pInfo, actParms, babyData);
} }
CEntity* ScriptLoader::LoadEyeball(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadEyeball(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{ {
return nullptr; if (!EnsurePropertyCount(propCount, 21, "Eyeball"))
return nullptr;
std::string name = mgr.HashInstanceName(in);
CPatterned::EFlavorType flavor = CPatterned::EFlavorType(in.readUint32Big());
zeus::CTransform xf = LoadEditorTransform(in);
zeus::CVector3f scale = zeus::CVector3f::ReadBig(in);
auto pair = CPatternedInfo::HasCorrectParameterCount(in);
if (!pair.first)
return nullptr;
CPatternedInfo pInfo(in, pair.second);
CActorParameters actParms = LoadActorParameters(in);
float f1 = in.readFloatBig();
float f2 = in.readFloatBig();
CAssetId wpsc(in);
CDamageInfo dInfo(in);
CAssetId partId1(in);
CAssetId partId2(in);
CAssetId texture1(in);
CAssetId texture2(in);
u32 w1 = in.readUint32Big();
u32 w2 = in.readUint32Big();
u32 w3 = in.readUint32Big();
u32 w4 = in.readUint32Big();
u32 w5 = in.readUint32Big();
if (g_ResFactory->GetResourceTypeById(pInfo.GetAnimationParameters().GetACSFile()) != SBIG('ANCS'))
return nullptr;
bool b1 = in.readBool();
CModelData mData(CAnimRes(pInfo.GetAnimationParameters().GetACSFile(),
pInfo.GetAnimationParameters().GetCharacter(), scale,
pInfo.GetAnimationParameters().GetInitialAnimation(), true));
return new MP1::CEyeball(mgr.AllocateUniqueId(), name, flavor, info, xf, std::move(mData), pInfo, f1, f2, wpsc,
dInfo, partId1, partId2, texture1, texture2, w1, w2, w3, w4, w5, actParms, b1);
} }
CEntity* ScriptLoader::LoadRadialDamage(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadRadialDamage(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
@ -2419,9 +2647,10 @@ CEntity* ScriptLoader::LoadRadialDamage(CStateManager& mgr, CInputStream& in, in
float radius = in.readFloatBig(); float radius = in.readFloatBig();
zeus::CTransform xf = ConvertEditorEulerToTransform4f(zeus::CVector3f::skZero, center); zeus::CTransform xf = ConvertEditorEulerToTransform4f(zeus::CVector3f::skZero, center);
return new CScriptSpecialFunction( return new CScriptSpecialFunction(mgr.AllocateUniqueId(), name, info, xf,
mgr.AllocateUniqueId(), name, info, xf, CScriptSpecialFunction::ESpecialFunction::RadialDamage, "", radius, 0.f, CScriptSpecialFunction::ESpecialFunction::RadialDamage, "", radius, 0.f,
0.f, 0.f, zeus::CVector3f::skZero, zeus::CColor::skBlack, active, dInfo, -1, -1, -1, -1, -1, -1); 0.f, 0.f, zeus::CVector3f::skZero, zeus::CColor::skBlack, active, dInfo, -1, -1,
-1, -1, -1, -1);
} }
CEntity* ScriptLoader::LoadCameraPitchVolume(CStateManager& mgr, CInputStream& in, int propCount, CEntity* ScriptLoader::LoadCameraPitchVolume(CStateManager& mgr, CInputStream& in, int propCount,
@ -2459,7 +2688,46 @@ CEntity* ScriptLoader::LoadEnvFxDensityController(CStateManager& mgr, CInputStre
CEntity* ScriptLoader::LoadMagdolite(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadMagdolite(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{ {
return nullptr; if (!EnsurePropertyCount(propCount, 22, "Magdolite"))
return nullptr;
SScaledActorHead actorHead = LoadScaledActorHead(in, mgr);
auto pair = CPatternedInfo::HasCorrectParameterCount(in);
if (!pair.first)
return nullptr;
CPatternedInfo pInfo(in, pair.second);
CActorParameters actorParameters = LoadActorParameters(in);
if (!pInfo.GetAnimationParameters().GetACSFile().IsValid())
return nullptr;
float f1 = in.readFloatBig();
float f2 = in.readFloatBig();
CDamageInfo damageInfo1(in);
CDamageInfo damageInfo2(in);
CDamageVulnerability damageVulnerability1(in);
CDamageVulnerability damageVulnerability2(in);
CAssetId modelId(in);
CAssetId skinId(in);
float f3 = in.readFloatBig();
float f4 = in.readFloatBig();
float f5 = in.readFloatBig();
float f6 = in.readFloatBig();
MP1::CMagdolite::CMagdoliteData magData(in);
float f7 = in.readFloatBig();
float f8 = in.readFloatBig();
float f9 = in.readFloatBig();
CModelData modelData(CAnimRes(pInfo.GetAnimationParameters().GetACSFile(),
pInfo.GetAnimationParameters().GetCharacter(), actorHead.x40_scale,
pInfo.GetAnimationParameters().GetInitialAnimation(), true));
return new MP1::CMagdolite(mgr.AllocateUniqueId(), actorHead.x0_name, info, actorHead.x10_transform,
std::move(modelData), pInfo, actorParameters, f1, f2, damageInfo1, damageInfo2,
damageVulnerability1,
damageVulnerability2, modelId, skinId, f3, f4, f5, f6, magData, f7, f8, f9);
} }
CEntity* ScriptLoader::LoadTeamAIMgr(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadTeamAIMgr(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
@ -2507,9 +2775,9 @@ CEntity* ScriptLoader::LoadSnakeWeedSwarm(CStateManager& mgr, CInputStream& in,
u32 w9 = (propCount < 29 ? -1 : in.readUint32Big()); u32 w9 = (propCount < 29 ? -1 : in.readUint32Big());
u32 f16 = (propCount < 29 ? 0.f : in.readFloatBig()); u32 f16 = (propCount < 29 ? 0.f : in.readFloatBig());
return new CSnakeWeedSwarm(mgr.AllocateUniqueId(), active, name, info, pos, scale, animParms, return new CSnakeWeedSwarm(mgr.AllocateUniqueId(), active, name, info, pos, scale, animParms, actParms, f1, f2, f3,
actParms, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, dInfo, f15, w4, w5, w6, w7, w8, w9,
f14, dInfo, f15, w4, w5, w6, w7, w8, w9, f16); f16);
} }
CEntity* ScriptLoader::LoadActorContraption(CStateManager& mgr, CInputStream& in, int propCount, CEntity* ScriptLoader::LoadActorContraption(CStateManager& mgr, CInputStream& in, int propCount,
@ -2581,11 +2849,13 @@ CEntity* ScriptLoader::LoadGeemer(CStateManager& mgr, CInputStream& in, int prop
u16 sId2 = in.readUint32Big() & 0xFFFF; u16 sId2 = in.readUint32Big() & 0xFFFF;
u16 sId3 = in.readUint32Big() & 0xFFFF; u16 sId3 = in.readUint32Big() & 0xFFFF;
CModelData mData(CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(), CModelData mData(
actHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true)); CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
actHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
return new MP1::CParasite(mgr.AllocateUniqueId(), actHead.x0_name, CPatterned::EFlavorType::Zero, info, return new MP1::CParasite(mgr.AllocateUniqueId(), actHead.x0_name, CPatterned::EFlavorType::Zero, info,
actHead.x10_transform, std::move(mData), pInfo, EBodyType::WallWalker, 0.f, f1, f2, f3, f4, 0.2f, 0.4f, 0.f, actHead.x10_transform, std::move(mData), pInfo, EBodyType::WallWalker, 0.f, f1, f2, f3,
f4, 0.2f, 0.4f, 0.f,
0.f, 0.f, 0.f, 0.f, 1.f, f7, 0.f, 0.f, f5, f6, false, 2, 0.f, 0.f, 0.f, 0.f, 1.f, f7, 0.f, 0.f, f5, f6, false, 2,
CDamageVulnerability::NormalVulnerabilty(), CDamageInfo(), sId1, sId2, sId3, -1, CDamageVulnerability::NormalVulnerabilty(), CDamageInfo(), sId1, sId2, sId3, -1,
-1, 0.f, actParms); -1, 0.f, actParms);
@ -2636,7 +2906,32 @@ CEntity* ScriptLoader::LoadSpindleCamera(CStateManager& mgr, CInputStream& in, i
CEntity* ScriptLoader::LoadAtomicAlpha(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadAtomicAlpha(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{ {
return nullptr; if (!EnsurePropertyCount(propCount, 14, "AtomicAlpha"))
return nullptr;
SScaledActorHead actHead = LoadScaledActorHead(in, mgr);
auto pair = CPatternedInfo::HasCorrectParameterCount(in);
if (!pair.first)
return nullptr;
CPatternedInfo pInfo(in, pair.second);
CActorParameters actParms = LoadActorParameters(in);
CAssetId wpsc(in);
CAssetId model(in);
CDamageInfo dInfo(in);
float f1 = in.readFloatBig();
float f2 = in.readFloatBig();
float f3 = in.readFloatBig();
bool b1 = in.readBool();
bool b2 = in.readBool();
CModelData mData(
CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
actHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
return new MP1::CAtomicAlpha(mgr.AllocateUniqueId(), actHead.x0_name, info, actHead.x10_transform, std::move(mData),
actParms, pInfo, wpsc, dInfo, f1, f2, f3, model, b1, b2);
} }
CEntity* ScriptLoader::LoadCameraHintTrigger(CStateManager& mgr, CInputStream& in, int propCount, CEntity* ScriptLoader::LoadCameraHintTrigger(CStateManager& mgr, CInputStream& in, int propCount,
@ -2712,7 +3007,8 @@ CEntity* ScriptLoader::LoadAmbientAI(CStateManager& mgr, CInputStream& in, int p
aabox = mData.GetBounds(head.x10_transform.getRotation()); aabox = mData.GetBounds(head.x10_transform.getRotation());
return new CAmbientAI(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, std::move(mData), aabox, return new CAmbientAI(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, std::move(mData), aabox,
matList, mass, hInfo, dVuln, actParms, alertRange, impactRange, alertAnim, impactAnim, active); matList, mass, hInfo, dVuln, actParms, alertRange, impactRange, alertAnim, impactAnim,
active);
} }
CEntity* ScriptLoader::LoadAtomicBeta(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadAtomicBeta(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
@ -2727,12 +3023,66 @@ CEntity* ScriptLoader::LoadIceZoomer(CStateManager& mgr, CInputStream& in, int p
CEntity* ScriptLoader::LoadPuffer(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadPuffer(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{ {
return nullptr; if (!EnsurePropertyCount(propCount, 16, "Puffer"))
return nullptr;
SScaledActorHead aHead = LoadScaledActorHead(in, mgr);
auto pair = CPatternedInfo::HasCorrectParameterCount(in);
if (!pair.first)
return nullptr;
CPatternedInfo pInfo(in, pair.second);
if (!pInfo.GetAnimationParameters().GetACSFile().IsValid())
return nullptr;
CActorParameters actorParameters = LoadActorParameters(in);
float hoverSpeed = in.readFloatBig();
CAssetId cloudEffect(in);
CDamageInfo cloudDamage(in);
CAssetId cloudSteam(in);
float f2 = in.readFloatBig();
bool b1 = in.readBool();
bool b2 = in.readBool();
bool b3 = in.readBool();
CDamageInfo explosionDamage(in);
s16 sfxId = in.readUint16Big();
CModelData mData(
CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
aHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
return new MP1::CPuffer(mgr.AllocateUniqueId(), aHead.x0_name, info, aHead.x10_transform, std::move(mData),
actorParameters, pInfo, hoverSpeed, cloudEffect, cloudDamage, cloudSteam, f2, b1, b2, b3,
explosionDamage, sfxId);
} }
CEntity* ScriptLoader::LoadTryclops(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadTryclops(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{ {
return nullptr; if (!EnsurePropertyCount(propCount, 10, "Tryclops"))
return nullptr;
SScaledActorHead actorHead = LoadScaledActorHead(in, mgr);
auto pair = CPatternedInfo::HasCorrectParameterCount(in);
if (!pair.first)
return nullptr;
CPatternedInfo pInfo(in, pair.second);
if (!pInfo.GetAnimationParameters().GetACSFile().IsValid())
return nullptr;
CActorParameters actorParameters = LoadActorParameters(in);
float f1 = in.readFloatBig();
float f2 = in.readFloatBig();
float f3 = in.readFloatBig();
float f4 = in.readFloatBig();
CModelData mData(CAnimRes(pInfo.GetAnimationParameters().GetACSFile(),
pInfo.GetAnimationParameters().GetCharacter(), actorHead.x40_scale,
pInfo.GetAnimationParameters().GetInitialAnimation(), true));
return new MP1::CTryclops(mgr.AllocateUniqueId(), actorHead.x0_name, info, actorHead.x10_transform,
std::move(mData), pInfo, actorParameters, f1, f2, f3, f4);
} }
CEntity* ScriptLoader::LoadRidley(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadRidley(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
@ -2750,8 +3100,11 @@ CEntity* ScriptLoader::LoadRidley(CStateManager& mgr, CInputStream& in, int prop
if (!pInfo.GetAnimationParameters().GetACSFile().IsValid()) if (!pInfo.GetAnimationParameters().GetACSFile().IsValid())
return nullptr; return nullptr;
CModelData mData(CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(), aHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true)); CModelData mData(
return new MP1::CRidley(mgr.AllocateUniqueId(), aHead.x0_name, info, aHead.x10_transform, std::move(mData), pInfo, actParms, in, propCount); CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
aHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
return new MP1::CRidley(mgr.AllocateUniqueId(), aHead.x0_name, info, aHead.x10_transform, std::move(mData), pInfo,
actParms, in, propCount);
} }
CEntity* ScriptLoader::LoadSeedling(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadSeedling(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
@ -2779,8 +3132,11 @@ CEntity* ScriptLoader::LoadSeedling(CStateManager& mgr, CInputStream& in, int pr
float f3 = in.readFloatBig(); float f3 = in.readFloatBig();
float f4 = in.readFloatBig(); float f4 = in.readFloatBig();
CModelData mData(CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(), aHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true)); CModelData mData(
return new MP1::CSeedling(mgr.AllocateUniqueId(), aHead.x0_name, info, aHead.x10_transform, std::move(mData), pInfo, actParms, needleId, weaponId, dInfo1, dInfo2, f1, f2, f3, f4); CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
aHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
return new MP1::CSeedling(mgr.AllocateUniqueId(), aHead.x0_name, info, aHead.x10_transform, std::move(mData), pInfo,
actParms, needleId, weaponId, dInfo1, dInfo2, f1, f2, f3, f4);
} }
CEntity* ScriptLoader::LoadThermalHeatFader(CStateManager& mgr, CInputStream& in, int propCount, CEntity* ScriptLoader::LoadThermalHeatFader(CStateManager& mgr, CInputStream& in, int propCount,
@ -2789,12 +3145,46 @@ CEntity* ScriptLoader::LoadThermalHeatFader(CStateManager& mgr, CInputStream& in
if (!EnsurePropertyCount(propCount, 4, "ThermalHeatFader")) if (!EnsurePropertyCount(propCount, 4, "ThermalHeatFader"))
return nullptr; return nullptr;
return LoadWorldLightFader(mgr, in, propCount, info); std::string name = mgr.HashInstanceName(in);
bool active = in.readBool();
float fadedLevel = in.readFloatBig();
float initialLevel = in.readFloatBig();
return new CScriptDistanceFog(mgr.AllocateUniqueId(), name, info, ERglFogMode::None, zeus::CColor::skBlack,
zeus::CVector2f(), 0.f, zeus::CVector2f(), false, active, fadedLevel, initialLevel,
0.f, 0.f);
} }
CEntity* ScriptLoader::LoadBurrower(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadBurrower(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{ {
return nullptr; if (!EnsurePropertyCount(propCount, 13, "Burrower"))
return nullptr;
SScaledActorHead aHead = LoadScaledActorHead(in, mgr);
auto pair = CPatternedInfo::HasCorrectParameterCount(in);
if (!pair.first)
return nullptr;
CPatternedInfo pInfo(in, pair.second);
if (!pInfo.GetAnimationParameters().GetACSFile().IsValid())
return nullptr;
CActorParameters actParms = LoadActorParameters(in);
CAssetId w1(in);
CAssetId w2(in);
CAssetId w3(in);
CDamageInfo dInfo(in);
CAssetId w4(in);
u32 w5 = in.readUint32Big();
CAssetId w6(in);
CModelData mData(
CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
aHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
return new MP1::CBurrower(mgr.AllocateUniqueId(), aHead.x0_name, info, aHead.x10_transform, std::move(mData), pInfo,
actParms, w1, w2, w3, dInfo, w4, w5, w6);
} }
CEntity* ScriptLoader::LoadBeam(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info) CEntity* ScriptLoader::LoadBeam(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
@ -2810,7 +3200,7 @@ CEntity* ScriptLoader::LoadBeam(CStateManager& mgr, CInputStream& in, int propCo
CBeamInfo beamInfo(in); CBeamInfo beamInfo(in);
CDamageInfo dInfo(in); CDamageInfo dInfo(in);
TToken<CWeaponDescription> weaponDesc = g_SimplePool->GetObj({SBIG('WPSC'), weaponDescId}); TToken <CWeaponDescription> weaponDesc = g_SimplePool->GetObj({SBIG('WPSC'), weaponDescId});
return new CScriptBeam(mgr.AllocateUniqueId(), aHead.x0_name, info, aHead.x10_transform, active, weaponDesc, return new CScriptBeam(mgr.AllocateUniqueId(), aHead.x0_name, info, aHead.x10_transform, active, weaponDesc,
beamInfo, dInfo); beamInfo, dInfo);
@ -2821,7 +3211,14 @@ CEntity* ScriptLoader::LoadWorldLightFader(CStateManager& mgr, CInputStream& in,
if (!EnsurePropertyCount(propCount, 4, "WorldLightFader")) if (!EnsurePropertyCount(propCount, 4, "WorldLightFader"))
return nullptr; return nullptr;
return nullptr; std::string name = mgr.HashInstanceName(in);
bool active = in.readBool();
float f1 = in.readFloatBig();
float f2 = in.readFloatBig();
return new CScriptDistanceFog(mgr.AllocateUniqueId(), name, info, ERglFogMode::None, zeus::CColor::skBlack,
zeus::CVector2f::skZero, 0.f, zeus::CVector2f::skZero, false, active, 0.f, 0.f, f1,
f2);
} }
CEntity* ScriptLoader::LoadMetroidPrimeStage2(CStateManager& mgr, CInputStream& in, int propCount, CEntity* ScriptLoader::LoadMetroidPrimeStage2(CStateManager& mgr, CInputStream& in, int propCount,

2
Runtime/World/ScriptLoader.hpp
View File

@ -82,7 +82,7 @@ public:
static CEntity* LoadPuddleToadGamma(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info); static CEntity* LoadPuddleToadGamma(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);
static CEntity* LoadDistanceFog(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info); static CEntity* LoadDistanceFog(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);
static CEntity* LoadFireFlea(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info); static CEntity* LoadFireFlea(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);
static CEntity* LoadMetareeAlpha(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info); static CEntity* LoadMetaree(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);
static CEntity* LoadDockAreaChange(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info); static CEntity* LoadDockAreaChange(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);
static CEntity* LoadActorRotate(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info); static CEntity* LoadActorRotate(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);
static CEntity* LoadSpecialFunction(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info); static CEntity* LoadSpecialFunction(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);

2
Runtime/World/ScriptObjectSupport.cpp
View File

@ -56,7 +56,7 @@ std::string_view ScriptObjectTypeToStr(EScriptObjectType type)
case EScriptObjectType::PuddleToadGamma: return "PuddleToadGamma"sv; case EScriptObjectType::PuddleToadGamma: return "PuddleToadGamma"sv;
case EScriptObjectType::DistanceFog: return "DistanceFog"sv; case EScriptObjectType::DistanceFog: return "DistanceFog"sv;
case EScriptObjectType::FireFlea: return "FireFlea"sv; case EScriptObjectType::FireFlea: return "FireFlea"sv;
case EScriptObjectType::MetareeAlpha: return "MetareeAlpha"sv; case EScriptObjectType::Metaree: return "Metaree"sv;
case EScriptObjectType::DockAreaChange: return "DockAreaChange"sv; case EScriptObjectType::DockAreaChange: return "DockAreaChange"sv;
case EScriptObjectType::ActorRotate: return "ActorRotate"sv; case EScriptObjectType::ActorRotate: return "ActorRotate"sv;
case EScriptObjectType::SpecialFunction: return "SpecialFunction"sv; case EScriptObjectType::SpecialFunction: return "SpecialFunction"sv;

2
Runtime/World/ScriptObjectSupport.hpp
View File

@ -55,7 +55,7 @@ enum class EScriptObjectType
PuddleToadGamma = 0x34, PuddleToadGamma = 0x34,
DistanceFog = 0x35, DistanceFog = 0x35,
FireFlea = 0x36, FireFlea = 0x36,
MetareeAlpha = 0x37, Metaree = 0x37,
DockAreaChange = 0x38, DockAreaChange = 0x38,
ActorRotate = 0x39, ActorRotate = 0x39,
SpecialFunction = 0x3A, SpecialFunction = 0x3A,

1
assetnameparser/CMakeLists.txt
View File

@ -1,4 +1,5 @@
cmake_minimum_required(VERSION 3.10 FATAL_ERROR) # because of c++17 cmake_minimum_required(VERSION 3.10 FATAL_ERROR) # because of c++17
set(BUILD_TESTING OFF)
add_subdirectory(tinyxml2) add_subdirectory(tinyxml2)
add_executable(assetnameparser "main.cpp") add_executable(assetnameparser "main.cpp")
include_directories(${LOGVISOR_INCLUDE_DIR}) include_directories(${LOGVISOR_INCLUDE_DIR})