1
0
Fork 0
mirror of https://github.com/Acamaeda/The-Modding-Tree.git synced 2024-11-21 16:13:55 +00:00
The-Modding-Tree/js/game.js

361 lines
10 KiB
JavaScript
Raw Normal View History

2020-08-19 02:50:24 +00:00
var player;
var needCanvasUpdate = true;
2020-08-24 02:01:14 +00:00
var NaNalert = false;
2020-09-10 01:28:47 +00:00
var gameEnded = false;
2020-08-19 02:50:24 +00:00
let modInfo = {
name: "The Modding Tree",
id: "modbase",
pointsName: "points",
discordName: "",
discordLink: "",
changelogLink: "https://github.com/Acamaeda/The-Modding-Tree/blob/master/changelog.md",
offlineLimit: 1 // In hours
}
let VERSION = {
2020-10-08 23:42:26 +00:00
num: "1.3.5 maybe",
name: "Tabception... ception!",
tmtNum: "1.3.5 maybe",
tmtName: "Tabception... ception!"
2020-08-19 02:50:24 +00:00
}
2020-10-07 05:18:56 +00:00
// Determines if it should show points/sec
function showPointGen(){
return (tmp.pointGen.neq(new Decimal(0)))
}
// Calculate points/sec!
function getPointGen() {
2020-10-11 20:16:36 +00:00
if(!hasUpg("c", 11))
return new Decimal(0)
let gain = new Decimal(1)
if (hasUpg("c", 12)) gain = gain.times(upgEffect("c", 12))
return gain
2020-08-19 02:50:24 +00:00
}
2020-10-07 05:18:56 +00:00
// Function to determine if the player is in a challenge
function inChallenge(layer, id){
let chall = player[layer].active
if (chall==toNumber(id)) return true
if (layers[layer].challs[chall].countsAs)
return layers[layer].challs[id].countsAs.includes(id)
}
function getResetGain(layer, useType = null) {
let type = useType
if (!useType) type = layers[layer].type
if (tmp[layer].gainExp.eq(0)) return new Decimal(0)
if (type=="static") {
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))
2020-09-14 19:26:10 +00:00
return gain.floor().sub(player[layer].points).add(1).max(1);
} else if (type=="normal"){
if (tmp[layer].baseAmount.lt(tmp[layer].requires)) return new Decimal(0)
let gain = tmp[layer].baseAmount.div(tmp[layer].requires).pow(layers[layer].exponent).times(tmp[layer].gainMult).pow(tmp[layer].gainExp)
2020-09-13 02:38:32 +00:00
if (gain.gte("e1e7")) gain = gain.sqrt().times("e5e6")
return gain.floor().max(0);
} else if (type=="custom"){
return layers[layer].getResetGain()
} else {
return new Decimal(0)
2020-08-19 02:50:24 +00:00
}
}
function getNextAt(layer, canMax=false, useType = null) {
let type = useType
if (!useType) type = layers[layer].type
if (tmp[layer].gainExp.eq(0)) return new Decimal(1/0)
if (type=="static")
{
if (!layers[layer].canBuyMax()) canMax = false
let amt = player[layer].points.plus((canMax&&tmp[layer].baseAmount.gte(tmp[layer].nextAt))?tmp[layer].resetGain:0)
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()
2020-08-25 22:42:43 +00:00
return cost;
} else if (type=="normal"){
let next = tmp[layer].resetGain.add(1)
2020-09-07 16:33:50 +00:00
if (next.gte("e1e7")) next = next.div("e5e6").pow(2)
next = next.root(tmp[layer].gainExp.div(tmp[layer].gainMult).root(layers[layer].exponent).times(tmp[layer].requires).max(tmp[layer].requires))
if (layers[layer].resCeil) next = next.ceil()
2020-08-25 22:42:43 +00:00
return next;
} else if (type=="custom"){
return layers[layer].getNextAt(canMax)
} else {
return new Decimal(0)
}}
2020-08-19 02:50:24 +00:00
// Return true if the layer should be highlighted. By default checks for upgrades only.
function shouldNotify(layer){
for (id in layers[layer].upgrades){
if (!isNaN(id)){
if (canAffordUpg(layer, id) && !hasUpg(layer, id) && tmp[layer].upgrades[id].unl){
return true
}
}
}
if (layers[layer].shouldNotify){
return layers[layer].shouldNotify()
}
else
return false
}
function canReset(layer)
{
if(tmp[layer].type == "normal")
return tmp[layer].baseAmount.gte(tmp[layer].requires)
else if(tmp[layer].type== "static")
return tmp[layer].baseAmount.gte(tmp[layer].nextAt)
else
return layers[layer].canReset()
}
2020-08-19 02:50:24 +00:00
function rowReset(row, layer) {
for (lr in ROW_LAYERS[row]){
if(layers[lr].doReset) {
player[lr].active = null // Exit challenges on any row reset on an equal or higher row
layers[lr].doReset(layer)
}
else
if(layers[layer].row > layers[lr].row) fullLayerReset(lr)
2020-08-19 02:50:24 +00:00
}
}
function fullLayerReset(layer) {
player[layer] = layers[layer].startData();
player[layer].upgrades = []
player[layer].milestones = []
player[layer].challs = []
if (layers[layer].tabFormat && !Array.isArray(layers[layer].tabFormat)) {
if (player.subtabs[layer] == undefined) player.subtabs[layer] = {}
if (player.subtabs[layer].mainTabs == undefined) player.subtabs[layer].mainTabs = Object.keys(layers[layer].tabFormat)[0]
}
if (layers[layer].microtabs) {
if (player.subtabs[layer] == undefined) player.subtabs[layer] = {}
for (item in layers[layer].microtabs)
if (player.subtabs[layer][item] == undefined) player.subtabs[layer][item] = Object.keys(layers[layer].microtabs[item])[0]
}
resetBuyables(layer)
}
function resetBuyables(layer){
if (layers[layer].buyables)
player[layer].buyables = getStartBuyables(layer)
player[layer].spentOnBuyables = new Decimal(0)
}
2020-10-11 20:16:36 +00:00
2020-09-09 22:14:05 +00:00
function addPoints(layer, gain) {
2020-09-14 19:26:10 +00:00
player[layer].points = player[layer].points.add(gain).max(0)
if (player[layer].best) player[layer].best = player[layer].best.max(player[layer].points)
2020-09-14 19:26:10 +00:00
if (player[layer].total) player[layer].total = player[layer].total.add(gain)
2020-09-09 22:14:05 +00:00
}
function generatePoints(layer, diff) {
addPoints(layer, tmp[layer].resetGain.times(diff))
2020-09-09 22:14:05 +00:00
}
2020-09-11 02:15:05 +00:00
var prevOnReset
2020-08-19 02:50:24 +00:00
function doReset(layer, force=false) {
let row = layers[layer].row
2020-08-19 02:50:24 +00:00
if (!force) {
if (tmp[layer].baseAmount.lt(tmp[layer].requires)) return;
let gain = tmp[layer].resetGain
if (layers[layer].type=="static") {
if (tmp[layer].baseAmount.lt(tmp[layer].nextAt)) return;
2020-09-30 02:32:08 +00:00
gain =(layers[layer].canBuyMax() ? gain : 1)
}
if (layers[layer].type=="custom") {
if (!tmp[layer].canReset) return;
}
if (layers[layer].onPrestige)
layers[layer].onPrestige(gain)
addPoints(layer, gain)
updateMilestones(layer)
2020-08-19 02:50:24 +00:00
if (!player[layer].unl) {
player[layer].unl = true;
needCanvasUpdate = true;
2020-09-11 14:21:08 +00:00
if (layers[layer].incr_order){
lrs = layers[layer].incr_order
for (lr in lrs)
if (!player[lrs[lr]].unl) player[lrs[lr]].order++
}
2020-08-19 02:50:24 +00:00
}
2020-09-11 14:21:08 +00:00
tmp[layer].baseAmount = new Decimal(0) // quick fix
2020-08-19 02:50:24 +00:00
}
2020-09-09 22:14:05 +00:00
if (tmp[layer].resetsNothing) return
2020-09-14 02:41:42 +00:00
for (layerResetting in layers) {
if (row >= layers[layerResetting].row && (!force || layerResetting != layer)) completeChall(layerResetting)
2020-09-14 02:41:42 +00:00
}
2020-09-11 02:15:05 +00:00
prevOnReset = {...player} //Deep Copy
player.points = (row == 0 ? new Decimal(0) : new Decimal(10))
for (let x = row; x >= 0; x--) rowReset(x, layer)
2020-09-11 02:15:05 +00:00
prevOnReset = undefined
2020-08-26 19:08:00 +00:00
updateTemp()
2020-09-09 02:10:25 +00:00
updateTemp()
2020-08-19 02:50:24 +00:00
}
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
2020-08-21 03:33:13 +00:00
if (player[layers[layer]].order) player[layers[layer]].order = 0
2020-08-19 02:50:24 +00:00
}
player.points = new Decimal(10)
2020-08-21 19:02:34 +00:00
updateTemp();
2020-08-19 02:50:24 +00:00
resizeCanvas();
}
2020-09-14 02:41:42 +00:00
function startChall(layer, x) {
2020-10-07 20:41:45 +00:00
let enter = false
2020-09-14 02:41:42 +00:00
if (!player[layer].unl) return
if (player[layer].active == x) {
completeChall(layer, x)
delete player[layer].active
2020-08-26 16:26:46 +00:00
} else {
2020-10-07 20:41:45 +00:00
enter = true
}
2020-09-14 02:41:42 +00:00
doReset(layer, true)
2020-10-07 20:41:45 +00:00
if(enter) player[layer].active = x
2020-09-14 02:41:42 +00:00
updateChallTemp(layer)
2020-08-26 16:26:46 +00:00
}
function canCompleteChall(layer, x)
{
if (x != player[layer].active) return
let chall = layers[layer].challs[x]
if (chall.currencyInternalName){
let name = chall.currencyInternalName
if (chall.currencyLayer){
let lr = chall.currencyLayer
2020-10-03 19:45:47 +00:00
return !(player[lr][name].lt(readData(chall.goal)))
}
else {
return !(player[name].lt(chall.cost))
}
}
else {
return !(player[layer].points.lt(chall.cost))
}
}
2020-09-14 02:41:42 +00:00
function completeChall(layer, x) {
var x = player[layer].active
if (!x) return
2020-10-11 20:42:32 +00:00
if (! canCompleteChall(layer, x)){
delete player[layer].active
return
}
if (player[layer].challs[x] < tmp[layer].challs[x].completionLimit) {
needCanvasUpdate = true
2020-10-11 20:42:32 +00:00
player[layer].challs[x] += 1
if (layers[layer].challs[x].onComplete) layers[layer].challs[x].onComplete()
2020-09-09 22:14:05 +00:00
}
2020-09-14 02:41:42 +00:00
delete player[layer].active
updateChallTemp(layer)
2020-09-09 22:14:05 +00:00
}
2020-09-15 19:27:33 +00:00
VERSION.withoutName = "v" + VERSION.num + (VERSION.pre ? " Pre-Release " + VERSION.pre : VERSION.pre ? " Beta " + VERSION.beta : "")
2020-09-14 19:26:10 +00:00
VERSION.withName = VERSION.withoutName + (VERSION.name ? ": " + VERSION.name : "")
2020-09-14 02:41:42 +00:00
2020-09-16 02:50:53 +00:00
const ENDGAME = new Decimal("e280000000");
2020-09-10 01:28:47 +00:00
2020-08-19 02:50:24 +00:00
function gameLoop(diff) {
2020-09-14 19:26:10 +00:00
if (player.points.gte(ENDGAME) || gameEnded) gameEnded = 1
2020-09-09 22:14:05 +00:00
if (isNaN(diff)) diff = 0
2020-09-10 01:46:36 +00:00
if (gameEnded && !player.keepGoing) {
diff = 0
player.tab = "gameEnded"
2020-09-10 01:28:47 +00:00
}
2020-09-14 19:26:10 +00:00
if (player.devSpeed) diff *= player.devSpeed
2020-09-14 21:18:02 +00:00
2020-09-14 22:12:36 +00:00
addTime(diff)
2020-09-14 21:18:02 +00:00
for (layer in layers){
if (layers[layer].update) layers[layer].update(diff);
2020-08-29 19:45:18 +00:00
}
2020-09-14 02:41:42 +00:00
for (layer in layers){
if (layers[layer].automate) layers[layer].automate();
}
2020-08-26 03:32:27 +00:00
for (layer in layers){
if (layers[layer].milestones) updateMilestones(layer);
2020-09-09 02:10:25 +00:00
}
2020-08-26 03:32:27 +00:00
2020-08-24 02:01:14 +00:00
if (player.hasNaN&&!NaNalert) {
2020-08-25 22:42:43 +00:00
clearInterval(interval);
2020-08-26 01:45:22 +00:00
player.autosave = false;
2020-08-24 02:01:14 +00:00
NaNalert = true;
2020-09-14 21:18:02 +00:00
alert("We have detected a corruption in your save. Please visit https://discord.gg/wwQfgPa for help.")
2020-08-24 02:01:14 +00:00
}
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();
}
2020-09-15 00:45:31 +00:00
var ticking = false
2020-08-19 02:50:24 +00:00
var interval = setInterval(function() {
2020-08-31 18:33:29 +00:00
if (player===undefined||tmp===undefined) return;
2020-09-15 00:45:31 +00:00
if (ticking) return;
2020-09-10 01:39:08 +00:00
if (gameEnded&&!player.keepGoing) return;
2020-09-15 00:45:31 +00:00
ticking = true
let now = Date.now()
2020-09-15 19:27:33 +00:00
let diff = (now - player.time) / 1e3
if (player.offTime !== undefined) {
if (player.offTime.remain > modInfo.offlineLimit * 3600000) player.offlineTime.remain = modInfo.offlineLimit * 3600000
2020-09-15 19:27:33 +00:00
if (player.offTime.remain > 0) {
let offlineDiff = Math.max(player.offTime.remain / 10, diff)
player.offTime.remain -= offlineDiff
diff += offlineDiff
}
if (!player.offlineProd || player.offTime.remain <= 0) delete player.offTime
2020-09-01 00:39:33 +00:00
}
2020-09-15 19:27:33 +00:00
if (player.devSpeed) diff *= player.devSpeed
2020-09-15 00:45:31 +00:00
player.time = now
2020-08-22 03:59:24 +00:00
if (needCanvasUpdate) resizeCanvas();
2020-08-21 19:02:34 +00:00
updateTemp();
2020-09-09 22:14:05 +00:00
gameLoop(diff)
2020-09-15 00:45:31 +00:00
ticking = false
2020-08-19 22:12:31 +00:00
}, 50)