Merge branch 'master' of https://github.com/Pseudo-Corp/SynergismOfficial

Author: Pseudonian

Sample_Saves/Synergism2.5 - (1) c10 completed.txt

@@ -201,9 +201,10 @@ export const addTimers = (input: TimerInput, time = 0) => {
 
       let timeToAmbrosia = calculateRequiredBlueberryTime()
 
-      const maxAccelMultiplier = (1/2) + (3/5 - 1/2) * +(player.singularityChallenges.noAmbrosiaUpgrades.completions >= 15) 
-                                  + (2/3 - 3/5) * +(player.singularityChallenges.noAmbrosiaUpgrades.completions >= 19)
-                                  + (3/4 - 2/3) * +(player.singularityChallenges.noAmbrosiaUpgrades.completions >= 20)
+      const maxAccelMultiplier = (1 / 2)
+        + (3 / 5 - 1 / 2) * +(player.singularityChallenges.noAmbrosiaUpgrades.completions >= 15)
+        + (2 / 3 - 3 / 5) * +(player.singularityChallenges.noAmbrosiaUpgrades.completions >= 19)
+        + (3 / 4 - 2 / 3) * +(player.singularityChallenges.noAmbrosiaUpgrades.completions >= 20)
 
       while (player.blueberryTime >= timeToAmbrosia) {
         const RNG = Math.random()
@@ -219,7 +220,10 @@ export const addTimers = (input: TimerInput, time = 0) => {
         timeToAmbrosia = calculateRequiredBlueberryTime()
         const secondsToNextAmbrosia = timeToAmbrosia / G.ambrosiaCurrStats.ambrosiaGenerationSpeed
 
-        G.ambrosiaTimer += Math.min(secondsToNextAmbrosia * maxAccelMultiplier, ambrosiaToGain * 0.2 * player.shopUpgrades.shopAmbrosiaAccelerator)
+        G.ambrosiaTimer += Math.min(
+          secondsToNextAmbrosia * maxAccelMultiplier,
+          ambrosiaToGain * 0.2 * player.shopUpgrades.shopAmbrosiaAccelerator
+        )
         timeToAmbrosia = calculateRequiredBlueberryTime()
       }
 

Sample_Saves/Synergism2.5 - (10) Omega completed.txt

@@ -136,7 +136,7 @@ import {
 
 import i18next from 'i18next'
 import localforage from 'localforage'
-import { BlueberryUpgrade, blueberryUpgradeData } from './BlueberryUpgrades'
+import { BlueberryUpgrade, blueberryUpgradeData, updateLoadoutHoverClasses } from './BlueberryUpgrades'
 import { DOMCacheGetOrSet } from './Cache/DOM'
 import { lastUpdated, prod, testing, version } from './Config'
 import { WowCubes, WowHypercubes, WowPlatonicCubes, WowTesseracts } from './CubeExperimental'
@@ -1590,6 +1590,8 @@ const loadSynergy = async () => {
       return
     }
 
+    updateLoadoutHoverClasses()
+
     player.lastExportedSave = data.lastExportedSave ?? 0
 
     if (data.offerpromo24used !== undefined) {
@@ -1634,12 +1636,6 @@ const loadSynergy = async () => {
       player.loaded10101 = false
     }
 
-    // Fix dumb shop stuff
-    // First, if shop isn't even defined we just define it as so
-    if (data.shopUpgrades === undefined) {
-      player.shopUpgrades = Object.assign({}, blankSave.shopUpgrades)
-    }
-
     if (typeof player.researches[76] === 'undefined') {
       player.codes.set(13, false)
       player.researches.push(
@@ -1936,9 +1932,8 @@ const loadSynergy = async () => {
 
     // checkVariablesOnLoad(data)
 
-    if (data.ascensionCount === undefined || player.ascensionCount === 0) {
-      player.ascensionCount = 0
-      if (player.ascensionCounter === 0 && player.prestigeCount > 0) {
+    if (player.ascensionCount === 0) {
+      if (player.prestigeCount > 0) {
         player.ascensionCounter = 86400 * 90
       }
       /*player.cubeUpgrades = [null, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -1969,12 +1964,6 @@ const loadSynergy = async () => {
         globalSpeed: 0
       }
     }
-    if (data.autoAntSacTimer == null) {
-      player.autoAntSacTimer = 900
-    }
-    if (data.autoAntSacrificeMode === undefined) {
-      player.autoAntSacrificeMode = 0
-    }
 
     if (player.transcendCount < 0) {
       player.transcendCount = 0
@@ -2015,25 +2004,6 @@ const loadSynergy = async () => {
       }
     }
 
-    if (data.history === undefined) {
-      player.history = { ants: [], ascend: [], reset: [], singularity: [] }
-    } else {
-      // See: https://discord.com/channels/677271830838640680/964168000360038481/964168002071330879
-      const keys = Object.keys(
-        blankSave.history
-      ) as (keyof (typeof blankSave)['history'])[]
-
-      for (const historyKey of keys) {
-        if (!(historyKey in player.history)) {
-          player.history[historyKey] = []
-        }
-      }
-    }
-
-    if (data.historyShowPerSecond === undefined) {
-      player.historyShowPerSecond = false
-    }
-
     if (!Number.isInteger(player.ascendBuilding1.cost)) {
       player.ascendBuilding1.cost = 1
       player.ascendBuilding1.owned = 0

Sample_Saves/Synergism2.5 - (11) Ready for first singularity.txt

@@ -20,18 +20,11 @@ const decimalSchema = z.custom<Decimal>((value) => {
   }
 }).transform((decimalSource) => new Decimal(decimalSource))
 
-const arrayStartingWithNull = (s: ZodType) =>
-  z.array(z.union([z.null(), s]))
-    .refine((arr) => arr.length > 0 && arr[0] === null, {
-      message: 'First element must be null'
-    })
-    .refine((arr) => arr.slice(1).every((element) => typeof element === 'number'), {
-      message: 'All elements after the first must be numbers'
-    })
+const arrayStartingWithNull = (s: ZodType) => z.tuple([z.null()]).rest(s)
 
-const arrayExtend = (array: number[], k: keyof Player) => {
+const arrayExtend = <K extends keyof Player, Value extends Player[K]>(array: Value, k: K) => {
   if (array.length < blankSave[k].length) {
-    array.push(...Array(blankSave[k].length - array.length).fill(0))
+    array.push(...blankSave[k].slice(array.length))
   }
   return array
 }
@@ -64,17 +57,18 @@ const toggleSchema = z.record(z.string(), z.boolean()).transform((record) => {
 const decimalStringSchema = z.string().regex(/^|-?\d+(\.\d{1,2})?$/)
 const integerStringSchema = z.string().regex(/^\d+$/)
 
-const hepteractCraftSchema = z.object({
-  AUTO: z.boolean(),
-  BAL: z.number(),
-  BASE_CAP: z.number(),
-  CAP: z.number(),
-  DISCOUNT: z.number(),
-  HEPTERACT_CONVERSION: z.number(),
-  HTML_STRING: z.string(),
-  OTHER_CONVERSIONS: z.record(z.string(), z.number()),
-  UNLOCKED: z.boolean()
-})
+const hepteractCraftSchema = (k: keyof Player['hepteractCrafts']) =>
+  z.object({
+    AUTO: z.boolean().default(() => blankSave.hepteractCrafts[k].AUTO),
+    BAL: z.number().default(() => blankSave.hepteractCrafts[k].BAL),
+    BASE_CAP: z.number(),
+    CAP: z.number().default(() => blankSave.hepteractCrafts[k].CAP),
+    DISCOUNT: z.number().default(() => blankSave.hepteractCrafts[k].DISCOUNT),
+    HEPTERACT_CONVERSION: z.number(),
+    HTML_STRING: z.string().default(() => blankSave.hepteractCrafts[k].HTML_STRING),
+    OTHER_CONVERSIONS: z.record(z.string(), z.number()),
+    UNLOCKED: z.boolean().default(() => blankSave.hepteractCrafts[k].UNLOCKED)
+  })
 
 export const playerSchema = z.object({
   firstPlayed: z.string().datetime().optional().default(() => new Date().toISOString()),
@@ -304,7 +298,7 @@ export const playerSchema = z.object({
   maxobtainiumpersecond: z.number().default(() => blankSave.maxobtainiumpersecond),
   maxobtainium: z.number().default(() => blankSave.maxobtainium),
 
-  researches: z.number().array(),
+  researches: z.number().array().transform((array) => arrayExtend(array, 'researches')),
 
   unlocks: z.record(z.string(), z.boolean()),
   achievements: z.number().array().transform((array) => arrayExtend(array, 'achievements')),
@@ -448,8 +442,8 @@ export const playerSchema = z.object({
   ascensionCounterReal: z.number().default(() => blankSave.ascensionCounterReal),
   ascensionCounterRealReal: z.number().default(() => blankSave.ascensionCounterRealReal),
   cubeUpgrades: arrayStartingWithNull(z.number())
-    .transform((array) => arrayExtend(array, 'cubeUpgrades'))
-    .default(() => [...blankSave.cubeUpgrades]),
+    .transform((array) => arrayExtend(array as [null, ...number[]], 'cubeUpgrades'))
+    .default((): [null, ...number[]] => [...blankSave.cubeUpgrades]),
   cubeUpgradesBuyMaxToggle: z.boolean().default(() => blankSave.cubeUpgradesBuyMaxToggle),
   autoCubeUpgradesToggle: z.boolean().default(() => blankSave.autoCubeUpgradesToggle),
   autoPlatonicUpgradesToggle: z.boolean().default(() => blankSave.autoPlatonicUpgradesToggle),
@@ -474,14 +468,14 @@ export const playerSchema = z.object({
   platonicBlessings: z.record(z.string(), z.number()).default(() => ({ ...blankSave.platonicBlessings })),
 
   hepteractCrafts: z.object({
-    chronos: hepteractCraftSchema,
-    hyperrealism: hepteractCraftSchema,
-    quark: hepteractCraftSchema,
-    challenge: hepteractCraftSchema,
-    abyss: hepteractCraftSchema,
-    accelerator: hepteractCraftSchema,
-    acceleratorBoost: hepteractCraftSchema,
-    multiplier: hepteractCraftSchema
+    chronos: hepteractCraftSchema('chronos'),
+    hyperrealism: hepteractCraftSchema('hyperrealism'),
+    quark: hepteractCraftSchema('quark'),
+    challenge: hepteractCraftSchema('challenge'),
+    abyss: hepteractCraftSchema('abyss'),
+    accelerator: hepteractCraftSchema('accelerator'),
+    acceleratorBoost: hepteractCraftSchema('acceleratorBoost'),
+    multiplier: hepteractCraftSchema('multiplier')
   }).transform((crafts) => {
     return Object.fromEntries(
       Object.entries(blankSave.hepteractCrafts).map(([key, value]) => {
@@ -521,7 +515,10 @@ export const playerSchema = z.object({
   ),
   corruptionShowStats: z.boolean().default(() => blankSave.corruptionShowStats),
 
-  constantUpgrades: arrayStartingWithNull(z.number()).default(() => [...blankSave.constantUpgrades]),
+  constantUpgrades: arrayStartingWithNull(z.number()).default((): [
+    null,
+    ...number[]
+  ] => [...blankSave.constantUpgrades]),
   // TODO: real types
   history: z.object({
     ants: z.any().array(),
@@ -623,11 +620,7 @@ export const playerSchema = z.object({
         })
       )
     )
-    .default(() => {
-      const v = JSON.parse(JSON.stringify(blankSave.singularityUpgrades))
-      console.log('DEFAULT SING UPGRADES', v)
-      return v
-    }),
+    .default(() => JSON.parse(JSON.stringify(blankSave.singularityUpgrades))),
   octeractUpgrades: z.record(z.string(), singularityUpgradeSchema('octeractsInvested'))
     .transform((upgrades) =>
       Object.fromEntries(

Sample_Saves/Synergism2.5 - (2) c11 completed.txt

@@ -16,6 +16,8 @@ import type {
 } from '../StatCache'
 import type { Tabs } from '../Tabs'
 
+type ArrayStartingWithNull<T> = [null, ...T[]]
+
 export interface Player {
   firstPlayed: string
   worlds: QuarkHandler
@@ -422,20 +424,20 @@ export interface Player {
   goldenQuarksTimer: number
 
   antPoints: Decimal
-  antUpgrades: (null | number)[]
+  antUpgrades: number[]
   antSacrificePoints: number
   antSacrificeTimer: number
   antSacrificeTimerReal: number
 
   talismanLevels: number[]
   talismanRarity: number[]
-  talismanOne: (null | number)[]
-  talismanTwo: (null | number)[]
-  talismanThree: (null | number)[]
-  talismanFour: (null | number)[]
-  talismanFive: (null | number)[]
-  talismanSix: (null | number)[]
-  talismanSeven: (null | number)[]
+  talismanOne: ArrayStartingWithNull<number>
+  talismanTwo: ArrayStartingWithNull<number>
+  talismanThree: ArrayStartingWithNull<number>
+  talismanFour: ArrayStartingWithNull<number>
+  talismanFive: ArrayStartingWithNull<number>
+  talismanSix: ArrayStartingWithNull<number>
+  talismanSeven: ArrayStartingWithNull<number>
   talismanShards: number
   commonFragments: number
   uncommonFragments: number
@@ -463,7 +465,7 @@ export interface Player {
   openHypercubes: number
   autoOpenPlatonicsCubes: boolean
   openPlatonicsCubes: number
-  cubeUpgrades: [null, ...number[]]
+  cubeUpgrades: ArrayStartingWithNull<number>
   cubeUpgradesBuyMaxToggle: boolean
   autoCubeUpgradesToggle: boolean
   autoPlatonicUpgradesToggle: boolean
@@ -535,7 +537,7 @@ export interface Player {
   corruptionLoadoutNames: string[]
   corruptionShowStats: boolean
 
-  constantUpgrades: [null, ...number[]]
+  constantUpgrades: ArrayStartingWithNull<number>
   history: Record<Category, ResetHistoryEntryUnion[]>
   historyShowPerSecond: boolean
 
@@ -835,13 +837,13 @@ export interface GlobalVariables {
   rune4Talisman: number
   rune5Talisman: number
 
-  talisman1Effect: [null, ...number[]]
-  talisman2Effect: [null, ...number[]]
-  talisman3Effect: [null, ...number[]]
-  talisman4Effect: [null, ...number[]]
-  talisman5Effect: [null, ...number[]]
-  talisman6Effect: [null, ...number[]]
-  talisman7Effect: [null, ...number[]]
+  talisman1Effect: ArrayStartingWithNull<number>
+  talisman2Effect: ArrayStartingWithNull<number>
+  talisman3Effect: ArrayStartingWithNull<number>
+  talisman4Effect: ArrayStartingWithNull<number>
+  talisman5Effect: ArrayStartingWithNull<number>
+  talisman6Effect: ArrayStartingWithNull<number>
+  talisman7Effect: ArrayStartingWithNull<number>
 
   talisman6Power: number
   talisman7Quarks: number
@@ -854,21 +856,21 @@ export interface GlobalVariables {
 
   talismanLevelCostMultiplier: number[]
 
-  talismanPositiveModifier: [null, ...number[]]
-  talismanNegativeModifier: [null, ...number[]]
+  talismanPositiveModifier: ArrayStartingWithNull<number>
+  talismanNegativeModifier: ArrayStartingWithNull<number>
 
-  commonTalismanEnhanceCost: [null, ...number[]]
-  uncommonTalismanEnchanceCost: [null, ...number[]]
-  rareTalismanEnchanceCost: [null, ...number[]]
-  epicTalismanEnhanceCost: [null, ...number[]]
-  legendaryTalismanEnchanceCost: [null, ...number[]]
-  mythicalTalismanEnchanceCost: [null, ...number[]]
+  commonTalismanEnhanceCost: ArrayStartingWithNull<number>
+  uncommonTalismanEnchanceCost: ArrayStartingWithNull<number>
+  rareTalismanEnchanceCost: ArrayStartingWithNull<number>
+  epicTalismanEnhanceCost: ArrayStartingWithNull<number>
+  legendaryTalismanEnchanceCost: ArrayStartingWithNull<number>
+  mythicalTalismanEnchanceCost: ArrayStartingWithNull<number>
 
   talismanRespec: number
 
   obtainiumGain: number
 
-  mirrorTalismanStats: [null, ...number[]]
+  mirrorTalismanStats: ArrayStartingWithNull<number>
   antELO: number
   effectiveELO: number
 
@@ -891,19 +893,19 @@ export interface GlobalVariables {
 
   buildingSubTab: BuildingSubtab
   // number000 of each before Diminishing Returns
-  blessingbase: [null, ...number[]]
-  blessingDRPower: [null, ...number[]]
+  blessingbase: ArrayStartingWithNull<number>
+  blessingDRPower: ArrayStartingWithNull<number>
   giftbase: number[]
   giftDRPower: number[]
-  benedictionbase: [null, ...number[]]
-  benedictionDRPower: [null, ...number[]]
+  benedictionbase: ArrayStartingWithNull<number>
+  benedictionDRPower: ArrayStartingWithNull<number>
   // 10 Million of each before Diminishing returns on first number 200k for second, and 10k for the last few
   platonicCubeBase: number[]
   platonicDRPower: number[]
 
-  cubeBonusMultiplier: [null, ...number[]]
-  tesseractBonusMultiplier: [null, ...number[]]
-  hypercubeBonusMultiplier: [null, ...number[]]
+  cubeBonusMultiplier: ArrayStartingWithNull<number>
+  tesseractBonusMultiplier: ArrayStartingWithNull<number>
+  hypercubeBonusMultiplier: ArrayStartingWithNull<number>
   platonicBonusMultiplier: number[]
 
   autoOfferingCounter: number
@@ -934,7 +936,7 @@ export interface GlobalVariables {
   acceleratorMultiplier: number
   multiplierMultiplier: number
 
-  constUpgradeCosts: [null, ...number[]]
+  constUpgradeCosts: ArrayStartingWithNull<number>
 
   globalConstantMult: Decimal
   autoTalismanTimer: number