Use the smart heap in createCustomState and deleteCustomState to prevent fragmentation

Also added allocFromSmartHeap in global.cpp, and made loadSettings in memcard.cpp use it.

Author: Zephiles

ttyd-tools/rel/include/commonfunctions.h

@@ -3,6 +3,7 @@
 #include <gc/OSModule.h>
 #include <ttyd/seqdrv.h>
 #include <ttyd/npcdrv.h>
+#include <ttyd/memory.h>
 #include <ttyd/party.h>
 
 #include <cstdint>
@@ -41,6 +42,7 @@ bool compareStringsSize(const char *str1, const char *str2, size_t size);
 bool compareStringToNextMap(const char *str);
 void setSeqMapChange(const char *map, const char *bero);
 void *clearMemory(void *destination, std::size_t size);
+ttyd::memory::SmartAllocationData *allocFromSmartHeap(uint32_t size, uint32_t group);
 void *getPartnerPointer();
 void *getFollowerPointer();
 void removePartnerFromOverworld();

ttyd-tools/rel/include/global.h

@@ -1057,7 +1057,10 @@ struct ManageCustomStates
     bool StateWasSelected;
     uint8_t SelectedState;
 
-    // Do not inline createCustomState nor deleteCustomState
+    // Do not inline resizeStateMemory, createCustomState, nor deleteCustomState
+    CustomStateStruct *resizeStateMemory(
+        CustomStateStruct *state, uint32_t numEntries, int32_t incrementAmount);
+    
     char *createCustomState();
     uint32_t deleteCustomState(uint32_t stateIndex);
 };

ttyd-tools/rel/source/commonfunctions.cpp

@@ -2,6 +2,7 @@
 
 #include <gc/DEMOPad.h>
 #include <gc/OSModule.h>
+#include <gc/OSCache.h>
 #include <ttyd/system.h>
 #include <ttyd/seqdrv.h>
 #include <ttyd/mariost.h>
@@ -229,6 +230,22 @@ void *clearMemory(void *destination, std::size_t size)
     return memset(destination, 0, size);
 }
 
+ttyd::memory::SmartAllocationData *allocFromSmartHeap(uint32_t size, uint32_t group)
+{
+    // Allocate the memory
+    ttyd::memory::SmartAllocationData *SmartData = ttyd::memory::smartAlloc(size, group);
+    
+    // Set up a temporary local variable to use for getting memory
+    void *Ptr = SmartData->pMemory;
+    
+    // Clear the memory, as this is not done automatically
+    Ptr = clearMemory(Ptr, size);
+    
+    // Be 100% certain that no memory issues occur
+    gc::OSCache::DCFlushRange(Ptr, size);
+    return SmartData;
+}
+
 void *getPartnerPointer()
 {
     ttyd::party::PartySlotId Id = ttyd::mario_party::marioGetPartyId();

ttyd-tools/rel/source/global.cpp

@@ -2,8 +2,8 @@
 #include "memcard.h"
 
 #include <ttyd/msgdrv.h>
+#include <ttyd/memory.h>
 #include <ttyd/mario_pouch.h>
-#include <ttyd/mariost.h>
 #include <ttyd/mario.h>
 #include <ttyd/mario_motion.h>
 #include <ttyd/seq_mapchange.h>
@@ -2264,6 +2264,37 @@ void SetCustomText::customTextInit(const char *initialText, uint32_t maxTextSize
     }
 }
 
+CustomStateStruct * ManageCustomStates::resizeStateMemory(
+    CustomStateStruct *state, uint32_t numEntries, int32_t incrementAmount)
+{
+    uint32_t CurrentStatesSize = sizeof(CustomStateStruct) * numEntries;
+    
+    // Allocate temporary memory to hold the states
+    // Allocate the memory on the smart heap to avoid fragmentation
+    ttyd::memory::SmartAllocationData *SmartData = 
+        allocFromSmartHeap(CurrentStatesSize, 
+            ttyd::memory::SmartAllocationGroup::kNone);
+    
+    // Set up a temporary local variable to use for getting the memory
+    CustomStateStruct *tempStateSmart = reinterpret_cast<CustomStateStruct *>(SmartData->pMemory);
+    
+    // Copy the states from the old memory to the temporary memory
+    memcpy(tempStateSmart, state, CurrentStatesSize);
+    
+    // Free the old memory
+    delete[] (state);
+    
+    // Allocate new memory to hold the states
+    state = new CustomStateStruct[numEntries + incrementAmount];
+    
+    // Copy the states from the temporary memory to the new memory
+    memcpy(state, tempStateSmart, CurrentStatesSize);
+    
+    // Free the temporary memory
+    ttyd::memory::smartFree(SmartData);
+    return state;
+}
+
 char *ManageCustomStates::createCustomState()
 {
     uint32_t tempTotalEntries = TotalEntries;
@@ -2290,16 +2321,7 @@ char *ManageCustomStates::createCustomState()
     }
     else
     {
-        // Allocate new memory to hold the new state
-        CustomStateStruct *tempStateNew = new CustomStateStruct[tempTotalEntries + 1];
-        
-        // Copy the states from the old memory to the new memory
-        memcpy(tempStateNew, tempState, sizeof(CustomStateStruct) * tempTotalEntries);
-        
-        // Free the old memory
-        delete[] (tempState);
-        
-        tempState = tempStateNew;
+        tempState = resizeStateMemory(tempState, tempTotalEntries, 1);
         State = tempState;
 
         tempTotalEntries++;
@@ -2430,16 +2452,7 @@ uint32_t ManageCustomStates::deleteCustomState(uint32_t stateIndex)
             memcpy(&tempState[stateIndex], &tempState[stateIndex + 1], CopySize);
         }
 
-        // Allocate new memory to hold the states
-        CustomStateStruct *tempStateNew = new CustomStateStruct[tempTotalEntries];
-        
-        // Copy the states from the old memory to the new memory
-        uint32_t NewSize = sizeof(CustomStateStruct) * tempTotalEntries;
-        memcpy(tempStateNew, tempState, NewSize);
-        
-        // Free the old memory
-        delete[] (tempState);
-        State = tempStateNew;
+        State = resizeStateMemory(tempState, tempTotalEntries, 0);
     }
     else
     {

ttyd-tools/rel/source/memcard.cpp

@@ -3,7 +3,6 @@
 #include "commonfunctions.h"
 
 #include <gc/card.h>
-#include <gc/OSCache.h>
 #include <ttyd/cardmgr.h>
 #include <ttyd/memory.h>
 
@@ -499,15 +498,11 @@ int32_t loadSettings(int32_t memoryCardSlot)
     // Set up the memory to be copied from the file
     // Allocate the memory on the smart heap to avoid fragmentation
     ttyd::memory::SmartAllocationData *SmartData = 
-        ttyd::memory::smartAlloc(FileSizeAdjusted, 
+        allocFromSmartHeap(FileSizeAdjusted, 
             ttyd::memory::SmartAllocationGroup::kNone);
 
-    // Set up a temporary local variable to use for getting memory
+    // Set up a temporary local variable to use for getting the memory
     char *MiscData = reinterpret_cast<char *>(SmartData->pMemory);
-    clearMemory(MiscData, FileSizeAdjusted);
-    
-    // Be 100% certain that no memory issues occur, since the allocated memory wasn't cleared automatically
-    gc::OSCache::DCFlushRange(MiscData, FileSizeAdjusted);
 
     // Get the data from the file
     // Must read by the stored size, as the struct size may exceed the size of the file