Cleanup tabs -> spaces, actually free memory

5 files changed, 256 insertions, 286 deletions

@@ -8,16 +8,17 @@
 #undef PROCESSENTRY32
 #undef Process32Next
 
-Memory::Memory(const std::wstring& processName) : _processName(processName) {
-}
+Memory::Memory(const std::wstring& processName) : _processName(processName) {}
 
 Memory::~Memory() {
     if (_threadActive) {
         _threadActive = false;
         _thread.join();
     }
+
     if (_handle != nullptr) {
-            CloseHandle(_handle);
+        for (uintptr_t addr : _allocations) VirtualFreeEx(_handle, (void*)addr, 0, MEM_RELEASE);
+        CloseHandle(_handle);
     }
 }
 
@@ -133,7 +134,7 @@ int Memory::ExecuteSigScans()
 {
         for (int i=0; i<0x200000; i+=0x1000) {
                 std::vector<byte> data = ReadData<byte>({i}, 0x1100);
-                
+
                 for (auto& [scanBytes, sigScan] : _sigScans) {
                         if (sigScan.found) continue;
                         int index = find(data, scanBytes);
@@ -19,103 +19,103 @@ enum class ProcStatus {
 // http://stackoverflow.com/q/32798185
 // http://stackoverflow.com/q/36018838
 // http://stackoverflow.com/q/1387064
+// https://github.com/fkloiber/witness-trainer/blob/master/source/foreign_process_memory.cpp
 class Memory final : public std::enable_shared_from_this<Memory> {
 public:
-        Memory(const std::wstring& processName);
-        ~Memory();
+    Memory(const std::wstring& processName);
+    ~Memory();
     void StartHeartbeat(HWND window, std::chrono::milliseconds beat = std::chrono::milliseconds(1000));
 
-        Memory(const Memory& memory) = delete;
-        Memory& operator=(const Memory& other) = delete;
+    Memory(const Memory& memory) = delete;
+    Memory& operator=(const Memory& other) = delete;
 
-        template <class T>
-        std::vector<T> ReadArray(int panel, int offset, int size) {
-                return ReadData<T>({GLOBALS, 0x18, panel*8, offset, 0}, size);
-        }
+    template <class T>
+    std::vector<T> ReadArray(int id, int offset, int size) {
+        return ReadData<T>({GLOBALS, 0x18, id*8, offset, 0}, size);
+    }
 
-        template <class T>
-        void WriteArray(int panel, int offset, const std::vector<T>& data) {
-                WriteData({GLOBALS, 0x18, panel*8, offset, 0}, data);
-        }
+    template <class T>
+    void WriteArray(int id, int offset, const std::vector<T>& data) {
+        WriteData({GLOBALS, 0x18, id*8, offset, 0}, data);
+    }
 
-        template <class T>
-        void WriteNewArray(int panel, int offset, const std::vector<T>& data) {
-        std::vector<uintptr_t> newAddr = {Allocate(data.size() * sizeof(T))};
-        WritePanelData(panel, offset, newAddr);
-                WriteArray(panel, offset, data);
-        }
+    template <class T>
+    void WriteNewArray(int id, int offset, const std::vector<T>& data) {
+        uintptr_t addr = VirtualAllocEx(_handle, nullptr, data.size() * sizeof(T), MEM_RESERVE | MEM_COMMIT, MEM_READWRITE);
+        _allocations.emplace_back(addr);
+        WriteEntityData(id, offset, addr);
+        WriteArray(id, offset, data);
+    }
 
-        template <class T>
-        std::vector<T> ReadPanelData(int panel, int offset, size_t size) {
-                return ReadData<T>({GLOBALS, 0x18, panel*8, offset}, size);
-        }
+    template <class T>
+    std::vector<T> ReadEntityData(int id, int offset, size_t size) {
+        return ReadData<T>({GLOBALS, 0x18, id*8, offset}, size);
+    }
 
-        template <class T>
-        void WritePanelData(int panel, int offset, const std::vector<T>& data) {
-                WriteData({GLOBALS, 0x18, panel*8, offset}, data);
-        }
+    template <class T>
+    void WriteEntityData(int id, int offset, const std::vector<T>& data) {
+        WriteData({GLOBALS, 0x18, id*8, offset}, data);
+    }
 
-        void AddSigScan(const std::vector<byte>& scanBytes, const std::function<void(int index)>& scanFunc);
-        int ExecuteSigScans();
+    void AddSigScan(const std::vector<byte>& scanBytes, const std::function<void(int index)>& scanFunc);
+    int ExecuteSigScans();
 
 private:
-        template<class T>
-        std::vector<T> ReadData(const std::vector<int>& offsets, size_t numItems) {
+    template<class T>
+    std::vector<T> ReadData(const std::vector<int>& offsets, size_t numItems) {
         if (numItems == 0) return {};
-                std::vector<T> data;
-                data.resize(numItems);
+        std::vector<T> data;
+        data.resize(numItems);
         void* computedOffset = ComputeOffset(offsets);
-                for (int i=0; i<5; i++) {
-                        if (ReadProcessMemory(_handle, computedOffset, &data[0], sizeof(T) * numItems, nullptr)) {
+        for (int i=0; i<5; i++) {
+            if (ReadProcessMemory(_handle, computedOffset, &data[0], sizeof(T) * numItems, nullptr)) {
                 if (i != 0) {
                     int k = 0;
                 }
-                                return data;
-                        }
-                }
-                ThrowError();
-                return {};
-        }
+                return data;
+            }
+        }
+        ThrowError();
+        return {};
+    }
 
-        template <class T>
-        void WriteData(const std::vector<int>& offsets, const std::vector<T>& data) {
+    template <class T>
+    void WriteData(const std::vector<int>& offsets, const std::vector<T>& data) {
         if (data.empty()) return;
         void* computedOffset = ComputeOffset(offsets);
-                for (int i=0; i<5; i++) {
-                        if (WriteProcessMemory(_handle, computedOffset, &data[0], sizeof(T) * data.size(), nullptr)) {
+        for (int i=0; i<5; i++) {
+            if (WriteProcessMemory(_handle, computedOffset, &data[0], sizeof(T) * data.size(), nullptr)) {
                 if (i != 0) {
                     int k = 0;
                 }
-                                return;
-                        }
-                }
-                ThrowError();
-        }
+                return;
+            }
+        }
+        ThrowError();
+    }
 
     void Heartbeat(HWND window);
-        bool Initialize();
-        void ThrowError();
-        void* ComputeOffset(std::vector<int> offsets);
-    uintptr_t Allocate(size_t bytes);
+    bool Initialize();
+    void ThrowError();
+    void* ComputeOffset(std::vector<int> offsets);
 
     int _previousFrame = 0;
     bool _threadActive = false;
     std::thread _thread;
     std::wstring _processName;
-        std::map<uintptr_t, uintptr_t> _computedAddresses;
-        uintptr_t _baseAddress = 0;
-        HANDLE _handle = nullptr;
-    uintptr_t _freeMem = 0;
-    uintptr_t _freeMemEnd = 0;
-        struct SigScan {
-                std::function<void(int)> scanFunc;
-                bool found;
-        };
-        std::map<std::vector<byte>, SigScan> _sigScans;
+    std::map<uintptr_t, uintptr_t> _computedAddresses;
+    uintptr_t _baseAddress = 0;
+    HANDLE _handle = nullptr;
+    std::vector<uintptr_t> _allocations;
+    struct SigScan {
+        std::function<void(int)> scanFunc;
+        bool found;
+    };
+    std::map<std::vector<byte>, SigScan> _sigScans;
 
-        friend class Temp;
-        friend class ChallengeRandomizer;
-        friend class Randomizer;
+    friend class Temp;
+    friend class ChallengeRandomizer;
+    friend class Randomizer;
 };
 
 #if GLOBALS == 0x5B28C0
@@ -7,22 +7,22 @@
 PuzzleSerializer::PuzzleSerializer(const std::shared_ptr<Memory>& memory) : _memory(memory) {}
 
 Puzzle PuzzleSerializer::ReadPuzzle(int id) {
-    int width = 2 * _memory->ReadPanelData<int>(id, GRID_SIZE_X, 1)[0] - 1;
-    int height = 2 * _memory->ReadPanelData<int>(id, GRID_SIZE_Y, 1)[0] - 1;
+    int width = 2 * _memory->ReadEntityData<int>(id, GRID_SIZE_X, 1)[0] - 1;
+    int height = 2 * _memory->ReadEntityData<int>(id, GRID_SIZE_Y, 1)[0] - 1;
     if (width < 0 || height < 0) return Puzzle(); // @Error: Grid size should be always positive? Looks like the starting panels break this rule, though.
 
-        int numIntersections = _memory->ReadPanelData<int>(id, NUM_DOTS, 1)[0];
-        _intersectionFlags = _memory->ReadArray<int>(id, DOT_FLAGS, numIntersections);
-        int numConnections = _memory->ReadPanelData<int>(id, NUM_CONNECTIONS, 1)[0];
-        _connectionsA = _memory->ReadArray<int>(id, DOT_CONNECTION_A, numConnections);
-        _connectionsB = _memory->ReadArray<int>(id, DOT_CONNECTION_B, numConnections);
-        _intersectionLocations = _memory->ReadArray<float>(id, DOT_POSITIONS, numIntersections*2);
+    int numIntersections = _memory->ReadEntityData<int>(id, NUM_DOTS, 1)[0];
+    _intersectionFlags = _memory->ReadArray<int>(id, DOT_FLAGS, numIntersections);
+    int numConnections = _memory->ReadEntityData<int>(id, NUM_CONNECTIONS, 1)[0];
+    _connectionsA = _memory->ReadArray<int>(id, DOT_CONNECTION_A, numConnections);
+    _connectionsB = _memory->ReadArray<int>(id, DOT_CONNECTION_B, numConnections);
+    _intersectionLocations = _memory->ReadArray<float>(id, DOT_POSITIONS, numIntersections*2);
 
     Puzzle p;
     p.NewGrid(width, height);
-        ReadIntersections(p);
+    ReadIntersections(p);
     ReadExtras(p);
-        ReadDecorations(p, id);
+    ReadDecorations(p, id);
     ReadSequence(p, id);
     return p;
 }
@@ -34,28 +34,28 @@ void PuzzleSerializer::WritePuzzle(const Puzzle& p, int id) {
     _intersectionLocations.clear();
 
     MIN = 0.1f;
-        MAX = 0.9f;
-        WIDTH_INTERVAL = (MAX - MIN) / (p.width/2);
-        HEIGHT_INTERVAL = (MAX - MIN) / (p.height/2);
+    MAX = 0.9f;
+    WIDTH_INTERVAL = (MAX - MIN) / (p.width/2);
+    HEIGHT_INTERVAL = (MAX - MIN) / (p.height/2);
     HORIZ_GAP_SIZE = WIDTH_INTERVAL / 2;
     VERTI_GAP_SIZE = HEIGHT_INTERVAL / 2;
 
-        WriteIntersections(p);
+    WriteIntersections(p);
     WriteDots(p);
     WriteGaps(p);
     WriteEndpoints(p);
     WriteDecorations(p, id);
     WriteSequence(p, id);
 
-        _memory->WritePanelData<int>(id, GRID_SIZE_X, {(p.width + 1)/2});
-        _memory->WritePanelData<int>(id, GRID_SIZE_Y, {(p.height + 1)/2});
-        _memory->WritePanelData<int>(id, NUM_DOTS, {static_cast<int>(_intersectionFlags.size())});
-        _memory->WriteArray<float>(id, DOT_POSITIONS, _intersectionLocations);
-        _memory->WriteArray<int>(id, DOT_FLAGS, _intersectionFlags);
-        _memory->WritePanelData<int>(id, NUM_CONNECTIONS, {static_cast<int>(_connectionsA.size())});
-        _memory->WriteArray<int>(id, DOT_CONNECTION_A, _connectionsA);
-        _memory->WriteArray<int>(id, DOT_CONNECTION_B, _connectionsB);
-        _memory->WritePanelData<int>(id, NEEDS_REDRAW, {1});
+    _memory->WriteEntityData<int>(id, GRID_SIZE_X, {(p.width + 1)/2});
+    _memory->WriteEntityData<int>(id, GRID_SIZE_Y, {(p.height + 1)/2});
+    _memory->WriteEntityData<int>(id, NUM_DOTS, {static_cast<int>(_intersectionFlags.size())});
+    _memory->WriteArray<float>(id, DOT_POSITIONS, _intersectionLocations);
+    _memory->WriteArray<int>(id, DOT_FLAGS, _intersectionFlags);
+    _memory->WriteEntityData<int>(id, NUM_CONNECTIONS, {static_cast<int>(_connectionsA.size())});
+    _memory->WriteArray<int>(id, DOT_CONNECTION_A, _connectionsA);
+    _memory->WriteArray<int>(id, DOT_CONNECTION_B, _connectionsB);
+    _memory->WriteEntityData<int>(id, NEEDS_REDRAW, {1});
 }
 
 void PuzzleSerializer::ReadIntersections(Puzzle& p) {
@@ -70,78 +70,78 @@ void PuzzleSerializer::ReadIntersections(Puzzle& p) {
     for (int j=0; j<_intersectionFlags.size(); j++) {
         if (_intersectionFlags[_connectionsA[j]] & Flags::IS_ENDPOINT) break;
         if (_intersectionFlags[_connectionsB[j]] & Flags::IS_ENDPOINT) break;
-                float x1 = _intersectionLocations[2*_connectionsA[j]];
-                float y1 = _intersectionLocations[2*_connectionsA[j]+1];
-                float x2 = _intersectionLocations[2*_connectionsB[j]];
-                float y2 = _intersectionLocations[2*_connectionsB[j]+1];
+        float x1 = _intersectionLocations[2*_connectionsA[j]];
+        float y1 = _intersectionLocations[2*_connectionsA[j]+1];
+        float x2 = _intersectionLocations[2*_connectionsB[j]];
+        float y2 = _intersectionLocations[2*_connectionsB[j]+1];
         auto [x, y] = loc_to_xy(p, _connectionsA[j]);
-        
-                         if (x1 < x2) x++;
-                else if (x1 > x2) x--;
-                else if (y1 < y2) y--;
-                else if (y1 > y2) y++;
+
+             if (x1 < x2) x++;
+        else if (x1 > x2) x--;
+        else if (y1 < y2) y--;
+        else if (y1 > y2) y++;
         p.grid[x][y].gap = Cell::Gap::NONE;
     }
 }
 
 void PuzzleSerializer::ReadExtras(Puzzle& p) {
     // This iterates bottom-top, left-right
-        int i = 0;
-        for (; i < _intersectionFlags.size(); i++) {
+    int i = 0;
+    for (; i < _intersectionFlags.size(); i++) {
         int flags = _intersectionFlags[i];
-                auto [x, y] = loc_to_xy(p, i);
-                if (y < 0) break; // This is the expected exit point
-                if (flags & Flags::IS_STARTPOINT) {
+        auto [x, y] = loc_to_xy(p, i);
+        if (y < 0) break; // This is the expected exit point
+        if (flags & Flags::IS_STARTPOINT) {
             p.grid[x][y].start = true;
-                }
+        }
         p.grid[x][y].dot = FlagsToDot(flags);
         if (flags & Flags::HAS_NO_CONN) {
             p.grid[x][y].gap = Cell::Gap::FULL;
         }
-        }
+    }
 
-        // Iterate the remaining intersections (endpoints, dots, gaps)
-        for (; i < _intersectionFlags.size(); i++) {
+    // Iterate the remaining intersections (endpoints, dots, gaps)
+    for (; i < _intersectionFlags.size(); i++) {
         int location = FindConnection(i);
-                if (location == -1) continue; // @Error: Unable to find connection point
+        if (location == -1) continue; // @Error: Unable to find connection point
         // (x1, y1) location of this intersection
         // (x2, y2) location of the connected intersection
-                float x1 = _intersectionLocations[2*i];
-                float y1 = _intersectionLocations[2*i+1];
-                float x2 = _intersectionLocations[2*location];
-                float y2 = _intersectionLocations[2*location+1];
+        float x1 = _intersectionLocations[2*i];
+        float y1 = _intersectionLocations[2*i+1];
+        float x2 = _intersectionLocations[2*location];
+        float y2 = _intersectionLocations[2*location+1];
         auto [x, y] = loc_to_xy(p, location);
 
-                if (_intersectionFlags[i] & Flags::IS_ENDPOINT) {
+        if (_intersectionFlags[i] & Flags::IS_ENDPOINT) {
             // Our x coordinate is less than the target's
-                             if (x1 < x2) p.grid[x][y].end = Cell::Dir::LEFT;
-                        else if (x1 > x2) p.grid[x][y].end = Cell::Dir::RIGHT;
+                 if (x1 < x2) p.grid[x][y].end = Cell::Dir::LEFT;
+            else if (x1 > x2) p.grid[x][y].end = Cell::Dir::RIGHT;
             // Note that Y coordinates are reversed: 0.0 (bottom) 1.0 (top)
-                        else if (y1 < y2) p.grid[x][y].end = Cell::Dir::DOWN;
+            else if (y1 < y2) p.grid[x][y].end = Cell::Dir::DOWN;
             else if (y1 > y2) p.grid[x][y].end = Cell::Dir::UP;
-                } else if (_intersectionFlags[i] & Flags::HAS_DOT) {
-                             if (x1 < x2) x--;
-                        else if (x1 > x2) x++;
-                        else if (y1 < y2) y++;
-                        else if (y1 > y2) y--;
+        } else if (_intersectionFlags[i] & Flags::HAS_DOT) {
+                 if (x1 < x2) x--;
+            else if (x1 > x2) x++;
+            else if (y1 < y2) y++;
+            else if (y1 > y2) y--;
             p.grid[x][y].dot = FlagsToDot(_intersectionFlags[i]);
         } else if (_intersectionFlags[i] & Flags::HAS_ONE_CONN) {
-                             if (x1 < x2) x--;
-                        else if (x1 > x2) x++;
-                        else if (y1 < y2) y++;
-                        else if (y1 > y2) y--;
+                 if (x1 < x2) x--;
+            else if (x1 > x2) x++;
+            else if (y1 < y2) y++;
+            else if (y1 > y2) y--;
             p.grid[x][y].gap = Cell::Gap::BREAK;
         }
-        }       
+    }
 }
 
 void PuzzleSerializer::ReadDecorations(Puzzle& p, int id) {
-        int numDecorations = _memory->ReadPanelData<int>(id, NUM_DECORATIONS, 1)[0];
-        std::vector<int> decorations = _memory->ReadArray<int>(id, DECORATIONS, numDecorations);
+    int numDecorations = _memory->ReadEntityData<int>(id, NUM_DECORATIONS, 1)[0];
+    std::vector<int> decorations = _memory->ReadArray<int>(id, DECORATIONS, numDecorations);
     if (numDecorations > 0) p.hasDecorations = true;
 
-        for (int i=0; i<numDecorations; i++) {
-                auto [x, y] = dloc_to_xy(p, i);
+    for (int i=0; i<numDecorations; i++) {
+        auto [x, y] = dloc_to_xy(p, i);
         auto d = std::make_shared<Decoration>();
         p.grid[x][y].decoration = d;
         d->type = static_cast<Type>(decorations[i] & 0xFF00);
@@ -156,11 +156,11 @@ void PuzzleSerializer::ReadDecorations(Puzzle& p, int id) {
                 break;
         }
         d->color = static_cast<Color>(decorations[i] & 0xF);
-        }
+    }
 }
 
 void PuzzleSerializer::ReadSequence(Puzzle& p, int id) {
-    int sequenceLength = _memory->ReadPanelData<int>(id, SEQUENCE_LEN, 1)[0];
+    int sequenceLength = _memory->ReadEntityData<int>(id, SEQUENCE_LEN, 1)[0];
     std::vector<int> sequence = _memory->ReadArray<int>(id, SEQUENCE, sequenceLength);
 
     for (int location : sequence) {
@@ -170,15 +170,15 @@ void PuzzleSerializer::ReadSequence(Puzzle& p, int id) {
 }
 
 void PuzzleSerializer::WriteIntersections(const Puzzle& p) {
-        // @Cleanup: If I write directly to locations, then I can simplify this gross loop iterator.
+    // @Cleanup: If I write directly to locations, then I can simplify this gross loop iterator.
     // int numIntersections = (p.width / 2 + 1) * (p.height / 2 + 1);
     // Grided intersections
-        for (int y=p.height-1; y>=0; y-=2) {
-                for (int x=0; x<p.width; x+=2) {
+    for (int y=p.height-1; y>=0; y-=2) {
+        for (int x=0; x<p.width; x+=2) {
             auto [xPos, yPos] = xy_to_pos(p, x, y);
-                        _intersectionLocations.push_back(xPos);
-                        _intersectionLocations.push_back(yPos);
-                        int flags = 0;
+            _intersectionLocations.push_back(xPos);
+            _intersectionLocations.push_back(yPos);
+            int flags = 0;
             if (p.grid[x][y].start) {
                 flags |= Flags::IS_STARTPOINT;
             }
@@ -199,26 +199,26 @@ void PuzzleSerializer::WriteIntersections(const Puzzle& p) {
 
             int numConnections = 0;
             if (p.grid[x][y].end != Cell::Dir::NONE) numConnections++;
-                        // Create connections for this intersection for top/left only.
+            // Create connections for this intersection for top/left only.
             // Top connection
-                        if (y > 0 && p.grid[x][y-1].gap != Cell::Gap::FULL) {
-                                _connectionsA.push_back(xy_to_loc(p, x, y-2));
-                                _connectionsB.push_back(xy_to_loc(p, x, y));
+            if (y > 0 && p.grid[x][y-1].gap != Cell::Gap::FULL) {
+                _connectionsA.push_back(xy_to_loc(p, x, y-2));
+                _connectionsB.push_back(xy_to_loc(p, x, y));
                 flags |= Flags::HAS_VERTI_CONN;
                 numConnections++;
-                        }
+            }
             // Bottom connection
             if (y < p.height - 1 && p.grid[x][y+1].gap != Cell::Gap::FULL) {
                 flags |= Flags::HAS_VERTI_CONN;
                 numConnections++;
             }
             // Left connection
-                        if (x > 0 && p.grid[x-1][y].gap != Cell::Gap::FULL) {
-                                _connectionsA.push_back(xy_to_loc(p, x-2, y));
-                                _connectionsB.push_back(xy_to_loc(p, x, y));
+            if (x > 0 && p.grid[x-1][y].gap != Cell::Gap::FULL) {
+                _connectionsA.push_back(xy_to_loc(p, x-2, y));
+                _connectionsB.push_back(xy_to_loc(p, x, y));
                 flags |= Flags::HAS_HORIZ_CONN;
                 numConnections++;
-                        }
+            }
             // Right connection
             if (x < p.width - 1 && p.grid[x+1][y].gap != Cell::Gap::FULL) {
                 flags |= Flags::HAS_HORIZ_CONN;
@@ -227,9 +227,9 @@ void PuzzleSerializer::WriteIntersections(const Puzzle& p) {
             if (numConnections == 0) flags |= HAS_NO_CONN;
             if (numConnections == 1) flags |= HAS_ONE_CONN;
 
-                        _intersectionFlags.push_back(flags);
-                }
-        }
+            _intersectionFlags.push_back(flags);
+        }
+    }
 }
 
 void PuzzleSerializer::WriteEndpoints(const Puzzle& p) {
@@ -237,27 +237,27 @@ void PuzzleSerializer::WriteEndpoints(const Puzzle& p) {
         for (int y=0; y<p.height; y++) {
             if (p.grid[x][y].end == Cell::Dir::NONE) continue;
             _connectionsA.push_back(xy_to_loc(p, x, y));
-                    _connectionsB.push_back(static_cast<int>(_intersectionFlags.size()));
+            _connectionsB.push_back(static_cast<int>(_intersectionFlags.size()));
 
             auto [xPos, yPos] = xy_to_pos(p, x, y);
             switch (p.grid[x][y].end) {
                 case Cell::Dir::LEFT:
-                                xPos -= .05f;
+                    xPos -= .05f;
                     break;
                 case Cell::Dir::RIGHT:
-                                xPos += .05f;
+                    xPos += .05f;
                     break;
                 case Cell::Dir::UP:
-                                yPos += .05f; // Y position goes from 0 (bottom) to 1 (top), so this is reversed.
+                    yPos += .05f; // Y position goes from 0 (bottom) to 1 (top), so this is reversed.
                     break;
                 case Cell::Dir::DOWN:
-                                yPos -= .05f;
+                    yPos -= .05f;
                     break;
             }
             _endpointLocations.emplace_back(x, y, static_cast<int>(_intersectionFlags.size()));
-                    _intersectionLocations.push_back(xPos);
-                    _intersectionLocations.push_back(yPos);
-                    _intersectionFlags.push_back(Flags::IS_ENDPOINT);
+            _intersectionLocations.push_back(xPos);
+            _intersectionLocations.push_back(yPos);
+            _intersectionFlags.push_back(Flags::IS_ENDPOINT);
         }
     }
 }
@@ -265,32 +265,32 @@ void PuzzleSerializer::WriteEndpoints(const Puzzle& p) {
 void PuzzleSerializer::WriteDots(const Puzzle& p) {
     for (int x=0; x<p.width; x++) {
         for (int y=0; y<p.height; y++) {
-                        if (x%2 == y%2) continue; // Cells are invalid, intersections are already handled.
-                        if (p.grid[x][y].dot == Cell::Dot::NONE) continue;
+            if (x%2 == y%2) continue; // Cells are invalid, intersections are already handled.
+            if (p.grid[x][y].dot == Cell::Dot::NONE) continue;
 
             // We need to introduce a new segment which contains this dot. Break the existing segment, and add one.
             int connectionLocation = -1;
-                        for (int i=0; i<_connectionsA.size(); i++) {
-                                auto [x1, y1] = loc_to_xy(p, _connectionsA[i]);
-                                auto [x2, y2] = loc_to_xy(p, _connectionsB[i]);
-                                if ((x1+1 == x && x2-1 == x && y1 == y && y2 == y) ||
-                                        (y1+1 == y && y2-1 == y && x1 == x && x2 == x)) {
+            for (int i=0; i<_connectionsA.size(); i++) {
+                auto [x1, y1] = loc_to_xy(p, _connectionsA[i]);
+                auto [x2, y2] = loc_to_xy(p, _connectionsB[i]);
+                if ((x1+1 == x && x2-1 == x && y1 == y && y2 == y) ||
+                    (y1+1 == y && y2-1 == y && x1 == x && x2 == x)) {
                     connectionLocation = i;
                     break;
-                                }
-                        }
+                }
+            }
             if (connectionLocation == -1) continue; // @Error
 
             // @Assume: B > A for connections. To remove, add the horiz/verti check, see gaps.
             int other_connection = _connectionsB[connectionLocation];
-                        _connectionsB[connectionLocation] = static_cast<int>(_intersectionFlags.size());
-                        _connectionsA.push_back(other_connection);
-                        _connectionsB.push_back(static_cast<int>(_intersectionFlags.size()));
+            _connectionsB[connectionLocation] = static_cast<int>(_intersectionFlags.size());
+            _connectionsA.push_back(other_connection);
+            _connectionsB.push_back(static_cast<int>(_intersectionFlags.size()));
 
-                        // Add this dot to the end
+            // Add this dot to the end
             auto [xPos, yPos] = xy_to_pos(p, x, y);
-                        _intersectionLocations.push_back(xPos);
-                        _intersectionLocations.push_back(yPos);
+            _intersectionLocations.push_back(xPos);
+            _intersectionLocations.push_back(yPos);
 
             int flags = Flags::HAS_DOT;
             switch (p.grid[x][y].dot) {
@@ -307,27 +307,27 @@ void PuzzleSerializer::WriteDots(const Puzzle& p) {
                     break;
             }
             _intersectionFlags.push_back(flags);
-                }
-        }
+        }
+    }
 }
 
 void PuzzleSerializer::WriteGaps(const Puzzle& p) {
     for (int x=0; x<p.width; x++) {
         for (int y=0; y<p.height; y++) {
-                        if (x%2 == y%2) continue; // Cells are invalid, intersections are already handled.
-                        if (p.grid[x][y].gap != Cell::Gap::BREAK) continue;
+            if (x%2 == y%2) continue; // Cells are invalid, intersections are already handled.
+            if (p.grid[x][y].gap != Cell::Gap::BREAK) continue;
 
             // We need to introduce a new segment which contains this dot. Break the existing segment, and add one.
             int connectionLocation = -1;
-                        for (int i=0; i<_connectionsA.size(); i++) {
-                                auto [x1, y1] = loc_to_xy(p, _connectionsA[i]);
-                                auto [x2, y2] = loc_to_xy(p, _connectionsB[i]);
-                                if ((x1+1 == x && x2-1 == x && y1 == y && y2 == y) ||
-                                        (y1+1 == y && y2-1 == y && x1 == x && x2 == x)) {
-                                        connectionLocation = i;
+            for (int i=0; i<_connectionsA.size(); i++) {
+                auto [x1, y1] = loc_to_xy(p, _connectionsA[i]);
+                auto [x2, y2] = loc_to_xy(p, _connectionsB[i]);
+                if ((x1+1 == x && x2-1 == x && y1 == y && y2 == y) ||
+                    (y1+1 == y && y2-1 == y && x1 == x && x2 == x)) {
+                    connectionLocation = i;
                     break;
-                                }
-                        }
+                }
+            }
             if (connectionLocation == -1) continue; // @Error
 
             auto [xPos, yPos] = xy_to_pos(p, x, y);
@@ -335,49 +335,49 @@ void PuzzleSerializer::WriteGaps(const Puzzle& p) {
             if (x%2 == 0) { // Vertical gap
                 _connectionsA[connectionLocation] = xy_to_loc(p, x, y-1);
                 _connectionsB[connectionLocation] = static_cast<int>(_intersectionFlags.size());
-                            _intersectionLocations.push_back(xPos);
-                            _intersectionLocations.push_back(yPos + VERTI_GAP_SIZE / 2);
+                _intersectionLocations.push_back(xPos);
+                _intersectionLocations.push_back(yPos + VERTI_GAP_SIZE / 2);
                 _intersectionFlags.push_back(Flags::HAS_ONE_CONN | Flags::HAS_VERTI_CONN);
 
                 _connectionsA.push_back(xy_to_loc(p, x, y+1));
                 _connectionsB.push_back(static_cast<int>(_intersectionFlags.size()));
-                            _intersectionLocations.push_back(xPos);
-                            _intersectionLocations.push_back(yPos - VERTI_GAP_SIZE / 2);
+                _intersectionLocations.push_back(xPos);
+                _intersectionLocations.push_back(yPos - VERTI_GAP_SIZE / 2);
                 _intersectionFlags.push_back(Flags::HAS_ONE_CONN | Flags::HAS_VERTI_CONN);
             } else if (y%2 == 0) { // Horizontal gap
                 _connectionsA[connectionLocation] = xy_to_loc(p, x-1, y);
                 _connectionsB[connectionLocation] = static_cast<int>(_intersectionFlags.size());
-                            _intersectionLocations.push_back(xPos - HORIZ_GAP_SIZE / 2);
-                            _intersectionLocations.push_back(yPos);
+                _intersectionLocations.push_back(xPos - HORIZ_GAP_SIZE / 2);
+                _intersectionLocations.push_back(yPos);
                 _intersectionFlags.push_back(Flags::HAS_ONE_CONN | Flags::HAS_HORIZ_CONN);
 
                 _connectionsA.push_back(xy_to_loc(p, x+1, y));
                 _connectionsB.push_back(static_cast<int>(_intersectionFlags.size()));
-                            _intersectionLocations.push_back(xPos + HORIZ_GAP_SIZE / 2);
-                            _intersectionLocations.push_back(yPos);
+                _intersectionLocations.push_back(xPos + HORIZ_GAP_SIZE / 2);
+                _intersectionLocations.push_back(yPos);
                 _intersectionFlags.push_back(Flags::HAS_ONE_CONN | Flags::HAS_HORIZ_CONN);
             }
-                }
-        }
+        }
+    }
 }
 
 void PuzzleSerializer::WriteDecorations(const Puzzle& p, int id) {
     if (!p.hasDecorations) return;
 
-        std::vector<int> decorations;
-        for (int y=p.height-2; y>0; y-=2) {
-                for (int x=1; x<p.width-1; x+=2) {
+    std::vector<int> decorations;
+    for (int y=p.height-2; y>0; y-=2) {
+        for (int x=1; x<p.width-1; x+=2) {
             auto d = p.grid[x][y].decoration;
             if (d) {
                 decorations.push_back(d->color | d->type | d->count | d->polyshape);
             } else {
                 decorations.push_back(0);
             }
-                }
-        }
+        }
+    }
 
-        _memory->WritePanelData<int>(id, NUM_DECORATIONS, {static_cast<int>(decorations.size())});
-        _memory->WriteArray<int>(id, DECORATIONS, decorations);
+    _memory->WriteEntityData<int>(id, NUM_DECORATIONS, {static_cast<int>(decorations.size())});
+    _memory->WriteArray<int>(id, DECORATIONS, decorations);
 }
 
 void PuzzleSerializer::WriteSequence(const Puzzle& p, int id) {
@@ -399,7 +399,7 @@ void PuzzleSerializer::WriteSequence(const Puzzle& p, int id) {
         }
     }
 
-    _memory->WritePanelData<int>(id, SEQUENCE_LEN, {static_cast<int>(sequence.size())});
+    _memory->WriteEntityData<int>(id, SEQUENCE_LEN, {static_cast<int>(sequence.size())});
     _memory->WriteNewArray<int>(id, SEQUENCE, sequence);
 }
 
@@ -438,7 +438,7 @@ int PuzzleSerializer::xy_to_dloc(const Puzzle& p, int x, int y) const {
 }
 
 std::tuple<float, float> PuzzleSerializer::xy_to_pos(const Puzzle& p, int x, int y) const {
-        return {
+    return {
         MIN + (x/2.0f) * WIDTH_INTERVAL,
         MAX - (y/2.0f) * HEIGHT_INTERVAL
     };
@@ -454,8 +454,8 @@ Cell::Dot PuzzleSerializer::FlagsToDot(int flags) const {
 
 int PuzzleSerializer::FindConnection(int location) const {
     for (int j=0; j<_connectionsA.size(); j++) {
-            if (_connectionsA[j] == location) return _connectionsB[j];
-            if (_connectionsB[j] == location) return _connectionsA[j];
+        if (_connectionsA[j] == location) return _connectionsB[j];
+        if (_connectionsB[j] == location) return _connectionsA[j];
     }
     return -1;
 }
@@ -156,35 +156,35 @@ void Randomizer::Randomize() {
 
 void Randomizer::AdjustSpeed() {
         // Desert Surface Final Control
-        _memory->WritePanelData<float>(0x09F95, OPEN_RATE, {0.04f}); // 4x
+        _memory->WriteEntityData<float>(0x09F95, OPEN_RATE, {0.04f}); // 4x
         // Swamp Sliding Bridge
-        _memory->WritePanelData<float>(0x0061A, OPEN_RATE, {0.1f}); // 4x
+        _memory->WriteEntityData<float>(0x0061A, OPEN_RATE, {0.1f}); // 4x
         // Mountain 2 Elevator
-        _memory->WritePanelData<float>(0x09EEC, OPEN_RATE, {0.075f}); // 3x
+        _memory->WriteEntityData<float>(0x09EEC, OPEN_RATE, {0.075f}); // 3x
 }
 
 void Randomizer::RandomizeLasers() {
         Randomize(lasers, SWAP::TARGETS);
         // Read the target of keep front laser, and write it to keep back laser.
-        std::vector<int> keepFrontLaserTarget = _memory->ReadPanelData<int>(0x0360E, TARGET, 1);
-        _memory->WritePanelData<int>(0x03317, TARGET, keepFrontLaserTarget);
+        std::vector<int> keepFrontLaserTarget = _memory->ReadEntityData<int>(0x0360E, TARGET, 1);
+        _memory->WriteEntityData<int>(0x03317, TARGET, keepFrontLaserTarget);
 }
 
 void Randomizer::PreventSnipes()
 {
         // Distance-gate swamp snipe 1 to prevent RNG swamp snipe
-        _memory->WritePanelData<float>(0x17C05, MAX_BROADCAST_DISTANCE, {15.0});
+        _memory->WriteEntityData<float>(0x17C05, MAX_BROADCAST_DISTANCE, {15.0});
         // Distance-gate shadows laser to prevent sniping through the bars
-        _memory->WritePanelData<float>(0x19650, MAX_BROADCAST_DISTANCE, {2.5});
+        _memory->WriteEntityData<float>(0x19650, MAX_BROADCAST_DISTANCE, {2.5});
 }
 
 // Private methods
 void Randomizer::RandomizeTutorial() {
         // Disable tutorial cursor speed modifications (not working?)
-        _memory->WritePanelData<float>(0x00295, CURSOR_SPEED_SCALE, {1.0});
-        _memory->WritePanelData<float>(0x0C373, CURSOR_SPEED_SCALE, {1.0});
-        _memory->WritePanelData<float>(0x00293, CURSOR_SPEED_SCALE, {1.0});
-        _memory->WritePanelData<float>(0x002C2, CURSOR_SPEED_SCALE, {1.0});
+        _memory->WriteEntityData<float>(0x00295, CURSOR_SPEED_SCALE, {1.0});
+        _memory->WriteEntityData<float>(0x0C373, CURSOR_SPEED_SCALE, {1.0});
+        _memory->WriteEntityData<float>(0x00293, CURSOR_SPEED_SCALE, {1.0});
+        _memory->WriteEntityData<float>(0x002C2, CURSOR_SPEED_SCALE, {1.0});
 }
 
 void Randomizer::RandomizeSymmetry() {
@@ -198,11 +198,11 @@ void Randomizer::RandomizeDesert() {
         Randomize(desertPanels, SWAP::LINES);
 
         // Turn off desert surface 8
-        _memory->WritePanelData<float>(0x09F94, POWER, {0.0, 0.0});
+        _memory->WriteEntityData<float>(0x09F94, POWER, {0.0, 0.0});
         // Turn off desert flood final
-        _memory->WritePanelData<float>(0x18076, POWER, {0.0, 0.0});
+        _memory->WriteEntityData<float>(0x18076, POWER, {0.0, 0.0});
         // Change desert floating target to desert flood final
-        _memory->WritePanelData<int>(0x17ECA, TARGET, {0x18077});
+        _memory->WriteEntityData<int>(0x17ECA, TARGET, {0x18077});
 }
 
 void Randomizer::RandomizeQuarry() {
@@ -210,14 +210,14 @@ void Randomizer::RandomizeQuarry() {
 
 void Randomizer::RandomizeTreehouse() {
         // Ensure that whatever pivot panels we have are flagged as "pivotable"
-        int panelFlags = _memory->ReadPanelData<int>(0x17DD1, STYLE_FLAGS, 1)[0];
-        _memory->WritePanelData<int>(0x17DD1, STYLE_FLAGS, {panelFlags | 0x8000});
-        panelFlags = _memory->ReadPanelData<int>(0x17CE3, STYLE_FLAGS, 1)[0];
-        _memory->WritePanelData<int>(0x17CE3, STYLE_FLAGS, {panelFlags | 0x8000});
-        panelFlags = _memory->ReadPanelData<int>(0x17DB7, STYLE_FLAGS, 1)[0];
-        _memory->WritePanelData<int>(0x17DB7, STYLE_FLAGS, {panelFlags | 0x8000});
-        panelFlags = _memory->ReadPanelData<int>(0x17E52, STYLE_FLAGS, 1)[0];
-        _memory->WritePanelData<int>(0x17E52, STYLE_FLAGS, {panelFlags | 0x8000});
+        int panelFlags = _memory->ReadEntityData<int>(0x17DD1, STYLE_FLAGS, 1)[0];
+        _memory->WriteEntityData<int>(0x17DD1, STYLE_FLAGS, {panelFlags | 0x8000});
+        panelFlags = _memory->ReadEntityData<int>(0x17CE3, STYLE_FLAGS, 1)[0];
+        _memory->WriteEntityData<int>(0x17CE3, STYLE_FLAGS, {panelFlags | 0x8000});
+        panelFlags = _memory->ReadEntityData<int>(0x17DB7, STYLE_FLAGS, 1)[0];
+        _memory->WriteEntityData<int>(0x17DB7, STYLE_FLAGS, {panelFlags | 0x8000});
+        panelFlags = _memory->ReadEntityData<int>(0x17E52, STYLE_FLAGS, 1)[0];
+        _memory->WriteEntityData<int>(0x17E52, STYLE_FLAGS, {panelFlags | 0x8000});
 }
 
 void Randomizer::RandomizeKeep() {
@@ -225,9 +225,9 @@ void Randomizer::RandomizeKeep() {
 
 void Randomizer::RandomizeShadows() {
         // Change the shadows tutorial cable to only activate avoid
-        _memory->WritePanelData<int>(0x319A8, CABLE_TARGET_2, {0});
+        _memory->WriteEntityData<int>(0x319A8, CABLE_TARGET_2, {0});
         // Change shadows avoid 8 to power shadows follow
-        _memory->WritePanelData<int>(0x1972F, TARGET, {0x1C34C});
+        _memory->WriteEntityData<int>(0x1972F, TARGET, {0x1C34C});
 
         std::vector<int> randomOrder(shadowsPanels.size(), 0);
         std::iota(randomOrder.begin(), randomOrder.end(), 0);
@@ -236,9 +236,9 @@ void Randomizer::RandomizeShadows() {
         RandomizeRange(randomOrder, SWAP::NONE, 16, 21); // Follow
         ReassignTargets(shadowsPanels, randomOrder);
         // Turn off original starting panel
-        _memory->WritePanelData<float>(shadowsPanels[0], POWER, {0.0f, 0.0f});
+        _memory->WriteEntityData<float>(shadowsPanels[0], POWER, {0.0f, 0.0f});
         // Turn on new starting panel
-        _memory->WritePanelData<float>(shadowsPanels[randomOrder[0]], POWER, {1.0f, 1.0f});
+        _memory->WriteEntityData<float>(shadowsPanels[randomOrder[0]], POWER, {1.0f, 1.0f});
 }
 
 void Randomizer::RandomizeTown() {
@@ -298,7 +298,7 @@ void Randomizer::RandomizeMountain() {
         // Randomize final pillars order
         std::vector<int> targets = {pillars[0] + 1};
         for (const int pillar : pillars) {
-                int target = _memory->ReadPanelData<int>(pillar, TARGET, 1)[0];
+                int target = _memory->ReadEntityData<int>(pillar, TARGET, 1)[0];
                 targets.push_back(target);
         }
         targets[5] = pillars[5] + 1;
@@ -309,17 +309,17 @@ void Randomizer::RandomizeMountain() {
         RandomizeRange(randomOrder, SWAP::NONE, 5, 9); // Right Pillars 1-4
         ReassignTargets(pillars, randomOrder, targets);
         // Turn off original starting panels
-        _memory->WritePanelData<float>(pillars[0], POWER, {0.0f, 0.0f});
-        _memory->WritePanelData<float>(pillars[5], POWER, {0.0f, 0.0f});
+        _memory->WriteEntityData<float>(pillars[0], POWER, {0.0f, 0.0f});
+        _memory->WriteEntityData<float>(pillars[5], POWER, {0.0f, 0.0f});
         // Turn on new starting panels
-        _memory->WritePanelData<float>(pillars[randomOrder[0]], POWER, {1.0f, 1.0f});
-        _memory->WritePanelData<float>(pillars[randomOrder[5]], POWER, {1.0f, 1.0f});
+        _memory->WriteEntityData<float>(pillars[randomOrder[0]], POWER, {1.0f, 1.0f});
+        _memory->WriteEntityData<float>(pillars[randomOrder[5]], POWER, {1.0f, 1.0f});
 }
 
 void Randomizer::RandomizeChallenge() {
         ChallengeRandomizer cr(_memory, Random::RandInt(1, 0x7FFFFFFF)); // 0 will trigger an "RNG not initialized" block
         for (int panel : challengePanels) {
-                _memory->WritePanelData<int>(panel, POWER_OFF_ON_FAIL, {0});
+                _memory->WriteEntityData<int>(panel, POWER_OFF_ON_FAIL, {0});
         }
 }
 
@@ -420,10 +420,10 @@ void Randomizer::SwapPanels(int panel1, int panel2, int flags) {
         }
 
         for (auto const& [offset, size] : offsets) {
-                std::vector<byte> panel1data = _memory->ReadPanelData<byte>(panel1, offset, size);
-                std::vector<byte> panel2data = _memory->ReadPanelData<byte>(panel2, offset, size);
-                _memory->WritePanelData<byte>(panel2, offset, panel1data);
-                _memory->WritePanelData<byte>(panel1, offset, panel2data);
+                std::vector<byte> panel1data = _memory->ReadEntityData<byte>(panel1, offset, size);
+                std::vector<byte> panel2data = _memory->ReadEntityData<byte>(panel2, offset, size);
+                _memory->WriteEntityData<byte>(panel2, offset, panel1data);
+                _memory->WriteEntityData<byte>(panel1, offset, panel2data);
         }
 }
 
@@ -433,7 +433,7 @@ void Randomizer::ReassignTargets(const std::vector<int>& panels, const std::vect
                 // The first panel may not have a wire to power it, so we use the panel ID itself.
                 targets = {panels[0] + 1};
                 for (const int panel : panels) {
-                        int target = _memory->ReadPanelData<int>(panel, TARGET, 1)[0];
+                        int target = _memory->ReadEntityData<int>(panel, TARGET, 1)[0];
                         targets.push_back(target);
                 }
         }
@@ -441,17 +441,17 @@ void Randomizer::ReassignTargets(const std::vector<int>& panels, const std::vect
         for (size_t i=0; i<order.size() - 1; i++) {
                 // Set the target of order[i] to order[i+1], using the "real" target as determined above.
                 const int panelTarget = targets[order[i+1]];
-                _memory->WritePanelData<int>(panels[order[i]], TARGET, {panelTarget});
+                _memory->WriteEntityData<int>(panels[order[i]], TARGET, {panelTarget});
         }
 }
 
 void Randomizer::ReassignNames(const std::vector<int>& panels, const std::vector<int>& order) {
         std::vector<int64_t> names;
         for (const int panel : panels) {
-                names.push_back(_memory->ReadPanelData<int64_t>(panel, AUDIO_LOG_NAME, 1)[0]);
+                names.push_back(_memory->ReadEntityData<int64_t>(panel, AUDIO_LOG_NAME, 1)[0]);
         }
 
         for (int i=0; i<panels.size(); i++) {
-                _memory->WritePanelData<int64_t>(panels[i], AUDIO_LOG_NAME, {names[order[i]]});
+                _memory->WriteEntityData<int64_t>(panels[i], AUDIO_LOG_NAME, {names[order[i]]});
         }
 }
@@ -233,40 +233,6 @@ void Randomizer2::RandomizeKeep() {
     
     // *** Hedges 3 **
     {
-        std::vector<int> audioMarkers = {
-            0x000034a9,
-            0x000034b1,
-            0x000034be,
-            0x000034c4,
-            0x000034cb,
-            0x000034cc,
-            0x000034cd,
-            0x000034ce,
-            0x000034df,
-            0x000034e0,
-            0x000034e1,
-            0x000034e2,
-            0x000034f3,
-            0x000131cb,
-            0x00017e34,
-            0x00017e6f,
-            0x00017e76,
-            0x00017e77,
-            0x00017e7a,
-            0x00017e7e,
-            0x00017e8b,
-            0x00017e8d,
-            0x00017eb5,
-            0x000394a4,
-            0x0003b54e,
-        };
-        std::vector<int> good;
-        for (int marker : audioMarkers) {
-            // std::vector<char> assetName = _memory->ReadArray<char>(marker, 0xD8, 100);
-            std::vector<char> name = {'m', 'a', 'z', 'e', '_', 'p', 'e', 'b', 'b', 'l', 'e', '\0'};
-            _memory->WriteNewArray(marker, 0xD8, name);
-        }
-
         Puzzle p;
         p.NewGrid(4, 4);
 
@@ -283,6 +249,9 @@ void Randomizer2::RandomizeKeep() {
         p.grid[0][8].start = true;
         p.grid[8][2].end = Cell::Dir::RIGHT;
 
+        std::vector<int> pebbleMarkers = {0x034a9, 0x034b1, 0x034be, 0x034c4};
+
+
         std::vector<Pos> cutEdges = Randomizer2Core::CutEdgesToBeUnique(p);
         assert(cutEdges.size() == 7);
         for (Pos pos : cutEdges) {
@@ -352,9 +321,9 @@ void Randomizer2::SetGate(int panel, int X, int Y) {
     }
 
     SetPos(panel, x, y, 19.2f);
-    _memory->WritePanelData<float>(panel, ORIENTATION, {0.0f, 0.0f, z, w});
+    _memory->WriteEntityData<float>(panel, ORIENTATION, {0.0f, 0.0f, z, w});
 }
 
 void Randomizer2::SetPos(int panel, float x, float y, float z) {
-    _memory->WritePanelData<float>(panel, POSITION, {x, y, z});
+    _memory->WriteEntityData<float>(panel, POSITION, {x, y, z});
 }
\ No newline at end of file