a mod for idle.vidski.dev
// ==UserScript==
// @name Cascade-Scripts
// @namespace http://tampermonkey.net/
// @version 0.0.3
// @description a mod for idle.vidski.dev
// @author Cascade
// @match https://idle.vidski.dev/*
// @icon https://www.google.com/s2/favicons?sz=64&domain=vidski.dev
// @grant none
// @require https://code.jquery.com/jquery-3.6.4.min.js
// @run-at document-start
// @license MIT
// ==/UserScript==
(async function() {
let db = {
}
function extractGameData(jsFile) {
function genericSlice(search, add = 1){
const startIndex = jsFile.indexOf(search);
if (startIndex === -1) return null;
let endIndex = startIndex + add;
// add enough here and in the for loop and in the return to hit the first { from the = (example: "={1:{id:1,nam..." would add one, since the { is one after the =)
let bracketCount = 0;
let inObject = false;
for (let i = startIndex + add; i < jsFile.length; i++) {
const char = jsFile[i];
if (char === '{') bracketCount++;
if (char === '}') {
bracketCount--;
if (bracketCount === 0 && inObject) {
endIndex = i + add;
break;
}
}
if (char === '{' && !inObject) inObject = true;
}
return jsFile.slice(startIndex + 1, endIndex);
}
// Extract HD (items) - it starts with "HD={" and goes until we hit the next const/let/var declaration
function extractHD() {
return genericSlice('={1:{id:1,name:{de:"Kupfererz",en:"Copper Ore"}', 1);
}
// Extract YD (actions) - it starts with "const YD={" and goes until we hit the next const/let/var declaration
function extractYD() {
return genericSlice('={1:{id:1,actions:{1:{id:1,skill_id:1,skill_level:1,action_type:"GATHERING",category:null,combat:null,name:{de:"Kupferader",en:"Copper Vein"}', 1);
}
// Extract Ti (skills)
function extractTi() {
return genericSlice('={1:{id:1,name:"Mining"', 1);
}
try {
// Extract the objects
const itemsStr = extractHD();
const actionsStr = extractYD();
const skillsStr = extractTi();
if (!itemsStr || !actionsStr || !skillsStr) {
throw new Error('Failed to extract one or both objects');
}
// Parse the objects
const db = {
items: Function(`
"use strict";
return (${itemsStr});
`)(),
actions: Function(`
"use strict";
return (${actionsStr});
`)(),
skills: Function(`
"use strict";
return (${skillsStr});
`)()
};
return db;
} catch (e) {
console.error('Extraction/evaluation error:', e);
return { items: {}, actions: {} };
}
}
fetch('https://idle.vidski.dev', {
method: 'GET'
})
.then(response => response.text())
.then(html => {
const parser = new DOMParser();
const doc = parser.parseFromString(html, 'text/html');
const appVersion = doc.querySelector('meta[name="app-version"]').getAttribute('content');
const scriptSrc = doc.querySelector('script[type="module"]').getAttribute('src');
console.log('App Version:', appVersion);
console.log('Scriptsrc:', scriptSrc);
return fetch(`https://idle.vidski.dev/${scriptSrc}`, { method: 'GET' });
})
.then(response => response.text())
.then(jsFile => {
db = extractGameData(jsFile);
console.log('game data:', db);
})
.catch(error => console.error('Error:', error));
// database functions
function getNestedProperty(obj, path) {
return path.split('.').reduce((o, i) => (o ? o[i] : undefined), obj);
}
let dbf = {
item: function(property1, value) {
const propertyMap = Object.values(db.items).reduce((map, item) => {
map[item[property1]] = item;
return map;
}, {});
return propertyMap[value];
},
skill: function(property1, value) {
const propertyMap = Object.values(db.skills).reduce((map, skill) => {
map[skill[property1]] = skill;
return map;
}, {});
return propertyMap[value];
},
action: function(property1, value) {
for (let skillKey in db.actions) {
let val = dbf.action_skill(property1, value, skillKey)
if(val) return val
}
return null; // Return null if no match is found
},
action_skill: function(property1, value, skillId) {
const skill = db.actions[skillId].actions;
for (let actionKey in skill) {
const action = skill[actionKey];
const property1Value = getNestedProperty(action, property1);
if (property1Value === value) {
return action;
}
}
},
}
const euler_mascheroni = 0.57721566490153286060651209008240243104215933593992;
let help = {
tiers: [1, 10, 25, 40, 55, 70, 85, 100, 115],
first_greater_than: (arr, num) => arr.find(x => x > num),
format_time: (seconds) => {
let h = Math.floor(seconds / 3600);
let m = Math.floor((seconds % 3600) / 60);
return (h > 0 ? `${h}h ` : '') + (m > 0 ? `${m}m` : h === 0 ? '0m' : '');
},
level_to_xp: (L) => {
// https://oldschool.runescape.wiki/w/Experience
// (L^2/8)−9/40L+75((2^(L/7)−2^(1/7))/(2^(1/7)−1))−γ
return ((L**2 /8) - (9/40*L) + 75*((2**(L/7)-2**(1/7))/(2**(1/7)-1)) - euler_mascheroni);
},
round: (v, n=1) => {
const digits = -Math.floor(Math.log10(n));
const result = Math.round(v / n) * n;
const formattedResult = result.toFixed(digits);
return parseFloat(formattedResult);
},
get_quality: (quality_id) => {
switch (quality_id){
case 0: return "poor"
case 1: return "common"
case 2: return "uncommon"
case 3: return "rare"
case 4: return "epic"
case 5: return "legendary"
case 6: return "special"
default: return "unknown"
}
}
}
let me = {}, me_ready = false
async function on_get_me(response){
try {
const data = await response.json();
console.log('your data:', data);
me = data;
me_ready = true
} catch (error) {console.error('Error parsing JSON:', error)};
}
async function wait_for_me() {
let response = await fetch('https://api-eu.vidski.dev/api/me/', {
headers: {
"Authorization": `Bearer ${JSON.parse(localStorage.getItem('auth-storage')).state.token}`,
},
})
if(response.ok)
on_get_me(response)
else
console.error(response)
}
window.cascade = {
get help() { return help; },
get db() { return db; },
get me() { return me; },
get me_ready() { return me_ready; },
}
// actual script below
await wait_for_me()
function create_table({ id, items, state = "open", duration = "0s", width = "482.5px", height = "211px" }) {
const tableEl = $("<table>", { class: "w-full caption-bottom text-sm" })
.append($("<tbody>", { class: "[&_tr:last-child]:border-0" }));
items.forEach(item => {
const tr = $("<tr>", { class: "border-b transition-colors hover:bg-muted/50 data-[state=selected]:bg-muted cursor-pointer" });
item.forEach(prop => {
const td = $("<td>", { class: "p-4 align-middle [&:has([role=checkbox])]:pr-0" });
if (Array.isArray(prop)) {
td.addClass("flex items-center gap-1")
.append($("<img>", { src: prop[0], class: `w-6 ${prop[2] ? `border border-${prop[2]}` : ""}` }))
.append(prop[1]);
} else {
td.text(prop);
}
tr.append(td);
});
tableEl.find("tbody").append(tr);
});
return tableEl;
}
function create_tab_menu(tabs, callback = undefined) {
let container = $('<div>', { class: 'flex flex-col mt-4' });
let buttonContainer = $('<div>', { class: 'flex flex-row space-x-1.5 p-2 justify-evenly' });
let contentContainer = $('<div>', { class: 'p-4', id: 'main-content' });
let tabContents = {};
let tabButtons = {};
tabs.forEach((tab, index) => {
let button = $('<button>', {
class: 'w-full items-center gap-2 p-2 text-center hover:bg-sidebar-accent hover:text-sidebar-accent-foreground rounded-3xl',
text: tab
});
tabButtons[tab] = button
let contentDiv = $('<div>', {
id: `tab-${tab}`,
class: 'hidden',
text: `Content for ${tab}`
});
tabContents[tab] = contentDiv;
if (index === 0) {
button.addClass('bg-sidebar-accent text-sidebar-accent-foreground');
contentContainer.append(contentDiv);
contentDiv.removeClass('hidden');
}
button.on('click', function () {
$('#main-content').empty().append(tabContents[tab]);
$('.tab-button').removeClass('bg-sidebar-accent text-sidebar-accent-foreground');
button.addClass('bg-sidebar-accent text-sidebar-accent-foreground');
if (callback) callback(tab);
});
button.addClass('tab-button');
buttonContainer.append(button);
});
container.append(buttonContainer, contentContainer);
return { container: container, tab_contents: tabContents, tab_buttons: tabButtons};
}
function recalculate_stats(){
const i = me.equipment
let bx = {
health: 50,
armor: 0,
block_chance: 0,
damage: 0,
attack_speed: 0,
mining_speed: 0,
mining_quality: 0,
fishing_speed: 0,
fishing_quality: 0,
smithing_speed: 0,
smithing_quality: 0,
smelting_speed: 0,
smelting_quality: 0,
woodcutting_speed: 0,
woodcutting_quality: 0,
cooking_speed: 0
}
, n = {
...bx
};
if (i) {
for (const [,r] of Object.entries(i)) {
if (!r)
continue;
const l = db.items[r];
if (!(!l || !l.stats))
for (const u in n){
//Object.prototype.hasOwnProperty.call(l.stats, u) && console.log("stat", u, l.stats[u])
Object.prototype.hasOwnProperty.call(l.stats, u) && (n[u] += l.stats[u])
}
}
n.damage === 0 && (n.damage = 2);
n.attack_speed === 0 && (n.attack_speed = 2e3);
//console.log("calculated stats: ", n)
return n
}
}
function get_current_action_name(){
let action_titles = $('div.text-card-foreground').find('div.text-sm:contains("Lv.")').parent().find('div.text-2xl')
let current_action_name = "unknown";
if(action_titles.length == 2){
//combat, first one is your name.
current_action_name = action_titles.eq(1).text().trim()
} else {
//normal skill
current_action_name = action_titles.text().trim()
}
return current_action_name
}
function get_calcs(data){
let current_skill = data.current_skill
let current_level = data.current_level
let current_xp = data.current_xp
let next_level_level = data.next_level_level
let next_tier_level = data.next_tier_level
let next_level_xp = data.next_level_xp
let next_tier_xp = data.next_tier_xp
let current_action = data.current_action
let actual_action_duration_seconds = data.actual_action_duration_seconds
let calculated_stats = data.calculated_stats
let calculations = []
let aph = 3600.0 / actual_action_duration_seconds
//console.log("aph ", aph)
let xph = aph * current_action.experience
let next_level_time = (next_level_xp - current_xp) / xph * 3600
let next_tier_time = (next_tier_xp - current_xp) / xph * 3600
let action_img = "images/items/" + current_action.image
if(current_action.action_type == "COMBAT"){
action_img = "/images/ui/combat/" + current_action.image
}
calculations.push([[action_img, "actions/hr"], help.round(aph, 0.1)])
calculations.push([["/images/ui/skills/" + current_skill.image, "xp/hr"], help.round(xph)])
calculations.push([`Lv. ${next_level_level}`, `${help.format_time(next_level_time)}`])
calculations.push([`Lv. ${next_tier_level}`, `${help.format_time(next_tier_time)}`])
calculations.push(["item", "per hr", "quantity", "rate"])
let quality_bonus = 1 + (calculated_stats[current_skill.name.toLowerCase() + '_quality'] ?? 0) / 100
for (let i = 0; i < current_action.rewards.length; i++){
current_action.rewards[i].drop_rate_with_bonus = current_action.rewards[i].drop_rate * quality_bonus
}
// assuming rates flow towards start of array if over 1. (take away rates starting at the end of array until it becomes 1)
let cum_drop_rate = 0
for (let i = 0; i < current_action.rewards.length; i++){
cum_drop_rate += current_action.rewards[i].drop_rate_with_bonus
}
//lower drop rates starting at last reward backwards until normal
if(cum_drop_rate > 1){
for (let i = current_action.rewards.length - 1; i >= 0; i--){
let reward = current_action.rewards[i]
let extra_drop_rate = cum_drop_rate - 1;
let amount_to_negate = Math.min(extra_drop_rate, 1)
reward.enrichment_normalized_drop_rate = reward.drop_rate_with_bonus - amount_to_negate
cum_drop_rate -= amount_to_negate
}
}
for (let i = 0; i < current_action.rewards.length; i++){
let reward = current_action.rewards[i]
let item = dbf.item('id', reward.item_id)
let item_quality = help.get_quality(item.quality)
let drop_rate = reward.enrichment_normalized_drop_rate ?? reward.drop_rate_with_bonus
let avg_drop = (reward.quantity + reward.max_quantity) / 2 * drop_rate
calculations.push([["/images/items/" + item.image, item.name.en, item_quality],
help.round(aph * avg_drop, 0.01) + "",
reward.quantity === reward.max_quantity ? `${reward.quantity}` : `${reward.quantity} to ${reward.max_quantity}`,
drop_rate < 0.01 ? `1 in ${help.round(1 / drop_rate, 1)}` : `${help.round(drop_rate * 100, 0.1)}%`])
}
return calculations
}
let current_tab = "Calculations"
const clear_panel = () => $('#cascade_container').remove();
function update(){
clear_panel()
let current_skill_name = $('header.sticky').find('span.text-foreground').find('span.inline-flex.items-center').text().trim()
let current_action_name = get_current_action_name()
let current_skill = dbf.skill('name', current_skill_name)
if(!current_skill || !current_action_name || !current_skill_name) return;
let current_level = Number($('div.flex.justify-between.p-2.pl-6.pr-6.text-sm').find('span:contains("Lv.")').text().replace("Lv.", "").trim())
let current_xp_progress_to_next = Number($('div.flex.justify-between.p-2.pl-6.pr-6.text-sm').find('span:contains("XP")').text().replace(",", "").replace("XP", "").trim().split('/')[0])
let current_xp = help.level_to_xp(current_level) + current_xp_progress_to_next
let next_level_xp = help.level_to_xp(current_level + 1)
let next_tier_level = help.first_greater_than(help.tiers, current_level)
let next_tier_xp = help.level_to_xp(next_tier_level)
let current_action = dbf.action_skill('name.en', current_action_name, current_skill.id)
console.log("Update", current_action)
let action_duration_original_ms
let actual_action_duration_seconds
let calculated_stats = recalculate_stats()
if(current_action.action_type == "COMBAT"){
console.log("Combat not supported")
action_duration_original_ms = 3600000
actual_action_duration_seconds = 3600
} else {
action_duration_original_ms = current_action.duration
// due to how speed works, 50% "speed" results in 2x more actions, and 99% "speed" results in 100x more actions.
let speed_or_more_accurately_duration_reduction_factor = (1 - ((calculated_stats[current_skill.name.toLowerCase() + '_speed']??0)) / 100.0)
actual_action_duration_seconds = action_duration_original_ms / 1000 * (speed_or_more_accurately_duration_reduction_factor)
}
let calcs = get_calcs({current_skill, current_level, current_xp, next_level_level: current_level + 1, next_tier_level, next_level_xp, next_tier_xp, current_action, actual_action_duration_seconds, calculated_stats})
let calcs_table = create_table({
items: calcs,
});
let tab_menu = create_tab_menu(["Calculations"], (tab_name) => {
current_tab = tab_name
})
let container = tab_menu.container
container.attr('id', 'cascade_container');
tab_menu.tab_contents["Calculations"] = calcs_table
$('div.col-span-1.order-0.lg\\:order-2').append(container)
tab_menu.tab_buttons[current_tab].click()
return current_action
}
// check for when action title changes
let last_action_title
setInterval(check_action, 100)
function check_action(){
const value = get_current_action_name()
if(value != last_action_title){
// update when action is changed
clear_panel()
setTimeout(update, 55)
}
last_action_title = value
}
// also update when 5s passes
setInterval(update, 5000)
})();