merge manual and computed state

[alttp.git] / resources / js / components / tracker / Map.js

diff --git a/resources/js/components/tracker/Map.js b/resources/js/components/tracker/Map.js
index cfae29c4b4a4875e0c71e087b7f7456ee511d014..b77612ef65bd02ae9eb481df3c8e90b28daf4bb1 100644 (file)
--- a/resources/js/components/tracker/Map.js
+++ b/resources/js/components/tracker/Map.js
@@ -686,7 +686,7 @@ const makeBackground = (src, level) => {
 };
 
 const Map = () => {
-       const { dungeons, setState, state } = useTracker();
+       const { dungeons, setManualState, state } = useTracker();
 
        const mapDungeon = React.useCallback(dungeon => {
                const definition = dungeons.find(d => d.id === dungeon.id);
@@ -701,51 +701,51 @@ const Map = () => {
                        remaining,
                        handlePrimary: () => {
                                if (getDungeonRemainingItems(state, definition)) {
-                                       setState(addDungeonCheck(definition));
+                                       setManualState(addDungeonCheck(definition));
                                } else if (
                                        !hasDungeonBoss(state, definition) || !hasDungeonPrize(state, definition)
                                ) {
                                        if (definition.boss) {
-                                               setState(setBossDefeated(definition, true));
+                                               setManualState(setBossDefeated(definition, true));
                                        }
                                        if (definition.prize) {
-                                               setState(setPrizeAcquired(definition, true));
+                                               setManualState(setPrizeAcquired(definition, true));
                                        }
                                } else {
-                                       setState(resetDungeonChecks(definition));
+                                       setManualState(resetDungeonChecks(definition));
                                        if (definition.boss) {
-                                               setState(setBossDefeated(definition, false));
+                                               setManualState(setBossDefeated(definition, false));
                                        }
                                        if (definition.prize) {
-                                               setState(setPrizeAcquired(definition, false));
+                                               setManualState(setPrizeAcquired(definition, false));
                                        }
                                }
                        },
                        handleSecondary: () => {
                                if (isDungeonCleared(state, definition)) {
                                        if (definition.items) {
-                                               setState(removeDungeonCheck(definition));
+                                               setManualState(removeDungeonCheck(definition));
                                        }
                                        if (definition.boss) {
-                                               setState(setBossDefeated(definition, false));
+                                               setManualState(setBossDefeated(definition, false));
                                        }
                                        if (definition.prize) {
-                                               setState(setPrizeAcquired(definition, false));
+                                               setManualState(setPrizeAcquired(definition, false));
                                        }
                                } else if (getDungeonClearedItems(state, definition)) {
-                                       setState(removeDungeonCheck(definition));
+                                       setManualState(removeDungeonCheck(definition));
                                } else {
-                                       setState(completeDungeonChecks(definition));
+                                       setManualState(completeDungeonChecks(definition));
                                        if (definition.boss) {
-                                               setState(setBossDefeated(definition, true));
+                                               setManualState(setBossDefeated(definition, true));
                                        }
                                        if (definition.prize) {
-                                               setState(setPrizeAcquired(definition, true));
+                                               setManualState(setPrizeAcquired(definition, true));
                                        }
                                }
                        },
                };
-       }, [dungeons, setState, state]);
+       }, [dungeons, setManualState, state]);
 
        const mapLocation = React.useCallback(loc => {
                const remaining = countRemainingLocations(state, loc.checks);
@@ -759,20 +759,20 @@ const Map = () => {
                        status,
                        handlePrimary: () => {
                                if (remaining) {
-                                       setState(clearAll(loc.checks));
+                                       setManualState(clearAll(loc.checks));
                                } else {
-                                       setState(unclearAll(loc.checks));
+                                       setManualState(unclearAll(loc.checks));
                                }
                        },
                        handleSecondary: () => {
                                if (remaining) {
-                                       setState(clearAll(loc.checks));
+                                       setManualState(clearAll(loc.checks));
                                } else {
-                                       setState(unclearAll(loc.checks));
+                                       setManualState(unclearAll(loc.checks));
                                }
                        },
                };
-       }, [setState, state]);
+       }, [setManualState, state]);
 
        const lwDungeons = React.useMemo(() => LW_DUNGEONS.map(mapDungeon), [mapDungeon]);
        const lwLocations = React.useMemo(() => LW_LOCATIONS.map(mapLocation), [mapLocation]);