Quick code review

[kakaroto]

Been reviewing the code to see what it does and have some comments.. unfortunately, since this isn't from a pull request, or a single commit with all the code, I can't do random review comments on a file, and I don't want to put comments spread over all the various commits. So I'm creating an issue for it here.

Note: this isn't a critique of your code, and you don't have to listen to any of my suggestions as they might not match your own coding style, but maybe something helps you here if you find it more practical and hadn't thought of it, or you see it as a potential fix for a bug that hasn't appeared yet. Some of the comments might also be irrelevant if you switch to using a compendium roll table, but I'll still make the comment in case it helps you notice something else.

Starting with criticalLoot.js :

• Order your functions in a more logical order. Your constructor calls init() then findTable(), but you have findTable() defined before init(). I'd move the init function right after the constructor so someone reading the code doesn't need to jump all over the place. Having generateTable right after findTable() (where it's used) is good though.

• Line 13 https://github.com/JacobMcAuley/critical-fumble/blob/07e46e91d03dc73635cdb6771479b4ff560ca388/src/criticalLoot.js#L13

  • Use an arrow function here, especially since you've had to use a .bind(this) at the end. The arrow key function ensures your function runs in the same context/score as the parent function.

• Line 15 https://github.com/JacobMcAuley/critical-fumble/blob/07e46e91d03dc73635cdb6771479b4ff560ca388/src/criticalLoot.js#L15

  • Easier to use an arrow function here
  • find doesn't return a promise so you don't need to await
  • I'd use game.tables instead of RollTables.collection as I think that's what's mostly used in the rest of foundry.js, though this would be a matter of preference
  • Use strict comparison === instead of == since you're comparing two strings here.
  • Use :

    let result = game.tables.entities.find((table) => table.data.name === `Critical-Fumble ${tempTable}`)

• Line 16, use strict comparison. Or easier in this case, just if (!result) would be enough too

• Line 17, you use the `Critical-Fumble ${tempTable}` again here for the table name, probably better to use a variable for it so you don't have a typo and you're sure you use the same name for the find as well as for the _generateTable.

• Smaller details such as

  • variable names.. tempTable not being a table but just being the upper case table name.. result not being a result but being the actual table, findTable() not finding a table but actually populating the tables variable (findTable implies that it tries to find a single table somewhere) and generating missing tables, so ensureTables would be a better name as it ensures all the tables are created.
  • I'd also call that function at the end of the init since it's part of the initialization instead of as a separate call in the constructor (that's just a matter of preference)
  • Maybe instead of doing a Object.keys().forEach, you could do for (let [tableId, tableData] of Object.entries(CRITICAL_FUMBLE_LOOT)) for example
  • You can/should use the table.name getter instead of table.data.name
  • Add spaces around keywords, it makes it easier to read if (x) { than if(x){

• Overall, I'd rewrite findTable this way :

  _ensureTables() {
     for (let [cr, tableData] of Object.entries(CRITICAL_FUMBLE_LOOT)) {
          let tableName = `Critical-Fumble ${cr.toUpperCase()}`;
          let table = game.tables.entities.find(t => t.name === tableName)
          if (!table)
              table = await this._generateTable(tableName, tableData);
         this.tables.push(table);
      }
  }

Note that I always do the this.tables.push(table) in here, and that assumes that the _generateTable only generates the table and doesn't add it to this.tables as well which simplifies code for both functions.

• generateTable function looks good. Just small things, like

  • the objects passed to create and createTableResult would benefit from being one field per line to make it easier to read.
  • I also noticed folder: null, it might be a good idea to have all of your tables in a Critical-Fumble folder for ease of organizing.
  • flagsData didn't need to be defined as a separate variable.. other than make it easier to read and make it a shorter line, but if you put one field per line, it would have made it easier.
  • Not calling this.tables.push(table) since we do it in _ensureTables above.

• init() function, you don't need to try/catch in the hook. The core code already try catches all hook callbacks and prints the error/stack if an exception is thrown.

  • Easier to use a bind here on your validateData
  • In your callback you used actorData as argument, when it's an updateToken hook, so really should have been a tokenData
  • Note that a token could be set to not represent any actor, so token.actor.id could crash because token.actor is null

    init() {
    Hooks.on("updateToken", this.validateData.bind(this));
    }

• In validateData

  • why have an actor in the token, and you call token.actor.id in the init only to then do an Actor.collection.get(actorId) ? I'd suggest you use token.actor directly.
  • With the bind used above, the method now takes token, id, data as argument
  • I don't understand why you named the data quickData
  • Note that you need to check for token.actor not being null here, so, if (!token.actor || token.actor.isPC) return;
  • The check for table != undefined can again be just if (table) but if you prefer to explicitely do it, then use strict comparison !==
  • The function name would probably be better as _onTokenUpdate or something like that, because validateData is not very useful as a name and it does more than just "validate"

• In isValidTarget:

  • The forEach within a forEach is hard to read/understand, it would probably be better to also use more array-like methods, like map and reduce for example
  • The second loop is really just a find. To turn it into a boolean, use !!result to return true if the result is not undefined.

isValidTarget(actor) {
   let targets = game.users.entities.map(u => u.targets)
                        .reduce((acc, t) => { return acc.concat(...t); }, [])
   return !!targets.find(t => t.actor && t.actor.id === actor.id)
}

• getTableByCR, looks good generally but

  • I would move it below isZeroHealth because it's used after it in the order of operations of validateData.
  • The throw at the end is also something I'm a bit conflicted about.. it makes sense because it should never happen but on the other hand, you could just return null because you can't find a table for that specific CR (whatever its value is).
  • The find callbacks argument is set to tableName when it's actually a table. So tableName.data.name makes no sense. It should really be table.data.name
  • Again, use 'table.namegetter instead of accessing data directly, sothis.tables.find(table => table.name === ...);`

• isZeroHealth :

  • I'd rename it isActorDead maybe ?
  • ~~You use actor.actorData which would never work? I'm not sure at all how this is actually working (haven't tested the module yet so maybe it's not actually). It should be actor.data, or maybe you were looking at token.data.actorData? ~~
  • You used actor as argument name when it should really be updateTokenData which can be very confusing!
  • In this case, the name isActorDead also doesn't work, and it should be named maybe something like isTokenKilled
  • Also, the updateData.actorData.data.attributes.hp.value will probably crash most of the time because token updates will often happen (when you move a token for example) without those fields being set, and you'll get a can't access data of undefined error. You should use : getProperty instead

    isTokenKilled(updateData) {
    let hp = getProperty(updateData, "actorData.data.attributes.hp.value")
    return hp !== undefined && hp <= 0;
    }

• in rollTable :

  • you do result.img before you check if result !== null
  • You use result.flags without checking if result is valid.. you should really just do at the begining if (!result) return;
  • You take critical_fumble_actions flag without checking for its existance. The handleRolls method expects an array, so you should really do : let parsedRolls = result.flags['critical_fumble_actions'] || []
  • Didn't notice this when I reviewed the generateTables method but the flags are wrong. The format for flags is scope: key: value, where the scope is the module id. So it should be : result.flags["critical-fumble"]["actions"] which in this case means that you need an extra step to ensure that "critical-fumble" key is defined, so probably better to use get property :

    let parsedrolls = getProperty(result.flags, "critical-fumble.actions") || []

• handleRolls looks good too, I would just :

  • the call to this._roll returns the total, so use let total instead of let roll since it would imply that return value is a Roll class.
  • change the format of the coins array to be coins.push({amount: total, currency: rolls[i].description}) instead of coinAmount and coinType (the array is already for coins, so no need to prefix coin into all the fields too

• _roll is for some reason an arrow function here, probably a mistake/old refactored code. Make that into a regular method. Otherwise, looks good.

• _coinDistributePrompt is good. Personally preference, I wouldn't do let d = new Dialog(..); \n d.render(true) I would just do : new Dialog(...).render(true)

• _coinToString. I would just put a space between the amount and the currency. Personal preference here too.

• _coinDistribute assumes there's only one GM and that all users are for a player (no observer, no assistant GM, etc..).

  • You use var instead of let for the length variable
  • Using length which is length - 1 is confusing, better rename it as totalPlayers
  • You do check that the users have a character they represent and are not GM, but that means that there would be coins lost if the total for that is more than 1. Probably better to calculcate the total players using a reduce : let totalPlayers = game.users.entities.reduce((acc, u) => { if (!u.isGM && u.character) acc += 1; return acc;}, 0)
  • I would probably do a Math.floor instead of Math.ceil and keep track of how many coins were shared and print how much is left over. (i.e: 5 coins and 4 players, 1 coin is left over instead of disappearing in the abyss and instead of giving 2 coins per player with the Math.ceil)
  • You use parseInt() which will already return an integer, so you don't need Math.ceil also, it's probably a lot less efficient than using Math.floor
  • Lone return at the end is useless
  • You mix a loop for the coins with the forEach for the users, which can be confusing. Use loops for both to make it easier to read.

• Out of class. I would just do new CriticalLoot() and have the Hooks.on("ready") done in its init method which would call the _ensureTables. You also don't need to store the result of the new I assume.

That's it for this file. I'll do a really quick pass over the criticalFumble.js now

• A lot of similar comments here with regards to method/variable naming, the findTable and init

• Instead of _validString should be isAttackRoll

• the validateData should first check that the message.type === CHAT_MESSAGE_TYPES.ROLL, and I think you can use message.roll in that case without having to JSON.parse

• The roll has an options.damageType on its parts? Didn't know that! Interesting :)

• in rollTable, Don't do new Audio, instead use : AudioHelper.play({src: sound});

• Ah you overload the d20 roll.. that's why the part has damage type.. that really shouldn't go there in my opinion because it's contaminating the json.

• I won't reviewing the overloaded roll for now because I don't want to diff it, but I notice you do data.item.damage... but if there's a d20 roll that happens that isn't on an item, that will result in a crash of can't access damage of undefined and d20 rolling stops working.

• Overall, I don't see any kind of checks for isGM which means that when a token update happens every player will try to roll from the fumble table. Also, every player when they first login, if they can't find the table, they'll try to create it themselves. Also, every player will try to create and distribute loot... Those things should only happen if the current player is the GM.

[JacobMcAuley]

Hey Kakaroto, Thanks for the review! I'm not the most experienced programmer yet, with less practical experience than I want. I appreciate you taking the time out of your day to provide a code review! Any future reviews will be accepted gladly!

Almost all the advice you offered I took. I hope the next time I work on something I can follow better design practice. Thanks!

[kakaroto]

You're welcome! I'll do another review later, but quick notes : your module.json includes src/hooks.js which doesn't exist and and your config.js still has all the roll tables data.