Merge pull request #666 from WookieeMatt/beta-into-main

v4.3.0 - Merging beta into main

module/data/actor/companion.mjs

@@ -0,0 +1,33 @@
+import { E20 } from "../../helpers/config.mjs";
+
+import { makeInt, makeStrWithChoices } from "../generic-makers.mjs";
+
+import { character } from './templates/character.mjs';
+import { common } from './templates/common.mjs';
+import { creature } from './templates/creature.mjs';
+
+const fields = foundry.data.fields;
+
+function makeDefensesFields(init) {
+  return new fields.SchemaField({
+    value: makeInt(init),
+  });
+}
+
+export class CompanionActorData extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    return {
+      ...character(),
+      ...common(),
+      ...creature(),
+      availability: makeStrWithChoices(Object.keys(E20.availabilities), 'standard'),
+      defenses: new fields.SchemaField({
+        toughness: makeDefensesFields(10),
+        evasion: makeDefensesFields(10),
+        willpower: makeDefensesFields(null),
+        cleverness: makeDefensesFields(null),
+      }),
+      type: makeStrWithChoices(Object.keys(E20.companionTypes), 'pet'),
+    };
+  }
+}

module/data/actor/gi-joe.mjs

@@ -0,0 +1,13 @@
+import { character } from './templates/character.mjs';
+import { common } from './templates/common.mjs';
+import { creature } from './templates/creature.mjs';
+
+export class GiJoeActorData extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    return {
+      ...character(),
+      ...common(),
+      ...creature(),
+    };
+  }
+}

module/data/actor/index.mjs

@@ -0,0 +1,21 @@
+import { CompanionActorData } from './companion.mjs';
+import { GiJoeActorData } from './gi-joe.mjs';
+import { MegaformZordActorData } from './megaform-zord.mjs';
+import { NpcActorData } from './npc.mjs';
+import { PonyActorData } from './pony.mjs';
+import { PowerRangerActorData } from './power-ranger.mjs';
+import { TransformerActorData } from './transformer.mjs';
+import { VehicleActorData } from './vehicle.mjs';
+import { ZordActorData } from './zord.mjs';
+
+export const config = {
+  companion: CompanionActorData,
+  giJoe: GiJoeActorData,
+  megaformZord: MegaformZordActorData,
+  npc: NpcActorData,
+  pony: PonyActorData,
+  powerRanger: PowerRangerActorData,
+  transformer: TransformerActorData,
+  vehicle: VehicleActorData,
+  zord: ZordActorData,
+};

module/data/actor/megaform-zord.mjs

@@ -0,0 +1,17 @@
+import { makeInt, makeStrArray } from "../generic-makers.mjs";
+
+import { common } from './templates/common.mjs';
+import { machine } from './templates/machine.mjs';
+import { zordBase } from './templates/zord-base.mjs';
+
+export class MegaformZordActorData extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    return {
+      ...common(),
+      ...machine(),
+      ...zordBase(),
+      health: makeInt(null),
+      zordIds: makeStrArray(),
+    };
+  }
+}

module/data/actor/npc.mjs

@@ -0,0 +1,30 @@
+import { makeInt } from "../generic-makers.mjs";
+
+import { character } from './templates/character.mjs';
+import { common } from './templates/common.mjs';
+import { creature } from './templates/creature.mjs';
+
+const fields = foundry.data.fields;
+
+function makeDefensesFields(init) {
+  return new fields.SchemaField({
+    value: makeInt(init),
+  });
+}
+
+export class NpcActorData extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    return {
+      ...character(),
+      ...common(),
+      ...creature(),
+      defenses: new fields.SchemaField({
+        toughness: makeDefensesFields(10),
+        evasion: makeDefensesFields(10),
+        willpower: makeDefensesFields(null),
+        cleverness: makeDefensesFields(null),
+      }),
+      threatLevel: makeInt(0),
+    };
+  }
+}

module/data/actor/pony.mjs

@@ -0,0 +1,16 @@
+import { makeBool } from "../generic-makers.mjs";
+
+import { character } from './templates/character.mjs';
+import { common } from './templates/common.mjs';
+import { creature } from './templates/creature.mjs';
+
+export class PonyActorData extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    return {
+      ...character(),
+      ...common(),
+      ...creature(),
+      canSpellcast: makeBool(true),
+    };
+  }
+}

module/data/actor/power-ranger.mjs

@@ -0,0 +1,16 @@
+import { makeBool } from "../generic-makers.mjs";
+
+import { character } from './templates/character.mjs';
+import { common } from './templates/common.mjs';
+import { creature } from './templates/creature.mjs';
+
+export class PowerRangerActorData extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    return {
+      ...character(),
+      ...common(),
+      ...creature(),
+      canMorph: makeBool(true),
+    };
+  }
+}

module/data/actor/templates/character.mjs

@@ -0,0 +1,37 @@
+import { makeInt, makeStr } from "../../generic-makers.mjs";
+
+const fields = foundry.data.fields;
+
+function makeDefensesFields(name, essence) {
+  return new fields.SchemaField({
+    armor: makeInt(0),
+    base: makeInt(10),
+    bonus: makeInt(0),
+    essence: makeStr(essence),
+    morphed: makeInt(0),
+    name: makeStr(name),
+    string: makeStr(''),
+    total: makeInt(0),
+  });
+}
+
+export const character = () => ({
+  background: new fields.SchemaField({
+    pronouns: makeStr(''),
+    role: makeStr(''),
+  }),
+  defenses: new fields.SchemaField({
+    toughness: makeDefensesFields('toughness', 'strength'),
+    evasion: makeDefensesFields('evasion', 'speed'),
+    willpower: makeDefensesFields('willpower', 'smarts'),
+    cleverness: makeDefensesFields('cleverness', 'social'),
+  }),
+  essences: new fields.SchemaField({
+    strength: makeInt(3),
+    speed: makeInt(3),
+    smarts: makeInt(3),
+    social: makeInt(3),
+  }),
+  level: makeInt(1),
+  notes: new fields.HTMLField(),
+});

module/data/actor/templates/common.mjs

@@ -0,0 +1,148 @@
+import { E20 } from "../../../helpers/config.mjs";
+
+import { makeBool, makeInt, makeStr, makeStrWithChoices } from "../../generic-makers.mjs";
+
+const fields = foundry.data.fields;
+
+function makeEssenceShift() {
+  return new fields.SchemaField({
+    shiftUp: makeInt(0),
+    shiftDown: makeInt(0),
+  });
+}
+
+function makeMovementFields() {
+  return new fields.SchemaField({
+    altMode: makeInt(0),
+    base: makeInt(0),
+    bonus: makeInt(0),
+    morphed: makeInt(0),
+    total: makeInt(0),
+  });
+}
+
+function makeSkillFields() {
+  return new fields.SchemaField({
+    essences: new fields.SchemaField({
+      smarts: makeBool(false),
+      social: makeBool(false),
+      speed: makeBool(false),
+      strength: makeBool(false),
+    }),
+    edge: makeBool(false),
+    isSpecialized: makeBool(false),
+    modifier: makeInt(0),
+    shift: makeStrWithChoices(Object.keys(E20.skillShifts), 'd20'),
+    shiftDown: makeInt(0),
+    shiftUp: makeInt(0),
+    snag: makeBool(false),
+  });
+}
+
+export const common = () => ({
+  altModeName: makeStr(''),
+  altModeSize: makeStrWithChoices(Object.keys(E20.actorSizes), 'common'),
+  canMorph: makeBool(false),
+  canSpellcast: makeBool(false),
+  canTransform: makeBool(false),
+  color: new fields.ColorField({initial: '#b5b1b1'}),
+  conditioning: makeInt(0),
+  energon: new fields.SchemaField({
+    dark: new fields.SchemaField({
+      value: makeInt(0),
+    }),
+    normal: new fields.SchemaField({
+      max: makeInt(0),
+      value: makeInt(0),
+    }),
+    primal: new fields.SchemaField({
+      value: makeInt(0),
+    }),
+    red: new fields.SchemaField({
+      value: makeInt(0),
+    }),
+    synthEn: new fields.SchemaField({
+      value: makeInt(0),
+    }),
+  }),
+  essenceRanks: new fields.SchemaField({
+    smarts: makeStrWithChoices(E20.EssenceRankNames, null),
+    social: makeStrWithChoices(E20.EssenceRankNames, null),
+    speed: makeStrWithChoices(E20.EssenceRankNames, null),
+    strength: makeStrWithChoices(E20.EssenceRankNames, null),
+  }),
+  essenceShifts: new fields.SchemaField({
+    any: makeEssenceShift(),
+    smarts: makeEssenceShift(),
+    social: makeEssenceShift(),
+    speed: makeEssenceShift(),
+    strength: makeEssenceShift(),
+  }),
+  focusEssence: makeStr(''),
+  health: new fields.SchemaField({
+    bonus: makeInt(0),
+    max: makeInt(0),
+    origin: makeInt(0),
+    value: makeInt(0),
+  }),
+  initiative: new fields.SchemaField({
+    edge: makeBool(false),
+    formula: makeStr('2d20kl + 0'),
+    modifier: makeInt(0),
+    snag: makeBool(false),
+    shift: makeStrWithChoices(E20.initiativeShiftList, 'd20'),
+    shiftDown: makeInt(0),
+    shiftUp: makeInt(0),
+  }),
+  isLocked: makeBool(false),
+  isMorphed: makeBool(false),
+  isTransformed: makeBool(false),
+  movement: new fields.SchemaField({
+    aerial: makeMovementFields(),
+    climb: makeMovementFields(),
+    ground: makeMovementFields(),
+    swim: makeMovementFields(),
+  }),
+  movementNotSet: makeBool(false),
+  powers: new fields.SchemaField({
+    personal: new fields.SchemaField({
+      regeneration: makeInt(0),
+      max: makeInt(0),
+      value: makeInt(0),
+    }),
+    sorcerous: new fields.SchemaField({
+      levelTaken: makeInt(0),
+      max: makeInt(0),
+      value: makeInt(0),
+    }),
+  }),
+  size: makeStrWithChoices(Object.keys(E20.actorSizes), 'common'),
+  skills: new fields.SchemaField({
+    acrobatics: makeSkillFields(),
+    alertness: makeSkillFields(),
+    animalHandling: makeSkillFields(),
+    athletics: makeSkillFields(),
+    brawn: makeSkillFields(),
+    culture: makeSkillFields(),
+    deception: makeSkillFields(),
+    driving: makeSkillFields(),
+    finesse: makeSkillFields(),
+    infiltration: makeSkillFields(),
+    intimidation: makeSkillFields(),
+    might: makeSkillFields(),
+    performance: makeSkillFields(),
+    persuasion: makeSkillFields(),
+    science: makeSkillFields(),
+    roleSkillDie: makeSkillFields(),
+    spellcasting: makeSkillFields(),
+    streetwise: makeSkillFields(),
+    survival: makeSkillFields(),
+    targeting: makeSkillFields(),
+    technology: makeSkillFields(),
+  }),
+  stun: new fields.SchemaField({
+    max: makeInt(0),
+    min: makeInt(0),
+    value: makeInt(0),
+  }),
+});

module/data/actor/templates/creature.mjs

@@ -0,0 +1,5 @@
+import { makeStrArray } from "../../generic-makers.mjs";
+
+export const creature = () => ({
+  languages: makeStrArray(),
+});

module/data/actor/templates/machine.mjs

@@ -0,0 +1,20 @@
+import { makeBool, makeInt } from "../../generic-makers.mjs";
+
+const fields = foundry.data.fields;
+
+function makeDefensesFields(usesDrivers, init) {
+  return new fields.SchemaField({
+    usesDrivers: makeBool(usesDrivers),
+    value: makeInt(init),
+  });
+}
+
+export const machine = () => ({
+  canHover: makeBool(false),
+  defenses: new fields.SchemaField({
+    toughness: makeDefensesFields(false, 10),
+    evasion: makeDefensesFields(false, 10),
+    willpower: makeDefensesFields(true, null),
+    cleverness: makeDefensesFields(true, null),
+  }),
+});

module/data/actor/templates/zord-base.mjs

@@ -0,0 +1,20 @@
+import { makeBool, makeInt } from "../../generic-makers.mjs";
+
+const fields = foundry.data.fields;
+
+function makeEssencesFields(usesDrivers, init) {
+  return new fields.SchemaField({
+    usesDrivers: makeBool(usesDrivers),
+    value: makeInt(init),
+  });
+}
+
+export const zordBase = () => ({
+  armor: makeInt(10),
+  essences: new fields.SchemaField({
+    strength: makeEssencesFields(false, 3),
+    speed: makeEssencesFields(false, 3),
+    smarts: makeEssencesFields(true, null),
+    social: makeEssencesFields(true, null),
+  }),
+});