Merge pull request 'First development' (#1) from dev into master

Reviewed-on: #1

js/data/achievements.js

@@ -84,8 +84,8 @@ addLayer("ach", {
         },
         34: {
             name: "Super!",
-            done() { return player.sp.points.gte(1) },
+            done() { return player.points.gte(5000) },
-            tooltip: "Reset for 1 SPP."
+            tooltip: "Reach 5000 points."
         },
         35: {
             name: "Where were you??",
@@ -129,11 +129,11 @@ addLayer("ach", {
         },
         53: {
             name: "A new prestige layer!",
-            done() { return player.sp.points.gte(5000) },
+            done() { return player.sp.points.gte(250) },
-            tooltip: "Reach 5000 SPP."
+            tooltip: "Reach 250 SPP."
         },
         54: {
-            name: "Ok so that speeds things up",
+            name: "Retention!",
             done() { return hasMilestone('f', 2) },
             tooltip: "Earn Filestone 3."
         },
@@ -153,14 +153,34 @@ addLayer("ach", {
             tooltip: "Get all row 3 directory upgrades."
         },
         63: {
-            name: "Wait that's all of them?",
+            name: "Now it gets expensive.",
             done() { return player.f.upgrades.map(x => x - 40).filter(x => x >= 0 && x < 9).length == 4 },
             tooltip: "Get all row 4 directory upgrades."
         },
         64: {
-            name: "Well that exploded",
+            name: "Extreme.",
-            done() { return player.i.points.gt(0) },
+            done() { return player.f.upgrades.map(x => x - 50).filter(x => x >= 0 && x < 9).length == 4 },
-            tooltip: "Reset for 1 integral.<br>Current endgame."
+            tooltip: "Get all row 5 directory upgrades."
+        },
+        65: {
+            name: "100 times over.",
+            done() { return player.f.total.gte(100) },
+            tooltip: "Get 100 Files."
+        },
+        71: {
+            name: "Alright I'm out of ideas.",
+            done() { return player.f.upgrades.map(x => x - 60).filter(x => x >= 0 && x < 9).length == 2 },
+            tooltip: "Get all row 6 directory upgrades."
+        },
+        72: {
+            name: "I guess one last achivement?",
+            done() { return getBuyableAmount('f', 11).gte(5) },
+            tooltip: "Get 5 <b>The finale of the intro</b> buyables."
+        },
+        73: {
+            name: "And then comes the prestige layer",
+            done() { return player.points.log(2).gte(128) },
+            tooltip: "Reach " + format(Decimal.pow(2, 128)) + " points"
         },
     },
     tabFormat: [

js/data/files.js

@@ -9,21 +9,49 @@ addLayer("f", {
     }},
     color: "#7f1bae",
     requires() {
-        let req = new Decimal(5000)
+        let req = new Decimal(250)
-        if (hasUpgrade(this.layer, 32)) { req = req.mul(0.75) }
+        if (hasUpgrade(this.layer, 32)) { req = req.mul(0.5) }
-        if (hasMilestone(this.layer, 7)) { req = req.mul(0.8) }
+        if (hasMilestone(this.layer, 9)) { req = req.mul(0.5) }
         return req
     }, // Can be a function that takes requirement increases into account
     resource: "files", // Name of prestige currency
     baseResource: "super progress points", // Name of resource prestige is based on
     baseAmount() {return player.sp.points}, // Get the current amount of baseResource
-    type: "static", // normal: cost to gain currency depends on amount gained. static: cost depends on how much you already have
+    type: "custom", // normal: cost to gain currency depends on amount gained. static: cost depends on how much you already have
-    exponent: 1.5, // Prestige currency exponent
+    exponent() {
+        let exp = 1.3
+        if (hasUpgrade(this.layer, 52)) exp **= 0.9
+        return exp
+    }, // Prestige currency exponent
     base() {
-        let base = 1.5
+        let base = 1.3
         if (hasUpgrade(this.layer, 41)) base **= 0.95
         return base
     },
+    getResetGain(canMax = tmp[this.layer].canBuyMax) {
+        let tlyr = tmp[this.layer]
+        let plyr = player[this.layer]
+        let amount = tlyr.baseAmount.div(tlyr.requires).log(tlyr.base).pow(Decimal.div(1, tlyr.exponent)).add(1)
+            .sub(plyr.points.mul(2).add(plyr.total).div(3)).sqrt().floor().max(0)
+        if (isNaN(amount)) return new Decimal(0)
+        if (!canMax && amount.gte(1)) return new Decimal(1)
+        return amount
+    },
+    getNextAt(canMax = tmp[this.layer].canBuyMax) {
+        let tlyr = tmp[this.layer]
+        let plyr = player[this.layer]
+        if (!canMax) return plyr.points.mul(2).add(plyr.total).div(3).pow(tlyr.exponent).pow_base(tlyr.base).mul(tlyr.requires)
+        return tlyr.getResetGain.pow(2).add(plyr.points).mul(2).add(plyr.total).div(3).pow(tlyr.exponent)
+            .pow_base(tlyr.base).mul(tlyr.requires)
+    },
+    canReset() {
+        return tmp[this.layer].getResetGain.gte(1)
+    },
+    prestigeButtonText() {
+        return "Reset for " + format(tmp[this.layer].getResetGain.max(1)) + " " + tmp[this.layer].resource + "<br><br>Req: "
+            + format(tmp[this.layer].baseAmount) + "/" + format(tmp[this.layer].getNextAt) + " " + tmp[this.layer].baseResource
+    },
+    prestigeNotify() { return tmp[this.layer].canReset },
     gainMult() { // Calculate the multiplier for main currency from bonuses
         return new Decimal(1)
     },
@@ -31,7 +59,7 @@ addLayer("f", {
         return new Decimal(1)
     },
     canBuyMax() {
-        return hasMilestone(this.layer, 6)
+        return hasMilestone(this.layer, 8)
     },
     row: 2, // Row the layer is in on the tree (0 is the first row)
     displayRow: 0,
@@ -41,24 +69,25 @@ addLayer("f", {
     milestones: {
         0: {
             requirementDescription: "1 total File.",
-            effectDescription() {
+            effectDescription: "Triple PP and SPP gen.",
-                return "Total levels boost point gen.<br>Effect: x" + format(getTotalLevel().add(1).log(5).add(1)) + "."
-            },
             done() { return player.f.total.gte(1) }
         },
         1: {
             requirementDescription: "2 total Files.",
-            effectDescription: "Triple PP and SPP gen.",
+            effectDescription() {
+                return "Total levels and super levels boost point gen.<br>Effect: x"
+                    + format(getTotalLevel().add(getTotalSuperLevel()).add(7).log(2)) + "."
+            },
             done() { return player.f.total.gte(2) }
         },
-        2: {
+        3: {
             requirementDescription: "3 total Files.",
-            effectDescription: "Multiply PP requirement by 0.5x.",
+            effectDescription: "Halve PP req.",
             done() { return player.f.total.gte(3) }
         },
-        3: {
+        2: {
             requirementDescription: "4 total Files.",
-            effectDescription: "Square point gen.",
+            effectDescription: "SPP no longer resets PP.",
             done() { return player.f.total.gte(4) }
         },
         4: {
@@ -67,31 +96,44 @@ addLayer("f", {
             done() { return player.f.total.gte(5) }
         },
         5: {
-            requirementDescription: "7 total Files.",
+            requirementDescription: "6 total Files.",
+            effectDescription: "You can now get fractional levels.",
+            done() { return player.f.total.gte(6) }
+        },
+        6: {
+            requirementDescription: "8 total Files.",
             effectDescription() {
                 return "Total Files boost point gen.<br>Effect: x" + format(player[this.layer].total.div(2).add(1)) + "."
             },
-            done() { return player.f.total.gte(7) }
+            done() { return player.f.total.gte(8) }
-        },
-        6: {
-            requirementDescription: "10 total Files.",
-            effectDescription: "You can buy max files.",
-            done() { return player.f.total.gte(10) }
         },
         7: {
-            requirementDescription: "15 total Files.",
+            requirementDescription: "10 total Files.",
-            effectDescription: "Multiply file cost by x0.8.",
+            effectDescription: "Autobuy all PP buyables.",
-            done() { return player.f.total.gte(15) }
+            done() { return player.f.total.gte(10) }
         },
         8: {
-            requirementDescription: "20 total Files.",
+            requirementDescription: "15 total Files.",
-            effectDescription: "Autobuy all PP buyables.",
+            effectDescription: "You can buy max files.",
-            done() { return player.f.total.gte(20) }
+            done() { return player.f.total.gte(15) }
         },
         9: {
-            requirementDescription: "30 total Files.",
+            requirementDescription: "20 total Files.",
-            effectDescription: "You can now get fractional levels.",
+            effectDescription: "Halve base file cost.",
-            done() { return player.f.total.gte(30) }
+            done() { return player.f.total.gte(20) }
+        },
+        10: {
+            requirementDescription: "25 total Files.",
+            effectDescription: "Autobuy both SPP buyables.",
+            done() { return player.f.total.gte(25) }
+        },
+        11: {
+            requirementDescription: "50 total Files.",
+            effectDescription() {
+                return "Total super levels boost second softcap.<br>Effect: ^"
+                    + format(getTotalSuperLevel().pow(1/10).add(1).log(10).add(1)) + "."
+            },
+            done() { return player.f.total.gte(50) }
         },
     },
     upgrades: {
@@ -127,7 +169,7 @@ addLayer("f", {
             branches: [21]
         },
         32: {
-            description: "Multiply base File cost by 0.75.",
+            description: "Halve base File cost.",
             cost: 6,
             canAfford() { return hasUpgrade(this.layer, 21) && hasUpgrade(this.layer, 22) },
             branches: [21, 22]
@@ -151,10 +193,10 @@ addLayer("f", {
             branches: [32]
         },
         43: {
-            description: "Files divide PP cost.",
+            description: "Total Files divide PP cost.",
             cost: 9,
             canAfford() { return hasUpgrade(this.layer, 32) && hasUpgrade(this.layer, 33) },
-            effect() { return player[this.layer].points.add(3).log(2).add(1) },
+            effect() { return player[this.layer].total.add(3).log(2).add(1) },
             effectDisplay() { return "/" + format(this.effect()) + "." },
             branches: [32, 33]
         },
@@ -163,6 +205,64 @@ addLayer("f", {
             cost: 8,
             canAfford() { return hasUpgrade(this.layer, 23) && hasUpgrade(this.layer, 33) },
             branches: [[23, 2], 33]
+        },
+        51: {
+            description: "Multiply all rank effects by 2.",
+            cost: 15,
+            canAfford() { return hasUpgrade(this.layer, 41) && hasUpgrade(this.layer, 43) },
+            branches: [41, [43, 2]]
+        },
+        52: {
+            description: "Raise File cost exponent ^0.8.",
+            cost: 13,
+            canAfford() { return hasUpgrade(this.layer, 42) },
+            branches: [42]
+        },
+        53: {
+            description: "Total files boost point gen.",
+            cost: 14,
+            canAfford() { return hasUpgrade(this.layer, 43) },
+            effect() { return player[this.layer].points.log(10).add(1) },
+            effectDisplay() { return "^" + format(this.effect()) + "." },
+            branches: [43]
+        },
+        54: {
+            description: "Halve base SPP cost.",
+            cost: 13,
+            canAfford() { return hasUpgrade(this.layer, 43) },
+            branches: [43]
+        },
+        61: {
+            description: "Decrease the second softcap's log base.",
+            cost: 20,
+            canAfford() { return hasUpgrade(this.layer, 51) && hasUpgrade(this.layer, 52) },
+            branches: [51, 52]
+        },
+        62: {
+            description: "Gain 20% of your SPP gain per second.",
+            cost: 20,
+            canAfford() { return hasUpgrade(this.layer, 53) && hasUpgrade(this.layer, 44) },
+            branches: [53, [44, 2]]
+        }
+    },
+    buyables: {
+        11: {
+            title: "The finale of the intro",
+            effect() { return Decimal.pow(1.5, getBuyableAmount(this.layer, this.id)) },
+            cost() { return Decimal.mul(getBuyableAmount(this.layer, this.id), 10) },
+            display() {
+                return "Increase point gen.<br><br>Amount: " + format(getBuyableAmount(this.layer, this.id))
+                    + ".<br>Effect: x" + format(this.effect(getBuyableAmount(this.layer, this.id))) + ".<br>Cost: "
+                    + format(this.cost(getBuyableAmount(this.layer, this.id))) + " Files."
+            },
+            canAfford() {
+                return Decimal.gte(player[this.layer].points, this.cost())
+                    && hasUpgrade(this.layer, 61) && hasUpgrade(this.layer, 62)
+            },
+            buy() {
+                addBuyables(this.layer, this.id, 1)
+                player[this.layer].points = player[this.layer].points.sub(this.cost())
+            }
         }
     },
     clickables: {
@@ -170,13 +270,10 @@ addLayer("f", {
             display() { return "Reset directory" },
             onClick() {
                 if (confirm("Are you sure you want to respec? This will cause a File reset.")) {
-                    if (player[this.layer].upgrades == 0) {
+                    if (player[this.layer].upgrades == 0) player.ach.has55 = true
-                        player.ach.has55 = true
+                    player[this.layer].points = player[this.layer].total
-                    }
-                    for (let i of player[this.layer].upgrades) {
-                        player[this.layer].points = player[this.layer].points.add(tmp[this.layer].upgrades[i].cost)
-                    }
                     player[this.layer].upgrades = []
+                    player[this.layer].buyables[11] = new Decimal(0)
                     doReset('f', true)
                 }
             },
@@ -187,7 +284,7 @@ addLayer("f", {
             }
         }
     },
-    layerShown(){ return player.p.points.gte(4000) || player[this.layer].unlocked },
+    layerShown(){ return player.sp.points.gte(400) || player[this.layer].unlocked },
     branches: ['p'],
     tabFormat: {
         filestones: {
@@ -198,8 +295,8 @@ addLayer("f", {
                 "blank",
                 "blank",
                 ["row", [
-                    ["milestones", [0, 2, 4, 6, 8]],
+                    ["milestones", [0, 2, 4, 6, 8, 10]],
-                    ["milestones", [1, 3, 5, 7, 9]]
+                    ["milestones", [1, 3, 5, 7, 9, 11]]
                 ]]
             ]
         },
@@ -216,8 +313,11 @@ addLayer("f", {
                     [11],
                     [21, 22, 23],
                     [31, 32, 33],
-                    [41, 42, 43, 44]
+                    [41, 42, 43, 44],
-                ]]
+                    [51, 52, 53, 54],
+                    [61, 62]
+                ]],
+                "buyables"
             ],
             unlocked() { return hasMilestone('f', 4) }
         },

js/data/integrals.js

@@ -7,7 +7,7 @@ addLayer("i", {
 		points: new Decimal(0)
     }},
     color: "#a62222",
-    requires: Decimal.pow(2, 127), // Can be a function that takes requirement increases into account
+    requires: Decimal.pow(2, 127.9), // Can be a function that takes requirement increases into account
     resource: "integrals", // Name of prestige currency
     baseResource: "points", // Name of resource prestige is based on
     baseAmount() {return player.points}, // Get the current amount of baseResource

js/data/levels.js

@@ -8,7 +8,7 @@ function inverseCumulativeExponential(base, levels) {
 function getAlphaLevel(points = player.p.points) {
     if (Decimal.eq(points, 0)) return new Decimal(0)
     const level = inverseCumulativeExponential(1.1, Decimal.pow(points, buyableEffect('p', 13).pow(-1)))
-    return hasMilestone('f', 9) ? level : level.floor()
+    return hasMilestone('f', 5) ? level : level.floor()
 }
 function getAlphaCost(points = player.p.points) {
     return cumulativeExponential(1.1, getAlphaLevel(points).floor()).pow(buyableEffect('p', 13))
@@ -19,7 +19,7 @@ function getAlphaEffect(points = player.p.points) {
 function getBetaLevel(points = player.p.points) {
     if (Decimal.eq(points, 0)) return new Decimal(0)
     const level = inverseCumulativeExponential(1.25, Decimal.div(Decimal.pow(points, buyableEffect('p', 13).pow(-1)), 5))
-    return hasMilestone('f', 9) ? level : level.floor()
+    return hasMilestone('f', 5) ? level : level.floor()
 }
 function getBetaCost(points = player.p.points) {
     return cumulativeExponential(1.25, getBetaLevel(points).floor()).mul(5).pow(buyableEffect('p', 13))
@@ -30,7 +30,7 @@ function getBetaEffect(points = player.p.points) {
 function getGammaLevel(points = player.p.points) {
     if (Decimal.eq(points, 0)) return new Decimal(0)
     const level = inverseCumulativeExponential(1.5, Decimal.div(Decimal.pow(points, buyableEffect('p', 13).pow(-1)), 15))
-    return hasMilestone('f', 9) ? level : level.floor()
+    return hasMilestone('f', 5) ? level : level.floor()
 }
 function getGammaCost(points = player.p.points) {
     return cumulativeExponential(1.5, getGammaLevel(points).floor()).mul(15).pow(buyableEffect('p', 13))
@@ -41,7 +41,7 @@ function getGammaEffect(points = player.p.points) {
 function getDeltaLevel(points = player.p.points) {
     if (Decimal.eq(points, 0)) return new Decimal(0)
     const level = inverseCumulativeExponential(2, Decimal.div(Decimal.pow(points, buyableEffect('p', 13).pow(-1)), 30))
-    return hasMilestone('f', 9) ? level : level.floor()
+    return hasMilestone('f', 5) ? level : level.floor()
 }
 function getDeltaCost(points = player.p.points) {
     return cumulativeExponential(2, getDeltaLevel(points).floor()).mul(30).pow(buyableEffect('p', 13))
@@ -52,7 +52,7 @@ function getDeltaEffect(points = player.p.points) {
 function getEpsilonLevel(points = player.p.points) {
     if (Decimal.eq(points, 0)) return new Decimal(0)
     const level = inverseCumulativeExponential(2.5, Decimal.div(Decimal.pow(points, buyableEffect('p', 13).pow(-1)), 50))
-    return hasMilestone('f', 9) ? level : level.floor()
+    return hasMilestone('f', 5) ? level : level.floor()
 }
 function getEpsilonCost(points = player.p.points) {
     return cumulativeExponential(2.5, getEpsilonLevel(points).floor()).mul(50).pow(buyableEffect('p', 13))
@@ -63,7 +63,7 @@ function getEpsilonEffect(points = player.p.points) {
 function getZetaLevel(points = player.p.points) {
     if (Decimal.eq(points, 0)) return new Decimal(0)
     const level = inverseCumulativeExponential(3, Decimal.div(Decimal.pow(points, buyableEffect('p', 13).pow(-1)), 80))
-    return hasMilestone('f', 9) ? level : level.floor()
+    return hasMilestone('f', 5) ? level : level.floor()
 }
 function getZetaCost(points = player.p.points) {
     return cumulativeExponential(3, getZetaLevel(points).floor()).mul(80).pow(buyableEffect('p', 13))

js/data/progress.js

@@ -23,11 +23,17 @@ addLayer("p", {
         let mult = new Decimal(1)
         mult = mult.mul(buyableEffect(this.layer, 11))
         mult = mult.mul(getThetaEffect())
-	    if (hasMilestone('f', 1)) mult = mult.mul(3)
+        if (hasMilestone('f', 0)) mult = mult.mul(3)
         return mult
     },
     gainExp() { // Calculate the exponent on main currency from bonuses
-        return buyableEffect('sp', 11)
+        return new Decimal(1)
+    },
+    doReset(resettingLayer) {
+        if (layers[resettingLayer].row <= this.row) return;
+        let keep = []
+        if (hasMilestone('f', 3) && resettingLayer == 'sp') keep.push("points")
+        layerDataReset(this.layer, keep)
     },
     row: 0, // Row the layer is in on the tree (0 is the first row)
     hotkeys: [
@@ -40,7 +46,7 @@ addLayer("p", {
         return gain
     },
     automate() {
-        if (hasMilestone('f', 8)) {
+        if (hasMilestone('f', 7)) {
             Object.values(tmp[this.layer].buyables).forEach(i => { if (i.canAfford) i.buy() })
         }
     },
@@ -206,7 +212,7 @@ addLayer("p", {
             effect() { return Decimal.add(getBuyableAmount(this.layer, this.id), hasUpgrade('f', 21) ? 2 : 0).pow_base(0.95) },
             cost() { return Decimal.pow(getBuyableAmount(this.layer, this.id), 1.4).mul(7).add(80) },
             display() {
-                return "Decrease Gamma effect base.<br><br>Amount: " + format(getBuyableAmount(this.layer, this.id))
+                return "Decrease Gamma effect log base.<br><br>Amount: " + format(getBuyableAmount(this.layer, this.id))
                     + ".<br>Effect: ^" + format(this.effect(getBuyableAmount(this.layer, this.id))) + ".<br>Cost: "
                     + format(this.cost(getBuyableAmount(this.layer, this.id))) + " total levels."
             },

js/data/ranks.js

@@ -6,7 +6,7 @@ function getAlphaRankCost(points = player.p.points) {
     return getAlphaRank(points).add(1).mul(20)
 }
 function getAlphaRankEffect(points = player.p.points) {
-    return getAlphaRank(points).div(25)
+    return getAlphaRank(points).div(25).mul(hasUpgrade('f', 51) + 1)
 }
 function getBetaRank(points = player.p.points) {
     if (Decimal.eq(points, 0)) return new Decimal(0)
@@ -16,7 +16,7 @@ function getBetaRankCost(points = player.p.points) {
     return getBetaRank(points).add(1).mul(15)
 }
 function getBetaRankEffect(points = player.p.points) {
-    return getBetaRank(points).div(100).mul(3)
+    return getBetaRank(points).div(100).mul(3).mul(hasUpgrade('f', 51) + 1)
 }
 function getGammaRank(points = player.p.points) {
     if (Decimal.eq(points, 0)) return new Decimal(0)
@@ -26,7 +26,7 @@ function getGammaRankCost(points = player.p.points) {
     return getGammaRank(points).add(1).mul(12)
 }
 function getGammaRankEffect(points = player.p.points) {
-    return getGammaRank(points).div(15)
+    return getGammaRank(points).div(15).mul(hasUpgrade('f', 51) + 1)
 }
 function getDeltaRank(points = player.p.points) {
     if (Decimal.eq(points, 0)) return new Decimal(0)
@@ -36,7 +36,7 @@ function getDeltaRankCost(points = player.p.points) {
     return getDeltaRank(points).add(1).mul(10)
 }
 function getDeltaRankEffect(points = player.p.points) {
-    return getDeltaRank(points).div(20)
+    return getDeltaRank(points).div(20).mul(hasUpgrade('f', 51) + 1)
 }
 function getEpsilonRank(points = player.p.points) {
     if (Decimal.eq(points, 0)) return new Decimal(0)
@@ -46,7 +46,7 @@ function getEpsilonRankCost(points = player.p.points) {
     return getEpsilonRank(points).add(1).mul(8)
 }
 function getEpsilonRankEffect(points = player.p.points) {
-    return getEpsilonRank(points).div(10)
+    return getEpsilonRank(points).div(10).mul(hasUpgrade('f', 51) + 1)
 }
 function getZetaRank(points = player.p.points) {
     if (Decimal.eq(points, 0)) return new Decimal(0)
@@ -56,7 +56,7 @@ function getZetaRankCost(points = player.p.points) {
     return getZetaRank(points).add(1).mul(7)
 }
 function getZetaRankEffect(points = player.p.points) {
-    return getZetaRank(points).div(5)
+    return getZetaRank(points).div(5).mul(hasUpgrade('f', 51) + 1)
 }
 
 function getTotalRank() {

js/data/super progress.js

@@ -7,28 +7,42 @@ addLayer("sp", {
 		points: new Decimal(0)
     }},
     color: "#107f76",
-    requires: 15000, // Can be a function that takes requirement increases into account
+    requires() {
+        let req = new Decimal(5000)
+        if (hasUpgrade('f', 54)) req = req.div(2)
+        return req
+    }, // Can be a function that takes requirement increases into account
     resource: "super progress points", // Name of prestige currency
     baseResource: "points", // Name of resource prestige is based on
     baseAmount() {return player.points}, // Get the current amount of baseResource
     type: "normal", // normal: cost to gain currency depends on amount gained. static: cost depends on how much you already have
-    exponent: 0.5, // Prestige currency exponent
+    exponent: 0.35, // Prestige currency exponent
     gainMult() { // Calculate the multiplier for main currency from bonuses
         let mult = new Decimal(1)
-	    if (hasMilestone('f', 1)) mult = mult.mul(3)
+        if (hasMilestone('f', 0)) mult = mult.mul(3)
         return mult
     },
     gainExp() { // Calculate the exponent on main currency from bonuses
-        return new Decimal(1)
+        return buyableEffect('sp', 11)
     },
     row: 1, // Row the layer is in on the tree (0 is the first row)
     displayRow: 0,
     hotkeys: [
         {key: "s", description: "S: Reset for super progress points", onPress(){if (canReset(this.layer)) doReset(this.layer)}},
     ],
+    passiveGeneration() {
+        let gain = 0
+        if (hasUpgrade('f', 62)) gain += 0.2
+        return gain
+    },
     onPrestige(gain) {
         if (player.p.points.eq(0)) { player.ach.has45 = true }
     },
+    automate() {
+        if (hasMilestone('f', 10)) {
+            Object.values(tmp[this.layer].buyables).forEach(i => { if (i.canAfford) i.buy() })
+        }
+    },
     bars: {
         eta: {
             direction: RIGHT,
@@ -72,7 +86,7 @@ addLayer("sp", {
             progress() { return player[this.layer].points.div(getKappaCost()) },
             display() {
                 return "Kappa - Level " + format(getKappaLevel()) + " (" + format(player[this.layer].points) + "/" + format(getKappaCost())
-                    + ")<br>Effect: x" + format(getKappaEffect()) + " to softcap."
+                    + ")<br>Effect: x" + format(getKappaEffect()) + " to first softcap."
             },
             fillStyle: {backgroundColor: "#107f76"},
             unlocked() { return getIotaLevel().gt(0) }
@@ -96,7 +110,7 @@ addLayer("sp", {
             effect() { return Decimal.div(getBuyableAmount(this.layer, this.id), 20).add(1) },
             cost() { return Decimal.pow(getBuyableAmount(this.layer, this.id), 1.2).mul(3).add(20) },
             display() {
-                return "Increase PP gain.<br><br>Amount: " + format(getBuyableAmount(this.layer, this.id))
+                return "Increase SPP gain.<br><br>Amount: " + format(getBuyableAmount(this.layer, this.id))
                     + ".<br>Effect: ^" + format(this.effect(getBuyableAmount(this.layer, this.id))) + ".<br>Cost: "
                     + format(this.cost(getBuyableAmount(this.layer, this.id))) + " total super levels."
             },
@@ -153,6 +167,6 @@ addLayer("sp", {
             unlocked() { return getTotalSuperLevel().gte(18) }
         },
     },
-    layerShown(){ return player.points.gte(10000) || player[this.layer].unlocked },
+    layerShown(){ return player.points.gte(4000) || player[this.layer].unlocked },
     branches: ['p'],
 })

js/mod.js

@@ -13,11 +13,24 @@ let modInfo = {
 
 // Set your version in num and name
 let VERSION = {
-	num: "1.2",
+	num: "1.5",
-	name: "First Release",
+	name: "The great rebalancing",
 }
 
 let changelog = `<h1>Changelog:</h1><br><br>
+	<h3>v1.5</h3><br>
+		- Clarified some effects.<br>
+		- Decreased SPP requirement.<br>
+		- Made <b>Even more progress</b> affect SPP gain.<br>
+		- Made Files need SPP instead of PP.<br>
+		- Made File cost dependent on total and points.<br>
+		- Made other changes to File cost.<br>
+		- Reshuffled some Filestones.<br>
+		- Added a new softcap.<br>
+		- Made Directory upgrade [4,3] use total Files.<br>
+		- Added more Filestones and Directory upgrades.<br>
+		- Added a Directory buyable.<br>
+		- Slightly increased Integral cost.<br><br>
 	<h3>v1.2</h3><br>
 		- Added a few missing format() calls.<br>
 		- Added a note for the hardcap.<br>
@@ -64,7 +77,9 @@ function getPointGen() {
 	gain = gain.mul(getZetaEffect())
 	gain = gain.mul(getLambdaEffect())
 	gain = gain.mul(tmp.ach.effect)
-	if (hasMilestone('f', 0)) gain = gain.mul(getTotalLevel().add(1).log(5).add(1))
+	gain = gain.mul(buyableEffect('f', 11))
+	if (hasMilestone('f', 1)) gain = gain.mul(getTotalLevel().add(7).log(2))
+	if (hasMilestone('f', 6)) gain = gain.mul(player.f.total.div(2).add(1))
 	// exponentiative
 	if (gain.gte(1)) {
 		gain = gain.pow(getEpsilonEffect())
@@ -72,9 +87,14 @@ function getPointGen() {
         gain = gain.pow(buyableEffect('sp', 12))
 		if (hasMilestone('f', 3)) gain = gain.pow(2)
 		if (hasUpgrade('f', 11)) gain = gain.pow(upgradeEffect('f', 11))
+		if (hasUpgrade('f', 53)) gain = gain.pow(upgradeEffect('f', 53))
 	}
 	// softcaps
 	gain = softcap(gain, getKappaEffect().mul(1000), d => d.add(1).log(Math.E).add(1).pow(2).sub(1).div(2))
+	gain = softcap(gain,
+		Decimal.pow(1e6, (hasMilestone('f', 11) ? getTotalSuperLevel().add(1).log(2).add(1).log(2).add(1) : 1)),
+		d => d.add(1).log(3 - hasUpgrade('f', 61)).add(1)
+	)
 	gain = softcap(gain, Decimal.pow(2, 128), _ => new Decimal(0), player.points)
 	return gain
 }
@@ -87,9 +107,16 @@ function addedPlayerData() { return {
 var displayThings = [
 	"All exponentiative upgrades only take affect above 1.",
 	() => getPointGen().gte(getKappaEffect().mul(1000)) ? "Your points per second are being logarithmically softcapped over "
-	+ format(getKappaEffect().mul(1000)) + "/s" : "",
+		+ format(getKappaEffect().mul(1000)) + "/s" : "",
+	() => getPointGen().gte(
+		Decimal.pow(1e6, hasMilestone('f', 10) ? getTotalSuperLevel().pow(1/10).add(1).log(10).add(1) : 1)
+	) ? "Your points per second are being logarithmically softcapped again over "
+			+ format(Decimal.pow(
+				1e6, hasMilestone('f', 11) ? getTotalSuperLevel().pow(1/10).add(1).log(10).add(1) : 1
+			)) + "/s"
+		: "",
 	() => getPointGen().add(player.points).gte(Decimal.pow(2, 128)) ? "Your points per second are being hardcapped over "
-	+ format(Decimal.pow(2, 128)) : ""
+		+ format(Decimal.pow(2, 128)) : ""
 ]
 
 // Determines when the game "ends"