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-11-21 16:13:55 +00:00
Code Issues Releases Activity Actions
The-Modding-Tree/js/game.js

1168 lines
39 KiB
JavaScript
Raw Normal View History

Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
var player;
var needCanvasUpdate = true;
function getStartPlayer() {
return {
tab: "tree",
time: Date.now(),
autosave: true,
points: new Decimal(10),
p: {
unl: false,
points: new Decimal(0),
best: new Decimal(0),
upgrades: [],
},
b: {
unl: false,
points: new Decimal(0),
best: new Decimal(0),
upgrades: [],
Alpha Build 4
2020-08-20 04:55:26 +00:00
auto: false,
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
},
g: {
unl: false,
points: new Decimal(0),
power: new Decimal(0),
best: new Decimal(0),
upgrades: [],
Alpha Build 4
2020-08-20 04:55:26 +00:00
auto: false,
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
},
e: {
unl: false,
order: 0,
points: new Decimal(0),
best: new Decimal(0),
enhancers: new Decimal(0),
upgrades: [],
},
t: {
unl: false,
order: 0,
points: new Decimal(0),
best: new Decimal(0),
energy: new Decimal(0),
extCapsules: new Decimal(0),
upgrades: [],
},
s: {
unl: false,
order: 0,
points: new Decimal(0),
best: new Decimal(0),
spent: new Decimal(0),
buildings: {
1: new Decimal(0),
2: new Decimal(0),
Alpha Build 1
2020-08-19 19:53:14 +00:00
3: new Decimal(0),
Alpha Build 5
2020-08-20 20:37:22 +00:00
4: new Decimal(0),
5: new Decimal(0)
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
},
upgrades: [],
},
}
}
const LAYERS = ["p", "b", "g", "e", "t", "s"]
const LAYER_REQS = {
p: new Decimal(10),
b: new Decimal(200),
g: new Decimal(200),
e: new Decimal(1e120),
t: new Decimal(1e120),
s: new Decimal(1e120),
}
const LAYER_RES = {
p: "prestige points",
b: "boosters",
g: "generators",
e: "enhance points",
t: "time capsules",
s: "space energy",
}
const LAYER_TYPE = {
p: "normal",
b: "static",
g: "static",
e: "normal",
t: "static",
s: "static",
}
const LAYER_EXP = {
p: new Decimal(0.5),
b: new Decimal(1.25),
g: new Decimal(1.25),
e: new Decimal(0.02),
Alpha Build 1
2020-08-19 19:53:14 +00:00
t: new Decimal(1.85),
s: new Decimal(1.85),
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
}
const LAYER_BASE = {
b: new Decimal(5),
g: new Decimal(5),
t: new Decimal(1e15),
s: new Decimal(1e15),
}
const LAYER_ROW = {
p: 0,
b: 1,
g: 1,
e: 2,
t: 2,
s: 2,
future_layer: 3,
}
const ROW_LAYERS = [
["p"],
["b","g"],
["e","t","s"],
["future_layer"],
]
const LAYER_EFFS = {
Alpha Build 4
2020-08-20 04:55:26 +00:00
b: function() { return Decimal.pow(Decimal.add(2, addToBoosterBase()), player.b.points.plus(getFreeBoosters())) },
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
g: function() { return Decimal.pow(Decimal.add(2, addToGenBase()), player.g.points).sub(1).times(getGenPowerGainMult()) },
t: function() { return {
Alpha Build 2
2020-08-19 22:12:31 +00:00
gain: Decimal.pow(3, player.t.points.plus(player.t.extCapsules.plus(getFreeExtCapsules()))).sub(1).times(getTimeEnergyGainMult()),
Alpha Build 1
2020-08-19 19:53:14 +00:00
limit: Decimal.pow(2, player.t.points.plus(player.t.extCapsules.plus(getFreeExtCapsules()))).sub(1).times(100).times(getTimeEnergyLimitMult()),
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
}},
}
const LAYER_UPGS = {
p: {
rows: 2,
cols: 3,
11: {
desc: "Gain 1 Point every second.",
cost: new Decimal(1),
unl: function() { return player.p.unl },
},
12: {
desc: "Point generation is faster based on your unspent Prestige Points.",
cost: new Decimal(1),
unl: function() { return player.p.upgrades.includes(11) },
currently: function() { return player.p.points.plus(1).pow(player.g.upgrades.includes(24)?1.1:(player.g.upgrades.includes(14)?0.75:0.5)) },
effDisp: function(x) { return format(x)+"x" },
},
13: {
desc: "Point generation is faster based on your Point amount.",
cost: new Decimal(5),
unl: function() { return player.p.upgrades.includes(12) },
currently: function() {
let ret = player.points.plus(1).log10().pow(0.75).plus(1)
if (player.g.upgrades.includes(15)) ret = ret.pow(LAYER_UPGS.g[15].currently())
return ret;
},
effDisp: function(x) { return format(x)+"x" },
},
21: {
desc: "Prestige Point gain is doubled.",
cost: new Decimal(20),
unl: function() { return (player.b.unl||player.g.unl)&&player.p.upgrades.includes(11) },
},
22: {
desc: "Point generation is faster based on your Prestige Upgrades bought.",
cost: new Decimal(75),
unl: function() { return (player.b.unl||player.g.unl)&&player.p.upgrades.includes(12) },
currently: function() { return Decimal.pow(1.4, player.p.upgrades.length) },
effDisp: function(x) { return format(x)+"x" },
},
23: {
desc: "Prestige Point gain is boosted by your Point amount.",
cost: new Decimal(5e3),
unl: function() { return (player.b.unl||player.g.unl)&&player.p.upgrades.includes(13) },
currently: function() {
let ret = player.points.plus(1).log10().cbrt().plus(1)
if (player.g.upgrades.includes(23)) ret = ret.pow(LAYER_UPGS.g[23].currently())
return ret;
},
effDisp: function(x) { return format(x)+"x" },
},
},
b: {
rows: 2,
cols: 3,
11: {
desc: "Boosters boost Prestige Point gain.",
cost: new Decimal(3),
unl: function() { return player.b.unl },
Alpha Build 1
2020-08-19 19:53:14 +00:00
currently: function() { return player.b.points.sqrt().plus(1).max(1.5) },
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
effDisp: function(x) { return format(x)+"x" },
},
12: {
desc: "Generators add to the Booster effect.",
cost: new Decimal(7),
unl: function() { return player.g.unl },
Alpha Build 2
2020-08-19 22:12:31 +00:00
currently: function() { return player.g.points.plus(1).log10().sqrt().div(3).times(player.t.upgrades.includes(14)?8.5:1) },
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
effDisp: function(x) { return "+"+format(x)+" to base" },
},
13: {
desc: "Prestige Points add to the Booster effect.",
cost: new Decimal(8),
unl: function() { return player.b.best.gte(8) },
currently: function() { return player.p.points.plus(1).log10().plus(1).log10().div(3) },
effDisp: function(x) { return "+"+format(x)+" to base" },
},
21: {
desc: "Square the Generator Power effect.",
cost: new Decimal(10),
unl: function() { return player.b.upgrades.includes(11) && player.b.upgrades.includes(12) },
},
22: {
desc: "The Generator Power effect is raised to the power of 1.2.",
cost: new Decimal(15),
unl: function() { return player.b.upgrades.includes(12) && player.b.upgrades.includes(13) },
},
23: {
desc: "Boosters are cheaper based on your points.",
cost: new Decimal(18),
unl: function() { return player.b.upgrades.includes(21) || player.b.upgrades.includes(22) },
Alpha Build 1
2020-08-19 19:53:14 +00:00
currently: function() { return player.points.plus(1).log10().plus(1).pow(3.2).pow(getSpaceBuildingEff(4)) },
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
effDisp: function(x) { return "/"+format(x) },
},
},
g: {
rows: 2,
cols: 5,
11: {
desc: "Generators boost Prestige Point gain.",
cost: new Decimal(3),
unl: function() { return player.g.unl },
Alpha Build 1
2020-08-19 19:53:14 +00:00
currently: function() { return player.g.points.sqrt().plus(1).max(1.5) },
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
effDisp: function(x) { return format(x)+"x" },
},
12: {
desc: "Boosters boost Generator Power gain.",
cost: new Decimal(7),
unl: function() { return player.b.unl },
Alpha Build 2
2020-08-19 22:12:31 +00:00
currently: function() { return player.b.points.plus(1).log10().sqrt().div(3).times(player.t.upgrades.includes(14)?3.75:1) },
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
effDisp: function(x) { return "+"+format(x)+" to base" },
},
13: {
desc: "Prestige Points boost Generator Power gain.",
cost: new Decimal(8),
unl: function() { return player.g.best.gte(8) },
currently: function() { return player.p.points.plus(1).log10().plus(1).log10().div(3) },
effDisp: function(x) { return "+"+format(x)+" to base" },
},
14: {
desc: "Prestige Upgrade 2 uses a better formula.",
cost: new Decimal(13),
unl: function() { return player.g.best.gte(10) },
},
15: {
desc: "Prestige Upgrade 3 is stronger based on your Generators.",
cost: new Decimal(15),
unl: function() { return player.g.upgrades.includes(13) },
currently: function() { return player.g.points.sqrt().plus(1) },
effDisp: function(x) { return "^"+format(x) },
},
21: {
desc: "Generator Power generates faster based on its amount.",
cost: new Decimal(18),
unl: function() { return player.g.upgrades.includes(15) },
currently: function() { return player.g.power.plus(1).log10().plus(1) },
effDisp: function(x) { return format(x)+"x" },
},
22: {
desc: "Generators are cheaper based on your Prestige Points.",
cost: new Decimal(19),
unl: function() { return player.g.upgrades.includes(15) },
currently: function() { return player.p.points.plus(1).pow(0.25) },
effDisp: function(x) { return "/"+format(x) },
},
23: {
desc: "Prestige Upgrade 6 is stronger based on your Boosters.",
cost: new Decimal(20),
unl: function() { return player.b.unl && player.g.upgrades.includes(15) },
currently: function() { return player.b.points.pow(0.75).plus(1) },
effDisp: function(x) { return "^"+format(x) },
},
24: {
desc: "Prestige Upgrade 2 uses an even better formula.",
cost: new Decimal(22),
unl: function() { return player.g.upgrades.includes(14) && (player.g.upgrades.includes(21)||player.g.upgrades.includes(22)) },
},
25: {
desc: "Prestige Points boost Generator Power gain.",
cost: new Decimal(28),
unl: function() { return player.g.upgrades.includes(23) && player.g.upgrades.includes(24) },
Alpha Build 1
2020-08-19 19:53:14 +00:00
currently: function() { return player.p.points.plus(1).log10().sqrt().plus(1).pow(player.t.upgrades.includes(14)?2.75:1) },
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
effDisp: function(x) { return format(x)+"x" },
},
},
e: {
Alpha Build 5
2020-08-20 20:37:22 +00:00
rows: 2,
Alpha Build 4
2020-08-20 04:55:26 +00:00
cols: 5,
Alpha Build 1
2020-08-19 19:53:14 +00:00
11: {
desc: "Boosters & Generators boost each other.",
cost: new Decimal(40),
unl: function() { return player.e.unl },
Alpha Build 4
2020-08-20 04:55:26 +00:00
currently: function() {
let exp = 1
if (player.e.upgrades.includes(14)) exp = 1.5
return {g: player.b.points.plus(1).log10().pow(exp), b: player.g.points.plus(1).log10().pow(exp)}
},
Alpha Build 1
2020-08-19 19:53:14 +00:00
effDisp: function(x) { return "+"+format(x.g)+" to Generator base, +"+format(x.b)+" to Booster base" },
},
12: {
desc: "Unspent Enhance Points boost Prestige Point gain.",
cost: new Decimal(150),
unl: function() { return player.e.unl&&player.e.best.gte(40) },
Alpha Build 4
2020-08-20 04:55:26 +00:00
currently: function() { return player.e.points.plus(1).pow(player.e.upgrades.includes(15)?3.25:1.5) },
Alpha Build 1
2020-08-19 19:53:14 +00:00
effDisp: function(x) { return format(x)+"x" },
},
13: {
desc: "You gain 1e10x as many Prestige Points.",
cost: new Decimal(1000),
unl: function() { return player.e.upgrades.includes(11)||player.e.upgrades.includes(12) },
},
Alpha Build 4
2020-08-20 04:55:26 +00:00
14: {
desc: "Enhance Upgrade 1 uses a better formula.",
cost: new Decimal(5e7),
unl: function() { return player.e.upgrades.includes(13)&&(player.t.unl||player.s.unl) },
},
15: {
desc: "Enhance Upgrade 2 uses a better formula.",
cost: new Decimal(2e10),
unl: function() { return player.e.upgrades.includes(14)&&(player.t.unl||player.s.unl)&&player.e.best.gte(1e9) },
},
Alpha Build 5
2020-08-20 20:37:22 +00:00
21: {
desc: "The Generator Power effect is raised to the power of 1.15.",
cost: new Decimal(1e15),
unl: function() { return player.t.unl&&(player.t.order==1||player.s.unl)&&player.e.upgrades.includes(14) },
},
22: {
Alpha Build 6
2020-08-21 03:33:13 +00:00
desc: "This layer behaves as if you chose it first (base req is now 1e120 points)",
cost: new Decimal(1e22),
unl: function() { return (player.t.unl&&player.s.unl&&player.e.order==2)||player.e.upgrades.includes(22)||player.e.upgrades.includes(23) },
Alpha Build 5
2020-08-20 20:37:22 +00:00
},
23: {
Alpha Build 6
2020-08-21 03:33:13 +00:00
desc: "This layer behaves as if you chose it first (base req is now 1e120 points)",
cost: new Decimal(1e40),
unl: function() { return (player.t.unl&&player.s.unl&&player.e.order==1)||player.e.upgrades.includes(22)||player.e.upgrades.includes(23) },
Alpha Build 5
2020-08-20 20:37:22 +00:00
},
24: {
desc: "???",
cost: new Decimal(1/0),
unl: function() { return false },
},
25: {
desc: "???",
cost: new Decimal(1/0),
unl: function() { return false },
},
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
},
t: {
Alpha Build 5
2020-08-20 20:37:22 +00:00
rows: 3,
Alpha Build 1
2020-08-19 19:53:14 +00:00
cols: 4,
11: {
desc: "Non-extra Time Capsules boost the Booster effect.",
cost: new Decimal(2),
unl: function() { return player.t.unl },
currently: function() { return player.t.points.pow(0.9).plus(0.5).plus(player.t.upgrades.includes(13)?LAYER_UPGS.t[13].currently():0) },
effDisp: function(x) { return "+"+format(x)+" to base" },
},
12: {
desc: "The Time Energy cap starts later based on your Boosters, and you get a free Extra Time Capsule.",
cost: new Decimal(3),
unl: function() { return player.t.best.gte(2)&&player.t.unl },
currently: function() { return player.b.points.pow(0.95).plus(1) },
effDisp: function(x) { return format(x)+"x" },
},
13: {
desc: "Extra Time Capsules are added to the first Time Upgrade's effect formula, but at a reduced amount.",
cost: new Decimal(3),
unl: function() { return player.t.upgrades.includes(11) },
currently: function() { return player.t.extCapsules.plus(getFreeExtCapsules()).pow(0.95) },
effDisp: function(x) { return "+"+format(x) },
},
14: {
Alpha Build 2
2020-08-19 22:12:31 +00:00
desc: "Generator Upgrades 2 & 10 are 275% stronger, and Booster Upgrade 2 is 750% stronger.",
Alpha Build 1
2020-08-19 19:53:14 +00:00
cost: new Decimal(4),
unl: function() { return player.t.upgrades.includes(12)||player.t.upgrades.includes(13) },
},
Alpha Build 2
2020-08-19 22:12:31 +00:00
21: {
Alpha Build 3
2020-08-20 01:27:52 +00:00
desc: "Time Energy boosts its own production & limit, and the Time Energy effect uses a better formula.",
Alpha Build 2
2020-08-19 22:12:31 +00:00
cost: new Decimal(4),
unl: function() { return player.t.upgrades.includes(14) },
currently: function() { return player.t.energy.plus(1).log10().pow(1.1).plus(1) },
effDisp: function(x) { return format(x)+"x" },
},
22: {
Alpha Build 3
2020-08-20 01:27:52 +00:00
desc: "Time Energy production & limit are boosted by your Enhance Points.",
cost: new Decimal(5),
unl: function() { return player.t.upgrades.includes(14)&&player.e.unl },
Alpha Build 4
2020-08-20 04:55:26 +00:00
currently: function() { return player.e.points.plus(1).pow(0.8/(1+player.t.order)) },
Alpha Build 3
2020-08-20 01:27:52 +00:00
effDisp: function(x) { return format(x)+"x" },
Alpha Build 2
2020-08-19 22:12:31 +00:00
},
23: {
Alpha Build 3
2020-08-20 01:27:52 +00:00
desc: "Time Energy production & limit are boosted by your Space Energy.",
cost: new Decimal(5),
unl: function() { return player.t.upgrades.includes(14)&&player.s.unl },
currently: function() { return Decimal.pow(3, player.s.points.pow(0.9)) },
effDisp: function(x) { return format(x)+"x" },
Alpha Build 2
2020-08-19 22:12:31 +00:00
},
24: {
Alpha Build 4
2020-08-20 04:55:26 +00:00
desc: "Get 18 free boosters added to their effect.",
cost: new Decimal(7),
unl: function() { return player.t.upgrades.includes(21)&&player.t.best.gte(5) },
Alpha Build 2
2020-08-19 22:12:31 +00:00
},
Alpha Build 5
2020-08-20 20:37:22 +00:00
31: {
desc: "Add 25 to the booster effect base.",
cost: new Decimal(8),
unl: function() { return (player.t.upgrades.includes(22)&&(player.e.order==1||player.s.unl))||(player.t.upgrades.includes(23)&&(player.s.order==1||player.e.unl)) },
},
32: {
Alpha Build 6
2020-08-21 03:33:13 +00:00
desc: "This layer behaves as if you chose it first (base req is now 1e120 points)",
cost: new Decimal(12),
unl: function() { return (player.s.unl&&player.e.unl)||player.t.upgrades.includes(32) },
Alpha Build 5
2020-08-20 20:37:22 +00:00
},
33: {
desc: "???",
cost: new Decimal(1/0),
unl: function() { return false },
},
34: {
desc: "???",
cost: new Decimal(1/0),
unl: function() { return false },
},
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
},
s: {
Alpha Build 5
2020-08-20 20:37:22 +00:00
rows: 3,
Alpha Build 1
2020-08-19 19:53:14 +00:00
cols: 4,
11: {
desc: "Add a free level to all Space Buildings.",
cost: new Decimal(2),
unl: function() { return player.s.unl },
},
12: {
desc: "Generator Power boosts its own generation.",
cost: new Decimal(3),
unl: function() { return player.s.best.gte(2)&&player.s.unl },
currently: function() { return player.g.power.plus(1).log10().plus(1) },
effDisp: function(x) { return format(x)+"x" },
},
13: {
desc: "Space Building Levels boost Generator Power gain, and get 2 extra Space.",
cost: new Decimal(3),
unl: function() { return player.s.upgrades.includes(11) },
currently: function() { return Decimal.pow(20, Object.values(player.s.buildings).reduce((a,b) => Decimal.add(a,b))) },
effDisp: function(x) { return format(x)+"x" },
},
14: {
desc: "Unlock a 4th Space Building, and add a free level to all Space Buildings.",
cost: new Decimal(4),
unl: function() { return player.s.upgrades.includes(12)&&player.s.upgrades.includes(13) },
},
Alpha Build 2
2020-08-19 22:12:31 +00:00
21: {
desc: "All Space Buildings are stronger based on your Generators.",
cost: new Decimal(4),
unl: function() { return player.s.upgrades.includes(14) },
currently: function() { return player.g.points.plus(1).log10().div(1.5).plus(1) },
effDisp: function(x) { return format(x.sub(1).times(100))+"% stronger" },
},
22: {
Alpha Build 4
2020-08-20 04:55:26 +00:00
desc: "Space Buildings are stronger based on your Time Energy.",
cost: new Decimal(6),
unl: function() { return player.s.upgrades.includes(14)&&player.t.unl },
currently: function() { return player.t.energy.plus(1).log10().plus(1).log10().div(5).plus(1) },
effDisp: function(x) { return format(x.sub(1).times(100))+"% stronger" },
Alpha Build 2
2020-08-19 22:12:31 +00:00
},
23: {
Alpha Build 4
2020-08-20 04:55:26 +00:00
desc: "Space Buildings are stronger based on your Enhancers.",
cost: new Decimal(5),
unl: function() { return player.s.upgrades.includes(14)&&player.e.unl },
currently: function() { return player.e.enhancers.sqrt().div((player.s.order==0)?5:7).plus(1) },
effDisp: function(x) { return format(x.sub(1).times(100))+"% stronger" },
Alpha Build 2
2020-08-19 22:12:31 +00:00
},
24: {
Alpha Build 4
2020-08-20 04:55:26 +00:00
desc: "Space Building costs scale half as fast, and you have 3 more Space.",
cost: new Decimal(7),
unl: function() { return player.s.upgrades.includes(21)&&(player.t.unl||player.e.unl) },
Alpha Build 2
2020-08-19 22:12:31 +00:00
},
Alpha Build 5
2020-08-20 20:37:22 +00:00
31: {
desc: "Space Building 1 uses a better formula.",
cost: new Decimal(7),
unl: function() { return (player.s.upgrades.includes(22)&&(player.t.order==0||player.e.unl))||(player.s.upgrades.includes(23)&&(player.e.order==0||player.t.unl)) },
},
32: {
desc: "Unlock a 5th Space Building.",
cost: new Decimal(8),
unl: function() { return (player.s.upgrades.includes(22)&&(player.t.order==1||player.e.unl))||(player.s.upgrades.includes(23)&&(player.e.order==1||player.t.unl)) },
},
33: {
Alpha Build 6
2020-08-21 03:33:13 +00:00
desc: "This layer behaves as if you chose it first (base req is now 1e120 points)",
cost: new Decimal(12),
unl: function() { return (player.t.unl&&player.e.unl)||player.s.upgrades.includes(33) },
Alpha Build 5
2020-08-20 20:37:22 +00:00
},
34: {
Alpha Build 6
2020-08-21 03:33:13 +00:00
desc: "Space Buildings boost the Generator Power effect (before all other boosts).",
cost: new Decimal(15),
unl: function() { return player.t.unl&&player.e.unl&&player.t.order==0&&player.e.order==0&&player.s.order==0 },
currently: function() { return Decimal.pow(Object.values(player.s.buildings).reduce((a,b) => Decimal.add(a,b)), 0.2).div(17.5) },
effDisp: function(x) { return "Add "+format(x)+" to exponent" },
Alpha Build 5
2020-08-20 20:37:22 +00:00
},
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
},
}
const TAB_REQS = {
tree: function() { return true },
options: function() { return true },
Alpha Build 2
2020-08-19 22:12:31 +00:00
info: function() { return true },
Alpha Build 4
2020-08-20 04:55:26 +00:00
changelog: function() { return true },
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
p: function() { return (player.p.unl||player.points.gte(getLayerReq('p')))&&layerUnl('p') },
b: function() { return (player.b.unl||player.points.gte(getLayerReq('b')))&&layerUnl('b') },
g: function() { return (player.g.unl||player.points.gte(getLayerReq('g')))&&layerUnl('g') },
e: function() { return (player.e.unl||player.points.gte(getLayerReq('e')))&&layerUnl('e') },
t: function() { return (player.t.unl||player.points.gte(getLayerReq('t')))&&layerUnl('t') },
s: function() { return (player.s.unl||player.points.gte(getLayerReq('s')))&&layerUnl('s') },
}
function getLayerEffDesc(layer) {
if (!Object.keys(LAYER_EFFS).includes(layer)) return "???"
let eff = LAYER_EFFS[layer]()
switch(layer) {
case "b":
return "translated to a "+format(eff)+"x multiplier to point gain"
break;
case "g":
return "which are generating "+format(eff)+" Generator Power/sec"
break;
case "t":
return "which are generating "+format(eff.gain)+" Time Energy/sec, but with a limit of "+format(eff.limit)+" Time Energy"
break;
}
}
function save() {
localStorage.setItem("prestige-tree", btoa(JSON.stringify(player)))
}
function load() {
let get = localStorage.getItem("prestige-tree");
Alpha Build 1
2020-08-19 19:53:14 +00:00
if (get===null||get===undefined) player = getStartPlayer()
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
else player = JSON.parse(atob(get))
player.tab = "tree"
checkForVars();
convertToDecimal();
loadVue();
}
function exportSave() {
let str = btoa(JSON.stringify(player))
const el = document.createElement("textarea");
el.value = str;
document.body.appendChild(el);
el.select();
el.setSelectionRange(0, 99999);
document.execCommand("copy");
document.body.removeChild(el);
}
function importSave() {
let imported = prompt("Paste your save here")
try {
player = JSON.parse(atob(imported))
save()
window.location.reload()
} catch(e) {
return;
}
}
function checkForVars() {
if (player.autosave===undefined) player.autosave = true;
if (player.b===undefined) player.b = getStartPlayer().b
if (player.g===undefined) player.g = getStartPlayer().g
if (player.p.best===undefined) player.p.best = player.p.points
if (player.b.best===undefined) player.b.best = player.b.points
Alpha Build 4
2020-08-20 04:55:26 +00:00
if (player.b.auto===undefined) player.b.auto = false
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
if (player.g.best===undefined) player.g.best = player.g.points
Alpha Build 4
2020-08-20 04:55:26 +00:00
if (player.g.auto===undefined) player.g.auto = false
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
if (player.e === undefined) player.e = getStartPlayer().e
if (player.e.order === undefined) player.e.order = 0
if (player.t === undefined) player.t = getStartPlayer().t
if (player.s === undefined) player.s = getStartPlayer().s
Alpha Build 1
2020-08-19 19:53:14 +00:00
if (player.s.buildings[4] === undefined) player.s.buildings[4] = new Decimal(0);
Alpha Build 5
2020-08-20 20:37:22 +00:00
if (player.s.buildings[5] === undefined) player.s.buildings[5] = new Decimal(0);
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
}
function convertToDecimal() {
player.points = new Decimal(player.points)
player.p.points = new Decimal(player.p.points)
player.p.best = new Decimal(player.p.best)
player.b.points = new Decimal(player.b.points)
player.b.best = new Decimal(player.b.best)
player.g.points = new Decimal(player.g.points)
player.g.best = new Decimal(player.g.best)
player.g.power = new Decimal(player.g.power)
player.e.points = new Decimal(player.e.points)
player.e.best = new Decimal(player.e.best)
player.e.enhancers = new Decimal(player.e.enhancers)
player.t.points = new Decimal(player.t.points)
player.t.best = new Decimal(player.t.best)
player.t.energy = new Decimal(player.t.energy)
player.t.extCapsules = new Decimal(player.t.extCapsules)
player.s.points = new Decimal(player.s.points)
player.s.best = new Decimal(player.s.best)
player.s.spent = new Decimal(player.s.spent)
Alpha Build 5
2020-08-20 20:37:22 +00:00
for (let i=1;i<=5;i++) player.s.buildings[i] = new Decimal(player.s.buildings[i])
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
}
function toggleOpt(name) {
player[name] = !player[name]
}
function exponentialFormat(num, precision) {
let e = num.log10().floor()
let m = num.div(Decimal.pow(10, e))
return m.toStringWithDecimalPlaces(3)+"e"+e.toStringWithDecimalPlaces(0)
}
function commaFormat(num, precision) {
if (num === null || num === undefined) return "NaN"
return num.toStringWithDecimalPlaces(precision).replace(/\B(?=(\d{3})+(?!\d))/g, ",")
}
function format(decimal, precision=3) {
decimal = new Decimal(decimal)
Alpha Build 6
2020-08-21 03:33:13 +00:00
if (decimal.gte("eee1000")) return exponentialFormat(decimal, precision)
else if (decimal.gte("ee1000")) return "ee"+format(decimal.log10().log10())
else if (decimal.gte("1e1000")) return decimal.div(Decimal.pow(10, decimal.log10().floor())).toStringWithDecimalPlaces(precision)+"e"+format(decimal.log10().floor())
else if (decimal.gte(1e9)) return exponentialFormat(decimal, precision)
Alpha Build 1
2020-08-19 19:53:14 +00:00
else if (decimal.gte(1e3)) return commaFormat(decimal, 0)
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
else return commaFormat(decimal, precision)
}
function formatWhole(decimal) {
return format(decimal, 0)
}
function showTab(name) {
if (!TAB_REQS[name]()) return
player.tab = name
if (name=="tree") needCanvasUpdate = true;
}
function canBuyMax(layer) {
switch(layer) {
case "b":
return player.b.best.gte(15)
break;
case "g":
return player.g.best.gte(15)
break;
}
return false;
}
function getLayerReq(layer) {
let req = LAYER_REQS[layer]
switch(layer) {
case "b":
if (player.g.unl && !player.b.unl) req = req.times(5000)
break;
case "g":
if (player.b.unl && !player.g.unl) req = req.times(5000)
break;
case "e":
Alpha Build 3
2020-08-20 01:27:52 +00:00
req = req.times(Decimal.pow("1e200", Decimal.pow(player.e.order, 2)))
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
break;
case "t":
Alpha Build 3
2020-08-20 01:27:52 +00:00
req = req.times(Decimal.pow("1e200", Decimal.pow(player.t.order, 2)))
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
break;
case "s":
Alpha Build 3
2020-08-20 01:27:52 +00:00
req = req.times(Decimal.pow("1e200", Decimal.pow(player.s.order, 2)))
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
break;
}
return req
}
function getLayerGainMult(layer) {
let mult = new Decimal(1)
switch(layer) {
case "p":
if (player.p.upgrades.includes(21)) mult = mult.times(2)
if (player.p.upgrades.includes(23)) mult = mult.times(LAYER_UPGS.p[23].currently())
if (player.b.upgrades.includes(11)) mult = mult.times(LAYER_UPGS.b[11].currently())
if (player.g.upgrades.includes(11)) mult = mult.times(LAYER_UPGS.g[11].currently())
if (player.e.unl) mult = mult.times(getEnhancerEff())
Alpha Build 1
2020-08-19 19:53:14 +00:00
if (player.e.upgrades.includes(12)) mult = mult.times(LAYER_UPGS.e[12].currently())
if (player.e.upgrades.includes(13)) mult = mult.times(1e10)
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
if (player.t.unl) mult = mult.times(getTimeEnergyEff())
if (player.s.unl) mult = mult.times(getSpaceBuildingEff(1))
break;
case "b":
if (player.b.upgrades.includes(23)) mult = mult.div(LAYER_UPGS.b[23].currently())
if (player.s.unl) mult = mult.div(getSpaceBuildingEff(3))
break;
case "g":
if (player.g.upgrades.includes(22)) mult = mult.div(LAYER_UPGS.g[22].currently())
if (player.s.unl) mult = mult.div(getSpaceBuildingEff(3))
break;
}
return mult
}
function getResetGain(layer) {
if (LAYER_TYPE[layer]=="static") {
if ((!canBuyMax(layer)) || player.points.lt(getLayerReq(layer))) return new Decimal(1)
let gain = player.points.div(getLayerReq(layer)).div(getLayerGainMult(layer)).max(1).log(LAYER_BASE[layer]).pow(Decimal.pow(LAYER_EXP[layer], -1))
if (gain.gte(12)) gain = gain.times(12).sqrt()
return gain.floor().sub(player[layer].points).plus(1).max(1);
}
if (player.points.lt(getLayerReq(layer))) return new Decimal(0)
let gain = player.points.div(getLayerReq(layer)).pow(LAYER_EXP[layer]).times(getLayerGainMult(layer))
return gain.floor().max(0);
}
function getNextAt(layer) {
if (LAYER_TYPE[layer]=="static") {
let amt = player[layer].points
if (amt.gte(12)) amt = amt.pow(2).div(12)
let extraCost = Decimal.pow(LAYER_BASE[layer], amt.pow(LAYER_EXP[layer])).times(getLayerGainMult(layer))
return extraCost.times(getLayerReq(layer)).max(getLayerReq(layer))
} else return getResetGain(layer).plus(1).div(getLayerGainMult(layer)).root(LAYER_EXP[layer]).times(getLayerReq(layer)).max(getLayerReq(layer))
}
function layerUnl(layer) {
switch(layer) {
case "p":
return true;
break;
case "b":
return player.p.unl;
break;
case "g":
return player.p.unl;
break;
case "e":
return player.b.unl&&player.g.unl;
break;
case "t":
return player.b.unl;
break;
case "s":
return player.g.unl;
break;
}
}
function rowReset(row, layer) {
let prev = JSON.parse(JSON.stringify(player)) // Deep Copy
switch(row) {
case 0:
player.points = new Decimal(0);
break;
case 1:
player.points = new Decimal(10);
player.p.points = new Decimal(0);
if (layer=="b"||layer=="g") {
if (player[layer].best.lt(8)) player.p.upgrades = [];
Alpha Build 1
2020-08-19 19:53:14 +00:00
} else if (layer=="t"||layer=="s") {
if (player[layer].best.lt(3)) player.p.upgrades = [];
} else if (layer=="e") {
if (player[layer].best.lt(10)) player.p.upgrades = [];
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
} else player.p.upgrades = [];
player.g.power = new Decimal(0);
break;
case 2:
player.b.points = new Decimal(0);
player.b.best = new Decimal(0);
Alpha Build 2
2020-08-19 22:12:31 +00:00
if (!player.t.best.gte(4)) player.b.upgrades = [];
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
player.g.points = new Decimal(0);
player.g.power = new Decimal(0);
player.g.best = new Decimal(0);
Alpha Build 2
2020-08-19 22:12:31 +00:00
if (!player.s.best.gte(4)) player.g.upgrades = [];
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
player.t.energy = new Decimal(0);
if (layer=="t"||layer=="e"||layer=="s") {
if (player[layer].best.gte(2)) {
player.b.best = new Decimal(prev.b.best)
player.g.best = new Decimal(prev.g.best)
}
}
break;
case 3:
player.t.points = new Decimal(0);
player.t.order = 0
player.t.best = new Decimal(0);
player.t.upgrades = [];
player.t.extCapsules = new Decimal(0);
player.e.order = 0
player.e.points = new Decimal(0);
player.e.best = new Decimal(0);
player.e.enhancers = new Decimal(0);
player.e.upgrades = [];
player.s = {
unl: player.s.unl,
order: 0,
points: new Decimal(0),
best: new Decimal(0),
spent: new Decimal(0),
buildings: {
1: new Decimal(0),
2: new Decimal(0),
Alpha Build 1
2020-08-19 19:53:14 +00:00
3: new Decimal(0),
Alpha Build 5
2020-08-20 20:37:22 +00:00
4: new Decimal(0),
5: new Decimal(0)
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
},
upgrades: [],
}
break;
}
}
function doReset(layer, force=false) {
if (!force) {
if (player.points.lt(getLayerReq(layer))) return;
let gain = getResetGain(layer)
if (LAYER_TYPE[layer]=="static") {
if (player.points.lt(getNextAt(layer))) return;
player[layer].points = player[layer].points.plus(canBuyMax(layer)?gain:1)
} else player[layer].points = player[layer].points.plus(gain)
player[layer].best = player[layer].best.max(player[layer].points)
if (!player[layer].unl) {
player[layer].unl = true;
needCanvasUpdate = true;
let layers = ROW_LAYERS[LAYER_ROW[layer]]
for (let i in layers) if (!player[layers[i]].unl) player[layers[i]].order++
}
}
Alpha Build 6
2020-08-21 03:33:13 +00:00
if ((layer=="b"&&player.t.best.gte(12))||(layer=="g"&&player.s.best.gte(12))) return;
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
let row = LAYER_ROW[layer]
if (row==0) rowReset(0, layer)
else for (let x=row;x>=1;x--) rowReset(x, layer)
}
function buyUpg(layer, id) {
if (!player[layer].unl) return
if (!LAYER_UPGS[layer][id].unl()) return
if (player[layer].upgrades.includes(id)) return
if (player[layer].points.lt(LAYER_UPGS[layer][id].cost)) return
player[layer].points = player[layer].points.sub(LAYER_UPGS[layer][id].cost)
player[layer].upgrades.push(id);
Alpha Build 6
2020-08-21 03:33:13 +00:00
if (layer=="t"&&id==32) player.t.order = 0;
if (layer=="e"&&(id==22||id==23)) {
player.e.order = 0;
if (!player.e.upgrades.includes(22)) player.e.upgrades.push(22)
if (!player.e.upgrades.includes(23)) player.e.upgrades.push(23)
}
if (layer=="s"&&id==33) player.s.order = 0;
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
}
function getPointGen() {
let gain = new Decimal(1)
if (player.p.upgrades.includes(12)) gain = gain.times(LAYER_UPGS.p[12].currently())
if (player.p.upgrades.includes(13)) gain = gain.times(LAYER_UPGS.p[13].currently())
if (player.p.upgrades.includes(22)) gain = gain.times(LAYER_UPGS.p[22].currently())
if (player.b.unl) gain = gain.times(LAYER_EFFS.b())
if (player.g.unl) gain = gain.times(getGenPowerEff())
if (player.t.unl) gain = gain.times(getTimeEnergyEff())
if (player.s.unl) gain = gain.times(getSpaceBuildingEff(1))
return gain
}
function addToBoosterBase() {
let toAdd = new Decimal(0)
if (player.b.upgrades.includes(12)) toAdd = toAdd.plus(LAYER_UPGS.b[12].currently())
if (player.b.upgrades.includes(13)) toAdd = toAdd.plus(LAYER_UPGS.b[13].currently())
Alpha Build 1
2020-08-19 19:53:14 +00:00
if (player.t.upgrades.includes(11)) toAdd = toAdd.plus(LAYER_UPGS.t[11].currently())
Alpha Build 5
2020-08-20 20:37:22 +00:00
if (player.t.upgrades.includes(31)) toAdd = toAdd.plus(25)
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
if (player.e.unl) toAdd = toAdd.plus(getEnhancerEff2())
Alpha Build 1
2020-08-19 19:53:14 +00:00
if (player.e.upgrades.includes(11)) toAdd = toAdd.plus(LAYER_UPGS.e[11].currently().b)
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
if (player.s.unl) toAdd = toAdd.plus(getSpaceBuildingEff(2))
return toAdd
}
Alpha Build 4
2020-08-20 04:55:26 +00:00
function getFreeBoosters() {
let free = new Decimal(0)
if (player.t.upgrades.includes(24)) free = free.plus(18)
return free
}
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
function addToGenBase() {
let toAdd = new Decimal(0)
if (player.g.upgrades.includes(12)) toAdd = toAdd.plus(LAYER_UPGS.g[12].currently())
if (player.g.upgrades.includes(13)) toAdd = toAdd.plus(LAYER_UPGS.g[13].currently())
if (player.e.unl) toAdd = toAdd.plus(getEnhancerEff2())
Alpha Build 1
2020-08-19 19:53:14 +00:00
if (player.e.upgrades.includes(11)) toAdd = toAdd.plus(LAYER_UPGS.e[11].currently().g)
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
if (player.s.unl) toAdd = toAdd.plus(getSpaceBuildingEff(2))
return toAdd
}
function getGenPowerGainMult() {
let mult = new Decimal(1)
if (player.g.upgrades.includes(21)) mult = mult.times(LAYER_UPGS.g[21].currently())
if (player.g.upgrades.includes(25)) mult = mult.times(LAYER_UPGS.g[25].currently())
Alpha Build 1
2020-08-19 19:53:14 +00:00
if (player.s.upgrades.includes(12)) mult = mult.times(LAYER_UPGS.s[12].currently())
if (player.s.upgrades.includes(13)) mult = mult.times(LAYER_UPGS.s[13].currently())
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
return mult
}
Alpha Build 6
2020-08-21 03:33:13 +00:00
function getGenPowerEffExp() {
let exp = new Decimal(1/3)
if (player.s.upgrades.includes(34)) exp = exp.plus(LAYER_UPGS.s[34].currently())
if (player.b.upgrades.includes(21)) exp = exp.times(2)
if (player.b.upgrades.includes(22)) exp = exp.times(1.2)
if (player.e.upgrades.includes(21)) exp = exp.times(1.15)
return exp;
}
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
function getGenPowerEff() {
Alpha Build 6
2020-08-21 03:33:13 +00:00
let eff = player.g.power.plus(1).pow(getGenPowerEffExp());
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
return eff
}
function resetRow(row) {
if (prompt('Are you sure you want to reset this row? It is highly recommended that you wait until the end of your current run before doing this! Type "I WANT TO RESET THIS" to confirm')!="I WANT TO RESET THIS") return
let pre_layers = ROW_LAYERS[row-1]
let layers = ROW_LAYERS[row]
let post_layers = ROW_LAYERS[row+1]
rowReset(row+1, post_layers[0])
doReset(pre_layers[0], true)
for (let layer in layers) {
player[layers[layer]].unl = false
Alpha Build 6
2020-08-21 03:33:13 +00:00
if (player[layers[layer]].order) player[layers[layer]].order = 0
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
}
resizeCanvas();
}
function getEnhancerCost() {
Alpha Build 6
2020-08-21 03:33:13 +00:00
let e = player.e.enhancers
if (e.gte(25)) e = e.pow(2).div(25)
let cost = Decimal.pow(2, e.pow(1.5))
Alpha Build 1 Patch 1
2020-08-19 20:07:06 +00:00
return cost.floor()
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
}
function getEnhancerEff() {
if (!player.e.unl) return new Decimal(1)
let eff = Decimal.pow(25, player.e.enhancers.pow(1.1))
return eff
}
function getEnhancerEff2() {
if (!player.e.unl) return new Decimal(0)
let eff = player.e.enhancers.pow(0.8)
return eff;
}
function buyEnhancer() {
let cost = getEnhancerCost()
if (player.e.points.lt(cost)) return
player.e.points = player.e.points.sub(cost)
player.e.enhancers = player.e.enhancers.plus(1)
}
Alpha Build 1
2020-08-19 19:53:14 +00:00
function getFreeExtCapsules() {
let amt = new Decimal(0)
if (player.t.upgrades.includes(12)) amt = amt.plus(1)
return amt
}
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
function getTimeEnergyEff() {
if (!player.t.unl) return new Decimal(1)
Alpha Build 2
2020-08-19 22:12:31 +00:00
let exp = 1.2
if (player.t.upgrades.includes(21)) exp = 1.75
let eff = player.t.energy.plus(1).pow(exp)
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
return eff;
}
Alpha Build 2
2020-08-19 22:12:31 +00:00
function getTimeEnergyGainMult() {
if (!player.t.unl) return new Decimal(1)
let mult = new Decimal(1);
if (player.t.upgrades.includes(21)) mult = mult.times(LAYER_UPGS.t[21].currently())
Alpha Build 3
2020-08-20 01:27:52 +00:00
if (player.t.upgrades.includes(22)) mult = mult.times(LAYER_UPGS.t[22].currently())
if (player.t.upgrades.includes(23)) mult = mult.times(LAYER_UPGS.t[23].currently())
Alpha Build 2
2020-08-19 22:12:31 +00:00
return mult;
}
Alpha Build 1
2020-08-19 19:53:14 +00:00
function getTimeEnergyLimitMult() {
if (!player.t.unl) return new Decimal(1)
let mult = new Decimal(1);
if (player.t.upgrades.includes(12)) mult = mult.times(LAYER_UPGS.t[12].currently())
Alpha Build 2
2020-08-19 22:12:31 +00:00
if (player.t.upgrades.includes(21)) mult = mult.times(LAYER_UPGS.t[21].currently())
Alpha Build 3
2020-08-20 01:27:52 +00:00
if (player.t.upgrades.includes(22)) mult = mult.times(LAYER_UPGS.t[22].currently())
if (player.t.upgrades.includes(23)) mult = mult.times(LAYER_UPGS.t[23].currently())
Alpha Build 1
2020-08-19 19:53:14 +00:00
return mult;
}
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
function getExtCapsuleCost() {
Alpha Build 6
2020-08-21 03:33:13 +00:00
let amt = player.t.extCapsules
if (amt.gte(25)) amt = amt.pow(2).div(25)
let cost = amt.times(0.4).pow(1.2).plus(1).times(10)
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
return cost.floor()
}
function buyExtCapsule() {
if (!player.t.unl) return
let cost = getExtCapsuleCost()
if (player.b.points.lt(cost)) return
player.b.points = player.b.points.sub(cost)
player.t.extCapsules = player.t.extCapsules.plus(1)
}
function getSpace() {
let baseSpace = player.s.best.pow(1.1).times(3).floor()
Alpha Build 1
2020-08-19 19:53:14 +00:00
if (player.s.upgrades.includes(13)) baseSpace = baseSpace.plus(2);
Alpha Build 4
2020-08-20 04:55:26 +00:00
if (player.s.upgrades.includes(24)) baseSpace = baseSpace.plus(3);
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
return baseSpace.sub(player.s.spent)
}
Alpha Build 4
2020-08-20 04:55:26 +00:00
function getSpaceBuildingCostMod() {
let mod = new Decimal(1)
if (player.s.upgrades.includes(24)) mod = new Decimal(0.5)
return mod;
}
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
function getSpaceBuildingCost(x) {
Alpha Build 5
2020-08-20 20:37:22 +00:00
let inputVal = new Decimal([1e3,1e10,1e25,1e48,1e100][x-1])
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
let bought = player.s.buildings[x]
Alpha Build 4
2020-08-20 04:55:26 +00:00
let cost = Decimal.pow(inputVal, bought.times(getSpaceBuildingCostMod()).pow(1.35)).times(inputVal).times((bought.gt(0)||x>1)?1:0)
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
return cost
}
Alpha Build 2
2020-08-19 22:12:31 +00:00
function getSpaceBuildingPow() {
if (!player.s.unl) return new Decimal(0)
let pow = new Decimal(1)
if (player.s.upgrades.includes(21)) pow = pow.times(LAYER_UPGS.s[21].currently())
Alpha Build 4
2020-08-20 04:55:26 +00:00
if (player.s.upgrades.includes(22)) pow = pow.times(LAYER_UPGS.s[22].currently())
if (player.s.upgrades.includes(23)) pow = pow.times(LAYER_UPGS.s[23].currently())
Alpha Build 2
2020-08-19 22:12:31 +00:00
return pow
}
Alpha Build 1
2020-08-19 19:53:14 +00:00
function getExtraBuildingLevels(x) {
let lvl = new Decimal(0)
if (player.s.upgrades.includes(11)) lvl = lvl.plus(1);
if (player.s.upgrades.includes(14)) lvl = lvl.plus(1);
Alpha Build 5
2020-08-20 20:37:22 +00:00
if (x<5) lvl = lvl.plus(getSpaceBuildingEff(5))
Alpha Build 1
2020-08-19 19:53:14 +00:00
return lvl
}
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
function getSpaceBuildingEff(x) {
Alpha Build 1
2020-08-19 19:53:14 +00:00
let bought = player.s.buildings[x].plus(getExtraBuildingLevels(x));
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
if (!player.s.unl) bought = new Decimal(0);
Alpha Build 1
2020-08-19 19:53:14 +00:00
if (getSpaceBuildingsUnl()<x) bought = new Decimal(0);
Alpha Build 2
2020-08-19 22:12:31 +00:00
let power = getSpaceBuildingPow()
bought = bought.times(power)
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
switch(x) {
case 1:
Alpha Build 5
2020-08-20 20:37:22 +00:00
return Decimal.pow(Decimal.add(1, bought.pow(player.s.upgrades.includes(31)?2.75:1)), player.s.points.sqrt()).times(Decimal.mul(4, bought.pow(player.s.upgrades.includes(31)?2.75:1))).max(1)
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
break;
case 2:
return bought.sqrt()
break;
case 3:
Alpha Build 1
2020-08-19 19:53:14 +00:00
return Decimal.pow(1e18, bought.pow(0.9))
break;
case 4:
return bought.plus(1).pow(1.25)
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
break;
Alpha Build 5
2020-08-20 20:37:22 +00:00
case 5:
return bought.sqrt().times(2)
break;
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
}
}
function getSpaceBuildingEffDesc(x) {
let eff = getSpaceBuildingEff(x)
switch(x) {
case 1:
return "Space Energy boosts Point gain & Prestige Point gain ("+format(eff)+"x)"
break;
case 2:
return "Adds to base of Booster/Generator effects by "+format(eff)
break;
case 3:
return "Makes Boosters/Generators cheaper by "+format(eff)+"x"
break;
Alpha Build 1
2020-08-19 19:53:14 +00:00
case 4:
return "Booster Upgrade 6's effect is raised to the power of "+format(eff)
Alpha Build 5
2020-08-20 20:37:22 +00:00
break;
case 5:
return "Add "+format(eff)+" free levels to all previous Space Buildings."
break;
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
}
}
function buyBuilding(x) {
if (!player.s.unl) return
Alpha Build 1
2020-08-19 19:53:14 +00:00
if (getSpaceBuildingsUnl()<x) return
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
if (getSpace().lt(1)) return
let cost = getSpaceBuildingCost(x)
if (player.g.power.lt(cost)) return
player.g.power = player.g.power.sub(cost)
player.s.spent = player.s.spent.plus(1)
player.s.buildings[x] = player.s.buildings[x].plus(1)
}
function respecSpaceBuildings() {
if (!player.s.unl) return;
if (!confirm("Are you sure you want to reset your Space Buildings? This will force you to do a Space reset as well!")) return
Alpha Build 5
2020-08-20 20:37:22 +00:00
for (let i=1;i<=5;i++) player.s.buildings[i] = new Decimal(0)
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
player.s.spent = new Decimal(0)
Alpha Build 1
2020-08-19 19:53:14 +00:00
doReset("s", true)
}
function getSpaceBuildingsUnl() {
let x = 3
if (player.s.upgrades.includes(14)) x++;
Alpha Build 5
2020-08-20 20:37:22 +00:00
if (player.s.upgrades.includes(32)) x++;
Alpha Build 1
2020-08-19 19:53:14 +00:00
return x;
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
}
Alpha Build 4
2020-08-20 04:55:26 +00:00
function toggleAuto(layer) {
if (player[layer].auto===undefined) return;
player[layer].auto = !player[layer].auto
}
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
function gameLoop(diff) {
if (player.p.upgrades.includes(11)) player.points = player.points.plus(getPointGen().times(diff))
if (player.g.unl) player.g.power = player.g.power.plus(LAYER_EFFS.g().times(diff))
if (player.g.best.gte(10)) player.p.points = player.p.points.plus(getResetGain("p").times(diff))
if (player.t.unl) {
let data = LAYER_EFFS.t()
player.t.energy = player.t.energy.plus(data.gain.times(diff)).min(data.limit)
}
Alpha Build 4
2020-08-20 04:55:26 +00:00
if (player.b.auto&&player.t.best.gte(5)) doReset("b")
if (player.g.auto&&player.s.best.gte(5)) doReset("g")
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
}
function hardReset() {
if (!confirm("Are you sure you want to do this? You will lose all your progress!")) return
player = getStartPlayer()
save();
window.location.reload();
}
var saveInterval = setInterval(function() {
Alpha Build 2 Patch 1
2020-08-19 22:20:42 +00:00
if (player===undefined) return;
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
if (player.autosave) save();
}, 5000)
var interval = setInterval(function() {
Alpha Build 2 Patch 1
2020-08-19 22:20:42 +00:00
if (player===undefined) return;
Pre-Alpha Build for you greedy gamers
2020-08-19 02:50:24 +00:00
let diff = (Date.now()-player.time)/1000
player.time = Date.now()
if (needCanvasUpdate && player.tab=="tree") resizeCanvas();
gameLoop(diff)
Alpha Build 2
2020-08-19 22:12:31 +00:00
}, 50)
document.onkeydown = function(e) {
Alpha Build 2 Patch 1
2020-08-19 22:20:42 +00:00
if (player===undefined) return;
Alpha Build 2
2020-08-19 22:12:31 +00:00
let shiftDown = e.shiftKey
let key = e.key
if (!LAYERS.includes(key)) return
if (player[key].unl) doReset(key)
}
Reference in a new issue Copy permalink