flyff-tools / apps / skillulator / src / zustand / treeStore.ts

import { produce } from "immer";
import { create } from "zustand";
import { immer } from "zustand/middleware/immer";
import { tree as jobTree } from "@/data/tree";
import {
	getJobById,
	getJobTotalSkillPoints,
	getSkillById,
	updateSkillRequirements,
} from "@/utils/skill-tree-helpers";
import { JOB_SKILLPOINTS } from "@/utils/constants";

export type State = {
	jobTree: typeof jobTree;
	skillPoints: number;
	JOB_SKILLPOINTS: typeof JOB_SKILLPOINTS;
};

type Actions = {
	increaseSkillPoint: ({
		jobId,
		skillId,
		masterVariationSkillId,
	}: {
		jobId: number;
		skillId: number;
		masterVariationSkillId?: number;
	}) => void;
	increaseSkillToMax: ({
		jobId,
		skillId,
		masterVariationSkillId,
	}: {
		jobId: number;
		skillId: number;
		masterVariationSkillId?: number;
	}) => void;
	decreaseSkillPoint: ({
		jobId,
		skillId,
		masterVariationSkillId,
	}: {
		jobId: number;
		skillId: number;
		masterVariationSkillId?: number;
	}) => void;
	initSkillPoints: (jobId: number, characterLevel: number) => void;

	createPreloadedSkillTree: (
		jobId: number,
		skills: Array<Record<string, number>>,
	) => void;
	resetSkillTree: (jobId: number) => void;
};

const initialState: State = {
	jobTree,
	JOB_SKILLPOINTS,
	skillPoints: 0,
};

export const useTreeStore = create<State & Actions>()(
	immer((set) => ({
		jobTree,
		JOB_SKILLPOINTS,
		skillPoints: 0,
		initSkillPoints: (jobId: number, characterLevel: number) =>
			set(
				produce((state: State) => {
					// need to figure out how many skill points are already spent and subtract it
					const totalSkillPoints = getJobTotalSkillPoints(
						state.JOB_SKILLPOINTS,
						jobId,
						characterLevel,
					);

					const job = getJobById(jobId, state.jobTree);
					if (!job) return state;

					// i didn't write this but it works so w/e
					const spentSkillPoints = job.skills.reduce((total, skill) => {
						const base = (skill.skillLevel || 0) * (skill.points || 0);
						const mv =
							skill.masterVariations?.reduce(
								(sum, mvSkill) =>
									sum + (mvSkill.skillLevel || 0) * (mvSkill.points || 0),
								0,
							) || 0;
						return total + base + mv;
					}, 0);

					const remainingSkillPoints = totalSkillPoints - spentSkillPoints;

					state.skillPoints = remainingSkillPoints;
					return state;
				}),
			),
		increaseSkillPoint: ({
			jobId,
			skillId,
			masterVariationSkillId,
		}: {
			jobId: number;
			skillId: number;
			masterVariationSkillId?: number;
		}) =>
			set(
				produce((state: State) => {
					const job = getJobById(jobId, state.jobTree);
					if (!job) return state;

					/**
					 * Master variation skills don't live in the outer skill array, only within the skill they are variations of...
					 */
					const skill = getSkillById(skillId, job.skills);

					if (
						skill?.masterVariations?.length &&
						typeof masterVariationSkillId !== "undefined"
					) {
						if (!masterVariationSkillId) return state;
						const masterVariationSkill = getSkillById(
							masterVariationSkillId,
							skill.masterVariations,
						);

						if (!masterVariationSkill) return state;

						if (masterVariationSkill.skillLevel === masterVariationSkill.levels)
							return state;
						if (masterVariationSkill.points > state.skillPoints) return state;

						masterVariationSkill.skillLevel += 1;
						state.skillPoints -= masterVariationSkill.points;

						updateSkillRequirements(
							job,
							masterVariationSkillId,
							masterVariationSkill.skillLevel,
						);
						return state;
					}

					if (!skill) return state;

					if (skill.skillLevel === skill.levels) return state;
					if (skill.points > state.skillPoints) return state;

					skill.skillLevel += 1;
					state.skillPoints -= skill.points;

					updateSkillRequirements(job, skillId, skill.skillLevel);
					return state;
				}),
			),
		decreaseSkillPoint: ({
			jobId,
			skillId,
			masterVariationSkillId,
		}: {
			jobId: number;
			skillId: number;
			masterVariationSkillId?: number;
		}) =>
			set(
				produce((state: State) => {
					const job = getJobById(jobId, state.jobTree);
					if (!job) return state;

					const skill = getSkillById(skillId, job.skills);
					if (
						skill?.masterVariations?.length &&
						typeof masterVariationSkillId !== "undefined"
					) {
						if (!masterVariationSkillId) return state;
						const masterVariationSkill = getSkillById(
							masterVariationSkillId,
							skill.masterVariations,
						);

						if (!masterVariationSkill) return state;
						if (masterVariationSkill.skillLevel === 0) {
							return state;
						}

						masterVariationSkill.skillLevel -= 1;
						state.skillPoints += masterVariationSkill.points;

						updateSkillRequirements(
							job,
							masterVariationSkillId,
							masterVariationSkill.skillLevel,
						);
						return state;
					}

					if (!skill || skill.skillLevel === 0) return state;

					skill.skillLevel -= 1;
					state.skillPoints += skill.points;

					updateSkillRequirements(job, skillId, skill.skillLevel);
					return state;
				}),
			),
		createPreloadedSkillTree: (
			jobId: number,
			predefinedSkills: Array<Record<string, number>>,
		) =>
			set(
				produce((state: State) => {
					// we map over the pre-defined skills
					// we check the skill id and level and update the skillLevel accordingly
					// we also need to do the check to see if the skill is the min level
					const job = getJobById(jobId, state.jobTree);
					if (!job) return state;

					for (const originalTreeSkill of job.skills) {
						// set level for the base skill if present in predefinedSkills
						for (const predefinedTreeSkill of predefinedSkills) {
							if (originalTreeSkill.id === predefinedTreeSkill.skill) {
								originalTreeSkill.skillLevel = predefinedTreeSkill.level;
							}
						}

						// also handle any master variation skills that live inside this skill
						if (originalTreeSkill.masterVariations?.length) {
							for (const mvSkill of originalTreeSkill.masterVariations) {
								for (const predefinedTreeSkill of predefinedSkills) {
									if (mvSkill.id === predefinedTreeSkill.skill) {
										mvSkill.skillLevel = predefinedTreeSkill.level;
									}
								}
								// update requirements for this master variation skill
								updateSkillRequirements(job, mvSkill.id, mvSkill.skillLevel);
							}
						}

						const skill = getSkillById(originalTreeSkill.id, job.skills);
						if (skill) {
							updateSkillRequirements(
								job,
								originalTreeSkill.id,
								skill.skillLevel,
							);
						}
					}
					return state;
				}),
			),
		increaseSkillToMax: ({
			jobId,
			skillId,
			masterVariationSkillId,
		}: {
			jobId: number;
			skillId: number;
			masterVariationSkillId?: number;
		}) =>
			set(
				produce((state: State) => {
					const job = getJobById(jobId, state.jobTree);
					if (!job) return state;

					const skill = getSkillById(skillId, job.skills);
					if (
						skill?.masterVariations?.length &&
						typeof masterVariationSkillId !== "undefined"
					) {
						if (!masterVariationSkillId) return state;
						const masterVariationSkill = getSkillById(
							masterVariationSkillId,
							skill.masterVariations,
						);

						if (!masterVariationSkill) return state;
						if (masterVariationSkill.levels === masterVariationSkill.skillLevel)
							return state;

						const maxPossibleLevel = Math.min(
							masterVariationSkill.levels,
							Math.floor(state.skillPoints / masterVariationSkill.points),
						);

						if (maxPossibleLevel > masterVariationSkill.skillLevel) {
							const levelsToAdd =
								maxPossibleLevel - masterVariationSkill.skillLevel;
							masterVariationSkill.skillLevel = maxPossibleLevel;
							state.skillPoints -= levelsToAdd * masterVariationSkill.points;
						}

						updateSkillRequirements(
							job,
							masterVariationSkillId,
							masterVariationSkill.skillLevel,
						);
						return state;
					}
					if (!skill) return state;

					if (skill.levels === skill.skillLevel) return state;

					const maxPossibleLevel = Math.min(
						skill.levels,
						Math.floor(state.skillPoints / skill.points),
					);

					if (maxPossibleLevel > skill.skillLevel) {
						const levelsToAdd = maxPossibleLevel - skill.skillLevel;
						skill.skillLevel = maxPossibleLevel;
						state.skillPoints -= levelsToAdd * skill.points;
					}

					updateSkillRequirements(job, skillId, skill.skillLevel);
					return state;
				}),
			),
		resetSkillTree: (jobId: number) =>
			set((state: State) => {
				const skillPoints = getJobTotalSkillPoints(
					state.JOB_SKILLPOINTS,
					jobId,
					15,
				);

				return {
					...initialState,
					skillPoints,
				};
			}),
	})),
);