Foundry/.dungeon
0
0
Fork 0
Code Issues 57 Pull requests Projects Releases 7 Packages Wiki Activity Actions

Make the system use Proxy and proper subclassing instead of the weird middle-ground polymorphism (closes #86)

Browse source
This commit is contained in:
Oliver-Akins 2024-03-18 23:16:17 -06:00
parent 745824f6cc
commit cd98e66484
17 changed files with 322 additions and 351 deletions
Download patch file Download diff file Expand all files Collapse all files

102
module/documents/Actor/GenericActor.mjs Normal file
View file

@ -0,0 +1,102 @@
import { localizer } from "../../utils/localizer.mjs";
export class DotDungeonActor extends Actor {
/** @type {any} */
system;
async openEmbeddedSheet($event) {
const data = $event.target.dataset;
let item = await fromUuid(data.embeddedEdit);
item?.sheet.render(true);
};
async createEmbeddedItem(defaults, opts = {}) {
let items = await this.createEmbeddedDocuments(`Item`, defaults);
if (items.length == 0) {
throw new Error(`Failed to create any items`);
};
this.sheet.render();
if (
game.settings.get(`dotdungeon`, `openEmbeddedOnCreate`)
&& !opts.overrideSheetOpen
) {
for (const item of items) {
item.sheet.render(true);
};
};
};
async genericEmbeddedCreate($event) {
const data = $event.currentTarget.dataset;
if (!this[`createCustom${data.embeddedCreate}`]) {
this.createEmbeddedItem({
type: data.embeddedCreate,
name: localizer(
`dotdungeon.default.name`,
{ document: `Actor`, type: data.embeddedCreate }
),
});
} else {
this[`createCustom${data.embeddedCreate}`]($event);
};
};
async genericEmbeddedUpdate($event) {
const target = $event.delegateTarget;
const data = target.dataset;
const item = await fromUuid(data.embeddedId);
let value = target.value;
switch (target.type) {
case "checkbox": value = target.checked; break;
};
await item?.update({ [data.embeddedUpdate]: value });
};
async genericEmbeddedDelete($event) {
let data = $event.currentTarget.dataset;
let item = await fromUuid(data.embeddedId);
if (!item) {
ui.notifications.error(
`dotdungeon.notification.error.item-not-found`,
{ console: false }
);
return;
};
Dialog.confirm({
title: game.i18n.format(
`dotdungeon.dialogs.${item.type}.delete.title`,
item
),
content: game.i18n.format(
`dotdungeon.dialogs.${item.type}.delete.content`,
item
),
yes: () => {
item.delete();
},
defaultYes: false,
});
};
async genericSendToChat($event) {
const data = $event.currentTarget.dataset;
const type = data.messageType;
if (this[`send${type}ToChat`]) {
return await this[`send${type}ToChat`]($event);
};
if (!data.messageContent) {
console.warn(`.dungeon | Tried to send a chat message with no content`);
return;
};
let message = await ChatMessage.create({
content: data.messageContent,
flavor: data.messageFlavor,
speaker: { actor: this.actor },
});
message.render();
};
};

104
module/documents/Actor/Handler.mjs
View file

@ -1,104 +0,0 @@
import PlayerActor from "./Player.mjs";
import MobActor from "./Mob.mjs";
import SyncActor from "./Sync.mjs";
/** @extends {Actor} */
export class ActorHandler extends Actor {
proxyTargets = {
player: PlayerActor,
mob: MobActor,
sync: SyncActor,
};
constructor(data, ctx) {
super(data, ctx);
};
/** @type {class|undefined} */
get fn() {
return this.proxyTargets[this.type];
};
async proxyFunction(funcName, ...args) {
if (!this.fn?.[funcName]) return;
return await this.fn?.[funcName].bind(this)(...args);
};
async openEmbeddedSheet($event) {
if (this.fn?.openEmbeddedSheet) {
this.fn.openEmbeddedSheet.bind(this)($event);
} else {
const data = $event.target.dataset;
let item = await fromUuid(data.embeddedEdit);
item?.sheet.render(true);
};
};
async genericEmbeddedUpdate($event) {
if (this.fn?.genericEmbeddedUpdate) {
return this.fn.genericEmbeddedUpdate.bind(this)($event);
};
const target = $event.delegateTarget;
const data = target.dataset;
const item = await fromUuid(data.embeddedId);
let value = target.value;
switch (target.type) {
case "checkbox": value = target.checked; break;
};
await item?.update({ [data.embeddedUpdate]: value });
};
async genericEmbeddedDelete($event) {
if (!this.fn?.genericEmbeddedDelete) return;
this.fn.genericEmbeddedDelete.bind(this)($event);
};
async genericEmbeddedCreate($event) {
const data = $event.currentTarget.dataset;
if (!this.fn?.[`createCustom${data.embeddedCreate}`]) return;
this.fn?.[`createCustom${data.embeddedCreate}`].bind(this)($event);
};
async genericSendToChat($event) {
const data = $event.currentTarget.dataset;
const type = data.messageType;
if (this.fn?.[`send${type}ToChat`]) {
return await this.fn?.[`send${type}ToChat`].bind(this)($event);
};
if (!data.messageContent) {
console.warn(`.dungeon | Tried to send a chat message with no content`);
return;
};
let message = await ChatMessage.create({
content: data.messageContent,
flavor: data.messageFlavor,
speaker: { actor: this.actor }
});
message.render();
};
/**
* @param {ItemHandler} item
* @returns {boolean} true to allow the document to be embedded
*/
async preItemEmbed(item) {
let type = item.type[0].toUpperCase() + item.type.slice(1);
if (this.fn?.[`pre${type}Embed`]) {
return await this.fn?.[`pre${type}Embed`].bind(this)(item);
};
return true;
};
_preUpdate(...args) {
return this.proxyFunction("_preUpdate", ...args);
};
getRollData() {
if (!this.fn?.getRollData) return {};
return this.fn?.getRollData.bind(this)();
};
useRestDie() {return this.proxyFunction("useRestDie")};
};

17
module/documents/Actor/Mob.mjs
View file

@ -1,11 +1,10 @@
/** @this {Actor} */
function getRollData() {
const data = {
initiative: this.system.initiative ?? 0,
};
return data;
};
import { DotDungeonActor } from "./GenericActor.mjs";
export default {
getRollData,
export class Mob extends DotDungeonActor {
getRollData() {
const data = {
initiative: this.system.initiative ?? 0,
};
return data;
};
};

199
module/documents/Actor/Player.mjs
View file

@ -1,155 +1,68 @@
import { ItemHandler } from "../Item/Handler.mjs";
import { DotDungeonActor } from "./GenericActor.mjs";
import { DotDungeonItem } from "../Item/GenericItem.mjs";
/** @this {Actor} */
async function genericEmbeddedDelete($event) {
let data = $event.currentTarget.dataset;
let item = await fromUuid(data.embeddedId);
export class Player extends DotDungeonActor {
if (!item) {
ui.notifications.error(
`dotdungeon.notification.error.item-not-found`,
{ console: false }
async createCustomPet() {
const body = new URLSearchParams({
number: 1,
animal: `Cat`,
"X-Requested-With": "fetch"
});
const r = await fetch(
`https://randommer.io/pet-names`,
{
method: "POST",
body
}
);
return;
await this.createEmbeddedItem([{
type: `pet`,
name: (await r.json())[0] ?? game.i18n.localize(`dotdungeon.defaults.pet.name`),
}]);
};
Dialog.confirm({
title: game.i18n.format(
`dotdungeon.dialogs.${item.type}.delete.title`,
item
),
content: game.i18n.format(
`dotdungeon.dialogs.${item.type}.delete.content`,
item
),
yes: () => {
item.delete();
},
defaultYes: false,
});
};
/** @this {Actor} */
async function createCustomItem(defaults, opts = {}) {
let items = await this.createEmbeddedDocuments(`Item`, defaults);
if (items.length == 0) {
throw new Error();
get atAspectLimit() {
let limit = game.settings.get(`dotdungeon`, `aspectLimit`);
return this.itemTypes.aspect.length >= limit;
};
this.sheet.render();
if (
game.settings.get(`dotdungeon`, `openEmbeddedOnCreate`)
&& !opts.overrideSheetOpen
) {
for (const item of items) {
item.sheet.render(true);
async preAspectEmbed(item) {
if (this.atAspectLimit) {
ui.notifications.error(
game.i18n.format(
`dotdungeon.notification.error.aspect-limit-reached`,
{ limit: game.settings.get(`dotdungeon`, `aspectLimit`) }
),
{ console: false }
);
return false;
};
};
};
/** @this {Actor} */
async function createCustomUntyped() {
await createCustomItem.bind(this)([{
type: `untyped`,
name: game.i18n.format(`dotdungeon.defaults.untyped.name`),
}]);
};
/**
* @param {DotDungeonItem} item
*/
async preUntypedEmbed(item) {
let inventoryItem = this.itemTypes.untyped.find(i => i.name === item.name);
if (inventoryItem) {
inventoryItem.update({"system.quantity": inventoryItem.system.quantity + 1});
ui.notifications.info(
game.i18n.format(
`dotdungeon.notification.info.increased-item-quantity`,
{ name: inventoryItem.name }
),
{ console: false }
);
return false;
};
};
/** @this {Actor} */
async function createCustomAspect() {
await createCustomItem.bind(this)([{
type: `aspect`,
name: game.i18n.format(`dotdungeon.defaults.aspect.name`),
}]);
};
/** @this {Actor} */
async function createCustomSpell() {
await createCustomItem.bind(this)([{
type: `spell`,
name: game.i18n.format(`dotdungeon.defaults.spell.name`),
}]);
};
/** @this {Actor} */
async function createCustomPet() {
const body = new URLSearchParams({
number: 1,
animal: `Cat`,
"X-Requested-With": "fetch"
})
const r = await fetch(
`https://randommer.io/pet-names`,
{
method: "POST",
body
}
);
await createCustomItem.bind(this)([{
type: `pet`,
name: (await r.json())[0] ?? game.i18n.localize(`dotdungeon.defaults.pet.name`),
}]);
};
/** @this {Actor} */
async function atAspectLimit() {
let limit = game.settings.get(`dotdungeon`, `aspectLimit`);
return this.itemTypes.aspect.length >= limit;
};
/**
* @param {ItemHandler} item
* @this {Actor}
*/
async function preAspectEmbed(item) {
if (await atAspectLimit.bind(this)()) {
ui.notifications.error(
game.i18n.format(
`dotdungeon.notification.error.aspect-limit-reached`,
{ limit: game.settings.get(`dotdungeon`, `aspectLimit`) }
),
{ console: false }
);
return false;
getRollData() {
const data = {
initiative: this.system.stats.hands ?? 0,
stats: this.system.stats,
};
return data;
};
};
/**
* @param {ItemHandler} item
* @this {Actor}
*/
async function preUntypedEmbed(item) {
let inventoryItem = this.itemTypes.untyped.find(i => i.name === item.name);
if (inventoryItem) {
inventoryItem.update({"system.quantity": inventoryItem.system.quantity + 1});
ui.notifications.info(
game.i18n.format(
`dotdungeon.notification.info.increased-item-quantity`,
{ name: inventoryItem.name }
),
{ console: false }
);
return false;
};
};
/** @this {Actor} */
function getRollData() {
const data = {
initiative: this.system.stats.hands ?? 0,
stats: this.system.stats,
};
return data;
};
export default {
atAspectLimit,
createCustomItem,
createCustomUntyped,
createCustomAspect,
createCustomSpell,
createCustomPet,
genericEmbeddedDelete,
preAspectEmbed,
preUntypedEmbed,
getRollData,
};

91
module/documents/Actor/Sync.mjs
View file

@ -1,60 +1,55 @@
import { syncMilestones, syncDice } from "../../config.mjs";
import { DotDungeonActor } from "./GenericActor.mjs";
/** @this {Actor} */
async function useRestDie() {
let addToSync = await (new Roll(syncDice)).evaluate();
await addToSync.toMessage({
speaker: ChatMessage.getSpeaker({ actor: this.actor }),
flavor: `Sync Restoration`,
});
this.update({
"system.rest_dice": this.system.rest_dice - 1,
"system.value": this.system.value + addToSync.total,
});
};
export class Sync extends DotDungeonActor {
async useRestDie() {
let addToSync = await (new Roll(syncDice)).evaluate();
await addToSync.toMessage({
speaker: ChatMessage.getSpeaker({ actor: this.actor }),
flavor: `Sync Restoration`,
});
this.update({
"system.rest_dice": this.system.rest_dice - 1,
"system.value": this.system.value + addToSync.total,
});
};
/** @this {Actor} */
async function _preUpdate(data, options) {
if (options.diff) {
if (data.system?.value != null) {
let currentSync = this.system.value;
let newSync = data.system.value;
async _preUpdate(data, options) {
if (options.diff) {
if (data.system?.value != null) {
let currentSync = this.system.value;
let newSync = data.system.value;
let minSync = Math.min(currentSync, newSync);
let maxSync = Math.max(currentSync, newSync);
let milestones = syncMilestones.filter(
m => minSync < m.value && m.value <= maxSync
);
let minSync = Math.min(currentSync, newSync);
let maxSync = Math.max(currentSync, newSync);
let milestones = syncMilestones.filter(
m => minSync < m.value && m.value <= maxSync
);
if (milestones.length > 0) data.system.rest_dice ??= this.system.rest_dice;
if (milestones.length > 0) data.system.rest_dice ??= this.system.rest_dice;
for (const milestone of milestones) {
// Damage
if (newSync < currentSync) {
if (!this.system.milestones_hit.has(milestone.value)) {
data.system.rest_dice += 1;
this.system.milestones_hit.add(milestone.value);
};
}
for (const milestone of milestones) {
// Damage
if (newSync < currentSync) {
if (!this.system.milestones_hit.has(milestone.value)) {
data.system.rest_dice += 1;
this.system.milestones_hit.add(milestone.value);
};
}
// Healing
else if (newSync > currentSync) {
if (
this.system.milestones_hit.has(milestone.value)
&& milestone.andReturn
&& milestone.value <= newSync
) {
this.system.milestones_hit.delete(milestone.value);
// Healing
else if (newSync > currentSync) {
if (
this.system.milestones_hit.has(milestone.value)
&& milestone.andReturn
&& milestone.value <= newSync
) {
this.system.milestones_hit.delete(milestone.value);
};
};
};
};
data.system.milestones_hit = [ ...this.system.milestones_hit ];
data.system.milestones_hit = [ ...this.system.milestones_hit ];
};
};
};
};
export default {
_preUpdate,
useRestDie,
};

46
module/documents/Actor/_proxy.mjs Normal file
View file

@ -0,0 +1,46 @@
import { DotDungeonActor } from "./GenericActor.mjs";
import { Player } from "./Player.mjs";
import { Sync } from "./Sync.mjs";
import { Mob } from "./Mob.mjs";
const classes = {
player: Player,
mob: Mob,
sync: Sync,
};
export const ActorProxy = new Proxy(function () {}, {
construct(target, args) {
const [data] = args;
if (!classes.hasOwnProperty(data.type)) {
return new DotDungeonActor(...args);
}
return new classes[data.type](...args);
},
get(target, prop, receiver) {
console.log(prop)
if (["create", "createDocuments"].includes(prop)) {
return function (data, options) {
if (data.constructor === Array) {
return data.map(i => ItemProxy.create(i, options))
}
if (!classes.hasOwnProperty(data.type)) {
return DotDungeonActor.create(data, options);
}
return classes[data.type].create(data, options)
};
};
if (prop == Symbol.hasInstance) {
return function (instance) {
return Object.values(classes).some(i => instance instanceof i)
};
};
return DotDungeonActor[prop];
},
});

15
module/documents/Item/Aspect.mjs
View file

@ -1,10 +1,9 @@
/** @this {ItemHandler} */
async function _preCreate(_data, _options, _user) {
if (this.isEmbedded) {
return await this.actor?.preItemEmbed(this);
};
};
import { DotDungeonItem } from "./GenericItem.mjs";
export default {
_preCreate,
export class Aspect extends DotDungeonItem {
async _preCreate() {
if (this.isEmbedded) {
return await this.actor?.preItemEmbed(this);
};
}
};

1
module/documents/Item/GenericItem.mjs Normal file
View file

@ -0,0 +1 @@
export class DotDungeonItem extends Item {};

30
module/documents/Item/Handler.mjs
View file

@ -1,30 +0,0 @@
import AspectItem from "./Aspect.mjs";
import SpellItem from "./Spell.mjs";
/** @extends {Item} */
export class ItemHandler extends Item {
proxyTargets = {
aspect: AspectItem,
spell: SpellItem,
};
constructor(data, ctx) {
super(data, ctx);
};
/** @type {class|undefined} */
get fn() {
return this.proxyTargets[this.type];
};
async proxyFunction(funcName, ...args) {
if (!this.fn?.[funcName]) return;
return await this.fn?.[funcName].bind(this)(...args);
};
async _preCreate(...args) {
if (this.fn?._preCreate) return this.fn?._preCreate.bind(this)(...args);
if (this.isEmbedded) return await this.actor?.preItemEmbed(this);
return;
};
};

1
module/documents/Item/Spell.mjs
View file

@ -1 +0,0 @@
export default {};

42
module/documents/Item/_proxy.mjs Normal file
View file

@ -0,0 +1,42 @@
import { Aspect } from "./Aspect.mjs";
import { DotDungeonItem } from "./GenericItem.mjs";
const classes = {
aspect: Aspect,
};
export const ItemProxy = new Proxy(function () {}, {
construct(target, args) {
const [data] = args;
if (!classes.hasOwnProperty(data.type)) {
return new DotDungeonItem(...args);
}
return new classes[data.type](...args);
},
get(target, prop, receiver) {
console.log(prop)
if (["create", "createDocuments"].includes(prop)) {
return function (data, options) {
if (data.constructor === Array) {
return data.map(i => ItemProxy.create(i, options))
}
if (!classes.hasOwnProperty(data.type)) {
return DotDungeonItem.create(data, options);
}
return classes[data.type].create(data, options)
};
};
if (prop == Symbol.hasInstance) {
return function (instance) {
return Object.values(classes).some(i => instance instanceof i)
};
};
return DotDungeonItem[prop];
},
});