Adjusted the Lock Flags menu to allow for locking each type of flag individually

Author: Zephiles

ttyd-tools/rel/include/global.h

@@ -119,8 +119,14 @@ enum CHEATS_RESOLVE_FADES_RETURN_VALUES
 
 enum CHEATS_LOCK_FLAGS_SELECTION
 {
-	LOCK_CURRENT_FLAGS = 1,
-	SET_NEW_AREA,
+	LOCK_GSW_FLAGS = 1,
+	LOCK_GSWF_FLAGS,
+	LOCK_GW_FLAGS,
+	LOCK_GF_FLAGS,
+	LOCK_LSW_FLAGS,
+	LOCK_LSWF_FLAGS,
+	SET_NEW_LSW_AREA,
+	SET_NEW_LSWF_AREA,
 };
 
 enum CHEATS_MANAGE_FLAGS_SELECTION
@@ -600,8 +606,20 @@ struct ClearCacheForBattlesStruct
 
 struct LockFlagsStruct
 {
-	uint8_t *FlagsToLockMemory;
-	char AreaLocked[4]; // 3 bytes for the area, 1 byte for NULL
+	/*
+	uint8_t *GSWsMemory; // 0x800
+	uint8_t *GSWFsMemory; // 0x400
+	uint8_t *GWsMemory; // 0x80
+	uint8_t *GFsMemory; // 0xC
+	uint8_t *LSWsMemory; // 0x400
+	uint8_t *LSWFsMemory; // 0x40
+	*/
+	
+	bool MemoryRegionLocked[6];
+	uint8_t *MemoryRegion[6];
+	uint32_t SequencePosition;
+	char LSWsAreaLocked[4]; // 3 bytes for the area, 1 byte for NULL
+	char LSWFsAreaLocked[4]; // 3 bytes for the area, 1 byte for NULL
 };
 
 struct TrickDisplay

ttyd-tools/rel/include/menufunctions.h

@@ -23,6 +23,9 @@ void raiseSystemLevel();
 void lowerSystemLevel();
 
 void partnerMenuRemoveOrBringOut(void *partnerEnabledAddress);
+bool lockFlagsMenuBackUpStandardFlags(bool &flag, uint8_t *&memoryRegion, uint32_t size, uint32_t offset);
+bool lockFlagsMenuBackUpGWOrGFFlags(bool &flag, uint8_t *&dstMemoryRegion, void *srcMemoryRegion, uint32_t size);
+bool lockFlagsMenuSetNewArea(bool flag, uint8_t *memoryRegion, char *area, uint32_t size, uint32_t offset);
 const char *getItemName(int16_t item);
 void *getFreeSlotPointer();
 int32_t getTotalItems();

ttyd-tools/rel/source/codes.cpp

@@ -831,36 +831,110 @@ void checkIfAreaFlagsShouldBeCleared()
 	}
 }
 
-void lockFlags()
+void lockFlagsStandard(bool flag, uint8_t *memoryRegion, uint32_t size, uint32_t offset)
 {
-	if (!Cheat[LOCK_FLAGS].Active)
+	if (!flag)
 	{
 		return;
 	}
 
-	uint8_t *tempFlagsToLockMemory = LockFlags.FlagsToLockMemory;
-	if (!tempFlagsToLockMemory)
+	if (!memoryRegion)
 	{
 		return;
 	}
 
+	// Restore the memory
 	uint32_t GlobalWorkPtrRaw = reinterpret_cast<uint32_t>(ttyd::mariost::globalWorkPointer);
+	void *MemoryStart = reinterpret_cast<void *>(GlobalWorkPtrRaw + offset);
+	memcpy(MemoryStart, memoryRegion, size);
+}
+
+void lockFlagsGWsOrGFs(bool flag, void *dstMemoryRegion, uint8_t *srcMemoryRegion, uint32_t size)
+{
+	if (!flag)
+	{
+		return;
+	}
 
-	// Restore the GSWFs
-	void *GSWFsAddresses = reinterpret_cast<void *>(GlobalWorkPtrRaw + 0x178);
-	memcpy(GSWFsAddresses, tempFlagsToLockMemory, 0x400);
+	if (!dstMemoryRegion)
+	{
+		return;
+	}
 
-	// Restore the GFs
-	ttyd::evtmgr::EvtWork *EventWork = ttyd::evtmgr::evtGetWork();
-	memcpy(EventWork->gfData, &tempFlagsToLockMemory[0x440], sizeof(EventWork->gfData));
+	memcpy(dstMemoryRegion, srcMemoryRegion, size);
+}
+
+void lockFlagsLSWsOrLSWFs(char *area, bool flag, uint8_t *memoryRegion, uint32_t size, uint32_t offset)
+{
+	if (!flag)
+	{
+		return;
+	}
 
-	// Restore the LSWFs
 	// Only restore if currently in the original area where the code was enabled
-	if (compareStrings(LockFlags.AreaLocked, ttyd::seq_mapchange::NextArea))
+	if (!compareStrings(area, ttyd::seq_mapchange::NextArea))
 	{
-		void *LSWFsAddresses = reinterpret_cast<void *>(GlobalWorkPtrRaw + 0xD78);
-		memcpy(LSWFsAddresses, &tempFlagsToLockMemory[0x400], 0x40);
+		return;
 	}
+	
+	lockFlagsStandard(flag, memoryRegion, size, offset);
+}
+
+void lockFlags()
+{
+	uint32_t Index = 0;
+	
+	// Restore the GSWs
+	uint32_t Size = 0x800;
+	uint32_t Offset = 0x578;
+	bool tempFlag = LockFlags.MemoryRegionLocked[Index];
+	lockFlagsStandard(tempFlag, LockFlags.MemoryRegion[Index], Size, Offset);
+	
+	// Restore the Sequence Position if the code is enabled
+	if (tempFlag)
+	{
+		setSequencePosition(LockFlags.SequencePosition);
+	}
+	Index++;
+	
+	// Restore the GSWFs
+	Size = 0x400;
+	Offset = 0x178;
+	lockFlagsStandard(LockFlags.MemoryRegionLocked[Index], LockFlags.MemoryRegion[Index], Size, Offset);
+	Index++;
+	
+	// Restore the GWs
+	ttyd::evtmgr::EvtWork *EventWork = ttyd::evtmgr::evtGetWork();
+	Size = 0x80;
+	lockFlagsGWsOrGFs(LockFlags.MemoryRegionLocked[Index], EventWork->gwData, LockFlags.MemoryRegion[Index], Size);
+	Index++;
+	
+	// Restore the GFs
+	Size = 0xC;
+	lockFlagsGWsOrGFs(LockFlags.MemoryRegionLocked[Index], EventWork->gfData, LockFlags.MemoryRegion[Index], Size);
+	Index++;
+	
+	// Restore the LSWs
+	Size = 0x400;
+	Offset = 0xDB8;
+	
+	lockFlagsLSWsOrLSWFs(LockFlags.LSWsAreaLocked, 
+		LockFlags.MemoryRegionLocked[Index], 
+		LockFlags.MemoryRegion[Index], 
+		Size, 
+		Offset);
+	
+	Index++;
+	
+	// Restore the LSWFs
+	Size = 0x40;
+	Offset = 0xD78;
+	
+	lockFlagsLSWsOrLSWFs(LockFlags.LSWFsAreaLocked, 
+		LockFlags.MemoryRegionLocked[Index], 
+		LockFlags.MemoryRegion[Index], 
+		Size, 
+		Offset);
 }
 
 void displaySequenceInPauseMenu()

ttyd-tools/rel/source/draw.cpp

@@ -3075,42 +3075,73 @@ void drawCheatsResolveFades()
 
 void drawCheatsLockFlags()
 {
-	// Draw the text indicating which area has its flags locked
-	uint32_t Color = 0xFFFFFFFF;
+	// Draw the Yes/No text for each option
 	uint8_t Alpha = 0xFF;
 	int32_t PosX = -232;
-	int32_t PosY = 60;
+	int32_t PosY = 180;
 	float Scale = 0.6;
+	uint32_t Color;
 
-	const char *String = "Current Area Local Flags Locked";
-	drawText(String, PosX, PosY, Alpha, Color, Scale);
-	PosY -= 20;
-	
-	// Get the text for which area has its flags locked
-	char CurrentAreaLockedText[64];
-	char *tempAreaLockedText = LockFlags.AreaLocked;
+	const char *String;
 
-	// Make sure the current area with its flags locked is valid
-	if (!Cheat[LOCK_FLAGS].Active || tempAreaLockedText[0] == '\0')
+	uint32_t Size = sizeof(LockFlags.MemoryRegionLocked) / sizeof(LockFlags.MemoryRegionLocked[0]);
+	for (uint32_t i = 0; i < Size; i++)
 	{
-		strcpy(CurrentAreaLockedText, "None");
+		getYesNoTextAndColor(LockFlags.MemoryRegionLocked[i], &String, &Color);
+		drawText(String, PosX + 120, PosY, Alpha, Color, Scale);
+		PosY -= 20;
 	}
-	else
+	PosY -= 60;
+	
+	auto getAreaText = [](char *stringOut, char *areaLocked, bool flag)
 	{
-		strcpy(CurrentAreaLockedText, tempAreaLockedText);
-		
-		// Check to see if the current area is one that can have its flags cleared
-		const char **tempAreaText = CheatsClearAreaFlagsAreas;
-		uint32_t Size = CheatsClearAreaFlagsAreasSize;
-		for (uint32_t i = 0; i < Size; i++)
+		// Make sure the current area with its flags locked is valid
+		if (!flag || areaLocked[0] == '\0')
 		{
-			if (compareStrings(tempAreaLockedText, tempAreaText[i]))
+			strcpy(stringOut, "None");
+			return static_cast<uint32_t>(0x4B4B4BFF);
+		}
+		else
+		{
+			strcpy(stringOut, areaLocked);
+			
+			// Check to see if the current area is one that can have its flags cleared
+			const char **tempAreaText = CheatsClearAreaFlagsAreas;
+			uint32_t Size = CheatsClearAreaFlagsAreasSize;
+			for (uint32_t i = 0; i < Size; i++)
 			{
-				strcpy(CurrentAreaLockedText, CheatsClearAreaFlagsAreasFullNames[i]);
-				break;
+				if (compareStrings(areaLocked, tempAreaText[i]))
+				{
+					strcpy(stringOut, CheatsClearAreaFlagsAreasFullNames[i]);
+					break;
+				}
 			}
 		}
-	}
+		return static_cast<uint32_t>(0xFFFFFFFF);
+	};
+	
+	// Draw the text indicating which area has its LSW flags locked
+	Color = 0xFFFFFFFF;
+	String = "Current Area LSW Flags Locked";
+	drawText(String, PosX, PosY, Alpha, Color, Scale);
+	PosY -= 20;
+	
+	// Get the text for which area has its LSW flags locked
+	char CurrentAreaLockedText[64];
+	Color = getAreaText(CurrentAreaLockedText, LockFlags.LSWsAreaLocked, LockFlags.MemoryRegionLocked[4]);
+	
+	// Draw the text for which area has its flags locked
+	drawText(CurrentAreaLockedText, PosX, PosY, Alpha, Color, Scale);
+	PosY -= 40;
+	
+	// Draw the text indicating which area has its LSWF flags locked
+	Color = 0xFFFFFFFF;
+	String = "Current Area LSWF Flags Locked";
+	drawText(String, PosX, PosY, Alpha, Color, Scale);
+	PosY -= 20;
+	
+	// Get the text for which area has its LSWF flags locked
+	Color = getAreaText(CurrentAreaLockedText, LockFlags.LSWFsAreaLocked, LockFlags.MemoryRegionLocked[5]);
 
 	// Draw the text for which area has its flags locked
 	drawText(CurrentAreaLockedText, PosX, PosY, Alpha, Color, Scale);

ttyd-tools/rel/source/global.cpp

@@ -1017,8 +1017,14 @@ const char *CheatsManageGlobalWordsOptions[]
 
 const char *CheatsLockFlagsOptions[]
 {
-	"Toggle Value",
-	"Set New Area",
+	"Lock GSWs",
+	"Lock GSWFs",
+	"Lock GWs",
+	"Lock GFs",
+	"Lock LSWs",
+	"Lock LSWFs",
+	"Set New LSW Area",
+	"Set New LSWF Area",
 };
 
 const char *CheatsManageGlobalFlagsOptions[]

ttyd-tools/rel/source/memcard.cpp

@@ -323,15 +323,9 @@ int32_t saveSettings()
 	uint32_t CheatsSize = sizeof(Cheat) / sizeof(Cheat[0]);
 	for (uint32_t i = 0; i < CheatsSize; i++)
 	{
-		uint32_t CurrentIndex = CheatsOrder[i];
-		
-		// Don't update the bool for the Lock Flags code
-		if (CurrentIndex != LOCK_FLAGS)
-		{
-			Settings->CheatsActive[i] = Cheat[CurrentIndex].Active;
-		}
-		
-		Settings->CheatButtonCombos[i] = Cheat[CurrentIndex].ButtonCombo;
+		uint32_t CurrentIndex 			= CheatsOrder[i];
+		Settings->CheatsActive[i] 		= Cheat[CurrentIndex].Active;
+		Settings->CheatButtonCombos[i] 	= Cheat[CurrentIndex].ButtonCombo;
 	}
 
 	// Copy the Displays bools
@@ -447,13 +441,8 @@ int32_t loadSettings()
 	uint32_t CheatsSize = sizeof(Cheat) / sizeof(Cheat[0]);
 	for (uint32_t i = 0; i < CheatsSize; i++)
 	{
-		uint32_t CurrentIndex = CheatsOrder[i];
-		
-		// Don't update the bool for the Lock Flags code
-		if (CurrentIndex != LOCK_FLAGS)
-		{
-			Cheat[CurrentIndex].Active = Settings->CheatsActive[i];
-		}
+		uint32_t CurrentIndex 		= CheatsOrder[i];
+		Cheat[CurrentIndex].Active 	= Settings->CheatsActive[i];
 
 		// Make sure the button combo is valid, so that new button combos are not overwritten with 0
 		uint16_t ButtonCombo = Settings->CheatButtonCombos[i];