eggsss

Author: 1vcian

src/components/Profile/MiscPanel.tsx

@@ -4,12 +4,14 @@ import { useGameData } from '../../hooks/useGameData';
 import { useForgeUpgradeStats } from '../../hooks/useForgeCalculator';
 import { Card } from '../UI/Card';
 import { Button } from '../UI/Button';
+import { SpriteIcon } from '../UI/SpriteIcon';
 import { Plus, Minus } from 'lucide-react';
 
 export function MiscPanel() {
     const { profile, updateNestedProfile } = useProfile();
     const { data: petConfig } = useGameData<any>('PetBaseConfig.json');
     const { data: forgeData } = useGameData<any>('ForgeUpgradeLibrary.json');
+    const { data: forgeConfig } = useGameData<any>('ForgeConfig.json');
 
     // Determine max forge level from config
     const maxForgeLevel = forgeData ? Math.max(...Object.keys(forgeData).map(Number)) : 99;
@@ -140,24 +142,18 @@ export function MiscPanel() {
                             </div>
 
                             {/* Stats */}
-                            <div className="grid grid-cols-2 gap-2">
-                                <div className="flex flex-col items-center bg-bg-input py-2 rounded border border-border">
-                                    <span className="text-text-muted font-bold mb-1">Hammers (Total)</span>
-                                    <span className="font-bold text-text-primary">
-                                        {new Intl.NumberFormat('en-US', { maximumFractionDigits: 0 }).format(upgradeStats.hammersToUpgrade)}
-                                    </span>
-                                    {upgradeStats.freeForgeChance > 0 && (
-                                        <span className="text-[9px] text-text-muted line-through">
-                                            {new Intl.NumberFormat('en-US', { maximumFractionDigits: 0 }).format(upgradeStats.rawHammersNeeded)}
-                                        </span>
-                                    )}
-                                </div>
-
+                            <div className="grid grid-cols-1 gap-2">
                                 <div className="flex flex-col items-center bg-bg-input py-2 rounded border border-border">
                                     <span className="text-text-muted font-bold mb-1">Time</span>
                                     <span className="font-bold text-text-primary">
                                         {formatTime(upgradeStats.totalTimeSeconds)}
                                     </span>
+                                    {forgeConfig && upgradeStats.totalTimeSeconds > 0 && (
+                                        <div className="flex items-center gap-1 mt-0.5 text-accent-primary font-bold">
+                                            <SpriteIcon name="GemSquare" size={12} />
+                                            {Math.ceil(upgradeStats.totalTimeSeconds * (forgeConfig.ForgeGemSkipCostPerSecond || 0.013))}
+                                        </div>
+                                    )}
                                 </div>
                             </div>
                         </div>

src/hooks/useEggsCalculator.ts

@@ -10,8 +10,11 @@ export interface EggOptimizationResult {
     hatchPoints: number;
     mergePoints: number;
     timeUsed: number;
+    baseTimeUsed: number;
+    gemTimeUsed: number;
     timeLeft: number;
     timeline: Timeline;
+    totalGemsUsed: number;
 }
 
 export interface TimelineEvent {
@@ -20,6 +23,7 @@ export interface TimelineEvent {
     endTime: number; // minutes
     duration: number; // minutes
     efficiency: number; // Points Per Second
+    gemCost?: number;
 }
 
 export type Timeline = TimelineEvent[][];
@@ -209,10 +213,11 @@ export function useEggsCalculator() {
     }, [guildWarConfig]);
 
     // --- Optimization Logic ---
+    const { data: forgeConfig } = useGameData<any>('ForgeConfig.json');
+
     const optimization = useMemo((): EggOptimizationResult | null => {
-        if (!hatchValuesProfile || !warPoints) return null;
+        if (!hatchValuesProfile || !warPoints || !forgeConfig) return null;
 
-        const totalMinutesAvailable = timeLimitHours * 60;
         const rarities = ['Common', 'Rare', 'Epic', 'Legendary', 'Ultimate', 'Mythic'];
 
         // 1. Prepare Pool of All Eggs
@@ -265,6 +270,10 @@ export function useEggsCalculator() {
         let hPoints = 0;
         let mPoints = 0;
 
+        let totalGemCost = 0;
+        const gemLimit = profile.misc.useGemsInCalculators ? profile.misc.gemCount : 0;
+        const gemCostPerSecond = forgeConfig.PetGemSkipCostPerSecond || 0.003;
+
         // 3. Greedy Assignment (Least Loaded / Earliest Finish)
         // User wants to balance slots ("non tutto sul primo") and minimize makespan.
         // Since we sorted by Time Descending (Big Rocks), using parameters of LPT (Longest Processing Time) 
@@ -276,10 +285,24 @@ export function useEggsCalculator() {
             let minCurrentTime = Number.MAX_VALUE;
 
             for (let i = 0; i < availableSlots; i++) {
-                // Must fit within limit
-                if (slots[i] + egg.time <= totalMinutesAvailable) {
-                    // We want the LEAST loaded slot to balance
-                    if (slots[i] < minCurrentTime) {
+                // Check if this slot is better (earlier)
+                if (slots[i] < minCurrentTime) {
+                    // Tentatively check if we can afford it with gems
+                    const startTime = slots[i];
+                    const endTime = startTime + egg.time;
+                    const baseMinutesAvailable = timeLimitHours * 60;
+
+                    let potentialGemCost = 0;
+                    if (endTime > baseMinutesAvailable) {
+                        const gemMinutes = Math.min(egg.time, endTime - Math.max(startTime, baseMinutesAvailable));
+                        if (gemMinutes > 0) {
+                            potentialGemCost = Math.ceil((gemMinutes * 60) * gemCostPerSecond);
+                        }
+                    }
+
+                    // Only consider this slot if we can afford the gems AND it fits within the base time limit
+                    // OR if it exceeds base time but we have gems for it.
+                    if (endTime <= baseMinutesAvailable || (totalGemCost + potentialGemCost <= gemLimit)) {
                         minCurrentTime = slots[i];
                         bestSlotIdx = i;
                     }
@@ -291,18 +314,31 @@ export function useEggsCalculator() {
                 const startTime = slots[bestSlotIdx];
                 const endTime = startTime + egg.time;
 
+                // Re-calculate Gem Cost (it should be the same as the check, but cleaner to recalc)
+                const baseMinutesAvailable = timeLimitHours * 60;
+                let gemCost = 0;
+
+                if (endTime > baseMinutesAvailable) {
+                    const gemMinutes = Math.min(egg.time, endTime - Math.max(startTime, baseMinutesAvailable));
+                    if (gemMinutes > 0) {
+                        gemCost = Math.ceil((gemMinutes * 60) * gemCostPerSecond);
+                    }
+                }
+
                 // Commit
                 slots[bestSlotIdx] = endTime;
                 timeline[bestSlotIdx].push({
                     rarity: egg.rarity,
                     startTime,
                     endTime,
                     duration: egg.time,
-                    efficiency: egg.eff
+                    efficiency: egg.eff,
+                    gemCost
                 });
                 toOpen[egg.rarity] = (toOpen[egg.rarity] || 0) + 1;
                 hPoints += egg.hPoints;
                 mPoints += egg.mPoints;
+                totalGemCost += gemCost;
             }
         }
 
@@ -313,12 +349,15 @@ export function useEggsCalculator() {
             totalPoints: hPoints + mPoints,
             hatchPoints: hPoints,
             mergePoints: mPoints,
-            timeUsed: makeSpan, // This will now be <= totalMinutesAvailable
-            timeLeft: totalMinutesAvailable - makeSpan,
-            timeline
+            timeUsed: makeSpan,
+            baseTimeUsed: Math.min(makeSpan, (timeLimitHours * 60)),
+            gemTimeUsed: Math.max(0, makeSpan - (timeLimitHours * 60)),
+            timeLeft: Math.max(0, (timeLimitHours * 60) - makeSpan),
+            timeline,
+            totalGemsUsed: totalGemCost
         };
 
-    }, [ownedEggs, timeLimitHours, availableSlots, hatchValuesProfile, warPoints]);
+    }, [ownedEggs, timeLimitHours, availableSlots, hatchValuesProfile, warPoints, forgeConfig, profile.misc.gemCount, profile.misc.useGemsInCalculators]);
 
     // --- Tech Tree Bonus (Additive Chance) ---
     const eggDungeonBonus = useMemo(() => {

src/hooks/useTreeOptimizer.ts

@@ -15,6 +15,7 @@ export interface TechUpgrade {
     points: number;
     tier: number;
     sprite_rect?: { x: number; y: number; width: number; height: number };
+    gemCost?: number;
 }
 
 export function useTreeOptimizer() {
@@ -77,8 +78,10 @@ export function useTreeOptimizer() {
     };
 
     // 4. Optimization Logic
+    const { data: forgeConfig } = useGameData<any>('ForgeConfig.json');
+
     const optimization = useMemo(() => {
-        if (!mapping || !library || !upgradeLibrary || !dayConfig) return null;
+        if (!mapping || !library || !upgradeLibrary || !dayConfig || !forgeConfig) return null;
 
         // Map Tier -> Points
         const tierPoints: Record<number, number> = {
@@ -107,25 +110,31 @@ export function useTreeOptimizer() {
         }
 
         let totalPoints = 0;
-        let timeRemainingSeconds = timeLimitHours * 3600;
+        const baseTimeLimitSeconds = timeLimitHours * 3600;
+
+        // Track resources
+        let accumulatedTimeSeconds = 0;
+        let accumulatedGemCost = 0;
+        const gemLimit = (profile.misc.useGemsInCalculators ? profile.misc.gemCount : 0);
         let potionsRemaining = potions;
+
         const actions: TechUpgrade[] = [];
+        const gemCostPerSecond = forgeConfig.TechTreeGemSkipCostPerSecond || 0.003;
 
         // Simple Greedy Simulation
-        // While we have time and potions, find all "available" upgrades
-        // Selection criteria: Max (Points / Duration) to fit most inside 1h or 24h?
-        // Actually Max Points / Duration is usually best for time-limited ranking
-
         const maxIter = 500; // Safety break
         let iter = 0;
 
-        while (timeRemainingSeconds > 0 && potionsRemaining > 0 && iter < maxIter) {
+        // We continue as long as we can potentially perform an action.
+        // Determining "can perform" is handled inside by the search for a candidate.
+        while (iter < maxIter) {
             iter++;
-            const possibleUpgrades: TechUpgrade[] = [];
 
             // Calculate current bonuses
             const bonuses = calculateTechBonuses(currentTree);
 
+            const possibleUpgrades: TechUpgrade[] = [];
+
             // Find all available upgrades
             Object.entries(mapping.trees || {}).forEach(([treeName, treeDef]: [string, any]) => {
                 treeDef.nodes.forEach((node: any) => {
@@ -137,7 +146,7 @@ export function useTreeOptimizer() {
                     if (currentLvl < maxLvl) {
                         // Check requirements
                         const reqsMet = (node.requirements || []).every((reqId: number) => {
-                            return (currentTree[treeName]?.[reqId] || 0) >= 1; // Usually need lvl 1 to unlock next
+                            return (currentTree[treeName]?.[reqId] || 0) >= 1;
                         });
 
                         if (reqsMet) {
@@ -173,36 +182,76 @@ export function useTreeOptimizer() {
             if (possibleUpgrades.length === 0) break;
 
             // Sort by efficiency (Points / Duration)
-            // If duration is 0, give it high priority
             possibleUpgrades.sort((a, b) => (b.points / (b.duration || 1)) - (a.points / (a.duration || 1)));
 
-            // Find first one that fits budget
-            const best = possibleUpgrades.find(upg => upg.cost <= potionsRemaining && upg.duration <= timeRemainingSeconds);
+            // Find first one that fits budget (Potions AND Gems)
+            const best = possibleUpgrades.find(upg => {
+                // Check Potion Cost
+                if (upg.cost > potionsRemaining) return false;
+
+                // Check Gem Cost
+                const startTime = accumulatedTimeSeconds;
+                const endTime = startTime + upg.duration;
+                let neededGems = 0;
+
+                if (endTime > baseTimeLimitSeconds) {
+                    const overlap = Math.min(upg.duration, endTime - Math.max(startTime, baseTimeLimitSeconds));
+                    if (overlap > 0) {
+                        neededGems = Math.ceil(overlap * gemCostPerSecond);
+                    }
+                }
+
+                if (neededGems > (gemLimit - accumulatedGemCost)) return false;
+
+                return true;
+            });
 
             if (best) {
-                actions.push(best);
+                // Re-calculate gem cost to attach (could optimize by returning it from find, but this is cheap)
+                const startTime = accumulatedTimeSeconds;
+                const endTime = startTime + best.duration;
+                let gemCost = 0;
+                if (endTime > baseTimeLimitSeconds) {
+                    const overlap = Math.min(best.duration, endTime - Math.max(startTime, baseTimeLimitSeconds));
+                    if (overlap > 0) {
+                        gemCost = Math.ceil(overlap * gemCostPerSecond);
+                    }
+                }
+
+                actions.push({ ...best, gemCost });
+
                 totalPoints += best.points;
                 potionsRemaining -= best.cost;
-                timeRemainingSeconds -= best.duration;
+                accumulatedTimeSeconds += best.duration;
+                accumulatedGemCost += gemCost;
+
                 // Update virtual tree
                 if (!currentTree[best.tree]) currentTree[best.tree] = {};
                 currentTree[best.tree][best.nodeId] = best.toLevel;
             } else {
-                // No more upgrades fit
+                // No upgrades fit our remaining resources
                 break;
             }
         }
 
+        // Calculate total time used
+        const usedSeconds = accumulatedTimeSeconds;
+        const gemTimeSeconds = Math.max(0, usedSeconds - baseTimeLimitSeconds);
+        const baseTimeSeconds = Math.min(usedSeconds, baseTimeLimitSeconds);
+
         return {
             totalPoints,
             actions,
-            timeUsed: (timeLimitHours * 3600 - timeRemainingSeconds) / 3600,
+            timeUsed: usedSeconds / 3600,
+            baseTimeUsed: baseTimeSeconds / 3600,
+            gemTimeUsed: gemTimeSeconds / 3600,
             potionsUsed: potions - potionsRemaining,
             remainingPotions: potionsRemaining,
-            finalBonuses: calculateTechBonuses(currentTree)
+            finalBonuses: calculateTechBonuses(currentTree),
+            totalGemsUsed: accumulatedGemCost
         };
 
-    }, [mapping, library, upgradeLibrary, dayConfig, treeMode, profile.techTree, timeLimitHours, potions]);
+    }, [mapping, library, upgradeLibrary, dayConfig, treeMode, profile.techTree, timeLimitHours, potions, forgeConfig, profile.misc.gemCount, profile.misc.useGemsInCalculators]);
 
     const applyUpgrades = (selectedActions: TechUpgrade[]) => {
         if (selectedActions.length === 0) return;