flyff-tools / apps / skillulator / src / utils / skill-tree-helpers.ts

import type { Jobs, Skills } from "../types";
import { SKILL_BRACKETS, type JOB_SKILLPOINTS } from "./constants";

export function getJobById(jobId: number, jobs: Jobs) {
	return jobs.filter((job) => job.id === jobId).at(0);
}

export function getSkillById(skillId: number, skills: Skills) {
	return skills.filter((skill) => skill.id === skillId).at(0);
}

export interface SkillRequirement {
	skill: number;
	level: number;
	hasMinLevel: boolean;
}

export function updateSkillRequirements(
	job: Jobs[0],
	skillId: number,
	newSkillLevel: number,
): void {
	if (!job) return;

	for (const skill of job.skills) {
		const requirement = skill.requirements.find((req) => req.skill === skillId);

		if (skill?.masterVariations) {
			for (const variation of skill.masterVariations) {
				const masterSkillRequirement = variation.requirements.find(
					(requirement) => requirement.skill === skillId,
				);

				if (!masterSkillRequirement) continue;
				const requirementIndex = variation.requirements.findIndex(
					(req) => req.skill === skillId,
				);

				console.log({ requirementIndex });

				const meetsRequirement = newSkillLevel >= masterSkillRequirement.level;
				variation.requirements[requirementIndex].hasMinLevel = meetsRequirement;
			}
		}
		if (!requirement) continue;

		const requirementIndex = skill.requirements.findIndex(
			(req) => req.skill === skillId,
		);

		const meetsRequirement = newSkillLevel >= requirement.level;
		skill.requirements[requirementIndex].hasMinLevel = meetsRequirement;
	}
}

export function checkSkillRequirements(skill: Skills[0]): boolean {
	return skill.requirements.every((req) => req.hasMinLevel);
}

export function isSkillMaxed(skill: Skills[0]): boolean {
	return skill.skillLevel === skill.levels;
}

export function isMasterSkillSelected(skill: Skills[0]) {
	return skill.skillLevel >= 1;
}

export function getJobByName(jobName: string, jobs: Jobs) {
	return jobs.find(
		(job) => job.name.en.toLowerCase() === jobName.toLowerCase(),
	);
}

export function encodeTree(skills: Skills, characterLevel: number) {
	const masterVariationSkills = skills
		.map((skill) =>
			skill?.masterVariations?.map(
				(variation) => `${variation.id}:${variation.skillLevel}`,
			),
		)
		.filter(Boolean)
		.flat()
		.join(",");

	const topLevelSkills = skills
		.map((skill) => `${skill.id}:${skill.skillLevel}`)
		.join(",");

	return `${topLevelSkills},${masterVariationSkills}#${characterLevel}`;
}

export function decodeTree(encodedSkills: string) {
	const characterLevel = encodedSkills.split("#").at(1);
	const decodedTree = encodedSkills.split("#").at(0);
	if (characterLevel && decodedTree) {
		return {
			normalizedSkillMap: decodedTree
				.split(",")
				.map((skill) => skill.split(":"))
				.map((s) => ({ skill: Number(s[0]), level: Number(s[1]) })),
			characterLevel,
		};
	}
	throw new Error("Could not decode skill tree");
}

export function getSkillPointsForLevel(characterLevel: number): number {
	if (characterLevel < 15) {
		return 0;
	}

	let totalPoints = 0;
	// this is because characters start at level one, not zero
	// needed to calculate the correct amount of skillpoints for the first bracket
	let previousMaxLevel = 1;

	for (const bracket of SKILL_BRACKETS) {
		const effectiveLevel = Math.min(characterLevel, bracket.maxLevel);
		const levelsInBracket = Math.max(0, effectiveLevel - previousMaxLevel);
		console.log(bracket, levelsInBracket, levelsInBracket * bracket.pointsPerLevel)

		totalPoints += levelsInBracket * bracket.pointsPerLevel;
		previousMaxLevel = bracket.maxLevel;

		if (characterLevel <= bracket.maxLevel) {
			break;
		}
	}

	return totalPoints;
}

export function getJobTotalSkillPoints(
	jobMap: typeof JOB_SKILLPOINTS,
	jobId: number,
	characterLevel: number,
) {
	if (characterLevel >= 60) {
		return (
			getSkillPointsForLevel(characterLevel) +
			jobMap[jobId].firstJobSP +
			jobMap[jobId].secondJobSP +
			jobMap[jobId].thirdJobSP
		);
	}

	return getSkillPointsForLevel(characterLevel) + jobMap[jobId].firstJobSP;
}