`
102 |
103 | Handlebars.registerPartial('iconMelee', ``);
104 | //`
`
105 |
106 | Handlebars.registerPartial('iconRanged', ``);
107 | //`
`
108 |
109 | /* -------------------------------------------- */
110 | /* Ready Hook & Others */
111 | /* -------------------------------------------- */
112 |
113 | Hooks.once('ready', async function() {
114 | // Wait to register hotbar drop hook on ready so that modules could register earlier if they want to
115 | Hooks.on('hotbarDrop', (bar, data, slot) => createItemMacro(data, slot));
116 | });
117 |
118 | // Hide certain types from being created through the UI
119 | Hooks.on("renderDialog", (dialog, html) => {
120 | let hiddenTypes = ["floor", "wall"];
121 | Array.from(html.find("#document-create option")).forEach(i => {if (hiddenTypes.includes(i.value)) i.remove()});
122 | });
123 |
124 | /* -------------------------------------------- */
125 | /* Character Creation Hooks */
126 | /* -------------------------------------------- */
127 |
128 | Hooks.on('createActor', async function(actor) {
129 | if (actor.type === 'character') {
130 | actor.updateSource({
131 | prototypeToken: {
132 | actorLink: true,
133 | disposition: CONST.TOKEN_DISPOSITIONS.FRIENDLY
134 | }
135 | });
136 | } else if (actor.type === 'monster') {
137 | actor.updateSource({
138 | prototypeToken: {
139 | appendNumber: true,
140 | displayName: CONST.TOKEN_DISPLAY_MODES.OWNER
141 | }
142 | });
143 | } else if (actor.type === 'stronghold') {
144 | const floor = {
145 | name: `New ${game.i18n.localize('ITEM.TypeFloor')}`,
146 | type: 'floor'
147 | };
148 | if (!actor.items.size) await actor.createEmbeddedDocuments('Item', [floor]);
149 | }
150 | });
151 |
152 | /* -------------------------------------------- */
153 | /* Token Creation Hooks */
154 | /* -------------------------------------------- */
155 |
156 | Hooks.on('createToken', async function(token, options, id) {
157 | if (token.actor.type === 'monster') {
158 | let newHitPoints = new Roll(`${token.actor.system.hitDice.number}${token.actor.system.hitDice.size}+${token.actor.system.hitDice.mod}`);
159 | await newHitPoints.evaluate({ async: true });
160 | token.actor.system.hitPoints.value = Math.max(1, newHitPoints.total);
161 | token.actor.system.hitPoints.max = Math.max(1, newHitPoints.total);
162 | }
163 | });
164 |
165 | /* -------------------------------------------- */
166 | /* Hotbar Macros */
167 | /* -------------------------------------------- */
168 |
169 | /**
170 | * Create a Macro from an Item drop.
171 | * Get an existing item macro if one exists, otherwise create a new one.
172 | * @param {Object} data The dropped data
173 | * @param {number} slot The hotbar slot to use
174 | * @returns {Promise}
175 | */
176 | async function createItemMacro(data, slot) {
177 | if (data.type !== 'Item') return;
178 | if (!('data' in data)) return ui.notifications.warn('You can only create macro buttons for owned Items');
179 | const item = data.data;
180 |
181 | // Create the macro command
182 | const command = `game.basicfantasyrpg.rollItemMacro('${item.name}');`;
183 | let macro = game.macros.find(m => (m.name === item.name) && (m.command === command));
184 | if (!macro) {
185 | macro = await Macro.create({
186 | name: item.name,
187 | type: 'script',
188 | img: item.img,
189 | command: command,
190 | flags: { 'basicfantasyrpg.itemMacro': true }
191 | });
192 | }
193 | game.user.assignHotbarMacro(macro, slot);
194 | return false;
195 | }
196 |
197 | /**
198 | * Create a Macro from an Item drop.
199 | * Get an existing item macro if one exists, otherwise create a new one.
200 | * @param {string} itemName
201 | * @return {Promise}
202 | */
203 | function rollItemMacro(itemName) {
204 | const speaker = ChatMessage.getSpeaker();
205 | let actor;
206 | if (speaker.token) actor = game.actors.tokens[speaker.token];
207 | if (!actor) actor = game.actors.get(speaker.actor);
208 | const item = actor ? actor.items.find(i => i.name === itemName) : null;
209 | if (!item) return ui.notifications.warn(`Your controlled Actor does not have an item named ${itemName}`);
210 |
211 | // Trigger the item roll
212 | return item.roll();
213 | }
--------------------------------------------------------------------------------
/template.json:
--------------------------------------------------------------------------------
1 | {
2 | "Actor": {
3 | "types": ["character", "monster", "siegeEngine", "stronghold", "vehicle"],
4 | "templates": {
5 | "base": {
6 | "armorClass": {
7 | "value": 11,
8 | "label": "BASICFANTASYRPG.ArmorClass",
9 | "abbr": "BASICFANTASYRPG.ArmorClassAbbr"
10 | },
11 | "attackBonus": {
12 | "value": 1,
13 | "label": "BASICFANTASYRPG.AttackBonus",
14 | "abbr": "BASICFANTASYRPG.AttackBonusAbbr"
15 | },
16 | "biography": "",
17 | "hitPoints": {
18 | "value": 10,
19 | "max": 10,
20 | "label": "BASICFANTASYRPG.HitPoints",
21 | "abbr": "BASICFANTASYRPG.HitPointsAbbr"
22 | },
23 | "initBonus": {
24 | "value": 0,
25 | "label": "BASICFANTASYRPG.InitiativeBonus"
26 | },
27 | "move": {
28 | "value": 30,
29 | "label": "BASICFANTASYRPG.Movement"
30 | },
31 | "saves": {
32 | "death": {
33 | "value": 13
34 | },
35 | "wands": {
36 | "value": 14
37 | },
38 | "paralysis": {
39 | "value": 15
40 | },
41 | "breath": {
42 | "value": 16
43 | },
44 | "spells": {
45 | "value": 18
46 | }
47 | }
48 | }
49 | },
50 | "character": {
51 | "templates": ["base"],
52 | "abilities": {
53 | "str": {
54 | "value": 10
55 | },
56 | "int": {
57 | "value": 10
58 | },
59 | "wis": {
60 | "value": 10
61 | },
62 | "dex": {
63 | "value": 10
64 | },
65 | "con": {
66 | "value": 10
67 | },
68 | "cha": {
69 | "value": 10
70 | }
71 | },
72 | "age": {
73 | "value": "",
74 | "label": "BASICFANTASYRPG.Age"
75 | },
76 | "class": {
77 | "value": "",
78 | "label": "BASICFANTASYRPG.Class"
79 | },
80 | "race": {
81 | "value": "",
82 | "label": "BASICFANTASYRPG.Race"
83 | },
84 | "sex": {
85 | "value": "",
86 | "label": "BASICFANTASYRPG.Sex"
87 | },
88 | "level": {
89 | "value": 1,
90 | "label": "BASICFANTASYRPG.Level"
91 | },
92 | "money": {
93 | "pp": {
94 | "value": 0
95 | },
96 | "gp": {
97 | "value": 0
98 | },
99 | "ep": {
100 | "value": 0
101 | },
102 | "sp": {
103 | "value": 0
104 | },
105 | "cp": {
106 | "value": 0
107 | }
108 | },
109 | "spellsPerLevel": {
110 | "value": {
111 | "1": 0,
112 | "2": 0,
113 | "3": 0,
114 | "4": 0,
115 | "5": 0,
116 | "6": 0
117 | },
118 | "label": "BASICFANTASYRPG.SpellsPerLevel"
119 | },
120 | "xp": {
121 | "value": 0,
122 | "next": 2000,
123 | "label": "BASICFANTASYRPG.ExperiencePoints",
124 | "abbr": "BASICFANTASYRPG.ExperiencePointsAbbr"
125 | }
126 | },
127 | "monster": {
128 | "templates": ["base"],
129 | "hitDice": {
130 | "size": "d8",
131 | "number": 1,
132 | "mod": 0,
133 | "label": "BASICFANTASYRPG.HitDice",
134 | "abbr": "BASICFANTASYRPG.HitDiceAbbr"
135 | },
136 | "morale": {
137 | "value": 7,
138 | "label": "BASICFANTASYRPG.Morale"
139 | },
140 | "numberAppearing": {
141 | "value": "1d4",
142 | "label": "BASICFANTASYRPG.NumberAppearing"
143 | },
144 | "specialAbility": {
145 | "value": 0,
146 | "label": "BASICFANTASYRPG.SpecialAbilityXPBonus"
147 | },
148 | "treasureType": {
149 | "value": "None",
150 | "label": "BASICFANTASYRPG.TreasureType"
151 | },
152 | "xp": {
153 | "value": 0,
154 | "label": "BASICFANTASYRPG.ExperiencePoints",
155 | "abbr": "BASICFANTASYRPG.ExperiencePointsAbbr"
156 | }
157 | },
158 | "siegeEngine": {
159 | "templates": [],
160 | "attackBonus": {
161 | "value": 0,
162 | "label": "BASICFANTASYRPG.AttackBonus",
163 | "abbr": "BASICFANTASYRPG.AttackBonusAbbr"
164 | },
165 | "biography": "",
166 | "cost": {
167 | "value": "",
168 | "label": "BASICFANTASYRPG.Cost"
169 | },
170 | "damage": {
171 | "value": 0,
172 | "label": "BASICFANTASYRPG.Damage"
173 | },
174 | "rangeBonus": {
175 | "value": 0,
176 | "label": "BASICFANTASYRPG.RangeBonus"
177 | },
178 | "rangeShort": {
179 | "value": "",
180 | "label": "BASICFANTASYRPG.RangeShort"
181 | },
182 | "rangeMedium": {
183 | "value": "",
184 | "label": "BASICFANTASYRPG.RangeMedium"
185 | },
186 | "rangeLong": {
187 | "value": "",
188 | "label": "BASICFANTASYRPG.RangeLong"
189 | },
190 | "rateOfFire": {
191 | "value": "",
192 | "label": "BASICFANTASYRPG.RateOfFire"
193 | },
194 | "targetAC": {
195 | "value": 20,
196 | "label": "BASICFANTASYRPG.TargetAC"
197 | }
198 | },
199 | "stronghold": {
200 | "templates": [],
201 | "biography": "",
202 | "costMultiplier": {
203 | "value": 1,
204 | "label": "BASICFANTASYRPG.CostMultiplier"
205 | },
206 | "floors": [],
207 | "followers": {
208 | "value": 0,
209 | "label": "BASICFANTASYRPG.Followers"
210 | },
211 | "workers": {
212 | "value": 1,
213 | "label": "BASICFANTASYRPG.Workers"
214 | }
215 | },
216 | "vehicle": {
217 | "templates": [],
218 | "armorClass": {
219 | "value": 11,
220 | "label": "BASICFANTASYRPG.ArmorClass",
221 | "abbr": "BASICFANTASYRPG.ArmorClassAbbr"
222 | },
223 | "biography": "",
224 | "cargo": {
225 | "value": 0,
226 | "label": "BASICFANTASYRPG.Cargo"
227 | },
228 | "hardness": {
229 | "value": 6,
230 | "label": "BASICFANTASYRPG.Hardness"
231 | },
232 | "hitPoints": {
233 | "aft": {
234 | "value": 16,
235 | "max": 16,
236 | "label": "BASICFANTASYRPG.SideAft"
237 | },
238 | "forward": {
239 | "value": 16,
240 | "max": 16,
241 | "label": "BASICFANTASYRPG.SideForward"
242 | },
243 | "port": {
244 | "value": 16,
245 | "max": 16,
246 | "label": "BASICFANTASYRPG.SidePort"
247 | },
248 | "starboard": {
249 | "value": 16,
250 | "max": 16,
251 | "label": "BASICFANTASYRPG.SideStarboard"
252 | },
253 | "label": "BASICFANTASYRPG.HitPoints",
254 | "abbr": "BASICFANTASYRPG.HitPointsAbbr"
255 | },
256 | "length": {
257 | "value": 35,
258 | "label": "BASICFANTASYRPG.Length"
259 | },
260 | "maneuverability": {
261 | "value": "15'",
262 | "label": "BASICFANTASYRPG.Maneuverability"
263 | },
264 | "move": {
265 | "value": 20,
266 | "label": "BASICFANTASYRPG.Movement"
267 | },
268 | "width": {
269 | "value": 8,
270 | "label": "BASICFANTASYRPG.Width"
271 | }
272 | }
273 | },
274 | "Item": {
275 | "types": ["item", "weapon", "armor", "spell", "feature", "floor", "wall"],
276 | "templates": {
277 | "base": {
278 | "description": ""
279 | },
280 | "valuable": {
281 | "price": {
282 | "value": "",
283 | "label": "BASICFANTASYRPG.Price"
284 | },
285 | "weight": {
286 | "value": 1,
287 | "label": "BASICFANTASYRPG.Weight"
288 | }
289 | }
290 | },
291 | "item": {
292 | "templates": ["base", "valuable"],
293 | "quantity": {
294 | "value": 1,
295 | "label": "BASICFANTASYRPG.Quantity"
296 | }
297 | },
298 | "weapon": {
299 | "templates": ["base", "valuable"],
300 | "bonusAb": {
301 | "value": 0,
302 | "label": "BASICFANTASYRPG.BonusAttackBonus"
303 | },
304 | "damage": {
305 | "value": "1d6",
306 | "label": "BASICFANTASYRPG.Damage",
307 | "abbr": "BASICFANTASYRPG.DamageAbbr"
308 | },
309 | "range":{
310 | "value": "Melee",
311 | "label": "BASICFANTASYRPG.Range"
312 | },
313 | "size": {
314 | "value": "M",
315 | "label": "BASICFANTASYRPG.Size"
316 | }
317 | },
318 | "armor": {
319 | "templates": ["base", "valuable"],
320 | "armorClass": {
321 | "value": 11,
322 | "label": "BASICFANTASYRPG.ArmorClass",
323 | "abbr": "BASICFANTASYRPG.ArmorClassAbbr"
324 | }
325 | },
326 | "spell": {
327 | "templates": ["base"],
328 | "class": {
329 | "value": "",
330 | "label": "BASICFANTASYRPG.Class"
331 | },
332 | "duration": {
333 | "value": "",
334 | "label": "BASICFANTASYRPG.Duration"
335 | },
336 | "prepared": {
337 | "value": 0,
338 | "label": "BASICFANTASYRPG.Prepared"
339 | },
340 | "range": {
341 | "value": "",
342 | "label": "BASICFANTASYRPG.Range"
343 | },
344 | "spellLevel": {
345 | "value": 1,
346 | "label": "BASICFANTASYRPG.SpellLevel"
347 | }
348 | },
349 | "feature": {
350 | "templates": ["base"],
351 | "formula": {
352 | "value": "d100",
353 | "label": "BASICFANTASYRPG.Formula"
354 | },
355 | "rollUnder": {
356 | "value": true,
357 | "label": "BASICFANTASYRPG.RollUnder"
358 | },
359 | "targetNumber": {
360 | "value": "",
361 | "label": "BASICFANTASYRPG.TargetNumber"
362 | }
363 | },
364 | "floor": {
365 | "templates": ["base", "valuable"],
366 | "area": {
367 | "value": 0,
368 | "label": "BASICFANTASYRPG.Area"
369 | },
370 | "height": {
371 | "value": 10,
372 | "label": "BASICFANTASYRPG.Height"
373 | },
374 | "material": {
375 | "value": "floor",
376 | "label": "BASICFANTASYRPG.Material"
377 | }
378 | },
379 | "wall": {
380 | "templates": ["base", "valuable"],
381 | "floor": {
382 | "value": 0,
383 | "label": "TYPES.Item.floor"
384 | },
385 | "hardness": {
386 | "value": 6,
387 | "label": "BASICFANTASYRPG.Hardness"
388 | },
389 | "material": {
390 | "value": "wood",
391 | "label": "BASICFANTASYRPG.Material"
392 | },
393 | "quantity": {
394 | "value": 1,
395 | "label": "BASICFANTASYRPG.Quantity"
396 | },
397 | "thickness": {
398 | "value": 1,
399 | "label": "BASICFANTASYRPG.Thickness"
400 | }
401 | }
402 | }
403 | }
--------------------------------------------------------------------------------
/module/documents/actor.mjs:
--------------------------------------------------------------------------------
1 | /**
2 | * Extend the base Actor document by defining a custom roll data structure which is ideal for the Simple system.
3 | * @extends {Actor}
4 | */
5 | export class BasicFantasyRPGActor extends Actor {
6 |
7 | /** @override */
8 | prepareData() {
9 | // Prepare data for the actor. Calling the super version of this executes
10 | // the following, in order: data reset (to clear active effects),
11 | // prepareBaseData(), prepareEmbeddedDocuments() (including active effects),
12 | // prepareDerivedData().
13 | super.prepareData();
14 | }
15 |
16 | /** @override */
17 | prepareBaseData() {
18 | // Data modifications in this step occur before processing embedded
19 | // documents or derived data.
20 | const actorData = this;
21 |
22 | // Make separate methods for each Actor type to keep things organized.
23 | this._prepareCharacterData(actorData);
24 | this._prepareMonsterData(actorData);
25 | this._prepareSiegeEngineData(actorData);
26 | this._prepareStrongholdData(actorData);
27 | this._prepareVehicleData(actorData);
28 | }
29 |
30 | /**
31 | * @override
32 | * Augment the basic actor data with additional dynamic data. Typically,
33 | * you'll want to handle most of your calculated/derived data in this step.
34 | * Data calculated in this step should generally not exist in template.json
35 | * (such as ability modifiers rather than ability scores) and should be
36 | * available both inside and outside of character sheets (such as if an actor
37 | * is queried and has a roll executed directly from it).
38 | */
39 | prepareDerivedData() {
40 | const actorData = this;
41 |
42 | // Make separate methods for each Actor type to keep things organized.
43 | this._prepareCharacterDerivedData(actorData);
44 | this._prepareMonsterDerivedData(actorData);
45 | this._prepareSiegeEngineDerivedData(actorData);
46 | this._prepareStrongholdDerivedData(actorData);
47 | this._prepareVehicleDerivedData(actorData);
48 | }
49 |
50 |
51 | /**
52 | * Prepare Character type template data
53 | */
54 | _prepareCharacterData(actorData) {
55 | if (actorData.type !== 'character') return;
56 | }
57 |
58 | /**
59 | * Prepare Character type derived data
60 | */
61 | _prepareCharacterDerivedData(actorData) {
62 | if (actorData.type !== 'character') return;
63 |
64 | // Make modifications to data here. For example:
65 | const data = actorData.system;
66 |
67 | // Loop through ability scores, and add their modifiers to our sheet output.
68 | for (let [key, ability] of Object.entries(data.abilities)) {
69 | // Calculate the ability bonus
70 | ability.bonus = this._calculateAbilityBonus(ability.value);
71 | }
72 | }
73 |
74 | /**
75 | * Determine ability score modifiers
76 | */
77 | _calculateAbilityBonus(abilityScore) {
78 | switch (abilityScore) {
79 | case 3: return -3;
80 | case 4:
81 | case 5: return -2;
82 | case 6:
83 | case 7:
84 | case 8: return -1;
85 | case 13:
86 | case 14:
87 | case 15: return 1;
88 | case 16:
89 | case 17: return 2;
90 | case 18: return 3;
91 | default: return 0;
92 | }
93 | }
94 |
95 |
96 | /**
97 | * Prepare Monster type template data.
98 | */
99 | _prepareMonsterData(actorData) {
100 | if (actorData.type !== 'monster') return;
101 |
102 | const data = actorData.system;
103 |
104 | // Handle changed label for monster special ability XP bonus -- this will be handled in the system data model when it's implemented
105 | data.specialAbility.label = 'BASICFANTASYRPG.SpecialAbilityXPBonus';
106 |
107 | data.xp.value = this._calculateMonsterXPValue();
108 | data.attackBonus.value = this._calculateMonsterAttackBonus();
109 | }
110 |
111 | /**
112 | * Calculate monster attack bonus
113 | */
114 | _calculateMonsterAttackBonus() {
115 | const hitDiceNumber = this.system.hitDice.number;
116 | if (hitDiceNumber < 1) {
117 | return 0;
118 | } else if (hitDiceNumber > 31) {
119 | return 16;
120 | }
121 | switch (hitDiceNumber) {
122 | case 9: return 8;
123 | case 10:
124 | case 11: return 9
125 | case 12:
126 | case 13: return 10;
127 | case 14:
128 | case 15: return 11;
129 | case 16:
130 | case 17:
131 | case 18:
132 | case 19: return 12;
133 | case 20:
134 | case 21:
135 | case 22:
136 | case 23: return 13;
137 | case 24:
138 | case 25:
139 | case 26:
140 | case 27: return 14;
141 | case 28:
142 | case 29:
143 | case 30:
144 | case 31: return 15;
145 | default: return hitDiceNumber; // this handles 1-9
146 | }
147 | }
148 |
149 | /**
150 | * Calculate Monster XP value
151 | */
152 | _calculateMonsterXPValue() {
153 | const hitDice = this.system.hitDice;
154 | const specialAbility = this.system.specialAbility.value;
155 | let xpLookup = [10, 25, 75, 145, 240, 360, 500, 670, 875, 1075, 1300, 1575, 1875, 2175, 2500, 2850, 3250, 3600, 4000, 4500, 5250, 6000, 6750, 7500, 8250, 9000];
156 | let specialAbilityLookup = [3, 12, 25, 30, 40, 45, 55, 65, 70, 75, 90, 95, 100, 110, 115, 125, 135, 145, 160, 175, 200, 225, 250, 275, 300, 325];
157 | let xpValue = 0;
158 | let xpSpecialAbilityBonus = 0;
159 | if (hitDice.number < 1 || (hitDice.number === 1 && hitDice.mod < 0) || hitDice.size < 'd8') {
160 | xpValue = xpLookup[0];
161 | xpSpecialAbilityBonus = specialAbilityLookup[0] * specialAbility;
162 | } else if (hitDice.number > 25) {
163 | xpValue = 9000 + (hitDice.number - 25) * 750;
164 | xpSpecialAbilityBonus = (325 + (hitDice.number - 25) * 25) * specialAbility;
165 | } else {
166 | xpValue = xpLookup[hitDice.number];
167 | xpSpecialAbilityBonus = specialAbilityLookup[hitDice.number] * specialAbility;
168 | }
169 | return xpValue + Math.max(0, xpSpecialAbilityBonus); // never return a negative special ability bonus
170 | }
171 |
172 | /**
173 | * Prepare Monster type derived data.
174 | */
175 | _prepareMonsterDerivedData(actorData) {
176 | if (actorData.type !== 'monster') return;
177 | }
178 |
179 |
180 | /**
181 | * Prepare Siege Engine type template data
182 | */
183 | _prepareSiegeEngineData(actorData) {
184 | if (actorData.type !== 'siegeEngine') return;
185 | }
186 |
187 | /**
188 | * Prepare Siege Engine type derived data
189 | */
190 | _prepareSiegeEngineDerivedData(actorData) {
191 | if (actorData.type !== 'siegeEngine') return;
192 | }
193 |
194 | /**
195 | * Prepare Stronghold type template data
196 | */
197 | _prepareStrongholdData(actorData) {
198 | if (actorData.type !== 'stronghold') return;
199 |
200 | const data = actorData.system;
201 | const floors = actorData.itemTypes.floor;
202 | const walls = actorData.itemTypes.wall;
203 |
204 | floors.forEach(floor => {
205 | switch (floor.system.material.value) {
206 | case 'roofSlate': floor.system.price.value = floor.system.area.value / 10 * 4; break;
207 | case 'roofWood': floor.system.price.value = floor.system.area.value / 10 * 2; break;
208 | case 'floor':
209 | case 'roofThatch':
210 | default: floor.system.price.value = floor.system.area.value / 10; break;
211 | }
212 | });
213 |
214 | walls.forEach(wall => {
215 | switch (wall.system.material.value) {
216 | case 'stoneHard':
217 | wall.system.hardness.value = 16;
218 | switch (wall.system.thickness.value) {
219 | case 15: wall.system.price.value = 350; break;
220 | case 10: wall.system.price.value = 260; break;
221 | case 5: wall.system.price.value = 90; break;
222 | default: wall.system.price.value = 40; break;
223 | }
224 | break;
225 | case 'stoneSoft':
226 | wall.system.hardness.value = 12;
227 | switch (wall.system.thickness.value) {
228 | case 10: wall.system.price.value = 200; break;
229 | case 5: wall.system.price.value = 70; break;
230 | default: wall.system.price.value = 30; break;
231 | }
232 | break;
233 | case 'brick':
234 | wall.system.hardness.value = 8;
235 | switch (wall.system.thickness.value) {
236 | case 5: wall.system.price.value = 50; break;
237 | default: wall.system.price.value = 20; break;
238 | }
239 | break;
240 | case 'wood':
241 | default:
242 | wall.system.hardness.value = 6;
243 | wall.system.thickness.value = 1;
244 | wall.system.price.value = 10;
245 | break;
246 | }
247 | wall.system.price.value *= wall.system.quantity.value;
248 | });
249 | }
250 |
251 | /**
252 | * Prepare Stronghold type derived data
253 | */
254 | _prepareStrongholdDerivedData(actorData) {
255 | if (actorData.type !== 'stronghold') return;
256 |
257 | const data = actorData.system;
258 | const floors = actorData.itemTypes.floor;
259 | const walls = actorData.itemTypes.wall;
260 |
261 | let totalCost = 0;
262 | let totalHeight = 0;
263 | floors.forEach(floor => {
264 | totalHeight += floor.system.height.value;
265 | totalCost += floor.system.price.value;
266 | });
267 | walls.forEach(wall => {
268 | totalCost += wall.system.price.value;
269 | });
270 |
271 | data.height = {
272 | "value": totalHeight,
273 | "label": 'BASICFANTASYRPG.Height'
274 | };
275 |
276 | data.cost = {
277 | "value": (totalCost + (totalCost * (totalHeight / 100))) * data.costMultiplier.value, // each 10' of height adds 10% to the costs in both time and money
278 | "label": 'BASICFANTASYRPG.Cost'
279 | };
280 |
281 | data.buildTime = {
282 | "value": Math.ceil(Math.max(data.cost.value / data.workers.value, Math.sqrt(data.cost.value))),
283 | "label": 'BASICFANTASYRPG.BuildTime'
284 | };
285 | }
286 |
287 |
288 | /**
289 | * Prepare Vehicle type template data
290 | */
291 | _prepareVehicleData(actorData) {
292 | if (actorData.type !== 'vehicle') return;
293 |
294 | const data = actorData.system;
295 | data.hitPoints.value = 0;
296 | data.hitPoints.max = 0;
297 |
298 | // Calculate totals for HP value and HP max
299 | for (let [key, side] of Object.entries(data.hitPoints)) {
300 | if (['forward', 'aft', 'port', 'starboard'].includes(key)) {
301 | data.hitPoints.value += side.value;
302 | data.hitPoints.max += side.max;
303 | }
304 | }
305 | }
306 |
307 | /**
308 | * Prepare Vehicle type derived data
309 | */
310 | _prepareVehicleDerivedData(actorData) {
311 | if (actorData.type !== 'vehicle') return;
312 |
313 | const data = actorData.system;
314 |
315 | // Check if any 1 or 2 sides are reduced to 0 HP
316 | let sidesAtZeroHP = 0;
317 | for (let [key, side] of Object.entries(data.hitPoints)) {
318 | if (['forward', 'aft', 'port', 'starboard'].includes(key) && side.value === 0 && side.max !== 0) {
319 | ++sidesAtZeroHP;
320 | }
321 | }
322 | if (sidesAtZeroHP === 1) {
323 | data.move.current = Math.floor(data.move.value / 2);
324 | } else if (sidesAtZeroHP > 1) {
325 | data.move.current = 0;
326 | } else {
327 | data.move.current = data.move.value;
328 | }
329 | }
330 |
331 |
332 | /**
333 | * Override getRollData() that's supplied to rolls.
334 | */
335 | getRollData() {
336 | const data = super.getRollData();
337 |
338 | // Prepare character roll data.
339 | this._getCharacterRollData(data);
340 | this._getMonsterRollData(data);
341 | this._getSiegeEngineRollData(data);
342 | this._getStrongholdRollData(data);
343 | this._getVehicleRollData(data);
344 | this._getActorRollData(data);
345 |
346 | return data;
347 | }
348 |
349 | /**
350 | * Prepare character roll data.
351 | */
352 | _getCharacterRollData(data) {
353 | if (this.type !== 'character') return;
354 |
355 | // Copy the ability scores to the top level, so that rolls can use
356 | // formulas like `@str.bonus + 4`.
357 | if (data.abilities) {
358 | for (let [k, v] of Object.entries(data.abilities)) {
359 | data[k] = foundry.utils.deepClone(v);
360 | }
361 | }
362 |
363 | // Add level for easier access, or fall back to 0.
364 | if (data.level) {
365 | data.lvl = data.level.value ?? 0;
366 | }
367 | }
368 |
369 | /**
370 | * Prepare NPC roll data.
371 | */
372 | _getMonsterRollData(data) {
373 | if (this.type !== 'monster') return;
374 |
375 | // Process additional NPC data here.
376 |
377 | }
378 |
379 | /**
380 | * Prepare Siege Engine roll data.
381 | */
382 | _getSiegeEngineRollData(data) {
383 | if (this.type !== 'siegeEngine') return;
384 |
385 | // Process additional Siege Engine data here.
386 |
387 | }
388 |
389 | /**
390 | * Prepare Stronghold roll data.
391 | */
392 | _getStrongholdRollData(data) {
393 | if (this.type !== 'stronghold') return;
394 |
395 | // Process additional Stronghold data here.
396 |
397 | }
398 |
399 | /**
400 | * Prepare Vehicle roll data.
401 | */
402 | _getVehicleRollData(data) {
403 | if (this.type !== 'vehicle') return;
404 |
405 | // Process additional Vehicle data here.
406 |
407 | }
408 |
409 | /**
410 | * Prepare shared Actor roll data.
411 | */
412 | _getActorRollData(data) {
413 | // Add attack bonus for easier access, or fall back to 0.
414 | if (data.attackBonus) {
415 | data.ab = data.attackBonus.value ?? 0;
416 | }
417 | }
418 | }
--------------------------------------------------------------------------------
/module/sheets/actor-sheet.mjs:
--------------------------------------------------------------------------------
1 | import {successChatMessage} from '../helpers/chat.mjs';
2 | import {onManageActiveEffect, prepareActiveEffectCategories} from '../helpers/effects.mjs';
3 |
4 | /**
5 | * Extend the basic ActorSheet with some very simple modifications
6 | * @extends {ActorSheet}
7 | */
8 | export class BasicFantasyRPGActorSheet extends ActorSheet {
9 |
10 | /** @override */
11 | static get defaultOptions() {
12 | return foundry.utils.mergeObject(super.defaultOptions, {
13 | classes: ['basicfantasyrpg', 'sheet', 'actor'],
14 | template: 'systems/basicfantasyrpg/templates/actor/actor-sheet.html',
15 | width: 600,
16 | height: 600,
17 | tabs: [{ navSelector: '.sheet-tabs', contentSelector: '.sheet-body', initial: 'combat' }]
18 | });
19 | }
20 |
21 | /** @override */
22 | get template() {
23 | return `systems/basicfantasyrpg/templates/actor/actor-${this.actor.type}-sheet.html`;
24 | }
25 |
26 | /* -------------------------------------------- */
27 |
28 | /** @override */
29 | async getData() {
30 | // Retrieve the data structure from the base sheet. You can inspect or log
31 | // the context variable to see the structure, but some key properties for
32 | // sheets are the actor object, the data object, whether or not it's
33 | // editable, the items array, and the effects array.
34 | const context = super.getData();
35 |
36 | //enrichedBiography -- enriches system.biography for editor
37 | context.enrichedBiography = await TextEditor.enrichHTML(this.object.system.biography, {async: true});
38 |
39 | // Use a safe clone of the actor data for further operations.
40 | const actorData = this.actor.toObject(false);
41 |
42 | // Add the actor's data to context.data for easier access, as well as flags.
43 | context.data = actorData.system;
44 | context.flags = actorData.flags;
45 |
46 | // Prepare character data and items.
47 | if (actorData.type === 'character') {
48 | this._prepareItems(context);
49 | this._prepareCharacterData(context);
50 | this._prepareActorData(context);
51 | }
52 |
53 | // Prepare NPC data and items.
54 | if (actorData.type === 'monster') {
55 | this._prepareItems(context);
56 | this._prepareActorData(context);
57 | }
58 |
59 | // Prepare Stronghold data and items
60 | if (actorData.type === 'stronghold') {
61 | this._prepareItems(context);
62 | }
63 |
64 | // Prepare Vehicle data and items
65 | if (actorData.type === 'vehicle') {
66 | this._prepareItems(context);
67 | }
68 |
69 | // Add roll data for TinyMCE editors.
70 | context.rollData = context.actor.getRollData();
71 |
72 | // Prepare active effects
73 | context.effects = prepareActiveEffectCategories(this.actor.effects);
74 |
75 | return context;
76 | }
77 |
78 | /**
79 | * Organize and classify Items for Actor sheets.
80 | *
81 | * @param {Object} actorData The actor to prepare.
82 | *
83 | * @return {undefined}
84 | */
85 | _prepareActorData(context) {
86 | // Handle saves.
87 | for (let [k, v] of Object.entries(context.data.saves)) {
88 | v.label = game.i18n.localize(CONFIG.BASICFANTASYRPG.saves[k]) ?? k;
89 | }
90 | }
91 |
92 | /**
93 | * Organize and classify Items for Character sheets.
94 | *
95 | * @param {Object} actorData The actor to prepare.
96 | *
97 | * @return {undefined}
98 | */
99 | _prepareCharacterData(context) {
100 | // Handle ability scores.
101 | for (let [k, v] of Object.entries(context.data.abilities)) {
102 | v.label = game.i18n.localize(CONFIG.BASICFANTASYRPG.abilities[k]) ?? k;
103 | }
104 | // Handle money.
105 | for (let [k, v] of Object.entries(context.data.money)) {
106 | v.label = game.i18n.localize(CONFIG.BASICFANTASYRPG.money[k]) ?? k;
107 | }
108 | }
109 |
110 | /**
111 | * Organize and classify Items for Actor sheets.
112 | *
113 | * @param {Object} actorData The actor to prepare.
114 | *
115 | * @return {undefined}
116 | */
117 | _prepareItems(context) {
118 | // Initialize containers.
119 | const gear = [];
120 | const weapons = [];
121 | const armors = [];
122 | const spells = {
123 | 1: [],
124 | 2: [],
125 | 3: [],
126 | 4: [],
127 | 5: [],
128 | 6: []
129 | };
130 | const features = [];
131 | const floors = [];
132 | const walls = [];
133 |
134 | // Define an object to store carried weight.
135 | let carriedWeight = {
136 | 'value': 0,
137 | _addWeight (moreWeight, quantity) {
138 | if (!quantity || quantity === '' || Number.isNaN(quantity) || quantity < 0) {
139 | return; // check we have a valid quantity, and do nothing if we do not
140 | }
141 | let q = Math.floor(quantity / 20);
142 | if (!Number.isNaN(parseFloat(moreWeight))) {
143 | this.value += parseFloat(moreWeight) * quantity;
144 | } else if (moreWeight === '*' && q > 0) { // '*' is gold pieces
145 | this.value += q;
146 | }
147 | }
148 | };
149 |
150 | // Iterate through items, allocating to containers
151 | for (let i of context.items) {
152 | i.img = i.img || DEFAULT_TOKEN;
153 | // Append to gear.
154 | if (i.type === 'item') {
155 | gear.push(i);
156 | carriedWeight._addWeight(i.system.weight.value, i.system.quantity.value);
157 | } else if (i.type === 'weapon') { // Append to weapons.
158 | weapons.push(i);
159 | carriedWeight._addWeight(i.system.weight.value, 1); // Weapons are always quantity 1
160 | } else if (i.type === 'armor') { // Append to armors.
161 | armors.push(i);
162 | carriedWeight._addWeight(i.system.weight.value, 1); // Armor is always quantity 1
163 | } else if (i.type === 'spell') { // Append to spells.
164 | if (i.system.spellLevel.value !== undefined) {
165 | spells[i.system.spellLevel.value].push(i);
166 | }
167 | } else if (i.type === 'feature') { // Append to features.
168 | features.push(i);
169 | } else if (i.type === 'floor') { // Append to floors for strongholds.
170 | floors.push(i);
171 | } else if (i.type === 'wall') { // Append to walls for strongholds.
172 | if (i.system.floor.value !== undefined) {
173 | if (!walls[i.system.floor.value]) walls[i.system.floor.value] = [];
174 | walls[i.system.floor.value].push(i);
175 | }
176 | }
177 | }
178 |
179 | // Iterate through money, add to carried weight
180 | if (context.data.money) {
181 | let gp = Number(context.data.money.gp.value);
182 | gp += context.data.money.pp.value;
183 | gp += context.data.money.ep.value;
184 | gp += context.data.money.sp.value;
185 | gp += context.data.money.cp.value;
186 | carriedWeight._addWeight('*', gp); // '*' will calculate GP weight
187 | }
188 |
189 | // Assign and return
190 | context.gear = gear;
191 | context.weapons = weapons;
192 | context.armors = armors;
193 | context.spells = spells;
194 | context.features = features;
195 | context.floors = floors;
196 | context.walls = walls;
197 | context.carriedWeight = Math.floor(carriedWeight.value); // we discard fractions of weight when we update the sheet
198 | }
199 |
200 | /* -------------------------------------------- */
201 |
202 | /** @override */
203 | activateListeners(html) {
204 | super.activateListeners(html);
205 |
206 | // Render the item sheet for viewing/editing prior to the editable check.
207 | html.find('.item-edit').click(ev => {
208 | const li = $(ev.currentTarget).parents('.item');
209 | const item = this.actor.items.get(li.data('itemId'));
210 | item.sheet.render(true);
211 | });
212 |
213 | // -------------------------------------------------------------
214 | // Everything below here is only needed if the sheet is editable
215 | if (!this.isEditable) return;
216 |
217 | // Add Inventory Item
218 | html.find('.item-create').click(this._onItemCreate.bind(this));
219 |
220 | // Delete Inventory Item
221 | html.find('.item-delete').click(ev => {
222 | const li = $(ev.currentTarget).parents('.item');
223 | const item = this.actor.items.get(li.data('itemId'));
224 | item.delete();
225 | li.slideUp(200, () => this.render(false));
226 | });
227 |
228 | // Prepare Spells
229 | html.find('.spell-prepare').click(ev => {
230 | const change = ev.currentTarget.dataset.change;
231 | if (parseInt(change)) {
232 | const li = $(ev.currentTarget).parents('.item');
233 | const item = this.actor.items.get(li.data('itemId'));
234 | let newValue = item.system.prepared.value + parseInt(change);
235 | item.update({'system.prepared.value': newValue});
236 | }
237 | });
238 |
239 | // Quantity
240 | html.find('.quantity').click(ev => {
241 | const change = ev.currentTarget.dataset.change;
242 | if (parseInt(change)) {
243 | const li = $(ev.currentTarget).parents('.item');
244 | const item = this.actor.items.get(li.data('itemId'));
245 | let newValue = item.system.quantity.value + parseInt(change);
246 | item.update({'system.quantity.value': newValue});
247 | }
248 | });
249 |
250 | // Active Effect management
251 | html.find('.effect-control').click(ev => onManageActiveEffect(ev, this.actor));
252 |
253 | // Rollable abilities.
254 | html.find('.rollable').click(this._onRoll.bind(this));
255 |
256 | // Siege Engine range bonuses
257 | if (this.actor.type === 'siegeEngine') {
258 | html.find('input[name="rangeBonus"]').click(ev => this.actor.update({'system.rangeBonus.value': Number(ev.currentTarget.value)}));
259 | }
260 |
261 | // Drag events for macros.
262 | if (this.actor.isOwner) {
263 | let handler = ev => this._onDragStart(ev);
264 | html.find('li.item').each((i, li) => {
265 | if (li.classList.contains('inventory-header')) return;
266 | li.setAttribute('draggable', true);
267 | li.addEventListener('dragstart', handler, false);
268 | });
269 | }
270 | }
271 |
272 | /**
273 | * Handle creating a new Owned Item for the actor using initial data defined in the HTML dataset
274 | * @param {Event} event The originating click event
275 | * @private
276 | */
277 | async _onItemCreate(event) {
278 | event.preventDefault();
279 | const header = event.currentTarget;
280 | // Get the type of item to create.
281 | const type = header.dataset.type;
282 | // Grab any data associated with this control.
283 | const data = foundry.utils.duplicate(header.dataset);
284 | if (type === 'spell') {
285 | // Move dataset spellLevelValue into spellLevel.value
286 | data.spellLevel = {
287 | 'value': data.spellLevelValue
288 | };
289 | delete data.spellLevelValue;
290 | } else if (type === 'wall') {
291 | data.floor = {
292 | "value": data.floorNumber
293 | };
294 | delete data.floorNumber;
295 | }
296 | // Initialize a default name.
297 | const name = `New ${type.capitalize()}`;
298 | // Prepare the item object.
299 | const itemData = {
300 | name: name,
301 | type: type,
302 | data: data
303 | };
304 | // Remove the type from the dataset since it's in the itemData.type prop.
305 | delete itemData.data['type'];
306 |
307 | // Finally, create the item!
308 | return await Item.create(itemData, {parent: this.actor});
309 | }
310 |
311 | /**
312 | * Handle clickable rolls.
313 | * @param {Event} event The originating click event
314 | * @private
315 | */
316 | async _onRoll(event) {
317 | event.preventDefault();
318 | const element = event.currentTarget;
319 | const dataset = element.dataset;
320 |
321 | if (dataset.rollType) {
322 | // Handle weapon rolls.
323 | if (dataset.rollType === 'weapon') {
324 | const itemId = element.closest('.item').dataset.itemId;
325 | const item = this.actor.items.get(itemId);
326 | let label = dataset.label ? `${game.i18n.localize('BASICFANTASYRPG.Roll')}: ${dataset.label}` : `${game.i18n.localize('BASICFANTASYRPG.Roll')}: ${dataset.attack.capitalize()} attack with ${item.name}`;
327 | let rollFormula = 'd20+@ab';
328 | if (this.actor.type === 'character') {
329 | if (dataset.attack === 'melee') {
330 | rollFormula += '+@str.bonus';
331 | } else if (dataset.attack === 'ranged') {
332 | rollFormula += '+@dex.bonus';
333 | }
334 | }
335 | rollFormula += '+' + item.system.bonusAb.value;
336 | let roll = new Roll(rollFormula, this.actor.getRollData());
337 | roll.toMessage({
338 | speaker: ChatMessage.getSpeaker({ actor: this.actor }),
339 | flavor: label,
340 | rollMode: game.settings.get('core', 'rollMode'),
341 | });
342 | return roll;
343 | }
344 |
345 | // Handle item rolls.
346 | if (dataset.rollType === 'item') {
347 | const itemId = element.closest('.item').dataset.itemId;
348 | const item = this.actor.items.get(itemId);
349 | if (item) return item.roll();
350 | }
351 | }
352 |
353 | // Handle rolls that supply the formula directly.
354 | if (dataset.roll) {
355 | let label = dataset.label ? `${game.i18n.localize('BASICFANTASYRPG.Roll')}: ${dataset.label}` : '';
356 | let roll = new Roll(dataset.roll, this.actor.getRollData());
357 | await roll.roll();
358 | label += successChatMessage(roll.total, dataset.targetNumber, dataset.rollUnder);
359 | roll.toMessage({
360 | speaker: ChatMessage.getSpeaker({ actor: this.actor }),
361 | flavor: label,
362 | rollMode: game.settings.get('core', 'rollMode'),
363 | });
364 | return roll;
365 | }
366 | }
367 | }
368 |
--------------------------------------------------------------------------------
/styles/basicfantasyrpg.css:
--------------------------------------------------------------------------------
1 | /* Custom Fonts */
2 | @font-face {
3 | font-family: 'Soutane';
4 | src: url('soutane-webfont.eot');
5 | src: url('soutane-webfont.eot?#iefix') format('embedded-opentype'),
6 | url('soutane-webfont.woff') format('woff'),
7 | url('soutane-webfont.ttf') format('truetype'),
8 | url('soutane-webfont.svg#soutaneregular') format('svg');
9 | font-weight: normal;
10 | font-style: normal;
11 | }
12 |
13 | @font-face {
14 | font-family: 'Soutane';
15 | src: url('soutanebold-webfont.eot');
16 | src: url('soutanebold-webfont.eot?#iefix') format('embedded-opentype'),
17 | url('soutanebold-webfont.woff') format('woff'),
18 | url('soutanebold-webfont.ttf') format('truetype'),
19 | url('soutanebold-webfont.svg#soutanebold') format('svg');
20 | font-weight: bold;
21 | font-style: normal;
22 | }
23 |
24 | @font-face {
25 | font-family: 'Soutane';
26 | src: url('soutanebolditalic-webfont.eot');
27 | src: url('soutanebolditalic-webfont.eot?#iefix') format('embedded-opentype'),
28 | url('soutanebolditalic-webfont.woff') format('woff'),
29 | url('soutanebolditalic-webfont.ttf') format('truetype'),
30 | url('soutanebolditalic-webfont.svg#soutanebold_italic') format('svg');
31 | font-weight: bold;
32 | font-style: italic;
33 | }
34 |
35 | @font-face {
36 | font-family: 'Soutane';
37 | src: url('soutaneitalic-webfont.eot');
38 | src: url('soutaneitalic-webfont.eot?#iefix') format('embedded-opentype'),
39 | url('soutaneitalic-webfont.woff') format('woff'),
40 | url('soutaneitalic-webfont.ttf') format('truetype'),
41 | url('soutaneitalic-webfont.svg#soutaneitalic') format('svg');
42 | font-weight: normal;
43 | font-style: italic;
44 | }
45 |
46 | @font-face {
47 | font-family: 'SoutaneBlack';
48 | src: url('soutaneblack-webfont.eot');
49 | src: url('soutaneblack-webfont.eot?#iefix') format('embedded-opentype'),
50 | url('soutaneblack-webfont.woff') format('woff'),
51 | url('soutaneblack-webfont.ttf') format('truetype'),
52 | url('soutaneblack-webfont.svg#soutaneblackregular') format('svg');
53 | font-weight: normal;
54 | font-style: normal;
55 | }
56 |
57 | @font-face {
58 | font-family: 'TeX Gyre Adventor';
59 | src: url('texgyreadventor-regular-webfont.eot');
60 | src: url('texgyreadventor-regular-webfont.eot?#iefix') format('embedded-opentype'),
61 | url('texgyreadventor-regular-webfont.woff') format('woff'),
62 | url('texgyreadventor-regular-webfont.ttf') format('truetype'),
63 | url('texgyreadventor-regular-webfont.svg#tex_gyre_adventorregular') format('svg');
64 | font-weight: normal;
65 | font-style: normal;
66 | }
67 |
68 | @font-face {
69 | font-family: 'TeX Gyre Adventor';
70 | src: url('texgyreadventor-italic-webfont.eot');
71 | src: url('texgyreadventor-italic-webfont.eot?#iefix') format('embedded-opentype'),
72 | url('texgyreadventor-italic-webfont.woff') format('woff'),
73 | url('texgyreadventor-italic-webfont.ttf') format('truetype'),
74 | url('texgyreadventor-italic-webfont.svg#tex_gyre_adventoritalic') format('svg');
75 | font-weight: normal;
76 | font-style: italic;
77 | }
78 |
79 | @font-face {
80 | font-family: 'TeX Gyre Adventor';
81 | src: url('texgyreadventor-bold-webfont.eot');
82 | src: url('texgyreadventor-bold-webfont.eot?#iefix') format('embedded-opentype'),
83 | url('texgyreadventor-bold-webfont.woff') format('woff'),
84 | url('texgyreadventor-bold-webfont.ttf') format('truetype'),
85 | url('texgyreadventor-bold-webfont.svg#tex_gyre_adventorbold') format('svg');
86 | font-weight: bold;
87 | font-style: normal;
88 | }
89 |
90 | @font-face {
91 | font-family: 'TeX Gyre Adventor';
92 | src: url('texgyreadventor-bolditalic-webfont.eot');
93 | src: url('texgyreadventor-bolditalic-webfont.eot?#iefix') format('embedded-opentype'),
94 | url('texgyreadventor-bolditalic-webfont.woff') format('woff'),
95 | url('texgyreadventor-bolditalic-webfont.ttf') format('truetype'),
96 | url('texgyreadventor-bolditalic-webfont.svg#tex_gyre_adventorbold_italic') format('svg');
97 | font-weight: bold;
98 | font-style: italic;
99 | }
100 |
101 | /* Global styles */
102 | @layer variables.base {
103 | body {
104 | --font-body: "Soutane", "Century Gothic", "TeX Gyre Adventor", var(--font-sans);
105 | --font-primary: "Soutane", "Century Gothic", "TeX Gyre Adventor", var(--font-sans);
106 | --font-h1: "Soutane", "Century Gothic", "TeX Gyre Adventor", var(--font-sans);
107 | --font-h2: "Century Gothic", "TeX Gyre Adventor", var(--font-sans);
108 | --font-h3: "Soutane", "Century Gothic", "TeX Gyre Adventor", var(--font-sans);
109 | }
110 |
111 | body .game .app {
112 | --font-primary: "Soutane", "Century Gothic", "TeX Gyre Adventor", var(--font-sans);
113 | }
114 | }
115 |
116 | .rollable:hover,
117 | .rollable:focus {
118 | color: #000;
119 | text-shadow: 0 0 10px red;
120 | cursor: pointer;
121 | }
122 |
123 | .chat-message,
124 | .chat-message h4 {
125 | font-family: "Century Gothic", "TeX Gyre Adventor", var(--font-sans);
126 | }
127 |
128 | .chat-message .chat-item-name {
129 | color: black;
130 | display: block;
131 | font-size: 14px;
132 | font-weight: bold;
133 | text-shadow: 1px 1px 2px #aaa;
134 | }
135 |
136 | .chat-message .chat-item-description {
137 | /* font-family: "Soutane", "Century Gothic", "TeX Gyre Adventor", var(--font-sans); */
138 | font-size: 16px;
139 | }
140 |
141 | .basicfantasyrpg .success-text,
142 | .chat-message .chat-item-description .chat-roll-success {
143 | color: green;
144 | font-variant: small-caps;
145 | font-weight: bold;
146 | text-shadow: 0 0 2px;
147 | }
148 |
149 | .basicfantasyrpg .failure-text,
150 | .chat-message .chat-item-description .chat-roll-failure {
151 | color: darkred;
152 | font-variant: small-caps;
153 | font-weight: bold;
154 | text-shadow: 0 0 2px;
155 | }
156 |
157 | .chat-message .chat-item-description .chat-roll-target-number {
158 | font-weight: bold;
159 | text-shadow: 0 0 2px;
160 | }
161 |
162 | .grid,
163 | .grid-2col {
164 | display: grid;
165 | grid-column: span 2 / span 2;
166 | grid-template-columns: repeat(2, minmax(0, 1fr));
167 | gap: 10px;
168 | margin: 10px 0;
169 | padding: 0;
170 | }
171 |
172 | .grid-3col {
173 | grid-column: span 3 / span 3;
174 | grid-template-columns: repeat(3, minmax(0, 1fr));
175 | }
176 |
177 | .grid-4col {
178 | grid-column: span 4 / span 4;
179 | grid-template-columns: repeat(4, minmax(0, 1fr));
180 | }
181 |
182 | .grid-5col {
183 | grid-column: span 5 / span 5;
184 | grid-template-columns: repeat(5, minmax(0, 1fr));
185 | }
186 |
187 | .grid-6col {
188 | grid-column: span 6 / span 6;
189 | grid-template-columns: repeat(6, minmax(0, 1fr));
190 | }
191 |
192 | .grid-7col {
193 | grid-column: span 7 / span 7;
194 | grid-template-columns: repeat(7, minmax(0, 1fr));
195 | }
196 |
197 | .grid-8col {
198 | grid-column: span 8 / span 8;
199 | grid-template-columns: repeat(8, minmax(0, 1fr));
200 | }
201 |
202 | .grid-9col {
203 | grid-column: span 9 / span 9;
204 | grid-template-columns: repeat(9, minmax(0, 1fr));
205 | }
206 |
207 | .grid-10col {
208 | grid-column: span 10 / span 10;
209 | grid-template-columns: repeat(10, minmax(0, 1fr));
210 | }
211 |
212 | .grid-11col {
213 | grid-column: span 11 / span 11;
214 | grid-template-columns: repeat(11, minmax(0, 1fr));
215 | }
216 |
217 | .grid-12col {
218 | grid-column: span 12 / span 12;
219 | grid-template-columns: repeat(12, minmax(0, 1fr));
220 | }
221 |
222 | .grid-start-2 {
223 | grid-column-start: 2;
224 | }
225 |
226 | .grid-start-3 {
227 | grid-column-start: 3;
228 | }
229 |
230 | .grid-start-4 {
231 | grid-column-start: 4;
232 | }
233 |
234 | .grid-start-5 {
235 | grid-column-start: 5;
236 | }
237 |
238 | .grid-start-6 {
239 | grid-column-start: 6;
240 | }
241 |
242 | .grid-start-7 {
243 | grid-column-start: 7;
244 | }
245 |
246 | .grid-start-8 {
247 | grid-column-start: 8;
248 | }
249 |
250 | .grid-start-9 {
251 | grid-column-start: 9;
252 | }
253 |
254 | .grid-start-10 {
255 | grid-column-start: 10;
256 | }
257 |
258 | .grid-start-11 {
259 | grid-column-start: 11;
260 | }
261 |
262 | .grid-start-12 {
263 | grid-column-start: 12;
264 | }
265 |
266 | .grid-span-2 {
267 | grid-column-end: span 2;
268 | }
269 |
270 | .grid-span-3 {
271 | grid-column-end: span 3;
272 | }
273 |
274 | .grid-span-4 {
275 | grid-column-end: span 4;
276 | }
277 |
278 | .grid-span-5 {
279 | grid-column-end: span 5;
280 | }
281 |
282 | .grid-span-6 {
283 | grid-column-end: span 6;
284 | }
285 |
286 | .grid-span-7 {
287 | grid-column-end: span 7;
288 | }
289 |
290 | .grid-span-8 {
291 | grid-column-end: span 8;
292 | }
293 |
294 | .grid-span-9 {
295 | grid-column-end: span 9;
296 | }
297 |
298 | .grid-span-10 {
299 | grid-column-end: span 10;
300 | }
301 |
302 | .grid-span-11 {
303 | grid-column-end: span 11;
304 | }
305 |
306 | .grid-span-12 {
307 | grid-column-end: span 12;
308 | }
309 |
310 | .flex-group-center,
311 | .flex-group-left,
312 | .flex-group-right {
313 | -webkit-box-pack: center;
314 | -ms-flex-pack: center;
315 | justify-content: center;
316 | -webkit-box-align: center;
317 | -ms-flex-align: center;
318 | align-items: center;
319 | text-align: center;
320 | }
321 |
322 | .flex-group-left {
323 | -webkit-box-pack: start;
324 | -ms-flex-pack: start;
325 | justify-content: flex-start;
326 | text-align: left;
327 | }
328 |
329 | .flex-group-right {
330 | -webkit-box-pack: end;
331 | -ms-flex-pack: end;
332 | justify-content: flex-end;
333 | text-align: right;
334 | }
335 |
336 | .flexshrink {
337 | -webkit-box-flex: 0;
338 | -ms-flex: 0;
339 | flex: 0;
340 | }
341 |
342 | .flex-between {
343 | -webkit-box-pack: justify;
344 | -ms-flex-pack: justify;
345 | justify-content: space-between;
346 | }
347 |
348 | .flexlarge {
349 | -webkit-box-flex: 2;
350 | -ms-flex: 2;
351 | flex: 2;
352 | }
353 |
354 | .flex-align-center {
355 | align-self: center;
356 | }
357 |
358 | .align-left {
359 | -webkit-box-pack: start;
360 | -ms-flex-pack: start;
361 | justify-content: flex-start;
362 | text-align: left;
363 | }
364 |
365 | .align-right {
366 | -webkit-box-pack: end;
367 | -ms-flex-pack: end;
368 | justify-content: flex-end;
369 | text-align: right;
370 | }
371 |
372 | .align-center {
373 | -webkit-box-pack: center;
374 | -ms-flex-pack: center;
375 | justify-content: center;
376 | text-align: center;
377 | }
378 |
379 | .vertical-line {
380 | border: none;
381 | border-left: 1px solid var(--color-border-light-primary);
382 | border-right: 1px solid var(--color-border-light-highlight);
383 | width: 0;
384 | }
385 |
386 | /* Styles limited to basicfantasyrpg sheets */
387 |
388 | .basicfantasyrpg.sheet.actor {
389 | font-family: "Century Gothic", "TeX Gyre Adventor", "Soutane", var(--font-sans);
390 | }
391 |
392 | .basicfantasyrpg .sheet-header {
393 | -webkit-box-flex: 0;
394 | -ms-flex: 0 auto;
395 | flex: 0 auto;
396 | overflow: hidden;
397 | display: -webkit-box;
398 | display: -ms-flexbox;
399 | display: flex;
400 | -webkit-box-orient: horizontal;
401 | -webkit-box-direction: normal;
402 | -ms-flex-direction: row;
403 | flex-direction: row;
404 | -ms-flex-wrap: wrap;
405 | flex-wrap: wrap;
406 | -webkit-box-pack: start;
407 | -ms-flex-pack: start;
408 | justify-content: flex-start;
409 | margin-bottom: 10px;
410 | }
411 |
412 | .basicfantasyrpg .sheet-header .profile-img {
413 | -webkit-box-flex: 0;
414 | -ms-flex: 0 0 100px;
415 | flex: 0 0 100px;
416 | height: 100px;
417 | margin-right: 10px;
418 | }
419 |
420 | .basicfantasyrpg .sheet-header .header-fields {
421 | -webkit-box-flex: 1;
422 | -ms-flex: 1;
423 | flex: 1;
424 | }
425 |
426 | .basicfantasyrpg .sheet-header h1.charname {
427 | height: 50px;
428 | padding: 0px;
429 | margin: 5px 0;
430 | border-bottom: 0;
431 | }
432 |
433 | .basicfantasyrpg .sheet-header h1.charname input {
434 | width: 100%;
435 | height: 100%;
436 | margin: 0;
437 | }
438 |
439 | .basicfantasyrpg .sheet-tabs {
440 | -webkit-box-flex: 0;
441 | -ms-flex: 0;
442 | flex: 0;
443 | }
444 |
445 | .basicfantasyrpg .sheet-body,
446 | .basicfantasyrpg .sheet-body .description,
447 | .basicfantasyrpg .sheet-body .editor,
448 | .basicfantasyrpg .sheet-body .tab,
449 | .basicfantasyrpg .sheet-body .tab .editor {
450 | height: calc(100% - 2px);
451 | }
452 |
453 | .basicfantasyrpg .sheet-body .tab.biography {
454 | max-height: calc(100% - 53px);
455 | }
456 |
457 | .basicfantasyrpg .editor-content {
458 | font-family: "Soutane", "Century Gothic", "TeX Gyre Adventor", var(--font-sans);
459 | font-size: 18px;
460 | overflow-y: hidden;
461 | }
462 |
463 | .basicfantasyrpg .tox .tox-editor-container {
464 | background: #fff;
465 | }
466 |
467 | .basicfantasyrpg .tox .tox-edit-area {
468 | padding: 0 8px;
469 | }
470 |
471 | .basicfantasyrpg .resource-content {
472 | white-space: nowrap;
473 | }
474 |
475 | .basicfantasyrpg .resource-label {
476 | font-weight: bold;
477 | }
478 |
479 | .basicfantasyrpg .items-header {
480 | height: 28px;
481 | margin: 2px 0;
482 | padding: 0;
483 | -webkit-box-align: center;
484 | -ms-flex-align: center;
485 | align-items: center;
486 | background: rgba(0, 0, 0, 0.05);
487 | border: 2px groove #eeede0;
488 | font-weight: bold;
489 | }
490 |
491 | .basicfantasyrpg .items-header>* {
492 | font-size: 14px;
493 | text-align: center;
494 | }
495 |
496 | .basicfantasyrpg .items-header .item-name {
497 | font-weight: bold;
498 | padding-left: 5px;
499 | text-align: left;
500 | display: -webkit-box;
501 | display: -ms-flexbox;
502 | display: flex;
503 | }
504 |
505 | .basicfantasyrpg .items-list {
506 | list-style: none;
507 | margin: 0;
508 | padding: 0;
509 | overflow-y: auto;
510 | scrollbar-width: thin;
511 | color: #444;
512 | }
513 |
514 | .basicfantasyrpg .items-list .item-list {
515 | list-style: none;
516 | margin: 0;
517 | padding: 0;
518 | }
519 |
520 | .basicfantasyrpg .items-list .item-name {
521 | -webkit-box-flex: 2;
522 | -ms-flex: 2;
523 | flex: 2;
524 | margin: 0;
525 | overflow: hidden;
526 | font-size: 13px;
527 | text-align: left;
528 | -webkit-box-align: center;
529 | -ms-flex-align: center;
530 | align-items: center;
531 | display: -webkit-box;
532 | display: -ms-flexbox;
533 | display: flex;
534 | }
535 |
536 | .basicfantasyrpg .items-list .item-detail {
537 | -webkit-box-flex: 1;
538 | -ms-flex: 1;
539 | flex: 1;
540 | margin: 0;
541 | overflow: hidden;
542 | font-size: 13px;
543 | text-align: left;
544 | -webkit-box-align: center;
545 | -ms-flex-align: center;
546 | align-items: center;
547 | display: -webkit-box;
548 | display: -ms-flexbox;
549 | display: flex;
550 | }
551 |
552 | .basicfantasyrpg .items-list .item-name h3,
553 | .basicfantasyrpg .items-list .item-name h4 {
554 | margin: 0;
555 | white-space: nowrap;
556 | overflow-x: hidden;
557 | font-family: "Century Gothic", "TeX Gyre Adventor", var(--font-sans);
558 | }
559 |
560 | .basicfantasyrpg .items-list .item-controls {
561 | display: -webkit-box;
562 | display: -ms-flexbox;
563 | display: flex;
564 | -webkit-box-flex: 0;
565 | -ms-flex: 0 0 100px;
566 | flex: 0 0 100px;
567 | -webkit-box-pack: end;
568 | -ms-flex-pack: end;
569 | justify-content: flex-end;
570 | }
571 |
572 | .basicfantasyrpg .items-list .item-controls a {
573 | font-size: 12px;
574 | text-align: center;
575 | margin: 0 6px;
576 | }
577 |
578 | .basicfantasyrpg .items-list .item {
579 | -webkit-box-align: center;
580 | -ms-flex-align: center;
581 | align-items: center;
582 | padding: 0 2px;
583 | border-bottom: 1px solid #c9c7b8;
584 | }
585 |
586 | .basicfantasyrpg .items-list .item:last-child {
587 | border-bottom: none;
588 | }
589 |
590 | .basicfantasyrpg .items-list .item .item-name {
591 | color: #191813;
592 | }
593 |
594 | .basicfantasyrpg .items-list .item .item-name .item-image {
595 | -webkit-box-flex: 0;
596 | -ms-flex: 0 0 30px;
597 | flex: 0 0 30px;
598 | height: 30px;
599 | background-size: 30px;
600 | border: none;
601 | margin-right: 5px;
602 | }
603 |
604 | .basicfantasyrpg .items-list .item-prop {
605 | text-align: center;
606 | border-left: 1px solid #c9c7b8;
607 | border-right: 1px solid #c9c7b8;
608 | font-size: 12px;
609 | }
610 |
611 | .basicfantasyrpg .items-list .item .item-name .item-image img,
612 | .basicfantasyrpg .items-list .item-prop img,
613 | .basicfantasyrpg .resources img {
614 | border: none;
615 | vertical-align: middle;
616 | }
617 |
618 | .basicfantasyrpg .items-list .items-header {
619 | height: 28px;
620 | margin: 2px 0;
621 | padding: 0;
622 | -webkit-box-align: center;
623 | -ms-flex-align: center;
624 | align-items: center;
625 | background: rgba(0, 0, 0, 0.05);
626 | border: 2px groove #eeede0;
627 | font-weight: bold;
628 | }
629 |
630 | .basicfantasyrpg .items-list .items-header>* {
631 | font-size: 12px;
632 | text-align: center;
633 | }
634 |
635 | .basicfantasyrpg .items-list .items-header .item-name {
636 | padding-left: 5px;
637 | text-align: left;
638 | }
639 |
640 | .basicfantasyrpg .item-detail {
641 | -webkit-box-flex: 0;
642 | -ms-flex: 0 0 200px;
643 | flex: 0 0 200px;
644 | padding: 0 8px;
645 | }
646 |
647 | .basicfantasyrpg .effects .item .effect-source,
648 | .basicfantasyrpg .effects .item .effect-duration,
649 | .basicfantasyrpg .effects .item .effect-controls {
650 | text-align: center;
651 | border-left: 1px solid #c9c7b8;
652 | border-right: 1px solid #c9c7b8;
653 | font-size: 12px;
654 | }
655 |
656 | .basicfantasyrpg .effects .item .effect-controls {
657 | border: none;
658 | }
659 |
--------------------------------------------------------------------------------