incremental-social/The-Modding-Tree
incremental-social/The-Modding-Tree
Template
1
0
Fork 0
mirror of https://github.com/Acamaeda/The-Modding-Tree.git synced 2024-12-18 03:41:34 +00:00
Code Issues Releases Activity Actions
The-Modding-Tree/Old Code/test.js

1872 lines
96 KiB
JavaScript
Raw Normal View History

Test with Despacit Tree Delta, numerous fixes
2020-10-11 18:49:29 +00:00
addLayer("p", {
effect() {return {}},
startData() { return {
unl: true,
points: new Decimal(0),
best: new Decimal(0),
total: new Decimal(0),
}},
color:() => "#00bfbf",
background:() => undefined,
requires:() => new Decimal(10), // Can be a function that takes requirement increases into account
resource: "prestige 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
base: 5, // Only needed for static layers, base of the formula (b^(x^exp))
resCeil: false, // True if the cost needs to be rounded up (use when baseResource is static?)
canBuyMax() {}, // Only needed for static layers with buy max
gainMult() { // Calculate the multiplier for main currency from bonuses
mult = new Decimal(1)
if (player[this.layer].upgrades.includes(21)) mult = mult.times(2)
if (player[this.layer].upgrades.includes(23)) mult = mult.times(this.upgrades[23].effect())
if (player.b.upgrades.includes(11)) mult = mult.times(layers.b.upgrades[11].effect())
if (player.g.upgrades.includes(11)) mult = mult.times(layers.g.upgrades[11].effect())
if (player.e.upgrades.includes(11)) mult = mult.times(layers.e.upgrades[11].effect())
if (player.e.unl) mult = mult.times(layers.e.buyables[11].effect.second)
if (player.d.unl) mult = mult.times(layers.d.buyables[11].effect(player.d.buyables[11]).first)
if (!player.s.active) if (player.pr.buyables[13].gt(0)) mult = mult.times(layers.pr.buyables[13].effect().first)
if (player.s.challs.includes(21)) mult = mult.times(layers.s.challs[21].effect())
return mult.max(1)
},
gainExp() { // Calculate the exponent on main currency from bonuses
let exp = new Decimal(1)
if (player.d.unl && player.d.banking == 1) exp = exp.div(2)
if (player.s.active == 11) exp = exp.div(10)
return exp
},
row: 0, // Row the layer is in on the tree (0 is the first row)
upgrades: {
rows: 2,
cols: 3,
11: {
desc:() => "Gain 1 Point every second.",
cost:() => new Decimal(1),
unl() { return player[this.layer].unl }, // The upgrade is only visible when this is true
},
12: {
desc:() => "Point generation is faster based on your unspent prestige points.",
cost:() => new Decimal(1),
unl() { return player[this.layer].upgrades.includes(11) },
effect() { // Calculate bonuses from the upgrade. Can return a single value or an object with multiple values
if (player.d.banking == 1) return new Decimal(1)
let ret = player[this.layer].points.add(2).pow(0.5)
if (player.s.unl) ret = ret.pow(layers.s.effect())
if (ret.gte("1e20000000")) ret = ret.sqrt().times("1e10000000")
return ret;
},
effectDisplay() { return format(tmp[this.layer].upgrades[this.id].effect)+"x" }, // Add formatting to the effect
},
13: {
desc:() => "Points boost point gain.",
cost:() => new Decimal(5),
unl() { return player[this.layer].upgrades.includes(12) },
effect() { // Calculate bonuses from the upgrade. Can return a single value or an object with multiple values
let ret = player.points.add(1).log10().add(1)
return ret;
},
effectDisplay() { return format(tmp[this.layer].upgrades[this.id].effect)+"x" }, // Add formatting to the effect
},
21: {
desc:() => "Double prestige point gain.",
cost:() => new Decimal(10),
unl() { return player[this.layer].upgrades.includes(13) },
},
22: {
desc:() => "Point generation is faster based on your prestige upgrades.",
cost:() => new Decimal(25),
unl() { return player[this.layer].upgrades.includes(21) },
effect() { // Calculate bonuses from the upgrade. Can return a single value or an object with multiple values
let ret = Decimal.pow(1.4, player[this.layer].upgrades.length)
return ret
},
effectDisplay() { return format(tmp[this.layer].upgrades[this.id].effect)+"x" }, // Add formatting to the effect
},
23: {
desc:() => "Prestige Point gain is boosted by normal Points.",
cost:() => new Decimal(250),
unl() { return player[this.layer].upgrades.includes(22) },
effect() {
let ret = player.points.add(1).log10().cbrt().add(1)
return ret;
},
effectDisplay() { return format(tmp[this.layer].upgrades[this.id].effect)+"x" }, // Add formatting to the effect
},
},
doReset(resettingLayer){ // Triggers when this layer is being reset, along with the layer doing the resetting. Not triggered by lower layers resetting, but is by layers on the same row.
if(resettingLayer == "b") {
if (player.b.milestones.includes("0")) {
let upgrades = player[this.layer].upgrades
fullLayerReset(this.layer)
player[this.layer].upgrades = upgrades
return;
}
}
if(resettingLayer == "g") {
if (player.g.milestones.includes("0")) {
let upgrades = player[this.layer].upgrades
fullLayerReset(this.layer)
player[this.layer].upgrades = upgrades
return;
}
}
if(resettingLayer == "e") {
if (player.e.milestones.includes("0")) {
let upgrades = player[this.layer].upgrades
fullLayerReset(this.layer)
player[this.layer].upgrades = upgrades
return;
}
}
if(resettingLayer == "r") {
if (player.r.milestones.includes("0")) {
let upgrades = player[this.layer].upgrades
fullLayerReset(this.layer)
player[this.layer].upgrades = upgrades
return;
}
}
if(resettingLayer == "d") {
if (player.d.milestones.includes("0")) {
let upgrades = player[this.layer].upgrades
fullLayerReset(this.layer)
player[this.layer].upgrades = upgrades
return;
}
}
if(layers[resettingLayer].row > this.row) fullLayerReset(this.layer) // This is actually the default behavior
},
layerShown() {return true}, // Condition for when layer appears on the tree
update(diff) {
if (player[this.layer].upgrades.includes(11)) player.points = player.points.add(tmp.pointGen.times(diff)).max(0)
}, // Do any gameloop things (e.g. resource generation) inherent to this layer
hotkeys: [
{key: "p", desc: "P: Reset points for prestige points.", onPress(){if (player[this.layer].unl) doReset(this.layer)}},
],
// Optional, lets you format the tab yourself by listing components. You can create your own components in v.js.
tabFormat: ["main-display",
["prestige-button", function() {return "Convert your points into "}],
["blank", "5px"], // Height
["display-text",
function() {return 'You have ' + format(player.points) + ' points.'},
{"font-size": "14px"}],
"upgrades"],
})
addLayer("b", {
startData() { return {
unl: false,
auto: false,
points: new Decimal(0),
best: new Decimal(0),
total: new Decimal(0),
milestones: []
}},
color:() => "#415a9e",
background:() => 'https://cdn.glitch.com/7460ed4d-c31b-459d-8407-710f48e787a3%2Fefdb5b70-5e55-4f23-9524-953a8eea4545.image.png?v=1601771864943',
requires() {
let req = new Decimal(5000)
if (player.g.unl && !player.b.unl) req = req.mul(500)
return req
}, // Can be a function that takes requirement increases into account
resource: "boosters", // Name of prestige currency
baseResource: "points", // Name of resource prestige is based on
baseAmount() {return player.points}, // Get the current amount of baseResource
type: "custom", // normal: cost to gain currency depends on amount gained. static: cost depends on how much you already have
exponent: 1, // Prestige currency exponent
base: 5, // Only needed for static layers, base of the formula (b^(x^exp))
resCeil: false, // True if the cost needs to be rounded up (use when baseResource is static?)
canBuyMax() {
return player[this.layer].milestones.includes("1")
}, // Only needed for static layers with buy max
gainMult() { // Calculate the multiplier for main currency from bonuses
mult = new Decimal(1)
if (player[this.layer].upgrades.includes(21)) mult = mult.div(layers[this.layer].upgrades[21].effect())
if (!player.s.active) if (player.pr.buyables[11].gt(0)) mult = mult.div(layers.pr.buyables[11].effect().first)
if (player.s.challs.includes(12)) mult = mult.div(layers.s.challs[12].effect())
return mult
},
gainExp() { // Calculate the exponent on main currency from bonuses
exp = new Decimal(1)
if (player.d.unl && player.d.banking == 3) exp = exp.div(2)
return exp
},
row: 1, // Row the layer is in on the tree (0 is the first row)
effect() {
let base = new Decimal(2)
if (player[this.layer].upgrades.includes(12)) base = base.add(layers[this.layer].upgrades[12].effect())
if (player[this.layer].upgrades.includes(13)) base = base.add(layers[this.layer].upgrades[13].effect())
if (player.e.unl && tmp.buyables) base = base.add(tmp.e.buyables[11].effect.first)
if (!player.s.active) if (player.pr.buyables[12].gt(0)) base = base.add(layers.pr.buyables[12].effect().first)
if (player.g.upgrades.includes(23)) base = base.mul(2)
if (player.s.active == 11) base = base.pow(0.1)
if (player.d.unl && player.d.banking == 3) base = new Decimal(2)
let exp = new Decimal(1)
if (player.d.banking == 1) exp = exp.div(2)
let free = new Decimal(0)
if (!player.s.active) if (player.pr.buyables[14].gt(0)) free = free.add(layers.pr.buyables[14].effect().first)
return Decimal.pow(base, player[this.layer].points.add(free)).pow(exp)
},
effectDescription:() => "multiplying point gain by "+format(layers[this.layer].effect())+"x",
milestones: {
0: {
requirementDesc:() => "4 boosters",
effectDesc:() => "You don't lose prestige upgrades on booster resets",
done() {
return player[this.layer].best.gte(4) || player.e.milestones.includes("0") || player.r.milestones.includes("0") || player.d.milestones.includes("0");
}
},
1: {
requirementDesc:() => "8 boosters",
effectDesc:() => "You can max-buy boosters.",
done() {
return player[this.layer].best.gte(8);
}
}
},
doReset(resettingLayer){ // Triggers when this layer is being reset, along with the layer doing the resetting. Not triggered by lower layers resetting, but is by layers on the same row.
let unlocked = true
let autoed = player[this.layer].auto
if(resettingLayer == "r") {
if (player.r.milestones.includes("2")) {
let milestones = player[this.layer].milestones
let upgrades = player[this.layer].upgrades
fullLayerReset(this.layer)
player[this.layer].milestones = milestones
player[this.layer].upgrades = upgrades
player[this.layer].unl = unlocked
player[this.layer].auto = autoed
return;
}
if (player.r.milestones.includes("1")) {
let milestones = player[this.layer].milestones
fullLayerReset(this.layer)
player[this.layer].milestones = milestones
player[this.layer].unl = unlocked
player[this.layer].auto = autoed
return;
}
}
if(resettingLayer == "d") {
if (player.d.milestones.includes("2")) {
let milestones = player[this.layer].milestones
let upgrades = player[this.layer].upgrades
fullLayerReset(this.layer)
player[this.layer].milestones = milestones
player[this.layer].upgrades = upgrades
player[this.layer].unl = unlocked
player[this.layer].auto = autoed
return;
}
if (player.d.milestones.includes("1")) {
let milestones = player[this.layer].milestones
fullLayerReset(this.layer)
player[this.layer].milestones = milestones
player[this.layer].unl = unlocked
player[this.layer].auto = autoed
return;
}
}
if(resettingLayer == "e") {
if (player.e.milestones.includes("2")) {
let milestones = player[this.layer].milestones
let upgrades = player[this.layer].upgrades
fullLayerReset(this.layer)
player[this.layer].milestones = milestones
player[this.layer].upgrades = upgrades
player[this.layer].unl = unlocked
player[this.layer].auto = autoed
return;
}
if (player.e.milestones.includes("1")) {
let milestones = player[this.layer].milestones
fullLayerReset(this.layer)
player[this.layer].milestones = milestones
player[this.layer].unl = unlocked
player[this.layer].auto = autoed
return;
}
}
if(layers[resettingLayer].row > this.row) {
fullLayerReset(this.layer) // This is actually the default behavior
player[this.layer].unl = unlocked
}
},
layerShown() {return player.p.unl}, // Condition for when layer appears on the tree
resetsNothing() {return player.e.milestones.includes("3") || player.r.milestones.includes("3") || player.d.milestones.includes("3")},
upgrades: {
rows: 2,
cols: 3,
11: {
desc:() => "Boosters multiply prestige points.",
cost:() => new Decimal(3),
unl() { return player[this.layer].unl }, // The upgrade is only visible when this is true
effect() { // Calculate bonuses from the upgrade. Can return a single value or an object with multiple values
let ret = player[this.layer].points.add(2).log10().add(1).pow(2)
return ret;
},
effectDisplay() { return format(tmp[this.layer].upgrades[this.id].effect)+"x" }, // Add formatting to the effect
},
12: {
desc:() => "Generators add to the base of Boosters.",
cost:() => new Decimal(8),
unl() { return player[this.layer].upgrades.includes(11) && player.g.unl }, // The upgrade is only visible when this is true
effect() { // Calculate bonuses from the upgrade. Can return a single value or an object with multiple values
let ret = player.g.points.add(1).log10().div(3)
return ret;
},
effectDisplay() { return "+"+format(tmp[this.layer].upgrades[this.id].effect) }, // Add formatting to the effect
},
13: {
desc:() => "Prestige Points add to the base of Boosters.",
cost:() => new Decimal(16),
unl() { return player[this.layer].upgrades.includes(12) }, // The upgrade is only visible when this is true
effect() { // Calculate bonuses from the upgrade. Can return a single value or an object with multiple values
let ret = player.p.points.add(1).log10().root(7).div(3)
return ret;
},
effectDisplay() { return "+"+format(tmp[this.layer].upgrades[this.id].effect) }, // Add formatting to the effect
},
21: {
desc:() => "Points divide the Booster cost.",
cost:() => new Decimal(20),
unl() { return player[this.layer].upgrades.includes(13) }, // The upgrade is only visible when this is true
effect() { // Calculate bonuses from the upgrade. Can return a single value or an object with multiple values
let ret = (player.points.add(1)).root(15)
return ret;
},
effectDisplay() { return "/"+format(tmp[this.layer].upgrades[this.id].effect) }, // Add formatting to the effect
},
22: {
desc:() => "Square the Generator Power effect.",
cost:() => new Decimal(21),
unl() { return player[this.layer].upgrades.includes(21) }, // The upgrade is only visible when this is true
},
23: {
desc:() => "Boosters multiply Generator Power gain.",
cost:() => new Decimal(24),
unl() { return player[this.layer].upgrades.includes(22) }, // The upgrade is only visible when this is true
effect() { // Calculate bonuses from the upgrade. Can return a single value or an object with multiple values
let ret = player.b.points.add(1).log10().add(1).pow(5)
return ret;
},
effectDisplay(fx) { return format(tmp[this.layer].upgrades[this.id].effect)+"x" }, // Add formatting to the effect
},
},
hotkeys: [
{key: "b", desc: "B: Reset points for boosters.", onPress(){if (player[this.layer].unl) doReset(this.layer)}},
],
incr_order: [], // Array of layer names to have their order increased when this one is first unlocked
prestigeButtonText() { //Is secretly HTML
return `<span v-if="player[layer].points.lt(10)">Convert your points into </span>+<b>${formatWhole(tmp[layer].resetGain)}</b> ${layers[layer].resource}<br><br><span v-if="player[layer].points.lt(10)">${(tmp[layer].baseAmount.gte(tmp[layer].nextAt)&&layers[layer].canBuyMax && layers[layer].canBuyMax())?"Next":"Req"}: ${formatWhole(tmp[layer].baseAmount)} / </span>${(layers[layer].resCeil ? formatWhole(tmp[layer].nextAtDisp) : format(tmp[layer].nextAtDisp))} ${ layers[layer].baseResource }`
},
getResetGain() {
if ((!layers[layer].canBuyMax()) || tmp[layer].baseAmount.lt(tmp[layer].requires)) return new Decimal(1)
let gain = tmp[layer].baseAmount.div(tmp[layer].requires).div(tmp[layer].gainMult).max(1).log(layers[layer].base).times(tmp[layer].gainExp).pow(Decimal.pow(layers[layer].exponent, -1))
if (gain.gte(12)) {
gain = gain.times(12).sqrt()
}
if (gain.gte(1225)) gain = gain.times(Decimal.pow(1225, 9)).pow(0.1)
return gain.floor().sub(player[layer].points).add(1).max(1);
},
getNextAt() {
let amt = player[layer].points
if (amt.gte(1225)) amt = amt.pow(10).div(Decimal.pow(1225, 9))
if (amt.gte(12)) {
amt = amt.pow(2).div(12)
}
let extraCost = Decimal.pow(layers[layer].base, amt.pow(layers[layer].exponent).div(tmp[layer].gainExp)).times(tmp[layer].gainMult)
let cost = extraCost.times(tmp[layer].requires).max(tmp[layer].requires)
if (layers[layer].resCeil) cost = cost.ceil()
return cost;
},
canReset() {
return tmp[this.layer].baseAmount.gte(tmp[this.layer].nextAt)
},
automate() {
if (player.e.milestones.includes("4") || player.r.milestones.includes("4") || player.d.milestones.includes("4") && player[this.layer].auto) doReset(this.layer, false)
}, // Do any automation inherent to this layer if appropriate
// Optional, lets you format the tab yourself by listing components. You can create your own components in v.js.
tabFormat: ["main-display",
["prestige-button", function() {return "Convert your points into "}, {}],
["blank", "5px"], // Height
["display-text",
function() {return 'You have ' + format(player.points) + ' points.'},
{"font-size": "14px"}],
"upgrades", "blank", "milestones"],
branches: [["p", 1]]
/*style() {return {
'background-color': '#3325CC'
}},*/
})
addLayer("g", {
startData() { return {
unl: false,
auto: false,
points: new Decimal(0),
best: new Decimal(0),
total: new Decimal(0),
power: new Decimal(0),
milestones: []
}},
color:() => "#409c6e",
background:() => 'https://cdn.glitch.com/7460ed4d-c31b-459d-8407-710f48e787a3%2Fefdb5b70-5e55-4f23-9524-953a8eea4545.image.png?v=1601771864943',
requires() {
let req = new Decimal(5000)
if (player.b.unl && !player.g.unl) req = req.mul(500)
return req
}, // Can be a function that takes requirement increases into account
resource: "generators", // Name of prestige currency
baseResource: "points", // Name of resource prestige is based on
baseAmount() {return player.points}, // Get the current amount of baseResource
type: "custom", // normal: cost to gain currency depends on amount gained. static: cost depends on how much you already have
exponent: 1, // Prestige currency exponent
base: 5, // Only needed for static layers, base of the formula (b^(x^exp))
resCeil: false, // True if the cost needs to be rounded up (use when baseResource is static?)
canBuyMax() {
return player[this.layer].milestones.includes("1")
}, // Only needed for static layers with buy max
gainMult() { // Calculate the multiplier for main currency from bonuses
mult = new Decimal(1)
if (player[this.layer].upgrades.includes(21)) mult = mult.div(layers[this.layer].upgrades[21].effect())
if (!player.s.active) if (player.pr.buyables[11].gt(0)) mult = mult.div(layers.pr.buyables[11].effect().first)
if (player.s.challs.includes(12)) mult = mult.div(layers.s.challs[12].effect())
return mult
},
gainExp() { // Calculate the exponent on main currency from bonuses
exp = new Decimal(1)
if (player.d.unl && player.d.banking == 3) exp = exp.div(2)
return exp
},
row: 1, // Row the layer is in on the tree (0 is the first row)
effect() {
let base = new Decimal(2)
if (player[this.layer].upgrades.includes(12)) base = base.add(layers[this.layer].upgrades[12].effect())
if (player[this.layer].upgrades.includes(13)) base = base.add(layers[this.layer].upgrades[13].effect())
if (player.r.upgrades.includes(14)) base = base.add(layers.r.upgrades[14].effect())
if (player.e.unl && tmp.buyables) base = base.add(tmp.e.buyables[11].effect.first)
if (!player.s.active) if (player.pr.buyables[12].gt(0)) base = base.add(layers.pr.buyables[12].effect().first)
if (player.s.active == 11) base = base.pow(0.1)
if (player.d.unl && player.d.banking == 3) base = new Decimal(2)
let genMult = new Decimal(1)
if (player[this.layer].upgrades.includes(14)) genMult = genMult.add(layers[this.layer].upgrades[14].effect())
if (player[this.layer].upgrades.includes(22)) genMult = genMult.add(layers[this.layer].upgrades[22].effect())
if (player.b.upgrades.includes(23)) genMult = genMult.add(layers.b.upgrades[23].effect(player.e.buyables[11]))
if (player.r.unl) genMult = genMult.times(layers.r.effect().powerBoost)
if (player.d.unl) genMult = genMult.times(layers.d.buyables[13].effect(player.d.buyables[13]).first)
let powerPow = new Decimal(1)
if (player.b.upgrades.includes(21)) powerPow = powerPow.add(1)
if (player.d.banking == 1) powerPow = powerPow.div(2)
let freeGens = new Decimal(0)
if (player.r.unl && tmp.buyables) freeGens = freeGens.add(tmp.r.buyables[13].effect.first)
if (!player.s.active) if (player.pr.buyables[14].gt(0)) freeGens = freeGens.add(layers.pr.buyables[14].effect().first)
return {
genProd: Decimal.pow(base, player[this.layer].points.add(freeGens)).sub(1).mul(genMult),
powerBoost: player.g.power.add(1).pow(1/3).pow(powerPow)
}
},
effectDescription() {return "producing "+format(layers[this.layer].effect().genProd)+" generator power each second"},
milestones: {
0: {
requirementDesc:() => "4 generators",
effectDesc:() => "You don't lose prestige upgrades on generator resets",
done() {
return player[this.layer].best.gte(4) || player.e.milestones.includes("0") || player.r.milestones.includes("0") || player.d.milestones.includes("0");
}
},
1: {
requirementDesc:() => "8 generators",
effectDesc:() => "You can buy max generators.",
done() {
return player[this.layer].best.gte(8);
}
},
2: {
requirementDesc:() => "14 generators",
effectDesc:() => "You get 100% of Prestige Points gained on Prestige each second.",
done() {
return player[this.layer].best.gte(14);
}
}
},
doReset(resettingLayer){ // Triggers when this layer is being reset, along with the layer doing the resetting. Not triggered by lower layers resetting, but is by layers on the same row.
if(layers[resettingLayer].row > this.row-1) player.g.power = new Decimal(0)
let unlocked = true
let autoed = player[this.layer].auto
if(resettingLayer == "d") {
if (player.d.milestones.includes("2")) {
let milestones = player[this.layer].milestones
let upgrades = player[this.layer].upgrades
fullLayerReset(this.layer)
player[this.layer].milestones = milestones
player[this.layer].upgrades = upgrades
player[this.layer].unl = unlocked
player[this.layer].auto = autoed
return;
}
if (player.d.milestones.includes("1")) {
let milestones = player[this.layer].milestones
fullLayerReset(this.layer)
player[this.layer].milestones = milestones
player[this.layer].unl = unlocked
player[this.layer].auto = autoed
return;
}
}
if(resettingLayer == "r") {
if (player.r.milestones.includes("2")) {
let milestones = player[this.layer].milestones
let upgrades = player[this.layer].upgrades
fullLayerReset(this.layer)
player[this.layer].milestones = milestones
player[this.layer].upgrades = upgrades
player[this.layer].unl = unlocked
player[this.layer].auto = autoed
return;
}
if (player.r.milestones.includes("1")) {
let milestones = player[this.layer].milestones
fullLayerReset(this.layer)
player[this.layer].milestones = milestones
player[this.layer].unl = unlocked
player[this.layer].auto = autoed
return;
}
}
if(resettingLayer == "e") {
if (player.e.milestones.includes("2")) {
let milestones = player[this.layer].milestones
let upgrades = player[this.layer].upgrades
fullLayerReset(this.layer)
player[this.layer].milestones = milestones
player[this.layer].upgrades = upgrades
player[this.layer].unl = unlocked
player[this.layer].auto = autoed
return;
}
if (player.e.milestones.includes("1")) {
let milestones = player[this.layer].milestones
fullLayerReset(this.layer)
player[this.layer].milestones = milestones
player[this.layer].unl = unlocked
player[this.layer].auto = autoed
return;
}
}
if(layers[resettingLayer].row > this.row) {
fullLayerReset(this.layer) // This is actually the default behavior
player[this.layer].unl = unlocked
}
},
convertToDecimal() {
player.g.power = new Decimal(player.g.power)
// Convert any layer-specific Decimal values (besides points, total, and best) from String to Decimal (used when loading save)
},
layerShown() {return player.p.unl}, // Condition for when layer appears on the tree
automate() {
if (player.e.milestones.includes("4") || player.r.milestones.includes("4") || player.d.milestones.includes("4") && player[this.layer].auto) doReset(this.layer, false)
}, // Do any automation inherent to this layer if appropriate
updateTemp() {
}, // Do any necessary temp updating, not that important usually
update(diff) {
if (player.g.unl) player.g.power = player.g.power.add(layers[this.layer].effect().genProd.mul(diff))
if (player[this.layer].milestones.includes("2")) generatePoints("p", diff)
},
resetsNothing() {return player.e.milestones.includes("3") || player.r.milestones.includes("3") || player.d.milestones.includes("3")},
onPrestige(gain) {
return
}, // Useful for if you gain secondary resources or have other interesting things happen to this layer when you reset it. You gain the currency after this function ends.
upgrades: {
rows: 2,
cols: 4,
11: {
desc:() => "Generators multiply prestige points.",
cost:() => new Decimal(3),
unl() { return player[this.layer].unl }, // The upgrade is only visible when this is true
effect() { // Calculate bonuses from the upgrade. Can return a single value or an object with multiple values
let ret = player[this.layer].points.add(2).log10().add(1).pow(2)
return ret;
},
effectDisplay(fx) { return format(tmp[this.layer].upgrades[this.id].effect)+"x" }, // Add formatting to the effect
},
12: {
desc:() => " Boosters add to the base of Generators.",
cost:() => new Decimal(8),
unl() { return player[this.layer].upgrades.includes(11) && player.b.unl }, // The upgrade is only visible when this is true
effect() { // Calculate bonuses from the upgrade. Can return a single value or an object with multiple values
let ret = player.b.points.add(1).log10().div(3)
return ret;
},
effectDisplay(fx) { return "+"+format(tmp[this.layer].upgrades[this.id].effect) }, // Add formatting to the effect
},
13: {
desc:() => "Prestige Points add to the base of Generators.",
cost:() => new Decimal(16),
unl() { return player[this.layer].upgrades.includes(12) }, // The upgrade is only visible when this is true
effect() { // Calculate bonuses from the upgrade. Can return a single value or an object with multiple values
let ret = player.p.points.add(1).log10().root(7).div(3)
return ret;
},
effectDisplay(fx) { return "+"+format(tmp[this.layer].upgrades[this.id].effect) }, // Add formatting to the effect
},
14: {
desc:() => "Generator Power boosts itself.",
cost:() => new Decimal(19),
unl() { return player[this.layer].upgrades.includes(13) }, // The upgrade is only visible when this is true
effect() { // Calculate bonuses from the upgrade. Can return a single value or an object with multiple values
let ret = player[this.layer].power.add(1).log10().add(1).pow(1.15)
return ret;
},
effectDisplay(fx) { return format(tmp[this.layer].upgrades[this.id].effect)+"x" }, // Add formatting to the effect
},
21: {
desc:() => "Prestige Points divide the Generator cost.",
cost:() => new Decimal(24),
unl() { return player[this.layer].upgrades.includes(14) }, // The upgrade is only visible when this is true
effect() { // Calculate bonuses from the upgrade. Can return a single value or an object with multiple values
let ret = (player.p.points.add(1)).root(13)
return ret;
},
effectDisplay(fx) { return "/"+format(tmp[this.layer].upgrades[this.id].effect) }, // Add formatting to the effect
},
22: {
desc:() => "Points multiply Generator Power gain.",
cost:() => new Decimal(25),
unl() { return player[this.layer].upgrades.includes(21) }, // The upgrade is only visible when this is true
effect() { // Calculate bonuses from the upgrade. Can return a single value or an object with multiple values
let ret = player.points.add(1).log10().add(1).pow(2)
return ret;
},
effectDisplay(fx) { return format(tmp[this.layer].upgrades[this.id].effect)+"x" }, // Add formatting to the effect
},
23: {
desc:() => "Double the Booster base.",
cost:() => new Decimal(26),
unl() { return player[this.layer].upgrades.includes(22) }, // The upgrade is only visible when this is true
},
24: {
desc:() => "???",
cost:() => new Decimal(1/0),
unl() { return false }, // The upgrade is only visible when this is true
},
},
hotkeys: [
{key: "g", desc: "G: Reset points for generators.", onPress(){if (player[this.layer].unl) doReset(this.layer)}},
],
incr_order: [], // Array of layer names to have their order increased when this one is first unlocked
prestigeButtonText() { //Is secretly HTML
return `<span v-if="player[layer].points.lt(10)">Convert your points into </span>+<b>${formatWhole(tmp[layer].resetGain)}</b> ${layers[layer].resource}<br><br><span v-if="player[layer].points.lt(10)">${(tmp[layer].baseAmount.gte(tmp[layer].nextAt)&&layers[layer].canBuyMax && layers[layer].canBuyMax())?"Next":"Req"}: ${formatWhole(tmp[layer].baseAmount)} / </span>${(layers[layer].resCeil ? formatWhole(tmp[layer].nextAtDisp) : format(tmp[layer].nextAtDisp))} ${ layers[layer].baseResource }`
},
getResetGain() {
if ((!layers[layer].canBuyMax()) || tmp[layer].baseAmount.lt(tmp[layer].requires)) return new Decimal(1)
let gain = tmp[layer].baseAmount.div(tmp[layer].requires).div(tmp[layer].gainMult).max(1).log(layers[layer].base).times(tmp[layer].gainExp).pow(Decimal.pow(layers[layer].exponent, -1))
if (gain.gte(12)) {
gain = gain.times(12).sqrt()
}
if (gain.gte(1225)) gain = gain.times(Decimal.pow(1225, 9)).pow(0.1)
return gain.floor().sub(player[layer].points).add(1).max(1);
},
getNextAt() {
let amt = player[layer].points
if (amt.gte(1225)) amt = amt.pow(10).div(Decimal.pow(1225, 9))
if (amt.gte(12)) {
amt = amt.pow(2).div(12)
}
let extraCost = Decimal.pow(layers[layer].base, amt.pow(layers[layer].exponent).div(tmp[layer].gainExp)).times(tmp[layer].gainMult)
let cost = extraCost.times(tmp[layer].requires).max(tmp[layer].requires)
if (layers[layer].resCeil) cost = cost.ceil()
return cost;
},
canReset() {
return tmp[this.layer].baseAmount.gte(tmp[this.layer].nextAt)
},
// Optional, lets you format the tab yourself by listing components. You can create your own components in v.js.
tabFormat: ["main-display",
["prestige-button", function() {return "Convert your points into "}, {}],
["display-text",
function() {return 'You have ' + format(player.points) + ' points.'},
{"font-size": "14px"}],
["blank", "5px"], // Height
["display-text",
function() {return 'You have ' + format(player.g.power) + ' generator power, translating to a '+format(layers.g.effect().powerBoost)+'x multiplier to points.'},
{"font-size": "14px"}],
"upgrades", "blank", "milestones"],
branches: [["p", 1]]
/*style() {return {
'background-color': '#3325CC'
}},*/
})
addLayer("e", {
startData() { return {
unl: false,
points: new Decimal(0),
best: new Decimal(0),
total: new Decimal(0),
milestones: [],
order: 0
}},
color:() => "#9643a3",
background:() => 'https://cdn.glitch.com/7460ed4d-c31b-459d-8407-710f48e787a3%2Fefdb5b70-5e55-4f23-9524-953a8eea4545.image.png?v=1601771864943',
requires() {
let req = new Decimal(1e60)
if (!player[this.layer].upgrades.includes(14)) if (player[this.layer].order > 0) req = req.pow(player[this.layer].order+1)
return req
}, // Can be a function that takes requirement increases into account
resource: "enhance 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.04, // Prestige currency exponent
base: 5, // Only needed for static layers, base of the formula (b^(x^exp))
resCeil: false, // True if the cost needs to be rounded up (use when baseResource is static?)
canBuyMax() {}, // Only needed for static layers with buy max
gainMult() { // Calculate the multiplier for main currency from bonuses
mult = new Decimal(1)
if (player[this.layer].upgrades.includes(12)) mult = mult.mul(layers[this.layer].upgrades[12].effect())
return mult
},
gainExp() { // Calculate the exponent on main currency from bonuses
return new Decimal(1)
},
row: 2, // Row the layer is in on the tree (0 is the first row)
milestones: {
0: {
requirementDesc:() => "1 enhance point",
effectDesc:() => "You don't lose prestige upgrades on previous resets and this resets",
done() {
return player[this.layer].best.gte(1);
}
},
1: {
requirementDesc:() => "3 enhance points",
effectDesc:() => "You keep all booster and generator milestones on reset.",
done() {
return player[this.layer].best.gte(3);
}
},
2: {
requirementDesc:() => "10 enhance points",
effectDesc:() => "You keep booster and generator upgrades on reset.",
done() {
return player[this.layer].best.gte(10);
}
},
3: {
requirementDesc:() => "15 enhance points",
effectDesc:() => "Boosters and generators do not reset everything.",
done() {
return player[this.layer].best.gte(15);
}
},
4: {
requirementDesc:() => "50 enhance points",
effectDesc:() => "Automate boosters and generators.",
done() {
return player[this.layer].best.gte(50);
},
toggles: [
["b", "auto"],
["g", "auto"]
]
}
},
buyables: {
rows: 1,
cols: 1,
11: {
title:() => "Enhancers", // Optional, displayed at the top in a larger font
cost() { // cost for buying xth buyable, can be an object if there are multiple currencies
let x = player[this.layer].buyables[this.id]
if (x.gte(25)) x = x.pow(2).div(25)
if (player[this.layer].upgrades.includes(13)) x = x.div(layers[this.layer].upgrades[13].effect())
let cost = Decimal.pow(2, x.pow(1.5))
return cost.floor()
},
effect() { // Effects of owning x of the items, x is a decimal
let x = player[this.layer].buyables[this.id]
let eff = {}
eff.first = Decimal.pow(1.5, x.sqrt())
eff.second = x.add(1).pow(3)
return eff;
},
display() { // Everything else displayed in the buyable button after the title
let data = tmp[this.layer].buyables[this.id]
return "Cost: " + format(data.cost) + " enhance points\n\
Amount: " + player[this.layer].buyables[this.id] + "\n\
Adds + " + format(data.effect.first) + " to the booster and generator base and multiply points and prestige points by " + format(data.effect.second)
},
unl() { return player[this.layer].unl },
canAfford() {
return player[this.layer].points.gte(tmp[this.layer].buyables[this.id].cost)},
buy() {
cost = tmp[this.layer].buyables[this.id].cost
player[this.layer].points = player[this.layer].points.sub(cost)
player[this.layer].buyables[this.id] = player[this.layer].buyables[this.id].add(1)
player[this.layer].spentOnBuyables = player[this.layer].spentOnBuyables.add(cost) // This is a built-in system that you can use for respeccing but it only works with a single Decimal value
},
buyMax() {}, // You'll have to handle this yourself if you want
},
},
doReset(resettingLayer){ // Triggers when this layer is being reset, along with the layer doing the resetting. Not triggered by lower layers resetting, but is by layers on the same row.
},
layerShown() {return player.b.unl && player.g.unl}, // Condition for when layer appears on the tree
automate() {
}, // Do any automation inherent to this layer if appropriate
updateTemp() {
}, // Do any necessary temp updating, not that important usually
resetsNothing() {return false},
onPrestige(gain) {
return
}, // Useful for if you gain secondary resources or have other interesting things happen to this layer when you reset it. You gain the currency after this function ends.
upgrades: {
rows: 1,
cols: 4,
11: {
desc:() => "Enhance points boost point and prestige point gain.",
cost:() => new Decimal(100),
unl() { return player[this.layer].unl }, // The upgrade is only visible when this is true
effect() { // Calculate bonuses from the upgrade. Can return a single value or an object with multiple values
let ret = player[this.layer].points.add(2).root(1.5)
return ret;
},
effectDisplay(fx) { return format(tmp[this.layer].upgrades[this.id].effect)+"x" }, // Add formatting to the effect
},
12: {
desc:() => "Generator Power boosts enhance point gain.",
cost:() => new Decimal(500),
unl() { return player[this.layer].upgrades.includes(11) }, // The upgrade is only visible when this is true
effect() { // Calculate bonuses from the upgrade. Can return a single value or an object with multiple values
let ret = player.g.power.add(1).log10().add(1).root(8)
return ret;
},
effectDisplay(fx) { return format(tmp[this.layer].upgrades[this.id].effect)+"x" }, // Add formatting to the effect
},
13: {
desc:() => "Boosters reduce the enhancer cost formula power.",
cost:() => new Decimal(1000),
unl() { return player[this.layer].upgrades.includes(12) }, // The upgrade is only visible when this is true
effect() { // Calculate bonuses from the upgrade. Can return a single value or an object with multiple values
let ret = player.b.points.add(1).log10().add(1).root(3)
return ret;
},
effectDisplay(fx) { return "/"+format(tmp[this.layer].upgrades[this.id].effect) }, // Add formatting to the effect
},
14: {
desc:() => "This layer behaves like it was bought first..",
cost:() => new Decimal(1000),
unl() { return player[this.layer].order > 0 && player[this.layer].upgrades.includes(13) }, // The upgrade is only visible when this is true
},
},
hotkeys: [
{key: "e", desc: "E: Reset points for enhance points.", onPress(){if (player[this.layer].unl) doReset(this.layer)}},
],
tooltipLocked() { // Optional, tooltip displays when the layer is locked
return ("(Passive layer) This layer requires " + this.requires() + " points. You only have " + formatWhole(player.points))
},
incr_order: ["r", "d"],
// Optional, lets you format the tab yourself by listing components. You can create your own components in v.js.
tabFormat: ["main-display",
["prestige-button", function() {return "Convert your points into "}, {}],
["display-text",
function() {return 'You have ' + format(player.points) + ' points.'},
{"font-size": "14px"}],
["blank", "5px"], // Height
"buyables", "blank", "blank",
"upgrades", "blank", "milestones"],
branches: [["b", 1], ["g", 1]]
/*style() {return {
'background-color': '#3325CC'
}},*/
})
addLayer("r", {
startData() { return {
unl: false,
points: new Decimal(0),
best: new Decimal(0),
total: new Decimal(0),
milestones: [],
power: new Decimal(1),
order: 0
}},
color:() => "#94bc42",
background:() => 'https://cdn.glitch.com/7460ed4d-c31b-459d-8407-710f48e787a3%2Fefdb5b70-5e55-4f23-9524-953a8eea4545.image.png?v=1601771864943',
requires() {
let req = new Decimal(1e20)
if (!player[this.layer].upgrades.includes(15)) if (player[this.layer].order > 0) req = req.pow(player[this.layer].order+1)
return req
}, // Can be a function that takes requirement increases into account
resource: "replicators", // Name of prestige currency
baseResource: "generator power", // Name of resource prestige is based on
baseAmount() {return player.g.power}, // Get the current amount of baseResource
type: "custom", // normal: cost to gain currency depends on amount gained. static: cost depends on how much you already have
exponent: 1, // Prestige currency exponent
base: 25, // Only needed for static layers, base of the formula (b^(x^exp))
resCeil: false, // True if the cost needs to be rounded up (use when baseResource is static?)
canBuyMax() {return player[this.layer].milestones.includes("4")}, // Only needed for static layers with buy max
gainMult() { // Calculate the multiplier for main currency from bonuses
mult = new Decimal(1)
return mult
},
gainExp() { // Calculate the exponent on main currency from bonuses
return new Decimal(1)
},
row: 2, // Row the layer is in on the tree (0 is the first row)
effect() {
let base = new Decimal(1)
if (player.r.unl && tmp.buyables) base = base.mul(tmp.r.buyables[11].effect.first)
if (player[this.layer].upgrades.includes(12)) base = base.mul(layers[this.layer].upgrades[12].effect())
if (player[this.layer].upgrades.includes(13)) base = base.mul(layers[this.layer].upgrades[13].effect())
let genMult = new Decimal(1)
if (player.r.unl && tmp.buyables) genMult = genMult.mul(tmp.r.buyables[12].effect.first)
return {
genProd: player[this.layer].points.add(1).log10().add(1).pow(base).sub(1),
powerBoost: player.r.power.add(1).log2().add(1).pow(genMult)
}
},
effectDescription() {return "making replicanti multiply by "+format(layers[this.layer].effect().genProd.add(1))+" each second"},
milestones: {
0: {
requirementDesc:() => "1 replicator",
effectDesc:() => "You don't lose prestige upgrades on previous resets and this resets",
done() {
return player[this.layer].best.gte(1);
}
},
1: {
requirementDesc:() => "2 replicators",
effectDesc:() => "You keep all booster and generator milestones on reset.",
done() {
return player[this.layer].best.gte(2);
}
},
2: {
requirementDesc:() => "4 replicators",
effectDesc:() => "You keep booster and generator upgrades on reset.",
done() {
return player[this.layer].best.gte(4);
}
},
3: {
requirementDesc:() => "5 replicators",
effectDesc:() => "Boosters and generators do not reset everything.",
done() {
return player[this.layer].best.gte(5);
}
},
4: {
requirementDesc:() => "8 replicators",
effectDesc:() => "Automate boosters and generators, and you can buy max replicators.",
done() {
return player[this.layer].best.gte(8);
},
toggles: [
["b", "auto"],
["g", "auto"]
]
}
},
buyables: {
rows: 1,
cols: 3,
11: {
title:() => "Replication Up", // Optional, displayed at the top in a larger font
cost() { // cost for buying xth buyable, can be an object if there are multiple currencies
let x = player[this.layer].buyables[this.id]
if (x.gte(25)) x = x.pow(2).div(25)
if (player[this.layer].buyables[this.id].gte(150)) x = x.pow(1.5).div(12.2474487139)
let cost = Decimal.pow(500, x.add(1).pow(1.5))
return cost.floor()
},
effect() { // Effects of owning x of the items, x is a decimal
let x = player[this.layer].buyables[this.id]
let eff = {}
eff.first = Decimal.pow(1.4, x.sqrt())
return eff;
},
display() { // Everything else displayed in the buyable button after the title
let data = tmp[this.layer].buyables[this.id]
return "Cost: " + format(data.cost) + " replicanti\n\
Amount: " + player[this.layer].buyables[this.id] + "\n\
Multiplies replicator power by " + format(data.effect.first) + "x"
},
unl() { return player[this.layer].unl },
canAfford() {
return player[this.layer].power.gte(tmp[this.layer].buyables[this.id].cost)},
buy() {
cost = tmp[this.layer].buyables[this.id].cost
player[this.layer].power = player[this.layer].power.sub(cost)
player[this.layer].buyables[this.id] = player[this.layer].buyables[this.id].add(1)
player[this.layer].spentOnBuyables = player[this.layer].spentOnBuyables.add(cost) // This is a built-in system that you can use for respeccing but it only works with a single Decimal value
},
buyMax() {}, // You'll have to handle this yourself if you want
},
12: {
title:() => "Effect Up", // Optional, displayed at the top in a larger font
cost() { // cost for buying xth buyable, can be an object if there are multiple currencies
let x = player[this.layer].buyables[this.id]
if (x.gte(25)) x = x.pow(2).div(25)
if (player[this.layer].buyables[this.id].gte(150)) x = x.pow(1.5).div(12.2474487139)
let cost = Decimal.pow(1000, x.add(1).pow(1.5))
return cost.floor()
},
effect() { // Effects of owning x of the items, x is a decimal
let x = player[this.layer].buyables[this.id]
let eff = {}
eff.first = x.add(1).log10().add(1).pow(0.25)
return eff;
},
display() { // Everything else displayed in the buyable button after the title
let data = tmp[this.layer].buyables[this.id]
return "Cost: " + format(data.cost) + " replicanti\n\
Amount: " + player[this.layer].buyables[this.id] + "\n\
Multiplies replicanti power by " + format(data.effect.first) + "x"
},
unl() { return player[this.layer].unl },
canAfford() {
return player[this.layer].power.gte(tmp[this.layer].buyables[this.id].cost)},
buy() {
cost = tmp[this.layer].buyables[this.id].cost
player[this.layer].power = player[this.layer].power.sub(cost)
player[this.layer].buyables[this.id] = player[this.layer].buyables[this.id].add(1)
player[this.layer].spentOnBuyables = player[this.layer].spentOnBuyables.add(cost) // This is a built-in system that you can use for respeccing but it only works with a single Decimal value
},
buyMax() {}, // You'll have to handle this yourself if you want
},
13: {
title:() => "Generator", // Optional, displayed at the top in a larger font
cost() { // cost for buying xth buyable, can be an object if there are multiple currencies
let x = player[this.layer].buyables[this.id]
if (x.gte(5)) x = x.pow(3).div(25)
if (player[this.layer].buyables[this.id].gte(25)) x = x.pow(4).div(244140625)
if (player[this.layer].buyables[this.id].gte(50)) x = x.pow(5).div(3.90625e13)
let cost = Decimal.pow("1.80e308", x.add(1).pow(0.125))
return cost.floor()
},
effect() { // Effects of owning x of the items, x is a decimal
let x = player[this.layer].buyables[this.id]
let eff = {}
eff.first = x
return eff;
},
display() { // Everything else displayed in the buyable button after the title
let data = tmp[this.layer].buyables[this.id]
return "Cost: " + format(data.cost) + " replicanti\n\
Amount: " + player[this.layer].buyables[this.id] + "\n\
Get " + format(data.effect.first) + " free generators, and increase the replicanti limit by "+format(tmp[this.layer].buyables[this.id].cost.div("1.80e308"))+"x"
},
unl() { return player[this.layer].unl },
canAfford() {
return player[this.layer].power.gte(tmp[this.layer].buyables[this.id].cost)},
buy() {
cost = tmp[this.layer].buyables[this.id].cost
player[this.layer].power = player[this.layer].power.sub(cost)
player[this.layer].buyables[this.id] = player[this.layer].buyables[this.id].add(1)
player[this.layer].spentOnBuyables = player[this.layer].spentOnBuyables.add(cost) // This is a built-in system that you can use for respeccing but it only works with a single Decimal value
},
buyMax() {}, // You'll have to handle this yourself if you want
},
},
upgrades: {
rows: 1,
cols: 5,
11: {
desc:() => "Replicanti boosts point gain.",
cost:() => new Decimal(3),
unl() { return player[this.layer].unl }, // The upgrade is only visible when this is true
effect() { // Calculate bonuses from the upgrade. Can return a single value or an object with multiple values
let ret = player[this.layer].power.add(1).log2().add(1).log2().add(1).pow(3)
return ret;
},
effectDisplay(fx) { return format(tmp[this.layer].upgrades[this.id].effect)+"x" }, // Add formatting to the effect
},
12: {
desc:() => "Generator Power boosts replicanti gain.",
cost:() => new Decimal(7),
unl() { return player[this.layer].upgrades.includes(11) }, // The upgrade is only visible when this is true
effect() { // Calculate bonuses from the upgrade. Can return a single value or an object with multiple values
let ret = player.g.power.add(1).log2().add(1).log2().add(1).log2().add(1)
return ret;
},
effectDisplay(fx) { return format(tmp[this.layer].upgrades[this.id].effect)+"x" }, // Add formatting to the effect
},
13: {
desc:() => "Replicanti boosts itself.",
cost:() => new Decimal(14),
unl() { return player[this.layer].upgrades.includes(12) }, // The upgrade is only visible when this is true
effect() { // Calculate bonuses from the upgrade. Can return a single value or an object with multiple values
let ret = player[this.layer].power.add(1).log2().add(1).log2().add(1).log2().add(1).log2().add(1)
return ret;
},
effectDisplay(fx) { return format(tmp[this.layer].upgrades[this.id].effect)+"x" }, // Add formatting to the effect
},
14: {
desc:() => "Replicators boost the generator base.",
cost:() => new Decimal(17),
unl() { return player[this.layer].upgrades.includes(13) }, // The upgrade is only visible when this is true
effect() { // Calculate bonuses from the upgrade. Can return a single value or an object with multiple values
let ret = player[this.layer].points.add(1).log2().add(1).log2().add(1).cbrt()
return ret;
},
effectDisplay(fx) { return "+"+format(tmp[this.layer].upgrades[this.id].effect) }, // Add formatting to the effect
},
15: {
desc:() => "This layer behaves like it was bought first.",
cost:() => new Decimal(20),
unl() { return player[this.layer].order > 0 && player[this.layer].upgrades.includes(14) }, // The upgrade is only visible when this is true
},
},
doReset(resettingLayer){ // Triggers when this layer is being reset, along with the layer doing the resetting. Not triggered by lower layers resetting, but is by layers on the same row.
if(layers[resettingLayer].row > this.row-1) player.r.power = new Decimal(1)
},
convertToDecimal() {
player.r.power = new Decimal(player.r.power).max(1)
},
layerShown() {return player.g.unl}, // Condition for when layer appears on the tree
automate() {
}, // Do any automation inherent to this layer if appropriate
updateTemp() {
}, // Do any necessary temp updating, not that important usually
resetsNothing() {return false},
onPrestige(gain) {
return
}, // Useful for if you gain secondary resources or have other interesting things happen to this layer when you reset it. You gain the currency after this function ends.
update(diff) {
player.r.power = player.r.power.mul(layers[this.layer].effect().genProd.mul(diff).add(1)).max(1).min(tmp["r"].buyables[13].cost)
},
hotkeys: [
{key: "r", desc: "R: Reset generator power for replicators.", onPress(){if (player[this.layer].unl) doReset(this.layer)}},
],
prestigeButtonText() { //Is secretly HTML
return `<span v-if="player[layer].points.lt(10)">Convert your generator power into </span>+<b>${formatWhole(tmp[layer].resetGain)}</b> ${layers[layer].resource}<br><br><span v-if="player[layer].points.lt(10)">${(tmp[layer].baseAmount.gte(tmp[layer].nextAt)&&layers[layer].canBuyMax && layers[layer].canBuyMax())?"Next":"Req"}: ${formatWhole(tmp[layer].baseAmount)} / </span>${(layers[layer].resCeil ? formatWhole(tmp[layer].nextAtDisp) : format(tmp[layer].nextAtDisp))} ${ layers[layer].baseResource }`
},
getResetGain() {
if ((!layers[layer].canBuyMax()) || tmp[layer].baseAmount.lt(tmp[layer].requires)) return new Decimal(1)
let gain = tmp[layer].baseAmount.div(tmp[layer].requires).div(tmp[layer].gainMult).max(1).log(layers[layer].base).times(tmp[layer].gainExp).pow(Decimal.pow(layers[layer].exponent, -1))
if (gain.gte(12)) {
gain = gain.times(12).sqrt()
}
if (gain.gte(1225)) gain = gain.times(Decimal.pow(1225, 9)).pow(0.1)
return gain.floor().sub(player[layer].points).add(1).max(1);
},
getNextAt() {
let amt = player[layer].points
if (amt.gte(1225)) amt = amt.pow(10).div(Decimal.pow(1225, 9))
if (amt.gte(12)) {
amt = amt.pow(2).div(12)
}
let extraCost = Decimal.pow(layers[layer].base, amt.pow(layers[layer].exponent).div(tmp[layer].gainExp)).times(tmp[layer].gainMult)
let cost = extraCost.times(tmp[layer].requires).max(tmp[layer].requires)
if (layers[layer].resCeil) cost = cost.ceil()
return cost;
},
canReset() {
return tmp[this.layer].baseAmount.gte(tmp[this.layer].nextAt)
},
tooltipLocked() { // Optional, tooltip displays when the layer is locked
return ("(Active layer) This layer requires " + this.requires() + " generator power. You only have " + formatWhole(player.g.power))
},
incr_order: ["e", "d"],
// Optional, lets you format the tab yourself by listing components. You can create your own components in v.js.
tabFormat: ["main-display",
["prestige-button", function() {return "Convert your generator power into "}, {}],
["display-text",
function() {return 'You have ' + format(player.r.power) + ' replicanti (Limit at '+format(tmp["r"].buyables[13].cost)+'), multiplying generator power gain by '+format(tmp.r.effect.powerBoost)+'.'},
{"font-size": "14px"}],
"upgrades", "buyables", ["blank", "25px"], "milestones"],
branches: [["g", 1]]
/*style() {return {
'background-color': '#3325CC'
}},*/
})
addLayer("d", {
startData() { return {
unl: false,
points: new Decimal(0),
best: new Decimal(0),
total: new Decimal(0),
milestones: [],
power: new Decimal(1),
order: 0,
banking: 0
}},
color:() => "#328ba8",
background:() => 'https://cdn.glitch.com/7460ed4d-c31b-459d-8407-710f48e787a3%2Fefdb5b70-5e55-4f23-9524-953a8eea4545.image.png?v=1601771864943',
requires() {
let req = new Decimal(1e32)
if (!player[this.layer].upgrades.includes(11)) if (player[this.layer].order > 0) req = req.pow(player[this.layer].order+1)
return req
}, // Can be a function that takes requirement increases into account
resource: "tachyon particles", // Name of prestige currency
baseResource: "prestige points", // Name of resource prestige is based on
baseAmount() {return player.p.points}, // Get the current amount of baseResource
type: "custom", // normal: cost to gain currency depends on amount gained. static: cost depends on how much you already have
exponent: 0.750, // Prestige currency exponent
base: 500, // Only needed for static layers, base of the formula (b^(x^exp))
resCeil: false, // True if the cost needs to be rounded up (use when baseResource is static?)
canBuyMax() {return true}, // Only needed for static layers with buy max
effect() {
let base = new Decimal(1.1)
return Decimal.pow(base, player[this.layer].points.pow(0.9))
},
effectDescription:() => "multiplying dilated currency gain by "+format(layers[this.layer].effect())+"x",
gainMult() { // Calculate the multiplier for main currency from bonuses
mult = new Decimal(1)
return mult
},
gainExp() { // Calculate the exponent on main currency from bonuses
return new Decimal(1)
},
row: 2, // Row the layer is in on the tree (0 is the first row)
milestones: {
0: {
requirementDesc:() => "1 tachyon particle",
effectDesc:() => "You don't lose prestige upgrades on previous resets and this resets",
done() {
return player[this.layer].best.gte(1);
}
},
1: {
requirementDesc:() => "2 tachyon particles",
effectDesc:() => "You keep all booster and generator milestones on reset.",
done() {
return player[this.layer].best.gte(2);
}
},
2: {
requirementDesc:() => "4 tachyon particles",
effectDesc:() => "You keep booster and generator upgrades on reset.",
done() {
return player[this.layer].best.gte(4);
}
},
3: {
requirementDesc:() => "5 tachyon particles",
effectDesc:() => "Boosters and generators do not reset everything.",
done() {
return player[this.layer].best.gte(5);
}
},
4: {
requirementDesc:() => "8 tachyon particles",
effectDesc:() => "Automate boosters and generators.",
done() {
return player[this.layer].best.gte(8);
},
toggles: [
["b", "auto"],
["g", "auto"]
]
}
},
dilationMult() {
let mult = layers[this.layer].effect()
if (player.d.unl) mult = mult.times(layers.d.buyables[21].effect(player.d.buyables[21]).first)
return mult
},
buyables: {
rows: 2,
cols: 3,
11: {
title:() => "Dilated Prestige Points", // Optional, displayed at the top in a larger font
cost() { // cost for buying xth buyable, can be an object if there are multiple currencies
return new Decimal(0)
},
effect() { // Effects of owning x of the items, x is a decimal
let x = player[this.layer].buyables[this.id]
let eff = {}
eff.first = x.add(1).root(2)
return eff;
},
display() { // Everything else displayed in the buyable button after the title
let data = tmp[this.layer].buyables[this.id]
return data.canAfford
? "You have " + format(player[this.layer].buyables[this.id], 0) + " dilated prestige points, which are boosting prestige point multiplier by " + format(data.effect.first) + "x.\n\n\
Dilation is currently " + (player[this.layer].banking == 1 ? "enabled.\n\
Click here to disable dilation and gain " + format(player.p.points.mul(layers[this.layer].dilationMult()).sub(player.d.buyables[11]).max(0), 0) + " dilated prestige points." : "disabled.\n\
Click here to enable dilation, which will force a dilation reset and square root all of your point generation speed, prestige point gain, generator effects, booster effects, and disable the second Prestige Upgrade.")
: "You need to obtain at least 2 tachyon particles before you can use this function."
},
unl() { return player[this.layer].unl },
canAfford() {
return true},
buy() {
if (player.d.banking == 1) player.d.buyables[11] = player.d.buyables[11].max(player.p.points.mul(layers[this.layer].dilationMult()))
player.d.banking = player.d.banking == 1 ? 0 : 1
doReset(this.layer, true)
},
buyMax() {}, // You'll have to handle this yourself if you want
},
12: {
title:() => "Dilated Points", // Optional, displayed at the top in a larger font
cost() { // cost for buying xth buyable, can be an object if there are multiple currencies
return new Decimal(0)
},
effect() { // Effects of owning x of the items, x is a decimal
let x = player[this.layer].buyables[this.id]
let eff = {}
eff.first = x.add(1)
return eff;
},
display() { // Everything else displayed in the buyable button after the title
let data = tmp[this.layer].buyables[this.id]
return data.canAfford
? "You have " + format(player[this.layer].buyables[this.id], 0) + " dilated points, which are boosting point multiplier by " + format(data.effect.first) + "x.\n\n\
Dilation is currently " + (player[this.layer].banking == 2 ? "enabled.\n\
Click here to disable dilation and gain " + format(player.points.mul(layers[this.layer].dilationMult()).sub(player.d.buyables[12]).max(0), 0) + " dilated prestige points." : "disabled.\n\
Click here to enable dilation, which will force a dilation reset and apply logarithm to your point generation.")
: "You need to obtain at least 3 tachyon particles before you can use this function."
},
unl() { return player[this.layer].unl },
canAfford() {
return player[this.layer].points.gte(3)},
buy() {
if (player.d.banking == 2) player.d.buyables[12] = player.d.buyables[12].max(player.points.mul(layers[this.layer].dilationMult()))
player.d.banking = player.d.banking == 2 ? 0 : 2
doReset(this.layer, true)
},
buyMax() {}, // You'll have to handle this yourself if you want
},
13: {
title:() => "Dilated Generator Power", // Optional, displayed at the top in a larger font
cost() { // cost for buying xth buyable, can be an object if there are multiple currencies
return new Decimal(0)
},
effect() { // Effects of owning x of the items, x is a decimal
let x = player[this.layer].buyables[this.id]
let eff = {}
eff.first = x.add(1).root(5)
return eff;
},
display() { // Everything else displayed in the buyable button after the title
let data = tmp[this.layer].buyables[this.id]
return data.canAfford
? "You have " + format(player[this.layer].buyables[this.id], 0) + " dilated generator power, which are boosting generator power gain by " + format(data.effect.first) + "x.\n\n\
Dilation is currently " + (player[this.layer].banking == 3 ? "enabled.\n\
Click here to disable dilation and gain " + format(player.g.power.mul(layers[this.layer].dilationMult()).sub(player.d.buyables[13]).max(0), 0) + " dilated generator power." : "disabled.\n\
Click here to enable dilation, which will force a dilation reset, lock the generator and booster bases at 2, and double booster and generator cost multiplier.")
: "You need to obtain at least 7 tachyon particles before you can use this function."
},
unl() { return player[this.layer].unl },
canAfford() {
return player[this.layer].points.gte(7)},
buy() {
if (player.d.banking == 3) player.d.buyables[13] = player.d.buyables[13].max(player.g.power.mul(layers[this.layer].dilationMult()))
player.d.banking = player.d.banking == 3 ? 0 : 3
doReset(this.layer, true)
},
buyMax() {}, // You'll have to handle this yourself if you want
},
21: {
title:() => "Dilation Boost", // Optional, displayed at the top in a larger font
cost() { // cost for buying xth buyable, can be an object if there are multiple currencies
let x = player[this.layer].buyables[this.id]
let cost = Decimal.pow("5000", x.add(1))
return {
1: cost.floor(),
2: cost.sqrt().div(50).floor(),
3: cost.pow(2).floor()
}
},
effect() { // Effects of owning x of the items, x is a decimal
let x = player[this.layer].buyables[this.id]
let eff = {}
eff.first = Decimal.pow(4, x)
return eff;
},
display() { // Everything else displayed in the buyable button after the title
let data = tmp[this.layer].buyables[this.id]
return "Cost: " + format(data.cost[1]) + " dilated prestige points, " + format(data.cost[2]) + " dilated points, " + format(data.cost[3]) + " dilated generator power\n\
Amount: " + player[this.layer].buyables[this.id] + "\n\
Multiply all dilation currency gain by " + format(data.effect.first) + "x"
},
unl() { return player[this.layer].unl },
canAfford() {
return (player[this.layer].buyables[11].gte(tmp[this.layer].buyables[this.id].cost[1]) && player[this.layer].buyables[12].gte(tmp[this.layer].buyables[this.id].cost[2]) && player[this.layer].buyables[13].gte(tmp[this.layer].buyables[this.id].cost[3]))
},
buy() {
cost = tmp[this.layer].buyables[this.id].cost
player[this.layer].buyables[11] = player[this.layer].buyables[11].sub(cost[1])
player[this.layer].buyables[12] = player[this.layer].buyables[12].sub(cost[2])
player[this.layer].buyables[13] = player[this.layer].buyables[13].sub(cost[3])
player[this.layer].buyables[this.id] = player[this.layer].buyables[this.id].add(1)
},
buyMax() {}, // You'll have to handle this yourself if you want
},
22: {
title:() => "shh", // Optional, displayed at the top in a larger font
cost() { // cost for buying xth buyable, can be an object if there are multiple currencies
let x = player[this.layer].buyables[this.id]
let cost = Decimal.pow("5000", x.add(1))
return cost.floor()
},
effect() { // Effects of owning x of the items, x is a decimal
let x = player[this.layer].buyables[this.id]
let eff = {}
eff.first = x
return eff;
},
display() { // Everything else displayed in the buyable button after the title
let data = tmp[this.layer].buyables[this.id]
return "Why are you here"
},
unl() { return false },
canAfford() {
return player[this.layer].buyables[11].gte(tmp[this.layer].buyables[this.id].cost)},
buy() {
cost = tmp[this.layer].buyables[this.id].cost
player[this.layer].buyables[11] = player[this.layer].buyables[11].sub(cost)
player[this.layer].buyables[this.id] = player[this.layer].buyables[this.id].add(1)
},
buyMax() {}, // You'll have to handle this yourself if you want
},
23: {
title:() => "shh", // Optional, displayed at the top in a larger font
cost() { // cost for buying xth buyable, can be an object if there are multiple currencies
let x = player[this.layer].buyables[this.id]
let cost = Decimal.pow("5000", x.add(1))
return cost.floor()
},
effect() { // Effects of owning x of the items, x is a decimal
let x = player[this.layer].buyables[this.id]
let eff = {}
eff.first = x
return eff;
},
display() { // Everything else displayed in the buyable button after the title
let data = tmp[this.layer].buyables[this.id]
return "Why are you here"
},
unl() { return false },
canAfford() {
return player[this.layer].buyables[11].gte(tmp[this.layer].buyables[this.id].cost)},
buy() {
cost = tmp[this.layer].buyables[this.id].cost
player[this.layer].buyables[11] = player[this.layer].buyables[11].sub(cost)
player[this.layer].buyables[this.id] = player[this.layer].buyables[this.id].add(1)
},
buyMax() {}, // You'll have to handle this yourself if you want
},
},
upgrades: {
rows: 1,
cols: 1,
11: {
desc:() => "This layer no longer uses order.",
cost:() => new Decimal(15),
unl() { return player[this.layer].order > 0 }, // The upgrade is only visible when this is true
},
},
doReset(resettingLayer){ // Triggers when this layer is being reset, along with the layer doing the resetting. Not triggered by lower layers resetting, but is by layers on the same row.
if(layers[resettingLayer].row > this.row-1) player.r.power = new Decimal(1)
},
layerShown() {return player.b.unl}, // Condition for when layer appears on the tree
automate() {
}, // Do any automation inherent to this layer if appropriate
updateTemp() {
}, // Do any necessary temp updating, not that important usually
resetsNothing() {return false},
onPrestige(gain) {
return
}, // Useful for if you gain secondary resources or have other interesting things happen to this layer when you reset it. You gain the currency after this function ends.
update(diff) {
},
hotkeys: [
{key: "d", desc: "D: Reset prestige points for tachyon particles.", onPress(){if (player[this.layer].unl) doReset(this.layer)}},
],
prestigeButtonText() { //Is secretly HTML
return `<span v-if="player[layer].points.lt(10)">Convert your prestige points into </span>+<b>${formatWhole(tmp[layer].resetGain)}</b> ${layers[layer].resource}<br><br><span v-if="player[layer].points.lt(10)">${(tmp[layer].baseAmount.gte(tmp[layer].nextAt)&&layers[layer].canBuyMax && layers[layer].canBuyMax())?"Next":"Req"}: ${formatWhole(tmp[layer].baseAmount)} / </span>${(layers[layer].resCeil ? formatWhole(tmp[layer].nextAtDisp) : format(tmp[layer].nextAtDisp))} ${ layers[layer].baseResource }`
},
getResetGain() {
if ((!layers[layer].canBuyMax()) || tmp[layer].baseAmount.lt(tmp[layer].requires)) return new Decimal(1)
let gain = tmp[layer].baseAmount.div(tmp[layer].requires).div(tmp[layer].gainMult).max(1).log(layers[layer].base).times(tmp[layer].gainExp).pow(Decimal.pow(layers[layer].exponent, -1))
if (gain.gte(12)) {
gain = gain.times(12).sqrt()
}
if (gain.gte(1225)) gain = gain.times(Decimal.pow(1225, 9)).pow(0.1)
return gain.floor().sub(player[layer].points).add(1).max(1);
},
getNextAt() {
let amt = player[layer].points
if (amt.gte(1225)) amt = amt.pow(10).div(Decimal.pow(1225, 9))
if (amt.gte(12)) {
amt = amt.pow(2).div(12)
}
let extraCost = Decimal.pow(layers[layer].base, amt.pow(layers[layer].exponent).div(tmp[layer].gainExp)).times(tmp[layer].gainMult)
let cost = extraCost.times(tmp[layer].requires).max(tmp[layer].requires)
if (layers[layer].resCeil) cost = cost.ceil()
return cost;
},
canReset() {
return tmp[this.layer].baseAmount.gte(tmp[this.layer].nextAt)
},
tooltipLocked() { // Optional, tooltip displays when the layer is locked
return ("(Idle layer) This layer requires " + this.requires() + " prestige points. You only have " + formatWhole(player.p.points))
},
incr_order: ["r", "e"],
// Optional, lets you format the tab yourself by listing components. You can create your own components in v.js.
tabFormat: ["main-display",
["prestige-button", function() {return "Convert your prestige points into "}, {}],
"upgrades", "buyables", ["blank", "25px"], "milestones"],
branches: [["b", 1]]
/*style() {return {
'background-color': '#3325CC'
}},*/
})
addLayer("pr", {
startData() { return {
unl: false,
points: new Decimal(0),
best: new Decimal(0),
total: new Decimal(0),
milestones: [],
power: new Decimal(1),
order: 0
}},
color:() => "#e8d684",
background:() => 'https://cdn.glitch.com/7460ed4d-c31b-459d-8407-710f48e787a3%2Fefdb5b70-5e55-4f23-9524-953a8eea4545.image.png?v=1601771864943',
requires() {
let req = new Decimal(68)
return req
}, // Can be a function that takes requirement increases into account
resource: "ascension power", // Name of prestige currency
baseResource: "boosters", // Name of resource prestige is based on
baseAmount() {return player.b.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
exponent: 0.850, // Prestige currency exponent
base: 1.03, // Only needed for static layers, base of the formula (b^(x^exp))
resCeil: true, // True if the cost needs to be rounded up (use when baseResource is static?)
canBuyMax() {return true}, // Only needed for static layers with buy max
gainMult() { // Calculate the multiplier for main currency from bonuses
mult = new Decimal(1)
return mult
},
gainExp() { // Calculate the exponent on main currency from bonuses
return new Decimal(1)
},
row: 2, // Row the layer is in on the tree (0 is the first row)
effect() {
let base = new Decimal(1.03)
return Decimal.pow(base, player[this.layer].points.sub(8).max(0).sqrt())
},
effectDescription:() => "increasing the perk power by "+format(layers[this.layer].effect().sub(1).mul(100))+"%",
maxActivePerks() {
let number = 1;
if (player.s.challs.includes(11)) number += 1
return number
},
activePerks() {
let number = 0;
for (var i in player[this.layer].buyables) {
if (player[this.layer].buyables[i].gt(0)) number += 1
}
return number
},
perkPower() {
let power = layers[this.layer].effect()
return power
},
buyables: {
rows: 1,
cols: 4,
11: {
title:() => "Cost Perk", // Optional, displayed at the top in a larger font
cost(x) { // cost for buying xth buyable, can be an object if there are multiple currencies
let multiplier = new Decimal(30)
return multiplier
},
effect(x) { // Effects of owning x of the items, x is a decimal
let eff = {}
eff.first = new Decimal(1e7)
eff.first = eff.first.pow(layers[this.layer].perkPower())
return eff;
},
display() { // Everything else displayed in the buyable button after the title
let data = tmp[this.layer].buyables[this.id]
let activeThing = (player[this.layer].buyables[this.id].gt(1) ? "Active for "+format(player[this.layer].buyables[this.id], 0)+" seconds" : "Not Active")
+ "\n\
Divide booster and generator costs by /" + format(data.effect.first)
return activeThing
},
unl() { return player[this.layer].unl },
canAfford() {
return (layers[this.layer].activePerks() < layers[this.layer].maxActivePerks()) },
buy() {
if (player[this.layer].buyables[this.id].gt(0)) return;
player[this.layer].buyables[this.id] = layers[this.layer].buyables[this.id].cost()
},
},
12: {
title:() => "Base Perk", // Optional, displayed at the top in a larger font
cost(x) { // cost for buying xth buyable, can be an object if there are multiple currencies
let multiplier = new Decimal(30)
return multiplier
},
effect(x) { // Effects of owning x of the items, x is a decimal
let eff = {}
eff.first = new Decimal(2)
eff.first = eff.first.pow(layers[this.layer].perkPower())
return eff;
},
display() { // Everything else displayed in the buyable button after the title
let data = tmp[this.layer].buyables[this.id]
let activeThing = (player[this.layer].buyables[this.id].gt(1) ? "Active for "+format(player[this.layer].buyables[this.id], 0)+" seconds" : "Not Active")
+ "\n\
Add +" + format(data.effect.first) + " to the generator and booster bases"
return activeThing
},
unl() { return player[this.layer].unl },
canAfford() {
return (layers[this.layer].activePerks() < layers[this.layer].maxActivePerks()) },
buy() {
if (player[this.layer].buyables[this.id].gt(0)) return;
player[this.layer].buyables[this.id] = layers[this.layer].buyables[this.id].cost()
},
},
13: {
title:() => "Multiplier Perk", // Optional, displayed at the top in a larger font
cost(x) { // cost for buying xth buyable, can be an object if there are multiple currencies
let multiplier = new Decimal(30)
return multiplier
},
effect(x) { // Effects of owning x of the items, x is a decimal
let eff = {}
eff.first = new Decimal(1e15)
eff.first = eff.first.pow(layers[this.layer].perkPower())
return eff;
},
display() { // Everything else displayed in the buyable button after the title
let data = tmp[this.layer].buyables[this.id]
let activeThing = (player[this.layer].buyables[this.id].gt(1) ? "Active for "+format(player[this.layer].buyables[this.id], 0)+" seconds" : "Not Active")
+ "\n\
Multiply prestige point and prestige point gain by x" + format(data.effect.first, 1)
return activeThing
},
unl() { return player[this.layer].unl },
canAfford() {
return (layers[this.layer].activePerks() < layers[this.layer].maxActivePerks()) },
buy() {
if (player[this.layer].buyables[this.id].gt(0)) return;
player[this.layer].buyables[this.id] = layers[this.layer].buyables[this.id].cost()
},
},
14: {
title:() => "Bonus Perk", // Optional, displayed at the top in a larger font
cost(x) { // cost for buying xth buyable, can be an object if there are multiple currencies
let multiplier = new Decimal(30)
return multiplier
},
effect(x) { // Effects of owning x of the items, x is a decimal
let eff = {}
eff.first = new Decimal(5)
eff.first = eff.first.pow(layers[this.layer].perkPower())
return eff;
},
display() { // Everything else displayed in the buyable button after the title
let data = tmp[this.layer].buyables[this.id]
let activeThing = (player[this.layer].buyables[this.id].gt(1) ? "Active for "+format(player[this.layer].buyables[this.id], 0)+" seconds" : "Not Active")
+ "\n\
Add +" + format(data.effect.first, 1) + " free boosters and generators"
return activeThing
},
unl() { return player.s.challs.includes(12) },
canAfford() {
return (layers[this.layer].activePerks() < layers[this.layer].maxActivePerks()) },
buy() {
if (player[this.layer].buyables[this.id].gt(0)) return;
player[this.layer].buyables[this.id] = layers[this.layer].buyables[this.id].cost()
},
},
},
layerShown() {return player.d.unl && player.e.unl && player.r.unl}, // Condition for when layer appears on the tree
automate() {
}, // Do any automation inherent to this layer if appropriate
updateTemp() {
}, // Do any necessary temp updating, not that important usually
resetsNothing() {return true},
onPrestige(gain) {
return
}, // Useful for if you gain secondary resources or have other interesting things happen to this layer when you reset it. You gain the currency after this function ends.
update(diff) {
for (var i in player[this.layer].buyables) {
player[this.layer].buyables[i] = player[this.layer].buyables[i].sub(diff).max(0)
}
},
hotkeys: [
{key: "P", desc: "Shift+P: Reset boosters for ascension power.", onPress(){if (player[this.layer].unl) doReset(this.layer)}},
],
incr_order: ["s"],
// Optional, lets you format the tab yourself by listing components. You can create your own components in v.js.
tabFormat: ["main-display",
["prestige-button", function() {return "Convert your points into "}, {}],
["display-text",
function() {return '(Perk Power: '+format((layers.pr.perkPower()?layers.pr.perkPower():new Decimal(1)).mul(100))+'%)'},
{"font-size": "16px", "color": "orange"}],
"buyables", ["blank", "25px"], "milestones"],
branches: [["b", 1]]
/*style() {return {
'background-color': '#3325CC'
}},*/
})
addLayer("s", {
startData() { return {
unl: false,
points: new Decimal(0),
best: new Decimal(0),
total: new Decimal(0),
milestones: [],
order: 0
}},
color:() => "#fab4d9",
background:() => 'https://cdn.glitch.com/7460ed4d-c31b-459d-8407-710f48e787a3%2Fefdb5b70-5e55-4f23-9524-953a8eea4545.image.png?v=1601771864943',
requires() {
let req = new Decimal(67)
return req
}, // Can be a function that takes requirement increases into account
resource: "stadium power", // Name of prestige currency
baseResource: "generators", // Name of resource prestige is based on
baseAmount() {return player.g.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
exponent: 0.850, // Prestige currency exponent
base: 1.03, // Only needed for static layers, base of the formula (b^(x^exp))
resCeil: true, // True if the cost needs to be rounded up (use when baseResource is static?)
canBuyMax() {return true}, // Only needed for static layers with buy max
gainMult() { // Calculate the multiplier for main currency from bonuses
mult = new Decimal(1)
return mult
},
gainExp() { // Calculate the exponent on main currency from bonuses
return new Decimal(1)
},
effect() {
let base = new Decimal(1.02)
return Decimal.pow(base, player[this.layer].points.sub(8).max(0).add(1.25).log10())
},
effectDescription:() => "increasing the second prestige upgrade power by "+format(layers[this.layer].effect().sub(1).mul(100))+"%",
row: 2, // Row the layer is in on the tree (0 is the first row)
doReset(resettingLayer){ // Triggers when this layer is being reset, along with the layer doing the resetting. Not triggered by lower layers resetting, but is by layers on the same row.
if(layers[resettingLayer].row > this.row-1) player.r.power = new Decimal(1)
},
layerShown() {return player.d.unl && player.e.unl && player.r.unl}, // Condition for when layer appears on the tree
automate() {
}, // Do any automation inherent to this layer if appropriate
updateTemp() {
}, // Do any necessary temp updating, not that important usually
challengeUnlocks: ["1.80e308", "1e340", "1e370", "1e800"],
getChallengeUnlock() {
let number = 0
for (var i in layers[this.layer].challs) {
if (layers[this.layer].challs[i].unl) if (layers[this.layer].challs[i].unl()) number += 1
}
return number
},
challs: {
rows: 2,
cols: 2,
11: {
name:() => "Spaceon",
desc:() => "Prestige point gain is raised to the 10th root.",
unl() { return player.points.gt(layers[this.layer].challengeUnlocks[0]) || player[this.layer].challs.includes(11) || player[this.layer].active == 11 },
goal:() => new Decimal("10000"),
currencyDisplayName: "prestige points", // Use if using a nonstandard currency
currencyInternalName: "points", // Use if using a nonstandard currency
currencyLayer: "p", // Leave empty if not in a layer
reward:() => "You can have two perks active at once.",
},
12: {
name:() => "Infinity",
desc:() => "Booster and generators are 90% weaker.",
unl() { return player.points.gt(layers[this.layer].challengeUnlocks[1]) || player[this.layer].challs.includes(12) || player[this.layer].active == 12 },
goal:() => new Decimal("1e137"),
currencyDisplayName: "prestige points", // Use if using a nonstandard currency
currencyInternalName: "points", // Use if using a nonstandard currency
currencyLayer: "p", // Leave empty if not in a layer
reward:() => "Unlock a new perk, and generator and booster cost is divided by stadium and ascension power.",
effect() {
let ret = player[this.layer].points.add(player.pr.points).mul(100).pow(3).add(1)
return ret;
},
effectDisplay(x) { return "/"+format(x) },
},
21: {
name:() => "Eternity",
desc:() => "Time speed is reduced based on your points. (Hold P for more prestige gain)",
unl() { return player.points.gt(layers[this.layer].challengeUnlocks[2]) || player[this.layer].challs.includes(21) || player[this.layer].active == 21 },
goal:() => new Decimal("1e147"),
currencyDisplayName: "prestige points", // Use if using a nonstandard currency
currencyInternalName: "points", // Use if using a nonstandard currency
currencyLayer: "p", // Leave empty if not in a layer
reward:() => "Generators and boosters multiply prestige point gain.",
effect() {
let ret = player.g.points.add(player.b.points).mul(1e5).pow(2).add(1)
return ret;
},
effectDisplay(x) { return format(x)+"x" },
},
22: {
name:() => "???",
desc:() => "Time speed is reduced based on your points.",
unl() { return player.points.gt(layers[this.layer].challengeUnlocks[3]) || player[this.layer].challs.includes(22) || player[this.layer].active == 22 },
goal:() => new Decimal("1e50"),
currencyDisplayName: "prestige points", // Use if using a nonstandard currency
currencyInternalName: "points", // Use if using a nonstandard currency
currencyLayer: "p", // Leave empty if not in a layer
reward:() => "Generators and boosters multiply prestige point gain.",
effect() {
let ret = player.g.points.add(player.b.points).mul(1e5).pow(2).add(1)
return ret;
},
effectDisplay(x) { return format(x)+"x" },
},
},
resetsNothing() {return true},
onPrestige(gain) {
return
}, // Useful for if you gain secondary resources or have other interesting things happen to this layer when you reset it. You gain the currency after this function ends.
update(diff) {
},
onReset() {
if (player[this.layer].active) doReset("d", true)
},
hotkeys: [
{key: "s", desc: "S: Reset generators for stadium power.", onPress(){if (player[this.layer].unl) doReset(this.layer)}},
],
// Optional, lets you format the tab yourself by listing components. You can create your own components in v.js.
tabFormat: ["main-display",
["prestige-button", function() {return "Convert your points into "}, {}],
["display-text",
function() {return 'Next stadium challenge at '+format(layers["s"].challengeUnlocks[layers["s"].getChallengeUnlock()])+" points."},
{"font-size": "14px"}], "blank", "blank",
["display-text",
function() {return '(Note: Perks do not work in stadium challenges)'},
{"font-size": "10px"}],
"challs"],
branches: [["g", 1]]
/*style() {return {
'background-color': '#3325CC'
}},*/
})
Reference in a new issue Copy permalink