isledecomp/isle
1
0
Fork 0
mirror of https://github.com/isledecomp/isle.git synced 2026-01-27 02:01:16 +00:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

More fixes

Browse Source
This commit is contained in:
Christian Semmler 2023-12-12 11:06:39 -05:00
parent aed1d26f81
commit 34b3d92696
18 changed files with 103 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
LEGO1/mxdirectdraw.cpp
View File

@ -313,16 +313,16 @@ BOOL MxDirectDraw::IsSupportedMode(int width, int height, int bpp)
// FUNCTION: LEGO1 0x1009da20 // FUNCTION: LEGO1 0x1009da20
void EnableResizing(HWND p_hwnd, BOOL p_flag) void EnableResizing(HWND p_hwnd, BOOL p_flag)
{ {
static DWORD s_dwStyle; static DWORD g_dwStyle;
if (!p_flag) { if (!p_flag) {
s_dwStyle = GetWindowLong(p_hwnd, GWL_STYLE); g_dwStyle = GetWindowLong(p_hwnd, GWL_STYLE);
if (s_dwStyle & WS_THICKFRAME) { if (g_dwStyle & WS_THICKFRAME) {
SetWindowLong(p_hwnd, GWL_STYLE, GetWindowLong(p_hwnd, GWL_STYLE) ^ WS_THICKFRAME); SetWindowLong(p_hwnd, GWL_STYLE, GetWindowLong(p_hwnd, GWL_STYLE) ^ WS_THICKFRAME);
} }
} }
else { else {
SetWindowLong(p_hwnd, GWL_STYLE, s_dwStyle); SetWindowLong(p_hwnd, GWL_STYLE, g_dwStyle);
} }
} }

4
LEGO1/mxhashtable.h
View File

@ -185,8 +185,8 @@ inline void MxHashTable<T>::Resize()
break; break;
} }
MxHashTableNode<T>** new_table = new MxHashTableNode<T>*[m_numSlots]; MxHashTableNode<T>** newTable = new MxHashTableNode<T>*[m_numSlots];
m_slots = new_table; m_slots = newTable;
memset(m_slots, 0, sizeof(MxHashTableNode<T>*) * m_numSlots); memset(m_slots, 0, sizeof(MxHashTableNode<T>*) * m_numSlots);
this->m_count = 0; this->m_count = 0;

2
LEGO1/mxlist.h
View File

@ -70,7 +70,7 @@ class MxList : protected MxCollection<T> {
MxListEntry<T>* m_first; // 0x10 MxListEntry<T>* m_first; // 0x10
MxListEntry<T>* m_last; // 0x14 MxListEntry<T>* m_last; // 0x14
void DeleteEntry(MxListEntry<T>* match); void DeleteEntry(MxListEntry<T>*);
MxListEntry<T>* InsertEntry(T, MxListEntry<T>*, MxListEntry<T>*); MxListEntry<T>* InsertEntry(T, MxListEntry<T>*, MxListEntry<T>*);
}; };

22
LEGO1/mxmusicmanager.cpp
View File

@ -29,14 +29,14 @@ void MxMusicManager::Init()
// FUNCTION: LEGO1 0x100c06a0 // FUNCTION: LEGO1 0x100c06a0
void MxMusicManager::InitData() void MxMusicManager::InitData()
{ {
m_MIDIStreamH = 0; m_midiStreamH = 0;
m_MIDIInitialized = FALSE; m_midiInitialized = FALSE;
m_unk0x38 = 0; m_unk0x38 = 0;
m_unk0x3c = 0; m_unk0x3c = 0;
m_unk0x40 = 0; m_unk0x40 = 0;
m_unk0x44 = 0; m_unk0x44 = 0;
m_unk0x48 = 0; m_unk0x48 = 0;
m_MIDIHdrP = NULL; m_midiHdrP = NULL;
} }
// FUNCTION: LEGO1 0x100c06c0 // FUNCTION: LEGO1 0x100c06c0
@ -66,7 +66,7 @@ void MxMusicManager::Destroy(MxBool p_fromDestructor)
void MxMusicManager::SetMIDIVolume() void MxMusicManager::SetMIDIVolume()
{ {
MxS32 result = (m_volume * m_multiplier) / 0x64; MxS32 result = (m_volume * m_multiplier) / 0x64;
HMIDISTRM streamHandle = m_MIDIStreamH; HMIDISTRM streamHandle = m_midiStreamH;
if (streamHandle) { if (streamHandle) {
MxS32 volume = CalculateVolume(result); MxS32 volume = CalculateVolume(result);
@ -148,13 +148,13 @@ void MxMusicManager::DeinitializeMIDI()
{ {
m_criticalSection.Enter(); m_criticalSection.Enter();
if (m_MIDIInitialized) { if (m_midiInitialized) {
m_MIDIInitialized = FALSE; m_midiInitialized = FALSE;
midiStreamStop(m_MIDIStreamH); midiStreamStop(m_midiStreamH);
midiOutUnprepareHeader((HMIDIOUT) m_MIDIStreamH, m_MIDIHdrP, sizeof(MIDIHDR)); midiOutUnprepareHeader((HMIDIOUT) m_midiStreamH, m_midiHdrP, sizeof(MIDIHDR));
midiOutSetVolume((HMIDIOUT) m_MIDIStreamH, m_MIDIVolume); midiOutSetVolume((HMIDIOUT) m_midiStreamH, m_midiVolume);
midiStreamClose(m_MIDIStreamH); midiStreamClose(m_midiStreamH);
delete m_MIDIHdrP; delete m_midiHdrP;
InitData(); InitData();
} }

10
LEGO1/mxmusicmanager.h
View File

@ -15,7 +15,7 @@ class MxMusicManager : public MxAudioManager {
virtual void SetVolume(MxS32 p_volume) override; // vtable+2c virtual void SetVolume(MxS32 p_volume) override; // vtable+2c
virtual MxResult Create(MxU32 p_frequencyMS, MxBool p_createThread); // vtable+30 virtual MxResult Create(MxU32 p_frequencyMS, MxBool p_createThread); // vtable+30
inline MxBool GetMIDIInitialized() { return m_MIDIInitialized; } inline MxBool GetMIDIInitialized() { return m_midiInitialized; }
void DeinitializeMIDI(); void DeinitializeMIDI();
undefined4 FUN_100c09c0(MxU8* p_data, MxS32 p_loopCount); undefined4 FUN_100c09c0(MxU8* p_data, MxS32 p_loopCount);
@ -27,16 +27,16 @@ class MxMusicManager : public MxAudioManager {
MxS32 CalculateVolume(MxS32 p_volume); MxS32 CalculateVolume(MxS32 p_volume);
void SetMIDIVolume(); void SetMIDIVolume();
HMIDISTRM m_MIDIStreamH; // 0x30 HMIDISTRM m_midiStreamH; // 0x30
MxBool m_MIDIInitialized; // 0x34 MxBool m_midiInitialized; // 0x34
undefined4 m_unk0x38; // 0x38 undefined4 m_unk0x38; // 0x38
undefined4 m_unk0x3c; // 0x3c undefined4 m_unk0x3c; // 0x3c
undefined4 m_unk0x40; // 0x40 undefined4 m_unk0x40; // 0x40
undefined4 m_unk0x44; // 0x44 undefined4 m_unk0x44; // 0x44
undefined4 m_unk0x48; // 0x48 undefined4 m_unk0x48; // 0x48
MIDIHDR* m_MIDIHdrP; // 0x4c MIDIHDR* m_midiHdrP; // 0x4c
MxS32 m_multiplier; // 0x50 MxS32 m_multiplier; // 0x50
DWORD m_MIDIVolume; // 0x54 DWORD m_midiVolume; // 0x54
protected: protected:
void Init(); void Init();

36
LEGO1/mxomni.cpp
View File

@ -33,8 +33,8 @@ void DeleteObjects(MxAtomId* p_id, MxS32 p_first, MxS32 p_last)
action.SetAtomId(*p_id); action.SetAtomId(*p_id);
action.SetUnknown24(-2); action.SetUnknown24(-2);
for (MxS32 l_first = p_first, l_last = p_last; l_first <= l_last; l_first++) { for (MxS32 first = p_first, last = p_last; first <= last; first++) {
action.SetObjectId(l_first); action.SetObjectId(first);
DeleteObject(action); DeleteObject(action);
} }
} }
@ -159,43 +159,43 @@ void MxOmni::Init()
} }
// FUNCTION: LEGO1 0x100af0b0 // FUNCTION: LEGO1 0x100af0b0
void MxOmni::SetInstance(MxOmni* instance) void MxOmni::SetInstance(MxOmni* p_instance)
{ {
g_instance = instance; g_instance = p_instance;
} }
// FUNCTION: LEGO1 0x100af0c0 // FUNCTION: LEGO1 0x100af0c0
MxResult MxOmni::Create(MxOmniCreateParam& p) MxResult MxOmni::Create(MxOmniCreateParam& p_param)
{ {
MxResult result = FAILURE; MxResult result = FAILURE;
if (!(m_atomIdCounterSet = new MxAtomIdCounterSet())) if (!(m_atomIdCounterSet = new MxAtomIdCounterSet()))
goto done; goto done;
m_mediaPath = p.GetMediaPath(); m_mediaPath = p_param.GetMediaPath();
m_windowHandle = p.GetWindowHandle(); m_windowHandle = p_param.GetWindowHandle();
if (p.CreateFlags().CreateObjectFactory()) { if (p_param.CreateFlags().CreateObjectFactory()) {
if (!(m_objectFactory = new MxObjectFactory())) if (!(m_objectFactory = new MxObjectFactory()))
goto done; goto done;
} }
if (p.CreateFlags().CreateVariableTable()) { if (p_param.CreateFlags().CreateVariableTable()) {
if (!(m_variableTable = new MxVariableTable())) if (!(m_variableTable = new MxVariableTable()))
goto done; goto done;
} }
if (p.CreateFlags().CreateTimer()) { if (p_param.CreateFlags().CreateTimer()) {
if (!(m_timer = new MxTimer())) if (!(m_timer = new MxTimer()))
goto done; goto done;
} }
if (p.CreateFlags().CreateTickleManager()) { if (p_param.CreateFlags().CreateTickleManager()) {
if (!(m_tickleManager = new MxTickleManager())) if (!(m_tickleManager = new MxTickleManager()))
goto done; goto done;
} }
if (p.CreateFlags().CreateNotificationManager()) { if (p_param.CreateFlags().CreateNotificationManager()) {
if (m_notificationManager = new MxNotificationManager()) { if (m_notificationManager = new MxNotificationManager()) {
if (m_notificationManager->Create(100, 0) != SUCCESS) if (m_notificationManager->Create(100, 0) != SUCCESS)
goto done; goto done;
@ -204,21 +204,21 @@ MxResult MxOmni::Create(MxOmniCreateParam& p)
goto done; goto done;
} }
if (p.CreateFlags().CreateStreamer()) { if (p_param.CreateFlags().CreateStreamer()) {
if (!(m_streamer = new MxStreamer()) || m_streamer->Create() != SUCCESS) if (!(m_streamer = new MxStreamer()) || m_streamer->Create() != SUCCESS)
goto done; goto done;
} }
if (p.CreateFlags().CreateVideoManager()) { if (p_param.CreateFlags().CreateVideoManager()) {
if (m_videoManager = new MxVideoManager()) { if (m_videoManager = new MxVideoManager()) {
if (m_videoManager->Create(p.GetVideoParam(), 100, 0) != SUCCESS) { if (m_videoManager->Create(p_param.GetVideoParam(), 100, 0) != SUCCESS) {
delete m_videoManager; delete m_videoManager;
m_videoManager = NULL; m_videoManager = NULL;
} }
} }
} }
if (p.CreateFlags().CreateSoundManager()) { if (p_param.CreateFlags().CreateSoundManager()) {
if (m_soundManager = new MxSoundManager()) { if (m_soundManager = new MxSoundManager()) {
if (m_soundManager->Create(10, 0) != SUCCESS) { if (m_soundManager->Create(10, 0) != SUCCESS) {
delete m_soundManager; delete m_soundManager;
@ -227,7 +227,7 @@ MxResult MxOmni::Create(MxOmniCreateParam& p)
} }
} }
if (p.CreateFlags().CreateMusicManager()) { if (p_param.CreateFlags().CreateMusicManager()) {
if (m_musicManager = new MxMusicManager()) { if (m_musicManager = new MxMusicManager()) {
if (m_musicManager->Create(50, 0) != SUCCESS) { if (m_musicManager->Create(50, 0) != SUCCESS) {
delete m_musicManager; delete m_musicManager;
@ -236,7 +236,7 @@ MxResult MxOmni::Create(MxOmniCreateParam& p)
} }
} }
if (p.CreateFlags().CreateEventManager()) { if (p_param.CreateFlags().CreateEventManager()) {
if (m_eventManager = new MxEventManager()) { if (m_eventManager = new MxEventManager()) {
if (m_eventManager->Create(50, 0) != SUCCESS) { if (m_eventManager->Create(50, 0) != SUCCESS) {
delete m_eventManager; delete m_eventManager;

4
LEGO1/mxomni.h
View File

@ -41,7 +41,7 @@ class MxOmni : public MxCore {
virtual MxLong Notify(MxParam& p_param) override; // vtable+04 virtual MxLong Notify(MxParam& p_param) override; // vtable+04
virtual void Init(); // vtable+14 virtual void Init(); // vtable+14
virtual MxResult Create(MxOmniCreateParam& p); // vtable+18 virtual MxResult Create(MxOmniCreateParam& p_param); // vtable+18
virtual void Destroy(); // vtable+1c virtual void Destroy(); // vtable+1c
virtual MxResult Start(MxDSAction* p_dsAction); // vtable+20 virtual MxResult Start(MxDSAction* p_dsAction); // vtable+20
virtual MxResult DeleteObject(MxDSAction& p_dsAction); // vtable+24 virtual MxResult DeleteObject(MxDSAction& p_dsAction); // vtable+24
@ -52,7 +52,7 @@ class MxOmni : public MxCore {
virtual void StartTimer(); // vtable+38 virtual void StartTimer(); // vtable+38
virtual void StopTimer(); // vtable+3c virtual void StopTimer(); // vtable+3c
virtual MxBool IsTimerRunning(); // vtable+40 virtual MxBool IsTimerRunning(); // vtable+40
static void SetInstance(MxOmni* instance); static void SetInstance(MxOmni* p_instance);
HWND GetWindowHandle() const { return this->m_windowHandle; } HWND GetWindowHandle() const { return this->m_windowHandle; }
MxObjectFactory* GetObjectFactory() const { return this->m_objectFactory; } MxObjectFactory* GetObjectFactory() const { return this->m_objectFactory; }
MxNotificationManager* GetNotificationManager() const { return this->m_notificationManager; } MxNotificationManager* GetNotificationManager() const { return this->m_notificationManager; }

46
LEGO1/mxomnicreateflags.h
View File

@ -35,60 +35,60 @@ class MxOmniCreateFlags {
inline const MxBool CreateTimer() const { return this->m_flags2 & Flag_CreateTimer; } inline const MxBool CreateTimer() const { return this->m_flags2 & Flag_CreateTimer; }
inline const MxBool CreateStreamer() const { return this->m_flags2 & Flag_CreateStreamer; } inline const MxBool CreateStreamer() const { return this->m_flags2 & Flag_CreateStreamer; }
inline void CreateObjectFactory(MxBool b) inline void CreateObjectFactory(MxBool p_enable)
{ {
this->m_flags1 = this->m_flags1 =
(b == TRUE ? this->m_flags1 | Flag_CreateObjectFactory : this->m_flags1 & ~Flag_CreateObjectFactory); (p_enable ? this->m_flags1 | Flag_CreateObjectFactory : this->m_flags1 & ~Flag_CreateObjectFactory);
} }
inline void CreateVariableTable(MxBool b) inline void CreateVariableTable(MxBool p_enable)
{ {
this->m_flags1 = this->m_flags1 =
(b == TRUE ? this->m_flags1 | Flag_CreateVariableTable : this->m_flags1 & ~Flag_CreateVariableTable); (p_enable ? this->m_flags1 | Flag_CreateVariableTable : this->m_flags1 & ~Flag_CreateVariableTable);
} }
inline void CreateTickleManager(MxBool b) inline void CreateTickleManager(MxBool p_enable)
{ {
this->m_flags1 = this->m_flags1 =
(b == TRUE ? this->m_flags1 | Flag_CreateTickleManager : this->m_flags1 & ~Flag_CreateTickleManager); (p_enable ? this->m_flags1 | Flag_CreateTickleManager : this->m_flags1 & ~Flag_CreateTickleManager);
} }
inline void CreateNotificationManager(MxBool b) inline void CreateNotificationManager(MxBool p_enable)
{ {
this->m_flags1 = this->m_flags1 =
(b == TRUE ? this->m_flags1 | Flag_CreateNotificationManager (p_enable ? this->m_flags1 | Flag_CreateNotificationManager
: this->m_flags1 & ~Flag_CreateNotificationManager); : this->m_flags1 & ~Flag_CreateNotificationManager);
} }
inline void CreateVideoManager(MxBool b) inline void CreateVideoManager(MxBool p_enable)
{ {
this->m_flags1 = this->m_flags1 =
(b == TRUE ? this->m_flags1 | Flag_CreateVideoManager : this->m_flags1 & ~Flag_CreateVideoManager); (p_enable ? this->m_flags1 | Flag_CreateVideoManager : this->m_flags1 & ~Flag_CreateVideoManager);
} }
inline void CreateSoundManager(MxBool b) inline void CreateSoundManager(MxBool p_enable)
{ {
this->m_flags1 = this->m_flags1 =
(b == TRUE ? this->m_flags1 | Flag_CreateSoundManager : this->m_flags1 & ~Flag_CreateSoundManager); (p_enable ? this->m_flags1 | Flag_CreateSoundManager : this->m_flags1 & ~Flag_CreateSoundManager);
} }
inline void CreateMusicManager(MxBool b) inline void CreateMusicManager(MxBool p_enable)
{ {
this->m_flags1 = this->m_flags1 =
(b == TRUE ? this->m_flags1 | Flag_CreateMusicManager : this->m_flags1 & ~Flag_CreateMusicManager); (p_enable ? this->m_flags1 | Flag_CreateMusicManager : this->m_flags1 & ~Flag_CreateMusicManager);
} }
inline void CreateEventManager(MxBool b) inline void CreateEventManager(MxBool p_enable)
{ {
this->m_flags1 = this->m_flags1 =
(b == TRUE ? this->m_flags1 | Flag_CreateEventManager : this->m_flags1 & ~Flag_CreateEventManager); (p_enable ? this->m_flags1 | Flag_CreateEventManager : this->m_flags1 & ~Flag_CreateEventManager);
} }
inline void CreateTimer(MxBool b) inline void CreateTimer(MxBool p_enable)
{ {
this->m_flags2 = (b == TRUE ? this->m_flags2 | Flag_CreateTimer : this->m_flags2 & ~Flag_CreateTimer); this->m_flags2 = (p_enable ? this->m_flags2 | Flag_CreateTimer : this->m_flags2 & ~Flag_CreateTimer);
} }
inline void CreateStreamer(MxBool b) inline void CreateStreamer(MxBool p_enable)
{ {
this->m_flags2 = (b == TRUE ? this->m_flags2 | Flag_CreateStreamer : this->m_flags2 & ~Flag_CreateStreamer); this->m_flags2 = (p_enable ? this->m_flags2 | Flag_CreateStreamer : this->m_flags2 & ~Flag_CreateStreamer);
} }
private: private:
unsigned char m_flags1; MxU8 m_flags1;
unsigned char m_flags2; MxU8 m_flags2;
}; };
#endif // MXOMNICREATEFLAGS_H #endif // MXOMNICREATEFLAGS_H

16
LEGO1/mxomnicreateparam.cpp
View File

@ -2,14 +2,14 @@
// FUNCTION: LEGO1 0x100b0b00 // FUNCTION: LEGO1 0x100b0b00
MxOmniCreateParam::MxOmniCreateParam( MxOmniCreateParam::MxOmniCreateParam(
const char* mediaPath, const char* p_mediaPath,
struct HWND__* windowHandle, struct HWND__* p_windowHandle,
MxVideoParam& vparam, MxVideoParam& p_vparam,
MxOmniCreateFlags flags MxOmniCreateFlags p_flags
) )
{ {
this->m_mediaPath = mediaPath; this->m_mediaPath = p_mediaPath;
this->m_windowHandle = (HWND) windowHandle; this->m_windowHandle = (HWND) p_windowHandle;
this->m_videoParam = vparam; this->m_videoParam = p_vparam;
this->m_createFlags = flags; this->m_createFlags = p_flags;
} }

8
LEGO1/mxomnicreateparam.h
View File

@ -11,10 +11,10 @@
class MxOmniCreateParam : public MxParam { class MxOmniCreateParam : public MxParam {
public: public:
__declspec(dllexport) MxOmniCreateParam( __declspec(dllexport) MxOmniCreateParam(
const char* mediaPath, const char* p_mediaPath,
struct HWND__* windowHandle, struct HWND__* p_windowHandle,
MxVideoParam& vparam, MxVideoParam& p_vparam,
MxOmniCreateFlags flags MxOmniCreateFlags p_flags
); );
MxOmniCreateFlags& CreateFlags() { return this->m_createFlags; } MxOmniCreateFlags& CreateFlags() { return this->m_createFlags; }

16
LEGO1/mxpalette.cpp
View File

@ -198,13 +198,13 @@ MxResult MxPalette::SetEntries(LPPALETTEENTRY p_entries)
} }
// FUNCTION: LEGO1 0x100bf2d0 // FUNCTION: LEGO1 0x100bf2d0
MxResult MxPalette::SetSkyColor(LPPALETTEENTRY p_sky_color) MxResult MxPalette::SetSkyColor(LPPALETTEENTRY p_skyColor)
{ {
MxResult status = 0; MxResult status = 0;
if (this->m_palette != NULL) { if (this->m_palette != NULL) {
this->m_entries[141].peRed = p_sky_color->peRed; this->m_entries[141].peRed = p_skyColor->peRed;
this->m_entries[141].peGreen = p_sky_color->peGreen; this->m_entries[141].peGreen = p_skyColor->peGreen;
this->m_entries[141].peBlue = p_sky_color->peBlue; this->m_entries[141].peBlue = p_skyColor->peBlue;
this->m_skyColor = this->m_entries[141]; this->m_skyColor = this->m_entries[141];
if (this->m_palette->SetEntries(0, 141, 1, &this->m_skyColor)) { if (this->m_palette->SetEntries(0, 141, 1, &this->m_skyColor)) {
status = -1; status = -1;
@ -220,14 +220,14 @@ void MxPalette::Detach()
} }
// FUNCTION: LEGO1 0x100bf340 // FUNCTION: LEGO1 0x100bf340
MxBool MxPalette::operator==(MxPalette& other) MxBool MxPalette::operator==(MxPalette& p_other)
{ {
for (MxS32 i = 0; i < 256; i++) { for (MxS32 i = 0; i < 256; i++) {
if (this->m_entries[i].peRed != other.m_entries[i].peRed) if (this->m_entries[i].peRed != p_other.m_entries[i].peRed)
return FALSE; return FALSE;
if (this->m_entries[i].peGreen != other.m_entries[i].peGreen) if (this->m_entries[i].peGreen != p_other.m_entries[i].peGreen)
return FALSE; return FALSE;
if (this->m_entries[i].peBlue != other.m_entries[i].peBlue) if (this->m_entries[i].peBlue != p_other.m_entries[i].peBlue)
return FALSE; return FALSE;
} }
return TRUE; return TRUE;

4
LEGO1/mxpalette.h
View File

@ -10,7 +10,7 @@
// SIZE 0x414 // SIZE 0x414
class MxPalette : public MxCore { class MxPalette : public MxCore {
public: public:
__declspec(dllexport) MxBool operator==(MxPalette&); __declspec(dllexport) MxBool operator==(MxPalette& p_other);
__declspec(dllexport) void Detach(); __declspec(dllexport) void Detach();
MxPalette(); MxPalette();
@ -22,7 +22,7 @@ class MxPalette : public MxCore {
void GetDefaultPalette(LPPALETTEENTRY p_entries); void GetDefaultPalette(LPPALETTEENTRY p_entries);
MxResult GetEntries(LPPALETTEENTRY p_entries); MxResult GetEntries(LPPALETTEENTRY p_entries);
MxResult SetEntries(LPPALETTEENTRY p_palette); MxResult SetEntries(LPPALETTEENTRY p_palette);
MxResult SetSkyColor(LPPALETTEENTRY p_sky_color); MxResult SetSkyColor(LPPALETTEENTRY p_skyColor);
void Reset(MxBool p_ignoreSkyColor); void Reset(MxBool p_ignoreSkyColor);
LPDIRECTDRAWPALETTE CreateNativePalette(); LPDIRECTDRAWPALETTE CreateNativePalette();
inline void SetOverrideSkyColor(MxBool p_value) { this->m_overrideSkyColor = p_value; } inline void SetOverrideSkyColor(MxBool p_value) { this->m_overrideSkyColor = p_value; }

12
LEGO1/mxpresenter.cpp
View File

@ -169,15 +169,15 @@ void MxPresenter::ParseExtra()
memcpy(extraCopy, extraData, len); memcpy(extraCopy, extraData, len);
extraCopy[len] = '\0'; extraCopy[len] = '\0';
char t_worldValue[512]; char worldValue[512];
if (KeyValueStringParse(t_worldValue, g_strWORLD, extraCopy)) { if (KeyValueStringParse(worldValue, g_strWORLD, extraCopy)) {
char* token = strtok(t_worldValue, g_parseExtraTokens); char* token = strtok(worldValue, g_parseExtraTokens);
char t_token[256]; char buf[256];
strcpy(t_token, token); strcpy(buf, token);
token = strtok(NULL, g_parseExtraTokens); token = strtok(NULL, g_parseExtraTokens);
MxS32 val = token ? atoi(token) : 0; MxS32 val = token ? atoi(token) : 0;
MxEntity* result = MxOmni::GetInstance()->FindWorld(t_token, val, this); MxEntity* result = MxOmni::GetInstance()->FindWorld(buf, val, this);
m_action->SetFlags(m_action->GetFlags() | MxDSAction::Flag_World); m_action->SetFlags(m_action->GetFlags() | MxDSAction::Flag_World);

4
LEGO1/mxqueue.h
View File

@ -13,13 +13,13 @@ class MxQueue : public MxList<T> {
MxBool Dequeue(T& p_obj) MxBool Dequeue(T& p_obj)
{ {
MxBool has_next = (m_first != NULL); MxBool hasNext = (m_first != NULL);
if (m_first) { if (m_first) {
p_obj = m_first->GetValue(); p_obj = m_first->GetValue();
DeleteEntry(m_first); DeleteEntry(m_first);
} }
return has_next; return hasNext;
} }
}; };

4
LEGO1/mxrect32.h
View File

@ -75,8 +75,8 @@ class MxRect32 {
inline void SetBottom(MxS32 p_bottom) { m_bottom = p_bottom; } inline void SetBottom(MxS32 p_bottom) { m_bottom = p_bottom; }
private: private:
inline static MxS32 Min(MxS32 a, MxS32 b) { return a <= b ? a : b; }; inline static MxS32 Min(MxS32 p_a, MxS32 p_b) { return p_a <= p_b ? p_a : p_b; };
inline static MxS32 Max(MxS32 a, MxS32 b) { return a <= b ? b : a; }; inline static MxS32 Max(MxS32 p_a, MxS32 p_b) { return p_a <= p_b ? p_b : p_a; };
MxS32 m_left; MxS32 m_left;
MxS32 m_top; MxS32 m_top;

2
LEGO1/mxregion.h
View File

@ -9,7 +9,7 @@
// SIZE 0x0c // SIZE 0x0c
struct MxRegionTopBottom { struct MxRegionTopBottom {
MxRegionTopBottom(MxRect32& p_rect); MxRegionTopBottom(MxRect32& p_rect);
MxRegionTopBottom(MxS32 m_top, MxS32 m_bottom); MxRegionTopBottom(MxS32 p_top, MxS32 p_bottom);
MxRegionTopBottom* Clone(); MxRegionTopBottom* Clone();
void FUN_100c5280(MxS32 p_left, MxS32 p_right); void FUN_100c5280(MxS32 p_left, MxS32 p_right);

6
LEGO1/mxsoundmanager.cpp
View File

@ -171,11 +171,11 @@ MxPresenter* MxSoundManager::FUN_100aebd0(const MxAtomId& p_atomId, MxU32 p_obje
} }
// FUNCTION: LEGO1 0x100aecf0 // FUNCTION: LEGO1 0x100aecf0
MxS32 MxSoundManager::FUN_100aecf0(MxU32 p_unk) MxS32 MxSoundManager::FUN_100aecf0(MxU32 p_undefined)
{ {
if (!p_unk) if (!p_undefined)
return -10000; return -10000;
return g_mxcoreCount[p_unk]; return g_mxcoreCount[p_undefined];
} }
// FUNCTION: LEGO1 0x100aed10 // FUNCTION: LEGO1 0x100aed10

2
LEGO1/mxsoundmanager.h
View File

@ -22,7 +22,7 @@ class MxSoundManager : public MxAudioManager {
inline LPDIRECTSOUND GetDirectSound() { return m_directSound; } inline LPDIRECTSOUND GetDirectSound() { return m_directSound; }
MxS32 FUN_100aecf0(MxU32 p_unk); MxS32 FUN_100aecf0(MxU32 p_undefined);
private: private:
void Init(); void Init();