diff --git a/.gitignore b/.gitignore index e09a007..e6f558d 100644 --- a/.gitignore +++ b/.gitignore @@ -16,7 +16,7 @@ main.js *.map # obsidian -data.json +.obsidian # Exclude macOS Finder (System Explorer) View States .DS_Store diff --git a/.prettierignore b/.prettierignore index e7c0c79..35349f3 100644 --- a/.prettierignore +++ b/.prettierignore @@ -2,3 +2,4 @@ node_modules .github package-lock.json main.js +src/quotes/quotes.ts diff --git a/LICENSE b/LICENSE index 03d2959..2fdc26c 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,7 @@ MIT License Copyright (c) 2023 Erica Xu +Copyright (c) 2023 Obsidian TTRPG Community and Collaborators Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/docs/Adding-animation-to-plugin-source.md b/docs/Adding-animation-to-plugin-source.md new file mode 100644 index 0000000..b5c0f1a --- /dev/null +++ b/docs/Adding-animation-to-plugin-source.md @@ -0,0 +1,314 @@ +# Adding your new animations to the plugin code + +This guide walks you step-by-step for adding your created animations into the source code. + +Each file where you need to add your additions will include commented templates to make the process easier. + +For this pages examples, I will use the following popular character: Pikachu. + +> 👿 Please DO NOT add a Pikachu animation to a public copy of this plugin. + +## 1. Adding quotes to QuoteManager.ts + +> ⚠ If you have not already added your new character's quote lines in [Quotes](Quotes.ts), do that first. You can find instructions in [Adding quotes to Granite](Adding-quotes-to-Granite.md). + +To have your characters say something within Granite, we need to tell the plugin to add its quotes. In [QuoteManager.ts](QuoteManager.ts), you will first want to import the quotes you created in [Quotes.ts](Quotes.ts). + +### Imports + +Underneath the import section, add your new character to the import list. + +**Before**: + +```ts +import GranitePlugin from './main'; +import { AnimationSourceType } from './Setting'; +import { GraniteMode, GraniteState } from './Granite'; +import { DRAKE_EXCLUSIVE_QUOTES, GEMMY_EXCLUSIVE_QUOTES, GRANITE_BASE_QUOTES, Quotes } from './quotes/Quotes'; +``` + +**After**: + +```ts +import GranitePlugin from './main'; +import { AnimationSourceType } from './Setting'; +import { GraniteMode, GraniteState } from './Granite'; +import { PIKACHU_EXCLUSIVE_QUOTES, DRAKE_EXCLUSIVE_QUOTES, GEMMY_EXCLUSIVE_QUOTES, GRANITE_BASE_QUOTES, Quotes } from './quotes/Quotes'; +``` + + +### Quotemap + +In the QuoteManager class, you will want to add your new character to the quote map. + +**Before**: + +```ts + constructor(plugin: GranitePlugin) { + this.plugin = plugin; + + this.quoteMap = { + [AnimationSourceType.GEMMY]: { + [GraniteMode.IDLE]: this.getIdleQuotes(GEMMY_EXCLUSIVE_QUOTES), + [GraniteMode.WRITING]: this.getWritingQuotes(GEMMY_EXCLUSIVE_QUOTES), + }, + [AnimationSourceType.DRAKE]: { + [GraniteMode.IDLE]: this.getIdleQuotes(DRAKE_EXCLUSIVE_QUOTES), + [GraniteMode.WRITING]: this.getWritingQuotes(DRAKE_EXCLUSIVE_QUOTES), + }, + }; +``` + +**After**: + +```ts + constructor(plugin: GranitePlugin) { + this.plugin = plugin; + + this.quoteMap = { + [AnimationSourceType.GEMMY]: { + [GraniteMode.IDLE]: this.getIdleQuotes(GEMMY_EXCLUSIVE_QUOTES), + [GraniteMode.WRITING]: this.getWritingQuotes(GEMMY_EXCLUSIVE_QUOTES), + }, + [AnimationSourceType.DRAKE]: { + [GraniteMode.IDLE]: this.getIdleQuotes(DRAKE_EXCLUSIVE_QUOTES), + [GraniteMode.WRITING]: this.getWritingQuotes(DRAKE_EXCLUSIVE_QUOTES), + }, + }; + [AnimationSourceType.PIKACHU]: { + [GraniteMode.IDLE]: this.getIdleQuotes(PIKACHU_EXCLUSIVE_QUOTES), + [GraniteMode.WRITING]: this.getWritingQuotes(PIKACHU_EXCLUSIVE_QUOTES), + }, + }; +``` + +## 2. Import your animations into Animations.ts + +To add your newly created animations into Granite to be rendered, we need to tell the plugin to process the gifs. + +### Imports + +Under the import section, we need to map a value to the animations. + +**Before**: +```ts +// Draconic Animations +import EMERGE_MOTION_DRAKE from '../animations/drake/drake_emerge.gif'; +import POP_MOTION_DRAKE from '../animations/drake/drake_pop.gif'; +import DISAPPEAR_MOTION_DRAKE from '../animations/drake/drake_disappear.gif'; +import ANGRY_MOTION_DRAKE from '../animations/drake/drake_angry.gif'; +import LOOK_MOTION_DRAKE from '../animations/drake/drake_lookAround.gif'; +import IDLE_MOTION_DRAKE from '../animations/drake/drake_idle.gif'; +import DISAPPOINT_IMG_DRAKE from '../animations/drake/drake_disappoint.gif'; +``` + +After: +```ts +// Draconic Animations +import EMERGE_MOTION_DRAKE from '../animations/PIKACHU/PIKACHU_emerge.gif'; +import POP_MOTION_DRAKE from '../animations/PIKACHU/PIKACHU_pop.gif'; +import DISAPPEAR_MOTION_DRAKE from '../animations/drake/drake_disappear.gif'; +import ANGRY_MOTION_DRAKE from '../animations/drake/drake_angry.gif'; +import LOOK_MOTION_DRAKE from '../animations/drake/drake_lookAround.gif'; +import IDLE_MOTION_DRAKE from '../animations/drake/drake_idle.gif'; +import DISAPPOINT_IMG_DRAKE from '../animations/drake/drake_disappoint.gif'; + +// Pikachu Animations +import EMERGE_MOTION_PIKACHU from '../animations/drake/drake_emerge.gif'; +import POP_MOTION_PIKACHU from '../animations/drake/drake_pop.gif'; +import DISAPPEAR_MOTION_PIKACHU from '../animations/drake/pikachu_disappear.gif'; +import ANGRY_MOTION_PIKACHU from '../animations/pikachu/pikachu_angry.gif'; +import LOOK_MOTION_PIKACHU from '../animations/pikachu/pikachu_lookAround.gif'; +import IDLE_MOTION_PIKACHU from '../animations/pikachu/pikachu_idle.gif'; +import DISAPPOINT_IMG_PIKACHU from '../animations/pikachu/pikachu_disappoint.gif'; +``` + +### Animations class + +Within the animations export class, you will want to add your animation map. + +**Before**: +```ts +// the mappings from an animation type to an actual image file for the drakeling +public readonly drakeAnimationMap: Record; +``` + +**After**: +```ts +// the mappings from an animation type to an actual image file for the pikachu +public readonly pikachuAnimationMap: Record; +// the mappings from an animation type to an actual image file for the drakeling +public readonly drakeAnimationMap: Record; +``` + + +### Animation Map + +Then further down, define the animation map. + +**Before**: + +```ts +constructor(plugin: GranitePlugin) { + this.plugin = plugin; + + this.drakeAnimationMap = { + [AnimationType.EMERGE]: EMERGE_MOTION_DRAKE, + [AnimationType.POP_MOTION]: POP_MOTION_DRAKE, + [AnimationType.DISAPPEAR_MOTION]: DISAPPEAR_MOTION_DRAKE, + [AnimationType.ANGRY_MOTION]: ANGRY_MOTION_DRAKE, + [AnimationType.LOOK_MOTION]: LOOK_MOTION_DRAKE, + [AnimationType.IDLE_MOTION]: IDLE_MOTION_DRAKE, + [AnimationType.DISAPPOINT_IMG]: DISAPPOINT_IMG_DRAKE, + }; +``` + + +**After**: + +```ts +constructor(plugin: GranitePlugin) { + this.plugin = plugin; + + this.pikachuAnimationMap = { + [AnimationType.EMERGE]: EMERGE_MOTION_PIKACHU, + [AnimationType.POP_MOTION]: POP_MOTION_PIKACHU, + [AnimationType.DISAPPEAR_MOTION]: DISAPPEAR_MOTION_PIKACHU, + [AnimationType.ANGRY_MOTION]: ANGRY_MOTION_PIKACHU, + [AnimationType.LOOK_MOTION]: LOOK_MOTION_PIKACHU, + [AnimationType.IDLE_MOTION]: IDLE_MOTION_PIKACHU, + [AnimationType.DISAPPOINT_IMG]: DISAPPOINT_IMG_PIKACHU, + }; + + this.drakeAnimationMap = { + [AnimationType.EMERGE]: EMERGE_MOTION_DRAKE, + [AnimationType.POP_MOTION]: POP_MOTION_DRAKE, + [AnimationType.DISAPPEAR_MOTION]: DISAPPEAR_MOTION_DRAKE, + [AnimationType.ANGRY_MOTION]: ANGRY_MOTION_DRAKE, + [AnimationType.LOOK_MOTION]: LOOK_MOTION_DRAKE, + [AnimationType.IDLE_MOTION]: IDLE_MOTION_DRAKE, + [AnimationType.DISAPPOINT_IMG]: DISAPPOINT_IMG_DRAKE, + }; +``` + +### Source Map + +And right below that, add your character to the source map. + +**Before**: + +```ts +this.animationSourceMap = { + [AnimationSourceType.DRAKE]: this.drakeAnimationMap, + [AnimationSourceType.GEMMY]: this.gemmyAnimationMap, +}; +``` + +**After**: + +```ts +this.animationSourceMap = { + [AnimationSourceType.PIKACHU]: this.pikachuAnimationMap, + [AnimationSourceType.DRAKE]: this.drakeAnimationMap, + [AnimationSourceType.GEMMY]: this.gemmyAnimationMap, +}; +``` + + +## 3. Update Settings.ts + +Now we need to make it so that you can toggle which character to use in your settings. + +### AnimationSourceType + +In the animation source type section, we need to define the name of the character for the animations we have loaded thus far. + +**Before**: + +```ts +export enum AnimationSourceType { + GEMMY = 'gemmy', + DRAKE = 'drake', +``` + +**After**: + +```ts +export enum AnimationSourceType { + GEMMY = 'gemmy', + DRAKE = 'drake', + PIKACHU = 'pikachu', +``` + +### PluginSettingsTab + +Now, we add the new character to the dropdown list. + +**Before**: + +```ts +.addDropdown(dropdown => + dropdown + .addOption(AnimationSourceType.GEMMY, 'Gemmy') + .addOption(AnimationSourceType.DRAKE, 'Drake') +``` + +**After**: + +```ts +.addDropdown(dropdown => + dropdown + .addOption(AnimationSourceType.GEMMY, 'Gemmy') + .addOption(AnimationSourceType.DRAKE, 'Drake') + .addOption(AnimationSourceType.PIKACHU, 'Pikachu') +``` + +## 4. Update Main.ts + +This last update will tell Granite what to load based on the settings provided. + +### Async loadsettings + +Before: + +```ts +async loadSettings() { + this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData()); + + // migrations + // @ts-ignore + if (this.settings.animationSource === 'dragon') { + this.settings.animationSource = AnimationSourceType.DRAKE; + } + // @ts-ignore + if (this.settings.animationSource === 'original') { + this.settings.animationSource = AnimationSourceType.GEMMY; + } + + await this.saveSettings(); +} +``` + + +```ts +async loadSettings() { + this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData()); + + // migrations + if (this.settings.animationSource === 'rat') { + this.settings.animationSource = AnimationSourceType.PIKACHU; + } + // @ts-ignore + if (this.settings.animationSource === 'dragon') { + this.settings.animationSource = AnimationSourceType.DRAKE; + } + // @ts-ignore + if (this.settings.animationSource === 'original') { + this.settings.animationSource = AnimationSourceType.GEMMY; + } + + await this.saveSettings(); +} +``` + + diff --git a/docs/Adding-animations-to-Granite.md b/docs/Adding-animations-to-Granite.md new file mode 100644 index 0000000..73fc04b --- /dev/null +++ b/docs/Adding-animations-to-Granite.md @@ -0,0 +1,47 @@ +# Adding animations to Granite Plugin + +This page gives the overall guidelines on what an animation needs to be to be successful in this plugin. + +## What format do these need to be in? + +All animations need to be in a `.gif` format. + +## Supported Emotes + +Granite supports a few different character emotes within the plugin. + +- Angry +- Disappear +- Disappoint +- Emerge +- Idle +- Look Around +- Pop + +## How long is each animation? + +- Angry is 1.92 seconds +- Disappear is 1.92 seconds +- Disappoint is 0.16 seconds +- Emerge is 3.84 seconds +- Idle is 7.3 seconds +- Look Around is 6.4 seconds +- Pop is 1.92 seconds + +## Where to place the animated gifs + +These animations are stored in `animations/name` where name is the name of the character. + +**Example**: As of writing this, Granite plugin has two characters: `gemmy` and `drake`. Gemmy's animations are located in `animations/gemmy` and Drake's animations are located in `animations/drake`. + +## What naming convention should I use? + +The animations need to be in lower case text. + +Additionally, the animations need to be named charactername_emote.gif, to match the emote they are for. + +Example: `gemmy_angry.gif` is the angry animation for Gemmy. + +## How do I add them to the plugin itself? + +See [Adding animations to plugin details](Adding-animation-to-plugin-source.md). diff --git a/docs/Adding-quotes-to-Granite.md b/docs/Adding-quotes-to-Granite.md new file mode 100644 index 0000000..f90fe39 --- /dev/null +++ b/docs/Adding-quotes-to-Granite.md @@ -0,0 +1,60 @@ + +# Adding quotes to Granite Plugin + +All quotes are handled in [Quotes,ts](src/quotes/Quotes.ts). +This file is a javascript array of objects, with each section controlling a certain character. + +Quotes are grouped under `Base Quotes`, and individual `Character Quotes`. +They are grouped further by `General`, `Idle`, and `Writing Mode` quotes. + +## Adding quotes to an existing character + +1. Open [Quotes.ts](src/quotes/Quotes.ts) and find the character you want to edit. +2. Determine if you are editing a general quote, idle quote, or writing mode quote. +3. In the section that you want to add your line to, use the following formatting to add your line: + +```json + `You are a background character in your own life.`, +``` + +How this may look in its `.json` file: + +```json + "general": [ + "You are a background character in your own life.", + ], +``` + + +Some rules of thumb: +- Every quote line needs to end with a comma `,`. +- Every quote line needs to be surrounded by double quotes `"`. + +## Adding a new character + +To add a new character into the quotes, you can add the following to the bottom of [Quotes.ts](src/quotes/Quotes.ts): + +**Before**: + +```ts +export const DRAKE_EXCLUSIVE_QUOTES: Quotes = { + general: [], + idle: [], + writingMode: [], +}; +``` + +**After**: + +```ts +export const DRAKE_EXCLUSIVE_QUOTES: Quotes = { + general: [], + idle: [], + writingMode: [], +}; +export const PIKACHU_EXCLUSIVE_QUOTES: Quotes = { + general: [], + idle: [], + writingMode: [], +}; +``` diff --git a/docs/README.md b/docs/README.md new file mode 100644 index 0000000..01ad3f4 --- /dev/null +++ b/docs/README.md @@ -0,0 +1,21 @@ +# Developing Granite plugin + +These documents go over the more advanced features of adding to and developing Granite. + +## Guides + +1. [Adding quotes to Granite](Adding-quotes-to-Granite.md) +2. [Adding animations to Granite](Adding-animations-to-Granite.md) +3. [Adding animation to plugin source files](Adding-animation-to-plugin-source.md) + +## Developer environment + +Granite is NPM enabled. You can retrieve the packages needed by using `npm -i D`. + +To auto-build the plugin while you are adding changes, you can use the following command in your terminal/IDE of choice: `npm run dev`. + +If you wish to specify a different output file for the built `main.js`, then add a `.env` file in the root directory of your fork, and add the following to the file: + +`OUTDIR="/absolute/path/to/your/vault/.obsidian/plugins/Granite"` + +This way, you can reload Obsidian and see your updated changes. You may also utilize the [Hot Reload](https://github.com/pjeby/hot-reload) to reload Obsidian for you. \ No newline at end of file diff --git a/main.js b/main.js index 257302c..0738544 100644 --- a/main.js +++ b/main.js @@ -132,6 +132,8 @@ var Animations = class { ["disappoint_ing" /* DISAPPOINT_IMG */]: gemmy_disappoint_default }; this.animationSourceMap = { + // Add your character to the animation source map, where name is your character name. + // [AnimationSourceType.NAME]: this.nameAnimationMap, ["drake" /* DRAKE */]: this.drakeAnimationMap, ["gemmy" /* GEMMY */]: this.gemmyAnimationMap }; @@ -175,40 +177,47 @@ var GRANITE_BASE_QUOTES = { "I slap the barrel with my member!... the 'barrel' open's its mouth!", "I'm not deprived, I'm depraved.", "You need a free hand to attempt a grapple", - `Careful how much you carry; the GM might actually ask you to calculate your inventory weight!`, - `Don't do that! Then we'll have to go look up the grapple rules!`, - `50 page backstory... NOPE`, - `It's astounding anyone can understand you, with all those Nat 1 Charisma rolls.`, - `The cheddar monks are here to save the day!`, - `You've been Gygaxed.`, - `STEP AWAY FROM THE PURCHASE MORE DICE BUTTON`, - `After thousands of years, I have attained my current state, while you struggle to complete this simple note.`, - `You are a background character in your own life.` + "Careful how much you carry; the GM might actually ask you to calculate your inventory weight!", + "Don't do that! Then we'll have to go look up the grapple rules!", + "50 page backstory... NOPE", + "It's astounding anyone can understand you, with all those Nat 1 Charisma rolls.", + "The cheddar monks are here to save the day!", + "You've been Gygaxed.", + "STEP AWAY FROM THE PURCHASE MORE DICE BUTTON", + "After thousands of years, I have attained my current state, while you struggle to complete this simple note.", + "You are a background character in your own life.", + "What... sorry Who is the Bard doing now?", + "DO NOT put the portable hole in the bag of holding!", + "DO NOT put the bag of holding in the portable hole!", + "If the shed's a'Rocking... RUN" ], writingMode: [ - `Player's dont take notes... maybe you should try that?`, - `Is that the best you can do? Keep writing!`, - `Write first, editor later.`, - `AI could probably write a better note...`, - `I love hearing your keyboard. Don't stop.`, - `How about we review some old notes today?`, - `Why not just use a template?`, - `Doesn't matter how much you plan... they will derail anyway!`, - `Maybe it's time to go get some water or coffee.`, - `That's not how rivers are in real-life...`, - `Anything is better than a blank page, even me. Write something!`, - `Have you given out Inspiration recently?`, - `Call me Jeeves. I. Dare. You.`, - `I cast 'Summon Bigger Fish`, - `Do you touch it?`, - `What would Matt Mercer do?`, - `To continue, please insert more credits`, - `Have you considered just... Not?` + "Player's dont take notes... maybe you should try that?", + "Is that the best you can do? Keep writing!", + "Write first, editor later.", + "AI could probably write a better note...", + "I love hearing your keyboard. Don't stop.", + "How about we review some old notes today?", + "Why not just use a template?", + "Doesn't matter how much you plan... they will derail anyway!", + "Maybe it's time to go get some water or coffee.", + "That's not how rivers are in real-life...", + "Anything is better than a blank page, even me. Write something!", + "Have you given out Inspiration recently?", + "Call me Jeeves. I. Dare. You.", + "I cast 'Summon Bigger Fish'", + "Do you touch it?", + "What would Matt Mercer do?", + "To continue, please insert more credits", + "Have you considered just... Not?", + "You can't just write 'I win'" ] }; var GEMMY_EXCLUSIVE_QUOTES = { general: [], - idle: [], + idle: [ + "You pooping?" + ], writingMode: [] }; var DRAKE_EXCLUSIVE_QUOTES = { @@ -230,6 +239,13 @@ var QuoteManager = class { ["IDLE" /* IDLE */]: this.getIdleQuotes(DRAKE_EXCLUSIVE_QUOTES), ["WRITING" /* WRITING */]: this.getWritingQuotes(DRAKE_EXCLUSIVE_QUOTES) } + // Copy and paste below to add your character's source here. + // Replace NAME with your new character's name + // + // [AnimationSourceType.NAME]: { + // [GraniteMode.IDLE]: this.getIdleQuotes(NAME_EXCLUSIVE_QUOTES), + // [GraniteMode.WRITING]: this.getWritingQuotes(NAME_EXCLUSIVE_QUOTES), + // }, }; console.log("granite | build quote map", this.quoteMap); } @@ -443,6 +459,11 @@ var GranitePlugin = class extends import_obsidian2.Plugin { console.log("granite | unload"); this.granite.disappear(); } + // Within the async, update your new character by adding them to the load list, + // where name is your character name and type is the type of creature it is. + // if (this.settings.animationSource === 'type') { + // this.settings.animationSource = AnimationSourceType.NAME; + // } async loadSettings() { this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData()); if (this.settings.animationSource === "dragon") { @@ -457,4 +478,4 @@ var GranitePlugin = class extends import_obsidian2.Plugin { await this.saveData(this.settings); } }; -//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/main.ts", "src/Setting.ts", "src/Animations.ts", "src/quotes/Quotes.ts", "src/QuoteManager.ts", "src/Granite.ts"],
  "sourcesContent": ["import { debounce, Plugin } from 'obsidian';\nimport { AnimationSourceType, DEFAULT_SETTINGS, GraniteSettings, GraniteSettingsTab } from './Setting';\nimport { Granite } from './Granite';\n\nexport default class GranitePlugin extends Plugin {\n\tsettings: GraniteSettings;\n\tgranite: Granite;\n\n\tasync onload() {\n\t\tconsole.log('granite | load');\n\n\t\tawait this.loadSettings();\n\n\t\tthis.granite = new Granite(this);\n\n\t\tthis.addCommand({\n\t\t\tid: 'show',\n\t\t\tname: 'Show Granite',\n\t\t\tcallback: () => {\n\t\t\t\tthis.granite.appear();\n\t\t\t},\n\t\t});\n\n\t\tthis.addCommand({\n\t\t\tid: 'hide',\n\t\t\tname: 'Hide Granite',\n\t\t\tcallback: () => {\n\t\t\t\tthis.granite.disappear();\n\t\t\t},\n\t\t});\n\n\t\tthis.addCommand({\n\t\t\tid: 'enter-writing-mode',\n\t\t\tname: 'Enter writing mode',\n\t\t\tcallback: () => {\n\t\t\t\tthis.granite.enterWritingMode();\n\t\t\t},\n\t\t});\n\n\t\tthis.addCommand({\n\t\t\tid: 'leave-writing-mode',\n\t\t\tname: 'Leave writing mode',\n\t\t\tcallback: () => {\n\t\t\t\tthis.granite.leaveWritingMode();\n\t\t\t},\n\t\t});\n\n\t\t// This adds a settings tab so the user can configure various aspects of the plugin\n\t\tthis.addSettingTab(new GraniteSettingsTab(this.app, this));\n\n\t\t// debounce editor-change event on workspace\n\t\tthis.registerEvent(\n\t\t\tthis.app.workspace.on(\n\t\t\t\t'editor-change',\n\t\t\t\tdebounce(() => {\n\t\t\t\t\tthis.granite.onEditorChange();\n\t\t\t\t}, 500),\n\t\t\t),\n\t\t);\n\n\t\tthis.app.workspace.onLayoutReady(() => this.granite.appear());\n\t}\n\n\tonunload() {\n\t\tconsole.log('granite | unload');\n\n\t\tthis.granite.disappear();\n\t}\n\n\tasync loadSettings() {\n\t\tthis.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());\n\n\t\t// migrations\n\t\t// @ts-ignore\n\t\tif (this.settings.animationSource === 'dragon') {\n\t\t\tthis.settings.animationSource = AnimationSourceType.DRAKE;\n\t\t}\n\t\t// @ts-ignore\n\t\tif (this.settings.animationSource === 'original') {\n\t\t\tthis.settings.animationSource = AnimationSourceType.GEMMY;\n\t\t}\n\n\t\tawait this.saveSettings();\n\t}\n\n\tasync saveSettings() {\n\t\tawait this.saveData(this.settings);\n\t}\n}\n", "import { App, PluginSettingTab, Setting } from 'obsidian';\nimport GranitePlugin from './main';\n\nexport enum AnimationSourceType {\n\tGEMMY = 'gemmy',\n\tDRAKE = 'drake',\n}\n\nexport interface GraniteSettings {\n\t// Add the animationSource property to the settings interface\n\tanimationSource: AnimationSourceType;\n\t// how often does Granite talk in idle mode, in minutes\n\tidleTalkFrequency: number;\n\t// the number of minutes you must write before Granite appears to mock you\n\twritingModeGracePeriod: number;\n}\n\nexport const DEFAULT_SETTINGS: GraniteSettings = {\n\tanimationSource: AnimationSourceType.GEMMY,\n\tidleTalkFrequency: 1,\n\twritingModeGracePeriod: 1,\n};\n\nexport class GraniteSettingsTab extends PluginSettingTab {\n\tplugin: GranitePlugin;\n\n\tconstructor(app: App, plugin: GranitePlugin) {\n\t\tsuper(app, plugin);\n\t\tthis.plugin = plugin;\n\t}\n\n\tdisplay(): void {\n\t\tconst { containerEl } = this;\n\n\t\tcontainerEl.empty();\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Animation Source')\n\t\t\t.setDesc('Choose the source of Granite animations.')\n\t\t\t.addDropdown(dropdown =>\n\t\t\t\tdropdown\n\t\t\t\t\t.addOption(AnimationSourceType.GEMMY, 'Gemmy')\n\t\t\t\t\t.addOption(AnimationSourceType.DRAKE, 'Drake')\n\t\t\t\t\t.setValue(this.plugin.settings.animationSource)\n\t\t\t\t\t.onChange(async value => {\n\t\t\t\t\t\t// Explicitly cast the value to the correct type\n\t\t\t\t\t\tconst animationSource = value as AnimationSourceType;\n\t\t\t\t\t\tthis.plugin.settings.animationSource = animationSource;\n\n\t\t\t\t\t\t// Show Granite with the new animations after changing the source\n\t\t\t\t\t\tthis.plugin.granite.reset();\n\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t}),\n\t\t\t);\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Idle talk frequency')\n\t\t\t.setDesc('How often does Granite speak when idle, in minutes.')\n\t\t\t.addSlider(slider =>\n\t\t\t\tslider\n\t\t\t\t\t.setLimits(5, 60, 5)\n\t\t\t\t\t.setValue(this.plugin.settings.idleTalkFrequency)\n\t\t\t\t\t.setDynamicTooltip()\n\t\t\t\t\t.onChange(async value => {\n\t\t\t\t\t\tthis.plugin.settings.idleTalkFrequency = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t}),\n\t\t\t);\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Writing mode grace period')\n\t\t\t.setDesc('How soon Granite starts to get disappointed after you stop tying in writing mode, in seconds.')\n\t\t\t.addSlider(slider =>\n\t\t\t\tslider\n\t\t\t\t\t.setLimits(5, 180, 5)\n\t\t\t\t\t.setDynamicTooltip()\n\t\t\t\t\t.setValue(this.plugin.settings.writingModeGracePeriod)\n\t\t\t\t\t.onChange(async value => {\n\t\t\t\t\t\tthis.plugin.settings.writingModeGracePeriod = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t}),\n\t\t\t);\n\t}\n}\n", "import GranitePlugin from './main';\nimport { AnimationSourceType } from './Setting';\n\n// Original Animations\nimport EMERGE_MOTION_GEMMY from '../animations/gemmy/gemmy_emerge.gif';\nimport POP_MOTION_GEMMY from '../animations/gemmy/gemmy_pop.gif';\nimport DISAPPEAR_MOTION_GEMMY from '../animations/gemmy/gemmy_disappear.gif';\nimport ANGRY_MOTION_GEMMY from '../animations/gemmy/gemmy_angry.gif';\nimport LOOK_MOTION_GEMMY from '../animations/gemmy/gemmy_lookAround.gif';\nimport IDLE_MOTION_GEMMY from '../animations/gemmy/gemmy_idle.gif';\nimport DISAPPOINT_IMG_GEMMY from '../animations/gemmy/gemmy_disappoint.gif';\n\n// Draconic Animations\nimport EMERGE_MOTION_DRAKE from '../animations/drake/drake_emerge.gif';\nimport POP_MOTION_DRAKE from '../animations/drake/drake_pop.gif';\nimport DISAPPEAR_MOTION_DRAKE from '../animations/drake/drake_disappear.gif';\nimport ANGRY_MOTION_DRAKE from '../animations/drake/drake_angry.gif';\nimport LOOK_MOTION_DRAKE from '../animations/drake/drake_lookAround.gif';\nimport IDLE_MOTION_DRAKE from '../animations/drake/drake_idle.gif';\nimport DISAPPOINT_IMG_DRAKE from '../animations/drake/drake_disappoint.gif';\n\nexport enum AnimationType {\n\tEMERGE = 'emerge',\n\tPOP_MOTION = 'pop_motion',\n\tDISAPPEAR_MOTION = 'disappear_motion',\n\tANGRY_MOTION = 'angry_motion',\n\tLOOK_MOTION = 'look_motion',\n\tIDLE_MOTION = 'idle_motion',\n\tDISAPPOINT_IMG = 'disappoint_ing',\n}\n\nexport class Animations {\n\tpublic readonly plugin: GranitePlugin;\n\n\t// the mappings from an animation type to an actual image file for the drakeling\n\tpublic readonly drakeAnimationMap: Record<AnimationType, string>;\n\t// the mappings from an animation type to an actual image file for the granite\n\tpublic readonly gemmyAnimationMap: Record<AnimationType, string>;\n\n\t// maps an animation source to the corresponding animation map\n\tpublic readonly animationSourceMap: Record<AnimationSourceType, Record<AnimationType, string>>;\n\n\tconstructor(plugin: GranitePlugin) {\n\t\tthis.plugin = plugin;\n\n\t\tthis.drakeAnimationMap = {\n\t\t\t[AnimationType.EMERGE]: EMERGE_MOTION_DRAKE,\n\t\t\t[AnimationType.POP_MOTION]: POP_MOTION_DRAKE,\n\t\t\t[AnimationType.DISAPPEAR_MOTION]: DISAPPEAR_MOTION_DRAKE,\n\t\t\t[AnimationType.ANGRY_MOTION]: ANGRY_MOTION_DRAKE,\n\t\t\t[AnimationType.LOOK_MOTION]: LOOK_MOTION_DRAKE,\n\t\t\t[AnimationType.IDLE_MOTION]: IDLE_MOTION_DRAKE,\n\t\t\t[AnimationType.DISAPPOINT_IMG]: DISAPPOINT_IMG_DRAKE,\n\t\t};\n\n\t\tthis.gemmyAnimationMap = {\n\t\t\t[AnimationType.EMERGE]: EMERGE_MOTION_GEMMY,\n\t\t\t[AnimationType.POP_MOTION]: POP_MOTION_GEMMY,\n\t\t\t[AnimationType.DISAPPEAR_MOTION]: DISAPPEAR_MOTION_GEMMY,\n\t\t\t[AnimationType.ANGRY_MOTION]: ANGRY_MOTION_GEMMY,\n\t\t\t[AnimationType.LOOK_MOTION]: LOOK_MOTION_GEMMY,\n\t\t\t[AnimationType.IDLE_MOTION]: IDLE_MOTION_GEMMY,\n\t\t\t[AnimationType.DISAPPOINT_IMG]: DISAPPOINT_IMG_GEMMY,\n\t\t};\n\n\t\tthis.animationSourceMap = {\n\t\t\t[AnimationSourceType.DRAKE]: this.drakeAnimationMap,\n\t\t\t[AnimationSourceType.GEMMY]: this.gemmyAnimationMap,\n\t\t};\n\n\t\tconsole.log('granite | build animation map', this.animationSourceMap);\n\t}\n\n\t/**\n\t * Plays a granite animation in the currently selected animation source type inside an element.\n\t *\n\t * @param el the element to play the animation in\n\t * @param animation the animation to play\n\t */\n\tpublic play(el: HTMLElement, animation: AnimationType): void {\n\t\tconst animationFile = this.animationSourceMap[this.plugin.settings.animationSource][animation];\n\n\t\tel.setAttribute('src', animationFile);\n\t}\n}\n", "export interface Quotes {\n\t// general quotes can appear both in normal and in writing mode\n\tgeneral: string[];\n\t// idle quotes can only appear in normal mode\n\tidle: string[];\n\t// writing mode quotes can only appear in writing mode\n\twritingMode: string[];\n}\n\n// these quotes can appear in every animation mode\nexport const GRANITE_BASE_QUOTES: Quotes = {\n\tgeneral: [\n\n\t],\n\tidle: [\n\t\t\"You can't arrest us! We already ate the evidence!\",\n\t\t\"Don't ever split the party!\",\n\t\t'If you kill a hive mind, is that murder or genocide?',\n\t\t'Roll initiative!',\n\t\t'You can try!',\n\t\t\"I'm not short, I'm concentrated awesome.\",\n\t\t\"I'm not greedy, I'm just allergic to poverty.\",\n\t\t\"I don't always cast spells, but when I do, it's fireball.\",\n\t\t\"I don't need luck, I have a high charisma stat.\",\n\t\t\"I don't always drink ale, but when I do, it's with my fellow adventurers after slaying a dragon.\",\n\t\t\"I don't always roll a critical hit, but when I do, the DM forgets to make me reroll the damage.\",\n\t\t'I may be chaotic neutral on paper, but in reality, I just like to watch the world burn.',\n\t\t'It\u2019s not stealing if it belongs to a dead guy.',\n\t\t'Who needs an army when you have a bag of holding full of rocks?',\n\t\t'Let me show you how to wear a snake.',\n\t\t'WHY WOULD YOU DO THAT!',\n\t\t'That dice needs to be retired!',\n\t\t\"I don't kill without reason. Fortunately, I'm bored. Reason enough!\",\n\t\t'Ah, my favoured enemy. Something alive.',\n\t\t\"I slap the barrel with my member!... the 'barrel' open's its mouth!\",\n\t\t\"I'm not deprived, I'm depraved.\",\n\t\t'You need a free hand to attempt a grapple',\n\t\t`Careful how much you carry; the GM might actually ask you to calculate your inventory weight!`,\n\t\t`Don't do that! Then we'll have to go look up the grapple rules!`,\n\t\t`50 page backstory... NOPE`,\n\t\t`It's astounding anyone can understand you, with all those Nat 1 Charisma rolls.`,\n\t\t`The cheddar monks are here to save the day!`,\n\t\t`You've been Gygaxed.`,\n\t\t`STEP AWAY FROM THE PURCHASE MORE DICE BUTTON`,\n\t\t`After thousands of years, I have attained my current state, while you struggle to complete this simple note.`,\n\t\t`You are a background character in your own life.`,\n\t],\n\twritingMode: [\n\t\t`Player's dont take notes... maybe you should try that?`,\n\t\t`Is that the best you can do? Keep writing!`,\n\t\t`Write first, editor later.`,\n\t\t`AI could probably write a better note...`,\n\t\t`I love hearing your keyboard. Don't stop.`,\n\t\t`How about we review some old notes today?`,\n\t\t`Why not just use a template?`,\n\t\t`Doesn't matter how much you plan... they will derail anyway!`,\n\t\t`Maybe it's time to go get some water or coffee.`,\n\t\t`That's not how rivers are in real-life...`,\n\t\t`Anything is better than a blank page, even me. Write something!`,\n\t\t`Have you given out Inspiration recently?`,\n\t\t`Call me Jeeves. I. Dare. You.`,\n\t\t`I cast 'Summon Bigger Fish`,\n\t\t`Do you touch it?`,\n\t\t`What would Matt Mercer do?`,\n\t\t`To continue, please insert more credits`,\n\t\t`Have you considered just... Not?`,\n\t],\n}\n\nexport const GEMMY_EXCLUSIVE_QUOTES: Quotes = {\n\tgeneral: [],\n\tidle: [],\n\twritingMode: [],\n}\n\nexport const DRAKE_EXCLUSIVE_QUOTES: Quotes = {\n\tgeneral: [],\n\tidle: [],\n\twritingMode: [],\n}\n", "import GranitePlugin from './main';\nimport { AnimationSourceType } from './Setting';\nimport { GraniteMode, GraniteState } from './Granite';\nimport { DRAKE_EXCLUSIVE_QUOTES, GEMMY_EXCLUSIVE_QUOTES, GRANITE_BASE_QUOTES, Quotes } from './quotes/Quotes';\n\nexport class QuoteManager {\n\tpublic readonly plugin: GranitePlugin;\n\t\n\tpublic readonly quoteMap: Record<AnimationSourceType, Record<GraniteMode, string[]>>;\n\t\n\tconstructor(plugin: GranitePlugin) {\n\t\tthis.plugin = plugin;\n\n\t\tthis.quoteMap = {\n\t\t\t[AnimationSourceType.GEMMY]: {\n\t\t\t\t[GraniteMode.IDLE]: this.getIdleQuotes(GEMMY_EXCLUSIVE_QUOTES),\n\t\t\t\t[GraniteMode.WRITING]: this.getWritingQuotes(GEMMY_EXCLUSIVE_QUOTES),\n\t\t\t},\n\t\t\t[AnimationSourceType.DRAKE]: {\n\t\t\t\t[GraniteMode.IDLE]: this.getIdleQuotes(DRAKE_EXCLUSIVE_QUOTES),\n\t\t\t\t[GraniteMode.WRITING]: this.getWritingQuotes(DRAKE_EXCLUSIVE_QUOTES),\n\t\t\t}\n\t\t};\n\n\t\tconsole.log('granite | build quote map', this.quoteMap);\n\t}\n\n\tprivate getIdleQuotes(exclusiveQuotes: Quotes): string[] {\n\t\treturn [...GRANITE_BASE_QUOTES.general, ...GRANITE_BASE_QUOTES.idle, ...exclusiveQuotes.general, ...exclusiveQuotes.idle];\n\t}\n\n\tprivate getWritingQuotes(exclusiveQuotes: Quotes): string[] {\n\t\treturn [...GRANITE_BASE_QUOTES.general, ...GRANITE_BASE_QUOTES.writingMode, ...exclusiveQuotes.general, ...exclusiveQuotes.writingMode];\n\t}\n\t\n\tpublic getQuote(): string {\n\t\tconst quotes: string[] = this.quoteMap[this.plugin.settings.animationSource][this.plugin.granite.mode];\n\n\t\treturn quotes[Math.floor(Math.random() * quotes.length)];\n\t}\n}\n", "import { Animations, AnimationType } from './Animations';\nimport GranitePlugin from './main';\nimport { QuoteManager } from './QuoteManager';\n\nconst BUBBLE_DURATION: number = 5000;\n\nexport enum GraniteMode {\n\tIDLE = 'IDLE',\n\tWRITING = 'WRITING',\n}\n\nexport enum GraniteState {\n\tVISIBLE = 'VISIBLE',\n\tINVISIBLE = 'INVISIBLE',\n\tDISAPPEARING = 'DISAPPEARING',\n\tAPPEARING = 'APPEARING',\n}\n\nexport class Granite {\n\tpublic readonly plugin: GranitePlugin;\n\tprivate readonly animations: Animations;\n\tprivate readonly quotes: QuoteManager;\n\n\tgraniteEl: HTMLElement;\n\timageEl: HTMLElement;\n\n\tstate: GraniteState;\n\tmode: GraniteMode;\n\n\tidleTimeout: number;\n\twritingModeTimeout: number;\n\n\tconstructor(plugin: GranitePlugin) {\n\t\tthis.plugin = plugin;\n\n\t\tthis.animations = new Animations(this.plugin);\n\t\tthis.quotes = new QuoteManager(this.plugin);\n\n\t\tthis.state = GraniteState.INVISIBLE;\n\t\tthis.mode = GraniteMode.IDLE;\n\n\t\tthis.createGraniteEl();\n\n\t\tthis.startNextIdleTimeout();\n\t}\n\n\tcreateGraniteEl() {\n\t\tthis.graniteEl = createDiv('granite-container');\n\t\tthis.graniteEl.setAttribute('aria-label-position', 'top');\n\t\tthis.graniteEl.setAttribute('aria-label-delay', '0');\n\t\tthis.graniteEl.setAttribute('aria-label-classes', 'granite-tooltip');\n\n\t\tthis.imageEl = this.graniteEl.createEl('img', {});\n\n\t\tthis.graniteEl.addEventListener('mouseenter', () => {\n\t\t\t// ignore mouse events in writing mode\n\t\t\tif (this.mode === GraniteMode.WRITING) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tthis.saySomething(true);\n\t\t\tthis.idleTimeout && clearTimeout(this.idleTimeout);\n\t\t});\n\n\t\tthis.graniteEl.addEventListener('mouseleave', () => {\n\t\t\t// ignore mouse events in writing mode\n\t\t\tif (this.mode === GraniteMode.WRITING) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tthis.animations.play(this.imageEl, AnimationType.IDLE_MOTION);\n\t\t\tthis.startNextIdleTimeout();\n\t\t});\n\n\t\tthis.graniteEl.hidden = true;\n\t\tdocument.body.appendChild(this.graniteEl);\n\t}\n\n\tasync appear(): Promise<void> {\n\t\tif (this.state === GraniteState.APPEARING || this.state === GraniteState.VISIBLE) {\n\t\t\treturn;\n\t\t}\n\n\t\t// show him\n\t\tthis.state = GraniteState.APPEARING;\n\t\tthis.graniteEl.hidden = false;\n\n\t\t// Quicker if we're in writing mode\n\t\tif (this.mode === GraniteMode.WRITING) {\n\t\t\tthis.animations.play(this.imageEl, AnimationType.POP_MOTION);\n\n\t\t\tawait sleep(1800);\n\n\t\t\t// another animation overrode this animation, so we quit\n\t\t\tif (this.state !== GraniteState.APPEARING) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tthis.state = GraniteState.VISIBLE;\n\t\t\tthis.saySomething(true);\n\t\t} else {\n\t\t\tthis.animations.play(this.imageEl, AnimationType.EMERGE);\n\n\t\t\tawait sleep(3800);\n\n\t\t\t// another animation overrode this animation, so we quit\n\t\t\tif (this.state !== GraniteState.APPEARING) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tthis.state = GraniteState.VISIBLE;\n\t\t\tthis.animations.play(this.imageEl, AnimationType.IDLE_MOTION);\n\t\t}\n\t}\n\n\tasync disappear(): Promise<void> {\n\t\t// don't make granite disappear while they are already leaving\n\t\tif (this.state === GraniteState.DISAPPEARING || this.state === GraniteState.INVISIBLE) {\n\t\t\treturn;\n\t\t}\n\n\t\tthis.state = GraniteState.DISAPPEARING;\n\n\t\tif (this.idleTimeout) window.clearTimeout(this.idleTimeout);\n\t\tif (this.writingModeTimeout) window.clearTimeout(this.writingModeTimeout);\n\n\t\tthis.animations.play(this.imageEl, AnimationType.DISAPPEAR_MOTION);\n\t\t// remote tooltip\n\t\tthis.graniteEl.dispatchEvent(new MouseEvent('mouseout', { bubbles: true, clientX: 10, clientY: 10 }));\n\n\t\tawait sleep(1300);\n\n\t\t// another animation overrode this animation, so we quit\n\t\tif (this.state !== GraniteState.DISAPPEARING) {\n\t\t\treturn;\n\t\t}\n\n\t\tthis.state = GraniteState.INVISIBLE;\n\t\tthis.graniteEl.hidden = true;\n\t}\n\n\tasync reset(): Promise<void> {\n\t\tif (this.state === GraniteState.DISAPPEARING || this.state === GraniteState.INVISIBLE) {\n\t\t\tawait this.appear();\n\t\t}\n\n\t\tthis.animations.play(this.imageEl, AnimationType.IDLE_MOTION);\n\t}\n\n\tonEditorChange(): void {\n\t\tif (this.mode === GraniteMode.IDLE) {\n\t\t\treturn;\n\t\t}\n\n\t\tif (this.state !== GraniteState.DISAPPEARING && this.state !== GraniteState.INVISIBLE) {\n\t\t\tthis.disappear();\n\t\t}\n\t\tthis.setWritingModeTimeout();\n\t}\n\n\tenterWritingMode(): void {\n\t\tthis.mode = GraniteMode.WRITING;\n\t\tthis.disappear();\n\n\t\tthis.setWritingModeTimeout();\n\t}\n\n\tleaveWritingMode() {\n\t\tthis.mode = GraniteMode.IDLE;\n\t\tthis.reset();\n\n\t\twindow.clearTimeout(this.writingModeTimeout);\n\t}\n\n\tsetWritingModeTimeout(): void {\n\t\tif (this.writingModeTimeout) {\n\t\t\twindow.clearTimeout(this.writingModeTimeout);\n\t\t}\n\n\t\tthis.writingModeTimeout = window.setTimeout(() => {\n\t\t\tif (this.mode === GraniteMode.WRITING) {\n\t\t\t\tthis.appear();\n\t\t\t}\n\t\t}, this.plugin.settings.writingModeGracePeriod * 1000);\n\t}\n\n\tstartNextIdleTimeout(): void {\n\t\t// if the set time is 5 minutes, this will set timeout to be a random time between 4-6 minutes\n\t\t// the range will be 80% - 120%\n\t\tconst randomFactor = 0.8 + 0.4 * Math.random();\n\t\tconst randomizedTimeout = randomFactor * this.plugin.settings.idleTalkFrequency * 60000;\n\n\t\tif (this.idleTimeout) {\n\t\t\twindow.clearTimeout(this.idleTimeout);\n\t\t}\n\n\t\tthis.idleTimeout = window.setTimeout(() => {\n\t\t\tif (this.mode === GraniteMode.WRITING) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tthis.saySomething(false);\n\t\t\tthis.startNextIdleTimeout();\n\t\t}, randomizedTimeout);\n\t}\n\n\tasync saySomething(persistent: boolean): Promise<void> {\n\t\tif (this.state !== GraniteState.VISIBLE) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst quote: string = this.quotes.getQuote();\n\n\t\tthis.graniteEl.setAttr('aria-label', quote);\n\t\tthis.graniteEl.setAttr('aria-label-position', 'top');\n\t\tthis.graniteEl.dispatchEvent(new MouseEvent('mouseover', { bubbles: true, clientX: 10, clientY: 10 }));\n\n\t\tif (this.mode === GraniteMode.WRITING) {\n\t\t\tthis.animations.play(this.imageEl, AnimationType.ANGRY_MOTION);\n\n\t\t\tawait sleep(1000);\n\n\t\t\tthis.animations.play(this.imageEl, AnimationType.DISAPPOINT_IMG);\n\t\t} else {\n\t\t\tthis.animations.play(this.imageEl, AnimationType.LOOK_MOTION);\n\t\t}\n\n\t\tif (!persistent) {\n\t\t\tawait sleep(BUBBLE_DURATION);\n\n\t\t\tthis.graniteEl.dispatchEvent(new MouseEvent('mouseout', { bubbles: true, clientX: 10, clientY: 10 }));\n\t\t\tthis.animations.play(this.imageEl, AnimationType.IDLE_MOTION);\n\t\t}\n\t}\n}\n"],
  "mappings": "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",
  "names": ["import_obsidian"]
}
 +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/main.ts", "src/Setting.ts", "src/Animations.ts", "src/quotes/Quotes.ts", "src/QuoteManager.ts", "src/Granite.ts"],
  "sourcesContent": ["import { debounce, Plugin } from 'obsidian';\nimport { AnimationSourceType, DEFAULT_SETTINGS, GraniteSettings, GraniteSettingsTab } from './Setting';\nimport { Granite } from './Granite';\n\nexport default class GranitePlugin extends Plugin {\n\tsettings: GraniteSettings;\n\tgranite: Granite;\n\n\tasync onload() {\n\t\tconsole.log('granite | load');\n\n\t\tawait this.loadSettings();\n\n\t\tthis.granite = new Granite(this);\n\n\t\tthis.addCommand({\n\t\t\tid: 'show',\n\t\t\tname: 'Show Granite',\n\t\t\tcallback: () => {\n\t\t\t\tthis.granite.appear();\n\t\t\t},\n\t\t});\n\n\t\tthis.addCommand({\n\t\t\tid: 'hide',\n\t\t\tname: 'Hide Granite',\n\t\t\tcallback: () => {\n\t\t\t\tthis.granite.disappear();\n\t\t\t},\n\t\t});\n\n\t\tthis.addCommand({\n\t\t\tid: 'enter-writing-mode',\n\t\t\tname: 'Enter writing mode',\n\t\t\tcallback: () => {\n\t\t\t\tthis.granite.enterWritingMode();\n\t\t\t},\n\t\t});\n\n\t\tthis.addCommand({\n\t\t\tid: 'leave-writing-mode',\n\t\t\tname: 'Leave writing mode',\n\t\t\tcallback: () => {\n\t\t\t\tthis.granite.leaveWritingMode();\n\t\t\t},\n\t\t});\n\n\t\t// This adds a settings tab so the user can configure various aspects of the plugin\n\t\tthis.addSettingTab(new GraniteSettingsTab(this.app, this));\n\n\t\t// debounce editor-change event on workspace\n\t\tthis.registerEvent(\n\t\t\tthis.app.workspace.on(\n\t\t\t\t'editor-change',\n\t\t\t\tdebounce(() => {\n\t\t\t\t\tthis.granite.onEditorChange();\n\t\t\t\t}, 500),\n\t\t\t),\n\t\t);\n\n\t\tthis.app.workspace.onLayoutReady(() => this.granite.appear());\n\t}\n\n\tonunload() {\n\t\tconsole.log('granite | unload');\n\n\t\tthis.granite.disappear();\n\t}\n\n\t// Within the async, update your new character by adding them to the load list,\n\t// where name is your character name and type is the type of creature it is.\n\t// \t\tif (this.settings.animationSource === 'type') {\n\t// \t\t\tthis.settings.animationSource = AnimationSourceType.NAME;\n\t// \t\t}\n\n\tasync loadSettings() {\n\t\tthis.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());\n\n\t\t// migrations\n\t\t// @ts-ignore\n\t\tif (this.settings.animationSource === 'dragon') {\n\t\t\tthis.settings.animationSource = AnimationSourceType.DRAKE;\n\t\t}\n\t\t// @ts-ignore\n\t\tif (this.settings.animationSource === 'original') {\n\t\t\tthis.settings.animationSource = AnimationSourceType.GEMMY;\n\t\t}\n\n\t\tawait this.saveSettings();\n\t}\n\n\tasync saveSettings() {\n\t\tawait this.saveData(this.settings);\n\t}\n}\n", "import { App, PluginSettingTab, Setting } from 'obsidian';\nimport GranitePlugin from './main';\n\nexport enum AnimationSourceType {\n\tGEMMY = 'gemmy',\n\tDRAKE = 'drake',\n\t// When you need to add a new character, add the following above:\n\t// NAME = 'name',\n}\n\nexport interface GraniteSettings {\n\t// Add the animationSource property to the settings interface\n\tanimationSource: AnimationSourceType;\n\t// how often does Granite talk in idle mode, in minutes\n\tidleTalkFrequency: number;\n\t// the number of minutes you must write before Granite appears to mock you\n\twritingModeGracePeriod: number;\n}\n\nexport const DEFAULT_SETTINGS: GraniteSettings = {\n\tanimationSource: AnimationSourceType.GEMMY,\n\tidleTalkFrequency: 1,\n\twritingModeGracePeriod: 1,\n};\n\nexport class GraniteSettingsTab extends PluginSettingTab {\n\tplugin: GranitePlugin;\n\n\tconstructor(app: App, plugin: GranitePlugin) {\n\t\tsuper(app, plugin);\n\t\tthis.plugin = plugin;\n\t}\n\n\tdisplay(): void {\n\t\tconst { containerEl } = this;\n\n\t\tcontainerEl.empty();\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Animation Source')\n\t\t\t.setDesc('Choose the source of Granite animations.')\n\t\t\t.addDropdown(dropdown =>\n\t\t\t\tdropdown\n\t\t\t\t\t.addOption(AnimationSourceType.GEMMY, 'Gemmy')\n\t\t\t\t\t.addOption(AnimationSourceType.DRAKE, 'Drake')\n\t\t\t\t\t// When you need to add a new character, copy and paste the following line above this one, and change the NAME\n\t\t\t\t\t// .addOption(AnimationSourceType.NAME, 'Name')\n\t\t\t\t\t.setValue(this.plugin.settings.animationSource)\n\t\t\t\t\t.onChange(async value => {\n\t\t\t\t\t\t// Explicitly cast the value to the correct type\n\t\t\t\t\t\tconst animationSource = value as AnimationSourceType;\n\t\t\t\t\t\tthis.plugin.settings.animationSource = animationSource;\n\n\t\t\t\t\t\t// Show Granite with the new animations after changing the source\n\t\t\t\t\t\tthis.plugin.granite.reset();\n\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t}),\n\t\t\t);\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Idle talk frequency')\n\t\t\t.setDesc('How often does Granite speak when idle, in minutes.')\n\t\t\t.addSlider(slider =>\n\t\t\t\tslider\n\t\t\t\t\t.setLimits(5, 60, 5)\n\t\t\t\t\t.setValue(this.plugin.settings.idleTalkFrequency)\n\t\t\t\t\t.setDynamicTooltip()\n\t\t\t\t\t.onChange(async value => {\n\t\t\t\t\t\tthis.plugin.settings.idleTalkFrequency = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t}),\n\t\t\t);\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Writing mode grace period')\n\t\t\t.setDesc('How soon Granite starts to get disappointed after you stop tying in writing mode, in seconds.')\n\t\t\t.addSlider(slider =>\n\t\t\t\tslider\n\t\t\t\t\t.setLimits(5, 180, 5)\n\t\t\t\t\t.setDynamicTooltip()\n\t\t\t\t\t.setValue(this.plugin.settings.writingModeGracePeriod)\n\t\t\t\t\t.onChange(async value => {\n\t\t\t\t\t\tthis.plugin.settings.writingModeGracePeriod = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t}),\n\t\t\t);\n\t}\n}\n", "import GranitePlugin from './main';\nimport { AnimationSourceType } from './Setting';\n\n// Original Animations\nimport EMERGE_MOTION_GEMMY from '../animations/gemmy/gemmy_emerge.gif';\nimport POP_MOTION_GEMMY from '../animations/gemmy/gemmy_pop.gif';\nimport DISAPPEAR_MOTION_GEMMY from '../animations/gemmy/gemmy_disappear.gif';\nimport ANGRY_MOTION_GEMMY from '../animations/gemmy/gemmy_angry.gif';\nimport LOOK_MOTION_GEMMY from '../animations/gemmy/gemmy_lookAround.gif';\nimport IDLE_MOTION_GEMMY from '../animations/gemmy/gemmy_idle.gif';\nimport DISAPPOINT_IMG_GEMMY from '../animations/gemmy/gemmy_disappoint.gif';\n\n// Draconic Animations\nimport EMERGE_MOTION_DRAKE from '../animations/drake/drake_emerge.gif';\nimport POP_MOTION_DRAKE from '../animations/drake/drake_pop.gif';\nimport DISAPPEAR_MOTION_DRAKE from '../animations/drake/drake_disappear.gif';\nimport ANGRY_MOTION_DRAKE from '../animations/drake/drake_angry.gif';\nimport LOOK_MOTION_DRAKE from '../animations/drake/drake_lookAround.gif';\nimport IDLE_MOTION_DRAKE from '../animations/drake/drake_idle.gif';\nimport DISAPPOINT_IMG_DRAKE from '../animations/drake/drake_disappoint.gif';\n\n// Importing a new character? Copy the below and change the NAME with your character name.\n//\n// Name Animations\n// import EMERGE_MOTION_NAME from '../animations/name/name_emerge.gif';\n// import POP_MOTION_NAME from '../animations/name/name_pop.gif';\n// import DISAPPEAR_MOTION_NAME from '../animations/name/name_disappear.gif';\n// import ANGRY_MOTION_NAME from '../animations/name/name_angry.gif';\n// import LOOK_MOTION_NAME from '../animations/name/name_lookAround.gif';\n// import IDLE_MOTION_NAME from '../animations/name/name_idle.gif';\n// import DISAPPOINT_IMG_NAME from '../animations/name/name_disappoint.gif';\n\nexport enum AnimationType {\n\tEMERGE = 'emerge',\n\tPOP_MOTION = 'pop_motion',\n\tDISAPPEAR_MOTION = 'disappear_motion',\n\tANGRY_MOTION = 'angry_motion',\n\tLOOK_MOTION = 'look_motion',\n\tIDLE_MOTION = 'idle_motion',\n\tDISAPPOINT_IMG = 'disappoint_ing',\n}\n\nexport class Animations {\n\tpublic readonly plugin: GranitePlugin;\n\n\t// Copy and paste this below, where name is your new character name.\n\t// the mappings from an animation type to an actual image file for the name\n\t// public readonly nameAnimationMap: Record<AnimationType, string>;\n\n\t// the mappings from an animation type to an actual image file for the drakeling\n\tpublic readonly drakeAnimationMap: Record<AnimationType, string>;\n\t// the mappings from an animation type to an actual image file for the granite\n\tpublic readonly gemmyAnimationMap: Record<AnimationType, string>;\n\n\t// maps an animation source to the corresponding animation map\n\tpublic readonly animationSourceMap: Record<AnimationSourceType, Record<AnimationType, string>>;\n\n\tconstructor(plugin: GranitePlugin) {\n\t\tthis.plugin = plugin;\n\n\t\t// Add your character to the animation map.\n\t\t// Replace name with your new character's name.\n\t\t//\n\t\t// \t\tthis.nameAnimationMap = {\n\t\t// \t\t\t[AnimationType.EMERGE]: EMERGE_MOTION_NAME,\n\t\t// \t\t\t[AnimationType.POP_MOTION]: POP_MOTION_NAME,\n\t\t// \t\t\t[AnimationType.DISAPPEAR_MOTION]: DISAPPEAR_MOTION_NAME,\n\t\t// \t\t\t[AnimationType.ANGRY_MOTION]: ANGRY_MOTION_NAME,\n\t\t// \t\t\t[AnimationType.LOOK_MOTION]: LOOK_MOTION_NAME,\n\t\t// \t\t\t[AnimationType.IDLE_MOTION]: IDLE_MOTION_NAME,\n\t\t// \t\t\t[AnimationType.DISAPPOINT_IMG]: DISAPPOINT_IMG_NAME,\n\t\t// \t\t};\n\n\t\tthis.drakeAnimationMap = {\n\t\t\t[AnimationType.EMERGE]: EMERGE_MOTION_DRAKE,\n\t\t\t[AnimationType.POP_MOTION]: POP_MOTION_DRAKE,\n\t\t\t[AnimationType.DISAPPEAR_MOTION]: DISAPPEAR_MOTION_DRAKE,\n\t\t\t[AnimationType.ANGRY_MOTION]: ANGRY_MOTION_DRAKE,\n\t\t\t[AnimationType.LOOK_MOTION]: LOOK_MOTION_DRAKE,\n\t\t\t[AnimationType.IDLE_MOTION]: IDLE_MOTION_DRAKE,\n\t\t\t[AnimationType.DISAPPOINT_IMG]: DISAPPOINT_IMG_DRAKE,\n\t\t};\n\n\t\tthis.gemmyAnimationMap = {\n\t\t\t[AnimationType.EMERGE]: EMERGE_MOTION_GEMMY,\n\t\t\t[AnimationType.POP_MOTION]: POP_MOTION_GEMMY,\n\t\t\t[AnimationType.DISAPPEAR_MOTION]: DISAPPEAR_MOTION_GEMMY,\n\t\t\t[AnimationType.ANGRY_MOTION]: ANGRY_MOTION_GEMMY,\n\t\t\t[AnimationType.LOOK_MOTION]: LOOK_MOTION_GEMMY,\n\t\t\t[AnimationType.IDLE_MOTION]: IDLE_MOTION_GEMMY,\n\t\t\t[AnimationType.DISAPPOINT_IMG]: DISAPPOINT_IMG_GEMMY,\n\t\t};\n\n\t\tthis.animationSourceMap = {\n\t\t\t// Add your character to the animation source map, where name is your character name.\n\t\t\t// [AnimationSourceType.NAME]: this.nameAnimationMap,\n\t\t\t[AnimationSourceType.DRAKE]: this.drakeAnimationMap,\n\t\t\t[AnimationSourceType.GEMMY]: this.gemmyAnimationMap,\n\t\t};\n\n\t\tconsole.log('granite | build animation map', this.animationSourceMap);\n\t}\n\n\t/**\n\t * Plays a granite animation in the currently selected animation source type inside an element.\n\t *\n\t * @param el the element to play the animation in\n\t * @param animation the animation to play\n\t */\n\tpublic play(el: HTMLElement, animation: AnimationType): void {\n\t\tconst animationFile = this.animationSourceMap[this.plugin.settings.animationSource][animation];\n\n\t\tel.setAttribute('src', animationFile);\n\t}\n}\n", "export interface Quotes {\n\t// general quotes can appear both in normal and in writing mode\n\tgeneral: string[];\n\t// idle quotes can only appear in normal mode\n\tidle: string[];\n\t// writing mode quotes can only appear in writing mode\n\twritingMode: string[];\n}\n\n// these quotes can appear in every animation mode\nexport const GRANITE_BASE_QUOTES: Quotes = {\n\tgeneral: [],\n\tidle: [\n\t\t\"You can't arrest us! We already ate the evidence!\",\n\t\t\"Don't ever split the party!\",\n\t\t\"If you kill a hive mind, is that murder or genocide?\",\n\t\t\"Roll initiative!\",\n\t\t\"You can try!\",\n\t\t\"I'm not short, I'm concentrated awesome.\",\n\t\t\"I'm not greedy, I'm just allergic to poverty.\",\n\t\t\"I don't always cast spells, but when I do, it's fireball.\",\n\t\t\"I don't need luck, I have a high charisma stat.\",\n\t\t\"I don't always drink ale, but when I do, it's with my fellow adventurers after slaying a dragon.\",\n\t\t\"I don't always roll a critical hit, but when I do, the DM forgets to make me reroll the damage.\",\n\t\t\"I may be chaotic neutral on paper, but in reality, I just like to watch the world burn.\",\n\t\t\"It\u2019s not stealing if it belongs to a dead guy.\",\n\t\t\"Who needs an army when you have a bag of holding full of rocks?\",\n\t\t\"Let me show you how to wear a snake.\",\n\t\t\"WHY WOULD YOU DO THAT!\",\n\t\t\"That dice needs to be retired!\",\n\t\t\"I don't kill without reason. Fortunately, I'm bored. Reason enough!\",\n\t\t\"Ah, my favoured enemy. Something alive.\",\n\t\t\"I slap the barrel with my member!... the 'barrel' open's its mouth!\",\n\t\t\"I'm not deprived, I'm depraved.\",\n\t\t\"You need a free hand to attempt a grapple\",\n\t\t\"Careful how much you carry; the GM might actually ask you to calculate your inventory weight!\",\n\t\t\"Don't do that! Then we'll have to go look up the grapple rules!\",\n\t\t\"50 page backstory... NOPE\",\n\t\t\"It's astounding anyone can understand you, with all those Nat 1 Charisma rolls.\",\n\t\t\"The cheddar monks are here to save the day!\",\n\t\t\"You've been Gygaxed.\",\n\t\t\"STEP AWAY FROM THE PURCHASE MORE DICE BUTTON\",\n\t\t\"After thousands of years, I have attained my current state, while you struggle to complete this simple note.\",\n\t\t\"You are a background character in your own life.\",\n\t\t\"What... sorry Who is the Bard doing now?\",\n\t\t\"DO NOT put the portable hole in the bag of holding!\",\n\t\t\"DO NOT put the bag of holding in the portable hole!\",\n\t\t\"If the shed's a'Rocking... RUN\",\n\t],\n\twritingMode: [\n\t\t\"Player's dont take notes... maybe you should try that?\",\n\t\t\"Is that the best you can do? Keep writing!\",\n\t\t\"Write first, editor later.\",\n\t\t\"AI could probably write a better note...\",\n\t\t\"I love hearing your keyboard. Don't stop.\",\n\t\t\"How about we review some old notes today?\",\n\t\t\"Why not just use a template?\",\n\t\t\"Doesn't matter how much you plan... they will derail anyway!\",\n\t\t\"Maybe it's time to go get some water or coffee.\",\n\t\t\"That's not how rivers are in real-life...\",\n\t\t\"Anything is better than a blank page, even me. Write something!\",\n\t\t\"Have you given out Inspiration recently?\",\n\t\t\"Call me Jeeves. I. Dare. You.\",\n\t\t\"I cast 'Summon Bigger Fish'\",\n\t\t\"Do you touch it?\",\n\t\t\"What would Matt Mercer do?\",\n\t\t\"To continue, please insert more credits\",\n\t\t\"Have you considered just... Not?\",\n\t\t\"You can't just write 'I win'\",\n\t],\n};\n\nexport const GEMMY_EXCLUSIVE_QUOTES: Quotes = {\n\tgeneral: [],\n\tidle: [\n\t\t\"You pooping?\",\n\t],\n\twritingMode: [],\n};\n\nexport const DRAKE_EXCLUSIVE_QUOTES: Quotes = {\n\tgeneral: [],\n\tidle: [],\n\twritingMode: [],\n};\n\n// Copy and paste this above. Change NAME with your new character\n// Be mindful of the indentations as comment mode strips them\n// export const NAME_EXCLUSIVE_QUOTES: Quotes = {\n// \tgeneral: [\n//\n// \t],\n//\n// \tidle: [\n\n// \t],\n//\n// \twritingMode: [\n//\t\"You can't just write 'I win'\",\n// \t],\n// };\n", "import GranitePlugin from './main';\nimport { AnimationSourceType } from './Setting';\nimport { GraniteMode, GraniteState } from './Granite';\nimport { DRAKE_EXCLUSIVE_QUOTES, GEMMY_EXCLUSIVE_QUOTES, GRANITE_BASE_QUOTES, Quotes } from './quotes/Quotes';\n// When you need to add a character, add the following to the above: NAME_EXCLUSIVE_QUOTES,\n// Example import { NAME_EXCLUSIVE_QUOTES, DRAKE_EXCLUSIVE_QUOTES, GEMMY_EXCLUSIVE_QUOTES, GRANITE_BASE_QUOTES, Quotes } from './quotes/Quotes';\n\nexport class QuoteManager {\n\tpublic readonly plugin: GranitePlugin;\n\n\tpublic readonly quoteMap: Record<AnimationSourceType, Record<GraniteMode, string[]>>;\n\n\tconstructor(plugin: GranitePlugin) {\n\t\tthis.plugin = plugin;\n\n\t\tthis.quoteMap = {\n\t\t\t[AnimationSourceType.GEMMY]: {\n\t\t\t\t[GraniteMode.IDLE]: this.getIdleQuotes(GEMMY_EXCLUSIVE_QUOTES),\n\t\t\t\t[GraniteMode.WRITING]: this.getWritingQuotes(GEMMY_EXCLUSIVE_QUOTES),\n\t\t\t},\n\t\t\t[AnimationSourceType.DRAKE]: {\n\t\t\t\t[GraniteMode.IDLE]: this.getIdleQuotes(DRAKE_EXCLUSIVE_QUOTES),\n\t\t\t\t[GraniteMode.WRITING]: this.getWritingQuotes(DRAKE_EXCLUSIVE_QUOTES),\n\t\t\t},\n\t\t\t// Copy and paste below to add your character's source here.\n\t\t\t// Replace NAME with your new character's name\n\t\t\t//\n\t\t\t// [AnimationSourceType.NAME]: {\n\t\t\t// \t[GraniteMode.IDLE]: this.getIdleQuotes(NAME_EXCLUSIVE_QUOTES),\n\t\t\t// \t[GraniteMode.WRITING]: this.getWritingQuotes(NAME_EXCLUSIVE_QUOTES),\n\t\t\t// },\n\t\t};\n\n\t\tconsole.log('granite | build quote map', this.quoteMap);\n\t}\n\n\tprivate getIdleQuotes(exclusiveQuotes: Quotes): string[] {\n\t\treturn [...GRANITE_BASE_QUOTES.general, ...GRANITE_BASE_QUOTES.idle, ...exclusiveQuotes.general, ...exclusiveQuotes.idle];\n\t}\n\n\tprivate getWritingQuotes(exclusiveQuotes: Quotes): string[] {\n\t\treturn [...GRANITE_BASE_QUOTES.general, ...GRANITE_BASE_QUOTES.writingMode, ...exclusiveQuotes.general, ...exclusiveQuotes.writingMode];\n\t}\n\n\tpublic getQuote(): string {\n\t\tconst quotes: string[] = this.quoteMap[this.plugin.settings.animationSource][this.plugin.granite.mode];\n\n\t\treturn quotes[Math.floor(Math.random() * quotes.length)];\n\t}\n}\n", "import { Animations, AnimationType } from './Animations';\nimport GranitePlugin from './main';\nimport { QuoteManager } from './QuoteManager';\n\nconst BUBBLE_DURATION: number = 5000;\n\nexport enum GraniteMode {\n\tIDLE = 'IDLE',\n\tWRITING = 'WRITING',\n}\n\nexport enum GraniteState {\n\tVISIBLE = 'VISIBLE',\n\tINVISIBLE = 'INVISIBLE',\n\tDISAPPEARING = 'DISAPPEARING',\n\tAPPEARING = 'APPEARING',\n}\n\nexport class Granite {\n\tpublic readonly plugin: GranitePlugin;\n\tprivate readonly animations: Animations;\n\tprivate readonly quotes: QuoteManager;\n\n\tgraniteEl: HTMLElement;\n\timageEl: HTMLElement;\n\n\tstate: GraniteState;\n\tmode: GraniteMode;\n\n\tidleTimeout: number;\n\twritingModeTimeout: number;\n\n\tconstructor(plugin: GranitePlugin) {\n\t\tthis.plugin = plugin;\n\n\t\tthis.animations = new Animations(this.plugin);\n\t\tthis.quotes = new QuoteManager(this.plugin);\n\n\t\tthis.state = GraniteState.INVISIBLE;\n\t\tthis.mode = GraniteMode.IDLE;\n\n\t\tthis.createGraniteEl();\n\n\t\tthis.startNextIdleTimeout();\n\t}\n\n\tcreateGraniteEl() {\n\t\tthis.graniteEl = createDiv('granite-container');\n\t\tthis.graniteEl.setAttribute('aria-label-position', 'top');\n\t\tthis.graniteEl.setAttribute('aria-label-delay', '0');\n\t\tthis.graniteEl.setAttribute('aria-label-classes', 'granite-tooltip');\n\n\t\tthis.imageEl = this.graniteEl.createEl('img', {});\n\n\t\tthis.graniteEl.addEventListener('mouseenter', () => {\n\t\t\t// ignore mouse events in writing mode\n\t\t\tif (this.mode === GraniteMode.WRITING) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tthis.saySomething(true);\n\t\t\tthis.idleTimeout && clearTimeout(this.idleTimeout);\n\t\t});\n\n\t\tthis.graniteEl.addEventListener('mouseleave', () => {\n\t\t\t// ignore mouse events in writing mode\n\t\t\tif (this.mode === GraniteMode.WRITING) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tthis.animations.play(this.imageEl, AnimationType.IDLE_MOTION);\n\t\t\tthis.startNextIdleTimeout();\n\t\t});\n\n\t\tthis.graniteEl.hidden = true;\n\t\tdocument.body.appendChild(this.graniteEl);\n\t}\n\n\tasync appear(): Promise<void> {\n\t\tif (this.state === GraniteState.APPEARING || this.state === GraniteState.VISIBLE) {\n\t\t\treturn;\n\t\t}\n\n\t\t// show him\n\t\tthis.state = GraniteState.APPEARING;\n\t\tthis.graniteEl.hidden = false;\n\n\t\t// Quicker if we're in writing mode\n\t\tif (this.mode === GraniteMode.WRITING) {\n\t\t\tthis.animations.play(this.imageEl, AnimationType.POP_MOTION);\n\n\t\t\tawait sleep(1800);\n\n\t\t\t// another animation overrode this animation, so we quit\n\t\t\tif (this.state !== GraniteState.APPEARING) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tthis.state = GraniteState.VISIBLE;\n\t\t\tthis.saySomething(true);\n\t\t} else {\n\t\t\tthis.animations.play(this.imageEl, AnimationType.EMERGE);\n\n\t\t\tawait sleep(3800);\n\n\t\t\t// another animation overrode this animation, so we quit\n\t\t\tif (this.state !== GraniteState.APPEARING) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tthis.state = GraniteState.VISIBLE;\n\t\t\tthis.animations.play(this.imageEl, AnimationType.IDLE_MOTION);\n\t\t}\n\t}\n\n\tasync disappear(): Promise<void> {\n\t\t// don't make granite disappear while they are already leaving\n\t\tif (this.state === GraniteState.DISAPPEARING || this.state === GraniteState.INVISIBLE) {\n\t\t\treturn;\n\t\t}\n\n\t\tthis.state = GraniteState.DISAPPEARING;\n\n\t\tif (this.idleTimeout) window.clearTimeout(this.idleTimeout);\n\t\tif (this.writingModeTimeout) window.clearTimeout(this.writingModeTimeout);\n\n\t\tthis.animations.play(this.imageEl, AnimationType.DISAPPEAR_MOTION);\n\t\t// remote tooltip\n\t\tthis.graniteEl.dispatchEvent(new MouseEvent('mouseout', { bubbles: true, clientX: 10, clientY: 10 }));\n\n\t\tawait sleep(1300);\n\n\t\t// another animation overrode this animation, so we quit\n\t\tif (this.state !== GraniteState.DISAPPEARING) {\n\t\t\treturn;\n\t\t}\n\n\t\tthis.state = GraniteState.INVISIBLE;\n\t\tthis.graniteEl.hidden = true;\n\t}\n\n\tasync reset(): Promise<void> {\n\t\tif (this.state === GraniteState.DISAPPEARING || this.state === GraniteState.INVISIBLE) {\n\t\t\tawait this.appear();\n\t\t}\n\n\t\tthis.animations.play(this.imageEl, AnimationType.IDLE_MOTION);\n\t}\n\n\tonEditorChange(): void {\n\t\tif (this.mode === GraniteMode.IDLE) {\n\t\t\treturn;\n\t\t}\n\n\t\tif (this.state !== GraniteState.DISAPPEARING && this.state !== GraniteState.INVISIBLE) {\n\t\t\tthis.disappear();\n\t\t}\n\t\tthis.setWritingModeTimeout();\n\t}\n\n\tenterWritingMode(): void {\n\t\tthis.mode = GraniteMode.WRITING;\n\t\tthis.disappear();\n\n\t\tthis.setWritingModeTimeout();\n\t}\n\n\tleaveWritingMode() {\n\t\tthis.mode = GraniteMode.IDLE;\n\t\tthis.reset();\n\n\t\twindow.clearTimeout(this.writingModeTimeout);\n\t}\n\n\tsetWritingModeTimeout(): void {\n\t\tif (this.writingModeTimeout) {\n\t\t\twindow.clearTimeout(this.writingModeTimeout);\n\t\t}\n\n\t\tthis.writingModeTimeout = window.setTimeout(() => {\n\t\t\tif (this.mode === GraniteMode.WRITING) {\n\t\t\t\tthis.appear();\n\t\t\t}\n\t\t}, this.plugin.settings.writingModeGracePeriod * 1000);\n\t}\n\n\tstartNextIdleTimeout(): void {\n\t\t// if the set time is 5 minutes, this will set timeout to be a random time between 4-6 minutes\n\t\t// the range will be 80% - 120%\n\t\tconst randomFactor = 0.8 + 0.4 * Math.random();\n\t\tconst randomizedTimeout = randomFactor * this.plugin.settings.idleTalkFrequency * 60000;\n\n\t\tif (this.idleTimeout) {\n\t\t\twindow.clearTimeout(this.idleTimeout);\n\t\t}\n\n\t\tthis.idleTimeout = window.setTimeout(() => {\n\t\t\tif (this.mode === GraniteMode.WRITING) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tthis.saySomething(false);\n\t\t\tthis.startNextIdleTimeout();\n\t\t}, randomizedTimeout);\n\t}\n\n\tasync saySomething(persistent: boolean): Promise<void> {\n\t\tif (this.state !== GraniteState.VISIBLE) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst quote: string = this.quotes.getQuote();\n\n\t\tthis.graniteEl.setAttr('aria-label', quote);\n\t\tthis.graniteEl.setAttr('aria-label-position', 'top');\n\t\tthis.graniteEl.dispatchEvent(new MouseEvent('mouseover', { bubbles: true, clientX: 10, clientY: 10 }));\n\n\t\tif (this.mode === GraniteMode.WRITING) {\n\t\t\tthis.animations.play(this.imageEl, AnimationType.ANGRY_MOTION);\n\n\t\t\tawait sleep(1000);\n\n\t\t\tthis.animations.play(this.imageEl, AnimationType.DISAPPOINT_IMG);\n\t\t} else {\n\t\t\tthis.animations.play(this.imageEl, AnimationType.LOOK_MOTION);\n\t\t}\n\n\t\tif (!persistent) {\n\t\t\tawait sleep(BUBBLE_DURATION);\n\n\t\t\tthis.graniteEl.dispatchEvent(new MouseEvent('mouseout', { bubbles: true, clientX: 10, clientY: 10 }));\n\t\t\tthis.animations.play(this.imageEl, AnimationType.IDLE_MOTION);\n\t\t}\n\t}\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAAAA,mBAAiC;;;ACAjC,sBAA+C;AAmBxC,IAAM,mBAAoC;AAAA,EAChD,iBAAiB;AAAA,EACjB,mBAAmB;AAAA,EACnB,wBAAwB;AACzB;AAEO,IAAM,qBAAN,cAAiC,iCAAiB;AAAA,EAGxD,YAAY,KAAU,QAAuB;AAC5C,UAAM,KAAK,MAAM;AACjB,SAAK,SAAS;AAAA,EACf;AAAA,EAEA,UAAgB;AACf,UAAM,EAAE,YAAY,IAAI;AAExB,gBAAY,MAAM;AAElB,QAAI,wBAAQ,WAAW,EACrB,QAAQ,kBAAkB,EAC1B,QAAQ,0CAA0C,EAClD;AAAA,MAAY,cACZ,SACE,UAAU,qBAA2B,OAAO,EAC5C,UAAU,qBAA2B,OAAO,EAG5C,SAAS,KAAK,OAAO,SAAS,eAAe,EAC7C,SAAS,OAAM,UAAS;AAExB,cAAM,kBAAkB;AACxB,aAAK,OAAO,SAAS,kBAAkB;AAGvC,aAAK,OAAO,QAAQ,MAAM;AAE1B,cAAM,KAAK,OAAO,aAAa;AAAA,MAChC,CAAC;AAAA,IACH;AAED,QAAI,wBAAQ,WAAW,EACrB,QAAQ,qBAAqB,EAC7B,QAAQ,qDAAqD,EAC7D;AAAA,MAAU,YACV,OACE,UAAU,GAAG,IAAI,CAAC,EAClB,SAAS,KAAK,OAAO,SAAS,iBAAiB,EAC/C,kBAAkB,EAClB,SAAS,OAAM,UAAS;AACxB,aAAK,OAAO,SAAS,oBAAoB;AACzC,cAAM,KAAK,OAAO,aAAa;AAAA,MAChC,CAAC;AAAA,IACH;AAED,QAAI,wBAAQ,WAAW,EACrB,QAAQ,2BAA2B,EACnC,QAAQ,+FAA+F,EACvG;AAAA,MAAU,YACV,OACE,UAAU,GAAG,KAAK,CAAC,EACnB,kBAAkB,EAClB,SAAS,KAAK,OAAO,SAAS,sBAAsB,EACpD,SAAS,OAAM,UAAS;AACxB,aAAK,OAAO,SAAS,yBAAyB;AAC9C,cAAM,KAAK,OAAO,aAAa;AAAA,MAChC,CAAC;AAAA,IACH;AAAA,EACF;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC9CO,IAAM,aAAN,MAAiB;AAAA,EAevB,YAAY,QAAuB;AAClC,SAAK,SAAS;AAed,SAAK,oBAAoB;AAAA,MACxB,CAAC,qBAAoB,GAAG;AAAA,MACxB,CAAC,6BAAwB,GAAG;AAAA,MAC5B,CAAC,yCAA8B,GAAG;AAAA,MAClC,CAAC,iCAA0B,GAAG;AAAA,MAC9B,CAAC,+BAAyB,GAAG;AAAA,MAC7B,CAAC,+BAAyB,GAAG;AAAA,MAC7B,CAAC,qCAA4B,GAAG;AAAA,IACjC;AAEA,SAAK,oBAAoB;AAAA,MACxB,CAAC,qBAAoB,GAAG;AAAA,MACxB,CAAC,6BAAwB,GAAG;AAAA,MAC5B,CAAC,yCAA8B,GAAG;AAAA,MAClC,CAAC,iCAA0B,GAAG;AAAA,MAC9B,CAAC,+BAAyB,GAAG;AAAA,MAC7B,CAAC,+BAAyB,GAAG;AAAA,MAC7B,CAAC,qCAA4B,GAAG;AAAA,IACjC;AAEA,SAAK,qBAAqB;AAAA;AAAA;AAAA,MAGzB,oBAA0B,GAAG,KAAK;AAAA,MAClC,oBAA0B,GAAG,KAAK;AAAA,IACnC;AAEA,YAAQ,IAAI,iCAAiC,KAAK,kBAAkB;AAAA,EACrE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,KAAK,IAAiB,WAAgC;AAC5D,UAAM,gBAAgB,KAAK,mBAAmB,KAAK,OAAO,SAAS,eAAe,EAAE,SAAS;AAE7F,OAAG,aAAa,OAAO,aAAa;AAAA,EACrC;AACD;;;ACxGO,IAAM,sBAA8B;AAAA,EAC1C,SAAS,CAAC;AAAA,EACV,MAAM;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACD;AAAA,EACA,aAAa;AAAA,IACZ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACD;AACD;AAEO,IAAM,yBAAiC;AAAA,EAC7C,SAAS,CAAC;AAAA,EACV,MAAM;AAAA,IACL;AAAA,EACD;AAAA,EACA,aAAa,CAAC;AACf;AAEO,IAAM,yBAAiC;AAAA,EAC7C,SAAS,CAAC;AAAA,EACV,MAAM,CAAC;AAAA,EACP,aAAa,CAAC;AACf;;;AC7EO,IAAM,eAAN,MAAmB;AAAA,EAKzB,YAAY,QAAuB;AAClC,SAAK,SAAS;AAEd,SAAK,WAAW;AAAA,MACf,oBAA0B,GAAG;AAAA,QAC5B,kBAAiB,GAAG,KAAK,cAAc,sBAAsB;AAAA,QAC7D,wBAAoB,GAAG,KAAK,iBAAiB,sBAAsB;AAAA,MACpE;AAAA,MACA,oBAA0B,GAAG;AAAA,QAC5B,kBAAiB,GAAG,KAAK,cAAc,sBAAsB;AAAA,QAC7D,wBAAoB,GAAG,KAAK,iBAAiB,sBAAsB;AAAA,MACpE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQD;AAEA,YAAQ,IAAI,6BAA6B,KAAK,QAAQ;AAAA,EACvD;AAAA,EAEQ,cAAc,iBAAmC;AACxD,WAAO,CAAC,GAAG,oBAAoB,SAAS,GAAG,oBAAoB,MAAM,GAAG,gBAAgB,SAAS,GAAG,gBAAgB,IAAI;AAAA,EACzH;AAAA,EAEQ,iBAAiB,iBAAmC;AAC3D,WAAO,CAAC,GAAG,oBAAoB,SAAS,GAAG,oBAAoB,aAAa,GAAG,gBAAgB,SAAS,GAAG,gBAAgB,WAAW;AAAA,EACvI;AAAA,EAEO,WAAmB;AACzB,UAAM,SAAmB,KAAK,SAAS,KAAK,OAAO,SAAS,eAAe,EAAE,KAAK,OAAO,QAAQ,IAAI;AAErG,WAAO,OAAO,KAAK,MAAM,KAAK,OAAO,IAAI,OAAO,MAAM,CAAC;AAAA,EACxD;AACD;;;AC7CA,IAAM,kBAA0B;AAczB,IAAM,UAAN,MAAc;AAAA,EAcpB,YAAY,QAAuB;AAClC,SAAK,SAAS;AAEd,SAAK,aAAa,IAAI,WAAW,KAAK,MAAM;AAC5C,SAAK,SAAS,IAAI,aAAa,KAAK,MAAM;AAE1C,SAAK,QAAQ;AACb,SAAK,OAAO;AAEZ,SAAK,gBAAgB;AAErB,SAAK,qBAAqB;AAAA,EAC3B;AAAA,EAEA,kBAAkB;AACjB,SAAK,YAAY,UAAU,mBAAmB;AAC9C,SAAK,UAAU,aAAa,uBAAuB,KAAK;AACxD,SAAK,UAAU,aAAa,oBAAoB,GAAG;AACnD,SAAK,UAAU,aAAa,sBAAsB,iBAAiB;AAEnE,SAAK,UAAU,KAAK,UAAU,SAAS,OAAO,CAAC,CAAC;AAEhD,SAAK,UAAU,iBAAiB,cAAc,MAAM;AAEnD,UAAI,KAAK,SAAS,yBAAqB;AACtC;AAAA,MACD;AAEA,WAAK,aAAa,IAAI;AACtB,WAAK,eAAe,aAAa,KAAK,WAAW;AAAA,IAClD,CAAC;AAED,SAAK,UAAU,iBAAiB,cAAc,MAAM;AAEnD,UAAI,KAAK,SAAS,yBAAqB;AACtC;AAAA,MACD;AAEA,WAAK,WAAW,KAAK,KAAK,wCAAkC;AAC5D,WAAK,qBAAqB;AAAA,IAC3B,CAAC;AAED,SAAK,UAAU,SAAS;AACxB,aAAS,KAAK,YAAY,KAAK,SAAS;AAAA,EACzC;AAAA,EAEA,MAAM,SAAwB;AAC7B,QAAI,KAAK,UAAU,+BAA0B,KAAK,UAAU,yBAAsB;AACjF;AAAA,IACD;AAGA,SAAK,QAAQ;AACb,SAAK,UAAU,SAAS;AAGxB,QAAI,KAAK,SAAS,yBAAqB;AACtC,WAAK,WAAW,KAAK,KAAK,sCAAiC;AAE3D,YAAM,MAAM,IAAI;AAGhB,UAAI,KAAK,UAAU,6BAAwB;AAC1C;AAAA,MACD;AAEA,WAAK,QAAQ;AACb,WAAK,aAAa,IAAI;AAAA,IACvB,OAAO;AACN,WAAK,WAAW,KAAK,KAAK,8BAA6B;AAEvD,YAAM,MAAM,IAAI;AAGhB,UAAI,KAAK,UAAU,6BAAwB;AAC1C;AAAA,MACD;AAEA,WAAK,QAAQ;AACb,WAAK,WAAW,KAAK,KAAK,wCAAkC;AAAA,IAC7D;AAAA,EACD;AAAA,EAEA,MAAM,YAA2B;AAEhC,QAAI,KAAK,UAAU,qCAA6B,KAAK,UAAU,6BAAwB;AACtF;AAAA,IACD;AAEA,SAAK,QAAQ;AAEb,QAAI,KAAK;AAAa,aAAO,aAAa,KAAK,WAAW;AAC1D,QAAI,KAAK;AAAoB,aAAO,aAAa,KAAK,kBAAkB;AAExE,SAAK,WAAW,KAAK,KAAK,kDAAuC;AAEjE,SAAK,UAAU,cAAc,IAAI,WAAW,YAAY,EAAE,SAAS,MAAM,SAAS,IAAI,SAAS,GAAG,CAAC,CAAC;AAEpG,UAAM,MAAM,IAAI;AAGhB,QAAI,KAAK,UAAU,mCAA2B;AAC7C;AAAA,IACD;AAEA,SAAK,QAAQ;AACb,SAAK,UAAU,SAAS;AAAA,EACzB;AAAA,EAEA,MAAM,QAAuB;AAC5B,QAAI,KAAK,UAAU,qCAA6B,KAAK,UAAU,6BAAwB;AACtF,YAAM,KAAK,OAAO;AAAA,IACnB;AAEA,SAAK,WAAW,KAAK,KAAK,wCAAkC;AAAA,EAC7D;AAAA,EAEA,iBAAuB;AACtB,QAAI,KAAK,SAAS,mBAAkB;AACnC;AAAA,IACD;AAEA,QAAI,KAAK,UAAU,qCAA6B,KAAK,UAAU,6BAAwB;AACtF,WAAK,UAAU;AAAA,IAChB;AACA,SAAK,sBAAsB;AAAA,EAC5B;AAAA,EAEA,mBAAyB;AACxB,SAAK,OAAO;AACZ,SAAK,UAAU;AAEf,SAAK,sBAAsB;AAAA,EAC5B;AAAA,EAEA,mBAAmB;AAClB,SAAK,OAAO;AACZ,SAAK,MAAM;AAEX,WAAO,aAAa,KAAK,kBAAkB;AAAA,EAC5C;AAAA,EAEA,wBAA8B;AAC7B,QAAI,KAAK,oBAAoB;AAC5B,aAAO,aAAa,KAAK,kBAAkB;AAAA,IAC5C;AAEA,SAAK,qBAAqB,OAAO,WAAW,MAAM;AACjD,UAAI,KAAK,SAAS,yBAAqB;AACtC,aAAK,OAAO;AAAA,MACb;AAAA,IACD,GAAG,KAAK,OAAO,SAAS,yBAAyB,GAAI;AAAA,EACtD;AAAA,EAEA,uBAA6B;AAG5B,UAAM,eAAe,MAAM,MAAM,KAAK,OAAO;AAC7C,UAAM,oBAAoB,eAAe,KAAK,OAAO,SAAS,oBAAoB;AAElF,QAAI,KAAK,aAAa;AACrB,aAAO,aAAa,KAAK,WAAW;AAAA,IACrC;AAEA,SAAK,cAAc,OAAO,WAAW,MAAM;AAC1C,UAAI,KAAK,SAAS,yBAAqB;AACtC;AAAA,MACD;AAEA,WAAK,aAAa,KAAK;AACvB,WAAK,qBAAqB;AAAA,IAC3B,GAAG,iBAAiB;AAAA,EACrB;AAAA,EAEA,MAAM,aAAa,YAAoC;AACtD,QAAI,KAAK,UAAU,yBAAsB;AACxC;AAAA,IACD;AAEA,UAAM,QAAgB,KAAK,OAAO,SAAS;AAE3C,SAAK,UAAU,QAAQ,cAAc,KAAK;AAC1C,SAAK,UAAU,QAAQ,uBAAuB,KAAK;AACnD,SAAK,UAAU,cAAc,IAAI,WAAW,aAAa,EAAE,SAAS,MAAM,SAAS,IAAI,SAAS,GAAG,CAAC,CAAC;AAErG,QAAI,KAAK,SAAS,yBAAqB;AACtC,WAAK,WAAW,KAAK,KAAK,0CAAmC;AAE7D,YAAM,MAAM,GAAI;AAEhB,WAAK,WAAW,KAAK,KAAK,8CAAqC;AAAA,IAChE,OAAO;AACN,WAAK,WAAW,KAAK,KAAK,wCAAkC;AAAA,IAC7D;AAEA,QAAI,CAAC,YAAY;AAChB,YAAM,MAAM,eAAe;AAE3B,WAAK,UAAU,cAAc,IAAI,WAAW,YAAY,EAAE,SAAS,MAAM,SAAS,IAAI,SAAS,GAAG,CAAC,CAAC;AACpG,WAAK,WAAW,KAAK,KAAK,wCAAkC;AAAA,IAC7D;AAAA,EACD;AACD;;;ALtOA,IAAqB,gBAArB,cAA2C,wBAAO;AAAA,EAIjD,MAAM,SAAS;AACd,YAAQ,IAAI,gBAAgB;AAE5B,UAAM,KAAK,aAAa;AAExB,SAAK,UAAU,IAAI,QAAQ,IAAI;AAE/B,SAAK,WAAW;AAAA,MACf,IAAI;AAAA,MACJ,MAAM;AAAA,MACN,UAAU,MAAM;AACf,aAAK,QAAQ,OAAO;AAAA,MACrB;AAAA,IACD,CAAC;AAED,SAAK,WAAW;AAAA,MACf,IAAI;AAAA,MACJ,MAAM;AAAA,MACN,UAAU,MAAM;AACf,aAAK,QAAQ,UAAU;AAAA,MACxB;AAAA,IACD,CAAC;AAED,SAAK,WAAW;AAAA,MACf,IAAI;AAAA,MACJ,MAAM;AAAA,MACN,UAAU,MAAM;AACf,aAAK,QAAQ,iBAAiB;AAAA,MAC/B;AAAA,IACD,CAAC;AAED,SAAK,WAAW;AAAA,MACf,IAAI;AAAA,MACJ,MAAM;AAAA,MACN,UAAU,MAAM;AACf,aAAK,QAAQ,iBAAiB;AAAA,MAC/B;AAAA,IACD,CAAC;AAGD,SAAK,cAAc,IAAI,mBAAmB,KAAK,KAAK,IAAI,CAAC;AAGzD,SAAK;AAAA,MACJ,KAAK,IAAI,UAAU;AAAA,QAClB;AAAA,YACA,2BAAS,MAAM;AACd,eAAK,QAAQ,eAAe;AAAA,QAC7B,GAAG,GAAG;AAAA,MACP;AAAA,IACD;AAEA,SAAK,IAAI,UAAU,cAAc,MAAM,KAAK,QAAQ,OAAO,CAAC;AAAA,EAC7D;AAAA,EAEA,WAAW;AACV,YAAQ,IAAI,kBAAkB;AAE9B,SAAK,QAAQ,UAAU;AAAA,EACxB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAM,eAAe;AACpB,SAAK,WAAW,OAAO,OAAO,CAAC,GAAG,kBAAkB,MAAM,KAAK,SAAS,CAAC;AAIzE,QAAI,KAAK,SAAS,oBAAoB,UAAU;AAC/C,WAAK,SAAS;AAAA,IACf;AAEA,QAAI,KAAK,SAAS,oBAAoB,YAAY;AACjD,WAAK,SAAS;AAAA,IACf;AAEA,UAAM,KAAK,aAAa;AAAA,EACzB;AAAA,EAEA,MAAM,eAAe;AACpB,UAAM,KAAK,SAAS,KAAK,QAAQ;AAAA,EAClC;AACD;",
  "names": ["import_obsidian"]
}
 diff --git a/manifest.json b/manifest.json index c1bf8c3..a676016 100644 --- a/manifest.json +++ b/manifest.json @@ -1,11 +1,10 @@ { "id": "granite", "name": "Granite", - "version": "0.1.1", - "minAppVersion": "0.19.0", + "version": "0.1.2", + "minAppVersion": "1.4.0", "description": "A Goal Reinforcing And Note Improving Tiny Entity", - "author": "Obsidian, and the Obsidian TTRPG Community", + "author": "Obsidian Team, and the Obsidian TTRPG Community", "authorUrl": "https://github.com/Obsidian-TTRPG-Community/gemmy_ttrpg", - "fundingUrl": "", "isDesktopOnly": false } diff --git a/package.json b/package.json index f3980fe..0ddaa3c 100644 --- a/package.json +++ b/package.json @@ -10,7 +10,7 @@ "format": "prettier --write ." }, "keywords": [], - "author": "Obsidian TTRPG Community", + "author": "Obsidian, and the Obsidian TTRPG Community", "license": "MIT", "devDependencies": { "@types/node": "^16.11.6", diff --git a/src/Animations.ts b/src/Animations.ts index 7ee10d7..372cacb 100644 --- a/src/Animations.ts +++ b/src/Animations.ts @@ -19,6 +19,17 @@ import LOOK_MOTION_DRAKE from '../animations/drake/drake_lookAround.gif'; import IDLE_MOTION_DRAKE from '../animations/drake/drake_idle.gif'; import DISAPPOINT_IMG_DRAKE from '../animations/drake/drake_disappoint.gif'; +// Importing a new character? Copy the below and change the NAME with your character name. +// +// Name Animations +// import EMERGE_MOTION_NAME from '../animations/name/name_emerge.gif'; +// import POP_MOTION_NAME from '../animations/name/name_pop.gif'; +// import DISAPPEAR_MOTION_NAME from '../animations/name/name_disappear.gif'; +// import ANGRY_MOTION_NAME from '../animations/name/name_angry.gif'; +// import LOOK_MOTION_NAME from '../animations/name/name_lookAround.gif'; +// import IDLE_MOTION_NAME from '../animations/name/name_idle.gif'; +// import DISAPPOINT_IMG_NAME from '../animations/name/name_disappoint.gif'; + export enum AnimationType { EMERGE = 'emerge', POP_MOTION = 'pop_motion', @@ -32,6 +43,10 @@ export enum AnimationType { export class Animations { public readonly plugin: GranitePlugin; + // Copy and paste this below, where name is your new character name. + // the mappings from an animation type to an actual image file for the name + // public readonly nameAnimationMap: Record; + // the mappings from an animation type to an actual image file for the drakeling public readonly drakeAnimationMap: Record; // the mappings from an animation type to an actual image file for the granite @@ -43,6 +58,19 @@ export class Animations { constructor(plugin: GranitePlugin) { this.plugin = plugin; + // Add your character to the animation map. + // Replace name with your new character's name. + // + // this.nameAnimationMap = { + // [AnimationType.EMERGE]: EMERGE_MOTION_NAME, + // [AnimationType.POP_MOTION]: POP_MOTION_NAME, + // [AnimationType.DISAPPEAR_MOTION]: DISAPPEAR_MOTION_NAME, + // [AnimationType.ANGRY_MOTION]: ANGRY_MOTION_NAME, + // [AnimationType.LOOK_MOTION]: LOOK_MOTION_NAME, + // [AnimationType.IDLE_MOTION]: IDLE_MOTION_NAME, + // [AnimationType.DISAPPOINT_IMG]: DISAPPOINT_IMG_NAME, + // }; + this.drakeAnimationMap = { [AnimationType.EMERGE]: EMERGE_MOTION_DRAKE, [AnimationType.POP_MOTION]: POP_MOTION_DRAKE, @@ -64,6 +92,8 @@ export class Animations { }; this.animationSourceMap = { + // Add your character to the animation source map, where name is your character name. + // [AnimationSourceType.NAME]: this.nameAnimationMap, [AnimationSourceType.DRAKE]: this.drakeAnimationMap, [AnimationSourceType.GEMMY]: this.gemmyAnimationMap, }; diff --git a/src/QuoteManager.ts b/src/QuoteManager.ts index 269395c..e71916c 100644 --- a/src/QuoteManager.ts +++ b/src/QuoteManager.ts @@ -2,6 +2,8 @@ import GranitePlugin from './main'; import { AnimationSourceType } from './Setting'; import { GraniteMode, GraniteState } from './Granite'; import { DRAKE_EXCLUSIVE_QUOTES, GEMMY_EXCLUSIVE_QUOTES, GRANITE_BASE_QUOTES, Quotes } from './quotes/Quotes'; +// When you need to add a character, add the following to the above: NAME_EXCLUSIVE_QUOTES, +// Example import { NAME_EXCLUSIVE_QUOTES, DRAKE_EXCLUSIVE_QUOTES, GEMMY_EXCLUSIVE_QUOTES, GRANITE_BASE_QUOTES, Quotes } from './quotes/Quotes'; export class QuoteManager { public readonly plugin: GranitePlugin; @@ -20,6 +22,13 @@ export class QuoteManager { [GraniteMode.IDLE]: this.getIdleQuotes(DRAKE_EXCLUSIVE_QUOTES), [GraniteMode.WRITING]: this.getWritingQuotes(DRAKE_EXCLUSIVE_QUOTES), }, + // Copy and paste below to add your character's source here. + // Replace NAME with your new character's name + // + // [AnimationSourceType.NAME]: { + // [GraniteMode.IDLE]: this.getIdleQuotes(NAME_EXCLUSIVE_QUOTES), + // [GraniteMode.WRITING]: this.getWritingQuotes(NAME_EXCLUSIVE_QUOTES), + // }, }; console.log('granite | build quote map', this.quoteMap); diff --git a/src/Setting.ts b/src/Setting.ts index ab59e89..ccfdcb0 100644 --- a/src/Setting.ts +++ b/src/Setting.ts @@ -4,6 +4,8 @@ import GranitePlugin from './main'; export enum AnimationSourceType { GEMMY = 'gemmy', DRAKE = 'drake', + // When you need to add a new character, add the following above: + // NAME = 'name', } export interface GraniteSettings { @@ -41,6 +43,8 @@ export class GraniteSettingsTab extends PluginSettingTab { dropdown .addOption(AnimationSourceType.GEMMY, 'Gemmy') .addOption(AnimationSourceType.DRAKE, 'Drake') + // When you need to add a new character, copy and paste the following line above this one, and change the NAME + // .addOption(AnimationSourceType.NAME, 'Name') .setValue(this.plugin.settings.animationSource) .onChange(async value => { // Explicitly cast the value to the correct type diff --git a/src/main.ts b/src/main.ts index b5d39d8..f574f4a 100644 --- a/src/main.ts +++ b/src/main.ts @@ -67,6 +67,12 @@ export default class GranitePlugin extends Plugin { this.granite.disappear(); } + // Within the async, update your new character by adding them to the load list, + // where name is your character name and type is the type of creature it is. + // if (this.settings.animationSource === 'type') { + // this.settings.animationSource = AnimationSourceType.NAME; + // } + async loadSettings() { this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData()); diff --git a/src/quotes/Quotes.ts b/src/quotes/Quotes.ts index c843896..84ebd0d 100644 --- a/src/quotes/Quotes.ts +++ b/src/quotes/Quotes.ts @@ -13,62 +13,67 @@ export const GRANITE_BASE_QUOTES: Quotes = { idle: [ "You can't arrest us! We already ate the evidence!", "Don't ever split the party!", - 'If you kill a hive mind, is that murder or genocide?', - 'Roll initiative!', - 'You can try!', + "If you kill a hive mind, is that murder or genocide?", + "Roll initiative!", + "You can try!", "I'm not short, I'm concentrated awesome.", "I'm not greedy, I'm just allergic to poverty.", "I don't always cast spells, but when I do, it's fireball.", "I don't need luck, I have a high charisma stat.", "I don't always drink ale, but when I do, it's with my fellow adventurers after slaying a dragon.", "I don't always roll a critical hit, but when I do, the DM forgets to make me reroll the damage.", - 'I may be chaotic neutral on paper, but in reality, I just like to watch the world burn.', - 'It’s not stealing if it belongs to a dead guy.', - 'Who needs an army when you have a bag of holding full of rocks?', - 'Let me show you how to wear a snake.', - 'WHY WOULD YOU DO THAT!', - 'That dice needs to be retired!', + "I may be chaotic neutral on paper, but in reality, I just like to watch the world burn.", + "It’s not stealing if it belongs to a dead guy.", + "Who needs an army when you have a bag of holding full of rocks?", + "Let me show you how to wear a snake.", + "WHY WOULD YOU DO THAT!", + "That dice needs to be retired!", "I don't kill without reason. Fortunately, I'm bored. Reason enough!", - 'Ah, my favoured enemy. Something alive.', + "Ah, my favoured enemy. Something alive.", "I slap the barrel with my member!... the 'barrel' open's its mouth!", "I'm not deprived, I'm depraved.", - 'You need a free hand to attempt a grapple', - `Careful how much you carry; the GM might actually ask you to calculate your inventory weight!`, - `Don't do that! Then we'll have to go look up the grapple rules!`, - `50 page backstory... NOPE`, - `It's astounding anyone can understand you, with all those Nat 1 Charisma rolls.`, - `The cheddar monks are here to save the day!`, - `You've been Gygaxed.`, - `STEP AWAY FROM THE PURCHASE MORE DICE BUTTON`, - `After thousands of years, I have attained my current state, while you struggle to complete this simple note.`, - `You are a background character in your own life.`, + "You need a free hand to attempt a grapple", + "Careful how much you carry; the GM might actually ask you to calculate your inventory weight!", + "Don't do that! Then we'll have to go look up the grapple rules!", + "50 page backstory... NOPE", + "It's astounding anyone can understand you, with all those Nat 1 Charisma rolls.", + "The cheddar monks are here to save the day!", + "You've been Gygaxed.", + "STEP AWAY FROM THE PURCHASE MORE DICE BUTTON", + "After thousands of years, I have attained my current state, while you struggle to complete this simple note.", + "You are a background character in your own life.", + "What... sorry Who is the Bard doing now?", + "DO NOT put the portable hole in the bag of holding!", + "DO NOT put the bag of holding in the portable hole!", + "If the shed's a'Rocking... RUN", ], writingMode: [ - `Player's dont take notes... maybe you should try that?`, - `Is that the best you can do? Keep writing!`, - `Write first, editor later.`, - `AI could probably write a better note...`, - `I love hearing your keyboard. Don't stop.`, - `How about we review some old notes today?`, - `Why not just use a template?`, - `Doesn't matter how much you plan... they will derail anyway!`, - `Maybe it's time to go get some water or coffee.`, - `That's not how rivers are in real-life...`, - `Anything is better than a blank page, even me. Write something!`, - `Have you given out Inspiration recently?`, - `Call me Jeeves. I. Dare. You.`, - `I cast 'Summon Bigger Fish`, - `Do you touch it?`, - `What would Matt Mercer do?`, - `To continue, please insert more credits`, - `Have you considered just... Not?`, + "Player's dont take notes... maybe you should try that?", + "Is that the best you can do? Keep writing!", + "Write first, editor later.", + "AI could probably write a better note...", + "I love hearing your keyboard. Don't stop.", + "How about we review some old notes today?", + "Why not just use a template?", + "Doesn't matter how much you plan... they will derail anyway!", + "Maybe it's time to go get some water or coffee.", + "That's not how rivers are in real-life...", + "Anything is better than a blank page, even me. Write something!", + "Have you given out Inspiration recently?", + "Call me Jeeves. I. Dare. You.", + "I cast 'Summon Bigger Fish'", + "Do you touch it?", + "What would Matt Mercer do?", + "To continue, please insert more credits", + "Have you considered just... Not?", + "You can't just write 'I win'", ], }; export const GEMMY_EXCLUSIVE_QUOTES: Quotes = { general: [], idle: [ - `You pooping?`, + "You pooping?", ], writingMode: [], }; @@ -78,3 +83,19 @@ export const DRAKE_EXCLUSIVE_QUOTES: Quotes = { idle: [], writingMode: [], }; + +// Copy and paste this above. Change NAME with your new character +// Be mindful of the indentations as comment mode strips them +// export const NAME_EXCLUSIVE_QUOTES: Quotes = { +// general: [ +// +// ], +// +// idle: [ + +// ], +// +// writingMode: [ +// "You can't just write 'I win'", +// ], +// }; diff --git a/styles.css b/styles.css index e099106..dc296f6 100644 --- a/styles.css +++ b/styles.css @@ -1,12 +1,3 @@ -/* - -This CSS file will be included with your plugin, and -available in the app when your plugin is enabled. - -If your plugin does not need CSS, delete this file. - -*/ - :root { --granite-size: 80px; }