import React, { createContext, useContext, useReducer, useEffect } from 'react'; import { calculateCost } from 'utils'; const GameContext = createContext(); const initialState = { money: 0, moneyPerShot: 1, experience: 0, experienceOnReset: 0, autoShootInterval: null, autoReloadInterval: null, autoShootEnabled: false, autoReloadEnabled: false, reloadProgress: 0, drugPriceUpgrades: { weed: [], meth: [], cocaine: [] }, shotsLeft: 12, maxShots: 12, reloadTime: 5000, isReloading: false, drugs: { weed: { amount: 0, value: 50 }, meth: { amount: 0, value: 400 }, cocaine: { amount: 0, value: 2500 }, }, production: { weed: 0, meth: 0, cocaine: 0, }, sales: { weed: 0, meth: 0, cocaine: 0, }, upgrades: { damageUpgrade: { level: 0, baseCost: 12, multiplier: 5 }, magazineUpgrade: { level: 0, baseCost: 90, multiplier: 2, maxLevel: 5 }, reloadUpgrade: { level: 0, baseCost: 270, multiplier: 1.5, maxLevel: 5 }, autoShootUpgrade: { level: 0, baseCost: 500, multiplier: 1 }, autoReloadUpgrade: { level: 0, baseCost: 1000, multiplier: 1 }, }, productionBuildings: { // Weed production - 4 tiers with updated costs weedFarm1: { count: 0, baseCost: 500, production: 0.5, drugType: 'weed' }, weedFarm2: { count: 0, baseCost: 500000, production: 2.0, drugType: 'weed' }, weedFarm3: { count: 0, baseCost: 25000000, production: 4.0, drugType: 'weed' }, weedFarm4: { count: 0, baseCost: 750000000, production: 8.0, drugType: 'weed' }, // Meth production - 4 tiers with updated costs methLab1: { count: 0, baseCost: 1000000, production: 0.5, drugType: 'meth' }, methLab2: { count: 0, baseCost: 750000000, production: 2.0, drugType: 'meth' }, methLab3: { count: 0, baseCost: 50000000000, production: 4.0, drugType: 'meth' }, methLab4: { count: 0, baseCost: 1000000000000, production: 8.0, drugType: 'meth' }, // Cocaine production - 4 tiers with updated costs cocaineLab1: { count: 0, baseCost: 25000000000000, production: 0.5, drugType: 'cocaine' }, cocaineLab2: { count: 0, baseCost: 750000000000000, production: 2.0, drugType: 'cocaine' }, cocaineLab3: { count: 0, baseCost: 2500000000000000, production: 4.0, drugType: 'cocaine' }, cocaineLab4: { count: 0, baseCost: 1000000000000000000, production: 8.0, drugType: 'cocaine' }, }, // Crew members sell specific drugs crew: { // Weed dealers weedDealer: { count: 0, baseCost: 500, sales: 0.5, drugType: 'weed' }, weedEnforcer: { count: 0, baseCost: 1000000, sales: 2.0, drugType: 'weed' }, weedSupplier: { count: 0, baseCost: 500000000, sales: 5.0, drugType: 'weed' }, // Meth dealers methDealer: { count: 0, baseCost: 1000000, sales: 0.5, drugType: 'meth' }, methEnforcer: { count: 0, baseCost: 500000000, sales: 2.0, drugType: 'meth' }, methSupplier: { count: 0, baseCost: 30000000000, sales: 5.0, drugType: 'meth' }, // Cocaine dealers cocaineDealer: { count: 0, baseCost: 25000000000, sales: 0.5, drugType: 'cocaine' }, cocaineEnforcer: { count: 0, baseCost: 2000000000000, sales: 2.0, drugType: 'cocaine' }, cocaineSupplier: { count: 0, baseCost: 1000000000000000, sales: 5.0, drugType: 'cocaine' }, }, buildings: { corner: { count: 0, baseCost: 5000, income: 20 }, lab: { count: 0, baseCost: 25000, income: 100 }, warehouse: { count: 0, baseCost: 100000, income: 500 }, }, passiveIncome: 0, totalShots: 0, totalEarned: 0, drugPricePrestigeUpgrades: {}, shootRewardPrestigeUpgrades: {}, // Legacy stats that persist through soft resets legacyStats: { totalShots: 0, totalEarned: 0, totalReloads: 0 }, }; function gameReducer(state, action) { switch (action.type) { case 'UPGRADE_DRUG_PRICE': { const { drugType, multiplier, cost, upgradeId } = action.payload; // Check if player can afford the upgrade if (state.money < cost) return state; // Check if upgrade is already purchased const isAlreadyPurchased = state.drugPriceUpgrades && state.drugPriceUpgrades[drugType] && state.drugPriceUpgrades[drugType].includes(upgradeId); if (isAlreadyPurchased) return state; // Update drug price const updatedDrugs = {...state.drugs}; updatedDrugs[drugType] = { ...updatedDrugs[drugType], value: updatedDrugs[drugType].value * multiplier }; // Update purchased upgrades list const updatedDrugPriceUpgrades = {...state.drugPriceUpgrades}; if (!updatedDrugPriceUpgrades[drugType]) { updatedDrugPriceUpgrades[drugType] = []; } updatedDrugPriceUpgrades[drugType] = [...updatedDrugPriceUpgrades[drugType], upgradeId]; return { ...state, money: state.money - cost, drugs: updatedDrugs, drugPriceUpgrades: updatedDrugPriceUpgrades }; } case 'SHOOT': if (state.shotsLeft <= 0 || state.isReloading) return state; // Calculate the bonus percentage from shooting income boosts const shootingBoostPercentage = Object.entries(state.shootRewardPrestigeUpgrades) .reduce((total, [key, isUnlocked]) => { if (isUnlocked) { if (key.startsWith('shootReward') && parseInt(key.slice(-1)) <= 3) { return total + 0.01; // 1% for first three upgrades } else if (key.startsWith('shootReward') && parseInt(key.slice(-1)) > 3) { return total + 0.02; // 2% for last three upgrades } } return total; }, 0); // Calculate the boosted money per shot const boostedMoneyPerShot = state.moneyPerShot * (1 + shootingBoostPercentage); return { ...state, money: state.money + boostedMoneyPerShot, shotsLeft: state.shotsLeft - 1, totalShots: state.totalShots + 1, totalEarned: state.totalEarned + boostedMoneyPerShot, legacyStats: { ...state.legacyStats, totalShots: state.legacyStats.totalShots + 1, totalEarned: state.legacyStats.totalEarned + boostedMoneyPerShot } }; case 'RELOAD': return { ...state, isReloading: true, reloadProgress: 0 }; case 'RELOAD_COMPLETE': return { ...state, shotsLeft: state.maxShots, isReloading: false, reloadProgress: 0, legacyStats: { ...state.legacyStats, totalReloads: state.legacyStats.totalReloads + 1 } }; case 'UPDATE_RELOAD_PROGRESS': return { ...state, reloadProgress: action.payload }; case 'PURCHASE_UPGRADE': { const { category, item } = action.payload; const currentLevel = state[category][item].level; const cost = calculateCost( state[category][item].baseCost, currentLevel ); if (state.money < cost) return state; let newState = { ...state, money: state.money - cost, [category]: { ...state[category], [item]: { ...state[category][item], level: currentLevel + 1 } } }; // Apply effects based on upgrade if (item === 'damageUpgrade') { // Custom multiplier progression based on level let multiplier = 1; // First 10 levels with specific multipliers: 5,4,3,2,2,2,6.66,8.88,10,12 const firstTenMultipliers = [5, 4, 3, 2, 2, 2, 6.66, 8.88, 10, 12]; if (currentLevel < 10) { multiplier = firstTenMultipliers[currentLevel]; } // Levels 11-25 all give x2 else if (currentLevel < 25) { multiplier = 2; } // Levels 26-50 gradually decrease from 1.75 to 1.25 else if (currentLevel < 50) { // Linear interpolation from 1.75 to 1.25 over 25 levels multiplier = 1.75 - ((currentLevel - 25) * (0.5 / 24)); } // Calculate the new moneyPerShot by multiplying the current value newState.moneyPerShot = Math.floor(state.moneyPerShot * multiplier); } else if (item === 'magazineUpgrade') { // Double clip size with each upgrade, max 5 levels if (currentLevel + 1 <= state[category][item].maxLevel) { newState.maxShots = initialState.maxShots * Math.pow(2, currentLevel + 1); } } else if (item === 'reloadUpgrade') { // First upgrade divides by 1.5, last by 1.1 (at level 5) if (currentLevel + 1 <= state[category][item].maxLevel) { // Scale from 1.5 down to 1.1 over 5 levels const reloadFactor = 1.5 - ((currentLevel) * 0.1); newState.reloadTime = initialState.reloadTime / Math.pow(reloadFactor, currentLevel + 1); } } return newState; } case 'PURCHASE_CREW': { const { type } = action.payload; // Use the same growth formula as farms: first_upgrade_cost × 1.794^(n-1) const cost = Math.floor( state.crew[type].baseCost * Math.pow(1.794, state.crew[type].count) ); if (state.money < cost) return state; const newCount = state.crew[type].count + 1; // Update sales rates for the corresponding drug type const newSales = { ...state.sales }; // Update sales rate for the specific drug type this crew member sells const drugType = state.crew[type].drugType; newSales[drugType] += state.crew[type].sales; return { ...state, money: state.money - cost, crew: { ...state.crew, [type]: { ...state.crew[type], count: newCount } }, sales: newSales }; } case 'PURCHASE_BUILDING': { const { type } = action.payload; const cost = calculateCost( state.buildings[type].baseCost, state.buildings[type].count ); if (state.money < cost) return state; const newCount = state.buildings[type].count + 1; const newPassiveIncome = recalculatePassiveIncome({ ...state.buildings, [type]: { ...state.buildings[type], count: newCount } }); return { ...state, money: state.money - cost, buildings: { ...state.buildings, [type]: { ...state.buildings[type], count: newCount } }, passiveIncome: newPassiveIncome }; } case 'COLLECT_PASSIVE_INCOME': return { ...state, money: state.money + state.passiveIncome, totalEarned: state.totalEarned + state.passiveIncome, legacyStats: { ...state.legacyStats, totalEarned: state.legacyStats.totalEarned + state.passiveIncome } }; case 'PURCHASE_PRODUCTION_BUILDING': { const { type } = action.payload; // Use the new growth formula: C_n = first_upgrade_cost × 1.794^(n-1) const cost = Math.floor( state.productionBuildings[type].baseCost * Math.pow(1.794, state.productionBuildings[type].count) ); if (state.money < cost) return state; const newCount = state.productionBuildings[type].count + 1; const newProduction = calculateDrugProduction({ ...state.productionBuildings, [type]: { ...state.productionBuildings[type], count: newCount } }); return { ...state, money: state.money - cost, productionBuildings: { ...state.productionBuildings, [type]: { ...state.productionBuildings[type], count: newCount } }, production: newProduction }; } case 'PURCHASE_EXPERIENCE_UPGRADE': { const { item } = action.payload; let cost = 0; let upgradeObject = {}; // Determine if it's a shoot reward or drug price upgrade if (item === 'autoShootUpgrade' || item === 'autoReloadUpgrade') { // Auto shoot and reload upgrades cost 100 exp each cost = 100; upgradeObject = 'upgrades'; } else if (item.startsWith('shootReward')) { // Find the matching upgrade in the shooting upgrades list for (const upgrade of experienceUpgrades.shooting) { if (upgrade.id === item) { cost = upgrade.cost; break; } } upgradeObject = 'shootRewardPrestigeUpgrades'; } else if (item.startsWith('allDrugPrice')) { // Find the matching upgrade in the drug price upgrades list for (const upgrade of experienceUpgrades.drugPrices) { if (upgrade.id === item) { cost = upgrade.cost; break; } } upgradeObject = 'drugPricePrestigeUpgrades'; } // Check if player has enough experience if (state.experience < cost) return state; // Apply the upgrade effects let newState = { ...state, experience: state.experience - cost }; // Handle the different upgrade types if (upgradeObject === 'upgrades') { // For auto shoot and reload, increase their level newState.upgrades = { ...state.upgrades, [item]: { ...state.upgrades[item], level: 1 } }; } else { // For prestige upgrades, set the flag to true newState[upgradeObject] = { ...state[upgradeObject], [item]: true }; } // Apply specific effects based on the upgrade type if (item.startsWith('allDrugPrice')) { // Apply 2x multiplier to all drug prices const newDrugs = { ...state.drugs }; Object.keys(newDrugs).forEach(drugType => { newDrugs[drugType].value = newDrugs[drugType].value * 2; }); newState.drugs = newDrugs; } return newState; } case 'PURCHASE_PERMANENT_UPGRADE': { const { category, id, cost } = action.payload; // Check if player can afford the upgrade if (state.money < cost) return state; // Check if the upgrade is already purchased if (state[category] && state[category][id]) return state; // Create new state with the upgrade purchased let newState = JSON.parse(JSON.stringify(initialState)); // Keep all permanent upgrades from previous state newState.drugPricePrestigeUpgrades = { ...state.drugPricePrestigeUpgrades, ...(category === 'drugPricePrestigeUpgrades' ? { [id]: true } : {}) }; newState.shootRewardPrestigeUpgrades = { ...state.shootRewardPrestigeUpgrades, ...(category === 'shootRewardPrestigeUpgrades' ? { [id]: true } : {}) }; // Apply effects of all permanent upgrades // Handle auto upgrades for all purchased permanent upgrades Object.keys(newState.shootRewardPrestigeUpgrades).forEach(upgradeId => { if (upgradeId === 'autoShoot') { newState.upgrades.autoShootUpgrade = { level: 1, baseCost: 500, multiplier: 1 }; } else if (upgradeId === 'autoReload') { newState.upgrades.autoReloadUpgrade = { level: 1, baseCost: 1000, multiplier: 1 }; } }); // Apply drug price upgrade effects - count how many are purchased const drugPriceUpgradeCount = Object.keys(newState.drugPricePrestigeUpgrades).filter( key => newState.drugPricePrestigeUpgrades[key] ).length; // Apply the effect of each drug price upgrade (each doubles the price) if (drugPriceUpgradeCount > 0) { Object.keys(newState.drugs).forEach(drugType => { // Apply 2^n multiplier where n is the number of upgrades newState.drugs[drugType].value = initialState.drugs[drugType].value * Math.pow(2, drugPriceUpgradeCount); }); } // Keep legacy stats newState.legacyStats = { ...state.legacyStats }; // Reset experienceOnReset newState.experienceOnReset = 0; return newState; } case 'PROCESS_DRUGS': { // Clone the current drug amounts const newDrugAmounts = { ...state.drugs }; let moneyEarned = 0; // Process production - add drugs based on production rates Object.entries(state.production).forEach(([drugType, rate]) => { if (rate > 0) { newDrugAmounts[drugType].amount += rate; } }); // Process sales - convert drugs to money based on sales rates and values Object.entries(state.sales).forEach(([drugType, rate]) => { if (rate > 0 && newDrugAmounts[drugType].amount > 0) { // Calculate how much can actually be sold const amountToSell = Math.min(rate, newDrugAmounts[drugType].amount); // Reduce drug amount newDrugAmounts[drugType].amount -= amountToSell; // Add money based on drug value moneyEarned += amountToSell * newDrugAmounts[drugType].value; } }); // Return updated state return { ...state, drugs: newDrugAmounts, money: state.money + moneyEarned, totalEarned: state.totalEarned + moneyEarned, experience: calculateExperience(state.totalEarned + moneyEarned), experienceOnReset: calculateExperience(state.totalEarned + moneyEarned), legacyStats: { ...state.legacyStats, totalEarned: state.legacyStats.totalEarned + moneyEarned } }; } case 'SOFT_RESET': { // Create a new state object based on the initial state const newState = JSON.parse(JSON.stringify(initialState)); // Only keep the new experience points from experienceOnReset newState.experience = state.experienceOnReset; // Reset experienceOnReset to 0 newState.experienceOnReset = 0; return newState; } case 'HARD_RESET': return initialState; case 'LOAD_GAME': return action.payload; case 'DEV_ADD_MONEY': return { ...state, money: state.money + action.payload, totalEarned: state.totalEarned + action.payload }; case 'DEV_ADD_EXP': return { ...state, experience: state.experience + action.payload }; case 'DEV_UNLOCK_ALL_UPGRADES': // Unlock all regular gun upgrades const maxedUpgrades = {}; Object.keys(state.upgrades).forEach(upgradeKey => { const maxLevel = state.upgrades[upgradeKey].maxLevel || 25; // Default to 25 if no max level maxedUpgrades[upgradeKey] = { ...state.upgrades[upgradeKey], level: maxLevel }; }); // Unlock all experience upgrades const allDrugPriceUpgrades = {}; experienceUpgrades.drugPrices.forEach(upgrade => { allDrugPriceUpgrades[upgrade.id] = true; }); const allShootRewardUpgrades = {}; experienceUpgrades.shooting.forEach(upgrade => { allShootRewardUpgrades[upgrade.id] = true; }); // Apply x1000 multiplier to money per shot and max shots return { ...state, upgrades: maxedUpgrades, drugPricePrestigeUpgrades: allDrugPriceUpgrades, shootRewardPrestigeUpgrades: allShootRewardUpgrades, moneyPerShot: state.moneyPerShot * 1000, maxShots: state.maxShots * 10, reloadTime: 500, // Set reload time to 0.5 seconds experience: state.experience + 10000000 // Add 10M experience points }; case 'TOGGLE_AUTO_SHOOT': return { ...state, autoShootEnabled: !state.autoShootEnabled }; case 'TOGGLE_AUTO_RELOAD': return { ...state, autoReloadEnabled: !state.autoReloadEnabled }; default: return state; } } function recalculatePassiveIncome(buildings) { let total = 0; // Only buildings contribute to passive income now // Crews sell drugs instead of generating direct income Object.values(buildings).forEach(building => { total += building.count * building.income; }); return total; } // Function to calculate drug production rates based on buildings function calculateDrugProduction(buildings) { const production = { weed: 0, meth: 0, cocaine: 0 }; // Calculate production for each building Object.entries(buildings).forEach(([key, building]) => { if (building.count > 0) { production[building.drugType] += building.count * building.production; } }); return production; } // Function to calculate drug sales rates based on dealers function calculateDrugSales(dealers) { const sales = { weed: 0, meth: 0, cocaine: 0 }; // Calculate sales for each dealer type Object.entries(dealers).forEach(([key, dealer]) => { if (dealer.count > 0) { sales[dealer.drugType] += dealer.count * dealer.sales; } }); return sales; } // Define experience upgrades for reference in PURCHASE_EXPERIENCE_UPGRADE const experienceUpgrades = { shooting: [ { id: 'shootReward1', cost: 1562500000 }, { id: 'shootReward2', cost: 1110888900000 }, { id: 'shootReward3', cost: 30625000000000 }, { id: 'shootReward4', cost: 140625000000000 }, { id: 'shootReward5', cost: 1562500000000000 }, { id: 'shootReward6', cost: 25000000000000000000000 } ], drugPrices: [ { id: 'allDrugPrice1', cost: 2500000 }, { id: 'allDrugPrice2', cost: 6250000000 }, { id: 'allDrugPrice3', cost: 2500000000000 }, { id: 'allDrugPrice4', cost: 62500000000000 }, { id: 'allDrugPrice5', cost: 625000000000000000 }, { id: 'allDrugPrice6', cost: 30625000000000000000 } ] }; // Experience is calculated based on total earned money with the formula: 20 * sqrt(totalMoney/1e7) function calculateExperience(totalMoney) { return Math.floor(20 * Math.sqrt(totalMoney / 1e7)); } export function GameProvider({ children }) { const [state, dispatch] = useReducer(gameReducer, initialState); // Passive income collector useEffect(() => { const interval = setInterval(() => { if (state.passiveIncome > 0) { dispatch({ type: 'COLLECT_PASSIVE_INCOME' }); } }, 1000); return () => clearInterval(interval); }, [state.passiveIncome]); // Drug production and sales cycle useEffect(() => { const interval = setInterval(() => { // Only dispatch if there's any production or sales happening if (state.production.weed > 0 || state.production.meth > 0 || state.production.cocaine > 0 || state.sales.weed > 0 || state.sales.meth > 0 || state.sales.cocaine > 0) { dispatch({ type: 'PROCESS_DRUGS' }); } }, 1000); return () => clearInterval(interval); }, [state.production, state.sales]); // Auto-shoot and auto-reload effects useEffect(() => { let autoShootInterval = null; let autoReloadInterval = null; // Set up auto-shooting if (state.autoShootEnabled && state.upgrades.autoShootUpgrade.level > 0) { autoShootInterval = setInterval(() => { if (!state.isReloading && state.shotsLeft > 0) { dispatch({ type: 'SHOOT' }); } }, 200); // Shoot every 200ms } // Set up auto-reloading if (state.autoReloadEnabled && state.upgrades.autoReloadUpgrade.level > 0) { autoReloadInterval = setInterval(() => { if (state.shotsLeft === 0 && !state.isReloading) { dispatch({ type: 'RELOAD' }); // Set up timer to update reload progress const startTime = Date.now(); const reloadTime = state.reloadTime; const progressInterval = setInterval(() => { const elapsedTime = Date.now() - startTime; const progress = Math.min((elapsedTime / reloadTime) * 100, 100); dispatch({ type: 'UPDATE_RELOAD_PROGRESS', payload: progress }); if (progress >= 100) { clearInterval(progressInterval); dispatch({ type: 'RELOAD_COMPLETE' }); } }, 16); // Update at roughly 60fps } }, 100); // Check for reload every 100ms } // Cleanup on unmount return () => { if (autoShootInterval) clearInterval(autoShootInterval); if (autoReloadInterval) clearInterval(autoReloadInterval); }; }, [ state.autoShootEnabled, state.autoReloadEnabled, state.upgrades.autoShootUpgrade.level, state.upgrades.autoReloadUpgrade.level, state.isReloading, state.shotsLeft, state.reloadTime ]); return ( {children} ); } export function useGame() { return useContext(GameContext); }