feat: add cosmere initiative system

src/declarations/foundry/common/documents/combat.d.ts

@@ -0,0 +1,9 @@
+namespace foundry {
+    namespace documents {
+        declare class BaseCombat<
+            Schema extends
+                foundry.abstract.DataSchema = foundry.abstract.DataSchema,
+            Parent extends Document | null = null,
+        > extends foundry.abstract.Document<Schema, Parent> {}
+    }
+}

src/declarations/foundry/common/documents/combatant.d.ts

@@ -0,0 +1,9 @@
+namespace foundry {
+    namespace documents {
+        declare class BaseCombatant<
+            Schema extends
+                foundry.abstract.DataSchema = foundry.abstract.DataSchema,
+            Parent extends Document | null = null,
+        > extends foundry.abstract.Document<Schema, Parent> {}
+    }
+}

src/index.ts

@@ -29,6 +29,10 @@ Hooks.once('init', async () => {
     CONFIG.Item.dataModels = dataModels.item.config;
     CONFIG.Item.documentClass = documents.CosmereItem;
 
+    CONFIG.Combat.documentClass = applications.combat.CosmereCombat;
+    CONFIG.Combatant.documentClass = applications.combat.CosmereCombatant;
+    CONFIG.ui.combat = applications.combat.CosmereCombatTracker;
+
     Actors.unregisterSheet('core', ActorSheet);
     Actors.registerSheet('cosmere-rpg', applications.actor.CharacterSheet, {
         types: ['character'],

src/lang/en.json

@@ -14,7 +14,7 @@
                     "placeholder": "[Path]"
                 },
                 "Specialties": {
-                    "placeholder": "[Specialty]"            
+                    "placeholder": "[Specialty]"
                 },
                 "Expertise": {
                     "name": "Expertise",
@@ -352,7 +352,15 @@
             "Vital": "Vital",
             "Healing": "Healing"
         },
-        "Currencies": {}
+        "Currencies": {},
+        "Combat": {
+            "FastPlayers": "Fast Characters",
+            "SlowPlayers": "Slow Characters",
+            "FastAdversaries": "Fast Adversaries",
+            "SlowAdversaries": "Slow Adversaries",
+            "ToggleTurn": "Toggle Turn Speed",
+            "ResetActivation": "Reset Activation"
+        }
     },
     "DICE": {
         "RollMode": "Roll Mode",

src/style.scss

@@ -1,6 +1,7 @@
 @import './style/sheets/module.scss';
-// @import './style/chat/module.scss';
+@import './style/sidebar/combat.scss';
 
+// @import './style/chat/module.scss';
 /* ----------------------------------------- */
 /*  Globals                                  */
 /* ----------------------------------------- */
@@ -34,10 +35,10 @@
 
 @font-face {
     font-family: 'cosmere-dingbats';
-    src: url("https://dl.dropboxusercontent.com/scl/fi/9909gen4fd0oveyzfposx/CosmereDingbats-Regular.otf?rlkey=ig6odq9hxyo1st8kt3ujp1czz&st=72qrads3&raw=1")
+    src: url('https://dl.dropboxusercontent.com/scl/fi/9909gen4fd0oveyzfposx/CosmereDingbats-Regular.otf?rlkey=ig6odq9hxyo1st8kt3ujp1czz&st=72qrads3&raw=1');
 }
 
 i.cosmere-icon {
     font-family: 'cosmere-dingbats';
     font-style: normal;
-}
+}

src/style/sidebar/combat.scss

@@ -0,0 +1,37 @@
+.cosmere-combatant-buttons {
+    display: flex;
+    text-align: center;
+    gap: 6px;
+}
+
+.cosmere-turn-speed-control,
+.cosmere-activate-control,
+.cosmere-activate-control-activated {
+    display: block;
+    width: 40px;
+    height: var(--sidebar-item-height);
+    background-size: 32px;
+    background-position: center;
+    background-repeat: no-repeat;
+    margin: 0 0.5em;
+}
+
+.cosmere-turn-speed-control {
+    background-image: url(/icons/svg/clockwork.svg);
+}
+
+.cosmere-activate-control,
+.cosmere-activate-control-activated {
+    background-image: url(/icons/svg/combat.svg);
+}
+
+.cosmere-activate-control-activated {
+    filter: brightness(40%);
+}
+
+.combat-phase {
+    padding: 0.5rem 0px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}

src/system/applications/combat/combat-tracker.ts

@@ -0,0 +1,156 @@
+import CosmereCombatant from './combatant';
+
+/**
+ * Overrides default tracker template to implement slow/fast buckets and activation button.
+ */
+export default class CosmereCombatTracker extends CombatTracker {
+    // eslint-disable-next-line @typescript-eslint/class-literal-property-style
+    override get template() {
+        return 'systems/cosmere-rpg/templates/combat/combat-tracker.hbs';
+    }
+
+    //modifies data being sent to the combat tracker template to add turn speed, type and activation status and splitting turns between the initiative phases.
+    override async getData(
+        options?: Partial<ApplicationOptions> | undefined,
+    ): Promise<object> {
+        const data = (await super.getData(options)) as {
+            turns: CosmereTurn[];
+            fastPlayers: CosmereTurn[];
+            slowPlayers: CosmereTurn[];
+            fastNPC: CosmereTurn[];
+            slowNPC: CosmereTurn[];
+        };
+        data.turns = data.turns.map((turn) => {
+            const combatant: CosmereCombatant =
+                this.viewed!.getEmbeddedDocument(
+                    'Combatant',
+                    turn.id,
+                    {},
+                ) as CosmereCombatant;
+            const newTurn: CosmereTurn = {
+                ...turn,
+                turnSpeed: combatant.getFlag(
+                    'cosmere-rpg',
+                    'turnSpeed',
+                ) as string,
+                type: combatant.actor.type,
+                activated: combatant.getFlag(
+                    'cosmere-rpg',
+                    'activated',
+                ) as boolean,
+            };
+            //strips active player formatting
+            newTurn.css = '';
+            return newTurn;
+        });
+        data.fastPlayers = data.turns.filter((turn) => {
+            return turn.type == 'character' && turn.turnSpeed == 'fast';
+        });
+        data.slowPlayers = data.turns.filter((turn) => {
+            return turn.type == 'character' && turn.turnSpeed == 'slow';
+        });
+        data.fastNPC = data.turns.filter((turn) => {
+            return turn.type == 'adversary' && turn.turnSpeed == 'fast';
+        });
+        data.slowNPC = data.turns.filter((turn) => {
+            return turn.type == 'adversary' && turn.turnSpeed == 'slow';
+        });
+
+        return data;
+    }
+
+    override activateListeners(html: JQuery<HTMLElement>): void {
+        super.activateListeners(html);
+        html.find('.cosmere-turn-speed-control').on(
+            'click',
+            this._onClickToggleTurnSpeed.bind(this),
+        );
+        html.find('.cosmere-activate-control').on(
+            'click',
+            this._onActivateCombatant.bind(this),
+        );
+    }
+
+    //toggles combatant turn speed on clicking the "fast/slow" text on the combat tracker window
+    protected _onClickToggleTurnSpeed(event: Event) {
+        event.preventDefault();
+        event.stopPropagation();
+        const btn = event.currentTarget as HTMLElement;
+        const li = btn.closest<HTMLElement>('.combatant')!;
+        const combatant: CosmereCombatant = this.viewed!.getEmbeddedDocument(
+            'Combatant',
+            li.dataset.combatantId!,
+            {},
+        ) as CosmereCombatant;
+        void combatant.toggleTurnSpeed();
+    }
+
+    //activates the combatant when clicking the activation icon
+    protected _onActivateCombatant(event: Event) {
+        event.preventDefault();
+        event.stopPropagation();
+        const btn = event.currentTarget as HTMLElement;
+        const li = btn.closest<HTMLElement>('.combatant')!;
+        const combatant: CosmereCombatant = this.viewed!.getEmbeddedDocument(
+            'Combatant',
+            li.dataset.combatantId!,
+            {},
+        ) as CosmereCombatant;
+        void combatant.setFlag('cosmere-rpg', 'activated', true);
+    }
+
+    //toggles combatant turn speed on clicking the "fast/slow" option in the turn tracker context menu
+    protected _onContextToggleTurnSpeed(li: JQuery<HTMLElement>) {
+        const combatant: CosmereCombatant = this.viewed!.getEmbeddedDocument(
+            'Combatant',
+            li.data('combatant-id') as string,
+            {},
+        ) as CosmereCombatant;
+        combatant.toggleTurnSpeed();
+    }
+
+    //resets combatants activation status to hasn't activated
+    protected _onContextResetActivation(li: JQuery<HTMLElement>) {
+        const combatant: CosmereCombatant = this.viewed!.getEmbeddedDocument(
+            'Combatant',
+            li.data('combatant-id') as string,
+            {},
+        ) as CosmereCombatant;
+        void combatant.setFlag('cosmere-rpg', 'activated', false);
+    }
+
+    _getEntryContextOptions(): ContextMenuEntry[] {
+        const menu: ContextMenuEntry[] = [
+            {
+                name: 'COSMERE.Combat.ToggleTurn',
+                icon: '',
+                callback: this._onContextToggleTurnSpeed.bind(this),
+            },
+            {
+                name: 'COSMERE.Combat.ResetActivation',
+                icon: '<i class="fas fa-undo"></i>',
+                callback: this._onContextResetActivation.bind(this),
+            },
+        ];
+        menu.push(
+            ...super
+                ._getEntryContextOptions()
+                .filter(
+                    (i) =>
+                        i.name !== 'COMBAT.CombatantReroll' &&
+                        i.name !== 'COMBAT.CombatantClear',
+                ),
+        );
+        return menu;
+    }
+}
+
+interface CosmereTurn {
+    id: string;
+    css: string;
+    pending: number;
+    finished: number;
+    type?: string;
+    turnSpeed?: string;
+    activated?: boolean;
+}

src/system/applications/combat/combat.ts

@@ -0,0 +1,22 @@
+export default class CosmereCombat extends Combat {
+    //sets all defeated combatants activation status to true (already activated), and all others to false(hasn't activated yet)
+    resetActivations() {
+        for (const combatant of this.turns) {
+            void combatant.setFlag(
+                'cosmere-rpg',
+                'activated',
+                combatant.isDefeated ? true : false,
+            );
+        }
+    }
+
+    override async startCombat(): Promise<this> {
+        this.resetActivations();
+        return super.startCombat();
+    }
+
+    override async nextRound(): Promise<this | undefined> {
+        this.resetActivations();
+        return super.nextRound();
+    }
+}

src/system/applications/combat/combatant.ts

@@ -0,0 +1,54 @@
+import { DocumentModificationOptions } from '@league-of-foundry-developers/foundry-vtt-types/src/foundry/common/abstract/document.mjs';
+import { SchemaField } from '@league-of-foundry-developers/foundry-vtt-types/src/foundry/common/data/fields.mjs';
+import { CosmereActor } from '../../documents';
+import { ActorType, TurnSpeed } from '@src/system/types/cosmere';
+
+/**
+ *
+ */
+
+export default class CosmereCombatant extends Combatant {
+    //sets actor type to CosmereActor, to get typescript to stop yelling. Might be a better way to do this but I'm newish to TS and don't know how.
+    override get actor(): CosmereActor {
+        return super.actor as CosmereActor;
+    }
+
+    //on creation, combatants turn speed is set to slow, activation status to false, and then sets the initiative, bypassing the need to roll
+    protected override _onCreate(
+        data: SchemaField.InnerAssignmentType<DataSchema>,
+        options: DocumentModificationOptions,
+        userID: string,
+    ) {
+        super._onCreate(data, options, userID);
+        void this.setFlag('cosmere-rpg', 'turnSpeed', 'slow');
+        void this.setFlag('cosmere-rpg', 'activated', false);
+        void this.combat?.setInitiative(
+            this.id!,
+            this.generateInitiative(
+                this.actor.type as ActorType,
+                TurnSpeed.Slow,
+            ),
+        );
+    }
+
+    generateInitiative(type: ActorType, speed: TurnSpeed): number {
+        let initiative: number = this.actor.system.attributes.spd.value;
+        if (type == ActorType.Character) initiative += 500;
+        if (speed == TurnSpeed.Fast) initiative += 1000;
+        return initiative;
+    }
+
+    toggleTurnSpeed() {
+        const currentSpeed = this.getFlag(
+            'cosmere-rpg',
+            'turnSpeed',
+        ) as TurnSpeed;
+        const newSpeed =
+            currentSpeed == TurnSpeed.Slow ? TurnSpeed.Fast : TurnSpeed.Slow;
+        void this.setFlag('cosmere-rpg', 'turnSpeed', newSpeed);
+        void this.combat?.setInitiative(
+            this.id!,
+            this.generateInitiative(this.actor.type as ActorType, newSpeed),
+        );
+    }
+}

src/system/applications/combat/index.ts

@@ -0,0 +1,5 @@
+import CosmereCombat from './combat';
+import CosmereCombatTracker from './combat-tracker';
+import CosmereCombatant from './combatant';
+
+export { CosmereCombat, CosmereCombatTracker, CosmereCombatant };

src/system/applications/index.ts

@@ -1 +1,2 @@
 export * as actor from './actor';
+export * as combat from './combat';

src/system/types/cosmere.ts

@@ -251,3 +251,8 @@ export const enum ItemType {
 
     Injury = 'injury',
 }
+
+export const enum TurnSpeed {
+    Fast = 'fast',
+    Slow = 'slow',
+}

src/system/util/handlebars/index.ts

@@ -432,6 +432,7 @@ export async function preloadHandlebarsTemplates() {
         'systems/cosmere-rpg/templates/actors/parts/actions.hbs',
         'systems/cosmere-rpg/templates/actors/parts/inventory.hbs',
         // 'systems/cosmere-rpg/templates/chat/parts/roll-details.hbs',
+        'systems/cosmere-rpg/templates/combat/combatant.hbs',
     ];
 
     return await loadTemplates(