mirror of
https://github.com/Acamaeda/The-Modding-Tree.git
synced 2024-11-24 17:31:50 +00:00
1872 lines
No EOL
96 KiB
JavaScript
1872 lines
No EOL
96 KiB
JavaScript
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'
|
|
}},*/
|
|
}) |