public/foundryvtt-reve-de-dragon
1
1
Fork 1
Code Issues 4 Pull Requests Projects Releases 140 Wiki Activity

Améliorations du combat

Browse Source 
- nettoyage des infos et messages de combat améliorés
- message de status envoyé uniquement par le GM (pour éviter les
doublons)
- stockage des infos de passes d'armes géré par RdDCombat

Déplacement des Hooks/notifications de messages socket:
- liés au combat dans la méthode RdDCombat.init

Convention de nommage: les méthodes de gestion de notification par
hook/socket sont préfixées 'on'
ex: onSocketMessage, onUpdateCombat, onPreDeleteCombat
This commit is contained in:
Vincent Vandemeulebrouck 2021-01-10 00:30:37 +01:00
parent ad00a3f700
commit 3f62582af5
8 changed files with 189 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
module/actor.js
View File

@ -25,7 +25,9 @@ import { RdDAlchimie } from "./rdd-alchimie.js";
* @extends {Actor}
*/
export class RdDActor extends Actor {
/* -------------------------------------------- */
static init() {
}
/* -------------------------------------------- */
/**
* Override the create() function to provide additional RdD functionality.
@ -2196,15 +2198,15 @@ export class RdDActor extends Actor {
}
/* -------------------------------------------- */
async encaisserDommages(attackerRoll, attacker = undefined) {
async encaisserDommages(rollData, attacker = undefined) {
if (attacker && !await attacker.accorder(this, 'avant-encaissement')) {
return;
}
console.log("encaisserDommages", attackerRoll)
console.log("encaisserDommages", rollData)
let santeOrig = duplicate(this.data.data.sante);
let encaissement = this.jetEncaissement(attackerRoll);
let encaissement = this.jetEncaissement(rollData);
this.ajouterBlessure(encaissement); // Will upate the result table
const perteVie = await this.santeIncDec("vie", - encaissement.vie);
@ -2513,7 +2515,6 @@ export class RdDActor extends Actor {
}
}
/* -------------------------------------------- */
_alchimieResult(rollData) {
RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-alchimie.html');

123
module/rdd-combat.js
View File

@ -9,6 +9,67 @@ import { RdDRollTables } from "./rdd-rolltables.js";
export class RdDCombat {
static init() {
this.initStorePasseArmes();
Hooks.on("updateCombat", (combat, data) => { RdDCombat.onUpdateCombat(combat, data) });
Hooks.on("preDeleteCombat", (combat, options) => { RdDCombat.onPreDeleteCombat(combat, options); });
}
/* -------------------------------------------- */
static initStorePasseArmes() {
game.system.rdd.combatStore = {
attaques: {},
defenses: {}
};
}
/* -------------------------------------------- */
static onSocketMessage(sockmsg) {
switch (sockmsg.msg) {
case "msg_encaisser":
return RdDCombat.terminerPasseArmes(data);
case "msg_defense":
return RdDCombat.handleMsgDefense(sockmsg.data);
}
}
/* -------------------------------------------- */
static onUpdateCombat(combat, data) {
if (combat.data.round != 0 && combat.turns && combat.data.active) {
RdDCombat.combatNouveauRound(combat);
}
}
/* -------------------------------------------- */
static onPreDeleteCombat(combat, options) {
if (game.user.isGM) {
ChatUtility.removeMyChatMessageContaining(`<div data-combatid="${combat.id}" data-combatmessage="actor-turn-summary">`)
/*
* TODO: support de plusieurs combats parallèles
* il faudrait avoir un id de combat en plus de celui de passe d'armes
*/
for (const key in game.system.rdd.combatStore.attaques) {
const attackerRoll = game.system.rdd.combatStore.attaques[key];
ChatUtility.removeChatMessageActionsPasseArme(`<div data-passearme="${attackerRoll.passeArme}">`);
}
for (const key in game.system.rdd.combatStore.defenses) {
const defenderRoll = game.system.rdd.combatStore.defenses[key];
ChatUtility.removeMyChatMessageContaining(`<div data-passearme="${defenderRoll.passeArme}">`);
}
RdDCombat.initStorePasseArmes();
}
}
/* -------------------------------------------- */
static combatNouveauRound(combat) {
let turn = combat.turns.find(t => t.tokenId == combat.current.tokenId);
if (game.user.isGM) {
// seul le GM notifie le status
this.displayActorCombatStatus(combat, turn.actor);
// TODO Playaudio for player??
}
}
/* -------------------------------------------- */
static isActive() {
return true;
@ -58,6 +119,33 @@ export class RdDCombat {
return RdDCombat.createUsingTarget(attacker)
}
/* -------------------------------------------- */
static handleMsgDefense(data) {
let defenderToken = canvas.tokens.get(data.defenderTokenId);
if (defenderToken) {
if (!game.user.isGM && game.user.character == undefined) { // vérification / sanity check
ui.notifications.error("Le joueur " + game.user.name + " n'est connecté à aucun personnage. Impossible de continuer.");
return;
}
if ((game.user.isGM && !defenderToken.actor.hasPlayerOwner) || (defenderToken.actor.hasPlayerOwner && (game.user.character.id == defenderToken.actor.data._id))) {
//console.log("User is pushing message...", game.user.name);
game.system.rdd.combatStore.attaques[data.attackerId] = duplicate(data.rollData);
data.whisper = [game.user];
data.blind = true;
data.rollMode = "blindroll";
ChatMessage.create(data);
}
}
}
static terminerPasseArmes(data) {
if (game.user.isGM) { // Seul le GM nettoie le stockage des données de combat
let attackerRoll = game.system.rdd.combatStore.attaques[data.attackerId]; // Retrieve the rolldata from the store
game.system.rdd.combatStore.attaques[data.attackerId] = undefined;
game.system.rdd.combatStore.defenses[attackerRoll.passeArme] = undefined;
}
}
/* -------------------------------------------- */
static _sendRollMessage(sender, recipient, defenderTokenId, topic, message, rollData) {
let chatMessage = {
@ -129,7 +217,7 @@ export class RdDCombat {
/* -------------------------------------------- */
async onEvent(button, event) {
let attackerRoll = game.system.rdd.rollDataHandler.attaques[this.attackerId];
let attackerRoll = game.system.rdd.combatStore.attaques[this.attackerId];
if (!attackerRoll) {
ui.notifications.warn("Action automatisée impossible, le jet de l'attaquant a été perdu (suite à un raffraichissement?)")
return;
@ -163,18 +251,18 @@ export class RdDCombat {
/* -------------------------------------------- */
_consumeDefense(passeArme) {
let defenderRoll = this._getDefense(passeArme);
game.system.rdd.rollDataHandler.defenses[passeArme] = undefined;
game.system.rdd.combatStore.defenses[passeArme] = undefined;
return defenderRoll;
}
/* -------------------------------------------- */
_getDefense(passeArme) {
return game.system.rdd.rollDataHandler.defenses[passeArme];
return game.system.rdd.combatStore.defenses[passeArme];
}
/* -------------------------------------------- */
_storeDefense(defenderRoll) {
game.system.rdd.rollDataHandler.defenses[defenderRoll.passeArme] = defenderRoll;
game.system.rdd.combatStore.defenses[defenderRoll.passeArme] = defenderRoll;
}
/* -------------------------------------------- */
@ -320,7 +408,7 @@ export class RdDCombat {
/* -------------------------------------------- */
async _onAttaqueParticuliere(rollData) {
game.system.rdd.rollDataHandler.attaques[this.attackerId] = duplicate(rollData);
game.system.rdd.combatStore.attaques[this.attackerId] = duplicate(rollData);
// Finesse et Rapidité seulement en mêlée et si la difficulté libre est de -1 minimum
const isMeleeDiffNegative = rollData.selectedCarac.label == "Mêlée" && rollData.diffLibre < 0;
@ -342,7 +430,7 @@ export class RdDCombat {
attackerRoll.dmg = RdDBonus.dmg(attackerRoll, this.attacker.getBonusDegat(), this.defender.isEntiteCauchemar());
// Save rollData for defender
game.system.rdd.rollDataHandler.attaques[this.attackerId] = duplicate(attackerRoll);
game.system.rdd.combatStore.attaques[this.attackerId] = duplicate(attackerRoll);
attackerRoll.show = {
cible: this.target ? this.defender.data.name : 'la cible',
@ -401,7 +489,7 @@ export class RdDCombat {
/* -------------------------------------------- */
async _onAttaqueEchecTotal(attackerRoll) {
game.system.rdd.rollDataHandler.attaques[this.attackerId] = duplicate(attackerRoll);
game.system.rdd.combatStore.attaques[this.attackerId] = duplicate(attackerRoll);
// Finesse et Rapidité seulement en mêlée et si la difficulté libre est de -1 minimum
ChatMessage.create({
@ -755,8 +843,9 @@ export class RdDCombat {
}
/* -------------------------------------------- */
static async displayActorCombatStatus(actor) {
let rollData = {
static async displayActorCombatStatus(combat, actor) {
let data = {
combatId: combat._id,
alias: actor.name,
etatGeneral: actor.getEtatGeneral(),
isSonne: actor.getSonne(),
@ -767,22 +856,14 @@ export class RdDCombat {
isCritique: false
}
if (actor.countBlessuresByName("critiques") > 0) { // Pour éviter le cumul grave + critique
rollData.isCritique = true;
data.isCritique = true;
} else if (actor.countBlessuresByName("graves") > 0) {
rollData.isGrave = true;
data.isGrave = true;
}
ChatUtility.createChatWithRollMode(actor.name, {
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-turn-summary.html`, rollData)
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-turn-summary.html`, data)
});
}
/* -------------------------------------------- */
static updateCombatRound(combat, data) {
if (combat.data.round != 0 && combat.turns && combat.data.active) {
let turn = combat.turns.find(t => t.tokenId == combat.current.tokenId);
this.displayActorCombatStatus(turn.actor);
// TODO Playaudio ??
}
}
}

34
module/rdd-main.js
View File

@ -103,13 +103,8 @@ Hooks.once("init", async function() {
// preload handlebars templates
RdDUtility.preloadHandlebarsTemplates();
// Create useful storage space
game.system.rdd = {
rollDataHandler: {
attaques: {},
defenses: {}
},
TMRUtility: TMRUtility
}
@ -190,7 +185,8 @@ Hooks.once("init", async function() {
/* -------------------------------------------- */
game.socket.on("system.foundryvtt-reve-de-dragon", data => {
RdDUtility.performSocketMesssage( data );
RdDUtility.onSocketMesssage(data);
RdDCombat.onSocketMessage(data);
});
/* -------------------------------------------- */
@ -208,7 +204,8 @@ Hooks.once("init", async function() {
Actors.unregisterSheet("core", ActorSheet);
Actors.registerSheet("foundryvtt-reve-de-dragon", RdDActorSheet, {
types: ["personnage"],
makeDefault: true }
makeDefault: true
}
);
Actors.registerSheet("foundryvtt-reve-de-dragon", RdDActorCreatureSheet, {
types: ["creature"],
@ -230,6 +227,11 @@ Hooks.once("init", async function() {
// Patch the initiative formula
_patch_initiative();
// préparation des différents modules
RdDCommands.init();
RdDCombat.init();
RdDTokenHud.init();
});
/* -------------------------------------------- */
@ -244,18 +246,10 @@ function messageDeBienvenue(){
` });
}
/* -------------------------------------------- */
Hooks.once("renderApplication", () => {
messageDeBienvenue();
});
/* -------------------------------------------- */
/* Foundry VTT Initialization */
/* -------------------------------------------- */
Hooks.once("ready", function () {
// préparation des lignes de commandes
RdDCommands.init();
/* -------------------------------------------- */
/* Affiche/Init le calendrier */
let calendrier = new RdDCalendrier();
@ -270,14 +264,14 @@ Hooks.once("ready", function() {
// Avertissement si joueur sans personnage
if (!game.user.isGM && game.user.character == undefined) {
ui.notifications.info("Attention ! Vous n'êtes connecté à aucun personnage !");
ChatMessage.create( { content:"<b>ATTENTION</b> Le joueur " + game.user.name + " n'est connecté à aucun personnage !",
user: game.user._id } );
ChatMessage.create({
content: "<b>ATTENTION</b> Le joueur " + game.user.name + " n'est connecté à aucun personnage !",
user: game.user._id
});
//whisper: [ ChatMessage.getWhisperRecipients("GM") ] } );
}
// Integration du TokenHUD
Hooks.on('renderTokenHUD', (app, html, data) => { RdDTokenHud.addTokenHudExtensions(app, html, data._id) });
Hooks.on("updateCombat", (combat, data) => { RdDCombat.updateCombatRound(combat, data) } );
messageDeBienvenue();
});
/* -------------------------------------------- */

5
module/rdd-token-hud.js
View File

@ -5,6 +5,11 @@ import { RdDUtility } from "./rdd-utility.js";
/* -------------------------------------------- */
export class RdDTokenHud {
static init(){
// Integration du TokenHUD
Hooks.on('renderTokenHUD', (app, html, data) => { RdDTokenHud.addTokenHudExtensions(app, html, data._id) });
}
/* -------------------------------------------- */
static async removeExtensionHud( app, html, tokenId) {
let combat = html.find('.control-icon.rdd-combat');

30
module/rdd-utility.js
View File

@ -629,13 +629,11 @@ export class RdDUtility {
}
/* -------------------------------------------- */
static performSocketMesssage(sockmsg) {
static onSocketMesssage(sockmsg) {
console.log(">>>>> MSG RECV", sockmsg);
switch (sockmsg.msg) {
case "msg_encaisser":
return RdDUtility._handleMsgEncaisser(sockmsg.data);
case "msg_defense":
return RdDUtility._handleMsgDefense(sockmsg.data);
case "msg_gm_chat_message":
return ChatUtility.handleGMChatMessage(sockmsg.data);
case "msg_sync_time":
@ -647,25 +645,6 @@ export class RdDUtility {
}
}
/* -------------------------------------------- */
static _handleMsgDefense(data) {
let defenderToken = canvas.tokens.get(data.defenderTokenId);
if (defenderToken) {
if (!game.user.isGM && game.user.character == undefined) { // vérification / sanity check
ui.notifications.error("Le joueur " + game.user.name + " n'est connecté à aucun personnage. Impossible de continuer.");
return;
}
if ((game.user.isGM && !defenderToken.actor.hasPlayerOwner) || (defenderToken.actor.hasPlayerOwner && (game.user.character.id == defenderToken.actor.data._id))) {
//console.log("User is pushing message...", game.user.name);
game.system.rdd.rollDataHandler.attaques[data.attackerId] = duplicate(data.rollData);
data.whisper = [game.user];
data.blind = true;
data.rollMode = "blindroll";
ChatMessage.create(data);
}
}
}
/* -------------------------------------------- */
static rollInitiativeCompetence(combatantId, arme) {
const combatant = game.combat.getCombatant(combatantId);
@ -760,12 +739,9 @@ export class RdDUtility {
/* -------------------------------------------- */
static _handleMsgEncaisser(data) {
if (game.user.isGM) { // Seul le GM effectue l'encaissement sur la fiche
let attackerRoll = game.system.rdd.rollDataHandler.attaques[data.attackerId]; // Retrieve the rolldata from the store
game.system.rdd.rollDataHandler.attaques[data.attackerId] = undefined;
game.system.rdd.rollDataHandler.defenses[attackerRoll.passeArme] = undefined;
let defender = canvas.tokens.get(data.defenderTokenId).actor;
defender.encaisserDommages(attackerRoll);
let attacker = data.attackerId ? game.actors.get(data.attackerId) : null;
defender.encaisserDommages(attackerRoll, attacker);
}
}

16
styles/simple.css
View File

@ -241,8 +241,18 @@ table {border: 1px solid #7a7971;}
}
.button-img {
vertical-align: baseline;
width: 8%;
height: 8%;
max-height: 48px;
border-width: 0;
}
.button-effect-img {
vertical-align: baseline;
width: 16px;
max-height: 16px;
height: 16;
border-width: 0;
}
@ -253,12 +263,6 @@ table {border: 1px solid #7a7971;}
vertical-align: bottom;
}
.img-sonne {
vertical-align: baseline;
max-height: 16px;
border: 0;
}
.foundryvtt-reve-de-dragon .sheet-header .header-fields {
-webkit-box-flex: 1;
-ms-flex: 1;

2
templates/actor-sheet.html
View File

@ -41,7 +41,7 @@
<label class="ctn-sonne">
Sonné :
<input class="resource-content" type="checkbox" name="data.sante.sonne.value" value="{{data.sante.sonne.value}}" {{#if data.sante.sonne.value}}checked{{/if}} />
<img class="img-sonne" {{#if data.sante.sonne.value}}style="opacity: 1;"{{else}}style="opacity: 0;"{{/if}} src="icons/svg/stoned.svg" height="16" width="16"/>
<img class="button-effect-img" {{#if data.sante.sonne.value}}style="opacity: 1;"{{else}}style="opacity: 0;"{{/if}} src="icons/svg/stoned.svg" height="16" width="16"/>
</label>
</li>
<li>

2
templates/chat-actor-turn-summary.html
View File

@ -1,5 +1,5 @@
<h4>C'est au tour de {{alias}} !</h4>
<div>{{blessuresStatus}}</div>
<div data-combatid="{{combatId}}" data-combatmessage="actor-turn-summary">{{blessuresStatus}}</div>
<div>Son état général est de : {{etatGeneral}} {{#if isSonne}} et est <strong>sonné</strong>{{/if}}</div>
{{#if isGrave}}
<div>{{alias}} souffre de Blessure(s) Grave(s) : n'oubliez pas de faire un Je de Vie toutes les SC ({{SConst}}) minutes.</div>