diff --git a/.github/workflows/daily-build.yml b/.github/workflows/daily-build.yml index 498ad39..bb9b194 100644 --- a/.github/workflows/daily-build.yml +++ b/.github/workflows/daily-build.yml @@ -1,5 +1,5 @@ name: Daily Build -run-name: Performium Daily Build (#${{ github.run_number }} - v1.7.0${{ github.run_number}}) +run-name: Performium Daily Build (#${{ github.run_number }} - v1.8.0${{ github.run_number}}) on: schedule: diff --git a/README.md b/README.md index 28fb48f..c220b7f 100644 --- a/README.md +++ b/README.md @@ -21,6 +21,8 @@ This plugin adds a ribbon and command of a new function meant to calculate the p - Complexity - Information +It also adds a ribbon and command where you can see all of the values you have calculated throughout the times you have the plugin installed and enabled! + ## Preview - ![image](https://github.com/user-attachments/assets/149e6167-c5e0-4c99-b050-4540dbeee7e0) diff --git a/manifest.json b/manifest.json index ebc5a73..dce3c0d 100644 --- a/manifest.json +++ b/manifest.json @@ -1,7 +1,7 @@ { "id": "performosu", "name": "Performium", - "version": "1.7.0", + "version": "1.8.0", "minAppVersion": "1.11.0", "description": "Integrates the osu! Performance Points system to gamify your note-taking experience!", "author": "Louie Kurenai", diff --git a/package-lock.json b/package-lock.json index 95ba9e2..edad393 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "performosu", - "version": "1.7.0", + "version": "1.8.0", "lockfileVersion": 2, "requires": true, "packages": { "": { "name": "performosu", - "version": "1.7.0", + "version": "1.8.0", "license": "MIT", "dependencies": { "shelljs": "^0.10.0" diff --git a/package.json b/package.json index d23258d..fd6b813 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "performosu", - "version": "1.7.0", + "version": "1.8.0", "description": "Integrates the osu! Performance Points system to gamify your note-taking experience!", "main": "main.js", "scripts": { diff --git a/src/main.ts b/src/main.ts index 8d5d9cf..80a7d77 100644 --- a/src/main.ts +++ b/src/main.ts @@ -17,6 +17,7 @@ import { calculatePerformance as calculatePerformance080325 } from "./utils/pp/0 import { calculatePerformance as calculatePerformance011726 } from "./utils/pp/011726"; import { calculatePerformance as calculatePerformance020426 } from "./utils/pp/020426"; import { calculatePerformance as calculatePerformance021426 } from "./utils/pp/021426"; +import { calculatePerformance as calculatePerformance031526 } from "./utils/pp/031526"; import { calculatePerformance as calculatePerformanceTest } from "./utils/pp/test"; import { getPerformanceVersion } from "./functions/getPerformanceVersion"; @@ -127,6 +128,8 @@ export default class PerformiumPlugin extends Plugin { async calculatePerformance(): Promise < number > { if (this.settings.ppSystem === "test") { return calculatePerformanceTest(this); + } else if (this.settings.ppSystem === "031526") { + return calculatePerformance031526(this); } else if (this.settings.ppSystem === "021426") { return calculatePerformance021426(this); } else if (this.settings.ppSystem === "020426") { @@ -153,8 +156,8 @@ export default class PerformiumPlugin extends Plugin { async calculateSecondaryPerformance(): Promise < number > { if (this.settings.secondaryPpSystem === "test") { return calculatePerformanceTest(this); - } else if (this.settings.secondaryPpSystem === "021426") { - return calculatePerformance021426(this); + } else if (this.settings.secondaryPpSystem === "031526") { + return calculatePerformance031526(this); } else if (this.settings.secondaryPpSystem === "020426") { return calculatePerformance020426(this); } else if (this.settings.secondaryPpSystem === "011726") { diff --git a/src/options/base.ts b/src/options/base.ts index 27f3001..e48b803 100644 --- a/src/options/base.ts +++ b/src/options/base.ts @@ -24,7 +24,7 @@ export interface PerformiumBaseSettings { } export const DEFAULT_SETTINGS: PerformiumBaseSettings = { - ppSystem: "021426", + ppSystem: "031526", installTimestamp: 0, totalFocusTime: 0, secondaryPpSystem: "test", @@ -141,7 +141,7 @@ export class PerformiumSettingsTab extends PluginSettingTab { // version display, perhaps new Setting(containerEl) - .setName("Performium v1.7.0") - .setDesc("Codename: Kinetisphere") + .setName("Performium v1.8.0") + .setDesc("Codename: Lightcore") } } diff --git a/src/utils/pp/031526.ts b/src/utils/pp/031526.ts new file mode 100644 index 0000000..e8fd376 --- /dev/null +++ b/src/utils/pp/031526.ts @@ -0,0 +1,186 @@ +/* + + 031226.ts: the system used for version v1.8.0 (codename lightcore) + this will be an attempt to fully rewrite the performance values and rebalance them until it's ready for publish. + while it might use some older evaluators, most of the code uses the new ones. + certain variables will be commented out until it's possible for use. + +*/ + +import PerformiumPlugin from "../../main"; +import { calculateVaultStats } from "src/functions/vaultStats"; + +// the new evaluators used for the rewritten code +import { getOrphanCount } from "../values/newerEvaluators/orphanCount"; +import { calculateVaultCleanliness } from "../values/newerEvaluators/vaultCleanliness"; +import { getAllFiles, getAllFolders } from "../values/newerEvaluators/itemCount"; +// import { countAllLinks, countAllWikiLinks } from "../values/newerEvaluators/linkCount"; +import { getTotalWordCount } from "../values/newerEvaluators/newVaultStats"; + +// the function to calculate the pp values from the entire vault (confusion, my bad) +export async function calculatePerformance(plugin: PerformiumPlugin): Promise { + const app = plugin.app; + + let vaultStats = await calculateVaultStats(app); + + let performanceValue = 0; + + let totalWords = await getTotalWordCount(app); + + async function calculateReadability(): Promise { + // readability function + let value = 0; + + // make use of the character-to-word ratio + let characterToWordRatio: number = totalWords / vaultStats.totalChars; + + // add a variable similar to the visual calculation of the cs (circle size) formula from the osu! game + let wordRadiusValue = 64 * (1 - (0.7 * ((characterToWordRatio - 2.5) / 5))); + + // debug + // console.log('wordRadiusValue: ' + wordRadiusValue); + + // add a bonus with the use of the recently made value + let wordLengthMultiplier = Math.max(1.0, 1.0 + (30 - wordRadiusValue) / 40); + + // add it as a bonus + value += wordRadiusValue * wordLengthMultiplier; + + return value; + } + + async function calculateVaultRating(): Promise { + // vault rating function + let value = 1; + + // for the multiplier of the value + let vaultCleanlinessValue = await calculateVaultCleanliness(vaultStats.totalFiles, vaultStats.totalFolders, vaultStats.totalParagraphs); + + return value + (vaultCleanlinessValue / 9.95); + } + + async function calculateInformability() { + // function to get values from equations with uses of the vault stats + let value = 1; + + // use various vault stats to make a readable value + let wordToSentenceRatio = vaultStats.totalWords / vaultStats.totalSentences; + let sentencetoParagraphRatio = vaultStats.totalSentences / vaultStats.totalParagraphs; + + // context bonus + let contextBonus = 0; + + if (sentencetoParagraphRatio >= 3) { + contextBonus += (Math.log(sentencetoParagraphRatio) + Math.log(sentencetoParagraphRatio * 1.5)) * 2; + } else { + contextBonus += Math.log(sentencetoParagraphRatio) * 2; + } + + value += contextBonus; + + value += ((wordToSentenceRatio * sentencetoParagraphRatio) / 5) / vaultStats.totalFiles; + + let fileToFolderRatio = await getAllFiles() / await getAllFolders(); + + value += fileToFolderRatio; + + // add a bonus with math logarithm + value += Math.log(vaultStats.totalSentences); + + // estimate the number of words and sentences in a paragraph + let paragraphWordCount = wordToSentenceRatio * sentencetoParagraphRatio; + + // debug + // console.log(`${paragraphWordCount}pp`); + + // add as a bonus + value += Math.log(paragraphWordCount) * (1 + ((paragraphWordCount / 25) / 10)); + + return value + } + + async function calcualtePenalties(): Promise { + // function to calculate penalties + let value = 0; + + // if the words are too short + let characterToWordRatio = vaultStats.totalChars / await getTotalWordCount(app); + + value += (Math.E ** ((4 - characterToWordRatio) / 2)) * 50; + + // get the total amount of orphans in the vault + let orphanCount: number = await getOrphanCount(app); + + // apply it to the value as a penalty + value += orphanCount; + + // add a multiplier to make things fair + value *= 1 + 0.055 * Math.log(1 + vaultStats.totalChars); + + // add another use to the character-to-word ratio variable + value += (characterToWordRatio / 2) * (characterToWordRatio * (1 / 125)); + + return value; + } + + async function calculateStatBonuses(): Promise { + // stat rating function + let value = 0; + + // get the bonus value of the vault's file count with mathematic logarithms + value += Math.log(vaultStats.totalFiles) * Math.PI; + + // as well as making use of the vault's folders + value += Math.log(vaultStats.totalFolders) * 1.5; + + console.log(value); + + // let wikiLinkCount = await countAllWikiLinks(app); + // let allLinkCount = await countAllLinks(app); + + // let allLinkTowikiLinkRatio = allLinkCount / wikiLinkCount; + // let wikiLinkToAllLinkRatio = wikiLinkCount / allLinkCount; + + // apply certain values as pieces of a penalty + // value += ((allLinkTowikiLinkRatio + wikiLinkToAllLinkRatio) / Math.E) - 10; + + // add some value with the use of total characters typed in the vault + let characterBonus = Math.log(vaultStats.totalChars) + (vaultStats.totalChars / 3000); + + value += characterBonus * Math.pow(Math.PI, 0.6); + + value += ((417 - (1 / 3)) / 4) * (1 - Math.pow(0.9975, plugin.settings.totalExecutionCount)); + + // add a small multiplier to the full value + value += (Math.log(value) + (1 + (value * 0.025))) / 125; + + return value; + } + + // calculate the full value + let readabilityValue = await calculateReadability(); + let vaultRatingValue = await calculateVaultRating(); + let statBonusValue = await calculateStatBonuses(); + let informabilityValue = await calculateInformability(); + let penaltyValue = await calcualtePenalties(); + + performanceValue += ((readabilityValue + statBonusValue + informabilityValue - penaltyValue) * vaultRatingValue) / 1.075; + + // debug + console.log(`readabilityValue: ${(readabilityValue * vaultRatingValue) / 1.075}pp`); + console.log(`statBonusValue: ${(statBonusValue * vaultRatingValue) / 1.075}pp`); + console.log(`informabilityValue: ${(informabilityValue * vaultRatingValue) / 1.075}pp`); + console.log(`penaltyValue: ${(penaltyValue * vaultRatingValue) / 1.075}pp`); + console.log(`vaultRatingValue: ${vaultRatingValue / 1.075}x`); + + // console.log('performanceValue: ' + performanceValue); + + // cleaner value handling + if (!Number.isFinite(performanceValue) || performanceValue <= 0) { + console.log("Invalid performance value. Setting to 0pp..."); + performanceValue = 0; + } + + return performanceValue; +} + diff --git a/versions.json b/versions.json index 0894123..eb5fc3b 100644 --- a/versions.json +++ b/versions.json @@ -10,5 +10,6 @@ "1.6.1": "1.11.0", "1.6.2": "1.11.0", "1.6.3": "1.11.0", - "1.7.0": "1.11.0" + "1.7.0": "1.11.0", + "1.8.0": "1.11.0" }