X-Git-Url: https://git.localhorst.tv/?a=blobdiff_plain;f=resources%2Fjs%2Fcomponents%2Ftracker%2FMap.js;h=3ee4b2f81458ab4eeb6190273623467406788bc1;hb=1b1f6865fb04dcec9e5c55b876cc9ff25706de23;hp=9c27a3476ff938d7ce4a56be9ae642d67e00c7df;hpb=7514794352d72e31689d161a6a7658604ddc1249;p=alttp.git

diff --git a/resources/js/components/tracker/Map.js b/resources/js/components/tracker/Map.js
index 9c27a34..3ee4b2f 100644
--- a/resources/js/components/tracker/Map.js
+++ b/resources/js/components/tracker/Map.js
@@ -3,11 +3,21 @@ import React from 'react';
 import { useTranslation } from 'react-i18next';
 
 import {
+	addDungeonCheck,
+	aggregateDungeonStatus,
+	aggregateLocationStatus,
 	clearAll,
-	decrement,
+	completeDungeonChecks,
+	countRemainingLocations,
+	getDungeonClearedItems,
+	getDungeonRemainingItems,
 	hasDungeonBoss,
-	increment,
-	toggleBoolean,
+	hasDungeonPrize,
+	isDungeonCleared,
+	removeDungeonCheck,
+	resetDungeonChecks,
+	setBossDefeated,
+	setPrizeAcquired,
 	unclearAll,
 } from '../../helpers/tracker';
 import { useTracker } from '../../hooks/tracker';
@@ -636,8 +646,8 @@ const Location = ({ number, l, size }) => {
 	>
 		<title>{t(`tracker.location.${l.id}`)}</title>
 		<rect className="box" x="0" y="0" />
-		{number && l.cleared < l.total ?
-			<text className="text" x="0" y="0">{Math.max(0, l.total - l.cleared)}</text>
+		{number && l.remaining ?
+			<text className="text" x="0" y="0">{l.remaining}</text>
 		: null}
 	</g>;
 };
@@ -648,8 +658,8 @@ Location.propTypes = {
 		id: PropTypes.string,
 		x: PropTypes.number,
 		y: PropTypes.number,
-		cleared: PropTypes.number,
-		total: PropTypes.number,
+		number: PropTypes.number,
+		remaining: PropTypes.number,
 		status: PropTypes.string,
 		handlePrimary: PropTypes.func,
 		handleSecondary: PropTypes.func,
@@ -677,91 +687,87 @@ const makeBackground = (src, level) => {
 };
 
 const Map = () => {
-	const { dungeons, setState, state } = useTracker();
+	const { dungeons, logic, setManualState, state } = useTracker();
 
 	const mapDungeon = React.useCallback(dungeon => {
 		const definition = dungeons.find(d => d.id === dungeon.id);
-		const cleared = state[`${dungeon.id}-checks`] || 0;
-		const total = definition.items;
-		let status = 'available';
-		if (cleared === total) {
-			if (['ct', 'gt'].includes(dungeon.id)) {
-				if (hasDungeonBoss(state, dungeon)) {
-					status = 'cleared';
-				}
-			} else {
-				status = 'cleared';
-			}
-		}
+		const remaining = getDungeonRemainingItems(state, definition);
+		const status = aggregateDungeonStatus(definition, logic, state);
 		return {
 			...dungeon,
 			status,
-			cleared,
-			total,
+			remaining,
 			handlePrimary: () => {
-				if (['ct', 'gt'].includes(dungeon.id) && cleared === total) {
-					if (hasDungeonBoss(state, dungeon)) {
-						// reset
-						setState(s => ({
-							...s,
-							[`${dungeon.id}-checks`]: 0,
-							[`${dungeon.id}-boss-defeated`]: false,
-						}));
-					} else {
-						setState(toggleBoolean(`${dungeon.id}-boss-defeated`));
+				if (getDungeonRemainingItems(state, definition)) {
+					setManualState(addDungeonCheck(definition));
+				} else if (
+					!hasDungeonBoss(state, definition) || !hasDungeonPrize(state, definition)
+				) {
+					if (definition.boss) {
+						setManualState(setBossDefeated(definition, true));
+					}
+					if (definition.prize) {
+						setManualState(setPrizeAcquired(definition, true));
 					}
 				} else {
-					setState(increment(`${dungeon.id}-checks`, total));
+					setManualState(resetDungeonChecks(definition));
+					if (definition.boss) {
+						setManualState(setBossDefeated(definition, false));
+					}
+					if (definition.prize) {
+						setManualState(setPrizeAcquired(definition, false));
+					}
 				}
 			},
 			handleSecondary: () => {
-				if (['ct', 'gt'].includes(dungeon.id) &&
-					(hasDungeonBoss(state, dungeon) || !cleared)
-				) {
-					if (hasDungeonBoss(state, dungeon)) {
-						setState(toggleBoolean(`${dungeon.id}-boss-defeated`));
-					} else {
-						setState(s => ({
-							...s,
-							[`${dungeon.id}-checks`]: total,
-							[`${dungeon.id}-boss-defeated`]: true,
-						}));
+				if (isDungeonCleared(state, definition)) {
+					if (definition.items) {
+						setManualState(removeDungeonCheck(definition));
+					}
+					if (definition.boss) {
+						setManualState(setBossDefeated(definition, false));
+					}
+					if (definition.prize) {
+						setManualState(setPrizeAcquired(definition, false));
 					}
+				} else if (getDungeonClearedItems(state, definition)) {
+					setManualState(removeDungeonCheck(definition));
 				} else {
-					setState(decrement(`${dungeon.id}-checks`, total));
+					setManualState(completeDungeonChecks(definition));
+					if (definition.boss) {
+						setManualState(setBossDefeated(definition, true));
+					}
+					if (definition.prize) {
+						setManualState(setPrizeAcquired(definition, true));
+					}
 				}
 			},
 		};
-	}, [dungeons, setState, state]);
+	}, [dungeons, logic, setManualState, state]);
 
 	const mapLocation = React.useCallback(loc => {
-		const cleared = loc.checks.reduce((acc, cur) => state[cur] ? acc + 1 : acc, 0);
-		const total = loc.checks.length;
-		let status = 'available';
-		if (cleared === total) {
-			status = 'cleared';
-		}
+		const remaining = countRemainingLocations(state, loc.checks);
+		const status = aggregateLocationStatus(loc.checks, logic, state);
 		return {
 			...loc,
-			cleared,
-			total,
+			remaining,
 			status,
 			handlePrimary: () => {
-				if (cleared < total) {
-					setState(clearAll(loc.checks));
+				if (remaining) {
+					setManualState(clearAll(loc.checks));
 				} else {
-					setState(unclearAll(loc.checks));
+					setManualState(unclearAll(loc.checks));
 				}
 			},
 			handleSecondary: () => {
-				if (cleared < total) {
-					setState(clearAll(loc.checks));
+				if (remaining) {
+					setManualState(clearAll(loc.checks));
 				} else {
-					setState(unclearAll(loc.checks));
+					setManualState(unclearAll(loc.checks));
 				}
 			},
 		};
-	}, [setState, state]);
+	}, [logic, setManualState, state]);
 
 	const lwDungeons = React.useMemo(() => LW_DUNGEONS.map(mapDungeon), [mapDungeon]);
 	const lwLocations = React.useMemo(() => LW_LOCATIONS.map(mapLocation), [mapLocation]);